def to_ir(
self,
target: QubitSet,
ir_type: IRType = IRType.JAQCD,
serialization_properties: SerializationProperties = None,
) -> Any:
"""Returns IR object of quantum operator and target
Args:
target (QubitSet): target qubit(s).
ir_type(IRType) : The IRType to use for converting the gate object to its
IR representation. Defaults to IRType.JAQCD.
serialization_properties (SerializationProperties): The serialization properties to use
while serializing the object to the IR representation. The serialization properties
supplied must correspond to the supplied `ir_type`. Defaults to None.
Returns:
Any: IR object of the quantum operator and target
Raises:
ValueError: If the supplied `ir_type` is not supported, or if the supplied serialization
properties don't correspond to the `ir_type`.
"""
if ir_type == IRType.JAQCD:
return self._to_jaqcd(target)
elif ir_type == IRType.OPENQASM:
if serialization_properties and not isinstance(
serialization_properties, OpenQASMSerializationProperties):
raise ValueError(
"serialization_properties must be of type OpenQASMSerializationProperties "
"for IRType.OPENQASM.")
return self._to_openqasm(
target, serialization_properties
or OpenQASMSerializationProperties())
else:
raise ValueError(f"Supplied ir_type {ir_type} is not supported.")
def test_from_circuit_with_verbatim(device_arn, device_parameters_class,
disable_qubit_rewiring, aws_session):
circ = Circuit().add_verbatim_box(Circuit().h(0))
mocked_task_arn = "task-arn-1"
aws_session.create_quantum_task.return_value = mocked_task_arn
shots = 1337
task = AwsQuantumTask.create(
aws_session,
device_arn,
circ,
S3_TARGET,
shots,
disable_qubit_rewiring=disable_qubit_rewiring,
)
assert task == AwsQuantumTask(mocked_task_arn, aws_session)
serialization_properties = OpenQASMSerializationProperties(
qubit_reference_type=QubitReferenceType.PHYSICAL)
_assert_create_quantum_task_called_with(
aws_session,
device_arn,
circ.to_ir(
ir_type=IRType.OPENQASM,
serialization_properties=serialization_properties,
).json(),
S3_TARGET,
shots,
device_parameters_class(paradigmParameters=GateModelParameters(
qubitCount=circ.qubit_count,
disableQubitRewiring=disable_qubit_rewiring)),
)
def test_from_circuit_with_disabled_rewiring(device_arn,
device_parameters_class,
aws_session, circuit):
mocked_task_arn = "task-arn-1"
aws_session.create_quantum_task.return_value = mocked_task_arn
shots = 53
task = AwsQuantumTask.create(aws_session,
device_arn,
circuit,
S3_TARGET,
shots,
disable_qubit_rewiring=True)
assert task == AwsQuantumTask(mocked_task_arn, aws_session)
_assert_create_quantum_task_called_with(
aws_session,
device_arn,
circuit.to_ir(
ir_type=IRType.OPENQASM,
serialization_properties=OpenQASMSerializationProperties(
QubitReferenceType.PHYSICAL),
).json(),
S3_TARGET,
shots,
device_parameters_class(paradigmParameters=GateModelParameters(
qubitCount=circuit.qubit_count, disableQubitRewiring=True)),
)
def _to_openqasm(self, serialization_properties: OpenQASMSerializationProperties) -> str:
if not self.target:
return "#pragma braket result probability all"
targets = ", ".join(
serialization_properties.format_target(int(target)) for target in self.target
)
return f"#pragma braket result probability {targets}"
def _to_openqasm(
self, target: QubitSet,
serialization_properties: OpenQASMSerializationProperties) -> str:
target_qubit_0 = serialization_properties.format_target(int(target[0]))
target_qubit_1 = serialization_properties.format_target(int(target[1]))
return (
f"#pragma braket noise two_qubit_dephasing({self.probability}) "
f"{target_qubit_0}, {target_qubit_1}")
def _(
circuit: Circuit,
aws_session: AwsSession,
create_task_kwargs: Dict[str, Any],
device_arn: str,
device_parameters: Union[
dict, BraketSchemaBase], # Not currently used for circuits
disable_qubit_rewiring: bool,
*args,
**kwargs,
) -> AwsQuantumTask:
validate_circuit_and_shots(circuit, create_task_kwargs["shots"])
# TODO: Update this to use `deviceCapabilities` from Amazon Braket's GetDevice operation
# in order to decide what parameters to build.
paradigm_parameters = GateModelParameters(
qubitCount=circuit.qubit_count,
disableQubitRewiring=disable_qubit_rewiring)
if "ionq" in device_arn:
device_parameters = IonqDeviceParameters(
paradigmParameters=paradigm_parameters)
elif "rigetti" in device_arn:
device_parameters = RigettiDeviceParameters(
paradigmParameters=paradigm_parameters)
elif "oqc" in device_arn:
device_parameters = OqcDeviceParameters(
paradigmParameters=paradigm_parameters)
else: # default to use simulator
device_parameters = GateModelSimulatorDeviceParameters(
paradigmParameters=paradigm_parameters)
qubit_reference_type = QubitReferenceType.VIRTUAL
if disable_qubit_rewiring or Instruction(
StartVerbatimBox()) in circuit.instructions:
qubit_reference_type = QubitReferenceType.PHYSICAL
serialization_properties = OpenQASMSerializationProperties(
qubit_reference_type=qubit_reference_type)
create_task_kwargs.update({
"action":
circuit.to_ir(
ir_type=IRType.OPENQASM,
serialization_properties=serialization_properties,
).json(),
"deviceParameters":
device_parameters.json(),
})
task_arn = aws_session.create_quantum_task(**create_task_kwargs)
return AwsQuantumTask(task_arn, aws_session, *args, **kwargs)
def _to_openqasm(
self, target: QubitSet,
serialization_properties: OpenQASMSerializationProperties) -> str:
matrix_list = ", ".join(
np.array2string(
matrix,
separator=", ",
formatter={
"all": lambda x: format_complex(x)
},
).replace("\n", "") for matrix in self._matrices)
qubit_list = ", ".join(
serialization_properties.format_target(int(qubit))
for qubit in target)
return f"#pragma braket noise kraus({matrix_list}) {qubit_list}"
def test_to_ir():
expected_target = QubitSet([0, 1])
expected_ir = "foo bar value"
expected_ir_type = IRType.OPENQASM
expected_serialization_properties = OpenQASMSerializationProperties(
qubit_reference_type=QubitReferenceType.PHYSICAL)
class FooGate(Gate):
def __init__(self):
super().__init__(qubit_count=2, ascii_symbols=["foo", "bar"])
def to_ir(self, target, ir_type, serialization_properties):
assert target == expected_target
assert ir_type == expected_ir_type
assert serialization_properties == expected_serialization_properties
return expected_ir
instr = Instruction(FooGate(), expected_target)
assert instr.to_ir(expected_ir_type,
expected_serialization_properties) == expected_ir
def to_ir(
self,
target: QubitSet = None,
ir_type: IRType = IRType.JAQCD,
serialization_properties: SerializationProperties = None,
) -> Union[str, List[Union[str, List[List[List[float]]]]]]:
"""Returns the IR representation for the observable
Args:
target (QubitSet): target qubit(s). Defaults to None.
ir_type(IRType) : The IRType to use for converting the result type object to its
IR representation. Defaults to IRType.JAQCD.
serialization_properties (SerializationProperties): The serialization properties to use
while serializing the object to the IR representation. The serialization properties
supplied must correspond to the supplied `ir_type`. Defaults to None.
Returns:
Union[str, List[Union[str, List[List[List[float]]]]]]: The IR representation for
the observable.
Raises:
ValueError: If the supplied `ir_type` is not supported, or if the supplied serialization
properties don't correspond to the `ir_type`.
"""
if ir_type == IRType.JAQCD:
return self._to_jaqcd()
elif ir_type == IRType.OPENQASM:
if serialization_properties and not isinstance(
serialization_properties, OpenQASMSerializationProperties):
raise ValueError(
"serialization_properties must be of type OpenQASMSerializationProperties "
"for IRType.OPENQASM.")
return self._to_openqasm(
serialization_properties or OpenQASMSerializationProperties(),
target)
else:
raise ValueError(f"Supplied ir_type {ir_type} is not supported.")
def test_ir_gate_level(testclass, subroutine_name, irclass, irsubclasses,
kwargs):
expected = irclass(**create_valid_ir_input(irsubclasses))
actual = testclass(
**create_valid_gate_class_input(irsubclasses, **kwargs)).to_ir(
**create_valid_target_input(irsubclasses))
assert actual == expected
@pytest.mark.parametrize(
"gate, target, serialization_properties, expected_ir",
[
(
Gate.Rx(angle=0.17),
[4],
OpenQASMSerializationProperties(
qubit_reference_type=QubitReferenceType.VIRTUAL),
"rx(0.17) q[4];",
),
(
Gate.Rx(angle=0.17),
[4],
OpenQASMSerializationProperties(
qubit_reference_type=QubitReferenceType.PHYSICAL),
"rx(0.17) $4;",
),
(
Gate.X(),
[4],
OpenQASMSerializationProperties(
qubit_reference_type=QubitReferenceType.VIRTUAL),
"x q[4];",
def _to_openqasm(
self, target: QubitSet,
serialization_properties: OpenQASMSerializationProperties) -> str:
target_qubit = serialization_properties.format_target(int(target[0]))
return f"#pragma braket noise bit_flip({self.probability}) {target_qubit}"
def _to_openqasm(
self, target: QubitSet,
serialization_properties: OpenQASMSerializationProperties) -> str:
target_qubit = serialization_properties.format_target(int(target[0]))
return (f"#pragma braket noise pauli_channel"
f"({self.probX}, {self.probY}, {self.probZ}) {target_qubit}")
def _to_openqasm(
self, target: QubitSet,
serialization_properties: OpenQASMSerializationProperties) -> str:
target_qubit = serialization_properties.format_target(int(target[0]))
return f"#pragma braket noise phase_damping({self.gamma}) {target_qubit}"
def _to_openqasm(
self, target: QubitSet,
serialization_properties: OpenQASMSerializationProperties) -> str:
target_qubit = serialization_properties.format_target(int(target[0]))
return ("#pragma braket noise generalized_amplitude_damping("
f"{self.gamma}, {self.probability}) {target_qubit}")
