cirq.contrib.graph_device.UndirectedGraphDevice

A device whose properties are represented by an edge-labelled graph.

Inherits From: Device

View aliases

Main aliases

cirq.contrib.graph_device.graph_device.UndirectedGraphDevice

cirq.contrib.graph_device.UndirectedGraphDevice(
    device_graph: Optional[cirq.contrib.graph_device.UndirectedHypergraph] = None,
    crosstalk_graph: Optional[cirq.contrib.graph_device.UndirectedHypergraph] = None
) -> None

Each (undirected) edge of the device graph is labelled by an UndirectedGraphDeviceEdge or None. None indicates that any operation is allowed and has zero duration.

Each (undirected) edge of the constraint graph is labelled either by a function or None. The function takes as arguments operations on the adjacent device edges and raises an error if they are not simultaneously executable. If None, no such operations are allowed.

Note that

* the crosstalk graph is allowed to have vertices (i.e. device edges)
    that do not exist in the graph device.
* duration_of does not check that operation is valid.

Attributes
`edges`
`labelled_edges`
`qubits`

Attributes

edges

labelled_edges

qubits

Methods

`can_add_operation_into_moment`

View source

can_add_operation_into_moment(
    operation: "cirq.Operation",
    moment: "cirq.Moment"
) -> bool

Determines if it's possible to add an operation into a moment.

For example, on the XmonDevice two CZs shouldn't be placed in the same moment if they are on adjacent qubits.

Args
`operation`	The operation being added.
`moment`	The moment being transformed.

Returns
Whether or not the moment will validate after adding the operation.

`decompose_operation`

View source

decompose_operation(
    operation: "cirq.Operation"
) -> "cirq.OP_TREE"

Returns a device-valid decomposition for the given operation.

This method is used when adding operations into circuits with a device specified, to avoid spurious failures due to e.g. using a Hadamard gate that must be decomposed into native gates.

`duration_of`

View source

duration_of(
    operation: cirq.ops.Operation
) -> cirq.value.Duration

`get_device_edge_from_op`

View source

get_device_edge_from_op(
    operation: cirq.ops.Operation
) -> cirq.contrib.graph_device.graph_device.UndirectedGraphDeviceEdge

`qubit_set`

View source

qubit_set() -> FrozenSet['cirq.Qid']

Returns a set or frozenset of qubits on the device, if possible.

Returns

Returns
If the device has a finite set of qubits, then a set or frozen set of all qubits on the device is returned. If the device has no well defined finite set of qubits (e.g. `cirq.UnconstrainedDevice` has this property), then `None` is returned.

If the device has a finite set of qubits, then a set or frozen set of all qubits on the device is returned.

If the device has no well defined finite set of qubits (e.g. cirq.UnconstrainedDevice has this property), then None is returned.

`validate_circuit`

View source

validate_circuit(
    circuit: "cirq.Circuit"
) -> None

Raises an exception if a circuit is not valid.

Args
`circuit`	The circuit to validate.

Raises
`ValueError`	The circuit isn't valid for this device.

`validate_crosstalk`

View source

validate_crosstalk(
    operation: cirq.ops.Operation,
    other_operations: Iterable[cirq.ops.Operation]
) -> None

`validate_moment`

View source

validate_moment(
    moment: cirq.ops.Moment
)

Raises an exception if a moment is not valid.

Args
`moment`	The moment to validate.

Raises
`ValueError`	The moment isn't valid for this device.

`validate_operation`

View source

validate_operation(
    operation: cirq.ops.Operation
) -> None

Raises an exception if an operation is not valid.

Args
`operation`	The operation to validate.

Raises
`ValueError`	The operation isn't valid for this device.

`add`

View source

__add__(
    other
)

`eq`

View source

__eq__(
    other
)

Return self==value.