From 86d744abed1df277d63ef53a5863cebec4990f75 Mon Sep 17 00:00:00 2001 From: daxfohl Date: Fri, 22 Apr 2022 16:41:02 -0700 Subject: [PATCH 1/8] Bump types so that SimulatesIntermediateState isn't bound to ActOnArgs --- cirq-core/cirq/sim/act_on_args.py | 3 +++ cirq-core/cirq/sim/act_on_args_container.py | 2 +- cirq-core/cirq/sim/simulator.py | 16 +++++++--------- cirq-core/cirq/sim/simulator_base.py | 8 +++++--- cirq-core/cirq/sim/simulator_test.py | 2 +- 5 files changed, 17 insertions(+), 14 deletions(-) diff --git a/cirq-core/cirq/sim/act_on_args.py b/cirq-core/cirq/sim/act_on_args.py index 2166453b2ff..6fc0b679833 100644 --- a/cirq-core/cirq/sim/act_on_args.py +++ b/cirq-core/cirq/sim/act_on_args.py @@ -386,3 +386,6 @@ def strat_act_on_from_apply_decompose( operation = operation.with_qubits(*[qubit_map[q] for q in operation.qubits]) protocols.act_on(operation, args) return True + + +TActOnArgs = TypeVar('TActOnArgs', bound=ActOnArgs) diff --git a/cirq-core/cirq/sim/act_on_args_container.py b/cirq-core/cirq/sim/act_on_args_container.py index 420293ed8bf..0b4e0856b64 100644 --- a/cirq-core/cirq/sim/act_on_args_container.py +++ b/cirq-core/cirq/sim/act_on_args_container.py @@ -18,8 +18,8 @@ import numpy as np from cirq import ops, protocols, value +from cirq.sim.act_on_args import TActOnArgs from cirq.sim.operation_target import OperationTarget -from cirq.sim.simulator import TActOnArgs if TYPE_CHECKING: import cirq diff --git a/cirq-core/cirq/sim/simulator.py b/cirq-core/cirq/sim/simulator.py index 371b3569003..f1bd5d8b3be 100644 --- a/cirq-core/cirq/sim/simulator.py +++ b/cirq-core/cirq/sim/simulator.py @@ -50,7 +50,6 @@ import numpy as np from cirq import _compat, circuits, ops, protocols, study, value, work -from cirq.sim.act_on_args import ActOnArgs from cirq.sim.operation_target import OperationTarget if TYPE_CHECKING: @@ -60,7 +59,6 @@ TStepResult = TypeVar('TStepResult', bound='StepResult') TSimulationTrialResult = TypeVar('TSimulationTrialResult', bound='SimulationTrialResult') TSimulatorState = TypeVar('TSimulatorState', bound=Any) -TActOnArgs = TypeVar('TActOnArgs', bound=ActOnArgs) class SimulatesSamples(work.Sampler, metaclass=abc.ABCMeta): @@ -551,7 +549,7 @@ def simulate_sweep_iter( class SimulatesIntermediateState( - Generic[TStepResult, TSimulationTrialResult, TActOnArgs], + Generic[TStepResult, TSimulationTrialResult, TSimulatorState], SimulatesFinalState[TSimulationTrialResult], metaclass=abc.ABCMeta, ): @@ -692,8 +690,8 @@ def _base_iterator( @abc.abstractmethod def _create_act_on_args( self, initial_state: Any, qubits: Sequence['cirq.Qid'] - ) -> 'cirq.OperationTarget[TActOnArgs]': - """Creates the OperationTarget state for a simulator. + ) -> TSimulatorState: + """Creates the TSimulatorState state for a simulator. Custom simulators should implement this method. @@ -706,14 +704,14 @@ def _create_act_on_args( ordering of the computational basis states. Returns: - The `OperationTarget` for this simulator. + The `TSimulatorState` for this simulator. """ @abc.abstractmethod def _core_iterator( self, circuit: 'cirq.AbstractCircuit', - sim_state: 'cirq.OperationTarget[TActOnArgs]', + sim_state: TSimulatorState, all_measurements_are_terminal: bool = False, ) -> Iterator[TStepResult]: """Iterator over StepResult from Moments of a Circuit. @@ -722,7 +720,7 @@ def _core_iterator( Args: circuit: The circuit to simulate. - sim_state: The initial args for the simulation. The form of + sim_state: The initial state for the simulation. The form of this state depends on the simulation implementation. See documentation of the implementing class for details. all_measurements_are_terminal: Whether all measurements in @@ -737,7 +735,7 @@ def _create_simulator_trial_result( self, params: 'cirq.ParamResolver', measurements: Dict[str, np.ndarray], - final_simulator_state: 'cirq.OperationTarget[TActOnArgs]', + final_simulator_state: TSimulatorState, ) -> TSimulationTrialResult: """This method can be implemented to create a trial result. diff --git a/cirq-core/cirq/sim/simulator_base.py b/cirq-core/cirq/sim/simulator_base.py index c2d07b0fe46..de0eefc0019 100644 --- a/cirq-core/cirq/sim/simulator_base.py +++ b/cirq-core/cirq/sim/simulator_base.py @@ -35,11 +35,11 @@ from cirq import ops, protocols, study, value, devices from cirq.sim import ActOnArgsContainer -from cirq.sim.operation_target import OperationTarget from cirq.sim import simulator +from cirq.sim.act_on_args import TActOnArgs +from cirq.sim.operation_target import OperationTarget from cirq.sim.simulator import ( TSimulationTrialResult, - TActOnArgs, SimulatesIntermediateState, SimulatesSamples, StepResult, @@ -57,7 +57,9 @@ class SimulatorBase( Generic[TStepResultBase, TSimulationTrialResult, TActOnArgs], - SimulatesIntermediateState[TStepResultBase, TSimulationTrialResult, TActOnArgs], + SimulatesIntermediateState[ + TStepResultBase, TSimulationTrialResult, OperationTarget[TActOnArgs] + ], SimulatesSamples, metaclass=abc.ABCMeta, ): diff --git a/cirq-core/cirq/sim/simulator_test.py b/cirq-core/cirq/sim/simulator_test.py index 26afb2a8e28..52b886196b8 100644 --- a/cirq-core/cirq/sim/simulator_test.py +++ b/cirq-core/cirq/sim/simulator_test.py @@ -22,6 +22,7 @@ import cirq from cirq import study +from cirq.sim.act_on_args import TActOnArgs from cirq.sim.simulator import ( TStepResult, SimulatesAmplitudes, @@ -30,7 +31,6 @@ SimulatesIntermediateState, SimulatesSamples, SimulationTrialResult, - TActOnArgs, ) From a7ec34b19289793c6b6491ca30f1f9617fc461de Mon Sep 17 00:00:00 2001 From: daxfohl Date: Fri, 22 Apr 2022 22:04:08 -0700 Subject: [PATCH 2/8] Fix StepResult initializer types to match TrialResult --- cirq-core/cirq/sim/simulator.py | 6 +++--- cirq-core/cirq/sim/simulator_base.py | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/cirq-core/cirq/sim/simulator.py b/cirq-core/cirq/sim/simulator.py index f1bd5d8b3be..c7f1c1b5e20 100644 --- a/cirq-core/cirq/sim/simulator.py +++ b/cirq-core/cirq/sim/simulator.py @@ -758,11 +758,10 @@ class StepResult(Generic[TSimulatorState], metaclass=abc.ABCMeta): results, ordered by the qubits that the measurement operates on. """ - def __init__(self, sim_state: 'cirq.OperationTarget') -> None: + def __init__(self, sim_state: TSimulatorState) -> None: + self._sim_state = sim_state self.measurements = sim_state.log_of_measurement_results - self._classical_data = sim_state.classical_data - @abc.abstractmethod def _simulator_state(self) -> TSimulatorState: """Returns the simulator state of the simulator after this step. @@ -773,6 +772,7 @@ def _simulator_state(self) -> TSimulatorState: simulation,see documentation for the implementing class for the form of details. """ + return self._sim_state @abc.abstractmethod def sample( diff --git a/cirq-core/cirq/sim/simulator_base.py b/cirq-core/cirq/sim/simulator_base.py index de0eefc0019..c11ffd640d9 100644 --- a/cirq-core/cirq/sim/simulator_base.py +++ b/cirq-core/cirq/sim/simulator_base.py @@ -354,13 +354,13 @@ def __init__(self, sim_state: OperationTarget[TActOnArgs]): Args: sim_state: The `OperationTarget` for this step. """ - self._sim_state = sim_state - self._merged_sim_state_cache: Optional[TActOnArgs] = None super().__init__(sim_state) + self._merged_sim_state_cache: Optional[TActOnArgs] = None qubits = sim_state.qubits self._qubits = qubits self._qubit_mapping = {q: i for i, q in enumerate(qubits)} self._qubit_shape = tuple(q.dimension for q in qubits) + self._classical_data = sim_state.classical_data def _qid_shape_(self): return self._qubit_shape From 595efb07ebfdf0b925ea9b247bf97db3247d11e6 Mon Sep 17 00:00:00 2001 From: daxfohl Date: Fri, 22 Apr 2022 22:06:05 -0700 Subject: [PATCH 3/8] docstring --- cirq-core/cirq/sim/simulator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cirq-core/cirq/sim/simulator.py b/cirq-core/cirq/sim/simulator.py index c7f1c1b5e20..2d9a160474d 100644 --- a/cirq-core/cirq/sim/simulator.py +++ b/cirq-core/cirq/sim/simulator.py @@ -691,7 +691,7 @@ def _base_iterator( def _create_act_on_args( self, initial_state: Any, qubits: Sequence['cirq.Qid'] ) -> TSimulatorState: - """Creates the TSimulatorState state for a simulator. + """Creates the state for a simulator. Custom simulators should implement this method. From 639a491b38437c1ebae939f6cb8c9bdce4b13198 Mon Sep 17 00:00:00 2001 From: daxfohl Date: Fri, 22 Apr 2022 22:22:06 -0700 Subject: [PATCH 4/8] coverage --- cirq-core/cirq/sim/simulator_base.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/cirq-core/cirq/sim/simulator_base.py b/cirq-core/cirq/sim/simulator_base.py index c11ffd640d9..e147a708c1a 100644 --- a/cirq-core/cirq/sim/simulator_base.py +++ b/cirq-core/cirq/sim/simulator_base.py @@ -379,9 +379,6 @@ def sample( ) -> np.ndarray: return self._sim_state.sample(qubits, repetitions, seed) - def _simulator_state(self) -> 'cirq.OperationTarget[TActOnArgs]': - return self._sim_state - class SimulationTrialResultBase( SimulationTrialResult[OperationTarget[TActOnArgs]], Generic[TActOnArgs], abc.ABC From c7a7d16f0a73f75df83f8eeff55ff5c49671f03e Mon Sep 17 00:00:00 2001 From: daxfohl Date: Sun, 24 Apr 2022 22:11:00 -0700 Subject: [PATCH 5/8] rename ActOnArgs --- cirq-core/cirq/__init__.py | 16 +++--- cirq-core/cirq/circuits/circuit_operation.py | 2 +- cirq-core/cirq/contrib/quimb/mps_simulator.py | 14 ++--- .../ops/classically_controlled_operation.py | 2 +- cirq-core/cirq/ops/clifford_gate.py | 16 +++--- cirq-core/cirq/ops/clifford_gate_test.py | 14 ++--- cirq-core/cirq/ops/common_channels.py | 4 +- cirq-core/cirq/ops/common_channels_test.py | 8 +-- cirq-core/cirq/ops/common_gates_test.py | 30 +++++----- cirq-core/cirq/ops/gate_operation.py | 2 +- cirq-core/cirq/ops/global_phase_op_test.py | 8 +-- cirq-core/cirq/ops/identity.py | 2 +- cirq-core/cirq/ops/identity_test.py | 2 +- cirq-core/cirq/ops/measurement_gate.py | 6 +- cirq-core/cirq/ops/measurement_gate_test.py | 24 ++++---- .../cirq/ops/random_gate_channel_test.py | 6 +- cirq-core/cirq/ops/raw_types.py | 2 +- cirq-core/cirq/ops/raw_types_test.py | 4 +- cirq-core/cirq/protocols/act_on_protocol.py | 12 ++-- .../cirq/protocols/act_on_protocol_test.py | 14 ++--- .../cirq/protocols/json_test_data/spec.py | 16 +++--- cirq-core/cirq/sim/__init__.py | 16 +++--- cirq-core/cirq/sim/act_on_args.py | 28 +++++----- cirq-core/cirq/sim/act_on_args_container.py | 26 ++++----- .../cirq/sim/act_on_args_container_test.py | 16 +++--- cirq-core/cirq/sim/act_on_args_test.py | 8 +-- .../cirq/sim/act_on_density_matrix_args.py | 10 ++-- .../sim/act_on_density_matrix_args_test.py | 26 ++++----- .../cirq/sim/act_on_state_vector_args.py | 18 +++--- .../cirq/sim/act_on_state_vector_args_test.py | 24 ++++---- cirq-core/cirq/sim/clifford/__init__.py | 6 +- .../clifford/act_on_clifford_tableau_args.py | 6 +- .../act_on_clifford_tableau_args_test.py | 12 ++-- .../sim/clifford/act_on_stabilizer_args.py | 8 +-- .../clifford/act_on_stabilizer_args_test.py | 12 ++-- .../act_on_stabilizer_ch_form_args.py | 8 +-- .../act_on_stabilizer_ch_form_args_test.py | 22 ++++---- .../cirq/sim/clifford/clifford_simulator.py | 32 +++++------ .../sim/clifford/clifford_simulator_test.py | 8 +-- .../cirq/sim/clifford/stabilizer_sampler.py | 4 +- .../clifford/stabilizer_state_ch_form_test.py | 2 +- .../cirq/sim/density_matrix_simulator.py | 28 +++++----- .../cirq/sim/density_matrix_simulator_test.py | 14 ++--- cirq-core/cirq/sim/operation_target.py | 10 ++-- cirq-core/cirq/sim/simulator.py | 8 +-- cirq-core/cirq/sim/simulator_base.py | 56 +++++++++---------- cirq-core/cirq/sim/simulator_base_test.py | 42 +++++++------- cirq-core/cirq/sim/simulator_test.py | 8 +-- cirq-core/cirq/sim/sparse_simulator.py | 16 +++--- cirq-core/cirq/sim/sparse_simulator_test.py | 2 +- cirq-core/cirq/sim/state_vector_simulator.py | 10 ++-- .../cirq/sim/state_vector_simulator_test.py | 20 +++---- cirq-core/cirq/testing/consistent_act_on.py | 10 ++-- .../cirq/testing/consistent_act_on_test.py | 8 +-- .../clifford_decomposition.py | 14 ++--- .../clifford_decomposition_test.py | 14 ++--- .../calibration/engine_simulator.py | 6 +- examples/direct_fidelity_estimation.py | 2 +- 58 files changed, 382 insertions(+), 382 deletions(-) diff --git a/cirq-core/cirq/__init__.py b/cirq-core/cirq/__init__.py index a7a0a78682c..ba1b10c30ab 100644 --- a/cirq-core/cirq/__init__.py +++ b/cirq-core/cirq/__init__.py @@ -445,13 +445,13 @@ ) from cirq.sim import ( - ActOnArgs, - ActOnArgsContainer, - ActOnCliffordTableauArgs, - ActOnDensityMatrixArgs, - ActOnStabilizerCHFormArgs, - ActOnStabilizerArgs, - ActOnStateVectorArgs, + DenseSimulationState, + SimulationProductState, + CliffordTableauSimulationState, + DensityMatrixSimulationState, + CHFormSimulationState, + StabilizerSimulationState, + StateVectorSimulationState, StabilizerStateChForm, CIRCUIT_LIKE, CliffordSimulator, @@ -466,7 +466,7 @@ measure_state_vector, final_density_matrix, final_state_vector, - OperationTarget, + SimulationState, sample, sample_density_matrix, sample_state_vector, diff --git a/cirq-core/cirq/circuits/circuit_operation.py b/cirq-core/cirq/circuits/circuit_operation.py index 48e46976762..eba29a8843a 100644 --- a/cirq-core/cirq/circuits/circuit_operation.py +++ b/cirq-core/cirq/circuits/circuit_operation.py @@ -350,7 +350,7 @@ def mapped_op(self, deep: bool = False) -> 'cirq.CircuitOperation': def _decompose_(self) -> Iterator['cirq.Operation']: return self.mapped_circuit(deep=False).all_operations() - def _act_on_(self, args: 'cirq.OperationTarget') -> bool: + def _act_on_(self, args: 'cirq.SimulationState') -> bool: if self.repeat_until: circuit = self._mapped_single_loop() while True: diff --git a/cirq-core/cirq/contrib/quimb/mps_simulator.py b/cirq-core/cirq/contrib/quimb/mps_simulator.py index b8ea3f1f751..526e52794dc 100644 --- a/cirq-core/cirq/contrib/quimb/mps_simulator.py +++ b/cirq-core/cirq/contrib/quimb/mps_simulator.py @@ -27,7 +27,7 @@ from cirq import devices, protocols, qis, value from cirq._compat import deprecated_parameter from cirq.sim import simulator, simulator_base -from cirq.sim.act_on_args import ActOnArgs +from cirq.sim.act_on_args import DenseSimulationState if TYPE_CHECKING: import cirq @@ -115,14 +115,14 @@ def _create_partial_act_on_args( classical_data=classical_data, ) - def _create_step_result(self, sim_state: 'cirq.OperationTarget[MPSState]'): + def _create_step_result(self, sim_state: 'cirq.SimulationState[MPSState]'): return MPSSimulatorStepResult(sim_state) def _create_simulator_trial_result( self, params: 'cirq.ParamResolver', measurements: Dict[str, np.ndarray], - final_simulator_state: 'cirq.OperationTarget[MPSState]', + final_simulator_state: 'cirq.SimulationState[MPSState]', ) -> 'MPSTrialResult': """Creates a single trial results with the measurements. @@ -148,7 +148,7 @@ def __init__( self, params: 'cirq.ParamResolver', measurements: Dict[str, np.ndarray], - final_simulator_state: 'cirq.OperationTarget[MPSState]', + final_simulator_state: 'cirq.SimulationState[MPSState]', ) -> None: super().__init__( params=params, measurements=measurements, final_simulator_state=final_simulator_state @@ -175,10 +175,10 @@ def _repr_pretty_(self, p: Any, cycle: bool): class MPSSimulatorStepResult(simulator_base.StepResultBase['MPSState']): """A `StepResult` that can perform measurements.""" - def __init__(self, sim_state: 'cirq.OperationTarget[MPSState]'): + def __init__(self, sim_state: 'cirq.SimulationState[MPSState]'): """Results of a step of the simulator. Attributes: - sim_state: The qubit:ActOnArgs lookup for this step. + sim_state: The qubit:DenseSimulationState lookup for this step. """ super().__init__(sim_state) @@ -560,7 +560,7 @@ def sample( @value.value_equality -class MPSState(ActOnArgs[_MPSHandler]): +class MPSState(DenseSimulationState[_MPSHandler]): """A state of the MPS simulation.""" @deprecated_parameter( diff --git a/cirq-core/cirq/ops/classically_controlled_operation.py b/cirq-core/cirq/ops/classically_controlled_operation.py index 28d9c22a003..1aa7f9eae11 100644 --- a/cirq-core/cirq/ops/classically_controlled_operation.py +++ b/cirq-core/cirq/ops/classically_controlled_operation.py @@ -171,7 +171,7 @@ def _circuit_diagram_info_( def _json_dict_(self) -> Dict[str, Any]: return {'conditions': self._conditions, 'sub_operation': self._sub_operation} - def _act_on_(self, args: 'cirq.OperationTarget') -> bool: + def _act_on_(self, args: 'cirq.SimulationState') -> bool: if all(c.resolve(args.classical_data) for c in self._conditions): protocols.act_on(self._sub_operation, args) return True diff --git a/cirq-core/cirq/ops/clifford_gate.py b/cirq-core/cirq/ops/clifford_gate.py index 06cfcb9afc2..46f67e69d4f 100644 --- a/cirq-core/cirq/ops/clifford_gate.py +++ b/cirq-core/cirq/ops/clifford_gate.py @@ -277,7 +277,7 @@ def _generate_clifford_from_known_gate( ) -> Union['SingleQubitCliffordGate', 'CliffordGate']: qubits = devices.LineQubit.range(num_qubits) t = qis.CliffordTableau(num_qubits=num_qubits) - args = sim.ActOnCliffordTableauArgs(tableau=t, qubits=qubits, prng=np.random.RandomState()) + args = sim.CliffordTableauSimulationState(tableau=t, qubits=qubits, prng=np.random.RandomState()) protocols.act_on(gate, args, qubits, allow_decompose=False) if num_qubits == 1: @@ -339,7 +339,7 @@ def from_op_list( ) base_tableau = qis.CliffordTableau(len(qubit_order)) - args = sim.clifford.ActOnCliffordTableauArgs( + args = sim.clifford.CliffordTableauSimulationState( tableau=base_tableau, qubits=qubit_order, prng=np.random.RandomState(0) # unused ) for op in operations: @@ -444,7 +444,7 @@ def _decompose_(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE': ) def _act_on_( - self, args: 'cirq.OperationTarget', qubits: Sequence['cirq.Qid'] + self, args: 'cirq.SimulationState', qubits: Sequence['cirq.Qid'] ) -> Union[NotImplementedType, bool]: # Note the computation complexity difference between _decompose_ and _act_on_. @@ -453,15 +453,15 @@ def _act_on_( # 1. Direct act_on is O(n^3) -- two matrices multiplication # 2. Decomposition is O(m^3)+O(k*n^2) -- Decomposition complexity + k * One/two-qubits Ops # So when m << n, the decomposition is more efficient. - if isinstance(args, sim.clifford.ActOnCliffordTableauArgs): + if isinstance(args, sim.clifford.CliffordTableauSimulationState): axes = args.get_axes(qubits) # This padding is important and cannot be omitted. padded_tableau = _pad_tableau(self._clifford_tableau, len(args.qubits), axes) args._state = args.tableau.then(padded_tableau) return True - if isinstance(args, sim.clifford.ActOnStabilizerCHFormArgs): - # Do we know how to apply CliffordTableau on ActOnStabilizerCHFormArgs? + if isinstance(args, sim.clifford.CHFormSimulationState): + # Do we know how to apply CliffordTableau on CHFormSimulationState? # It should be unlike because CliffordTableau ignores the global phase but CHForm # is aimed to fix that. return NotImplemented @@ -706,10 +706,10 @@ def __pow__(self, exponent) -> 'SingleQubitCliffordGate': def _act_on_( self, - args: 'cirq.OperationTarget', # pylint: disable=unused-argument + args: 'cirq.SimulationState', # pylint: disable=unused-argument qubits: Sequence['cirq.Qid'], # pylint: disable=unused-argument ): - # TODO(#5256) Add the implementation of _act_on_ with ActOnCliffordTableauArgs. + # TODO(#5256) Add the implementation of _act_on_ with CliffordTableauSimulationState. return NotImplemented # Single Clifford Gate decomposition is more efficient than the general Tableau decomposition. diff --git a/cirq-core/cirq/ops/clifford_gate_test.py b/cirq-core/cirq/ops/clifford_gate_test.py index faf3e7c5a27..51b5dbd36b5 100644 --- a/cirq-core/cirq/ops/clifford_gate_test.py +++ b/cirq-core/cirq/ops/clifford_gate_test.py @@ -19,7 +19,7 @@ import pytest import cirq -from cirq.protocols.act_on_protocol_test import DummyActOnArgs +from cirq.protocols.act_on_protocol_test import DummySimulationState from cirq.testing import EqualsTester, assert_allclose_up_to_global_phase _bools = (False, True) @@ -783,10 +783,10 @@ def test_clifford_gate_act_on_small_case(): # Note this is also covered by the `from_op_list` one, etc. qubits = cirq.LineQubit.range(5) - args = cirq.ActOnCliffordTableauArgs( + args = cirq.CliffordTableauSimulationState( tableau=cirq.CliffordTableau(num_qubits=5), qubits=qubits, prng=np.random.RandomState() ) - expected_args = cirq.ActOnCliffordTableauArgs( + expected_args = cirq.CliffordTableauSimulationState( tableau=cirq.CliffordTableau(num_qubits=5), qubits=qubits, prng=np.random.RandomState() ) cirq.act_on(cirq.H, expected_args, qubits=[qubits[0]], allow_decompose=False) @@ -818,8 +818,8 @@ def test_clifford_gate_act_on_large_case(): t1 = cirq.CliffordTableau(num_qubits=n) t2 = cirq.CliffordTableau(num_qubits=n) qubits = cirq.LineQubit.range(n) - args1 = cirq.ActOnCliffordTableauArgs(tableau=t1, qubits=qubits, prng=prng) - args2 = cirq.ActOnCliffordTableauArgs(tableau=t2, qubits=qubits, prng=prng) + args1 = cirq.CliffordTableauSimulationState(tableau=t1, qubits=qubits, prng=prng) + args2 = cirq.CliffordTableauSimulationState(tableau=t2, qubits=qubits, prng=prng) ops = [] for _ in range(num_ops): g = prng.randint(len(gate_candidate)) @@ -838,7 +838,7 @@ def test_clifford_gate_act_on_ch_form(): # Although we don't support CH_form from the _act_on_, it will fall back # to the decomposititon method and apply it through decomposed ops. # Here we run it for the coverage only. - args = cirq.ActOnStabilizerCHFormArgs( + args = cirq.CHFormSimulationState( initial_state=cirq.StabilizerStateChForm(num_qubits=2, initial_state=1), qubits=cirq.LineQubit.range(2), prng=np.random.RandomState(), @@ -849,4 +849,4 @@ def test_clifford_gate_act_on_ch_form(): def test_clifford_gate_act_on_fail(): with pytest.raises(TypeError, match="Failed to act"): - cirq.act_on(cirq.CliffordGate.X, DummyActOnArgs(), qubits=()) + cirq.act_on(cirq.CliffordGate.X, DummySimulationState(), qubits=()) diff --git a/cirq-core/cirq/ops/common_channels.py b/cirq-core/cirq/ops/common_channels.py index dda34bfb96f..95a32cdac30 100644 --- a/cirq-core/cirq/ops/common_channels.py +++ b/cirq-core/cirq/ops/common_channels.py @@ -713,7 +713,7 @@ def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optio def _qid_shape_(self): return (self._dimension,) - def _act_on_(self, args: 'cirq.OperationTarget', qubits: Sequence['cirq.Qid']): + def _act_on_(self, args: 'cirq.SimulationState', qubits: Sequence['cirq.Qid']): if len(qubits) != 1: return NotImplemented @@ -736,7 +736,7 @@ def _unitary_(self): from cirq.sim import act_on_args - if isinstance(args, act_on_args.ActOnArgs) and not args.can_represent_mixed_states: + if isinstance(args, act_on_args.DenseSimulationState) and not args.can_represent_mixed_states: result = args._perform_measurement(qubits)[0] gate = PlusGate(self.dimension, self.dimension - result) protocols.act_on(gate, args, qubits) diff --git a/cirq-core/cirq/ops/common_channels_test.py b/cirq-core/cirq/ops/common_channels_test.py index 0f87a522843..806d37a426b 100644 --- a/cirq-core/cirq/ops/common_channels_test.py +++ b/cirq-core/cirq/ops/common_channels_test.py @@ -18,7 +18,7 @@ import pytest import cirq -from cirq.protocols.act_on_protocol_test import DummyActOnArgs +from cirq.protocols.act_on_protocol_test import DummySimulationState X = np.array([[0, 1], [1, 0]]) Y = np.array([[0, -1j], [1j, 0]]) @@ -489,9 +489,9 @@ def test_reset_channel_text_diagram(): def test_reset_act_on(): with pytest.raises(TypeError, match="Failed to act"): - cirq.act_on(cirq.ResetChannel(), DummyActOnArgs(), qubits=()) + cirq.act_on(cirq.ResetChannel(), DummySimulationState(), qubits=()) - args = cirq.ActOnStateVectorArgs( + args = cirq.StateVectorSimulationState( available_buffer=np.empty(shape=(2, 2, 2, 2, 2), dtype=np.complex64), qubits=cirq.LineQubit.range(5), prng=np.random.RandomState(), @@ -714,7 +714,7 @@ def test_bit_flip_channel_text_diagram(): def test_stabilizer_supports_depolarize(): with pytest.raises(TypeError, match="act_on"): for _ in range(100): - cirq.act_on(cirq.depolarize(3 / 4), DummyActOnArgs(), qubits=()) + cirq.act_on(cirq.depolarize(3 / 4), DummySimulationState(), qubits=()) q = cirq.LineQubit(0) c = cirq.Circuit(cirq.depolarize(3 / 4).on(q), cirq.measure(q, key='m')) diff --git a/cirq-core/cirq/ops/common_gates_test.py b/cirq-core/cirq/ops/common_gates_test.py index d2fcb6f5de9..b44d23611a6 100644 --- a/cirq-core/cirq/ops/common_gates_test.py +++ b/cirq-core/cirq/ops/common_gates_test.py @@ -17,7 +17,7 @@ import sympy import cirq -from cirq.protocols.act_on_protocol_test import DummyActOnArgs +from cirq.protocols.act_on_protocol_test import DummySimulationState H = np.array([[1, 1], [1, -1]]) * np.sqrt(0.5) HH = cirq.kron(H, H) @@ -289,11 +289,11 @@ def test_h_str(): def test_x_act_on_tableau(): with pytest.raises(TypeError, match="Failed to act"): - cirq.act_on(cirq.X, DummyActOnArgs(), qubits=()) + cirq.act_on(cirq.X, DummySimulationState(), qubits=()) original_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=31) flipped_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=23) - args = cirq.ActOnCliffordTableauArgs( + args = cirq.CliffordTableauSimulationState( tableau=original_tableau.copy(), qubits=cirq.LineQubit.range(5), prng=np.random.RandomState(), @@ -338,11 +338,11 @@ def _unitary_(self): def test_y_act_on_tableau(): with pytest.raises(TypeError, match="Failed to act"): - cirq.act_on(cirq.Y, DummyActOnArgs(), qubits=()) + cirq.act_on(cirq.Y, DummySimulationState(), qubits=()) original_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=31) flipped_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=23) - args = cirq.ActOnCliffordTableauArgs( + args = cirq.CliffordTableauSimulationState( tableau=original_tableau.copy(), qubits=cirq.LineQubit.range(5), prng=np.random.RandomState(), @@ -376,13 +376,13 @@ def test_y_act_on_tableau(): def test_z_h_act_on_tableau(): with pytest.raises(TypeError, match="Failed to act"): - cirq.act_on(cirq.Z, DummyActOnArgs(), qubits=()) + cirq.act_on(cirq.Z, DummySimulationState(), qubits=()) with pytest.raises(TypeError, match="Failed to act"): - cirq.act_on(cirq.H, DummyActOnArgs(), qubits=()) + cirq.act_on(cirq.H, DummySimulationState(), qubits=()) original_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=31) flipped_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=23) - args = cirq.ActOnCliffordTableauArgs( + args = cirq.CliffordTableauSimulationState( tableau=original_tableau.copy(), qubits=cirq.LineQubit.range(5), prng=np.random.RandomState(), @@ -429,10 +429,10 @@ def test_z_h_act_on_tableau(): def test_cx_act_on_tableau(): with pytest.raises(TypeError, match="Failed to act"): - cirq.act_on(cirq.CX, DummyActOnArgs(), qubits=()) + cirq.act_on(cirq.CX, DummySimulationState(), qubits=()) original_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=31) - args = cirq.ActOnCliffordTableauArgs( + args = cirq.CliffordTableauSimulationState( tableau=original_tableau.copy(), qubits=cirq.LineQubit.range(5), prng=np.random.RandomState(), @@ -473,10 +473,10 @@ def test_cx_act_on_tableau(): def test_cz_act_on_tableau(): with pytest.raises(TypeError, match="Failed to act"): - cirq.act_on(cirq.CZ, DummyActOnArgs(), qubits=()) + cirq.act_on(cirq.CZ, DummySimulationState(), qubits=()) original_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=31) - args = cirq.ActOnCliffordTableauArgs( + args = cirq.CliffordTableauSimulationState( tableau=original_tableau.copy(), qubits=cirq.LineQubit.range(5), prng=np.random.RandomState(), @@ -516,12 +516,12 @@ def test_cz_act_on_tableau(): def test_cz_act_on_equivalent_to_h_cx_h_tableau(): - args1 = cirq.ActOnCliffordTableauArgs( + args1 = cirq.CliffordTableauSimulationState( tableau=cirq.CliffordTableau(num_qubits=2), qubits=cirq.LineQubit.range(2), prng=np.random.RandomState(), ) - args2 = cirq.ActOnCliffordTableauArgs( + args2 = cirq.CliffordTableauSimulationState( tableau=cirq.CliffordTableau(num_qubits=2), qubits=cirq.LineQubit.range(2), prng=np.random.RandomState(), @@ -583,7 +583,7 @@ def test_act_on_ch_form(input_gate_sequence, outcome): else: assert num_qubits == 2 qubits = cirq.LineQubit.range(2) - args = cirq.ActOnStabilizerCHFormArgs( + args = cirq.CHFormSimulationState( qubits=cirq.LineQubit.range(2), prng=np.random.RandomState(), initial_state=original_state.copy(), diff --git a/cirq-core/cirq/ops/gate_operation.py b/cirq-core/cirq/ops/gate_operation.py index f928a29a419..cccbf0d8959 100644 --- a/cirq-core/cirq/ops/gate_operation.py +++ b/cirq-core/cirq/ops/gate_operation.py @@ -254,7 +254,7 @@ def _measurement_key_objs_(self) -> Optional[AbstractSet['cirq.MeasurementKey']] return getter() return NotImplemented - def _act_on_(self, args: 'cirq.OperationTarget'): + def _act_on_(self, args: 'cirq.SimulationState'): getter = getattr(self.gate, '_act_on_', None) if getter is not None: return getter(args, self.qubits) diff --git a/cirq-core/cirq/ops/global_phase_op_test.py b/cirq-core/cirq/ops/global_phase_op_test.py index a2e8ccf62c5..c95c866217d 100644 --- a/cirq-core/cirq/ops/global_phase_op_test.py +++ b/cirq-core/cirq/ops/global_phase_op_test.py @@ -43,7 +43,7 @@ def test_protocols(): @pytest.mark.parametrize('phase', [1, 1j, -1]) def test_act_on_tableau(phase): original_tableau = cirq.CliffordTableau(0) - args = cirq.ActOnCliffordTableauArgs(original_tableau.copy(), np.random.RandomState()) + args = cirq.CliffordTableauSimulationState(original_tableau.copy(), np.random.RandomState()) cirq.act_on(cirq.global_phase_operation(phase), args, allow_decompose=False) assert args.tableau == original_tableau @@ -51,7 +51,7 @@ def test_act_on_tableau(phase): @pytest.mark.parametrize('phase', [1, 1j, -1]) def test_act_on_ch_form(phase): state = cirq.StabilizerStateChForm(0) - args = cirq.ActOnStabilizerCHFormArgs( + args = cirq.CHFormSimulationState( qubits=[], prng=np.random.RandomState(), initial_state=state ) cirq.act_on(cirq.global_phase_operation(phase), args, allow_decompose=False) @@ -240,7 +240,7 @@ def test_gate_protocols(): @pytest.mark.parametrize('phase', [1, 1j, -1]) def test_gate_act_on_tableau(phase): original_tableau = cirq.CliffordTableau(0) - args = cirq.ActOnCliffordTableauArgs(original_tableau.copy(), np.random.RandomState()) + args = cirq.CliffordTableauSimulationState(original_tableau.copy(), np.random.RandomState()) cirq.act_on(cirq.GlobalPhaseGate(phase), args, qubits=(), allow_decompose=False) assert args.tableau == original_tableau @@ -248,7 +248,7 @@ def test_gate_act_on_tableau(phase): @pytest.mark.parametrize('phase', [1, 1j, -1]) def test_gate_act_on_ch_form(phase): state = cirq.StabilizerStateChForm(0) - args = cirq.ActOnStabilizerCHFormArgs( + args = cirq.CHFormSimulationState( qubits=[], prng=np.random.RandomState(), initial_state=state ) cirq.act_on(cirq.GlobalPhaseGate(phase), args, qubits=(), allow_decompose=False) diff --git a/cirq-core/cirq/ops/identity.py b/cirq-core/cirq/ops/identity.py index 435bdabc008..d4153bfc834 100644 --- a/cirq-core/cirq/ops/identity.py +++ b/cirq-core/cirq/ops/identity.py @@ -61,7 +61,7 @@ def __init__( if len(self._qid_shape) != num_qubits: raise ValueError('len(qid_shape) != num_qubits') - def _act_on_(self, args: 'cirq.OperationTarget', qubits: Sequence['cirq.Qid']): + def _act_on_(self, args: 'cirq.SimulationState', qubits: Sequence['cirq.Qid']): return True def _qid_shape_(self) -> Tuple[int, ...]: diff --git a/cirq-core/cirq/ops/identity_test.py b/cirq-core/cirq/ops/identity_test.py index c782cd39228..908edb28fae 100644 --- a/cirq-core/cirq/ops/identity_test.py +++ b/cirq-core/cirq/ops/identity_test.py @@ -205,6 +205,6 @@ def with_qubits(self, *new_qubits): def test_identity_short_circuits_act_on(): - args = mock.Mock(cirq.ActOnArgs) + args = mock.Mock(cirq.DenseSimulationState) args._act_on_fallback_.side_effect = mock.Mock(side_effect=Exception('No!')) cirq.act_on(cirq.IdentityGate(1)(cirq.LineQubit(0)), args) diff --git a/cirq-core/cirq/ops/measurement_gate.py b/cirq-core/cirq/ops/measurement_gate.py index 66f16080ea5..8cd409220bb 100644 --- a/cirq-core/cirq/ops/measurement_gate.py +++ b/cirq-core/cirq/ops/measurement_gate.py @@ -260,10 +260,10 @@ def _from_json_dict_(cls, num_qubits, key, invert_mask, qid_shape=None, **kwargs def _has_stabilizer_effect_(self) -> Optional[bool]: return True - def _act_on_(self, args: 'cirq.OperationTarget', qubits: Sequence['cirq.Qid']) -> bool: - from cirq.sim import ActOnArgs + def _act_on_(self, args: 'cirq.SimulationState', qubits: Sequence['cirq.Qid']) -> bool: + from cirq.sim import DenseSimulationState - if not isinstance(args, ActOnArgs): + if not isinstance(args, DenseSimulationState): return NotImplemented args.measure(qubits, self.key, self.full_invert_mask()) return True diff --git a/cirq-core/cirq/ops/measurement_gate_test.py b/cirq-core/cirq/ops/measurement_gate_test.py index ae29c4f792d..d8d9ecde478 100644 --- a/cirq-core/cirq/ops/measurement_gate_test.py +++ b/cirq-core/cirq/ops/measurement_gate_test.py @@ -284,7 +284,7 @@ def test_act_on_state_vector(): a, b = [cirq.LineQubit(3), cirq.LineQubit(1)] m = cirq.measure(a, b, key='out', invert_mask=(True,)) - args = cirq.ActOnStateVectorArgs( + args = cirq.StateVectorSimulationState( available_buffer=np.empty(shape=(2, 2, 2, 2, 2)), qubits=cirq.LineQubit.range(5), prng=np.random.RandomState(), @@ -294,7 +294,7 @@ def test_act_on_state_vector(): cirq.act_on(m, args) assert args.log_of_measurement_results == {'out': [1, 0]} - args = cirq.ActOnStateVectorArgs( + args = cirq.StateVectorSimulationState( available_buffer=np.empty(shape=(2, 2, 2, 2, 2)), qubits=cirq.LineQubit.range(5), prng=np.random.RandomState(), @@ -306,7 +306,7 @@ def test_act_on_state_vector(): cirq.act_on(m, args) assert args.log_of_measurement_results == {'out': [1, 1]} - args = cirq.ActOnStateVectorArgs( + args = cirq.StateVectorSimulationState( available_buffer=np.empty(shape=(2, 2, 2, 2, 2)), qubits=cirq.LineQubit.range(5), prng=np.random.RandomState(), @@ -331,7 +331,7 @@ def test_act_on_clifford_tableau(): # The below assertion does not fail since it ignores non-unitary operations cirq.testing.assert_all_implemented_act_on_effects_match_unitary(m) - args = cirq.ActOnCliffordTableauArgs( + args = cirq.CliffordTableauSimulationState( tableau=cirq.CliffordTableau(num_qubits=5, initial_state=0), qubits=cirq.LineQubit.range(5), prng=np.random.RandomState(), @@ -339,7 +339,7 @@ def test_act_on_clifford_tableau(): cirq.act_on(m, args) assert args.log_of_measurement_results == {'out': [1, 0]} - args = cirq.ActOnCliffordTableauArgs( + args = cirq.CliffordTableauSimulationState( tableau=cirq.CliffordTableau(num_qubits=5, initial_state=8), qubits=cirq.LineQubit.range(5), prng=np.random.RandomState(), @@ -348,7 +348,7 @@ def test_act_on_clifford_tableau(): cirq.act_on(m, args) assert args.log_of_measurement_results == {'out': [1, 1]} - args = cirq.ActOnCliffordTableauArgs( + args = cirq.CliffordTableauSimulationState( tableau=cirq.CliffordTableau(num_qubits=5, initial_state=10), qubits=cirq.LineQubit.range(5), prng=np.random.RandomState(), @@ -369,20 +369,20 @@ def test_act_on_stabilizer_ch_form(): # The below assertion does not fail since it ignores non-unitary operations cirq.testing.assert_all_implemented_act_on_effects_match_unitary(m) - args = cirq.ActOnStabilizerCHFormArgs( + args = cirq.CHFormSimulationState( qubits=cirq.LineQubit.range(5), prng=np.random.RandomState(), initial_state=0 ) cirq.act_on(m, args) assert args.log_of_measurement_results == {'out': [1, 0]} - args = cirq.ActOnStabilizerCHFormArgs( + args = cirq.CHFormSimulationState( qubits=cirq.LineQubit.range(5), prng=np.random.RandomState(), initial_state=8 ) cirq.act_on(m, args) assert args.log_of_measurement_results == {'out': [1, 1]} - args = cirq.ActOnStabilizerCHFormArgs( + args = cirq.CHFormSimulationState( qubits=cirq.LineQubit.range(5), prng=np.random.RandomState(), initial_state=10 ) cirq.act_on(m, args) @@ -399,7 +399,7 @@ def test_act_on_qutrit(): a, b = [cirq.LineQid(3, dimension=3), cirq.LineQid(1, dimension=3)] m = cirq.measure(a, b, key='out', invert_mask=(True,)) - args = cirq.ActOnStateVectorArgs( + args = cirq.StateVectorSimulationState( available_buffer=np.empty(shape=(3, 3, 3, 3, 3)), qubits=cirq.LineQid.range(5, dimension=3), prng=np.random.RandomState(), @@ -411,7 +411,7 @@ def test_act_on_qutrit(): cirq.act_on(m, args) assert args.log_of_measurement_results == {'out': [2, 2]} - args = cirq.ActOnStateVectorArgs( + args = cirq.StateVectorSimulationState( available_buffer=np.empty(shape=(3, 3, 3, 3, 3)), qubits=cirq.LineQid.range(5, dimension=3), prng=np.random.RandomState(), @@ -423,7 +423,7 @@ def test_act_on_qutrit(): cirq.act_on(m, args) assert args.log_of_measurement_results == {'out': [2, 1]} - args = cirq.ActOnStateVectorArgs( + args = cirq.StateVectorSimulationState( available_buffer=np.empty(shape=(3, 3, 3, 3, 3)), qubits=cirq.LineQid.range(5, dimension=3), prng=np.random.RandomState(), diff --git a/cirq-core/cirq/ops/random_gate_channel_test.py b/cirq-core/cirq/ops/random_gate_channel_test.py index 8e46fdcff99..57b776c262a 100644 --- a/cirq-core/cirq/ops/random_gate_channel_test.py +++ b/cirq-core/cirq/ops/random_gate_channel_test.py @@ -215,13 +215,13 @@ def test_stabilizer_supports_probability(): def test_unsupported_stabilizer_safety(): - from cirq.protocols.act_on_protocol_test import DummyActOnArgs + from cirq.protocols.act_on_protocol_test import DummySimulationState with pytest.raises(TypeError, match="act_on"): for _ in range(100): - cirq.act_on(cirq.X.with_probability(0.5), DummyActOnArgs(), qubits=()) + cirq.act_on(cirq.X.with_probability(0.5), DummySimulationState(), qubits=()) with pytest.raises(TypeError, match="act_on"): - cirq.act_on(cirq.X.with_probability(sympy.Symbol('x')), DummyActOnArgs(), qubits=()) + cirq.act_on(cirq.X.with_probability(sympy.Symbol('x')), DummySimulationState(), qubits=()) q = cirq.LineQubit(0) c = cirq.Circuit((cirq.X(q) ** 0.25).with_probability(0.5), cirq.measure(q, key='m')) diff --git a/cirq-core/cirq/ops/raw_types.py b/cirq-core/cirq/ops/raw_types.py index 9b07c9661a3..ec1ae470518 100644 --- a/cirq-core/cirq/ops/raw_types.py +++ b/cirq-core/cirq/ops/raw_types.py @@ -797,7 +797,7 @@ def _is_parameterized_(self) -> bool: protocols.is_parameterized(tag) for tag in self.tags ) - def _act_on_(self, args: 'cirq.OperationTarget') -> bool: + def _act_on_(self, args: 'cirq.SimulationState') -> bool: sub = getattr(self.sub_operation, "_act_on_", None) if sub is not None: return sub(args) diff --git a/cirq-core/cirq/ops/raw_types_test.py b/cirq-core/cirq/ops/raw_types_test.py index 92e1f6ee65d..a635b32d00d 100644 --- a/cirq-core/cirq/ops/raw_types_test.py +++ b/cirq-core/cirq/ops/raw_types_test.py @@ -754,9 +754,9 @@ def qubits(self): pass q = cirq.LineQubit(1) - from cirq.protocols.act_on_protocol_test import DummyActOnArgs + from cirq.protocols.act_on_protocol_test import DummySimulationState - args = DummyActOnArgs() + args = DummySimulationState() cirq.act_on(YesActOn()(q).with_tags("test"), args) with pytest.raises(TypeError, match="Failed to act"): cirq.act_on(NoActOn()(q).with_tags("test"), args) diff --git a/cirq-core/cirq/protocols/act_on_protocol.py b/cirq-core/cirq/protocols/act_on_protocol.py index a38515b30ae..06c48ac6a96 100644 --- a/cirq-core/cirq/protocols/act_on_protocol.py +++ b/cirq-core/cirq/protocols/act_on_protocol.py @@ -28,11 +28,11 @@ class SupportsActOn(Protocol): """An object that explicitly specifies how to act on simulator states.""" @doc_private - def _act_on_(self, args: 'cirq.OperationTarget') -> Union[NotImplementedType, bool]: + def _act_on_(self, args: 'cirq.SimulationState') -> Union[NotImplementedType, bool]: """Applies an action to the given argument, if it is a supported type. For example, unitary operations can implement an `_act_on_` method that - checks if `isinstance(args, cirq.ActOnStateVectorArgs)` and, if so, + checks if `isinstance(args, cirq.StateVectorSimulationState)` and, if so, apply their unitary effect to the state vector. The global `cirq.act_on` method looks for whether or not the given @@ -59,12 +59,12 @@ class SupportsActOnQubits(Protocol): @doc_private def _act_on_( - self, args: 'cirq.OperationTarget', qubits: Sequence['cirq.Qid'] + self, args: 'cirq.SimulationState', qubits: Sequence['cirq.Qid'] ) -> Union[NotImplementedType, bool]: """Applies an action to the given argument, if it is a supported type. For example, unitary operations can implement an `_act_on_` method that - checks if `isinstance(args, cirq.ActOnStateVectorArgs)` and, if so, + checks if `isinstance(args, cirq.StateVectorSimulationState)` and, if so, apply their unitary effect to the state vector. The global `cirq.act_on` method looks for whether or not the given @@ -88,7 +88,7 @@ def _act_on_( def act_on( action: Any, - args: 'cirq.OperationTarget', + args: 'cirq.SimulationState', qubits: Sequence['cirq.Qid'] = None, *, allow_decompose: bool = True, @@ -97,7 +97,7 @@ def act_on( For example, the action may be a `cirq.Operation` and the state argument may represent the internal state of a state vector simulator (a - `cirq.ActOnStateVectorArgs`). + `cirq.StateVectorSimulationState`). For non-operations, the `qubits` argument must be explicitly supplied. diff --git a/cirq-core/cirq/protocols/act_on_protocol_test.py b/cirq-core/cirq/protocols/act_on_protocol_test.py index d3ba8113932..79d3cd583ac 100644 --- a/cirq-core/cirq/protocols/act_on_protocol_test.py +++ b/cirq-core/cirq/protocols/act_on_protocol_test.py @@ -28,7 +28,7 @@ def measure(self, axes, seed=None): pass -class DummyActOnArgs(cirq.ActOnArgs): +class DummySimulationState(cirq.DenseSimulationState): def __init__(self, fallback_result: Any = NotImplemented): super().__init__(prng=np.random.RandomState(), state=DummyQuantumState()) self.fallback_result = fallback_result @@ -43,18 +43,18 @@ def _act_on_fallback_( def test_act_on_fallback_succeeds(): - args = DummyActOnArgs(fallback_result=True) + args = DummySimulationState(fallback_result=True) cirq.act_on(op, args) def test_act_on_fallback_fails(): - args = DummyActOnArgs(fallback_result=NotImplemented) + args = DummySimulationState(fallback_result=NotImplemented) with pytest.raises(TypeError, match='Failed to act'): cirq.act_on(op, args) def test_act_on_fallback_errors(): - args = DummyActOnArgs(fallback_result=False) + args = DummySimulationState(fallback_result=False) with pytest.raises(ValueError, match='_act_on_fallback_ must return True or NotImplemented'): cirq.act_on(op, args) @@ -71,7 +71,7 @@ def with_qubits(self: TSelf, *new_qubits: 'cirq.Qid') -> TSelf: def _act_on_(self, args): return False - args = DummyActOnArgs(fallback_result=True) + args = DummySimulationState(fallback_result=True) with pytest.raises(ValueError, match='_act_on_ must return True or NotImplemented'): cirq.act_on(Op(), args) @@ -85,7 +85,7 @@ def qubits(self) -> Tuple['cirq.Qid', ...]: def with_qubits(self: TSelf, *new_qubits: 'cirq.Qid') -> TSelf: pass - args = DummyActOnArgs() + args = DummySimulationState() with pytest.raises( ValueError, match='Calls to act_on should not supply qubits if the action is an Operation' ): @@ -93,6 +93,6 @@ def with_qubits(self: TSelf, *new_qubits: 'cirq.Qid') -> TSelf: def test_qubits_should_be_defined_for_operations(): - args = DummyActOnArgs() + args = DummySimulationState() with pytest.raises(ValueError, match='Calls to act_on should'): cirq.act_on(cirq.KrausChannel([np.array([[1, 0], [0, 0]])]), args, qubits=None) diff --git a/cirq-core/cirq/protocols/json_test_data/spec.py b/cirq-core/cirq/protocols/json_test_data/spec.py index c6cddc39049..50b874b6fc3 100644 --- a/cirq-core/cirq/protocols/json_test_data/spec.py +++ b/cirq-core/cirq/protocols/json_test_data/spec.py @@ -81,17 +81,17 @@ 'Heatmap', 'TwoQubitInteractionHeatmap', # Intermediate states with work buffers and unknown external prng guts. - 'ActOnArgs', - 'ActOnArgsContainer', - 'ActOnCliffordTableauArgs', - 'ActOnDensityMatrixArgs', - 'ActOnStabilizerArgs', - 'ActOnStabilizerCHFormArgs', - 'ActOnStateVectorArgs', + 'DenseSimulationState', + 'SimulationProductState', + 'CliffordTableauSimulationState', + 'DensityMatrixSimulationState', + 'StabilizerSimulationState', + 'CHFormSimulationState', + 'StateVectorSimulationState', 'ApplyChannelArgs', 'ApplyMixtureArgs', 'ApplyUnitaryArgs', - 'OperationTarget', + 'SimulationState', # Abstract base class for creating compilation targets. 'CompilationTargetGateset', 'TwoQubitCompilationTargetGateset', diff --git a/cirq-core/cirq/sim/__init__.py b/cirq-core/cirq/sim/__init__.py index 307047c8d30..ee6b1b22089 100644 --- a/cirq-core/cirq/sim/__init__.py +++ b/cirq-core/cirq/sim/__init__.py @@ -15,13 +15,13 @@ """Classes for circuit simulators and base implementations of these classes.""" from typing import Tuple, Dict -from cirq.sim.act_on_args import ActOnArgs +from cirq.sim.act_on_args import DenseSimulationState -from cirq.sim.act_on_args_container import ActOnArgsContainer +from cirq.sim.act_on_args_container import SimulationProductState -from cirq.sim.act_on_density_matrix_args import ActOnDensityMatrixArgs +from cirq.sim.act_on_density_matrix_args import DensityMatrixSimulationState -from cirq.sim.act_on_state_vector_args import ActOnStateVectorArgs +from cirq.sim.act_on_state_vector_args import StateVectorSimulationState from cirq.sim.density_matrix_utils import measure_density_matrix, sample_density_matrix @@ -32,7 +32,7 @@ DensityMatrixTrialResult, ) -from cirq.sim.operation_target import OperationTarget +from cirq.sim.operation_target import SimulationState from cirq.sim.mux import ( CIRCUIT_LIKE, @@ -66,9 +66,9 @@ from cirq.sim.state_vector import measure_state_vector, sample_state_vector, StateVectorMixin from cirq.sim.clifford import ( - ActOnCliffordTableauArgs, - ActOnStabilizerCHFormArgs, - ActOnStabilizerArgs, + CliffordTableauSimulationState, + CHFormSimulationState, + StabilizerSimulationState, StabilizerSampler, StabilizerStateChForm, CliffordSimulator, diff --git a/cirq-core/cirq/sim/act_on_args.py b/cirq-core/cirq/sim/act_on_args.py index 6fc0b679833..8fbb844def8 100644 --- a/cirq-core/cirq/sim/act_on_args.py +++ b/cirq-core/cirq/sim/act_on_args.py @@ -33,16 +33,16 @@ from cirq import protocols, value from cirq._compat import _warn_or_error, deprecated, deprecated_parameter from cirq.protocols.decompose_protocol import _try_decompose_into_operations_and_qubits -from cirq.sim.operation_target import OperationTarget +from cirq.sim.operation_target import SimulationState -TSelf = TypeVar('TSelf', bound='ActOnArgs') +TSelf = TypeVar('TSelf', bound='DenseSimulationState') TState = TypeVar('TState', bound='cirq.QuantumStateRepresentation') if TYPE_CHECKING: import cirq -class ActOnArgs(OperationTarget, Generic[TState], metaclass=abc.ABCMeta): +class DenseSimulationState(SimulationState, Generic[TState], metaclass=abc.ABCMeta): """State and context for an operation acting on a state tensor.""" @deprecated_parameter( @@ -66,7 +66,7 @@ def __init__( classical_data: Optional['cirq.ClassicalDataStore'] = None, state: Optional[TState] = None, ): - """Inits ActOnArgs. + """Inits DenseSimulationState. Args: prng: The pseudo random number generator to use for probabilistic @@ -157,7 +157,7 @@ def copy(self: TSelf, deep_copy_buffers: bool = True) -> TSelf: args._state = self._state.copy(deep_copy_buffers=deep_copy_buffers) else: _warn_or_error( - 'Pass a `QuantumStateRepresentation` into the `ActOnArgs` constructor. The `_on_`' + 'Pass a `QuantumStateRepresentation` into the `DenseSimulationState` constructor. The `_on_`' ' overrides will be removed in cirq v0.16.' ) self._on_copy(args, deep_copy_buffers) @@ -165,7 +165,7 @@ def copy(self: TSelf, deep_copy_buffers: bool = True) -> TSelf: @deprecated( deadline='v0.16', - fix='Pass a `QuantumStateRepresentation` into the `ActOnArgs` constructor.', + fix='Pass a `QuantumStateRepresentation` into the `DenseSimulationState` constructor.', ) def _on_copy(self: TSelf, args: TSelf, deep_copy_buffers: bool = True): """Subclasses should implement this with any additional state copy @@ -182,7 +182,7 @@ def kronecker_product(self: TSelf, other: TSelf, *, inplace=False) -> TSelf: args._state = self._state.kron(other._state) else: _warn_or_error( - 'Pass a `QuantumStateRepresentation` into the `ActOnArgs` constructor. The `_on_`' + 'Pass a `QuantumStateRepresentation` into the `DenseSimulationState` constructor. The `_on_`' ' overrides will be removed in cirq v0.16.' ) self._on_kronecker_product(other, args) @@ -191,7 +191,7 @@ def kronecker_product(self: TSelf, other: TSelf, *, inplace=False) -> TSelf: @deprecated( deadline='v0.16', - fix='Pass a `QuantumStateRepresentation` into the `ActOnArgs` constructor.', + fix='Pass a `QuantumStateRepresentation` into the `DenseSimulationState` constructor.', ) def _on_kronecker_product(self: TSelf, other: TSelf, target: TSelf): """Subclasses should implement this with any additional state product @@ -225,7 +225,7 @@ def factor( remainder._state = r else: _warn_or_error( - 'Pass a `QuantumStateRepresentation` into the `ActOnArgs` constructor. The `_on_`' + 'Pass a `QuantumStateRepresentation` into the `DenseSimulationState` constructor. The `_on_`' ' overrides will be removed in cirq v0.16.' ) self._on_factor(qubits, extracted, remainder, validate, atol) @@ -240,7 +240,7 @@ def allows_factoring(self): @deprecated( deadline='v0.16', - fix='Pass a `QuantumStateRepresentation` into the `ActOnArgs` constructor.', + fix='Pass a `QuantumStateRepresentation` into the `DenseSimulationState` constructor.', ) def _on_factor( self: TSelf, @@ -276,7 +276,7 @@ def transpose_to_qubit_order( args._state = self._state.reindex(self.get_axes(qubits)) else: _warn_or_error( - 'Pass a `QuantumStateRepresentation` into the `ActOnArgs` constructor. The `_on_`' + 'Pass a `QuantumStateRepresentation` into the `DenseSimulationState` constructor. The `_on_`' ' overrides will be removed in cirq v0.16.' ) self._on_transpose_to_qubit_order(qubits, args) @@ -285,7 +285,7 @@ def transpose_to_qubit_order( @deprecated( deadline='v0.16', - fix='Pass a `QuantumStateRepresentation` into the `ActOnArgs` constructor.', + fix='Pass a `QuantumStateRepresentation` into the `DenseSimulationState` constructor.', ) def _on_transpose_to_qubit_order(self: TSelf, qubits: Sequence['cirq.Qid'], target: TSelf): """Subclasses should implement this with any additional state transpose @@ -375,7 +375,7 @@ def can_represent_mixed_states(self) -> bool: def strat_act_on_from_apply_decompose( - val: Any, args: 'cirq.ActOnArgs', qubits: Sequence['cirq.Qid'] + val: Any, args: 'cirq.DenseSimulationState', qubits: Sequence['cirq.Qid'] ) -> bool: operations, qubits1, _ = _try_decompose_into_operations_and_qubits(val) assert len(qubits1) == len(qubits) @@ -388,4 +388,4 @@ def strat_act_on_from_apply_decompose( return True -TActOnArgs = TypeVar('TActOnArgs', bound=ActOnArgs) +TDenseSimulationState = TypeVar('TDenseSimulationState', bound=DenseSimulationState) diff --git a/cirq-core/cirq/sim/act_on_args_container.py b/cirq-core/cirq/sim/act_on_args_container.py index 0b4e0856b64..15079bf5c9a 100644 --- a/cirq-core/cirq/sim/act_on_args_container.py +++ b/cirq-core/cirq/sim/act_on_args_container.py @@ -18,19 +18,19 @@ import numpy as np from cirq import ops, protocols, value -from cirq.sim.act_on_args import TActOnArgs -from cirq.sim.operation_target import OperationTarget +from cirq.sim.act_on_args import TDenseSimulationState +from cirq.sim.operation_target import SimulationState if TYPE_CHECKING: import cirq -class ActOnArgsContainer(Generic[TActOnArgs], OperationTarget[TActOnArgs], abc.Mapping): - """A container for a `Qid`-to-`ActOnArgs` dictionary.""" +class SimulationProductState(Generic[TDenseSimulationState], SimulationState[TDenseSimulationState], abc.Mapping): + """A container for a `Qid`-to-`DenseSimulationState` dictionary.""" def __init__( self, - args: Dict[Optional['cirq.Qid'], TActOnArgs], + args: Dict[Optional['cirq.Qid'], TDenseSimulationState], qubits: Sequence['cirq.Qid'], split_untangled_states: bool, classical_data: Optional['cirq.ClassicalDataStore'] = None, @@ -38,7 +38,7 @@ def __init__( """Initializes the class. Args: - args: The `ActOnArgs` dictionary. This will not be copied; the + args: The `DenseSimulationState` dictionary. This will not be copied; the original reference will be kept here. qubits: The canonical ordering of qubits. split_untangled_states: If True, optimizes operations by running @@ -53,14 +53,14 @@ def __init__( self._split_untangled_states = split_untangled_states @property - def args(self) -> Mapping[Optional['cirq.Qid'], TActOnArgs]: + def args(self) -> Mapping[Optional['cirq.Qid'], TDenseSimulationState]: return self._args @property def split_untangled_states(self) -> bool: return self._split_untangled_states - def create_merged_state(self) -> TActOnArgs: + def create_merged_state(self) -> TDenseSimulationState: if not self.split_untangled_states: return self.args[None] final_args = self.args[None] @@ -97,9 +97,9 @@ def _act_on_fallback_( self._args[q1] = args0.rename(q0, q1, inplace=True) return True - # Go through the op's qubits and join any disparate ActOnArgs states + # Go through the op's qubits and join any disparate DenseSimulationState states # into a new combined state. - op_args_opt: Optional[TActOnArgs] = None + op_args_opt: Optional[TDenseSimulationState] = None for q in qubits: if op_args_opt is None: op_args_opt = self.args[q] @@ -129,7 +129,7 @@ def _act_on_fallback_( self._args[q] = op_args return True - def copy(self, deep_copy_buffers: bool = True) -> 'cirq.ActOnArgsContainer[TActOnArgs]': + def copy(self, deep_copy_buffers: bool = True) -> 'cirq.SimulationProductState[TDenseSimulationState]': classical_data = self._classical_data.copy() copies = {} for act_on_args in set(self.args.values()): @@ -137,7 +137,7 @@ def copy(self, deep_copy_buffers: bool = True) -> 'cirq.ActOnArgsContainer[TActO for copy in copies.values(): copy._classical_data = classical_data args = {q: copies[a] for q, a in self.args.items()} - return ActOnArgsContainer( + return SimulationProductState( args, self.qubits, self.split_untangled_states, classical_data=classical_data ) @@ -161,7 +161,7 @@ def sample( index_order = [qubit_map[q] for q in qubits] return stacked[:, index_order] - def __getitem__(self, item: Optional['cirq.Qid']) -> TActOnArgs: + def __getitem__(self, item: Optional['cirq.Qid']) -> TDenseSimulationState: return self.args[item] def __len__(self) -> int: diff --git a/cirq-core/cirq/sim/act_on_args_container_test.py b/cirq-core/cirq/sim/act_on_args_container_test.py index 92dde560fdb..106e02b69db 100644 --- a/cirq-core/cirq/sim/act_on_args_container_test.py +++ b/cirq-core/cirq/sim/act_on_args_container_test.py @@ -37,7 +37,7 @@ def reindex(self, axes): return self -class EmptyActOnArgs(cirq.ActOnArgs): +class EmptySimulationState(cirq.DenseSimulationState): def __init__(self, qubits, classical_data): super().__init__(state=EmptyQuantumState(), qubits=qubits, classical_data=classical_data) @@ -53,19 +53,19 @@ def _act_on_fallback_( def create_container( qubits: Sequence['cirq.Qid'], split_untangled_states=True -) -> cirq.ActOnArgsContainer[EmptyActOnArgs]: - args_map: Dict[Optional['cirq.Qid'], EmptyActOnArgs] = {} +) -> cirq.SimulationProductState[EmptySimulationState]: + args_map: Dict[Optional['cirq.Qid'], EmptySimulationState] = {} log = cirq.ClassicalDataDictionaryStore() if split_untangled_states: for q in reversed(qubits): - args_map[q] = EmptyActOnArgs([q], log) - args_map[None] = EmptyActOnArgs((), log) + args_map[q] = EmptySimulationState([q], log) + args_map[None] = EmptySimulationState((), log) else: - args = EmptyActOnArgs(qubits, log) + args = EmptySimulationState(qubits, log) for q in qubits: args_map[q] = args - args_map[None] = args if not split_untangled_states else EmptyActOnArgs((), log) - return cirq.ActOnArgsContainer(args_map, qubits, split_untangled_states, classical_data=log) + args_map[None] = args if not split_untangled_states else EmptySimulationState((), log) + return cirq.SimulationProductState(args_map, qubits, split_untangled_states, classical_data=log) def test_entanglement_causes_join(): diff --git a/cirq-core/cirq/sim/act_on_args_test.py b/cirq-core/cirq/sim/act_on_args_test.py index a8b9a4c51ad..d21f411e078 100644 --- a/cirq-core/cirq/sim/act_on_args_test.py +++ b/cirq-core/cirq/sim/act_on_args_test.py @@ -32,7 +32,7 @@ def reindex(self, axes): return self -class DummyArgs(cirq.ActOnArgs): +class DummyArgs(cirq.DenseSimulationState): def __init__(self): super().__init__(state=DummyQuantumState(), qubits=cirq.LineQubit.range(2)) @@ -104,7 +104,7 @@ def test_field_getters(): def test_on_methods_deprecated(): - class OldStyleArgs(cirq.ActOnArgs): + class OldStyleArgs(cirq.DenseSimulationState): def _act_on_fallback_(self, action, qubits, allow_decompose=True): pass @@ -121,7 +121,7 @@ def _act_on_fallback_(self, action, qubits, allow_decompose=True): def test_on_methods_deprecated_if_implemented(): - class OldStyleArgs(cirq.ActOnArgs): + class OldStyleArgs(cirq.DenseSimulationState): def _act_on_fallback_(self, action, qubits, allow_decompose=True): pass @@ -150,7 +150,7 @@ def _on_transpose_to_qubit_order(self, qubits, target): def test_deprecated(): - class DeprecatedArgs(cirq.ActOnArgs): + class DeprecatedArgs(cirq.DenseSimulationState): def _act_on_fallback_(self, action, qubits, allow_decompose=True): pass diff --git a/cirq-core/cirq/sim/act_on_density_matrix_args.py b/cirq-core/cirq/sim/act_on_density_matrix_args.py index c596cbe5631..77f04b1d17a 100644 --- a/cirq-core/cirq/sim/act_on_density_matrix_args.py +++ b/cirq-core/cirq/sim/act_on_density_matrix_args.py @@ -20,7 +20,7 @@ from cirq import protocols, qis, sim from cirq._compat import proper_repr from cirq.linalg import transformations -from cirq.sim.act_on_args import ActOnArgs, strat_act_on_from_apply_decompose +from cirq.sim.act_on_args import DenseSimulationState, strat_act_on_from_apply_decompose if TYPE_CHECKING: import cirq @@ -236,7 +236,7 @@ def can_represent_mixed_states(self) -> bool: return True -class ActOnDensityMatrixArgs(ActOnArgs[_BufferedDensityMatrix]): +class DensityMatrixSimulationState(DenseSimulationState[_BufferedDensityMatrix]): """State and context for an operation acting on a density matrix. To act on this object, directly edit the `target_tensor` property, which is @@ -254,7 +254,7 @@ def __init__( dtype: Type[np.number] = np.complex64, classical_data: Optional['cirq.ClassicalDataStore'] = None, ): - """Inits ActOnDensityMatrixArgs. + """Inits DensityMatrixSimulationState. Args: available_buffer: A workspace with the same shape and dtype as @@ -312,7 +312,7 @@ def _act_on_fallback_( def __repr__(self) -> str: return ( - 'cirq.ActOnDensityMatrixArgs(' + 'cirq.DensityMatrixSimulationState(' f'initial_state={proper_repr(self.target_tensor)},' f' qid_shape={self.qid_shape!r},' f' qubits={self.qubits!r},' @@ -333,7 +333,7 @@ def qid_shape(self): def _strat_apply_channel_to_state( - action: Any, args: 'cirq.ActOnDensityMatrixArgs', qubits: Sequence['cirq.Qid'] + action: Any, args: 'cirq.DensityMatrixSimulationState', qubits: Sequence['cirq.Qid'] ) -> bool: """Apply channel to state.""" return True if args._state.apply_channel(action, args.get_axes(qubits)) else NotImplemented diff --git a/cirq-core/cirq/sim/act_on_density_matrix_args_test.py b/cirq-core/cirq/sim/act_on_density_matrix_args_test.py index 559759f5f10..721ff162e6b 100644 --- a/cirq-core/cirq/sim/act_on_density_matrix_args_test.py +++ b/cirq-core/cirq/sim/act_on_density_matrix_args_test.py @@ -23,7 +23,7 @@ def test_default_parameter(): tensor = cirq.to_valid_density_matrix( 0, len(qid_shape), qid_shape=qid_shape, dtype=np.complex64 ) - args = cirq.ActOnDensityMatrixArgs(qubits=cirq.LineQubit.range(1), initial_state=0) + args = cirq.DensityMatrixSimulationState(qubits=cirq.LineQubit.range(1), initial_state=0) np.testing.assert_almost_equal(args.target_tensor, tensor) assert len(args.available_buffer) == 3 for buffer in args.available_buffer: @@ -33,7 +33,7 @@ def test_default_parameter(): def test_shallow_copy_buffers(): - args = cirq.ActOnDensityMatrixArgs(qubits=cirq.LineQubit.range(1), initial_state=0) + args = cirq.DensityMatrixSimulationState(qubits=cirq.LineQubit.range(1), initial_state=0) copy = args.copy(deep_copy_buffers=False) assert copy.available_buffer is args.available_buffer @@ -46,7 +46,7 @@ def num_qubits(self) -> int: def _decompose_(self, qubits): yield cirq.X(*qubits) - args = cirq.ActOnDensityMatrixArgs( + args = cirq.DensityMatrixSimulationState( qubits=cirq.LineQubit.range(1), prng=np.random.RandomState(), initial_state=0, @@ -63,7 +63,7 @@ def test_cannot_act(): class NoDetails: pass - args = cirq.ActOnDensityMatrixArgs( + args = cirq.DensityMatrixSimulationState( qubits=cirq.LineQubit.range(1), prng=np.random.RandomState(), initial_state=0, @@ -74,7 +74,7 @@ class NoDetails: def test_with_qubits(): - original = cirq.ActOnDensityMatrixArgs( + original = cirq.DensityMatrixSimulationState( qubits=cirq.LineQubit.range(1), initial_state=1, dtype=np.complex64 ) extened = original.with_qubits(cirq.LineQubit.range(1, 2)) @@ -94,12 +94,12 @@ def test_qid_shape_error(): def test_initial_state_vector(): qubits = cirq.LineQubit.range(3) - args = cirq.ActOnDensityMatrixArgs( + args = cirq.DensityMatrixSimulationState( qubits=qubits, initial_state=np.full((8,), 1 / np.sqrt(8)), dtype=np.complex64 ) assert args.target_tensor.shape == (2, 2, 2, 2, 2, 2) - args2 = cirq.ActOnDensityMatrixArgs( + args2 = cirq.DensityMatrixSimulationState( qubits=qubits, initial_state=np.full((2, 2, 2), 1 / np.sqrt(8)), dtype=np.complex64 ) assert args2.target_tensor.shape == (2, 2, 2, 2, 2, 2) @@ -107,12 +107,12 @@ def test_initial_state_vector(): def test_initial_state_matrix(): qubits = cirq.LineQubit.range(3) - args = cirq.ActOnDensityMatrixArgs( + args = cirq.DensityMatrixSimulationState( qubits=qubits, initial_state=np.full((8, 8), 1 / 8), dtype=np.complex64 ) assert args.target_tensor.shape == (2, 2, 2, 2, 2, 2) - args2 = cirq.ActOnDensityMatrixArgs( + args2 = cirq.DensityMatrixSimulationState( qubits=qubits, initial_state=np.full((2, 2, 2, 2, 2, 2), 1 / 8), dtype=np.complex64 ) assert args2.target_tensor.shape == (2, 2, 2, 2, 2, 2) @@ -121,19 +121,19 @@ def test_initial_state_matrix(): def test_initial_state_bad_shape(): qubits = cirq.LineQubit.range(3) with pytest.raises(ValueError, match="Invalid quantum state"): - cirq.ActOnDensityMatrixArgs( + cirq.DensityMatrixSimulationState( qubits=qubits, initial_state=np.full((4,), 1 / 2), dtype=np.complex64 ) with pytest.raises(ValueError, match="Invalid quantum state"): - cirq.ActOnDensityMatrixArgs( + cirq.DensityMatrixSimulationState( qubits=qubits, initial_state=np.full((2, 2), 1 / 2), dtype=np.complex64 ) with pytest.raises(ValueError, match="Invalid quantum state"): - cirq.ActOnDensityMatrixArgs( + cirq.DensityMatrixSimulationState( qubits=qubits, initial_state=np.full((4, 4), 1 / 4), dtype=np.complex64 ) with pytest.raises(ValueError, match="Invalid quantum state"): - cirq.ActOnDensityMatrixArgs( + cirq.DensityMatrixSimulationState( qubits=qubits, initial_state=np.full((2, 2, 2, 2), 1 / 4), dtype=np.complex64 ) diff --git a/cirq-core/cirq/sim/act_on_state_vector_args.py b/cirq-core/cirq/sim/act_on_state_vector_args.py index 93c258de2ba..fcf6336f749 100644 --- a/cirq-core/cirq/sim/act_on_state_vector_args.py +++ b/cirq-core/cirq/sim/act_on_state_vector_args.py @@ -20,7 +20,7 @@ from cirq import _compat, linalg, protocols, qis, sim from cirq._compat import proper_repr from cirq.linalg import transformations -from cirq.sim.act_on_args import ActOnArgs, strat_act_on_from_apply_decompose +from cirq.sim.act_on_args import DenseSimulationState, strat_act_on_from_apply_decompose if TYPE_CHECKING: import cirq @@ -293,7 +293,7 @@ def _swap_target_tensor_for(self, new_target_tensor: np.ndarray): """Gives a new state vector for the system. Typically, the new state vector should be `args.available_buffer` where - `args` is this `cirq.ActOnStateVectorArgs` instance. + `args` is this `cirq.StateVectorSimulationState` instance. Args: new_target_tensor: The new system state. Must have the same shape @@ -308,7 +308,7 @@ def supports_factor(self) -> bool: return True -class ActOnStateVectorArgs(ActOnArgs[_BufferedStateVector]): +class StateVectorSimulationState(DenseSimulationState[_BufferedStateVector]): """State and context for an operation acting on a state vector. There are two common ways to act on this object: @@ -329,7 +329,7 @@ def __init__( dtype: Type[np.number] = np.complex64, classical_data: Optional['cirq.ClassicalDataStore'] = None, ): - """Inits ActOnStateVectorArgs. + """Inits StateVectorSimulationState. Args: available_buffer: A workspace with the same shape and dtype as @@ -365,7 +365,7 @@ def swap_target_tensor_for(self, new_target_tensor: np.ndarray): """Gives a new state vector for the system. Typically, the new state vector should be `args.available_buffer` where - `args` is this `cirq.ActOnStateVectorArgs` instance. + `args` is this `cirq.StateVectorSimulationState` instance. Args: new_target_tensor: The new system state. Must have the same shape @@ -456,7 +456,7 @@ def _act_on_fallback_( def __repr__(self) -> str: return ( - 'cirq.ActOnStateVectorArgs(' + 'cirq.StateVectorSimulationState(' f'initial_state={proper_repr(self.target_tensor)},' f' qubits={self.qubits!r},' f' classical_data={self.classical_data!r})' @@ -472,13 +472,13 @@ def available_buffer(self): def _strat_act_on_state_vector_from_apply_unitary( - action: Any, args: 'cirq.ActOnStateVectorArgs', qubits: Sequence['cirq.Qid'] + action: Any, args: 'cirq.StateVectorSimulationState', qubits: Sequence['cirq.Qid'] ) -> bool: return True if args._state.apply_unitary(action, args.get_axes(qubits)) else NotImplemented def _strat_act_on_state_vector_from_mixture( - action: Any, args: 'cirq.ActOnStateVectorArgs', qubits: Sequence['cirq.Qid'] + action: Any, args: 'cirq.StateVectorSimulationState', qubits: Sequence['cirq.Qid'] ) -> bool: index = args._state.apply_mixture(action, args.get_axes(qubits), args.prng) if index is None: @@ -490,7 +490,7 @@ def _strat_act_on_state_vector_from_mixture( def _strat_act_on_state_vector_from_channel( - action: Any, args: 'cirq.ActOnStateVectorArgs', qubits: Sequence['cirq.Qid'] + action: Any, args: 'cirq.StateVectorSimulationState', qubits: Sequence['cirq.Qid'] ) -> bool: index = args._state.apply_channel(action, args.get_axes(qubits), args.prng) if index is None: diff --git a/cirq-core/cirq/sim/act_on_state_vector_args_test.py b/cirq-core/cirq/sim/act_on_state_vector_args_test.py index dd08eeca095..0ad61de7119 100644 --- a/cirq-core/cirq/sim/act_on_state_vector_args_test.py +++ b/cirq-core/cirq/sim/act_on_state_vector_args_test.py @@ -24,7 +24,7 @@ def test_default_parameter(): dtype = np.complex64 tensor = cirq.one_hot(shape=(2, 2, 2), dtype=np.complex64) qubits = cirq.LineQubit.range(3) - args = cirq.ActOnStateVectorArgs(qubits=qubits, initial_state=tensor, dtype=dtype) + args = cirq.StateVectorSimulationState(qubits=qubits, initial_state=tensor, dtype=dtype) qid_shape = cirq.protocols.qid_shape(qubits) tensor = np.reshape(tensor, qid_shape) np.testing.assert_almost_equal(args.target_tensor, tensor) @@ -34,7 +34,7 @@ def test_default_parameter(): def test_infer_target_tensor(): dtype = np.complex64 - args = cirq.ActOnStateVectorArgs( + args = cirq.StateVectorSimulationState( qubits=cirq.LineQubit.range(2), initial_state=np.array([1.0, 0.0, 0.0, 0.0], dtype=dtype), dtype=dtype, @@ -44,7 +44,7 @@ def test_infer_target_tensor(): np.array([[1.0 + 0.0j, 0.0 + 0.0j], [0.0 + 0.0j, 0.0 + 0.0j]], dtype=dtype), ) - args = cirq.ActOnStateVectorArgs(qubits=cirq.LineQubit.range(2), initial_state=0, dtype=dtype) + args = cirq.StateVectorSimulationState(qubits=cirq.LineQubit.range(2), initial_state=0, dtype=dtype) np.testing.assert_almost_equal( args.target_tensor, np.array([[1.0 + 0.0j, 0.0 + 0.0j], [0.0 + 0.0j, 0.0 + 0.0j]], dtype=dtype), @@ -52,7 +52,7 @@ def test_infer_target_tensor(): def test_shallow_copy_buffers(): - args = cirq.ActOnStateVectorArgs(qubits=cirq.LineQubit.range(1), initial_state=0) + args = cirq.StateVectorSimulationState(qubits=cirq.LineQubit.range(1), initial_state=0) copy = args.copy(deep_copy_buffers=False) assert copy.available_buffer is args.available_buffer @@ -65,7 +65,7 @@ def num_qubits(self) -> int: def _decompose_(self, qubits): yield cirq.X(*qubits) - args = cirq.ActOnStateVectorArgs( + args = cirq.StateVectorSimulationState( available_buffer=np.empty((2, 2, 2), dtype=np.complex64), qubits=cirq.LineQubit.range(3), prng=np.random.RandomState(), @@ -83,7 +83,7 @@ def test_cannot_act(): class NoDetails: pass - args = cirq.ActOnStateVectorArgs( + args = cirq.StateVectorSimulationState( available_buffer=np.empty((2, 2, 2), dtype=np.complex64), qubits=cirq.LineQubit.range(3), prng=np.random.RandomState(), @@ -107,7 +107,7 @@ def _kraus_(self): mock_prng = mock.Mock() mock_prng.random.return_value = 1 / 3 + 1e-6 - args = cirq.ActOnStateVectorArgs( + args = cirq.StateVectorSimulationState( available_buffer=np.empty_like(initial_state), qubits=cirq.LineQubit.range(4), prng=mock_prng, @@ -126,7 +126,7 @@ def _kraus_(self): ) mock_prng.random.return_value = 1 / 3 - 1e-6 - args = cirq.ActOnStateVectorArgs( + args = cirq.StateVectorSimulationState( available_buffer=np.empty_like(initial_state), qubits=cirq.LineQubit.range(4), prng=mock_prng, @@ -163,7 +163,7 @@ def _kraus_(self): def get_result(state: np.ndarray, sample: float): mock_prng.random.return_value = sample - args = cirq.ActOnStateVectorArgs( + args = cirq.StateVectorSimulationState( available_buffer=np.empty_like(state), qubits=cirq.LineQubit.range(4), prng=mock_prng, @@ -218,7 +218,7 @@ def _kraus_(self): mock_prng = mock.Mock() mock_prng.random.return_value = 0.9999 - args = cirq.ActOnStateVectorArgs( + args = cirq.StateVectorSimulationState( available_buffer=np.empty(2, dtype=np.complex64), qubits=cirq.LineQubit.range(1), prng=mock_prng, @@ -267,7 +267,7 @@ def test_measured_mixture(): def test_with_qubits(): - original = cirq.ActOnStateVectorArgs( + original = cirq.StateVectorSimulationState( qubits=cirq.LineQubit.range(2), initial_state=1, dtype=np.complex64 ) extened = original.with_qubits(cirq.LineQubit.range(2, 4)) @@ -286,7 +286,7 @@ def test_qid_shape_error(): def test_deprecated_methods(): - args = cirq.ActOnStateVectorArgs(qubits=[cirq.LineQubit(0)]) + args = cirq.StateVectorSimulationState(qubits=[cirq.LineQubit(0)]) with cirq.testing.assert_deprecated('unintentionally made public', deadline='v0.16'): args.subspace_index([0], 0) with cirq.testing.assert_deprecated('unintentionally made public', deadline='v0.16'): diff --git a/cirq-core/cirq/sim/clifford/__init__.py b/cirq-core/cirq/sim/clifford/__init__.py index d466ca209b5..1044fead601 100644 --- a/cirq-core/cirq/sim/clifford/__init__.py +++ b/cirq-core/cirq/sim/clifford/__init__.py @@ -1,9 +1,9 @@ # pylint: disable=wrong-or-nonexistent-copyright-notice -from cirq.sim.clifford.act_on_clifford_tableau_args import ActOnCliffordTableauArgs +from cirq.sim.clifford.act_on_clifford_tableau_args import CliffordTableauSimulationState -from cirq.sim.clifford.act_on_stabilizer_ch_form_args import ActOnStabilizerCHFormArgs +from cirq.sim.clifford.act_on_stabilizer_ch_form_args import CHFormSimulationState -from cirq.sim.clifford.act_on_stabilizer_args import ActOnStabilizerArgs +from cirq.sim.clifford.act_on_stabilizer_args import StabilizerSimulationState from cirq.sim.clifford.stabilizer_state_ch_form import StabilizerStateChForm diff --git a/cirq-core/cirq/sim/clifford/act_on_clifford_tableau_args.py b/cirq-core/cirq/sim/clifford/act_on_clifford_tableau_args.py index 0008f859839..b9a92b58ae6 100644 --- a/cirq-core/cirq/sim/clifford/act_on_clifford_tableau_args.py +++ b/cirq-core/cirq/sim/clifford/act_on_clifford_tableau_args.py @@ -19,13 +19,13 @@ import numpy as np from cirq.qis import clifford_tableau -from cirq.sim.clifford.act_on_stabilizer_args import ActOnStabilizerArgs +from cirq.sim.clifford.act_on_stabilizer_args import StabilizerSimulationState if TYPE_CHECKING: import cirq -class ActOnCliffordTableauArgs(ActOnStabilizerArgs[clifford_tableau.CliffordTableau]): +class CliffordTableauSimulationState(StabilizerSimulationState[clifford_tableau.CliffordTableau]): """State and context for an operation acting on a clifford tableau.""" def __init__( @@ -35,7 +35,7 @@ def __init__( qubits: Optional[Sequence['cirq.Qid']] = None, classical_data: Optional['cirq.ClassicalDataStore'] = None, ): - """Inits ActOnCliffordTableauArgs. + """Inits CliffordTableauSimulationState. Args: tableau: The CliffordTableau to act on. Operations are expected to diff --git a/cirq-core/cirq/sim/clifford/act_on_clifford_tableau_args_test.py b/cirq-core/cirq/sim/clifford/act_on_clifford_tableau_args_test.py index 8135841841e..dfa7f4fa90f 100644 --- a/cirq-core/cirq/sim/clifford/act_on_clifford_tableau_args_test.py +++ b/cirq-core/cirq/sim/clifford/act_on_clifford_tableau_args_test.py @@ -33,7 +33,7 @@ def _unitary_(self): return np.array([[0, -1j], [1j, 0]]) original_tableau = cirq.CliffordTableau(num_qubits=3) - args = cirq.ActOnCliffordTableauArgs( + args = cirq.CliffordTableauSimulationState( tableau=original_tableau.copy(), qubits=cirq.LineQubit.range(3), prng=np.random.RandomState(), @@ -42,13 +42,13 @@ def _unitary_(self): cirq.act_on(UnitaryXGate(), args, [cirq.LineQubit(1)]) assert args.tableau == cirq.CliffordTableau(num_qubits=3, initial_state=2) - args = cirq.ActOnCliffordTableauArgs( + args = cirq.CliffordTableauSimulationState( tableau=original_tableau.copy(), qubits=cirq.LineQubit.range(3), prng=np.random.RandomState(), ) cirq.act_on(UnitaryYGate(), args, [cirq.LineQubit(1)]) - expected_args = cirq.ActOnCliffordTableauArgs( + expected_args = cirq.CliffordTableauSimulationState( tableau=original_tableau.copy(), qubits=cirq.LineQubit.range(3), prng=np.random.RandomState(), @@ -64,7 +64,7 @@ class NoDetails: class NoDetailsSingleQubitGate(cirq.testing.SingleQubitGate): pass - args = cirq.ActOnCliffordTableauArgs( + args = cirq.CliffordTableauSimulationState( tableau=cirq.CliffordTableau(num_qubits=3), qubits=cirq.LineQubit.range(3), prng=np.random.RandomState(), @@ -78,13 +78,13 @@ class NoDetailsSingleQubitGate(cirq.testing.SingleQubitGate): def test_copy(): - args = cirq.ActOnCliffordTableauArgs( + args = cirq.CliffordTableauSimulationState( tableau=cirq.CliffordTableau(num_qubits=3), qubits=cirq.LineQubit.range(3), prng=np.random.RandomState(), ) args1 = args.copy() - assert isinstance(args1, cirq.ActOnCliffordTableauArgs) + assert isinstance(args1, cirq.CliffordTableauSimulationState) assert args is not args1 assert args.tableau is not args1.tableau assert args.tableau == args1.tableau diff --git a/cirq-core/cirq/sim/clifford/act_on_stabilizer_args.py b/cirq-core/cirq/sim/clifford/act_on_stabilizer_args.py index d95b072eac1..4b48fc99fdb 100644 --- a/cirq-core/cirq/sim/clifford/act_on_stabilizer_args.py +++ b/cirq-core/cirq/sim/clifford/act_on_stabilizer_args.py @@ -22,7 +22,7 @@ from cirq.ops import common_gates, global_phase_op, matrix_gates, swap_gates from cirq.ops.clifford_gate import SingleQubitCliffordGate from cirq.protocols import has_unitary, num_qubits, unitary -from cirq.sim.act_on_args import ActOnArgs +from cirq.sim.act_on_args import DenseSimulationState from cirq.type_workarounds import NotImplementedType if TYPE_CHECKING: @@ -32,8 +32,8 @@ TStabilizerState = TypeVar('TStabilizerState', bound='cirq.StabilizerState') -class ActOnStabilizerArgs( - ActOnArgs[TStabilizerState], Generic[TStabilizerState], metaclass=abc.ABCMeta +class StabilizerSimulationState( + DenseSimulationState[TStabilizerState], Generic[TStabilizerState], metaclass=abc.ABCMeta ): """Abstract wrapper around a stabilizer state for the act_on protocol.""" @@ -58,7 +58,7 @@ def __init__( qubits: Optional[Sequence['cirq.Qid']] = None, classical_data: Optional['cirq.ClassicalDataStore'] = None, ): - """Initializes the ActOnStabilizerArgs. + """Initializes the StabilizerSimulationState. Args: state: The quantum stabilizer state to use in the simulation or diff --git a/cirq-core/cirq/sim/clifford/act_on_stabilizer_args_test.py b/cirq-core/cirq/sim/clifford/act_on_stabilizer_args_test.py index e72cfc5dbe3..50559d9cc67 100644 --- a/cirq-core/cirq/sim/clifford/act_on_stabilizer_args_test.py +++ b/cirq-core/cirq/sim/clifford/act_on_stabilizer_args_test.py @@ -22,7 +22,7 @@ def test_apply_gate(): q0, q1 = cirq.LineQubit.range(2) state = Mock() - args = cirq.ActOnStabilizerArgs(state=state, qubits=[q0, q1]) + args = cirq.StabilizerSimulationState(state=state, qubits=[q0, q1]) assert args._strat_apply_gate(cirq.X, [q0]) is True state.apply_x.assert_called_with(0, 1.0, 0.0) @@ -83,7 +83,7 @@ def test_apply_gate(): def test_apply_mixture(): q0 = cirq.LineQubit(0) state = Mock() - args = cirq.ActOnStabilizerArgs(state=state, qubits=[q0]) + args = cirq.StabilizerSimulationState(state=state, qubits=[q0]) for _ in range(100): assert args._strat_apply_mixture(cirq.BitFlipChannel(0.5), [q0]) is True @@ -94,7 +94,7 @@ def test_apply_mixture(): def test_act_from_single_qubit_decompose(): q0 = cirq.LineQubit(0) state = Mock() - args = cirq.ActOnStabilizerArgs(state=state, qubits=[q0]) + args = cirq.StabilizerSimulationState(state=state, qubits=[q0]) assert ( args._strat_act_from_single_qubit_decompose( cirq.MatrixGate(np.array([[0, 1], [1, 0]])), [q0] @@ -114,13 +114,13 @@ def _qid_shape_(self): q0 = cirq.LineQubit(0) state = Mock() - args = cirq.ActOnStabilizerArgs(state=state, qubits=[q0]) + args = cirq.StabilizerSimulationState(state=state, qubits=[q0]) assert args._strat_decompose(XContainer(), [q0]) is True state.apply_x.assert_called_with(0, 1.0, 0.0) def test_deprecated(): with cirq.testing.assert_deprecated('log_of_measurement_results', deadline='v0.16', count=2): - _ = cirq.ActOnStabilizerArgs(state=0, log_of_measurement_results={}) + _ = cirq.StabilizerSimulationState(state=0, log_of_measurement_results={}) with cirq.testing.assert_deprecated('positional', deadline='v0.16'): - _ = cirq.ActOnStabilizerArgs(0) + _ = cirq.StabilizerSimulationState(0) diff --git a/cirq-core/cirq/sim/clifford/act_on_stabilizer_ch_form_args.py b/cirq-core/cirq/sim/clifford/act_on_stabilizer_ch_form_args.py index 66069f7ea4f..377680c3239 100644 --- a/cirq-core/cirq/sim/clifford/act_on_stabilizer_ch_form_args.py +++ b/cirq-core/cirq/sim/clifford/act_on_stabilizer_ch_form_args.py @@ -18,14 +18,14 @@ from cirq._compat import proper_repr from cirq.sim.clifford import stabilizer_state_ch_form -from cirq.sim.clifford.act_on_stabilizer_args import ActOnStabilizerArgs +from cirq.sim.clifford.act_on_stabilizer_args import StabilizerSimulationState if TYPE_CHECKING: import cirq -class ActOnStabilizerCHFormArgs( - ActOnStabilizerArgs[stabilizer_state_ch_form.StabilizerStateChForm] +class CHFormSimulationState( + StabilizerSimulationState[stabilizer_state_ch_form.StabilizerStateChForm] ): """Wrapper around a stabilizer state in CH form for the act_on protocol.""" @@ -69,7 +69,7 @@ def __init__( def __repr__(self) -> str: return ( - 'cirq.ActOnStabilizerCHFormArgs(' + 'cirq.CHFormSimulationState(' f'initial_state={proper_repr(self.state)},' f' qubits={self.qubits!r},' f' classical_data={self.classical_data!r})' diff --git a/cirq-core/cirq/sim/clifford/act_on_stabilizer_ch_form_args_test.py b/cirq-core/cirq/sim/clifford/act_on_stabilizer_ch_form_args_test.py index 32d6d7aa922..067a6f09cc3 100644 --- a/cirq-core/cirq/sim/clifford/act_on_stabilizer_ch_form_args_test.py +++ b/cirq-core/cirq/sim/clifford/act_on_stabilizer_ch_form_args_test.py @@ -19,17 +19,17 @@ def test_init_state(): - args = cirq.ActOnStabilizerCHFormArgs(qubits=cirq.LineQubit.range(1), initial_state=1) + args = cirq.CHFormSimulationState(qubits=cirq.LineQubit.range(1), initial_state=1) np.testing.assert_allclose(args.state.state_vector(), [0, 1]) with pytest.raises(ValueError, match='Must specify qubits'): - _ = cirq.ActOnStabilizerCHFormArgs(initial_state=1) + _ = cirq.CHFormSimulationState(initial_state=1) def test_cannot_act(): class NoDetails(cirq.testing.SingleQubitGate): pass - args = cirq.ActOnStabilizerCHFormArgs(qubits=[], prng=np.random.RandomState()) + args = cirq.CHFormSimulationState(qubits=[], prng=np.random.RandomState()) with pytest.raises(TypeError, match="Failed to act"): cirq.act_on(NoDetails(), args, qubits=()) @@ -38,13 +38,13 @@ class NoDetails(cirq.testing.SingleQubitGate): def test_gate_with_act_on(): class CustomGate(cirq.testing.SingleQubitGate): def _act_on_(self, args, qubits): - if isinstance(args, cirq.ActOnStabilizerCHFormArgs): + if isinstance(args, cirq.CHFormSimulationState): qubit = args.qubit_map[qubits[0]] args.state.gamma[qubit] += 1 return True state = cirq.StabilizerStateChForm(num_qubits=3) - args = cirq.ActOnStabilizerCHFormArgs( + args = cirq.CHFormSimulationState( qubits=cirq.LineQubit.range(3), prng=np.random.RandomState(), initial_state=state ) @@ -61,11 +61,11 @@ def num_qubits(self) -> int: def _unitary_(self): return np.array([[0, -1j], [1j, 0]]) - args = cirq.ActOnStabilizerCHFormArgs( + args = cirq.CHFormSimulationState( qubits=cirq.LineQubit.range(3), prng=np.random.RandomState() ) cirq.act_on(UnitaryYGate(), args, [cirq.LineQubit(1)]) - expected_args = cirq.ActOnStabilizerCHFormArgs( + expected_args = cirq.CHFormSimulationState( qubits=cirq.LineQubit.range(3), prng=np.random.RandomState() ) cirq.act_on(cirq.Y, expected_args, [cirq.LineQubit(1)]) @@ -80,11 +80,11 @@ def num_qubits(self) -> int: def _unitary_(self): return np.array([[1, 1], [1, -1]]) / (2**0.5) - args = cirq.ActOnStabilizerCHFormArgs( + args = cirq.CHFormSimulationState( qubits=cirq.LineQubit.range(3), prng=np.random.RandomState() ) cirq.act_on(UnitaryHGate(), args, [cirq.LineQubit(1)]) - expected_args = cirq.ActOnStabilizerCHFormArgs( + expected_args = cirq.CHFormSimulationState( qubits=cirq.LineQubit.range(3), prng=np.random.RandomState() ) cirq.act_on(cirq.H, expected_args, [cirq.LineQubit(1)]) @@ -92,11 +92,11 @@ def _unitary_(self): def test_copy(): - args = cirq.ActOnStabilizerCHFormArgs( + args = cirq.CHFormSimulationState( qubits=cirq.LineQubit.range(3), prng=np.random.RandomState() ) args1 = args.copy() - assert isinstance(args1, cirq.ActOnStabilizerCHFormArgs) + assert isinstance(args1, cirq.CHFormSimulationState) assert args is not args1 assert args.state is not args1.state np.testing.assert_equal(args.state.state_vector(), args1.state.state_vector()) diff --git a/cirq-core/cirq/sim/clifford/clifford_simulator.py b/cirq-core/cirq/sim/clifford/clifford_simulator.py index 1919222d618..6fc42e88077 100644 --- a/cirq-core/cirq/sim/clifford/clifford_simulator.py +++ b/cirq-core/cirq/sim/clifford/clifford_simulator.py @@ -43,7 +43,7 @@ class CliffordSimulator( simulator_base.SimulatorBase[ 'cirq.CliffordSimulatorStepResult', 'cirq.CliffordTrialResult', - 'cirq.ActOnStabilizerCHFormArgs', + 'cirq.CHFormSimulationState', ] ): """An efficient simulator for Clifford circuits.""" @@ -69,11 +69,11 @@ def is_supported_operation(op: 'cirq.Operation') -> bool: def _create_partial_act_on_args( self, - initial_state: Union[int, 'cirq.ActOnStabilizerCHFormArgs'], + initial_state: Union[int, 'cirq.CHFormSimulationState'], qubits: Sequence['cirq.Qid'], classical_data: 'cirq.ClassicalDataStore', - ) -> 'cirq.ActOnStabilizerCHFormArgs': - """Creates the ActOnStabilizerChFormArgs for a circuit. + ) -> 'cirq.CHFormSimulationState': + """Creates the CHFormSimulationState for a circuit. Args: initial_state: The initial state for the simulation in the @@ -86,12 +86,12 @@ def _create_partial_act_on_args( simulation. Returns: - ActOnStabilizerChFormArgs for the circuit. + CHFormSimulationState for the circuit. """ - if isinstance(initial_state, clifford.ActOnStabilizerCHFormArgs): + if isinstance(initial_state, clifford.CHFormSimulationState): return initial_state - return clifford.ActOnStabilizerCHFormArgs( + return clifford.CHFormSimulationState( prng=self._prng, classical_data=classical_data, qubits=qubits, @@ -99,7 +99,7 @@ def _create_partial_act_on_args( ) def _create_step_result( - self, sim_state: 'cirq.OperationTarget[clifford.ActOnStabilizerCHFormArgs]' + self, sim_state: 'cirq.SimulationState[clifford.CHFormSimulationState]' ): return CliffordSimulatorStepResult(sim_state=sim_state) @@ -107,7 +107,7 @@ def _create_simulator_trial_result( self, params: 'cirq.ParamResolver', measurements: Dict[str, np.ndarray], - final_simulator_state: 'cirq.OperationTarget[cirq.ActOnStabilizerCHFormArgs]', + final_simulator_state: 'cirq.SimulationState[cirq.CHFormSimulationState]', ): return CliffordTrialResult( @@ -116,14 +116,14 @@ def _create_simulator_trial_result( class CliffordTrialResult( - simulator_base.SimulationTrialResultBase['clifford.ActOnStabilizerCHFormArgs'] + simulator_base.SimulationTrialResultBase['clifford.CHFormSimulationState'] ): @simulator._deprecated_step_result_parameter(old_position=3) def __init__( self, params: 'cirq.ParamResolver', measurements: Dict[str, np.ndarray], - final_simulator_state: 'cirq.OperationTarget[cirq.ActOnStabilizerCHFormArgs]', + final_simulator_state: 'cirq.SimulationState[cirq.CHFormSimulationState]', ) -> None: super().__init__( params=params, measurements=measurements, final_simulator_state=final_simulator_state @@ -146,13 +146,13 @@ def _repr_pretty_(self, p: Any, cycle: bool): p.text("cirq.CliffordTrialResult(...)" if cycle else self.__str__()) -class CliffordSimulatorStepResult(simulator_base.StepResultBase['cirq.ActOnStabilizerCHFormArgs']): +class CliffordSimulatorStepResult(simulator_base.StepResultBase['cirq.CHFormSimulationState']): """A `StepResult` that includes `StateVectorMixin` methods.""" - def __init__(self, sim_state: 'cirq.OperationTarget[clifford.ActOnStabilizerCHFormArgs]'): + def __init__(self, sim_state: 'cirq.SimulationState[clifford.CHFormSimulationState]'): """Results of a step of the simulator. Attributes: - sim_state: The qubit:ActOnArgs lookup for this step. + sim_state: The qubit:DenseSimulationState lookup for this step. """ super().__init__(sim_state) self._clifford_state = None @@ -238,7 +238,7 @@ def state_vector(self): return self.ch_form.state_vector() def apply_unitary(self, op: 'cirq.Operation'): - ch_form_args = clifford.ActOnStabilizerCHFormArgs( + ch_form_args = clifford.CHFormSimulationState( prng=np.random.RandomState(), qubits=self.qubit_map.keys(), initial_state=self.ch_form ) try: @@ -268,7 +268,7 @@ def apply_measurement( state = self.copy() classical_data = value.ClassicalDataDictionaryStore() - ch_form_args = clifford.ActOnStabilizerCHFormArgs( + ch_form_args = clifford.CHFormSimulationState( prng=prng, classical_data=classical_data, qubits=self.qubit_map.keys(), diff --git a/cirq-core/cirq/sim/clifford/clifford_simulator_test.py b/cirq-core/cirq/sim/clifford/clifford_simulator_test.py index c3bfca63d90..a2774caf357 100644 --- a/cirq-core/cirq/sim/clifford/clifford_simulator_test.py +++ b/cirq-core/cirq/sim/clifford/clifford_simulator_test.py @@ -211,7 +211,7 @@ def test_clifford_state_initial_state(): def test_clifford_trial_result_repr(): q0 = cirq.LineQubit(0) - final_simulator_state = cirq.ActOnStabilizerCHFormArgs(qubits=[q0]) + final_simulator_state = cirq.CHFormSimulationState(qubits=[q0]) assert ( repr( cirq.CliffordTrialResult( @@ -222,7 +222,7 @@ def test_clifford_trial_result_repr(): ) == "cirq.SimulationTrialResult(params=cirq.ParamResolver({}), " "measurements={'m': array([[1]])}, " - "final_simulator_state=cirq.ActOnStabilizerCHFormArgs(" + "final_simulator_state=cirq.CHFormSimulationState(" "initial_state=StabilizerStateChForm(num_qubits=1), " "qubits=(cirq.LineQubit(0),), " "classical_data=cirq.ClassicalDataDictionaryStore()))" @@ -231,7 +231,7 @@ def test_clifford_trial_result_repr(): def test_clifford_trial_result_str(): q0 = cirq.LineQubit(0) - final_simulator_state = cirq.ActOnStabilizerCHFormArgs(qubits=[q0]) + final_simulator_state = cirq.CHFormSimulationState(qubits=[q0]) assert ( str( cirq.CliffordTrialResult( @@ -247,7 +247,7 @@ def test_clifford_trial_result_str(): def test_clifford_trial_result_repr_pretty(): q0 = cirq.LineQubit(0) - final_simulator_state = cirq.ActOnStabilizerCHFormArgs(qubits=[q0]) + final_simulator_state = cirq.CHFormSimulationState(qubits=[q0]) result = cirq.CliffordTrialResult( params=cirq.ParamResolver({}), measurements={'m': np.array([[1]])}, diff --git a/cirq-core/cirq/sim/clifford/stabilizer_sampler.py b/cirq-core/cirq/sim/clifford/stabilizer_sampler.py index 73bab9091f1..7184fc71e46 100644 --- a/cirq-core/cirq/sim/clifford/stabilizer_sampler.py +++ b/cirq-core/cirq/sim/clifford/stabilizer_sampler.py @@ -19,7 +19,7 @@ import cirq from cirq import protocols, value from cirq.qis.clifford_tableau import CliffordTableau -from cirq.sim.clifford.act_on_clifford_tableau_args import ActOnCliffordTableauArgs +from cirq.sim.clifford.act_on_clifford_tableau_args import CliffordTableauSimulationState from cirq.work import sampler @@ -53,7 +53,7 @@ def _run(self, circuit: 'cirq.AbstractCircuit', repetitions: int) -> Dict[str, n qubits = circuit.all_qubits() for _ in range(repetitions): - state = ActOnCliffordTableauArgs( + state = CliffordTableauSimulationState( CliffordTableau(num_qubits=len(qubits)), qubits=list(qubits), prng=self._prng ) for op in circuit.all_operations(): diff --git a/cirq-core/cirq/sim/clifford/stabilizer_state_ch_form_test.py b/cirq-core/cirq/sim/clifford/stabilizer_state_ch_form_test.py index 30ef642a745..ec8127e2ab9 100644 --- a/cirq-core/cirq/sim/clifford/stabilizer_state_ch_form_test.py +++ b/cirq-core/cirq/sim/clifford/stabilizer_state_ch_form_test.py @@ -66,7 +66,7 @@ def test_run(): state = cirq.StabilizerStateChForm(num_qubits=3) classical_data = cirq.ClassicalDataDictionaryStore() for op in circuit.all_operations(): - args = cirq.ActOnStabilizerCHFormArgs( + args = cirq.CHFormSimulationState( qubits=list(circuit.all_qubits()), prng=np.random.RandomState(), classical_data=classical_data, diff --git a/cirq-core/cirq/sim/density_matrix_simulator.py b/cirq-core/cirq/sim/density_matrix_simulator.py index 1a3188e654d..5d5efbee27e 100644 --- a/cirq-core/cirq/sim/density_matrix_simulator.py +++ b/cirq-core/cirq/sim/density_matrix_simulator.py @@ -29,7 +29,7 @@ class DensityMatrixSimulator( simulator_base.SimulatorBase[ 'cirq.DensityMatrixStepResult', 'cirq.DensityMatrixTrialResult', - 'cirq.ActOnDensityMatrixArgs', + 'cirq.DensityMatrixSimulationState', ], simulator.SimulatesExpectationValues, ): @@ -147,11 +147,11 @@ def __init__( def _create_partial_act_on_args( self, - initial_state: Union[np.ndarray, 'cirq.STATE_VECTOR_LIKE', 'cirq.ActOnDensityMatrixArgs'], + initial_state: Union[np.ndarray, 'cirq.STATE_VECTOR_LIKE', 'cirq.DensityMatrixSimulationState'], qubits: Sequence['cirq.Qid'], classical_data: 'cirq.ClassicalDataStore', - ) -> 'cirq.ActOnDensityMatrixArgs': - """Creates the ActOnDensityMatrixArgs for a circuit. + ) -> 'cirq.DensityMatrixSimulationState': + """Creates the DensityMatrixSimulationState for a circuit. Args: initial_state: The initial state for the simulation in the @@ -163,12 +163,12 @@ def _create_partial_act_on_args( simulation. Returns: - ActOnDensityMatrixArgs for the circuit. + DensityMatrixSimulationState for the circuit. """ - if isinstance(initial_state, act_on_density_matrix_args.ActOnDensityMatrixArgs): + if isinstance(initial_state, act_on_density_matrix_args.DensityMatrixSimulationState): return initial_state - return act_on_density_matrix_args.ActOnDensityMatrixArgs( + return act_on_density_matrix_args.DensityMatrixSimulationState( qubits=qubits, prng=self._prng, classical_data=classical_data, @@ -179,14 +179,14 @@ def _create_partial_act_on_args( def _can_be_in_run_prefix(self, val: Any): return not protocols.measurement_keys_touched(val) - def _create_step_result(self, sim_state: 'cirq.OperationTarget[cirq.ActOnDensityMatrixArgs]'): + def _create_step_result(self, sim_state: 'cirq.SimulationState[cirq.DensityMatrixSimulationState]'): return DensityMatrixStepResult(sim_state=sim_state, dtype=self._dtype) def _create_simulator_trial_result( self, params: 'cirq.ParamResolver', measurements: Dict[str, np.ndarray], - final_simulator_state: 'cirq.OperationTarget[cirq.ActOnDensityMatrixArgs]', + final_simulator_state: 'cirq.SimulationState[cirq.DensityMatrixSimulationState]', ) -> 'cirq.DensityMatrixTrialResult': return DensityMatrixTrialResult( params=params, measurements=measurements, final_simulator_state=final_simulator_state @@ -227,7 +227,7 @@ def simulate_expectation_values_sweep( return swept_evs -class DensityMatrixStepResult(simulator_base.StepResultBase['cirq.ActOnDensityMatrixArgs']): +class DensityMatrixStepResult(simulator_base.StepResultBase['cirq.DensityMatrixSimulationState']): """A single step in the simulation of the DensityMatrixSimulator. Attributes: @@ -243,14 +243,14 @@ class DensityMatrixStepResult(simulator_base.StepResultBase['cirq.ActOnDensityMa ) def __init__( self, - sim_state: 'cirq.OperationTarget[cirq.ActOnDensityMatrixArgs]', + sim_state: 'cirq.SimulationState[cirq.DensityMatrixSimulationState]', simulator: 'cirq.DensityMatrixSimulator' = None, dtype: 'DTypeLike' = np.complex64, ): """DensityMatrixStepResult. Args: - sim_state: The qubit:ActOnArgs lookup for this step. + sim_state: The qubit:DenseSimulationState lookup for this step. simulator: The simulator used to create this. dtype: The `numpy.dtype` used by the simulation. One of `numpy.complex64` or `numpy.complex128`. @@ -342,7 +342,7 @@ def __repr__(self) -> str: @value.value_equality(unhashable=True) class DensityMatrixTrialResult( - simulator_base.SimulationTrialResultBase[act_on_density_matrix_args.ActOnDensityMatrixArgs] + simulator_base.SimulationTrialResultBase[act_on_density_matrix_args.DensityMatrixSimulationState] ): """A `SimulationTrialResult` for `DensityMatrixSimulator` runs. @@ -386,7 +386,7 @@ def __init__( self, params: 'cirq.ParamResolver', measurements: Dict[str, np.ndarray], - final_simulator_state: 'cirq.OperationTarget[cirq.ActOnDensityMatrixArgs]', + final_simulator_state: 'cirq.SimulationState[cirq.DensityMatrixSimulationState]', ) -> None: super().__init__( params=params, measurements=measurements, final_simulator_state=final_simulator_state diff --git a/cirq-core/cirq/sim/density_matrix_simulator_test.py b/cirq-core/cirq/sim/density_matrix_simulator_test.py index fc805a70554..cde1ba9a195 100644 --- a/cirq-core/cirq/sim/density_matrix_simulator_test.py +++ b/cirq-core/cirq/sim/density_matrix_simulator_test.py @@ -976,7 +976,7 @@ def test_density_matrix_simulator_state_repr(): def test_density_matrix_trial_result_eq(): q0 = cirq.LineQubit(0) - final_simulator_state = cirq.ActOnDensityMatrixArgs( + final_simulator_state = cirq.DensityMatrixSimulationState( initial_state=np.ones((2, 2)) * 0.5, qubits=[q0] ) eq = cirq.testing.EqualsTester() @@ -1010,7 +1010,7 @@ def test_density_matrix_trial_result_eq(): def test_density_matrix_trial_result_qid_shape(): q0, q1 = cirq.LineQubit.range(2) - final_simulator_state = cirq.ActOnDensityMatrixArgs( + final_simulator_state = cirq.DensityMatrixSimulationState( initial_state=np.ones((4, 4)) / 4, qubits=[q0, q1] ) assert cirq.qid_shape( @@ -1021,7 +1021,7 @@ def test_density_matrix_trial_result_qid_shape(): ) ) == (2, 2) q0, q1 = cirq.LineQid.for_qid_shape((3, 4)) - final_simulator_state = cirq.ActOnDensityMatrixArgs( + final_simulator_state = cirq.DensityMatrixSimulationState( initial_state=np.ones((12, 12)) / 12, qubits=[q0, q1] ) assert cirq.qid_shape( @@ -1036,7 +1036,7 @@ def test_density_matrix_trial_result_qid_shape(): def test_density_matrix_trial_result_repr(): q0 = cirq.LineQubit(0) dtype = np.complex64 - final_simulator_state = cirq.ActOnDensityMatrixArgs( + final_simulator_state = cirq.DensityMatrixSimulationState( available_buffer=[], qid_shape=(2,), prng=np.random.RandomState(0), @@ -1053,7 +1053,7 @@ def test_density_matrix_trial_result_repr(): "cirq.DensityMatrixTrialResult(" "params=cirq.ParamResolver({'s': 1}), " "measurements={'m': np.array([[1]], dtype=np.int32)}, " - "final_simulator_state=cirq.ActOnDensityMatrixArgs(" + "final_simulator_state=cirq.DensityMatrixSimulationState(" "initial_state=np.array([[(0.5+0j), (0.5+0j)], [(0.5+0j), (0.5+0j)]], dtype=np.complex64), " "qid_shape=(2,), " "qubits=(cirq.LineQubit(0),), " @@ -1124,7 +1124,7 @@ def test_works_on_pauli_string(): def test_density_matrix_trial_result_str(): q0 = cirq.LineQubit(0) dtype = np.complex64 - final_simulator_state = cirq.ActOnDensityMatrixArgs( + final_simulator_state = cirq.DensityMatrixSimulationState( available_buffer=[], qid_shape=(2,), prng=np.random.RandomState(0), @@ -1149,7 +1149,7 @@ def test_density_matrix_trial_result_str(): def test_density_matrix_trial_result_repr_pretty(): q0 = cirq.LineQubit(0) dtype = np.complex64 - final_simulator_state = cirq.ActOnDensityMatrixArgs( + final_simulator_state = cirq.DensityMatrixSimulationState( available_buffer=[], qid_shape=(2,), prng=np.random.RandomState(0), diff --git a/cirq-core/cirq/sim/operation_target.py b/cirq-core/cirq/sim/operation_target.py index 835062ff128..79495fbd514 100644 --- a/cirq-core/cirq/sim/operation_target.py +++ b/cirq-core/cirq/sim/operation_target.py @@ -37,11 +37,11 @@ import cirq -TSelfTarget = TypeVar('TSelfTarget', bound='OperationTarget') -TActOnArgs = TypeVar('TActOnArgs', bound='cirq.ActOnArgs') +TSelfTarget = TypeVar('TSelfTarget', bound='SimulationState') +TDenseSimulationState = TypeVar('TDenseSimulationState', bound='cirq.DenseSimulationState') -class OperationTarget(Generic[TActOnArgs], metaclass=abc.ABCMeta): +class SimulationState(Generic[TDenseSimulationState], metaclass=abc.ABCMeta): """An interface for quantum states as targets for operations.""" def __init__( @@ -77,7 +77,7 @@ def classical_data(self) -> 'cirq.ClassicalDataStoreReader': return self._classical_data @abc.abstractmethod - def create_merged_state(self) -> TActOnArgs: + def create_merged_state(self) -> TDenseSimulationState: """Creates a final merged state.""" @abc.abstractmethod @@ -124,7 +124,7 @@ def sample( ) -> np.ndarray: """Samples the state value.""" - def __getitem__(self, item: Optional['cirq.Qid']) -> TActOnArgs: + def __getitem__(self, item: Optional['cirq.Qid']) -> TDenseSimulationState: """Gets the item associated with the qubit.""" def __len__(self) -> int: diff --git a/cirq-core/cirq/sim/simulator.py b/cirq-core/cirq/sim/simulator.py index 2d9a160474d..28082913541 100644 --- a/cirq-core/cirq/sim/simulator.py +++ b/cirq-core/cirq/sim/simulator.py @@ -50,7 +50,7 @@ import numpy as np from cirq import _compat, circuits, ops, protocols, study, value, work -from cirq.sim.operation_target import OperationTarget +from cirq.sim.operation_target import SimulationState if TYPE_CHECKING: import cirq @@ -586,7 +586,7 @@ def simulate_sweep_iter( is often used in specifying the initial state, i.e. the ordering of the computational basis states. initial_state: The initial state for the simulation. This can be - either a raw state or an `OperationTarget`. The form of the + either a raw state or an `SimulationState`. The form of the raw state depends on the simulation implementation. See documentation of the implementing class for details. @@ -598,7 +598,7 @@ def simulate_sweep_iter( for param_resolver in study.to_resolvers(params): state = ( initial_state.copy() - if isinstance(initial_state, OperationTarget) + if isinstance(initial_state, SimulationState) else initial_state ) all_step_results = self.simulate_moment_steps( @@ -643,7 +643,7 @@ def simulate_moment_steps( is often used in specifying the initial state, i.e. the ordering of the computational basis states. initial_state: The initial state for the simulation. This can be - either a raw state or a `TActOnArgs`. The form of the + either a raw state or a `TDenseSimulationState`. The form of the raw state depends on the simulation implementation. See documentation of the implementing class for details. diff --git a/cirq-core/cirq/sim/simulator_base.py b/cirq-core/cirq/sim/simulator_base.py index e147a708c1a..acdbbac57f0 100644 --- a/cirq-core/cirq/sim/simulator_base.py +++ b/cirq-core/cirq/sim/simulator_base.py @@ -34,10 +34,10 @@ import numpy as np from cirq import ops, protocols, study, value, devices -from cirq.sim import ActOnArgsContainer +from cirq.sim import SimulationProductState from cirq.sim import simulator -from cirq.sim.act_on_args import TActOnArgs -from cirq.sim.operation_target import OperationTarget +from cirq.sim.act_on_args import TDenseSimulationState +from cirq.sim.operation_target import SimulationState from cirq.sim.simulator import ( TSimulationTrialResult, SimulatesIntermediateState, @@ -56,9 +56,9 @@ class SimulatorBase( - Generic[TStepResultBase, TSimulationTrialResult, TActOnArgs], + Generic[TStepResultBase, TSimulationTrialResult, TDenseSimulationState], SimulatesIntermediateState[ - TStepResultBase, TSimulationTrialResult, OperationTarget[TActOnArgs] + TStepResultBase, TSimulationTrialResult, SimulationState[TDenseSimulationState] ], SimulatesSamples, metaclass=abc.ABCMeta, @@ -119,8 +119,8 @@ def _create_partial_act_on_args( initial_state: Any, qubits: Sequence['cirq.Qid'], classical_data: 'cirq.ClassicalDataStore', - ) -> TActOnArgs: - """Creates an instance of the TActOnArgs class for the simulator. + ) -> TDenseSimulationState: + """Creates an instance of the TDenseSimulationState class for the simulator. It represents the supplied qubits initialized to the provided state. @@ -134,11 +134,11 @@ def _create_partial_act_on_args( """ @abc.abstractmethod - def _create_step_result(self, sim_state: OperationTarget[TActOnArgs]) -> TStepResultBase: + def _create_step_result(self, sim_state: SimulationState[TDenseSimulationState]) -> TStepResultBase: """This method should be implemented to create a step result. Args: - sim_state: The OperationTarget for this trial. + sim_state: The SimulationState for this trial. Returns: The StepResult. @@ -169,7 +169,7 @@ def _can_be_in_run_prefix(self, val: Any): def _core_iterator( self, circuit: 'cirq.AbstractCircuit', - sim_state: OperationTarget[TActOnArgs], + sim_state: SimulationState[TDenseSimulationState], all_measurements_are_terminal: bool = False, ) -> Iterator[TStepResultBase]: """Standard iterator over StepResult from Moments of a Circuit. @@ -286,7 +286,7 @@ def simulate_sweep_iter( is often used in specifying the initial state, i.e. the ordering of the computational basis states. initial_state: The initial state for the simulation. This can be - either a raw state or an `OperationTarget`. The form of the + either a raw state or an `SimulationState`. The form of the raw state depends on the simulation implementation. See documentation of the implementing class for details. @@ -314,13 +314,13 @@ def sweep_prefixable(op: 'cirq.Operation'): def _create_act_on_args( self, initial_state: Any, qubits: Sequence['cirq.Qid'] - ) -> OperationTarget[TActOnArgs]: - if isinstance(initial_state, OperationTarget): + ) -> SimulationState[TDenseSimulationState]: + if isinstance(initial_state, SimulationState): return initial_state classical_data = value.ClassicalDataDictionaryStore() if self._split_untangled_states: - args_map: Dict[Optional['cirq.Qid'], TActOnArgs] = {} + args_map: Dict[Optional['cirq.Qid'], TDenseSimulationState] = {} if isinstance(initial_state, int): for q in reversed(qubits): args_map[q] = self._create_partial_act_on_args( @@ -336,7 +336,7 @@ def _create_act_on_args( for q in qubits: args_map[q] = args args_map[None] = self._create_partial_act_on_args(0, (), classical_data) - return ActOnArgsContainer( + return SimulationProductState( args_map, qubits, self._split_untangled_states, classical_data=classical_data ) else: @@ -345,17 +345,17 @@ def _create_act_on_args( ) -class StepResultBase(Generic[TActOnArgs], StepResult[OperationTarget[TActOnArgs]], abc.ABC): +class StepResultBase(Generic[TDenseSimulationState], StepResult[SimulationState[TDenseSimulationState]], abc.ABC): """A base class for step results.""" - def __init__(self, sim_state: OperationTarget[TActOnArgs]): + def __init__(self, sim_state: SimulationState[TDenseSimulationState]): """Initializes the step result. Args: - sim_state: The `OperationTarget` for this step. + sim_state: The `SimulationState` for this step. """ super().__init__(sim_state) - self._merged_sim_state_cache: Optional[TActOnArgs] = None + self._merged_sim_state_cache: Optional[TDenseSimulationState] = None qubits = sim_state.qubits self._qubits = qubits self._qubit_mapping = {q: i for i, q in enumerate(qubits)} @@ -366,7 +366,7 @@ def _qid_shape_(self): return self._qubit_shape @property - def _merged_sim_state(self) -> TActOnArgs: + def _merged_sim_state(self) -> TDenseSimulationState: if self._merged_sim_state_cache is None: self._merged_sim_state_cache = self._sim_state.create_merged_state() return self._merged_sim_state_cache @@ -381,7 +381,7 @@ def sample( class SimulationTrialResultBase( - SimulationTrialResult[OperationTarget[TActOnArgs]], Generic[TActOnArgs], abc.ABC + SimulationTrialResult[SimulationState[TDenseSimulationState]], Generic[TDenseSimulationState], abc.ABC ): """A base class for trial results.""" @@ -390,7 +390,7 @@ def __init__( self, params: study.ParamResolver, measurements: Dict[str, np.ndarray], - final_simulator_state: 'cirq.OperationTarget[TActOnArgs]', + final_simulator_state: 'cirq.SimulationState[TDenseSimulationState]', ) -> None: """Initializes the `SimulationTrialResultBase` class. @@ -404,9 +404,9 @@ def __init__( trial finishes. """ super().__init__(params, measurements, final_simulator_state=final_simulator_state) - self._merged_sim_state_cache: Optional[TActOnArgs] = None + self._merged_sim_state_cache: Optional[TDenseSimulationState] = None - def get_state_containing_qubit(self, qubit: 'cirq.Qid') -> TActOnArgs: + def get_state_containing_qubit(self, qubit: 'cirq.Qid') -> TDenseSimulationState: """Returns the independent state space containing the qubit. Args: @@ -416,17 +416,17 @@ def get_state_containing_qubit(self, qubit: 'cirq.Qid') -> TActOnArgs: The state space containing the qubit.""" return self._final_simulator_state[qubit] - def _get_substates(self) -> Sequence[TActOnArgs]: + def _get_substates(self) -> Sequence[TDenseSimulationState]: state = self._final_simulator_state - if isinstance(state, ActOnArgsContainer): - substates: Dict[TActOnArgs, int] = {} + if isinstance(state, SimulationProductState): + substates: Dict[TDenseSimulationState, int] = {} for q in state.qubits: substates[self.get_state_containing_qubit(q)] = 0 substates[state[None]] = 0 return tuple(substates.keys()) return [state.create_merged_state()] - def _get_merged_sim_state(self) -> TActOnArgs: + def _get_merged_sim_state(self) -> TDenseSimulationState: if self._merged_sim_state_cache is None: self._merged_sim_state_cache = self._final_simulator_state.create_merged_state() return self._merged_sim_state_cache diff --git a/cirq-core/cirq/sim/simulator_base_test.py b/cirq-core/cirq/sim/simulator_base_test.py index 47e3170fc24..dd4b8170f44 100644 --- a/cirq-core/cirq/sim/simulator_base_test.py +++ b/cirq-core/cirq/sim/simulator_base_test.py @@ -56,7 +56,7 @@ def copy(self, deep_copy_buffers: bool = True) -> 'CountingState': ) -class CountingActOnArgs(cirq.ActOnArgs[CountingState]): +class CountingSimulationState(cirq.DenseSimulationState[CountingState]): def __init__(self, state, qubits, classical_data): state_obj = CountingState(state) super().__init__(state=state_obj, qubits=qubits, classical_data=classical_data) @@ -80,13 +80,13 @@ def measurement_count(self): return self._state.measurement_count -class SplittableCountingActOnArgs(CountingActOnArgs): +class SplittableCountingSimulationState(CountingSimulationState): @property def allows_factoring(self): return True -class CountingStepResult(cirq.StepResultBase[CountingActOnArgs]): +class CountingStepResult(cirq.StepResultBase[CountingSimulationState]): def sample( self, qubits: List[cirq.Qid], @@ -98,16 +98,16 @@ def sample( measurements.append(self._merged_sim_state._perform_measurement(qubits)) return np.array(measurements, dtype=int) - def _simulator_state(self) -> CountingActOnArgs: + def _simulator_state(self) -> CountingSimulationState: return self._merged_sim_state -class CountingTrialResult(cirq.SimulationTrialResultBase[CountingActOnArgs]): +class CountingTrialResult(cirq.SimulationTrialResultBase[CountingSimulationState]): pass class CountingSimulator( - cirq.SimulatorBase[CountingStepResult, CountingTrialResult, CountingActOnArgs] + cirq.SimulatorBase[CountingStepResult, CountingTrialResult, CountingSimulationState] ): def __init__(self, noise=None, split_untangled_states=False): super().__init__(noise=noise, split_untangled_states=split_untangled_states) @@ -117,21 +117,21 @@ def _create_partial_act_on_args( initial_state: Any, qubits: Sequence['cirq.Qid'], classical_data: cirq.ClassicalDataStore, - ) -> CountingActOnArgs: - return CountingActOnArgs(qubits=qubits, state=initial_state, classical_data=classical_data) + ) -> CountingSimulationState: + return CountingSimulationState(qubits=qubits, state=initial_state, classical_data=classical_data) def _create_simulator_trial_result( self, params: cirq.ParamResolver, measurements: Dict[str, np.ndarray], - final_simulator_state: 'cirq.OperationTarget[CountingActOnArgs]', + final_simulator_state: 'cirq.SimulationState[CountingSimulationState]', ) -> CountingTrialResult: return CountingTrialResult( params, measurements, final_simulator_state=final_simulator_state ) def _create_step_result( - self, sim_state: cirq.OperationTarget[CountingActOnArgs] + self, sim_state: cirq.SimulationState[CountingSimulationState] ) -> CountingStepResult: return CountingStepResult(sim_state) @@ -145,8 +145,8 @@ def _create_partial_act_on_args( initial_state: Any, qubits: Sequence['cirq.Qid'], classical_data: cirq.ClassicalDataStore, - ) -> CountingActOnArgs: - return SplittableCountingActOnArgs( + ) -> CountingSimulationState: + return SplittableCountingSimulationState( qubits=qubits, state=initial_state, classical_data=classical_data ) @@ -260,7 +260,7 @@ def test_integer_initial_state_is_split(): def test_integer_initial_state_is_not_split_if_disabled(): sim = SplittableCountingSimulator(split_untangled_states=False) args = sim._create_act_on_args(2, (q0, q1)) - assert isinstance(args, SplittableCountingActOnArgs) + assert isinstance(args, SplittableCountingSimulationState) assert args[q0] is args[q1] assert args.state == 2 @@ -268,8 +268,8 @@ def test_integer_initial_state_is_not_split_if_disabled(): def test_integer_initial_state_is_not_split_if_impossible(): sim = CountingSimulator() args = sim._create_act_on_args(2, (q0, q1)) - assert isinstance(args, CountingActOnArgs) - assert not isinstance(args, SplittableCountingActOnArgs) + assert isinstance(args, CountingSimulationState) + assert not isinstance(args, SplittableCountingSimulationState) assert args[q0] is args[q1] assert args.state == 2 @@ -306,20 +306,20 @@ def test_measurement_causes_split(): def test_measurement_does_not_split_if_disabled(): sim = SplittableCountingSimulator(split_untangled_states=False) args = sim._create_act_on_args(2, (q0, q1)) - assert isinstance(args, SplittableCountingActOnArgs) + assert isinstance(args, SplittableCountingSimulationState) args.apply_operation(cirq.measure(q0)) - assert isinstance(args, SplittableCountingActOnArgs) + assert isinstance(args, SplittableCountingSimulationState) assert args[q0] is args[q1] def test_measurement_does_not_split_if_impossible(): sim = CountingSimulator() args = sim._create_act_on_args(2, (q0, q1)) - assert isinstance(args, CountingActOnArgs) - assert not isinstance(args, SplittableCountingActOnArgs) + assert isinstance(args, CountingSimulationState) + assert not isinstance(args, SplittableCountingSimulationState) args.apply_operation(cirq.measure(q0)) - assert isinstance(args, CountingActOnArgs) - assert not isinstance(args, SplittableCountingActOnArgs) + assert isinstance(args, CountingSimulationState) + assert not isinstance(args, SplittableCountingSimulationState) assert args[q0] is args[q1] diff --git a/cirq-core/cirq/sim/simulator_test.py b/cirq-core/cirq/sim/simulator_test.py index 52b886196b8..b3c34072a61 100644 --- a/cirq-core/cirq/sim/simulator_test.py +++ b/cirq-core/cirq/sim/simulator_test.py @@ -22,7 +22,7 @@ import cirq from cirq import study -from cirq.sim.act_on_args import TActOnArgs +from cirq.sim.act_on_args import TDenseSimulationState from cirq.sim.simulator import ( TStepResult, SimulatesAmplitudes, @@ -63,8 +63,8 @@ def sample(self, qubits, repetitions=1, seed=None): class SimulatesIntermediateStateImpl( - Generic[TStepResult, TActOnArgs], - SimulatesIntermediateState[TStepResult, 'SimulationTrialResult', TActOnArgs], + Generic[TStepResult, TDenseSimulationState], + SimulatesIntermediateState[TStepResult, 'SimulationTrialResult', TDenseSimulationState], metaclass=abc.ABCMeta, ): """A SimulatesIntermediateState that uses the default SimulationTrialResult type.""" @@ -73,7 +73,7 @@ def _create_simulator_trial_result( self, params: study.ParamResolver, measurements: Dict[str, np.ndarray], - final_simulator_state: 'cirq.OperationTarget[TActOnArgs]', + final_simulator_state: 'cirq.SimulationState[TDenseSimulationState]', ) -> 'SimulationTrialResult': """This method creates a default trial result. diff --git a/cirq-core/cirq/sim/sparse_simulator.py b/cirq-core/cirq/sim/sparse_simulator.py index d95182f4794..283ceda3a63 100644 --- a/cirq-core/cirq/sim/sparse_simulator.py +++ b/cirq-core/cirq/sim/sparse_simulator.py @@ -155,11 +155,11 @@ def __init__( def _create_partial_act_on_args( self, - initial_state: Union['cirq.STATE_VECTOR_LIKE', 'cirq.ActOnStateVectorArgs'], + initial_state: Union['cirq.STATE_VECTOR_LIKE', 'cirq.StateVectorSimulationState'], qubits: Sequence['cirq.Qid'], classical_data: 'cirq.ClassicalDataStore', ): - """Creates the ActOnStateVectorArgs for a circuit. + """Creates the StateVectorSimulationState for a circuit. Args: initial_state: The initial state for the simulation in the @@ -171,12 +171,12 @@ def _create_partial_act_on_args( simulation. Returns: - ActOnStateVectorArgs for the circuit. + StateVectorSimulationState for the circuit. """ - if isinstance(initial_state, act_on_state_vector_args.ActOnStateVectorArgs): + if isinstance(initial_state, act_on_state_vector_args.StateVectorSimulationState): return initial_state - return act_on_state_vector_args.ActOnStateVectorArgs( + return act_on_state_vector_args.StateVectorSimulationState( qubits=qubits, prng=self._prng, classical_data=classical_data, @@ -184,7 +184,7 @@ def _create_partial_act_on_args( dtype=self._dtype, ) - def _create_step_result(self, sim_state: 'cirq.OperationTarget[cirq.ActOnStateVectorArgs]'): + def _create_step_result(self, sim_state: 'cirq.SimulationState[cirq.StateVectorSimulationState]'): return SparseSimulatorStep(sim_state=sim_state, dtype=self._dtype) def simulate_expectation_values_sweep_iter( @@ -228,14 +228,14 @@ class SparseSimulatorStep( ) def __init__( self, - sim_state: 'cirq.OperationTarget[cirq.ActOnStateVectorArgs]', + sim_state: 'cirq.SimulationState[cirq.StateVectorSimulationState]', simulator: 'cirq.Simulator' = None, dtype: 'DTypeLike' = np.complex64, ): """Results of a step of the simulator. Args: - sim_state: The qubit:ActOnArgs lookup for this step. + sim_state: The qubit:DenseSimulationState lookup for this step. simulator: The simulator used to create this. dtype: The `numpy.dtype` used by the simulation. One of `numpy.complex64` or `numpy.complex128`. diff --git a/cirq-core/cirq/sim/sparse_simulator_test.py b/cirq-core/cirq/sim/sparse_simulator_test.py index cd962051148..b93cd056765 100644 --- a/cirq-core/cirq/sim/sparse_simulator_test.py +++ b/cirq-core/cirq/sim/sparse_simulator_test.py @@ -749,7 +749,7 @@ def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs): def test_simulator_step_state_mixin(): qubits = cirq.LineQubit.range(2) - args = cirq.ActOnStateVectorArgs( + args = cirq.StateVectorSimulationState( available_buffer=np.array([0, 1, 0, 0]).reshape((2, 2)), prng=cirq.value.parse_random_state(0), qubits=qubits, diff --git a/cirq-core/cirq/sim/state_vector_simulator.py b/cirq-core/cirq/sim/state_vector_simulator.py index a473565ba3e..2a7028e66f8 100644 --- a/cirq-core/cirq/sim/state_vector_simulator.py +++ b/cirq-core/cirq/sim/state_vector_simulator.py @@ -43,7 +43,7 @@ class SimulatesIntermediateStateVector( Generic[TStateVectorStepResult], simulator_base.SimulatorBase[ - TStateVectorStepResult, 'cirq.StateVectorTrialResult', 'cirq.ActOnStateVectorArgs', + TStateVectorStepResult, 'cirq.StateVectorTrialResult', 'cirq.StateVectorSimulationState', ], simulator.SimulatesAmplitudes, metaclass=abc.ABCMeta, @@ -69,7 +69,7 @@ def _create_simulator_trial_result( self, params: 'cirq.ParamResolver', measurements: Dict[str, np.ndarray], - final_simulator_state: 'cirq.OperationTarget[cirq.ActOnStateVectorArgs]', + final_simulator_state: 'cirq.SimulationState[cirq.StateVectorSimulationState]', ) -> 'cirq.StateVectorTrialResult': return StateVectorTrialResult( params=params, measurements=measurements, final_simulator_state=final_simulator_state @@ -102,7 +102,7 @@ def compute_amplitudes_sweep_iter( class StateVectorStepResult( - simulator_base.StepResultBase['cirq.ActOnStateVectorArgs'], metaclass=abc.ABCMeta + simulator_base.StepResultBase['cirq.StateVectorSimulationState'], metaclass=abc.ABCMeta ): pass @@ -132,7 +132,7 @@ def _value_equality_values_(self) -> Any: @value.value_equality(unhashable=True) class StateVectorTrialResult( state_vector.StateVectorMixin, - simulator_base.SimulationTrialResultBase['cirq.ActOnStateVectorArgs'], + simulator_base.SimulationTrialResultBase['cirq.StateVectorSimulationState'], ): """A `SimulationTrialResult` that includes the `StateVectorMixin` methods. @@ -144,7 +144,7 @@ def __init__( self, params: 'cirq.ParamResolver', measurements: Dict[str, np.ndarray], - final_simulator_state: 'cirq.OperationTarget[cirq.ActOnStateVectorArgs]', + final_simulator_state: 'cirq.SimulationState[cirq.StateVectorSimulationState]', ) -> None: super().__init__( params=params, diff --git a/cirq-core/cirq/sim/state_vector_simulator_test.py b/cirq-core/cirq/sim/state_vector_simulator_test.py index fdae8ece86e..6bff10df026 100644 --- a/cirq-core/cirq/sim/state_vector_simulator_test.py +++ b/cirq-core/cirq/sim/state_vector_simulator_test.py @@ -20,7 +20,7 @@ def test_state_vector_trial_result_repr(): q0 = cirq.NamedQubit('a') - final_simulator_state = cirq.ActOnStateVectorArgs( + final_simulator_state = cirq.StateVectorSimulationState( available_buffer=np.array([0, 1], dtype=np.complex64), prng=np.random.RandomState(0), qubits=[q0], @@ -36,7 +36,7 @@ def test_state_vector_trial_result_repr(): "cirq.StateVectorTrialResult(" "params=cirq.ParamResolver({'s': 1}), " "measurements={'m': np.array([[1]], dtype=np.int32)}, " - "final_simulator_state=cirq.ActOnStateVectorArgs(" + "final_simulator_state=cirq.StateVectorSimulationState(" "initial_state=np.array([0j, (1+0j)], dtype=np.complex64), " "qubits=(cirq.NamedQubit('a'),), " "classical_data=cirq.ClassicalDataDictionaryStore()))" @@ -55,7 +55,7 @@ def test_state_vector_simulator_state_repr(): def test_state_vector_trial_result_equality(): eq = cirq.testing.EqualsTester() - final_simulator_state = cirq.ActOnStateVectorArgs(initial_state=np.array([])) + final_simulator_state = cirq.StateVectorSimulationState(initial_state=np.array([])) eq.add_equality_group( cirq.StateVectorTrialResult( params=cirq.ParamResolver({}), @@ -82,7 +82,7 @@ def test_state_vector_trial_result_equality(): final_simulator_state=final_simulator_state, ) ) - final_simulator_state = cirq.ActOnStateVectorArgs(initial_state=np.array([1])) + final_simulator_state = cirq.StateVectorSimulationState(initial_state=np.array([1])) eq.add_equality_group( cirq.StateVectorTrialResult( params=cirq.ParamResolver({'s': 1}), @@ -94,7 +94,7 @@ def test_state_vector_trial_result_equality(): def test_state_vector_trial_result_state_mixin(): qubits = cirq.LineQubit.range(2) - final_simulator_state = cirq.ActOnStateVectorArgs( + final_simulator_state = cirq.StateVectorSimulationState( qubits=qubits, initial_state=np.array([0, 1, 0, 0]) ) result = cirq.StateVectorTrialResult( @@ -110,7 +110,7 @@ def test_state_vector_trial_result_state_mixin(): def test_state_vector_trial_result_qid_shape(): - final_simulator_state = cirq.ActOnStateVectorArgs( + final_simulator_state = cirq.StateVectorSimulationState( qubits=[cirq.NamedQubit('a')], initial_state=np.array([0, 1]) ) trial_result = cirq.StateVectorTrialResult( @@ -120,7 +120,7 @@ def test_state_vector_trial_result_qid_shape(): ) assert cirq.qid_shape(trial_result) == (2,) - final_simulator_state = cirq.ActOnStateVectorArgs( + final_simulator_state = cirq.StateVectorSimulationState( qubits=cirq.LineQid.for_qid_shape((3, 2)), initial_state=np.array([0, 0, 0, 0, 1, 0]) ) trial_result = cirq.StateVectorTrialResult( @@ -134,7 +134,7 @@ def test_state_vector_trial_result_qid_shape(): def test_state_vector_trial_state_vector_is_copy(): final_state_vector = np.array([0, 1], dtype=np.complex64) qubit_map = {cirq.NamedQubit('a'): 0} - final_simulator_state = cirq.ActOnStateVectorArgs( + final_simulator_state = cirq.StateVectorSimulationState( qubits=list(qubit_map), initial_state=final_state_vector ) trial_result = cirq.StateVectorTrialResult( @@ -145,7 +145,7 @@ def test_state_vector_trial_state_vector_is_copy(): def test_str_big(): qs = cirq.LineQubit.range(10) - final_simulator_state = cirq.ActOnStateVectorArgs( + final_simulator_state = cirq.StateVectorSimulationState( prng=np.random.RandomState(0), qubits=qs, initial_state=np.array([1] * 2**10, dtype=np.complex64) * 0.03125, @@ -156,7 +156,7 @@ def test_str_big(): def test_pretty_print(): - final_simulator_state = cirq.ActOnStateVectorArgs( + final_simulator_state = cirq.StateVectorSimulationState( available_buffer=np.array([1]), prng=np.random.RandomState(0), qubits=[], diff --git a/cirq-core/cirq/testing/consistent_act_on.py b/cirq-core/cirq/testing/consistent_act_on.py index 0bd30f378ec..7fb7a7b34a6 100644 --- a/cirq-core/cirq/testing/consistent_act_on.py +++ b/cirq-core/cirq/testing/consistent_act_on.py @@ -46,7 +46,7 @@ def state_vector_has_stabilizer(state_vector: np.ndarray, stabilizer: DensePauli """ qubits = LineQubit.range(protocols.num_qubits(stabilizer)) - args = act_on_state_vector_args.ActOnStateVectorArgs( + args = act_on_state_vector_args.StateVectorSimulationState( available_buffer=np.empty_like(state_vector), qubits=qubits, prng=np.random.RandomState(), @@ -71,9 +71,9 @@ def assert_all_implemented_act_on_effects_match_unitary( Args: val: A gate or operation that may be an input to protocols.act_on. assert_tableau_implemented: asserts that protocols.act_on() works with - val and ActOnCliffordTableauArgs inputs. + val and CliffordTableauSimulationState inputs. assert_ch_form_implemented: asserts that protocols.act_on() works with - val and ActOnStabilizerStateChFormArgs inputs. + val and CHFormSimulationState inputs. """ # pylint: disable=unused-variable @@ -159,7 +159,7 @@ def _final_clifford_tableau( the tableau otherwise.""" tableau = clifford_tableau.CliffordTableau(len(qubit_map)) - args = act_on_clifford_tableau_args.ActOnCliffordTableauArgs( + args = act_on_clifford_tableau_args.CliffordTableauSimulationState( tableau=tableau, qubits=list(qubit_map.keys()), prng=np.random.RandomState() ) for op in circuit.all_operations(): @@ -187,7 +187,7 @@ def _final_stabilizer_state_ch_form( returns the StabilizerStateChForm otherwise.""" stabilizer_ch_form = stabilizer_state_ch_form.StabilizerStateChForm(len(qubit_map)) - args = act_on_stabilizer_ch_form_args.ActOnStabilizerCHFormArgs( + args = act_on_stabilizer_ch_form_args.CHFormSimulationState( qubits=list(qubit_map.keys()), prng=np.random.RandomState(), initial_state=stabilizer_ch_form, diff --git a/cirq-core/cirq/testing/consistent_act_on_test.py b/cirq-core/cirq/testing/consistent_act_on_test.py index 34be8031b95..5506d3bbeb3 100644 --- a/cirq-core/cirq/testing/consistent_act_on_test.py +++ b/cirq-core/cirq/testing/consistent_act_on_test.py @@ -24,8 +24,8 @@ class GoodGate(cirq.testing.SingleQubitGate): def _unitary_(self): return np.array([[0, 1], [1, 0]]) - def _act_on_(self, args: 'cirq.OperationTarget', qubits: Sequence['cirq.Qid']): - if isinstance(args, cirq.ActOnCliffordTableauArgs): + def _act_on_(self, args: 'cirq.SimulationState', qubits: Sequence['cirq.Qid']): + if isinstance(args, cirq.CliffordTableauSimulationState): tableau = args.tableau q = args.qubit_map[qubits[0]] tableau.rs[:] ^= tableau.zs[:, q] @@ -37,8 +37,8 @@ class BadGate(cirq.testing.SingleQubitGate): def _unitary_(self): return np.array([[0, 1j], [1, 0]]) - def _act_on_(self, args: 'cirq.OperationTarget', qubits: Sequence['cirq.Qid']): - if isinstance(args, cirq.ActOnCliffordTableauArgs): + def _act_on_(self, args: 'cirq.SimulationState', qubits: Sequence['cirq.Qid']): + if isinstance(args, cirq.CliffordTableauSimulationState): tableau = args.tableau q = args.qubit_map[qubits[0]] tableau.rs[:] ^= tableau.zs[:, q] diff --git a/cirq-core/cirq/transformers/analytical_decompositions/clifford_decomposition.py b/cirq-core/cirq/transformers/analytical_decompositions/clifford_decomposition.py index 1e51d8b866e..7079d118a50 100644 --- a/cirq-core/cirq/transformers/analytical_decompositions/clifford_decomposition.py +++ b/cirq-core/cirq/transformers/analytical_decompositions/clifford_decomposition.py @@ -26,7 +26,7 @@ def _X( q: int, - args: sim.ActOnCliffordTableauArgs, + args: sim.CliffordTableauSimulationState, operations: List[ops.Operation], qubits: List['cirq.Qid'], ): @@ -36,7 +36,7 @@ def _X( def _Z( q: int, - args: sim.ActOnCliffordTableauArgs, + args: sim.CliffordTableauSimulationState, operations: List[ops.Operation], qubits: List['cirq.Qid'], ): @@ -46,7 +46,7 @@ def _Z( def _Sdg( q: int, - args: sim.ActOnCliffordTableauArgs, + args: sim.CliffordTableauSimulationState, operations: List[ops.Operation], qubits: List['cirq.Qid'], ): @@ -57,7 +57,7 @@ def _Sdg( def _H( q: int, - args: sim.ActOnCliffordTableauArgs, + args: sim.CliffordTableauSimulationState, operations: List[ops.Operation], qubits: List['cirq.Qid'], ): @@ -68,7 +68,7 @@ def _H( def _CNOT( q1: int, q2: int, - args: sim.ActOnCliffordTableauArgs, + args: sim.CliffordTableauSimulationState, operations: List[ops.Operation], qubits: List['cirq.Qid'], ): @@ -79,7 +79,7 @@ def _CNOT( def _SWAP( q1: int, q2: int, - args: sim.ActOnCliffordTableauArgs, + args: sim.CliffordTableauSimulationState, operations: List[ops.Operation], qubits: List['cirq.Qid'], ): @@ -114,7 +114,7 @@ def decompose_clifford_tableau_to_operations( t: qis.CliffordTableau = clifford_tableau.copy() operations: List[ops.Operation] = [] - args = sim.ActOnCliffordTableauArgs(tableau=t, qubits=qubits, prng=np.random.RandomState()) + args = sim.CliffordTableauSimulationState(tableau=t, qubits=qubits, prng=np.random.RandomState()) _X_with_ops = functools.partial(_X, args=args, operations=operations, qubits=qubits) _Z_with_ops = functools.partial(_Z, args=args, operations=operations, qubits=qubits) diff --git a/cirq-core/cirq/transformers/analytical_decompositions/clifford_decomposition_test.py b/cirq-core/cirq/transformers/analytical_decompositions/clifford_decomposition_test.py index e635ff7ae2f..29b3f4b43e1 100644 --- a/cirq-core/cirq/transformers/analytical_decompositions/clifford_decomposition_test.py +++ b/cirq-core/cirq/transformers/analytical_decompositions/clifford_decomposition_test.py @@ -39,7 +39,7 @@ def test_misaligned_qubits(): def test_clifford_decompose_one_qubit(): """Two random instance for one qubit decomposition.""" qubits = cirq.LineQubit.range(1) - args = cirq.ActOnCliffordTableauArgs( + args = cirq.CliffordTableauSimulationState( tableau=cirq.CliffordTableau(num_qubits=1), qubits=qubits, prng=np.random.RandomState() ) cirq.act_on(cirq.X, args, qubits=[qubits[0]], allow_decompose=False) @@ -51,7 +51,7 @@ def test_clifford_decompose_one_qubit(): assert_allclose_up_to_global_phase(cirq.unitary(expect_circ), cirq.unitary(circ), atol=1e-7) qubits = cirq.LineQubit.range(1) - args = cirq.ActOnCliffordTableauArgs( + args = cirq.CliffordTableauSimulationState( tableau=cirq.CliffordTableau(num_qubits=1), qubits=qubits, prng=np.random.RandomState() ) cirq.act_on(cirq.Z, args, qubits=[qubits[0]], allow_decompose=False) @@ -74,7 +74,7 @@ def test_clifford_decompose_one_qubit(): def test_clifford_decompose_two_qubits(): """Two random instance for two qubits decomposition.""" qubits = cirq.LineQubit.range(2) - args = cirq.ActOnCliffordTableauArgs( + args = cirq.CliffordTableauSimulationState( tableau=cirq.CliffordTableau(num_qubits=2), qubits=qubits, prng=np.random.RandomState() ) cirq.act_on(cirq.H, args, qubits=[qubits[0]], allow_decompose=False) @@ -85,7 +85,7 @@ def test_clifford_decompose_two_qubits(): assert_allclose_up_to_global_phase(cirq.unitary(expect_circ), cirq.unitary(circ), atol=1e-7) qubits = cirq.LineQubit.range(2) - args = cirq.ActOnCliffordTableauArgs( + args = cirq.CliffordTableauSimulationState( tableau=cirq.CliffordTableau(num_qubits=2), qubits=qubits, prng=np.random.RandomState() ) cirq.act_on(cirq.H, args, qubits=[qubits[0]], allow_decompose=False) @@ -118,7 +118,7 @@ def test_clifford_decompose_by_unitary(): t = cirq.CliffordTableau(num_qubits=n) qubits = cirq.LineQubit.range(n) expect_circ = cirq.Circuit() - args = cirq.ActOnCliffordTableauArgs(tableau=t, qubits=qubits, prng=prng) + args = cirq.CliffordTableauSimulationState(tableau=t, qubits=qubits, prng=prng) for _ in range(num_ops): g = prng.randint(len(gate_candidate)) indices = (prng.randint(n),) if g < 5 else prng.choice(n, 2, replace=False) @@ -145,7 +145,7 @@ def test_clifford_decompose_by_reconstruction(): t = cirq.CliffordTableau(num_qubits=n) qubits = cirq.LineQubit.range(n) expect_circ = cirq.Circuit() - args = cirq.ActOnCliffordTableauArgs(tableau=t, qubits=qubits, prng=prng) + args = cirq.CliffordTableauSimulationState(tableau=t, qubits=qubits, prng=prng) for _ in range(num_ops): g = prng.randint(len(gate_candidate)) indices = (prng.randint(n),) if g < 5 else prng.choice(n, 2, replace=False) @@ -156,7 +156,7 @@ def test_clifford_decompose_by_reconstruction(): ops = cirq.decompose_clifford_tableau_to_operations(qubits, args.tableau) reconstruct_t = cirq.CliffordTableau(num_qubits=n) - reconstruct_args = cirq.ActOnCliffordTableauArgs( + reconstruct_args = cirq.CliffordTableauSimulationState( tableau=reconstruct_t, qubits=qubits, prng=prng ) for op in ops: diff --git a/cirq-google/cirq_google/calibration/engine_simulator.py b/cirq-google/cirq_google/calibration/engine_simulator.py index 69eba099950..a9edab68ea8 100644 --- a/cirq-google/cirq_google/calibration/engine_simulator.py +++ b/cirq-google/cirq_google/calibration/engine_simulator.py @@ -456,14 +456,14 @@ def simulate( def _create_partial_act_on_args( self, - initial_state: Union[int, cirq.ActOnStateVectorArgs], + initial_state: Union[int, cirq.StateVectorSimulationState], qubits: Sequence[cirq.Qid], classical_data: cirq.ClassicalDataStore, - ) -> cirq.ActOnStateVectorArgs: + ) -> cirq.StateVectorSimulationState: # Needs an implementation since it's abstract but will never actually be called. raise NotImplementedError() - def _create_step_result(self, sim_state: cirq.OperationTarget) -> cirq.SparseSimulatorStep: + def _create_step_result(self, sim_state: cirq.SimulationState) -> cirq.SparseSimulatorStep: # Needs an implementation since it's abstract but will never actually be called. raise NotImplementedError() diff --git a/examples/direct_fidelity_estimation.py b/examples/direct_fidelity_estimation.py index 20085320be0..322b36c648c 100644 --- a/examples/direct_fidelity_estimation.py +++ b/examples/direct_fidelity_estimation.py @@ -369,7 +369,7 @@ def direct_fidelity_estimation( clifford_tableau = cirq.CliffordTableau(n_qubits) try: for gate in circuit.all_operations(): - tableau_args = clifford.ActOnCliffordTableauArgs( + tableau_args = clifford.CliffordTableauSimulationState( tableau=clifford_tableau, qubits=qubits ) cirq.act_on(gate, tableau_args) From 44afc44579ca74b2d624d0d7fa4c49ed2bea9473 Mon Sep 17 00:00:00 2001 From: daxfohl Date: Sun, 24 Apr 2022 22:18:04 -0700 Subject: [PATCH 6/8] format --- cirq-core/cirq/ops/clifford_gate.py | 4 +++- cirq-core/cirq/ops/common_channels.py | 5 ++++- cirq-core/cirq/ops/global_phase_op_test.py | 8 ++------ cirq-core/cirq/sim/act_on_args.py | 16 ++++++++-------- cirq-core/cirq/sim/act_on_args_container.py | 8 ++++++-- .../cirq/sim/act_on_state_vector_args_test.py | 4 +++- .../act_on_stabilizer_ch_form_args_test.py | 12 +++--------- cirq-core/cirq/sim/density_matrix_simulator.py | 12 +++++++++--- cirq-core/cirq/sim/simulator_base.py | 12 +++++++++--- cirq-core/cirq/sim/simulator_base_test.py | 4 +++- cirq-core/cirq/sim/sparse_simulator.py | 4 +++- .../clifford_decomposition.py | 4 +++- 12 files changed, 56 insertions(+), 37 deletions(-) diff --git a/cirq-core/cirq/ops/clifford_gate.py b/cirq-core/cirq/ops/clifford_gate.py index 46f67e69d4f..dceb89fd85b 100644 --- a/cirq-core/cirq/ops/clifford_gate.py +++ b/cirq-core/cirq/ops/clifford_gate.py @@ -277,7 +277,9 @@ def _generate_clifford_from_known_gate( ) -> Union['SingleQubitCliffordGate', 'CliffordGate']: qubits = devices.LineQubit.range(num_qubits) t = qis.CliffordTableau(num_qubits=num_qubits) - args = sim.CliffordTableauSimulationState(tableau=t, qubits=qubits, prng=np.random.RandomState()) + args = sim.CliffordTableauSimulationState( + tableau=t, qubits=qubits, prng=np.random.RandomState() + ) protocols.act_on(gate, args, qubits, allow_decompose=False) if num_qubits == 1: diff --git a/cirq-core/cirq/ops/common_channels.py b/cirq-core/cirq/ops/common_channels.py index 95a32cdac30..17b61ca6eb4 100644 --- a/cirq-core/cirq/ops/common_channels.py +++ b/cirq-core/cirq/ops/common_channels.py @@ -736,7 +736,10 @@ def _unitary_(self): from cirq.sim import act_on_args - if isinstance(args, act_on_args.DenseSimulationState) and not args.can_represent_mixed_states: + if ( + isinstance(args, act_on_args.DenseSimulationState) + and not args.can_represent_mixed_states + ): result = args._perform_measurement(qubits)[0] gate = PlusGate(self.dimension, self.dimension - result) protocols.act_on(gate, args, qubits) diff --git a/cirq-core/cirq/ops/global_phase_op_test.py b/cirq-core/cirq/ops/global_phase_op_test.py index c95c866217d..b29d62c51c8 100644 --- a/cirq-core/cirq/ops/global_phase_op_test.py +++ b/cirq-core/cirq/ops/global_phase_op_test.py @@ -51,9 +51,7 @@ def test_act_on_tableau(phase): @pytest.mark.parametrize('phase', [1, 1j, -1]) def test_act_on_ch_form(phase): state = cirq.StabilizerStateChForm(0) - args = cirq.CHFormSimulationState( - qubits=[], prng=np.random.RandomState(), initial_state=state - ) + args = cirq.CHFormSimulationState(qubits=[], prng=np.random.RandomState(), initial_state=state) cirq.act_on(cirq.global_phase_operation(phase), args, allow_decompose=False) assert state.state_vector() == [[phase]] @@ -248,9 +246,7 @@ def test_gate_act_on_tableau(phase): @pytest.mark.parametrize('phase', [1, 1j, -1]) def test_gate_act_on_ch_form(phase): state = cirq.StabilizerStateChForm(0) - args = cirq.CHFormSimulationState( - qubits=[], prng=np.random.RandomState(), initial_state=state - ) + args = cirq.CHFormSimulationState(qubits=[], prng=np.random.RandomState(), initial_state=state) cirq.act_on(cirq.GlobalPhaseGate(phase), args, qubits=(), allow_decompose=False) assert state.state_vector() == [[phase]] diff --git a/cirq-core/cirq/sim/act_on_args.py b/cirq-core/cirq/sim/act_on_args.py index 8fbb844def8..119a7c8d183 100644 --- a/cirq-core/cirq/sim/act_on_args.py +++ b/cirq-core/cirq/sim/act_on_args.py @@ -157,8 +157,8 @@ def copy(self: TSelf, deep_copy_buffers: bool = True) -> TSelf: args._state = self._state.copy(deep_copy_buffers=deep_copy_buffers) else: _warn_or_error( - 'Pass a `QuantumStateRepresentation` into the `DenseSimulationState` constructor. The `_on_`' - ' overrides will be removed in cirq v0.16.' + 'Pass a `QuantumStateRepresentation` into the `DenseSimulationState` constructor.' + ' The `_on_` overrides will be removed in cirq v0.16.' ) self._on_copy(args, deep_copy_buffers) return args @@ -182,8 +182,8 @@ def kronecker_product(self: TSelf, other: TSelf, *, inplace=False) -> TSelf: args._state = self._state.kron(other._state) else: _warn_or_error( - 'Pass a `QuantumStateRepresentation` into the `DenseSimulationState` constructor. The `_on_`' - ' overrides will be removed in cirq v0.16.' + 'Pass a `QuantumStateRepresentation` into the `DenseSimulationState` constructor.' + ' The `_on_` overrides will be removed in cirq v0.16.' ) self._on_kronecker_product(other, args) args._set_qubits(self.qubits + other.qubits) @@ -225,8 +225,8 @@ def factor( remainder._state = r else: _warn_or_error( - 'Pass a `QuantumStateRepresentation` into the `DenseSimulationState` constructor. The `_on_`' - ' overrides will be removed in cirq v0.16.' + 'Pass a `QuantumStateRepresentation` into the `DenseSimulationState` constructor.' + ' The `_on_` overrides will be removed in cirq v0.16.' ) self._on_factor(qubits, extracted, remainder, validate, atol) extracted._set_qubits(qubits) @@ -276,8 +276,8 @@ def transpose_to_qubit_order( args._state = self._state.reindex(self.get_axes(qubits)) else: _warn_or_error( - 'Pass a `QuantumStateRepresentation` into the `DenseSimulationState` constructor. The `_on_`' - ' overrides will be removed in cirq v0.16.' + 'Pass a `QuantumStateRepresentation` into the `DenseSimulationState` constructor.' + ' The `_on_` overrides will be removed in cirq v0.16.' ) self._on_transpose_to_qubit_order(qubits, args) args._set_qubits(qubits) diff --git a/cirq-core/cirq/sim/act_on_args_container.py b/cirq-core/cirq/sim/act_on_args_container.py index 15079bf5c9a..f0b27429616 100644 --- a/cirq-core/cirq/sim/act_on_args_container.py +++ b/cirq-core/cirq/sim/act_on_args_container.py @@ -25,7 +25,9 @@ import cirq -class SimulationProductState(Generic[TDenseSimulationState], SimulationState[TDenseSimulationState], abc.Mapping): +class SimulationProductState( + Generic[TDenseSimulationState], SimulationState[TDenseSimulationState], abc.Mapping +): """A container for a `Qid`-to-`DenseSimulationState` dictionary.""" def __init__( @@ -129,7 +131,9 @@ def _act_on_fallback_( self._args[q] = op_args return True - def copy(self, deep_copy_buffers: bool = True) -> 'cirq.SimulationProductState[TDenseSimulationState]': + def copy( + self, deep_copy_buffers: bool = True + ) -> 'cirq.SimulationProductState[TDenseSimulationState]': classical_data = self._classical_data.copy() copies = {} for act_on_args in set(self.args.values()): diff --git a/cirq-core/cirq/sim/act_on_state_vector_args_test.py b/cirq-core/cirq/sim/act_on_state_vector_args_test.py index 0ad61de7119..4b67d3880d4 100644 --- a/cirq-core/cirq/sim/act_on_state_vector_args_test.py +++ b/cirq-core/cirq/sim/act_on_state_vector_args_test.py @@ -44,7 +44,9 @@ def test_infer_target_tensor(): np.array([[1.0 + 0.0j, 0.0 + 0.0j], [0.0 + 0.0j, 0.0 + 0.0j]], dtype=dtype), ) - args = cirq.StateVectorSimulationState(qubits=cirq.LineQubit.range(2), initial_state=0, dtype=dtype) + args = cirq.StateVectorSimulationState( + qubits=cirq.LineQubit.range(2), initial_state=0, dtype=dtype + ) np.testing.assert_almost_equal( args.target_tensor, np.array([[1.0 + 0.0j, 0.0 + 0.0j], [0.0 + 0.0j, 0.0 + 0.0j]], dtype=dtype), diff --git a/cirq-core/cirq/sim/clifford/act_on_stabilizer_ch_form_args_test.py b/cirq-core/cirq/sim/clifford/act_on_stabilizer_ch_form_args_test.py index 067a6f09cc3..0306de97c05 100644 --- a/cirq-core/cirq/sim/clifford/act_on_stabilizer_ch_form_args_test.py +++ b/cirq-core/cirq/sim/clifford/act_on_stabilizer_ch_form_args_test.py @@ -61,9 +61,7 @@ def num_qubits(self) -> int: def _unitary_(self): return np.array([[0, -1j], [1j, 0]]) - args = cirq.CHFormSimulationState( - qubits=cirq.LineQubit.range(3), prng=np.random.RandomState() - ) + args = cirq.CHFormSimulationState(qubits=cirq.LineQubit.range(3), prng=np.random.RandomState()) cirq.act_on(UnitaryYGate(), args, [cirq.LineQubit(1)]) expected_args = cirq.CHFormSimulationState( qubits=cirq.LineQubit.range(3), prng=np.random.RandomState() @@ -80,9 +78,7 @@ def num_qubits(self) -> int: def _unitary_(self): return np.array([[1, 1], [1, -1]]) / (2**0.5) - args = cirq.CHFormSimulationState( - qubits=cirq.LineQubit.range(3), prng=np.random.RandomState() - ) + args = cirq.CHFormSimulationState(qubits=cirq.LineQubit.range(3), prng=np.random.RandomState()) cirq.act_on(UnitaryHGate(), args, [cirq.LineQubit(1)]) expected_args = cirq.CHFormSimulationState( qubits=cirq.LineQubit.range(3), prng=np.random.RandomState() @@ -92,9 +88,7 @@ def _unitary_(self): def test_copy(): - args = cirq.CHFormSimulationState( - qubits=cirq.LineQubit.range(3), prng=np.random.RandomState() - ) + args = cirq.CHFormSimulationState(qubits=cirq.LineQubit.range(3), prng=np.random.RandomState()) args1 = args.copy() assert isinstance(args1, cirq.CHFormSimulationState) assert args is not args1 diff --git a/cirq-core/cirq/sim/density_matrix_simulator.py b/cirq-core/cirq/sim/density_matrix_simulator.py index 5d5efbee27e..c30a2c020be 100644 --- a/cirq-core/cirq/sim/density_matrix_simulator.py +++ b/cirq-core/cirq/sim/density_matrix_simulator.py @@ -147,7 +147,9 @@ def __init__( def _create_partial_act_on_args( self, - initial_state: Union[np.ndarray, 'cirq.STATE_VECTOR_LIKE', 'cirq.DensityMatrixSimulationState'], + initial_state: Union[ + np.ndarray, 'cirq.STATE_VECTOR_LIKE', 'cirq.DensityMatrixSimulationState' + ], qubits: Sequence['cirq.Qid'], classical_data: 'cirq.ClassicalDataStore', ) -> 'cirq.DensityMatrixSimulationState': @@ -179,7 +181,9 @@ def _create_partial_act_on_args( def _can_be_in_run_prefix(self, val: Any): return not protocols.measurement_keys_touched(val) - def _create_step_result(self, sim_state: 'cirq.SimulationState[cirq.DensityMatrixSimulationState]'): + def _create_step_result( + self, sim_state: 'cirq.SimulationState[cirq.DensityMatrixSimulationState]' + ): return DensityMatrixStepResult(sim_state=sim_state, dtype=self._dtype) def _create_simulator_trial_result( @@ -342,7 +346,9 @@ def __repr__(self) -> str: @value.value_equality(unhashable=True) class DensityMatrixTrialResult( - simulator_base.SimulationTrialResultBase[act_on_density_matrix_args.DensityMatrixSimulationState] + simulator_base.SimulationTrialResultBase[ + act_on_density_matrix_args.DensityMatrixSimulationState + ] ): """A `SimulationTrialResult` for `DensityMatrixSimulator` runs. diff --git a/cirq-core/cirq/sim/simulator_base.py b/cirq-core/cirq/sim/simulator_base.py index acdbbac57f0..951452126b2 100644 --- a/cirq-core/cirq/sim/simulator_base.py +++ b/cirq-core/cirq/sim/simulator_base.py @@ -134,7 +134,9 @@ def _create_partial_act_on_args( """ @abc.abstractmethod - def _create_step_result(self, sim_state: SimulationState[TDenseSimulationState]) -> TStepResultBase: + def _create_step_result( + self, sim_state: SimulationState[TDenseSimulationState] + ) -> TStepResultBase: """This method should be implemented to create a step result. Args: @@ -345,7 +347,9 @@ def _create_act_on_args( ) -class StepResultBase(Generic[TDenseSimulationState], StepResult[SimulationState[TDenseSimulationState]], abc.ABC): +class StepResultBase( + Generic[TDenseSimulationState], StepResult[SimulationState[TDenseSimulationState]], abc.ABC +): """A base class for step results.""" def __init__(self, sim_state: SimulationState[TDenseSimulationState]): @@ -381,7 +385,9 @@ def sample( class SimulationTrialResultBase( - SimulationTrialResult[SimulationState[TDenseSimulationState]], Generic[TDenseSimulationState], abc.ABC + SimulationTrialResult[SimulationState[TDenseSimulationState]], + Generic[TDenseSimulationState], + abc.ABC, ): """A base class for trial results.""" diff --git a/cirq-core/cirq/sim/simulator_base_test.py b/cirq-core/cirq/sim/simulator_base_test.py index dd4b8170f44..c13b479000c 100644 --- a/cirq-core/cirq/sim/simulator_base_test.py +++ b/cirq-core/cirq/sim/simulator_base_test.py @@ -118,7 +118,9 @@ def _create_partial_act_on_args( qubits: Sequence['cirq.Qid'], classical_data: cirq.ClassicalDataStore, ) -> CountingSimulationState: - return CountingSimulationState(qubits=qubits, state=initial_state, classical_data=classical_data) + return CountingSimulationState( + qubits=qubits, state=initial_state, classical_data=classical_data + ) def _create_simulator_trial_result( self, diff --git a/cirq-core/cirq/sim/sparse_simulator.py b/cirq-core/cirq/sim/sparse_simulator.py index 283ceda3a63..06026835d9e 100644 --- a/cirq-core/cirq/sim/sparse_simulator.py +++ b/cirq-core/cirq/sim/sparse_simulator.py @@ -184,7 +184,9 @@ def _create_partial_act_on_args( dtype=self._dtype, ) - def _create_step_result(self, sim_state: 'cirq.SimulationState[cirq.StateVectorSimulationState]'): + def _create_step_result( + self, sim_state: 'cirq.SimulationState[cirq.StateVectorSimulationState]' + ): return SparseSimulatorStep(sim_state=sim_state, dtype=self._dtype) def simulate_expectation_values_sweep_iter( diff --git a/cirq-core/cirq/transformers/analytical_decompositions/clifford_decomposition.py b/cirq-core/cirq/transformers/analytical_decompositions/clifford_decomposition.py index 7079d118a50..5018e510125 100644 --- a/cirq-core/cirq/transformers/analytical_decompositions/clifford_decomposition.py +++ b/cirq-core/cirq/transformers/analytical_decompositions/clifford_decomposition.py @@ -114,7 +114,9 @@ def decompose_clifford_tableau_to_operations( t: qis.CliffordTableau = clifford_tableau.copy() operations: List[ops.Operation] = [] - args = sim.CliffordTableauSimulationState(tableau=t, qubits=qubits, prng=np.random.RandomState()) + args = sim.CliffordTableauSimulationState( + tableau=t, qubits=qubits, prng=np.random.RandomState() + ) _X_with_ops = functools.partial(_X, args=args, operations=operations, qubits=qubits) _Z_with_ops = functools.partial(_Z, args=args, operations=operations, qubits=qubits) From 864f599b1d22e8da00ad83994a776d5347b03775 Mon Sep 17 00:00:00 2001 From: daxfohl Date: Mon, 25 Apr 2022 06:14:13 -0700 Subject: [PATCH 7/8] rename modules --- cirq-core/cirq/contrib/quimb/mps_simulator.py | 2 +- cirq-core/cirq/ops/common_channels.py | 4 ++-- cirq-core/cirq/sim/__init__.py | 10 +++++----- cirq-core/cirq/sim/clifford/__init__.py | 6 +++--- ...r_ch_form_args.py => ch_form_simulation_state.py} | 2 +- ...args_test.py => ch_form_simulation_state_test.py} | 0 ...t.py => clifford_tableau_simulatin_state_test.py} | 0 ..._args.py => clifford_tableau_simulation_state.py} | 2 +- cirq-core/cirq/sim/clifford/stabilizer_sampler.py | 2 +- ...ilizer_args.py => stabilizer_simulation_state.py} | 2 +- ...s_test.py => stabilizer_simulation_state_test.py} | 0 .../{act_on_args.py => dense_simulation_state.py} | 2 +- ...n_args_test.py => dense_simulation_state_test.py} | 6 ++++-- ...ix_args.py => density_matrix_simulation_state.py} | 2 +- ...st.py => density_matrix_simulation_state_test.py} | 2 +- cirq-core/cirq/sim/density_matrix_simulator.py | 8 ++++---- ...args_container.py => simulation_product_state.py} | 4 ++-- ...iner_test.py => simulation_product_state_test.py} | 0 .../sim/{operation_target.py => simulation_state.py} | 0 cirq-core/cirq/sim/simulator.py | 2 +- cirq-core/cirq/sim/simulator_base.py | 4 ++-- cirq-core/cirq/sim/simulator_test.py | 2 +- cirq-core/cirq/sim/sparse_simulator.py | 6 +++--- ...ctor_args.py => state_vector_simulation_state.py} | 2 +- ...test.py => state_vector_simulation_state_test.py} | 2 +- cirq-core/cirq/testing/consistent_act_on.py | 12 ++++++------ 26 files changed, 43 insertions(+), 41 deletions(-) rename cirq-core/cirq/sim/clifford/{act_on_stabilizer_ch_form_args.py => ch_form_simulation_state.py} (97%) rename cirq-core/cirq/sim/clifford/{act_on_stabilizer_ch_form_args_test.py => ch_form_simulation_state_test.py} (100%) rename cirq-core/cirq/sim/clifford/{act_on_clifford_tableau_args_test.py => clifford_tableau_simulatin_state_test.py} (100%) rename cirq-core/cirq/sim/clifford/{act_on_clifford_tableau_args.py => clifford_tableau_simulation_state.py} (96%) rename cirq-core/cirq/sim/clifford/{act_on_stabilizer_args.py => stabilizer_simulation_state.py} (99%) rename cirq-core/cirq/sim/clifford/{act_on_stabilizer_args_test.py => stabilizer_simulation_state_test.py} (100%) rename cirq-core/cirq/sim/{act_on_args.py => dense_simulation_state.py} (99%) rename cirq-core/cirq/sim/{act_on_args_test.py => dense_simulation_state_test.py} (96%) rename cirq-core/cirq/sim/{act_on_density_matrix_args.py => density_matrix_simulation_state.py} (99%) rename cirq-core/cirq/sim/{act_on_density_matrix_args_test.py => density_matrix_simulation_state_test.py} (98%) rename cirq-core/cirq/sim/{act_on_args_container.py => simulation_product_state.py} (98%) rename cirq-core/cirq/sim/{act_on_args_container_test.py => simulation_product_state_test.py} (100%) rename cirq-core/cirq/sim/{operation_target.py => simulation_state.py} (100%) rename cirq-core/cirq/sim/{act_on_state_vector_args.py => state_vector_simulation_state.py} (99%) rename cirq-core/cirq/sim/{act_on_state_vector_args_test.py => state_vector_simulation_state_test.py} (99%) diff --git a/cirq-core/cirq/contrib/quimb/mps_simulator.py b/cirq-core/cirq/contrib/quimb/mps_simulator.py index 526e52794dc..24680a59d3b 100644 --- a/cirq-core/cirq/contrib/quimb/mps_simulator.py +++ b/cirq-core/cirq/contrib/quimb/mps_simulator.py @@ -27,7 +27,7 @@ from cirq import devices, protocols, qis, value from cirq._compat import deprecated_parameter from cirq.sim import simulator, simulator_base -from cirq.sim.act_on_args import DenseSimulationState +from cirq.sim.dense_simulation_state import DenseSimulationState if TYPE_CHECKING: import cirq diff --git a/cirq-core/cirq/ops/common_channels.py b/cirq-core/cirq/ops/common_channels.py index 17b61ca6eb4..fd09a8da914 100644 --- a/cirq-core/cirq/ops/common_channels.py +++ b/cirq-core/cirq/ops/common_channels.py @@ -734,10 +734,10 @@ def _unitary_(self): u[:inc] = np.eye(self.dimension)[-inc:] return u - from cirq.sim import act_on_args + from cirq.sim import dense_simulation_state if ( - isinstance(args, act_on_args.DenseSimulationState) + isinstance(args, dense_simulation_state.DenseSimulationState) and not args.can_represent_mixed_states ): result = args._perform_measurement(qubits)[0] diff --git a/cirq-core/cirq/sim/__init__.py b/cirq-core/cirq/sim/__init__.py index ee6b1b22089..f61f7a477ac 100644 --- a/cirq-core/cirq/sim/__init__.py +++ b/cirq-core/cirq/sim/__init__.py @@ -15,13 +15,13 @@ """Classes for circuit simulators and base implementations of these classes.""" from typing import Tuple, Dict -from cirq.sim.act_on_args import DenseSimulationState +from cirq.sim.dense_simulation_state import DenseSimulationState -from cirq.sim.act_on_args_container import SimulationProductState +from cirq.sim.simulation_product_state import SimulationProductState -from cirq.sim.act_on_density_matrix_args import DensityMatrixSimulationState +from cirq.sim.density_matrix_simulation_state import DensityMatrixSimulationState -from cirq.sim.act_on_state_vector_args import StateVectorSimulationState +from cirq.sim.state_vector_simulation_state import StateVectorSimulationState from cirq.sim.density_matrix_utils import measure_density_matrix, sample_density_matrix @@ -32,7 +32,7 @@ DensityMatrixTrialResult, ) -from cirq.sim.operation_target import SimulationState +from cirq.sim.simulation_state import SimulationState from cirq.sim.mux import ( CIRCUIT_LIKE, diff --git a/cirq-core/cirq/sim/clifford/__init__.py b/cirq-core/cirq/sim/clifford/__init__.py index 1044fead601..8a572d30df0 100644 --- a/cirq-core/cirq/sim/clifford/__init__.py +++ b/cirq-core/cirq/sim/clifford/__init__.py @@ -1,9 +1,9 @@ # pylint: disable=wrong-or-nonexistent-copyright-notice -from cirq.sim.clifford.act_on_clifford_tableau_args import CliffordTableauSimulationState +from cirq.sim.clifford.clifford_tableau_simulation_state import CliffordTableauSimulationState -from cirq.sim.clifford.act_on_stabilizer_ch_form_args import CHFormSimulationState +from cirq.sim.clifford.ch_form_simulation_state import CHFormSimulationState -from cirq.sim.clifford.act_on_stabilizer_args import StabilizerSimulationState +from cirq.sim.clifford.stabilizer_simulation_state import StabilizerSimulationState from cirq.sim.clifford.stabilizer_state_ch_form import StabilizerStateChForm diff --git a/cirq-core/cirq/sim/clifford/act_on_stabilizer_ch_form_args.py b/cirq-core/cirq/sim/clifford/ch_form_simulation_state.py similarity index 97% rename from cirq-core/cirq/sim/clifford/act_on_stabilizer_ch_form_args.py rename to cirq-core/cirq/sim/clifford/ch_form_simulation_state.py index 377680c3239..0f89e172e12 100644 --- a/cirq-core/cirq/sim/clifford/act_on_stabilizer_ch_form_args.py +++ b/cirq-core/cirq/sim/clifford/ch_form_simulation_state.py @@ -18,7 +18,7 @@ from cirq._compat import proper_repr from cirq.sim.clifford import stabilizer_state_ch_form -from cirq.sim.clifford.act_on_stabilizer_args import StabilizerSimulationState +from cirq.sim.clifford.stabilizer_simulation_state import StabilizerSimulationState if TYPE_CHECKING: import cirq diff --git a/cirq-core/cirq/sim/clifford/act_on_stabilizer_ch_form_args_test.py b/cirq-core/cirq/sim/clifford/ch_form_simulation_state_test.py similarity index 100% rename from cirq-core/cirq/sim/clifford/act_on_stabilizer_ch_form_args_test.py rename to cirq-core/cirq/sim/clifford/ch_form_simulation_state_test.py diff --git a/cirq-core/cirq/sim/clifford/act_on_clifford_tableau_args_test.py b/cirq-core/cirq/sim/clifford/clifford_tableau_simulatin_state_test.py similarity index 100% rename from cirq-core/cirq/sim/clifford/act_on_clifford_tableau_args_test.py rename to cirq-core/cirq/sim/clifford/clifford_tableau_simulatin_state_test.py diff --git a/cirq-core/cirq/sim/clifford/act_on_clifford_tableau_args.py b/cirq-core/cirq/sim/clifford/clifford_tableau_simulation_state.py similarity index 96% rename from cirq-core/cirq/sim/clifford/act_on_clifford_tableau_args.py rename to cirq-core/cirq/sim/clifford/clifford_tableau_simulation_state.py index b9a92b58ae6..4937aa7eeff 100644 --- a/cirq-core/cirq/sim/clifford/act_on_clifford_tableau_args.py +++ b/cirq-core/cirq/sim/clifford/clifford_tableau_simulation_state.py @@ -19,7 +19,7 @@ import numpy as np from cirq.qis import clifford_tableau -from cirq.sim.clifford.act_on_stabilizer_args import StabilizerSimulationState +from cirq.sim.clifford.stabilizer_simulation_state import StabilizerSimulationState if TYPE_CHECKING: import cirq diff --git a/cirq-core/cirq/sim/clifford/stabilizer_sampler.py b/cirq-core/cirq/sim/clifford/stabilizer_sampler.py index 7184fc71e46..ec589389f16 100644 --- a/cirq-core/cirq/sim/clifford/stabilizer_sampler.py +++ b/cirq-core/cirq/sim/clifford/stabilizer_sampler.py @@ -19,7 +19,7 @@ import cirq from cirq import protocols, value from cirq.qis.clifford_tableau import CliffordTableau -from cirq.sim.clifford.act_on_clifford_tableau_args import CliffordTableauSimulationState +from cirq.sim.clifford.clifford_tableau_simulation_state import CliffordTableauSimulationState from cirq.work import sampler diff --git a/cirq-core/cirq/sim/clifford/act_on_stabilizer_args.py b/cirq-core/cirq/sim/clifford/stabilizer_simulation_state.py similarity index 99% rename from cirq-core/cirq/sim/clifford/act_on_stabilizer_args.py rename to cirq-core/cirq/sim/clifford/stabilizer_simulation_state.py index 4b48fc99fdb..2680c0cc619 100644 --- a/cirq-core/cirq/sim/clifford/act_on_stabilizer_args.py +++ b/cirq-core/cirq/sim/clifford/stabilizer_simulation_state.py @@ -22,7 +22,7 @@ from cirq.ops import common_gates, global_phase_op, matrix_gates, swap_gates from cirq.ops.clifford_gate import SingleQubitCliffordGate from cirq.protocols import has_unitary, num_qubits, unitary -from cirq.sim.act_on_args import DenseSimulationState +from cirq.sim.dense_simulation_state import DenseSimulationState from cirq.type_workarounds import NotImplementedType if TYPE_CHECKING: diff --git a/cirq-core/cirq/sim/clifford/act_on_stabilizer_args_test.py b/cirq-core/cirq/sim/clifford/stabilizer_simulation_state_test.py similarity index 100% rename from cirq-core/cirq/sim/clifford/act_on_stabilizer_args_test.py rename to cirq-core/cirq/sim/clifford/stabilizer_simulation_state_test.py diff --git a/cirq-core/cirq/sim/act_on_args.py b/cirq-core/cirq/sim/dense_simulation_state.py similarity index 99% rename from cirq-core/cirq/sim/act_on_args.py rename to cirq-core/cirq/sim/dense_simulation_state.py index 119a7c8d183..8b74b127669 100644 --- a/cirq-core/cirq/sim/act_on_args.py +++ b/cirq-core/cirq/sim/dense_simulation_state.py @@ -33,7 +33,7 @@ from cirq import protocols, value from cirq._compat import _warn_or_error, deprecated, deprecated_parameter from cirq.protocols.decompose_protocol import _try_decompose_into_operations_and_qubits -from cirq.sim.operation_target import SimulationState +from cirq.sim.simulation_state import SimulationState TSelf = TypeVar('TSelf', bound='DenseSimulationState') TState = TypeVar('TState', bound='cirq.QuantumStateRepresentation') diff --git a/cirq-core/cirq/sim/act_on_args_test.py b/cirq-core/cirq/sim/dense_simulation_state_test.py similarity index 96% rename from cirq-core/cirq/sim/act_on_args_test.py rename to cirq-core/cirq/sim/dense_simulation_state_test.py index d21f411e078..790304421f6 100644 --- a/cirq-core/cirq/sim/act_on_args_test.py +++ b/cirq-core/cirq/sim/dense_simulation_state_test.py @@ -18,7 +18,7 @@ import pytest import cirq -from cirq.sim import act_on_args +from cirq.sim import dense_simulation_state class DummyQuantumState(cirq.QuantumStateRepresentation): @@ -57,7 +57,9 @@ def _decompose_(self, qubits): yield cirq.X(*qubits) args = DummyArgs() - assert act_on_args.strat_act_on_from_apply_decompose(Composite(), args, [cirq.LineQubit(0)]) + assert dense_simulation_state.strat_act_on_from_apply_decompose( + Composite(), args, [cirq.LineQubit(0)] + ) def test_mapping(): diff --git a/cirq-core/cirq/sim/act_on_density_matrix_args.py b/cirq-core/cirq/sim/density_matrix_simulation_state.py similarity index 99% rename from cirq-core/cirq/sim/act_on_density_matrix_args.py rename to cirq-core/cirq/sim/density_matrix_simulation_state.py index 77f04b1d17a..e8f72eab373 100644 --- a/cirq-core/cirq/sim/act_on_density_matrix_args.py +++ b/cirq-core/cirq/sim/density_matrix_simulation_state.py @@ -20,7 +20,7 @@ from cirq import protocols, qis, sim from cirq._compat import proper_repr from cirq.linalg import transformations -from cirq.sim.act_on_args import DenseSimulationState, strat_act_on_from_apply_decompose +from cirq.sim.dense_simulation_state import DenseSimulationState, strat_act_on_from_apply_decompose if TYPE_CHECKING: import cirq diff --git a/cirq-core/cirq/sim/act_on_density_matrix_args_test.py b/cirq-core/cirq/sim/density_matrix_simulation_state_test.py similarity index 98% rename from cirq-core/cirq/sim/act_on_density_matrix_args_test.py rename to cirq-core/cirq/sim/density_matrix_simulation_state_test.py index 721ff162e6b..03b5e5d497f 100644 --- a/cirq-core/cirq/sim/act_on_density_matrix_args_test.py +++ b/cirq-core/cirq/sim/density_matrix_simulation_state_test.py @@ -89,7 +89,7 @@ def test_with_qubits(): def test_qid_shape_error(): with pytest.raises(ValueError, match="qid_shape must be provided"): - cirq.sim.act_on_density_matrix_args._BufferedDensityMatrix.create(initial_state=0) + cirq.sim.density_matrix_simulation_state._BufferedDensityMatrix.create(initial_state=0) def test_initial_state_vector(): diff --git a/cirq-core/cirq/sim/density_matrix_simulator.py b/cirq-core/cirq/sim/density_matrix_simulator.py index c30a2c020be..6c1f1cbd08e 100644 --- a/cirq-core/cirq/sim/density_matrix_simulator.py +++ b/cirq-core/cirq/sim/density_matrix_simulator.py @@ -18,7 +18,7 @@ from cirq import ops, protocols, study, value from cirq._compat import deprecated_class, deprecated_parameter, proper_repr -from cirq.sim import simulator, act_on_density_matrix_args, simulator_base +from cirq.sim import simulator, density_matrix_simulation_state, simulator_base if TYPE_CHECKING: import cirq @@ -167,10 +167,10 @@ def _create_partial_act_on_args( Returns: DensityMatrixSimulationState for the circuit. """ - if isinstance(initial_state, act_on_density_matrix_args.DensityMatrixSimulationState): + if isinstance(initial_state, density_matrix_simulation_state.DensityMatrixSimulationState): return initial_state - return act_on_density_matrix_args.DensityMatrixSimulationState( + return density_matrix_simulation_state.DensityMatrixSimulationState( qubits=qubits, prng=self._prng, classical_data=classical_data, @@ -347,7 +347,7 @@ def __repr__(self) -> str: @value.value_equality(unhashable=True) class DensityMatrixTrialResult( simulator_base.SimulationTrialResultBase[ - act_on_density_matrix_args.DensityMatrixSimulationState + density_matrix_simulation_state.DensityMatrixSimulationState ] ): """A `SimulationTrialResult` for `DensityMatrixSimulator` runs. diff --git a/cirq-core/cirq/sim/act_on_args_container.py b/cirq-core/cirq/sim/simulation_product_state.py similarity index 98% rename from cirq-core/cirq/sim/act_on_args_container.py rename to cirq-core/cirq/sim/simulation_product_state.py index f0b27429616..15114e8704d 100644 --- a/cirq-core/cirq/sim/act_on_args_container.py +++ b/cirq-core/cirq/sim/simulation_product_state.py @@ -18,8 +18,8 @@ import numpy as np from cirq import ops, protocols, value -from cirq.sim.act_on_args import TDenseSimulationState -from cirq.sim.operation_target import SimulationState +from cirq.sim.dense_simulation_state import TDenseSimulationState +from cirq.sim.simulation_state import SimulationState if TYPE_CHECKING: import cirq diff --git a/cirq-core/cirq/sim/act_on_args_container_test.py b/cirq-core/cirq/sim/simulation_product_state_test.py similarity index 100% rename from cirq-core/cirq/sim/act_on_args_container_test.py rename to cirq-core/cirq/sim/simulation_product_state_test.py diff --git a/cirq-core/cirq/sim/operation_target.py b/cirq-core/cirq/sim/simulation_state.py similarity index 100% rename from cirq-core/cirq/sim/operation_target.py rename to cirq-core/cirq/sim/simulation_state.py diff --git a/cirq-core/cirq/sim/simulator.py b/cirq-core/cirq/sim/simulator.py index 28082913541..5af47f0be30 100644 --- a/cirq-core/cirq/sim/simulator.py +++ b/cirq-core/cirq/sim/simulator.py @@ -50,7 +50,7 @@ import numpy as np from cirq import _compat, circuits, ops, protocols, study, value, work -from cirq.sim.operation_target import SimulationState +from cirq.sim.simulation_state import SimulationState if TYPE_CHECKING: import cirq diff --git a/cirq-core/cirq/sim/simulator_base.py b/cirq-core/cirq/sim/simulator_base.py index 951452126b2..dcb4550eb53 100644 --- a/cirq-core/cirq/sim/simulator_base.py +++ b/cirq-core/cirq/sim/simulator_base.py @@ -36,8 +36,8 @@ from cirq import ops, protocols, study, value, devices from cirq.sim import SimulationProductState from cirq.sim import simulator -from cirq.sim.act_on_args import TDenseSimulationState -from cirq.sim.operation_target import SimulationState +from cirq.sim.dense_simulation_state import TDenseSimulationState +from cirq.sim.simulation_state import SimulationState from cirq.sim.simulator import ( TSimulationTrialResult, SimulatesIntermediateState, diff --git a/cirq-core/cirq/sim/simulator_test.py b/cirq-core/cirq/sim/simulator_test.py index b3c34072a61..556e73f391c 100644 --- a/cirq-core/cirq/sim/simulator_test.py +++ b/cirq-core/cirq/sim/simulator_test.py @@ -22,7 +22,7 @@ import cirq from cirq import study -from cirq.sim.act_on_args import TDenseSimulationState +from cirq.sim.dense_simulation_state import TDenseSimulationState from cirq.sim.simulator import ( TStepResult, SimulatesAmplitudes, diff --git a/cirq-core/cirq/sim/sparse_simulator.py b/cirq-core/cirq/sim/sparse_simulator.py index 06026835d9e..e295fc3a9ec 100644 --- a/cirq-core/cirq/sim/sparse_simulator.py +++ b/cirq-core/cirq/sim/sparse_simulator.py @@ -20,7 +20,7 @@ from cirq import ops from cirq._compat import deprecated_parameter -from cirq.sim import simulator, state_vector, state_vector_simulator, act_on_state_vector_args +from cirq.sim import simulator, state_vector, state_vector_simulator, state_vector_simulation_state if TYPE_CHECKING: import cirq @@ -173,10 +173,10 @@ def _create_partial_act_on_args( Returns: StateVectorSimulationState for the circuit. """ - if isinstance(initial_state, act_on_state_vector_args.StateVectorSimulationState): + if isinstance(initial_state, state_vector_simulation_state.StateVectorSimulationState): return initial_state - return act_on_state_vector_args.StateVectorSimulationState( + return state_vector_simulation_state.StateVectorSimulationState( qubits=qubits, prng=self._prng, classical_data=classical_data, diff --git a/cirq-core/cirq/sim/act_on_state_vector_args.py b/cirq-core/cirq/sim/state_vector_simulation_state.py similarity index 99% rename from cirq-core/cirq/sim/act_on_state_vector_args.py rename to cirq-core/cirq/sim/state_vector_simulation_state.py index fcf6336f749..3b886e8c039 100644 --- a/cirq-core/cirq/sim/act_on_state_vector_args.py +++ b/cirq-core/cirq/sim/state_vector_simulation_state.py @@ -20,7 +20,7 @@ from cirq import _compat, linalg, protocols, qis, sim from cirq._compat import proper_repr from cirq.linalg import transformations -from cirq.sim.act_on_args import DenseSimulationState, strat_act_on_from_apply_decompose +from cirq.sim.dense_simulation_state import DenseSimulationState, strat_act_on_from_apply_decompose if TYPE_CHECKING: import cirq diff --git a/cirq-core/cirq/sim/act_on_state_vector_args_test.py b/cirq-core/cirq/sim/state_vector_simulation_state_test.py similarity index 99% rename from cirq-core/cirq/sim/act_on_state_vector_args_test.py rename to cirq-core/cirq/sim/state_vector_simulation_state_test.py index 4b67d3880d4..4dc54331e78 100644 --- a/cirq-core/cirq/sim/act_on_state_vector_args_test.py +++ b/cirq-core/cirq/sim/state_vector_simulation_state_test.py @@ -284,7 +284,7 @@ def test_with_qubits(): def test_qid_shape_error(): with pytest.raises(ValueError, match="qid_shape must be provided"): - cirq.sim.act_on_state_vector_args._BufferedStateVector.create(initial_state=0) + cirq.sim.state_vector_simulation_state._BufferedStateVector.create(initial_state=0) def test_deprecated_methods(): diff --git a/cirq-core/cirq/testing/consistent_act_on.py b/cirq-core/cirq/testing/consistent_act_on.py index 7fb7a7b34a6..b7d28749d02 100644 --- a/cirq-core/cirq/testing/consistent_act_on.py +++ b/cirq-core/cirq/testing/consistent_act_on.py @@ -22,11 +22,11 @@ from cirq.ops.dense_pauli_string import DensePauliString from cirq import protocols from cirq.qis import clifford_tableau -from cirq.sim import act_on_state_vector_args, final_state_vector +from cirq.sim import state_vector_simulation_state, final_state_vector from cirq.sim.clifford import ( - act_on_clifford_tableau_args, + clifford_tableau_simulation_state, stabilizer_state_ch_form, - act_on_stabilizer_ch_form_args, + ch_form_simulation_state, ) @@ -46,7 +46,7 @@ def state_vector_has_stabilizer(state_vector: np.ndarray, stabilizer: DensePauli """ qubits = LineQubit.range(protocols.num_qubits(stabilizer)) - args = act_on_state_vector_args.StateVectorSimulationState( + args = state_vector_simulation_state.StateVectorSimulationState( available_buffer=np.empty_like(state_vector), qubits=qubits, prng=np.random.RandomState(), @@ -159,7 +159,7 @@ def _final_clifford_tableau( the tableau otherwise.""" tableau = clifford_tableau.CliffordTableau(len(qubit_map)) - args = act_on_clifford_tableau_args.CliffordTableauSimulationState( + args = clifford_tableau_simulation_state.CliffordTableauSimulationState( tableau=tableau, qubits=list(qubit_map.keys()), prng=np.random.RandomState() ) for op in circuit.all_operations(): @@ -187,7 +187,7 @@ def _final_stabilizer_state_ch_form( returns the StabilizerStateChForm otherwise.""" stabilizer_ch_form = stabilizer_state_ch_form.StabilizerStateChForm(len(qubit_map)) - args = act_on_stabilizer_ch_form_args.CHFormSimulationState( + args = ch_form_simulation_state.CHFormSimulationState( qubits=list(qubit_map.keys()), prng=np.random.RandomState(), initial_state=stabilizer_ch_form, From 6110ea51e0abad1e5d3aaefc60bfd8d431cf0b46 Mon Sep 17 00:00:00 2001 From: daxfohl Date: Mon, 25 Apr 2022 07:17:00 -0700 Subject: [PATCH 8/8] Rename act_on_args locals and tests --- cirq-core/cirq/contrib/quimb/mps_simulator_test.py | 4 ++-- cirq-core/cirq/sim/clifford/clifford_simulator_test.py | 2 +- cirq-core/cirq/sim/density_matrix_simulator_test.py | 2 +- cirq-core/cirq/sim/simulation_product_state.py | 4 ++-- cirq-core/cirq/sim/simulator.py | 4 ++-- cirq-core/cirq/sim/simulator_base.py | 10 +++++----- cirq-core/cirq/sim/sparse_simulator_test.py | 4 ++-- 7 files changed, 15 insertions(+), 15 deletions(-) diff --git a/cirq-core/cirq/contrib/quimb/mps_simulator_test.py b/cirq-core/cirq/contrib/quimb/mps_simulator_test.py index dfd241f6d27..0d20cf9047e 100644 --- a/cirq-core/cirq/contrib/quimb/mps_simulator_test.py +++ b/cirq-core/cirq/contrib/quimb/mps_simulator_test.py @@ -183,7 +183,7 @@ def test_cnot_flipped(): ) -def test_act_on_args(): +def test_simulation_state(): q0, q1 = qubit_order = cirq.LineQubit.range(2) circuit = cirq.Circuit(cirq.CNOT(q1, q0)) mps_simulator = ccq.mps_simulator.MPSSimulator() @@ -537,7 +537,7 @@ def test_state_copy(): assert not np.shares_memory(x[i], y[i]) -def test_state_act_on_args_initializer(): +def test_simulation_state_initializer(): s = ccq.mps_simulator.MPSState( qubits=(cirq.LineQubit(0),), prng=np.random.RandomState(0), diff --git a/cirq-core/cirq/sim/clifford/clifford_simulator_test.py b/cirq-core/cirq/sim/clifford/clifford_simulator_test.py index a2774caf357..cbbd08f06fd 100644 --- a/cirq-core/cirq/sim/clifford/clifford_simulator_test.py +++ b/cirq-core/cirq/sim/clifford/clifford_simulator_test.py @@ -99,7 +99,7 @@ def test_simulate_initial_state(): ) -def test_simulate_act_on_args(): +def test_simulation_state(): q0, q1 = cirq.LineQubit.range(2) simulator = cirq.CliffordSimulator() for b0 in [0, 1]: diff --git a/cirq-core/cirq/sim/density_matrix_simulator_test.py b/cirq-core/cirq/sim/density_matrix_simulator_test.py index cde1ba9a195..435d264cc94 100644 --- a/cirq-core/cirq/sim/density_matrix_simulator_test.py +++ b/cirq-core/cirq/sim/density_matrix_simulator_test.py @@ -591,7 +591,7 @@ def test_simulate_initial_state(dtype: Type[np.number], split: bool): @pytest.mark.parametrize('dtype', [np.complex64, np.complex128]) @pytest.mark.parametrize('split', [True, False]) -def test_simulate_act_on_args(dtype: Type[np.number], split: bool): +def test_simulation_state(dtype: Type[np.number], split: bool): q0, q1 = cirq.LineQubit.range(2) simulator = cirq.DensityMatrixSimulator(dtype=dtype, split_untangled_states=split) for b0 in [0, 1]: diff --git a/cirq-core/cirq/sim/simulation_product_state.py b/cirq-core/cirq/sim/simulation_product_state.py index 15114e8704d..9100c66499d 100644 --- a/cirq-core/cirq/sim/simulation_product_state.py +++ b/cirq-core/cirq/sim/simulation_product_state.py @@ -136,8 +136,8 @@ def copy( ) -> 'cirq.SimulationProductState[TDenseSimulationState]': classical_data = self._classical_data.copy() copies = {} - for act_on_args in set(self.args.values()): - copies[act_on_args] = act_on_args.copy(deep_copy_buffers) + for sim_state in set(self.args.values()): + copies[sim_state] = sim_state.copy(deep_copy_buffers) for copy in copies.values(): copy._classical_data = classical_data args = {q: copies[a] for q, a in self.args.items()} diff --git a/cirq-core/cirq/sim/simulator.py b/cirq-core/cirq/sim/simulator.py index 5af47f0be30..321d3e88a81 100644 --- a/cirq-core/cirq/sim/simulator.py +++ b/cirq-core/cirq/sim/simulator.py @@ -684,8 +684,8 @@ def _base_iterator( StepResults from simulating a Moment of the Circuit. """ qubits = ops.QubitOrder.as_qubit_order(qubit_order).order_for(circuit.all_qubits()) - act_on_args = self._create_act_on_args(initial_state, qubits) - return self._core_iterator(circuit, act_on_args) + sim_state = self._create_act_on_args(initial_state, qubits) + return self._core_iterator(circuit, sim_state) @abc.abstractmethod def _create_act_on_args( diff --git a/cirq-core/cirq/sim/simulator_base.py b/cirq-core/cirq/sim/simulator_base.py index dcb4550eb53..71c09ce11f6 100644 --- a/cirq-core/cirq/sim/simulator_base.py +++ b/cirq-core/cirq/sim/simulator_base.py @@ -226,7 +226,7 @@ def _run( 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) + sim_state = self._create_act_on_args(0, qubits) prefix, general_suffix = ( split_into_matching_protocol_then_general(resolved_circuit, self._can_be_in_run_prefix) @@ -234,13 +234,13 @@ def _run( else (resolved_circuit[0:0], resolved_circuit) ) step_result = None - for step_result in self._core_iterator(circuit=prefix, sim_state=act_on_args): + 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=act_on_args, all_measurements_are_terminal=True + circuit=general_suffix, sim_state=sim_state, all_measurements_are_terminal=True ): pass assert step_result is not None @@ -253,9 +253,9 @@ def _run( for i in range(repetitions): for step_result in self._core_iterator( general_suffix, - sim_state=act_on_args.copy(deep_copy_buffers=False) + sim_state=sim_state.copy(deep_copy_buffers=False) if i < repetitions - 1 - else act_on_args, + else sim_state, ): pass for k, r in step_result._classical_data.records.items(): diff --git a/cirq-core/cirq/sim/sparse_simulator_test.py b/cirq-core/cirq/sim/sparse_simulator_test.py index b93cd056765..3329dc8135d 100644 --- a/cirq-core/cirq/sim/sparse_simulator_test.py +++ b/cirq-core/cirq/sim/sparse_simulator_test.py @@ -465,7 +465,7 @@ def test_simulate_initial_state(dtype: Type[np.number], split: bool): @pytest.mark.parametrize('dtype', [np.complex64, np.complex128]) @pytest.mark.parametrize('split', [True, False]) -def test_simulate_act_on_args(dtype: Type[np.number], split: bool): +def test_simulation_state(dtype: Type[np.number], split: bool): q0, q1 = cirq.LineQubit.range(2) simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split) for b0 in [0, 1]: @@ -1343,7 +1343,7 @@ def test_nondeterministic_mixture_noise(): assert result1 != result2 -def test_act_on_args_pure_state_creation(): +def test_pure_state_creation(): sim = cirq.Simulator() qids = cirq.LineQubit.range(3) shape = cirq.qid_shape(qids)