Python Quantum Computing simulator

qubit.py

from random import random

class QuDit:

    nD = 0      # Hilbert Space Dimension
    nQ = 0      # Number of Qudits used in simulation
    state = []

    # Initialize
    def __init__(self, D, Q):
        self.nD = D
        self.nQ = Q
        for i in range(0, self.nQ):
            self.state.append([])
            for j in range(0, self.nD):
                self.state[i].append(complex(random(), random()))

    # Normalize
    def Normalize(self, Q0):
        norm = 0
        for j in range(0, self.nD):
            norm += (self.state[Q0][j].real ** 2 + self.state[Q0][j].imag ** 2)
        norm = norm ** 0.5
        for j in range(0, self.nD):
            self.state[Q0][j] = complex((self.state[Q0][j].real) / norm, (self.state[Q0][j].imag) / norm)

    # Measure
    def Measure(self, Q0):
        pseudorand = random()
        sum = 0
        collapse = 0
        for j in range(0, self.nD):
            sum += (self.state[Q0][j].real ** 2 + self.state[Q0][j].imag ** 2)
            if ((collapse == 0) & (pseudorand < sum)):
                self.state[Q0][j] = complex(1, 0)
                collapse = 1
            else:
                self.state[Q0][j] = complex(0, 0)

    # One QuDit Operator
    def F001(self, M, Q0):
        newstate = []
        sum = 0
        # M is nD x nD
        for i in range(0, self.nD):
            newstate.append(complex(0, 0))
            newstate[i] = 0
            for j in range(0, self.nD):
                newstate[i] += self.state[Q0][j] * M[i][j]
        self.state[Q0] = newstate

    # Print State
    def __repr__(self):
        dirac = "System State ==>"
        for i in range (0,self.nQ):
            dirac = dirac + "\n QuDit : " + str(i) + "\t"
            for j in range (0,self.nD):
                dirac = dirac + " + " + str(self.state[i][j]) + " |" + str(j) + "> "
        return dirac

def execQuDit():
    QSys = QuDit(2, 2)
    print(QSys)

    for Qx in range(0, QSys.nQ):
        QSys.Normalize(Qx)
    print(QSys)

    X = [[0, 1], [1, 0]]
    Z = [[1, 0], [0, -1]]
    H = [[1.0 / 2.0 ** 0.5, 1.0 / 2.0 ** 0.5], [1.0 / 2.0 ** 0.5, -1.0 / 2.0 ** 0.5]]

    QSys.F001(X, 0)
    QSys.F001(Z, 1)
    print(QSys)

    for Qx in range(0, QSys.nQ):
        QSys.Measure(Qx)
    print(QSys)

    QSys.F001(H, 0)
    print(QSys)

if __name__ == '__main__':
    execQuDit()

Extended design for arbitary quantum dimension and quantum digits. Also, the coefficients are complex numbers.