qiskit-documentation/docs/api/qiskit/0.44/qiskit.extensions.UCRZGate.mdx

---
title: UCRZGate
description: API reference for qiskit.extensions.UCRZGate
in_page_toc_min_heading_level: 1
python_api_type: class
python_api_name: qiskit.extensions.UCRZGate
---

# UCRZGate

<Class id="qiskit.extensions.UCRZGate" isDedicatedPage={true} github="https://github.com/qiskit/qiskit/tree/stable/0.25/qiskit/extensions/quantum_initializer/ucrz.py" signature="qiskit.extensions.UCRZGate(angle_list)" modifiers="class">
  Bases: [`UCPauliRotGate`](qiskit.extensions.UCPauliRotGate "qiskit.extensions.quantum_initializer.uc_pauli_rot.UCPauliRotGate")

  Uniformly controlled rotations (also called multiplexed rotations). The decomposition is based on ‘Synthesis of Quantum Logic Circuits’ by V. Shende et al. ([https://arxiv.org/pdf/quant-ph/0406176.pdf](https://arxiv.org/pdf/quant-ph/0406176.pdf))

  Create a new gate.

  **Parameters**

  *   **name** – The Qobj name of the gate.
  *   **num\_qubits** – The number of qubits the gate acts on.
  *   **params** – A list of parameters.
  *   **label** – An optional label for the gate.

  ## Attributes

  ### condition\_bits

  <Attribute id="qiskit.extensions.UCRZGate.condition_bits">
    Get Clbits in condition.
  </Attribute>

  ### decompositions

  <Attribute id="qiskit.extensions.UCRZGate.decompositions">
    Get the decompositions of the instruction from the SessionEquivalenceLibrary.
  </Attribute>

  ### definition

  <Attribute id="qiskit.extensions.UCRZGate.definition">
    Return definition in terms of other basic gates.
  </Attribute>

  ### duration

  <Attribute id="qiskit.extensions.UCRZGate.duration">
    Get the duration.
  </Attribute>

  ### label

  <Attribute id="qiskit.extensions.UCRZGate.label">
    Return instruction label
  </Attribute>

  ### name

  <Attribute id="qiskit.extensions.UCRZGate.name">
    Return the name.
  </Attribute>

  ### num\_clbits

  <Attribute id="qiskit.extensions.UCRZGate.num_clbits">
    Return the number of clbits.
  </Attribute>

  ### num\_qubits

  <Attribute id="qiskit.extensions.UCRZGate.num_qubits">
    Return the number of qubits.
  </Attribute>

  ### params

  <Attribute id="qiskit.extensions.UCRZGate.params">
    return instruction params.
  </Attribute>

  ### unit

  <Attribute id="qiskit.extensions.UCRZGate.unit">
    Get the time unit of duration.
  </Attribute>

  ## Methods

  ### add\_decomposition

  <Function id="qiskit.extensions.UCRZGate.add_decomposition" signature="add_decomposition(decomposition)">
    Add a decomposition of the instruction to the SessionEquivalenceLibrary.
  </Function>

  ### assemble

  <Function id="qiskit.extensions.UCRZGate.assemble" signature="assemble()">
    Assemble a QasmQobjInstruction
  </Function>

  ### broadcast\_arguments

  <Function id="qiskit.extensions.UCRZGate.broadcast_arguments" signature="broadcast_arguments(qargs, cargs)">
    Validation and handling of the arguments and its relationship.

    For example, `cx([q[0],q[1]], q[2])` means `cx(q[0], q[2]); cx(q[1], q[2])`. This method yields the arguments in the right grouping. In the given example:

    ```python
    in: [[q[0],q[1]], q[2]],[]
    outs: [q[0], q[2]], []
          [q[1], q[2]], []
    ```

    The general broadcasting rules are:

    > *   If len(qargs) == 1:
    >
    >     ```python
    >     [q[0], q[1]] -> [q[0]],[q[1]]
    >     ```
    >
    > *   If len(qargs) == 2:
    >
    >     ```python
    >     [[q[0], q[1]], [r[0], r[1]]] -> [q[0], r[0]], [q[1], r[1]]
    >     [[q[0]], [r[0], r[1]]]       -> [q[0], r[0]], [q[0], r[1]]
    >     [[q[0], q[1]], [r[0]]]       -> [q[0], r[0]], [q[1], r[0]]
    >     ```
    >
    > *   If len(qargs) >= 3:
    >
    >     ```python
    >     [q[0], q[1]], [r[0], r[1]],  ...] -> [q[0], r[0], ...], [q[1], r[1], ...]
    >     ```

    **Parameters**

    *   **qargs** ([*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)")) – List of quantum bit arguments.
    *   **cargs** ([*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)")) – List of classical bit arguments.

    **Returns**

    A tuple with single arguments.

    **Raises**

    [**CircuitError**](circuit#qiskit.circuit.CircuitError "qiskit.circuit.CircuitError") – If the input is not valid. For example, the number of arguments does not match the gate expectation.

    **Return type**

    [*Iterable*](https://docs.python.org/3/library/typing.html#typing.Iterable "(in Python v3.12)")\[[tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.12)")\[[list](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)"), [list](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)")]]
  </Function>

  ### c\_if

  <Function id="qiskit.extensions.UCRZGate.c_if" signature="c_if(classical, val)">
    Set a classical equality condition on this instruction between the register or cbit `classical` and value `val`.

    <Admonition title="Note" type="note">
      This is a setter method, not an additive one. Calling this multiple times will silently override any previously set condition; it does not stack.
    </Admonition>
  </Function>

  ### control

  <Function id="qiskit.extensions.UCRZGate.control" signature="control(num_ctrl_qubits=1, label=None, ctrl_state=None)">
    Return controlled version of gate. See [`ControlledGate`](qiskit.circuit.ControlledGate "qiskit.circuit.ControlledGate") for usage.

    **Parameters**

    *   **num\_ctrl\_qubits** ([*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")) – number of controls to add to gate (default: `1`)
    *   **label** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)") *| None*) – optional gate label
    *   **ctrl\_state** ([*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")  *|*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)") *| None*) – The control state in decimal or as a bitstring (e.g. `'111'`). If `None`, use `2**num_ctrl_qubits-1`.

    **Returns**

    Controlled version of gate. This default algorithm uses `num_ctrl_qubits-1` ancilla qubits so returns a gate of size `num_qubits + 2*num_ctrl_qubits - 1`.

    **Return type**

    [qiskit.circuit.ControlledGate](qiskit.circuit.ControlledGate "qiskit.circuit.ControlledGate")

    **Raises**

    [**QiskitError**](exceptions#qiskit.exceptions.QiskitError "qiskit.exceptions.QiskitError") – unrecognized mode or invalid ctrl\_state
  </Function>

  ### copy

  <Function id="qiskit.extensions.UCRZGate.copy" signature="copy(name=None)">
    Copy of the instruction.

    **Parameters**

    **name** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")) – name to be given to the copied circuit, if `None` then the name stays the same.

    **Returns**

    a copy of the current instruction, with the name updated if it was provided

    **Return type**

    [qiskit.circuit.Instruction](qiskit.circuit.Instruction "qiskit.circuit.Instruction")
  </Function>

  ### inverse

  <Function id="qiskit.extensions.UCRZGate.inverse" signature="inverse()">
    Invert this instruction.

    If the instruction is composite (i.e. has a definition), then its definition will be recursively inverted.

    Special instructions inheriting from Instruction can implement their own inverse (e.g. T and Tdg, Barrier, etc.)

    **Returns**

    a fresh instruction for the inverse

    **Return type**

    [qiskit.circuit.Instruction](qiskit.circuit.Instruction "qiskit.circuit.Instruction")

    **Raises**

    [**CircuitError**](circuit#qiskit.circuit.CircuitError "qiskit.circuit.CircuitError") – if the instruction is not composite and an inverse has not been implemented for it.
  </Function>

  ### is\_parameterized

  <Function id="qiskit.extensions.UCRZGate.is_parameterized" signature="is_parameterized()">
    Return True .IFF. instruction is parameterized else False
  </Function>

  ### power

  <Function id="qiskit.extensions.UCRZGate.power" signature="power(exponent)">
    Creates a unitary gate as gate^exponent.

    **Parameters**

    **exponent** ([*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")) – Gate^exponent

    **Returns**

    To which to\_matrix is self.to\_matrix^exponent.

    **Return type**

    [qiskit.extensions.UnitaryGate](qiskit.extensions.UnitaryGate "qiskit.extensions.UnitaryGate")

    **Raises**

    [**CircuitError**](circuit#qiskit.circuit.CircuitError "qiskit.circuit.CircuitError") – If Gate is not unitary
  </Function>

  ### qasm

  <Function id="qiskit.extensions.UCRZGate.qasm" signature="qasm()">
    Return a default OpenQASM string for the instruction.

    Derived instructions may override this to print in a different format (e.g. `measure q[0] -> c[0];`).

    <Admonition title="Deprecated since version 0.25.0" type="danger">
      The method `qiskit.circuit.instruction.Instruction.qasm()` is deprecated as of qiskit-terra 0.25.0. It will be removed no earlier than 3 months after the release date. Correct exporting to OpenQASM 2 is the responsibility of a larger exporter; it cannot safely be done on an object-by-object basis without context. No replacement will be provided, because the premise is wrong.
    </Admonition>
  </Function>

  ### repeat

  <Function id="qiskit.extensions.UCRZGate.repeat" signature="repeat(n)">
    Creates an instruction with gate repeated n amount of times.

    **Parameters**

    **n** ([*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")) – Number of times to repeat the instruction

    **Returns**

    Containing the definition.

    **Return type**

    [qiskit.circuit.Instruction](qiskit.circuit.Instruction "qiskit.circuit.Instruction")

    **Raises**

    [**CircuitError**](circuit#qiskit.circuit.CircuitError "qiskit.circuit.CircuitError") – If n \< 1.
  </Function>

  ### reverse\_ops

  <Function id="qiskit.extensions.UCRZGate.reverse_ops" signature="reverse_ops()">
    For a composite instruction, reverse the order of sub-instructions.

    This is done by recursively reversing all sub-instructions. It does not invert any gate.

    **Returns**

    **a new instruction with**

    sub-instructions reversed.

    **Return type**

    [qiskit.circuit.Instruction](qiskit.circuit.Instruction "qiskit.circuit.Instruction")
  </Function>

  ### soft\_compare

  <Function id="qiskit.extensions.UCRZGate.soft_compare" signature="soft_compare(other)">
    Soft comparison between gates. Their names, number of qubits, and classical bit numbers must match. The number of parameters must match. Each parameter is compared. If one is a ParameterExpression then it is not taken into account.

    **Parameters**

    **other** (*instruction*) – other instruction.

    **Returns**

    are self and other equal up to parameter expressions.

    **Return type**

    [bool](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")
  </Function>

  ### to\_matrix

  <Function id="qiskit.extensions.UCRZGate.to_matrix" signature="to_matrix()">
    Return a Numpy.array for the gate unitary matrix.

    **Returns**

    if the Gate subclass has a matrix definition.

    **Return type**

    np.ndarray

    **Raises**

    [**CircuitError**](circuit#qiskit.circuit.CircuitError "qiskit.circuit.CircuitError") – If a Gate subclass does not implement this method an exception will be raised when this base class method is called.
  </Function>

  ### validate\_parameter

  <Function id="qiskit.extensions.UCRZGate.validate_parameter" signature="validate_parameter(parameter)">
    Gate parameters should be int, float, or ParameterExpression
  </Function>
</Class>