sf.circuitspecs.GaussianUnitary¶

class
GaussianUnitary
[source]¶ Bases:
strawberryfields.circuitspecs.circuit_specs.CircuitSpecs
Compiler to arrange a Gaussian quantum circuit into the canonical Symplectic form. This compile specification checks whether the circuit can be implemented as a sequence of Gaussian operations. If so, it arranges them in the canonical order with displacement at the end. After compilation, the circuit will consist of at most two operations, a
GaussianTransform
and aDgate
. This compiler can be accessed by callingProgram.compile()
with ‘gaussian_unitary’ specified.Example:
Consider the following Strawberry Fields program, compiled using the ‘gaussian_unitary’ compiler:
from strawberryfields.ops import Xgate, Zgate, Sgate, Dgate, Rgate import strawberryfields as sf circuit = sf.Program(1) with circuit.context as q: Xgate(0.4)  q[0] Zgate(0.5)  q[0] Sgate(0.6)  q[0] Dgate(1.0+2.0j)  q[0] Rgate(0.3)  q[0] Sgate(0.6, 1.0)  q[0] compiled_circuit = circuit.compile("gaussian_unitary")
We can now print the compiled circuit, consisting of one
GaussianTransform
and oneDgate
:>>> compiled_circuit.print() GaussianTransform([[ 0.3543 1.3857] [0.0328 2.9508]])  (q[0]) Dgate(1.151+3.91j, 0)  (q[0])
Attributes
A rigid circuit template that defines this circuit specification.
The allowed circuit topologies or connectivity of the class, modelled as a directed acyclic graph.
Allowed parameter ranges for supported quantum operations.

circuit
¶ A rigid circuit template that defines this circuit specification.
This property is optional. If arbitrary topologies are allowed in the circuit class, do not define this property. In such a case, it will simply return
None
.If a backend device expects a specific template for the recieved Blackbird script, this method will return the serialized Blackbird circuit in string form.
 Returns
Blackbird program or template representing the circuit
 Return type
Union[str, None]

decompositions
= {'BipartiteGraphEmbed': {}, 'CXgate': {}, 'CZgate': {}, 'Fouriergate': {}, 'Gaussian': {}, 'GraphEmbed': {}, 'MZgate': {}, 'Pgate': {}, 'Xgate': {}, 'Zgate': {}}¶

graph
¶ The allowed circuit topologies or connectivity of the class, modelled as a directed acyclic graph.
This property is optional; if arbitrary topologies are allowed in the circuit class, this will simply return
None
. Returns
a directed acyclic graph
 Return type
networkx.DiGraph

interactive
= True¶

local
= True¶

modes
= None¶

parameter_ranges
¶ Allowed parameter ranges for supported quantum operations.
This property is optional.
 Returns
a dictionary mapping an allowed quantum operation to a nested list of the form
[[p0_min, p0_max], [p1_min, p0_max], ...]
. wherepi
corresponds to thei
th gate parameter Return type
dict[str, list]

primitives
= {'All', 'BSgate', 'Dgate', 'GaussianTransform', 'Interferometer', 'Rgate', 'S2gate', 'Sgate', '_Delete', '_New_modes'}¶

remote
= True¶

short_name
= 'gaussian_unitary'¶
Methods
compile
(seq, registers)Try to arrange a quantum circuit into the canonical Symplectic form.
decompose
(seq)Recursively decompose all gates in a given sequence, as allowed by the circuit specification.

compile
(seq, registers)[source]¶ Try to arrange a quantum circuit into the canonical Symplectic form.
This method checks whether the circuit can be implemented as a sequence of Gaussian operations. If the answer is yes it arranges them in the canonical order with displacement at the end.
 Parameters
seq (Sequence[Command]) – quantum circuit to modify
registers (Sequence[RegRefs]) – quantum registers
 Returns
modified circuit
 Return type
List[Command]
 Raises
CircuitError – the circuit does not correspond to a Gaussian unitary

decompose
(seq)¶ Recursively decompose all gates in a given sequence, as allowed by the circuit specification.
This method follows the directives defined in the
primitives
anddecompositions
class attributes to determine whether a command should be decomposed.The order of precedence to determine whether decomposition should be applied is as follows.
First, we check if the operation is in
decompositions
. If not, decomposition is skipped, and the operation is applied as a primitive (if supported by theCircuitSpecs
).Next, we check if (a) the operation supports decomposition, and (b) if the user has explicitly requested no decomposition.
If both (a) and (b) are true, the operation is applied as a primitive (if supported by the
CircuitSpecs
).Otherwise, we attempt to decompose the operation by calling
decompose()
recursively.
 Parameters
list[strawberryfields.program_utils.Command] – list of commands to be decomposed
 Returns
list of compiled commands for the circuit specification
 Return type

Downloads