hybridlane.ops.qumode.Beamsplitter

class hybridlane.ops.qumode.Beamsplitter(theta, phi, wires, id=None)

Bases: pennylane.operation.CVOperation

Beamsplitter gate \(BS(\theta, \varphi)\)

\[BS(\theta,\varphi) = \exp\left[-i \frac{\theta}{2} (e^{i\varphi} \ad b + e^{-i\varphi}ab^\dagger)\right]\]
Parameters:

  • theta (pennylane.typing.TensorLike)

  • phi (pennylane.typing.TensorLike)

  • wires (pennylane.wires.WiresLike)

  • id (str | None)

num_params = 2

Number of trainable parameters that the operator depends on.

By default, this property returns as many parameters as were used for the operator creation. If the number of parameters for an operator subclass is fixed, this property can be overwritten to return the fixed value.

Returns:

number of parameters

Return type:

int

num_wires = 2

Number of wires the operator acts on.

ndim_params = (0, 0)

Number of dimensions per trainable parameter of the operator.

By default, this property returns the numbers of dimensions of the parameters used for the operator creation. If the parameter sizes for an operator subclass are fixed, this property can be overwritten to return the fixed value.

Returns:

Number of dimensions for each trainable parameter.

Return type:

tuple

grad_method = 'A'

Gradient computation method.

  • 'A': analytic differentiation using the parameter-shift method.

  • 'F': finite difference numerical differentiation.

  • None: the operation may not be differentiated.

Default is 'F', or None if the Operation has zero parameters.

grad_recipe

Gradient recipe for the parameter-shift method.

This is a tuple with one nested list per operation parameter. For parameter \(\phi_k\), the nested list contains elements of the form \([c_i, a_i, s_i]\) where \(i\) is the index of the term, resulting in a gradient recipe of

\[\frac{\partial}{\partial\phi_k}f = \sum_{i} c_i f(a_i \phi_k + s_i).\]

If None, the default gradient recipe containing the two terms \([c_0, a_0, s_0]=[1/2, 1, \pi/2]\) and \([c_1, a_1, s_1]=[-1/2, 1, -\pi/2]\) is assumed for every parameter.

Type:

tuple(Union(list[list[float]], None)) or None

resource_keys

The set of parameters that affects the resource requirement of the operator.

All decomposition rules for this operator class are expected to have a resource function that accepts keyword arguments that match these keys exactly. The resource_rep() function will also expect keyword arguments that match these keys when called with this operator type.

The default implementation is an empty set, which is suitable for most operators.

See also

resource_params()

property resource_params

A dictionary containing the minimal information needed to compute a resource estimate of the operator’s decomposition.

The keys of this dictionary should match the resource_keys attribute of the operator class. Two instances of the same operator type should have identical resource_params iff their decompositions exhibit the same counts for each gate type, even if the individual gate parameters differ.

Examples

The MultiRZ has non-empty resource_keys:

>>> qml.MultiRZ.resource_keys
{'num_wires'}

The resource_params of an instance of MultiRZ will contain the number of wires:

>>> op = qml.MultiRZ(0.5, wires=[0, 1])
>>> op.resource_params
{'num_wires': 2}

Note that another MultiRZ may have different parameters but the same resource_params:

>>> op2 = qml.MultiRZ(0.7, wires=[1, 2])
>>> op2.resource_params
{'num_wires': 2}
adjoint()

Create an operation that is the adjoint of this one. Used to simplify Adjoint operators constructed by adjoint().

Adjointed operations are the conjugated and transposed version of the original operation. Adjointed ops are equivalent to the inverted operation for unitary gates.

Operator.adjoint can be optionally defined by Operator developers, while adjoint() is the entry point for constructing generic adjoint representations.

Returns:

The adjointed operation.

>>> class MyClass(qml.operation.Operator):
...
...     def adjoint(self):
...         return self
...
>>> op = qml.adjoint(MyClass(wires=0))
>>> op
Adjoint(MyClass(wires=[0]))
>>> op.decomposition()
[MyClass(wires=[0])]
>>> op.simplify()
MyClass(wires=[0])
simplify()

Reduce the depth of nested operators to the minimum.

Returns:

simplified operator

Return type:

.Operator

label(decimals=None, base_label=None, cache=None)

A customizable string representation of the operator.

Parameters:

  • decimals=None (int) – If None, no parameters are included. Else, specifies how to round the parameters.

  • base_label=None (str) – overwrite the non-parameter component of the label

  • cache=None (dict) – dictionary that carries information between label calls in the same drawing

Returns:

label to use in drawings

Return type:

str

Example:

>>> op = qml.RX(1.23456, wires=0)
>>> op.label()
'RX'
>>> op.label(base_label="my_label")
'my_label'
>>> op = qml.RX(1.23456, wires=0, id="test_data")
>>> op.label()
'RX\n("test_data")'
>>> op.label(decimals=2)
'RX\n(1.23,"test_data")'
>>> op.label(base_label="my_label")
'my_label\n("test_data")'
>>> op.label(decimals=2, base_label="my_label")
'my_label\n(1.23,"test_data")'

If the operation has a matrix-valued parameter and a cache dictionary is provided, unique matrices will be cached in the 'matrices' key list. The label will contain the index of the matrix in the 'matrices' list.

>>> op2 = qml.QubitUnitary(np.eye(2), wires=0)
>>> cache = {'matrices': []}
>>> op2.label(cache=cache)
'U\n(M0)'
>>> cache['matrices']
[tensor([[1., 0.],
 [0., 1.]], requires_grad=True)]
>>> op3 = qml.QubitUnitary(np.eye(4), wires=(0,1))
>>> op3.label(cache=cache)
'U\n(M1)'
>>> cache['matrices']
[tensor([[1., 0.],
        [0., 1.]], requires_grad=True),
tensor([[1., 0., 0., 0.],
        [0., 1., 0., 0.],
        [0., 0., 1., 0.],
        [0., 0., 0., 1.]], requires_grad=True)]