
from numpy import matrix

# tuodaan queenvis.py tiedostosta vis funktio
from queenvis import vis

queens = matrix([
    [0, 0, 0, 1, 0],
    [1, 0, 0, 0, 0],
    [0, 0, 1, 0, 0],
    [0, 0, 0, 0, 1],
    [0, 1, 0, 0, 0]
])

import matplotlib.pyplot as plt

# jos käytät vscodea ja tarvitset pimeän väriteeman niin poista # kommenttimerkki
# plt.style.use('dark_background')

# visualisoidaan kuningattaret shakkilaudalla
vis(queens)


# 1 = ruudussa kuningatar, 0 = tyhjä ruutu
# Sijoitetaan kuingattaret matriisiin
queens = matrix([
    [0, 1, 0, 0],    
    [0, 0, 0, 1],
    [1, 0, 0, 0],
    [0, 0, 1, 0]
])

vis(queens)


from qiskit import *
from qiskit.visualization import *
from qiskit.providers.aer import AerSimulator
from numpy import *
from cmath import *

# Luodaan kvanttipiiri qc, jossa 2 kubittia ja 2 klassista rekisteriä
# Kubitit indeksoidaan pythonissa 0, 1, ..
# Qiskitissä kubitin alkutila on oletuksena |0>
qc = QuantumCircuit(2, 2)

# Operoidaan kubittiin 0 hadamard-portilla, jolloin syntyy superpositiotila |+> = 0.71( |0> + |1>)
qc.h(0)
# NOT-portin operaatio eli 180 asteen kierto Blochin pallolla x-akselin ympäri,
# jolloin jälkimmäinen kubitti 1 siirtyy tilasta |0> --> tilaan  |1>
qc.x(1)

# CNOT eli controlled not, eli kubittien 0 ja 1 lomittuminen, kubitti 0 on ohjaava kubitti ja kohde  on 1.
# Kohdekubitin tila kääntyy, jos ohjaavan kubitin arvo on 1
qc.cx(0, 1)

qc.measure(0, 0)
qc.measure(1, 1)

display(qc.draw(output='mpl'))

backend = AerSimulator(method='statevector')
result = backend.run(qc).result()

plot_histogram(result.get_counts())


# TODO aseta piiriin 4 kubittia ja 4 rekisteriä
qc = QuantumCircuit(4, 4)

# Kubittien 0 ja 1 W-tila
qc.h(0)
qc.x(1)
qc.cx(0, 1)
# Kubittien 2 ja 3 W-tilan koodi, joka on sama kuin yllä mutta eri kubiteilla
qc.h(2)
qc.x(3)
qc.cx(2,3)

qc.measure(0, 0)
qc.measure(1, 1)
# TODO mittaa myös kubitit 2 ja 3 omiin bitteihin klassisessa rekisterissä
qc.measure(2, 2)
qc.measure(3, 3)


display(qc.draw(output='mpl'))

backend = AerSimulator(method='statevector')
counts = backend.run(qc).result().get_counts()

plot_histogram(counts)


from numpy import array

states = []
boards = []
for state in counts:
    states.append(state)
    state = list(map(int, state))
    state.reverse() # mittaustulokset täyttävät klassisen rekisterin oikealta vasemmalle
    
    board = array(state).reshape(2, 2)
    boards.append(board)

vis(boards, states)


# tuodaan wstate.py tiedostosta funktio Wstate
from wstate import Wstate
# tuodaan utils.py tiedostosta apufunktio get_rich_counts
from utils import get_rich_counts

# katso ensiksi N = 2 tulokset, sitten muuta N = 3
N = 2

qc = QuantumCircuit()

rows = []
for n in range(N):
    row = QuantumRegister(N, f'row{n}')
    rows.append(row)
    # lisätään kvanttipiiriin N kpl N kubitin kvanttirekistereitä
    qc.add_register(row)

W = Wstate(N)
for row in rows:
    # lisätään W-alipiiri riville
    qc.append(W, row)
    
# Tähän lisättiin komento decompose
#qc = qc.decompose()

columns = QuantumRegister(N, 'col')
qc.add_register(columns)

for row in rows:
    # lisätään CX-portti jokaisen rivin kubitin ja sitä vastaavan columns apukubitin välille
    qc.cx(row, columns)

# lisätään visuaalinen erotus mittausta ennen
qc.barrier()

# shakkilaudan kubittien mittaus
board = ClassicalRegister(N**2, 'board')
qc.add_register(board)
qc.measure([q for row in rows for q in row], board)

# apukubittien mittaus
tests = ClassicalRegister(N, 'tests')
qc.add_register(tests)
qc.measure(columns, tests)

# piirretään valmis kvanttipiiri
display(qc.draw(output='mpl'))

backend = AerSimulator(method='statevector')
result = backend.run(transpile(qc, backend)).result()

boards = []
tests = []
# täytetään boards ja tests lista mittaustuloksista
for state in get_rich_counts(result)[0]:
    tests.append(state['tests'])
    boards.append(array(state['board']).reshape(N, N))

vis(boards, tests, numx = N, scale = 2 / N)


backend = Aer.get_backend('unitary_simulator')

qc = QuantumCircuit(3)

qc.h(2)
qc.cx(1, 2)
qc.tdg(2)
qc.cx(0, 2)
qc.t(2)
qc.cx(1, 2)
qc.tdg(2)
qc.cx(0, 2)
qc.t(2)
qc.t(1)
qc.cx(0, 1)
qc.h(2)
qc.t(0)
qc.tdg(1)
qc.cx(0, 1)

display(qc.draw(output='mpl'))
U = backend.run(qc).result().get_unitary(qc, decimals=3)

print('Yllä olevan kvanttipiirin unitaarinen matriisi')
display(array_to_latex(U))

print('Oikea Toffoli-portti referenssinä')

# luodaan uusi piiri
qc = QuantumCircuit(3)

# tekee X-operaation 2 kubittiin jos kubitit 0 ja 1 ovat |1
qc.ccx(0, 1, 2)

display(qc.draw(output='mpl'))
U = backend.run(qc).result().get_unitary(qc, decimals=3)

print('Yllä olevan kvanttipiirin unitaarinen matriisi')
display(array_to_latex(U))

Yllä olevan kvanttipiirin unitaarinen matriisi

Oikea Toffoli-portti referenssinä

Yllä olevan kvanttipiirin unitaarinen matriisi


qc = QuantumCircuit()

rows = []
for n in range(2):
    row = QuantumRegister(2, f'row{n}')
    rows.append(row)
    # lisätään kvanttipiiriin N kpl N kubitin kvanttirekistereitä
    qc.add_register(row)

W = Wstate(2)
for row in rows:
    # lisätään W-alipiiri riville
    qc.append(W, row)

# lisätään diagonals-apukubitit
diagonals = QuantumRegister(2, 'diag')
qc.add_register(diagonals)

qc.ccx(rows[0][0], rows[1][1], diagonals[0])
# DONE: lisätty toinen Toffoli, joka flippaa diag1 apukubitin, jos pinkillä diagonaalilla on kaksi kuningatarta
qc.ccx(rows[1][0], rows[0][1], diagonals[1])

# lisätään visuaalinen erotus mittausta ennen
qc.barrier()

# shakkilaudan kubittien mittaus
board = ClassicalRegister(4, 'board')
qc.add_register(board)
qc.measure([q for row in rows for q in row], board)

# apukubittien mittaus
tests = ClassicalRegister(2, 'tests')
qc.add_register(tests)

# TODO mittaa `diagonals` kubitit `tests` rekisteriin
qc.measure(diagonals,tests)

# piirretään valmis kvanttipiiri
display(qc.draw(output='mpl'))

backend = AerSimulator(method='statevector')
result = backend.run(transpile(qc, backend)).result()

boards = []
tests = []
# täytetään boards ja tests lista mittaustuloksista
for state in get_rich_counts(result)[0]:
    tests.append(state['tests'])
    boards.append(array(state['board']).reshape(2, 2))

vis(boards, tests)


qc = QuantumCircuit()

# katso ensiksi tulokset N = 3, sitten muuta N = 4
N = 4
# muuta solution_filter = True jos haluat nähdä vain oikeat asetelmat
solution_filter = True

rows = []
for n in range(N):
    row = QuantumRegister(N, f'row{n}')
    rows.append(row)
    # lisätään kvanttipiiriin N kpl N kubitin kvanttirekistereitä
    qc.add_register(row)

W = Wstate(N)
for row in rows:
    # lisätään W-alipiiri riville
    qc.append(W, row)

columns = QuantumRegister(N, 'col')
qc.add_register(columns)

for row in rows:
    # lisätään CX-portti jokaisen rivin kubitin ja sitä vastaavan columns apukubitin välille
    qc.cx(row, columns)

# lisätään diagonals-apukubitit
diagonals = QuantumRegister((N**2 - N)/2, 'diag')
qc.add_register(diagonals)

# asetetaan diagonals-apukubitit alkutilaan |1>, jotta oikeassa ratkaisussa kaikki apukubittien mittaustulokset ovat 1
qc.x(diagonals)

# käydään kaikki diagonaaliparit läpi
for i in range(1, N + 1):
    for j in range(i + 1, N + 1):
        for x in range(1, N + 1):
            for y in range(1, N + 1):
                if abs(i-j) == abs(x-y):
                    k = int((i-1)/2*(2*N-i))+j-i
                    q1 = rows[i-1][x-1]
                    q2 = rows[j-1][y-1]
                    qc.ccx(q1, q2, diagonals[k-1])

# lisätään visuaalinen erotus mittausta ennen
qc.barrier()

# shakkilaudan kubittien mittaus
board = ClassicalRegister(N**2, 'board')
qc.add_register(board)
qc.measure([q for row in rows for q in row], board)

# apukubittien mittaus
tests = ClassicalRegister(len(columns) + len(diagonals), 'tests')
qc.add_register(tests)
# mitataan columns-apukubitit ensimmäiseen N bittiin tests rekisterissä
qc.measure(columns, tests[:N])
# mitataan diagonals-apukubitit viimeiseen N bittiin tests rekisterissä
qc.measure(diagonals, tests[N:])

# piirretään valmis kvanttipiiri
display(qc.draw(output='mpl'))

backend = AerSimulator(method='statevector')
result = backend.run(transpile(qc, backend)).result()

boards = []
tests = []
# täytetään boards ja tests lista mittaustuloksista
for state in get_rich_counts(result)[0]:
    # jos solution_filter on epätosi tai kaikki testit meni läpi, lisätään asetelma ja testit listaan
    if not solution_filter or all(array(state['tests']) == 1):
        tests.append(state['tests'])
        boards.append(array(state['board']).reshape(N, N))

if len(boards) == 0:
    print("Ei ratkaisuja")
else:
    vis(boards, tests, numx = N, scale = 8/N, res = 30)


from itertools import permutations

N = 5

dirs = [[1, 1], [-1, 1]]

def row_check(row):
    return row.sum() == 1

def diagonal_check(board, pos, dir):
    delta = pos + array(dir)
    while all(delta < board.shape) and all(delta >= 0):
        if board[delta[0], delta[1]]:
            return False
        delta += dir
    return True

basis = [[int(j == i) for j in range(N)] for i in range(N)]

all_boards = map(matrix, permutations(basis))

solutions = []
for board in all_boards:
    for i, q in enumerate(board.flat):
        if q:
            pos = unravel_index(i, (N, N))
            for dir in dirs:
                if not diagonal_check(board, pos, dir): break
            else:
                continue
            break
    else:
        solutions.append(board)

from queenvis import vis

vis(solutions, numx=4, res=60)

8 kuningattaren ongelma¶

Tehtävä 1¶

$N$ kuningattaren ongelman ratkaisun kriteerit¶

Rivillä on korkeintaan yksi kuningatar kuvataan W-tilan avulla¶

Tehtävä 2¶

Ancillat eli apukubitit¶

Sarakkeet: $CX$-portti¶

Tehtävä 3¶

Toffoli-portti $CCX$¶

Miten Toffoli-portti luodaan?¶

Diagonaalit: $CCX$-portti¶

Tehtävä 4¶

Diagonaalien optimointi¶

Tehtävä 5¶

Lisämateriaalia¶

Kvanttipiirin simulointi¶

Klassinen algoritmi¶