pytorchqbit 0.0.1

Quantum bit and the usual gates in torch tensors straight from the Wikipedia

pypytorchqbit

Quantum bit and the usual gates in torch tensors straight from the Wikipedia.

apply

Apply gate to a state

For example this chain evaluates to zero:

>>> from functools import reduce
>>> s = reduce( apply, [Zero(), H(), PauliZ(), H(), PauliX()])
>>> Measure.one(s)
0

Swap places of a bit

>>> one = Combine(Zero(), One())
>>> Measure.one(one)
1
>>> one
tensor([[0.+0.j],
        [1.+0.j],
        [0.+0.j],
        [0.+0.j]])
>>> two = apply(one, SWAP())
>>> Measure.one(two)
2
>>> two
tensor([[0.+0.j],
        [0.+0.j],
        [1.+0.j],
        [0.+0.j]])

Quantum bit definitions

Zero

Qubit that evaluates as zero every single time

>>> Zero
|0>
>>> Zero()
tensor([[1.+0.j],
        [0.+0.j]])
>>> Measure.one(Zero())
0

One

Qubit that evaluates as one every single time

>>> One
|1>
>>> One()
tensor([[0.+0.j],
        [1.+0.j]])
>>> Measure.one(One())
1

Plus

Qubit that evaluates as one and zero evenly

>>> Plus
|+>
>>> Plus()
tensor([[0.7071+0.j],
        [0.7071+0.j]])

Minus

Qubit that evaluates as one and zero evenly

>>> Minus
|->
>>> Minus()
tensor([[ 0.7071+0.j],
        [-0.7071+0.j]])

Measure

Simulates the measure process of the qubit

>>> Measure.one(One())
1

Combine

Use Kronecker product of two arrays to combine qubits.

>>> Combine(Zero(),Zero())
tensor([[1.+0.j],
        [0.+0.j],
        [0.+0.j],
        [0.+0.j]])


>>> from functools import reduce
>>> reduce(Combine, [One(), Zero(), Zero()])
tensor([[0.+0.j],
        [0.+0.j],
        [0.+0.j],
        [0.+0.j],
        [1.+0.j],
        [0.+0.j],
        [0.+0.j],
        [0.+0.j]])
>>> Combine(One(), Zero(), Zero())
tensor([[0.+0.j],
        [0.+0.j],
        [0.+0.j],
        [0.+0.j],
        [1.+0.j],
        [0.+0.j],
        [0.+0.j],
        [0.+0.j]])

Each row represents the probability of getting it's index's value as a result

>>> Measure.one(Combine(Zero(),Zero()))
0

>>> Measure.one( Combine(One(), Combine(Zero(),Zero())) )
4

equal

The equal is a test if the two qubit states

>>> equal(One(), One())
True
>>> equal(One(), Zero())
False

Quantum gates

Identity

Identity gate

>>> Identity
Identity
>>> Identity()
tensor([[1.+0.j, 0.+0.j],
        [0.+0.j, 1.+0.j]])
>>> Identity(2)
tensor([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
        [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
        [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
        [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])

H

Hadamard gate

>>> H
H
>>> H()
tensor([[ 0.7071+0.j,  0.7071+0.j],
        [ 0.7071+0.j, -0.7071+0.j]])

PauliX

Pauli X gate

>>> PauliX
X
>>> PauliX()
tensor([[0.+0.j, 1.+0.j],
        [1.+0.j, 0.+0.j]])

PauliY

Pauli Y gate

>>> PauliY
Y
>>> PauliY()
tensor([[0.+0.j, -0.-1.j],
        [0.+1.j, 0.+0.j]])

PauliZ

Pauli Z gate

>>> PauliZ
Z
>>> PauliZ()
tensor([[ 1.+0.j,  0.+0.j],
        [ 0.+0.j, -1.+0.j]])

Phase

Phase (S, P) gate

>>> Phase
P
>>> Phase()
tensor([[1.+0.j, 0.+0.j],
        [0.+0.j, 0.+1.j]])

R

R is the custom phase shift gate

>>> from math import pi
>>> R(pi/4)
R(0.7853981633974483)
>>> R(pi/4)()
tensor([[1.0000+0.0000j, 0.0000+0.0000j],
        [0.0000+0.0000j, 0.7071+0.7071j]])

CNOT

CNOT is the Controlled Not gate (CX)

>>> CNOT
CX
>>> CNOT()
tensor([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
        [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
        [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j],
        [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j]])

CPauliZ

CPauliZ is the Controlled Pauli Z gate (CZ)

>>> CPauliZ
CZ
>>> CPauliZ()
tensor([[ 1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j],
        [ 0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j],
        [ 0.+0.j,  0.+0.j,  1.+0.j,  0.+0.j],
        [ 0.+0.j,  0.+0.j,  0.+0.j, -1.+0.j]])

SWAP

SWAP is the qbit swap gate

>>> SWAP
SWAP
>>> SWAP()
tensor([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
        [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
        [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
        [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])

Pauli group

P1

P1 is the First Pauli Group done from the cross product of [-1, 1, -1j, 1j] and [Identity(), PauliX(), PauliY(), PauliZ()]

>>> P1
P1
>>> p1 = list(P1())
>>> len(p1)
16
>>> equal(p1[0], -1*Identity())
True
>>> equal(p1[1], 1*Identity())
True
>>> equal(p1[2], -1j*Identity())
True
>>> equal(p1[3], 1j*Identity())
True
>>> equal(p1[15], 1j*PauliZ())
True

p1 is a group, so these apply:

Associativy:

>>> all([ any([equal(apply(a,b), c) for c in P1()]) for a in P1() for b in P1()])
True

Identity:

>>> equal( Identity(), p1[1])
True

>>> all([ equal(apply(a, Identity()), a) for a in P1()])
True

Inverse element:

>>> all([ any([equal(apply(a, b), Identity()) for b in P1()]) for a in P1() ])
True

Pn

Pn is the n:th Pauli group instance

>>> P2 = Pn(2)
>>> P2
P2
>>> p2 = list(P2())
>>> len(p2)
1024
>>> p2[0]
tensor([[-1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j],
        [ 0.+0.j, -1.+0.j,  0.+0.j,  0.+0.j],
        [ 0.+0.j,  0.+0.j, -1.+0.j,  0.+0.j],
        [ 0.+0.j,  0.+0.j,  0.+0.j, -1.+0.j]])

>>> p2[1]
tensor([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
        [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
        [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
        [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])

p2 is a group, so these apply:

Associativy:

>>> import random
>>> all_products = [apply(a,b) for a in p2 for b in p2]
>>> all([ any([equal(p, c) for c in p2]) for p in random.sample(all_products, 1000)])
True

Identity:

>>> equal(Identity(2), p2[1])
True
>>> i2 = p2[1]
>>> all([ equal(apply(a, i2), a) for a in p2])
True

Inverse element:

>>> all([ any([equal(apply(a, b), i2) for b in p2]) for a in random.sample(p2, 20)])
True

Stabilizer codes

S_5_1_3

S_5_1_3 error correction code encodes one logical qubit into five physical qubits. S_5_1_3 protects against an arbitrary single-qubit error and it has code distance three codes.

>>> S_5_1_3
S_5_1_3

>>> S_5_1_3.g1()
tensor([[ 0.+0.j,  1.+0.j,  1.+0.j,  0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j,  1.+0.j,  1.+0.j,  0.+0.j],
        [ 1.+0.j,  0.+0.j,  0.+0.j, -1.+0.j,  0.+0.j, -1.+0.j,  1.+0.j,  0.+0.j,  0.+0.j,  1.+0.j]])

>>> S_5_1_3.g2()
tensor([[ 1.+0.j,  0.+0.j,  0.+0.j,  1.+0.j,  1.+0.j,  0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j,  1.+0.j],
        [ 0.+0.j,  1.+0.j,  1.+0.j,  0.+0.j,  0.+0.j, -1.+0.j,  0.+0.j, -1.+0.j,  1.+0.j,  0.+0.j]])

>>> S_5_1_3.g3()
tensor([[ 0.+0.j,  1.+0.j,  1.+0.j,  0.+0.j,  0.+0.j,  1.+0.j,  1.+0.j,  0.+0.j,  1.+0.j,  0.+0.j],
        [ 1.+0.j,  0.+0.j,  0.+0.j,  1.+0.j,  1.+0.j,  0.+0.j,  0.+0.j, -1.+0.j,  0.+0.j, -1.+0.j]])

>>> S_5_1_3.g4()
tensor([[ 1.+0.j,  0.+0.j,  0.+0.j,  1.+0.j,  1.+0.j,  0.+0.j,  0.+0.j,  1.+0.j,  1.+0.j,  0.+0.j],
        [ 0.+0.j, -1.+0.j,  1.+0.j,  0.+0.j,  0.+0.j,  1.+0.j,  1.+0.j,  0.+0.j,  0.+0.j, -1.+0.j]])