# Implementing diagonal and block diagonal unitary matrices in quantum circuits

**URL:** https://discuss.pennylane.ai/t/implementing-diagonal-and-block-diagonal-unitary-matrices-in-quantum-circuits/7642
**Category:** PennyLane Help
**Created:** [November 24, 2024, 5:55pm UTC](https://discuss.pennylane.ai/t/implementing-diagonal-and-block-diagonal-unitary-matrices-in-quantum-circuits/7642 "2024-11-24T17:55:16Z")
**Posts on this page:** 2
**Page:** 1

<div class="post-metadata">

### Author: ![Shehara](https://yyz2.discourse-cdn.com/flex012/user_avatar/discuss.pennylane.ai/shehara/32/2553_2.png) [@Shehara](https://discuss.pennylane.ai/u/Shehara)
#### Post date: [November 24, 2024, 5:55pm UTC](https://discuss.pennylane.ai/t/implementing-diagonal-and-block-diagonal-unitary-matrices-in-quantum-circuits/7642/1 "2024-11-24T17:55:16Z")

</div>

Hi! I would like to know how PennyLane implements arbitrary unitary matrices in quantum circuits. For an example, is there a way to expand `UA` in the below code to see how it is being implemented using single-qubit and two-qubit gates in a quantum circuit?

Also, is there an efficient way to implement diagonal/block diagonal unitary matrices in quantum circuits? Could you please point me towards relevant references as well.

Thanks a lot!

```auto
# Import libraries
import pennylane as qml
import numpy as np

# Unitary matrix
A = np.diag([1, 1, 2, 3]) / 4

# Block encoded matrix
UA = qml.BlockEncode(A, wires=[0, 1, 2])

# Print the block encoded matrix
print(qml.matrix(UA).round(2))

# Decompose the block encoded matrix
LCU = qml.pauli_decompose(qml.matrix(UA))
print(LCU)

```

---

<div class="post-metadata">

### Author: ![CatalinaAlbornoz](https://yyz2.discourse-cdn.com/flex012/user_avatar/discuss.pennylane.ai/catalinaalbornoz/32/1196_2.png) [@CatalinaAlbornoz](https://discuss.pennylane.ai/u/CatalinaAlbornoz)
#### Post date: [November 26, 2024, 1:57am UTC](https://discuss.pennylane.ai/t/implementing-diagonal-and-block-diagonal-unitary-matrices-in-quantum-circuits/7642/2 "2024-11-26T01:57:03Z")

</div>

Hi @Shehara , welcome to the Forum!

qml.pauli\_decompose uses the [Walsh-Hadamard transform](https://en.wikipedia.org/wiki/Hadamard_transform). You can learn more [here](https://docs.pennylane.ai/en/stable/code/api/pennylane.pauli_decompose.html) in the theory section of the docs.

Instead of using BlockEncode, you can use [qml.DiagonalQubitUnitary](https://docs.pennylane.ai/en/stable/code/api/pennylane.DiagonalQubitUnitary.html) as long as the dimension is a power of two.

Here’s a code example.

```auto
# Import libraries
import pennylane as qml
import numpy as np

# Create a device
dev = qml.device('default.qubit',wires=2)

# Create an array with the values for the diagonal unitary matrix
D = np.array([1, 1, 1, 1])

# Create a QNode
@qml.qnode(dev)
def circuitD(D):
  qml.DiagonalQubitUnitary(D, wires=[0,1])
  return qml.probs()

# Draw your circuit and print the output
qml.draw_mpl(circuitD)(D)
circuitD(D)

```

To compute the decomposition you can use the `compute_decomposition` method (see more in [the docs](https://docs.pennylane.ai/en/stable/code/api/pennylane.DiagonalQubitUnitary.html#pennylane.DiagonalQubitUnitary.compute_decomposition)).

Example code:

```auto
qml.DiagonalQubitUnitary.compute_decomposition(D, wires=[0, 1])

```

Note that this method isn’t available for `BlockEncode`.  
Does this answer your questions?

I hope this helps!