Lei Mao bio photo

Lei Mao

Machine Learning, Artificial Intelligence, Computer Science.

Twitter Facebook LinkedIn GitHub   G. Scholar E-Mail RSS


Kronecker product is widely used in circuits, especially those that have parallel logical gates, to manipulate bits.

In this blog post, I would like to discuss the mathematics of Kronecker product in circuits.


Kronecker Product Mixed-Product Property

Let $A \in \mathbb{C}^{m \times n}$, $B \in \mathbb{C}^{r \times s}$, $C \in \mathbb{C}^{n \times p}$, and $D \in \mathbb{C}^{s \times t}$, then

Note that $AC$ and $BD$ have to be valid matrix multiplications.

It is easy to prove using the Kronecker product definition.

Logical Gates Are Matrices

Logical gates could be natually represented by matrices. For example, given any one bit, we could represent it as a unique one-hot state vector of length $2^1 = 2$. More concretely, 0 is $| 0 \rangle = [1, 0]^{\top}$, 1 is $| 1 \rangle = [0, 1]^{\top}$. given any two bits, we could represent it as a unique one-hot state vector of length $2^2 = 4$. More concretely, 00 is $| 00 \rangle = [1, 0, 0, 0]^{\top}$, 01 is $| 01 \rangle = [0, 1, 0, 0]^{\top}$, 10 is $| 10 \rangle = [0, 0, 1, 0]^{\top}$, 11 is $| 11 \rangle = [0, 0, 0, 1]^{\top}$. So on and so forth.

A classical AND gate takes into two bits and generates one bit. Its matrix representation $\text{AND} \in \mathbb{C}^{2^1 \times 2^2}$, which takes in a state vector of length 4 and generates a state vector of length 2, is

The expectations of AND gate are 00 -> AND -> 0, 01 -> AND -> 0, 10 -> AND -> 0, 11 -> AND -> 1. Let’s check one of them, say 01 -> AND -> 0, using matrix multiplication.

The gate input is $| 01 \rangle = [0, 1, 0, 0]^{\top}$ (10) and the gate output is $| 0 \rangle = [1, 0]^{\top}$ (0), which matches our expectation.

Parallel Logical Gates and Kronecker Product

Parallel Logical Gates

If we have an input of multiple bits, we would like to take the first several consecutive bits for logical gate 1, the second several consecutive bits for logical gate 2, and so on, and we collect all the outputs as the final output. The logical gate 1, 2, etc., are parallel logical gates.

Parallel Logical Gates

For example, we have three bits, 010. We would like to take the first two bits 01 for AND and the third bit for NOT. The expected output would be 01 because 01 -> AND -> 0 and 0 -> NOT -> 1.

The three bits, 010, could also be represented by a state vector of length $2^3=8$. Normally, we would need to convert 010 to a uint, which is 2 and then we know the state vector is $| 010 \rangle = [0, 0, 1, 0, 0, 0, 0, 0]^{\top}$. However, since 01 could be thought as one system state and 0 could be thought as an another system state, 010 would be a merged system state of system state 01 and system state 0. Mathematically, if we know the state vector for 01 and 0, we could compute the merged system state 010 using Kronecker product.

Where $\otimes$ is the Kronecker product. Informally, people call Kronecker product and tensor product interchangably. The state vector for 010 calculated from the output product matches our expectation.

We apply the first two bits 01 for AND, as we have caculated above, we have

The NOT gate could be represented using the matrix below

We apply the last bit 0 for NOT, we have

Because of the way we set up the circuits, AND and NOT are parallel logical gates, the output state vector has to be merged into one state vector.

So running the circuits above is equivalent to, mathematically,

We happen to find that we could apply the Kronecker product mixed-product property we mentioned in the prerequisites.

This means that in order to compute the output of this parallel logical gates, we don’t have to compute the outputs for each single logical gate separately and collect the outputs back together. Given the intact input state vector, $|010\rangle $, we could apply a merged operator of AND and NOT, which turns out to be $\text{AND} \otimes \text{NOT}$, and the output could be computed directly using matrix multiplication once.


Any two parallel logical gates could be described using a single logical gate that is the Kronecker product of the two.

In general, if we have a circuit consisting of two parallel logical gates, $X$ and $Y$, the input state vector $| a \rangle$ to $X$, the input state vector $| b \rangle$ to $Y$, the output state vector $| c \rangle$ from $X$, the output state vector $| d \rangle$ from $Y$, the merged input state vector $| ab \rangle$ or $| ba \rangle$, and the merged output state vector $| cd \rangle$ or $| dc \rangle$, we have the following equations.

One interesting thing to note is that $X \otimes Y \cong Y \otimes X$ and $Y \otimes X = P (X \otimes Y) Q$, where $P$ and $Q$ are row and column permutation matrices respectively. We could also have $| ba \rangle = W | ab \rangle$, and $| dc \rangle = V | cd \rangle$, where $W$ and $V$ are row permutation matrices.

Permutation matrix is always invertible and its inversion is equivalent to its transpose.

It seems that $V^{-1} P = I$ and $Q W = I$. But I have not thought of a formal proof to this.


Here I implemented a simple Python script to simulate and verify the parallel logical gates and Kronecker product processes I described above.

import math
import numpy as np 

class Bits(object):

    def __init__(self, bit_string):

        self.bit_string = bit_string

    def sanity_check(self, bit_string):

        for char in bit_string:
            if char != "0" and char != "1":
                raise Exception("BitString construction uses a string consisting of 0 and 1!")

    def __len__(self):

        return len(self.bit_string)
    def __eq__(self, bits):

        return self.bit_string == bits.bit_string

    def __str__(self):

        return self.bit_string

    def to_uint(self):

        return int(self.bit_string, 2)

    def to_state_vec(self):
        Return a one-hot state vector for bits
        vec = [0] * (2 ** len(self))
        vec[self.to_uint()] = 1

        return vec

def state_vec_to_bits(state_vec):

    num_zeros = 0
    num_ones = 0
    state_vec_len = len(state_vec)
    num_bits = math.log(state_vec_len, 2)
    if not num_bits.is_integer():
        raise Exception("Invalid state vector length!")
    num_bits = int(num_bits)
    idx = None
    for i, element in enumerate(state_vec):
        if element == 0:
            num_zeros += 1
        elif element == 1:
            num_ones += 1
            idx = i
            raise Exception("State vector should only container 0 or 1!")
    if num_ones != 1 or idx is None:
        raise Exception("State vector should only have one 1!")

    bit_string = bin(idx)[2:].zfill(num_bits)

    bits = Bits(bit_string=bit_string)

    return bits

def main():

    # Gate operators
    NOT = np.array([[0,1],[1,0]])
    AND = np.array([[1,1,1,0],[0,0,0,1]])

    bit_string_a = "01"
    bit_string_b = "0"
    bit_string_c = "0"
    bit_string_d = "1"

    bits_a = Bits(bit_string=bit_string_a)
    bits_b = Bits(bit_string=bit_string_b)
    bits_c = Bits(bit_string=bit_string_c)
    bits_d = Bits(bit_string=bit_string_d)
    bits_ab = Bits(bit_string=bit_string_a + bit_string_b)
    bits_ba = Bits(bit_string=bit_string_b + bit_string_a)
    bits_cd = Bits(bit_string=bit_string_c + bit_string_d)
    bits_dc = Bits(bit_string=bit_string_d + bit_string_c)

    assert bits_a == state_vec_to_bits(state_vec=bits_a.to_state_vec())
    assert bits_b == state_vec_to_bits(state_vec=bits_b.to_state_vec())
    assert bits_c == state_vec_to_bits(state_vec=bits_c.to_state_vec())
    assert bits_d == state_vec_to_bits(state_vec=bits_d.to_state_vec())

    A = np.array(bits_a.to_state_vec())
    B = np.array(bits_b.to_state_vec())
    C = np.array(bits_c.to_state_vec())
    D = np.array(bits_d.to_state_vec())
    AB = np.array(bits_ab.to_state_vec())
    BA = np.array(bits_ba.to_state_vec())
    CD = np.array(bits_cd.to_state_vec())
    DC = np.array(bits_dc.to_state_vec())

    # Parallel operations
    # A -> AND -> C
    # B -> NOT -> D
    # We have the following equations
    # AND * A = C
    assert np.array_equal(np.dot(AND, A), C)
    # NOT * B = D
    assert np.array_equal(np.dot(NOT, B), D)
    # A \otimes B = AB
    assert np.array_equal(np.kron(A, B), AB)
    # B \otimes A = BA
    assert np.array_equal(np.kron(B, A), BA)
    # C \otimes D = CD
    assert np.array_equal(np.kron(C, D), CD)
    # D \otimes C = DC
    assert np.array_equal(np.kron(D, C), DC)
    # (AND \otimes NOT) * (A \otimes B) = (C \otimes D)
    assert np.array_equal(np.dot(np.kron(AND, NOT), np.kron(A, B)), np.kron(C, D))
    # (NOT \otimes AND) * (B \otimes A) = (D \otimes C)
    assert np.array_equal(np.dot(np.kron(NOT, AND), np.kron(B, A)), np.kron(D, C))

if __name__ == "__main__":