Fastcore Transform x Quantum

from fastcore.all import Transform
                     
class S(Transform):
    def encodes(self, x): return x ** 2
    def decodes(self, x): return x ** 0.5
            
S()(10) # 100
S().decode(100) # 10
S().decode(S()(10)) # 10

square = Transform(lambda x: x ** 2)
square(10) # 100
square.decode(100) # 100

@Transform
def square(x): return x ** 2
square(10) # 100
type(square) # <class 'fastcore.transform.Transform'>

class MultiS(Transform):
    def encodes(self, x: int | float | complex | tuple): return x**2
    def encodes(self, x: list): return [x**2 for x in x]
    def decodes(self, x: int | float | complex | tuple): return x**0.5
    def decodes(self, x: list): return [x**0.5 for x in x]

ms = MultiS()
# Lists
# By default, Transform processes lists as a whole
# 2nd encodes method is called
ms([1, 2, 3]) # [1, 4, 9]
# 2nd decodes method is called
ms.decode([1, 4, 9]) # [1.0, 2.0, 3.0]
                     
# Tuples
# By default, Transform processes tuples elementwise
# 1st decodes method is called
ms((1, 2, 3)) # (1, 4, 9)
# 1st decodes method is called
ms.decode((1, 4, 9)) # (1.0, 2.0, 3.0)
                     

# Complex numbers
# 1st encodes method is called on complex number
ms(10.0j) # (-100+0j)
# 1st decodes method is called on complex number
ms.decode(ms(10.0j)) # (6.123233995736766e-16+10j)

from fastcore.all import Pipeline
                     
class S(Transform):
    "Square a number. Reverse is square root."
    def encodes(self, x): return x ** 2
    def decodes(self, x): return x ** 0.5
    
class A(Transform):
    "Add 1. Reverse is subtract 1."
    def encodes(self, x): return x + 1
    def decodes(self, x): return x - 1

pipe = Pipeline(S(), A())
pipe(10) # 10**2 + 1 = 101
pipe.decode(10) # (10 - 1)**0.5 = 3.0
pipe.decode(pipe(10)) # (10**2 + 1 - 1)**0.5 = 10

import numpy as np
         
class _Q(Transform):
    "Base transform for quantum gates"
    def encodes(self, x): return x @ self.gate
    def decodes(self, x): return x @ self.gate.conj().T
                     
class I(_Q):
    "Identity gate. Does nothing."
    gate = np.array([[1, 0], 
                     [0, 1]])
    
class X(_Q):
    "X (NOT) gate. Flips from |0> to |1> and vice versa."
    gate = np.array([[0, 1], 
                     [1, 0]])
    
class H(_Q):
    "Hadamard (Superposition) gate. Turns a qubit into a superposition."
    gate = np.array([[1, 1], 
                     [1, -1]]) / np.sqrt(2)

zero_state = [1+0j, 0+0j] # Basis state |0>
superposition_state = np.array([0.5+0.5j, 0.5-0.5j]) # complex superposition

# Identity operation
i = I()
i(zero_state) # [1+0j, 0+0j] (|0>)
i.decode(zero_state) # [1+0j, 0+0j] (|0>)
                     
# X (NOT) operation 
x = X()                 
x(zero_state) # [0+0j, 1+0j] (|1>)
x.decode(x(zero_state)) # [1+0j, 0+0j] (|0>)
x(superposition_state) # [0.5-0.5j, 0.5+0.5j] (flips sign of complex part)

# Hadamard (Superposition) operation
h = H()
h(zero_state) # [0.707+0j, 0.707+0j] (superposition)
h(superposition_state) # [0.707+0j, 0+0.707j] (phase state)
h.decode(h(superposition_state)) # [0.5+0.5j, 0.5-0.5j] (complex superposition)

class M(Transform):
    "Turn a quantum statevector into a probability distribution"
    def encodes(self, x): return np.abs(x)**2
    def decodes(self, x): return NotImplementedError("No inverse exists for absolute value.")

class Samp(Transform):
    "Sample from a probability distribution"
    def encodes(self, x): return format(np.random.choice(len(x), p=x), f'0{int(np.log2(len(x)))}b')
    def decodes(self, x): return NotImplementedError("Sampling is not reversible.")

m = M()
samp = Samp()
# Sampling from zero state (|0>)
zero_state = [1+0j, 0+0j]
m(zero_state) # Transforms [1+0j, 0+0j] -> [1, 0]
samp(m(zero_state)) # 0 (Result is always 0)
                     
# Sampling from equal superposition
equal_superposition = [0.707, 0.707]
m(equal_superposition) # Transforms [0.707, 0.707] -> [0.5, 0.5] (A coin flip. i.e. Bernoulli distribution))
samp(m(equal_superposition)) # 0 or 1 with equal probability

# Sampling from complex superposition
complex_superposition = [0.5+0.5j, 0.5-0.5j]
m(complex_superposition) # Transforms [0.5+0.5j, 0.5-0.5j] -> [0.5, 0.5] (A coin flip. i.e. Bernoulli distribution)
samp(m(complex_superposition)) # Result is 0 or 1 with equal probability

qc = Pipeline(X(), H(), I(), M(), Samp())
# X transforms [1, 0] -> [0, 1]
# H transforms [0, 1] -> [0.707+0j, -0.707+0j]
# I transforms [0.707+0j, -0.707+0j] -> [0.707+0j, -0.707+0j]
# M transforms [0.707+0j, -0.707+0j] -> [0.5, 0.5]
# Samp samples from random distribution [0.5, 0.5]
qc(zero_state) # 0 or 1 with equal probability

class Concat(Transform):
    "Combine single qubit gates into a multi-qubit gate"
    def __init__(self, gates): self.gates = gates
    # Concatenate 2 or more gates
    def encodes(self, x): return x @ np.kron(*[g.gate for g in self.gates])
    # Reverse propagation for all gates
    def decodes(self, x):
        for g in reversed(self.gates): x = x @ np.kron(g.gate.conj().T, np.eye(len(x) // g.gate.shape[0]))
        return x

class CNOT(_Q):
    "Controlled NOT gate"
    def __init__(self): self.gate = np.array([[1, 0, 0, 0], 
                                              [0, 1, 0, 0], 
                                              [0, 0, 0, 1], 
                                              [0, 0, 1, 0]])
                     
two_qubit_zero_state = np.array([1+0j, 0+0j, 0+0j, 0+0j]) # |00>
qc = Pipeline([Concat([H(), I()]), CNOT(), M(), Samp()]),
# Concat([H(), I()]) transforms [1, 0, 0, 0] -> [0.707, 0, 0.707, 0]
# CNOT() transforms [0.707, 0, 0.707, 0] -> [0.707, 0, 0, 0.707]
# M() transforms [0.707, 0, 0, 0.707] -> [0.5, 0, 0, 0.5]
# Samp() samples from [0.5, 0, 0, 0.5] (50% chance at 00 and 50% chance at 3, which is 11 in binary)
qc(two_qubit_zero_state) # 00 or 11 with equal probability

• Quantum Country - Quantum Education Essays
• IBM Quantum Learning platform
• PennyLane Quantum Learning platform
• Paper: The Potential Impact of Quantum Computers on Society (2017) by Ronald de Wolf

• Quantum Computation and Quantum Information (Nielsen & Chuang)
• Machine Learning with Quantum Computers (Schuld & Petruccione)
• Quantum Mechanics: The Theoretical Minimum (Susskind)
• Modern Quantum Mechanics (Sakurai)

• Playlist - Introduction to Quantum information Science (Artur Ekert)
• Playlist - Quantum Machine Learning (Peter Wittek)
• Playlist - Quantum Paradoxes (Maria Violaris)
• Playlist - The History of Quantum Computing (Interviews)
• Playlist - Maths of Quantum Mechanics
• Channel - Looking Glass Universe
• Video - The Map of Quantum Computing
• Video - Logic Gates Rotate Qubits (Josh's Channel)
• Video - How Quantum Entanglement Works
• Video - Interpretations of Quantum Mechanics