|View source on GitHub|
A cell made up of a grid of sub-cells.
cirq.interop.quirk.cells.CompositeCell( height: int, sub_cell_cols_generator: Iterable[List[Optional[Cell]]], *, gate_count: int )
This is used for custom circuit gates.
||The number of qubits spanned by this composite cell. Note that the height may be larger than the number of affected qubits (e.g. the custom gate X⊗I⊗X has a height of 3 despite only operating on two qubits)..|
||The columns making up the contents of this composite cell. These columns may only be generated when iterating this iterable for the first time.|
||An upper bound on the number of operations in the circuit produced by this cell.|
basis_change() -> "cirq.OP_TREE"
Operations to conjugate a column with.
The main distinctions between operations performed during the body of a column and operations performed during the basis change are:
- Basis change operations are not affected by operation modifiers in the column. For example, adding a control into the same column will not affect the basis change.
- Basis change operations happen twice, once when starting a column and a second time (but inverted) when ending a column.
circuit() -> "cirq.Circuit"
controlled_by( qubit: "cirq.Qid" ) -> "CompositeCell"
The same cell, but with an explicit control on its main operations.
Cells with effects that do not need to be controlled are permitted to return themselves unmodified.
||The control qubit.|
|A modified cell with an additional control.|
gate_count() -> int
Cheaply determines an upper bound on the resulting circuit size.
The upper bound may be larger than the actual count. For example, a
small circuit may nevertheless have involved a huge amount of rewriting
work to create. In such cases the
gate_count is permitted to be large
to indicate the danger, despite the output being small.
This method exists in order to defend against billion laugh type attacks. It is important that counting is fast and efficient even in extremely adversarial conditions.
modify_column( column: List[Optional['Cell']] ) -> None
Applies this cell's modification to its column.
For example, a control cell will add a control qubit to other operations in the column.
A mutable list of cells in the column, including empty
cells (with value
operations() -> "cirq.OP_TREE"
Returns operations that implement the cell's main action.
||The cell is not ready for conversion into operations, e.g. it may still have unspecified inputs.|
persistent_modifiers() -> Dict[str, Callable[['Cell'], 'Cell']]
Overridable modifications to apply to the rest of the circuit.
Persistent modifiers apply to all cells in the same column and also to all cells in future columns (until a column overrides the modifier with another one using the same key).
|A dictionary of keyed modifications. Each modifier lasts until a later cell specifies a new modifier with the same key.|
with_input( letter: str, register: Union[Sequence['cirq.Qid'], int] ) -> "CompositeCell"
The same cell, but linked to an explicit input register or constant.
If the cell doesn't need the input, it is returned unchanged.
||The input variable name ('a', 'b', or 'r').|
||The list of qubits to use as the input, or else a classical constant to use as the input.|
|The same cell, but with the specified input made explicit.|
with_line_qubits_mapped_to( qubits: List['cirq.Qid'] ) -> "Cell"
Returns the same cell, but targeting different qubits.
It is assumed that the cell is currently targeting
instances, where the x coordinate indicates the qubit to take from the
The new qubits. The qubit at offset
|The same cell, but with new qubits.|