cirq_aqt.aqt_target_gateset.AQTTargetGateset

Target gateset accepting XXPowGate + X/Y/Z/PhX single qubit rotations + measurement gates.

cirq_aqt.aqt_target_gateset.AQTTargetGateset()

By default, cirq_aqt.AQTTargetGateset will accept and compile unknown gates to the following universal target gateset:

Args
`*gates`	A list of `cirq.Gate` subclasses / `cirq.Gate` instances / `cirq.GateFamily` instances to initialize the Gateset.
`name`	(Optional) Name for the Gateset. Useful for description.
`unroll_circuit_op`	If True, `cirq.CircuitOperation` is recursively validated by validating the underlying `cirq.Circuit`.
`preserve_moment_structure`	Whether to preserve the moment structure of the circuit during compilation or not.

Attributes
`gates`
`name`
`num_qubits`	Maximum number of qubits on which a gate from this gateset can act upon.
`postprocess_transformers`	List of transformers which should be run after decomposing individual operations.
`preprocess_transformers`	List of transformers which should be run before decomposing individual operations.

Methods

decompose_to_target_gateset(
    op: 'cirq.Operation', moment_idx: int
) -> cirq_aqt.aqt_target_gateset.DecomposeResult

Method to rewrite the given operation using gates from this gateset.

Args
`op`	`cirq.Operation` to be rewritten using gates from this gateset.
`moment_idx`	Moment index where the given operation `op` occurs in a circuit.

Returns

Returns
An equivalent `cirq.OP_TREE` implementing `op` using gates from this gateset. `None` or `NotImplemented` if does not know how to decompose `op`.

validate(
    circuit_or_optree: Union['cirq.AbstractCircuit', op_tree.OP_TREE]
) -> bool

Validates gates forming circuit_or_optree should be contained in Gateset.

Args
`circuit_or_optree`	The `cirq.Circuit` or `cirq.OP_TREE` to validate.

with_params(
    *, name: Optional[str] = None, unroll_circuit_op: Optional[bool] = None
) -> 'Gateset'

Returns a copy of this Gateset with identical gates and new values for named arguments.

If a named argument is None then corresponding value of this Gateset is used instead.

Args
`name`	New name for the Gateset.
`unroll_circuit_op`	If True, new Gateset will recursively validate `cirq.CircuitOperation` by validating the underlying `cirq.Circuit`.

Returns
`self` if all new values are None or identical to the values of current Gateset. else a new Gateset with identical gates and new values for named arguments.

__contains__(
    item: Union[raw_types.Gate, raw_types.Operation]
) -> bool

Check for containment of a given Gate/Operation in this Gateset.

Containment checks are handled as follows:

For Gates or Operations that have an underlying gate (i.e. op.gate is not None):
- Forwards the containment check to the underlying cirq.GateFamily objects.
- Examples of such operations include cirq.GateOperations and their controlled and tagged variants (i.e. instances of cirq.TaggedOperation, cirq.ControlledOperation where op.gate is not None) etc.
For Operations that do not have an underlying gate:
- Forwards the containment check to self._validate_operation(item).
- Examples of such operations include cirq.CircuitOperations and their controlled and tagged variants (i.e. instances of cirq.TaggedOperation, cirq.ControlledOperation where op.gate is None) etc.

The complexity of the method in terms of the number of gates, n, is

O(1) when any default cirq.GateFamily instance accepts the given item, except for an Instance GateFamily trying to match an item with a different global phase.
O(n) for all other cases: matching against custom gate families, matching across global phase for the default Instance GateFamily, no match against any underlying gate family.

Args
`item`	The `cirq.Gate` or `cirq.Operation` instance to check containment for.

__eq__(
    other: _SupportsValueEquality
) -> bool

__ne__(
    other: _SupportsValueEquality
) -> bool