cirq-core 1.4.0.dev20240529225110__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/ops/__init__.py

@@ -11,211 +11,251 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-"""Gates (unitary and non-unitary), operations, base types, and gate sets.
-"""
+"""Gates (unitary and non-unitary), operations, base types, and gate sets."""
 
-from cirq.ops.arithmetic_operation import ArithmeticGate
+from cirq.ops.arithmetic_operation import ArithmeticGate as ArithmeticGate
 
-from cirq.ops.clifford_gate import CliffordGate, SingleQubitCliffordGate
+from cirq.ops.clifford_gate import (
+    CliffordGate as CliffordGate,
+    SingleQubitCliffordGate as SingleQubitCliffordGate,
+)
 
 from cirq.ops.dense_pauli_string import (
-    BaseDensePauliString,
-    DensePauliString,
-    MutableDensePauliString,
+    BaseDensePauliString as BaseDensePauliString,
+    DensePauliString as DensePauliString,
+    MutableDensePauliString as MutableDensePauliString,
 )
 
-from cirq.ops.boolean_hamiltonian import BooleanHamiltonianGate
+from cirq.ops.boolean_hamiltonian import BooleanHamiltonianGate as BooleanHamiltonianGate
 
 from cirq.ops.common_channels import (
-    amplitude_damp,
-    AmplitudeDampingChannel,
-    asymmetric_depolarize,
-    AsymmetricDepolarizingChannel,
-    bit_flip,
-    BitFlipChannel,
-    depolarize,
-    DepolarizingChannel,
-    generalized_amplitude_damp,
-    GeneralizedAmplitudeDampingChannel,
-    phase_damp,
-    phase_flip,
-    PhaseDampingChannel,
-    PhaseFlipChannel,
-    R,
-    reset,
-    reset_each,
-    ResetChannel,
+    amplitude_damp as amplitude_damp,
+    AmplitudeDampingChannel as AmplitudeDampingChannel,
+    asymmetric_depolarize as asymmetric_depolarize,
+    AsymmetricDepolarizingChannel as AsymmetricDepolarizingChannel,
+    bit_flip as bit_flip,
+    BitFlipChannel as BitFlipChannel,
+    depolarize as depolarize,
+    DepolarizingChannel as DepolarizingChannel,
+    generalized_amplitude_damp as generalized_amplitude_damp,
+    GeneralizedAmplitudeDampingChannel as GeneralizedAmplitudeDampingChannel,
+    phase_damp as phase_damp,
+    phase_flip as phase_flip,
+    PhaseDampingChannel as PhaseDampingChannel,
+    PhaseFlipChannel as PhaseFlipChannel,
+    R as R,
+    reset as reset,
+    reset_each as reset_each,
+    ResetChannel as ResetChannel,
 )
 
 from cirq.ops.common_gates import (
-    CNOT,
-    CNotPowGate,
-    cphase,
-    CX,
-    CXPowGate,
-    CZ,
-    CZPowGate,
-    H,
-    HPowGate,
-    Rx,
-    Ry,
-    Rz,
-    rx,
-    ry,
-    rz,
-    S,
-    T,
-    XPowGate,
-    YPowGate,
-    ZPowGate,
+    CNOT as CNOT,
+    CNotPowGate as CNotPowGate,
+    cphase as cphase,
+    CX as CX,
+    CXPowGate as CXPowGate,
+    CZ as CZ,
+    CZPowGate as CZPowGate,
+    H as H,
+    HPowGate as HPowGate,
+    Rx as Rx,
+    Ry as Ry,
+    Rz as Rz,
+    rx as rx,
+    ry as ry,
+    rz as rz,
+    S as S,
+    T as T,
+    XPowGate as XPowGate,
+    YPowGate as YPowGate,
+    ZPowGate as ZPowGate,
 )
 
 from cirq.ops.common_gate_families import (
-    AnyUnitaryGateFamily,
-    AnyIntegerPowerGateFamily,
-    ParallelGateFamily,
+    AnyUnitaryGateFamily as AnyUnitaryGateFamily,
+    AnyIntegerPowerGateFamily as AnyIntegerPowerGateFamily,
+    ParallelGateFamily as ParallelGateFamily,
 )
 
-from cirq.ops.classically_controlled_operation import ClassicallyControlledOperation
+from cirq.ops.classically_controlled_operation import (
+    ClassicallyControlledOperation as ClassicallyControlledOperation,
+)
 
-from cirq.ops.controlled_gate import ControlledGate
+from cirq.ops.controlled_gate import ControlledGate as ControlledGate
 
-from cirq.ops.diagonal_gate import DiagonalGate
+from cirq.ops.diagonal_gate import DiagonalGate as DiagonalGate
 
-from cirq.ops.eigen_gate import EigenGate
+from cirq.ops.eigen_gate import EigenGate as EigenGate
 
-from cirq.ops.fourier_transform import PhaseGradientGate, qft, QuantumFourierTransformGate
+from cirq.ops.fourier_transform import (
+    PhaseGradientGate as PhaseGradientGate,
+    qft as qft,
+    QuantumFourierTransformGate as QuantumFourierTransformGate,
+)
 
-from cirq.ops.fsim_gate import FSimGate, PhasedFSimGate
+from cirq.ops.fsim_gate import FSimGate as FSimGate, PhasedFSimGate as PhasedFSimGate
 
-from cirq.ops.gate_features import InterchangeableQubitsGate
+from cirq.ops.gate_features import InterchangeableQubitsGate as InterchangeableQubitsGate
 
-from cirq.ops.gate_operation import GateOperation
+from cirq.ops.gate_operation import GateOperation as GateOperation
 
-from cirq.ops.gateset import GateFamily, Gateset
+from cirq.ops.gateset import GateFamily as GateFamily, Gateset as Gateset
 
-from cirq.ops.identity import I, identity_each, IdentityGate
+from cirq.ops.identity import I as I, identity_each as identity_each, IdentityGate as IdentityGate
 
-from cirq.ops.global_phase_op import GlobalPhaseGate, global_phase_operation
+from cirq.ops.global_phase_op import (
+    GlobalPhaseGate as GlobalPhaseGate,
+    global_phase_operation as global_phase_operation,
+)
 
-from cirq.ops.kraus_channel import KrausChannel
+from cirq.ops.kraus_channel import KrausChannel as KrausChannel
 
 from cirq.ops.linear_combinations import (
-    LinearCombinationOfGates,
-    LinearCombinationOfOperations,
-    PauliSum,
-    PauliSumLike,
-    ProjectorSum,
+    LinearCombinationOfGates as LinearCombinationOfGates,
+    LinearCombinationOfOperations as LinearCombinationOfOperations,
+    PauliSum as PauliSum,
+    PauliSumLike as PauliSumLike,
+    ProjectorSum as ProjectorSum,
 )
 
-from cirq.ops.mixed_unitary_channel import MixedUnitaryChannel
+from cirq.ops.mixed_unitary_channel import MixedUnitaryChannel as MixedUnitaryChannel
 
-from cirq.ops.pauli_sum_exponential import PauliSumExponential
+from cirq.ops.pauli_sum_exponential import PauliSumExponential as PauliSumExponential
 
-from cirq.ops.pauli_measurement_gate import PauliMeasurementGate
+from cirq.ops.pauli_measurement_gate import PauliMeasurementGate as PauliMeasurementGate
 
-from cirq.ops.parallel_gate import ParallelGate, parallel_gate_op
+from cirq.ops.parallel_gate import (
+    ParallelGate as ParallelGate,
+    parallel_gate_op as parallel_gate_op,
+)
 
-from cirq.ops.projector import ProjectorString
+from cirq.ops.projector import ProjectorString as ProjectorString
 
-from cirq.ops.controlled_operation import ControlledOperation
+from cirq.ops.controlled_operation import ControlledOperation as ControlledOperation
 
-from cirq.ops.qubit_manager import BorrowableQubit, CleanQubit, QubitManager, SimpleQubitManager
+from cirq.ops.qubit_manager import (
+    BorrowableQubit as BorrowableQubit,
+    CleanQubit as CleanQubit,
+    QubitManager as QubitManager,
+    SimpleQubitManager as SimpleQubitManager,
+)
 
-from cirq.ops.greedy_qubit_manager import GreedyQubitManager
+from cirq.ops.greedy_qubit_manager import GreedyQubitManager as GreedyQubitManager
 
-from cirq.ops.qubit_order import QubitOrder
+from cirq.ops.qubit_order import QubitOrder as QubitOrder
 
-from cirq.ops.qubit_order_or_list import QubitOrderOrList
+from cirq.ops.qubit_order_or_list import QubitOrderOrList as QubitOrderOrList
 
-from cirq.ops.matrix_gates import MatrixGate
+from cirq.ops.matrix_gates import MatrixGate as MatrixGate
 
 from cirq.ops.measure_util import (
-    M,
-    measure,
-    measure_each,
-    measure_paulistring_terms,
-    measure_single_paulistring,
+    M as M,
+    measure as measure,
+    measure_each as measure_each,
+    measure_paulistring_terms as measure_paulistring_terms,
+    measure_single_paulistring as measure_single_paulistring,
 )
 
-from cirq.ops.measurement_gate import MeasurementGate
+from cirq.ops.measurement_gate import MeasurementGate as MeasurementGate
 
-from cirq.ops.named_qubit import NamedQubit, NamedQid
+from cirq.ops.named_qubit import NamedQubit as NamedQubit, NamedQid as NamedQid
 
 from cirq.ops.op_tree import (
-    flatten_op_tree,
-    freeze_op_tree,
-    flatten_to_ops,
-    flatten_to_ops_or_moments,
-    OP_TREE,
-    transform_op_tree,
+    flatten_op_tree as flatten_op_tree,
+    freeze_op_tree as freeze_op_tree,
+    flatten_to_ops as flatten_to_ops,
+    flatten_to_ops_or_moments as flatten_to_ops_or_moments,
+    OP_TREE as OP_TREE,
+    transform_op_tree as transform_op_tree,
 )
 
-from cirq.ops.parity_gates import XX, XXPowGate, YY, YYPowGate, ZZ, ZZPowGate, MSGate, ms
+from cirq.ops.parity_gates import (
+    XX as XX,
+    XXPowGate as XXPowGate,
+    YY as YY,
+    YYPowGate as YYPowGate,
+    ZZ as ZZ,
+    ZZPowGate as ZZPowGate,
+    MSGate as MSGate,
+    ms as ms,
+)
 
-from cirq.ops.pauli_gates import Pauli, X, Y, Z
+from cirq.ops.pauli_gates import Pauli as Pauli, X as X, Y as Y, Z as Z
 
-from cirq.ops.pauli_interaction_gate import PauliInteractionGate
+from cirq.ops.pauli_interaction_gate import PauliInteractionGate as PauliInteractionGate
 
 from cirq.ops.pauli_string import (
-    MutablePauliString,
-    PAULI_GATE_LIKE,
-    PAULI_STRING_LIKE,
-    PauliString,
-    SingleQubitPauliStringGateOperation,
+    MutablePauliString as MutablePauliString,
+    PAULI_GATE_LIKE as PAULI_GATE_LIKE,
+    PAULI_STRING_LIKE as PAULI_STRING_LIKE,
+    PauliString as PauliString,
+    SingleQubitPauliStringGateOperation as SingleQubitPauliStringGateOperation,
 )
 
-from cirq.ops.pauli_string_phasor import PauliStringPhasor, PauliStringPhasorGate
+from cirq.ops.pauli_string_phasor import (
+    PauliStringPhasor as PauliStringPhasor,
+    PauliStringPhasorGate as PauliStringPhasorGate,
+)
 
-from cirq.ops.pauli_string_raw_types import PauliStringGateOperation
+from cirq.ops.pauli_string_raw_types import PauliStringGateOperation as PauliStringGateOperation
 
-from cirq.ops.permutation_gate import QubitPermutationGate
+from cirq.ops.permutation_gate import QubitPermutationGate as QubitPermutationGate
 
-from cirq.ops.phased_iswap_gate import givens, PhasedISwapPowGate
+from cirq.ops.phased_iswap_gate import givens as givens, PhasedISwapPowGate as PhasedISwapPowGate
 
-from cirq.ops.phased_x_gate import PhasedXPowGate
+from cirq.ops.phased_x_gate import PhasedXPowGate as PhasedXPowGate
 
-from cirq.ops.phased_x_z_gate import PhasedXZGate
+from cirq.ops.phased_x_z_gate import PhasedXZGate as PhasedXZGate
 
-from cirq.ops.qid_util import q
+from cirq.ops.qid_util import q as q
 
-from cirq.ops.random_gate_channel import RandomGateChannel
+from cirq.ops.random_gate_channel import RandomGateChannel as RandomGateChannel
 
-from cirq.ops.raw_types import Gate, Operation, Qid, TaggedOperation
+from cirq.ops.raw_types import (
+    Gate as Gate,
+    Operation as Operation,
+    Qid as Qid,
+    TaggedOperation as TaggedOperation,
+)
 
 from cirq.ops.swap_gates import (
-    ISWAP,
-    ISwapPowGate,
-    ISWAP_INV,
-    riswap,
-    SQRT_ISWAP,
-    SQRT_ISWAP_INV,
-    SWAP,
-    SwapPowGate,
+    ISWAP as ISWAP,
+    ISwapPowGate as ISwapPowGate,
+    ISWAP_INV as ISWAP_INV,
+    riswap as riswap,
+    SQRT_ISWAP as SQRT_ISWAP,
+    SQRT_ISWAP_INV as SQRT_ISWAP_INV,
+    SWAP as SWAP,
+    SwapPowGate as SwapPowGate,
 )
 
-from cirq.ops.tags import RoutingSwapTag, VirtualTag
+from cirq.ops.tags import RoutingSwapTag as RoutingSwapTag, VirtualTag as VirtualTag
 
 from cirq.ops.three_qubit_gates import (
-    CCNOT,
-    CCNotPowGate,
-    CCX,
-    CCXPowGate,
-    CCZ,
-    CCZPowGate,
-    CSWAP,
-    CSwapGate,
-    FREDKIN,
-    ThreeQubitDiagonalGate,
-    TOFFOLI,
+    CCNOT as CCNOT,
+    CCNotPowGate as CCNotPowGate,
+    CCX as CCX,
+    CCXPowGate as CCXPowGate,
+    CCZ as CCZ,
+    CCZPowGate as CCZPowGate,
+    CSWAP as CSWAP,
+    CSwapGate as CSwapGate,
+    FREDKIN as FREDKIN,
+    ThreeQubitDiagonalGate as ThreeQubitDiagonalGate,
+    TOFFOLI as TOFFOLI,
 )
 
-from cirq.ops.two_qubit_diagonal_gate import TwoQubitDiagonalGate
+from cirq.ops.two_qubit_diagonal_gate import TwoQubitDiagonalGate as TwoQubitDiagonalGate
 
-from cirq.ops.wait_gate import wait, WaitGate
+from cirq.ops.wait_gate import wait as wait, WaitGate as WaitGate
 
-from cirq.ops.state_preparation_channel import StatePreparationChannel
+from cirq.ops.state_preparation_channel import StatePreparationChannel as StatePreparationChannel
 
-from cirq.ops.control_values import AbstractControlValues, ProductOfSums, SumOfProducts
+from cirq.ops.control_values import (
+    AbstractControlValues as AbstractControlValues,
+    ProductOfSums as ProductOfSums,
+    SumOfProducts as SumOfProducts,
+)
 
-from cirq.ops.uniform_superposition_gate import UniformSuperpositionGate
+from cirq.ops.uniform_superposition_gate import UniformSuperpositionGate as UniformSuperpositionGate

cirq/ops/arithmetic_operation.py

@@ -15,10 +15,10 @@
 
 import abc
 import itertools
-from typing import Union, Iterable, List, Sequence, cast, Tuple, TYPE_CHECKING
-from typing_extensions import Self
+from typing import cast, Iterable, List, Sequence, Tuple, TYPE_CHECKING, Union
 
 import numpy as np
+from typing_extensions import Self
 
 from cirq.ops.raw_types import Gate
 

cirq/ops/arithmetic_operation_test.py

@@ -12,10 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Union, Sequence
+from typing import Sequence, Union
 
-import pytest
 import numpy as np
+import pytest
 
 import cirq
 

cirq/ops/boolean_hamiltonian.py

@@ -31,7 +31,8 @@ import sympy.parsing.sympy_parser as sympy_parser
 import cirq
 from cirq import value
 from cirq.ops import raw_types
-from cirq.ops.linear_combinations import PauliSum, PauliString
+from cirq.ops.linear_combinations import PauliSum
+from cirq.ops.pauli_string import PauliString
 
 
 @value.value_equality
@@ -80,7 +81,7 @@ class BooleanHamiltonianGate(raw_types.Gate):
         return (2,) * len(self._parameter_names)
 
     def _value_equality_values_(self) -> Any:
-        return self._parameter_names, self._boolean_strs, self._theta
+        return tuple(self._parameter_names), tuple(self._boolean_strs), self._theta
 
     def _json_dict_(self) -> Dict[str, Any]:
         return {

cirq/ops/classically_controlled_operation.py

@@ -14,14 +14,14 @@
 from typing import (
     AbstractSet,
     Any,
-    Mapping,
     Dict,
     FrozenSet,
     List,
+    Mapping,
     Optional,
     Sequence,
-    TYPE_CHECKING,
     Tuple,
+    TYPE_CHECKING,
     Union,
 )
 
@@ -45,6 +45,36 @@ class ClassicallyControlledOperation(raw_types.Operation):
 
     This object is typically created via
      `operation.with_classical_controls(*conditions)`.
+
+    Examples:
+
+    >>> import cirq
+    >>> a, b, c = cirq.LineQubit.range(3)
+    >>> circuit1 = cirq.Circuit(
+    ...     cirq.measure(a, key='control_key'),
+    ...     cirq.X(b).with_classical_controls('control_key'))
+    >>> print(circuit1)
+    0: ─────────────M───────
+                    ║
+    1: ─────────────╫───X───
+                    ║   ║
+    control_key: ═══@═══^═══
+    >>> circuit2 = cirq.Circuit([
+    ...     cirq.measure(a, key='control_key1'),
+    ...     cirq.measure(b, key='control_key2'),
+    ...     cirq.X(c).with_classical_controls('control_key1', 'control_key2')])
+    >>> print(circuit2)
+                     ┌──┐
+    0: ───────────────M─────────
+                      ║
+    1: ───────────────╫M────────
+                      ║║
+    2: ───────────────╫╫────X───
+                      ║║    ║
+    control_key1: ════@╬════^═══
+                       ║    ║
+    control_key2: ═════@════^═══
+                     └──┘
     """
 
     def __init__(
@@ -169,15 +199,12 @@ class ClassicallyControlledOperation(raw_types.Operation):
                 + ', '.join(str(c) for c in self._conditions)
                 + '])',
             ) + wire_symbols[1:]
-        exponent_qubit_index = None
-        if sub_info.exponent_qubit_index is not None:
-            exponent_qubit_index = sub_info.exponent_qubit_index + control_label_count
-        elif sub_info.exponent is not None:
-            exponent_qubit_index = control_label_count
+        exp_index = sub_info.exponent_qubit_index
+        if exp_index is None:
+            # None means at bottom, which means the last of the original wire symbols
+            exp_index = len(sub_info.wire_symbols) - 1
         return protocols.CircuitDiagramInfo(
-            wire_symbols=wire_symbols,
-            exponent=sub_info.exponent,
-            exponent_qubit_index=exponent_qubit_index,
+            wire_symbols=wire_symbols, exponent=sub_info.exponent, exponent_qubit_index=exp_index
         )
 
     def _json_dict_(self) -> Dict[str, Any]:
@@ -216,10 +243,10 @@ class ClassicallyControlledOperation(raw_types.Operation):
         return local_keys.union(protocols.control_keys(self._sub_operation))
 
     def _qasm_(self, args: 'cirq.QasmArgs') -> Optional[str]:
-        args.validate_version('2.0')
+        args.validate_version('2.0', '3.0')
         if len(self._conditions) > 1:
             raise ValueError('QASM does not support multiple conditions.')
         subop_qasm = protocols.qasm(self._sub_operation, args=args)
         if not self._conditions:
             return subop_qasm
-        return f'if ({self._conditions[0].qasm}) {subop_qasm}'
+        return f'if ({protocols.qasm(self._conditions[0], args=args)}) {subop_qasm}'

cirq/ops/classically_controlled_operation_test.py

@@ -196,7 +196,7 @@ a: ═══@═══╩══════════════════
     )
 
 
-def test_qasm():
+def test_qasm_sympy_condition():
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.measure(q0, key='a'),
@@ -222,6 +222,29 @@ if (m_a==0) x q[1];
     )
 
 
+def test_qasm_key_condition():
+    q0, q1 = cirq.LineQubit.range(2)
+    circuit = cirq.Circuit(cirq.measure(q0, key='a'), cirq.X(q1).with_classical_controls('a'))
+    qasm = cirq.qasm(circuit)
+    assert (
+        qasm
+        == f"""// Generated from Cirq v{cirq.__version__}
+
+OPENQASM 2.0;
+include "qelib1.inc";
+
+
+// Qubits: [q(0), q(1)]
+qreg q[2];
+creg m_a[1];
+
+
+measure q[0] -> m_a[0];
+if (m_a==1) x q[1];
+"""
+    )
+
+
 def test_qasm_no_conditions():
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
@@ -1033,3 +1056,126 @@ def test_moment_diagram():
   │
     """.strip()
     )
+
+
+def test_diagram_exponents():
+    q0, q1 = cirq.LineQubit.range(2)
+    circuit = cirq.Circuit(
+        cirq.measure(q0, key='m'), (cirq.X(q1) ** 0.5).with_classical_controls('m')
+    )
+    cirq.testing.assert_has_diagram(
+        circuit,
+        """
+0: ───M───────────
+      ║
+1: ───╫───X^0.5───
+      ║   ║
+m: ═══@═══^═══════
+""",
+    )
+
+
+def test_diagram_exponents_cx():
+    q0, q1, q2 = cirq.LineQubit.range(3)
+    circuit = cirq.Circuit(
+        cirq.measure(q0, key='m'), (cirq.CX(q2, q1) ** 0.5).with_classical_controls('m')
+    )
+    cirq.testing.assert_has_diagram(
+        circuit,
+        """
+0: ───M───────────
+      ║
+1: ───╫───X^0.5───
+      ║   ║
+2: ───╫───@───────
+      ║   ║
+m: ═══@═══^═══════
+""",
+    )
+
+
+def test_diagram_exponents_multiple_keys():
+    q0, q1, q2 = cirq.LineQubit.range(3)
+    circuit = cirq.Circuit(
+        cirq.measure(q0, key='m0'),
+        cirq.measure(q1, key='m1'),
+        (cirq.X(q2) ** 0.5).with_classical_controls('m0', 'm1'),
+    )
+    cirq.testing.assert_has_diagram(
+        circuit,
+        """
+       ┌──┐
+0: ─────M─────────────
+        ║
+1: ─────╫M────────────
+        ║║
+2: ─────╫╫────X^0.5───
+        ║║    ║
+m0: ════@╬════^═══════
+         ║    ║
+m1: ═════@════^═══════
+       └──┘
+""",
+    )
+
+
+def test_sympy_indexed_condition_circuit():
+    a = sympy.IndexedBase('a')
+    # XOR the 2nd and 3rd bits of the measurement (big-endian)
+    cond = cirq.SympyCondition(sympy.Xor(a[1], a[2]))
+    q0, q1, q2, q3 = cirq.LineQubit.range(4)
+    sim = cirq.Simulator()
+    circuit = cirq.Circuit(
+        cirq.measure(q0, q1, q2, key='a'),
+        cirq.X(q3).with_classical_controls(cond),
+        cirq.measure(q3, key='b'),
+    )
+    cirq.testing.assert_has_diagram(
+        circuit,
+        """
+0: ───M──────────────────────────────────────────
+      ║
+1: ───M──────────────────────────────────────────
+      ║
+2: ───M──────────────────────────────────────────
+      ║
+3: ───╫───X(conditions=[a[1] ^ a[2]])───M('b')───
+      ║   ║
+a: ═══@═══^══════════════════════════════════════
+""",
+    )
+    result = sim.sample(circuit)
+    assert result['a'][0] == 0b000
+    assert result['b'][0] == 0
+    circuit.insert(0, cirq.X(q2))
+    result = sim.sample(circuit)
+    assert result['a'][0] == 0b001
+    assert result['b'][0] == 1
+    circuit.insert(0, cirq.X(q1))
+    circuit.insert(0, cirq.X(q2))
+    result = sim.sample(circuit)
+    assert result['a'][0] == 0b010
+    assert result['b'][0] == 1
+    circuit.insert(0, cirq.X(q2))
+    result = sim.sample(circuit)
+    assert result['a'][0] == 0b011
+    assert result['b'][0] == 0
+    circuit.insert(0, cirq.X(q0))
+    circuit.insert(0, cirq.X(q1))
+    circuit.insert(0, cirq.X(q2))
+    result = sim.sample(circuit)
+    assert result['a'][0] == 0b100
+    assert result['b'][0] == 0
+    circuit.insert(0, cirq.X(q2))
+    result = sim.sample(circuit)
+    assert result['a'][0] == 0b101
+    assert result['b'][0] == 1
+    circuit.insert(0, cirq.X(q1))
+    circuit.insert(0, cirq.X(q2))
+    result = sim.sample(circuit)
+    assert result['a'][0] == 0b110
+    assert result['b'][0] == 1
+    circuit.insert(0, cirq.X(q2))
+    result = sim.sample(circuit)
+    assert result['a'][0] == 0b111
+    assert result['b'][0] == 0