def test_simulation_qft_circuit(qft_circuit_operations, batch_size):
qubit_count = 16
simulation = StateVectorSimulation(qubit_count, 0, batch_size)
operations = qft_circuit_operations(qubit_count)
simulation.evolve(operations)
assert np.allclose(simulation.probabilities,
[1 / (2**qubit_count)] * (2**qubit_count))
def test_simulation_simple_circuits(instructions, qubit_count, state_vector,
probability_amplitudes):
# +2 to ensure evolve doesn't fail for partition size greater than
# or equal to the number of instructions
for batch_size in range(1, len(instructions) + 2):
simulation = StateVectorSimulation(qubit_count, 0, batch_size)
simulation.evolve(instructions)
assert np.allclose(state_vector, simulation.state_vector)
assert np.allclose(probability_amplitudes, simulation.probabilities)
def test_simulation_retrieve_samples(batch_size):
simulation = StateVectorSimulation(2, 10000, batch_size)
simulation.evolve(
[gate_operations.Hadamard([0]),
gate_operations.CX([0, 1])])
counter = Counter(simulation.retrieve_samples())
assert simulation.qubit_count == 2
assert counter.keys() == {0, 3}
assert 0.4 < counter[0] / (counter[0] + counter[3]) < 0.6
assert 0.4 < counter[3] / (counter[0] + counter[3]) < 0.6
assert counter[0] + counter[3] == 10000
def test_apply_observables(observables, equivalent_gates, qubit_count,
batch_size):
sim_observables = StateVectorSimulation(qubit_count, 0, batch_size)
sim_observables.apply_observables(observables)
sim_gates = StateVectorSimulation(qubit_count, 0, batch_size)
sim_gates.evolve(equivalent_gates)
assert np.allclose(sim_observables.state_with_observables,
sim_gates.state_vector)
def _formatted_measurements(
simulation: StateVectorSimulation) -> List[List[str]]:
""" Retrieves formatted measurements obtained from the specified simulation.
Args:
simulation (StateVectorSimulation): Simulation to use for obtaining the measurements.
Returns:
List[List[str]]: List containing the measurements, where each measurement consists
of a list of measured values of qubits.
"""
return [
list("{number:0{width}b}".format(number=sample,
width=simulation.qubit_count))
for sample in simulation.retrieve_samples()
]
def run(
self,
circuit_ir: Program,
qubit_count: int,
shots: int = 0,
*,
batch_size: int = 1,
) -> GateModelTaskResult:
""" Executes the circuit specified by the supplied `circuit_ir` on the simulator.
Args:
circuit_ir (Program): ir representation of a braket circuit specifying the
instructions to execute.
qubit_count (int): The number of qubits to simulate.
shots (int): The number of times to run the circuit.
batch_size (int): The size of the circuit partitions to contract,
if applying multiple gates at a time is desired; see `StateVectorSimulation`.
Must be a positive integer.
Defaults to 1, which means gates are applied one at a time without any
optmized contraction.
Returns:
GateModelTaskResult: object that represents the result
Raises:
ValueError: If result types are not specified in the IR or sample is specified
as a result type when shots=0. Or, if statevector and amplitude result types
are requested when shots>0.
Examples:
>>> circuit_ir = Circuit().h(0).to_ir()
>>> DefaultSimulator().run(circuit_ir, qubit_count=1, shots=100)
>>> circuit_ir = Circuit().h(0).to_ir()
>>> DefaultSimulator().run(circuit_ir, qubit_count=1, batch_size=10)
"""
DefaultSimulator._validate_shots_and_ir_results(
shots, circuit_ir, qubit_count)
operations = [
from_braket_instruction(instruction)
for instruction in circuit_ir.instructions
]
if shots > 0 and circuit_ir.basis_rotation_instructions:
for instruction in circuit_ir.basis_rotation_instructions:
operations.append(from_braket_instruction(instruction))
DefaultSimulator._validate_operation_qubits(operations)
simulation = StateVectorSimulation(qubit_count,
shots,
batch_size=batch_size)
simulation.evolve(operations)
results = []
if not shots and circuit_ir.results:
(
non_observable_result_types,
observable_result_types,
) = DefaultSimulator._translate_result_types(circuit_ir)
observables = DefaultSimulator._validate_and_consolidate_observable_result_types(
list(observable_result_types.values()), qubit_count)
results = DefaultSimulator._generate_results(
circuit_ir,
non_observable_result_types,
observable_result_types,
observables,
simulation,
)
return DefaultSimulator._create_results_obj(results, circuit_ir,
simulation)
def test_instantiation_fails_batch_size_nonpositive(batch_size):
StateVectorSimulation(4, 0, batch_size)
def test_instantiation_fails_batch_size_wrong_type(batch_size):
StateVectorSimulation(4, 0, batch_size)
def test_build_contraction_fails_unrecognised_operation(batch_size):
simulation = StateVectorSimulation(4, 0, batch_size)
simulation.evolve([gate_operations.PauliX([0]), "foo"])
def test_state_with_observables_fails_before_applying(batch_size):
StateVectorSimulation(4, 0, batch_size).state_with_observables
def test_apply_observables_fails_second_call(batch_size):
simulation = StateVectorSimulation(4, 0, batch_size)
simulation.apply_observables([observables.PauliX([0])])
simulation.apply_observables([observables.PauliX([0])])