Datasets:
keyword
stringclasses 7
values | repo_name
stringlengths 8
98
| file_path
stringlengths 4
244
| file_extension
stringclasses 29
values | file_size
int64 0
84.1M
| line_count
int64 0
1.6M
| content
stringlengths 1
84.1M
⌀ | language
stringclasses 14
values |
|---|---|---|---|---|---|---|---|
2D
|
shigemorita/2Dpy
|
contour.py
|
.py
| 2,436
| 70
|
import numpy
import pandas
from matplotlib import pyplot
from matplotlib import ticker
data_file = "contour.csv"
num_contour = 16
pyplot.rcParams["axes.linewidth"] = 1.5
pyplot.rcParams["figure.dpi"] = 100
pyplot.rcParams["figure.figsize"] = (4, 4)
pyplot.rcParams["font.family"] = "serif"
pyplot.rcParams["font.size"] = 16
pyplot.rcParams["xtick.major.width"] = 1.5
pyplot.rcParams["ytick.major.width"] = 1.5
pyplot.rcParams["xtick.minor.width"] = 1.5
pyplot.rcParams["ytick.minor.width"] = 1.5
pyplot.rcParams["xtick.major.size"] = 6
pyplot.rcParams["ytick.major.size"] = 6
pyplot.rcParams["xtick.minor.size"] = 3
pyplot.rcParams["ytick.minor.size"] = 3
pyplot.rcParams["axes.labelpad"] = 15
pyplot.rcParams["xtick.major.pad"] = 18
pyplot.rcParams["ytick.major.pad"] = 18
pyplot.rcParams["xtick.top"] = True
pyplot.rcParams["ytick.right"] = True
pyplot.rcParams["xtick.direction"] = "in"
pyplot.rcParams["ytick.direction"] = "in"
data = pandas.read_csv(data_file, header=0, index_col=0)
x = data.columns[0:].astype(float)
y = data.index[0:].astype(float)
z = data.values
zmax = numpy.absolute(z).max()
fig = pyplot.figure()
ax = fig.add_subplot(1, 1, 1)
ax.contour(x, y, z, num_contour, cmap="bwr", vmin=-1 * zmax, vmax=zmax)
ax.set_xlim(1200, 1000)
ax.set_xticks(numpy.arange(1200, 1000 - 1, -50))
ax.xaxis.set_minor_locator(ticker.MultipleLocator(10))
ax.set_ylim(1200, 1000)
ax.set_yticks(numpy.arange(1200, 1000 - 1, -50))
ax.yaxis.set_minor_locator(ticker.MultipleLocator(10))
ax.set_title("Synchronous")
ax.set_xlabel(r"$\nu$${_{1}}$ / cm${^{-1}}$")
ax.set_ylabel(r"$\nu$${_{2}}$ / cm${^{-1}}$")
pyplot.savefig("contour.png", dpi=200, bbox_inches="tight")
fig = pyplot.figure()
ax = fig.add_subplot(1, 1, 1)
ax.contour(x, y, z, num_contour, cmap="bwr", vmin=-1 * zmax, vmax=zmax)
fig = pyplot.figure()
ax = fig.add_subplot(1, 1, 1)
ax.pcolormesh(x, y, z, cmap="bwr", vmin=-1 * zmax, vmax=zmax)
fig = pyplot.figure()
ax = fig.add_subplot(1, 1, 1)
ax.contour(x, y, z, num_contour, colors="black", linewidths=0.5, linestyles="solid", vmin=-1 * zmax, vmax=zmax)
ax.pcolormesh(x, y, z, cmap="jet", vmin=-1 * zmax, vmax=zmax)
fig = pyplot.figure()
ax = fig.add_subplot(1, 1, 1)
ax.contour(x, y, z, num_contour, colors="black", linewidths=0.5, vmin=-1 * zmax, vmax=zmax)
ax.contourf(x, y, z, levels=0, colors=["gray", "white"], vmin=-1 * zmax, vmax=zmax)
|
Python
|
2D
|
shigemorita/2Dpy
|
2Dpy.py
|
.py
| 2,013
| 68
|
import math
import numpy
import pandas
from matplotlib import pyplot
hetero = False
inputfile1 = "spec.csv"
# hetero=True
# inputfile1="spec1.csv"
# inputfile2="spec2.csv"
left_large = True
dynamic = True
num_contour = 16
# file read
spec1 = pandas.read_csv(inputfile1, header=0, index_col=0).T
if hetero == False: inputfile2 = inputfile1
spec2 = pandas.read_csv(inputfile2, header=0, index_col=0).T
if len(spec1) != len(spec2): raise Exception("data mismatching")
spec1.T.plot(legend=None)
pyplot.show()
if left_large: pyplot.xlim(max(spec1.columns), min(spec1.columns))
if hetero:
spec2.T.plot(legend=None)
if left_large:
pyplot.xlim(max(spec2.columns), min(spec2.columns))
pyplot.show()
if dynamic:
spec1 = spec1 - spec1.mean()
spec2 = spec2 - spec2.mean()
def contourplot(spec):
x = spec.columns[0:].astype(float)
y = spec.index[0:].astype(float)
z = spec.values
zmax = numpy.absolute(z).max()
pyplot.figure(figsize=(6, 6))
pyplot.contour(x, y, z, num_contour, cmap="bwr", vmin=-1 * zmax, vmax=zmax)
# pyplot.pcolormesh(x,y,z,cmap='jet',vmin=-1*zmax,vmax=zmax)
if left_large:
pyplot.xlim(max(x), min(x))
pyplot.ylim(max(y), min(y))
pyplot.show()
# synchronous correlation
sync = pandas.DataFrame(spec1.values.T @ spec2.values / (len(spec1) - 1))
sync.index = spec1.columns
sync.columns = spec2.columns
sync = sync.T
contourplot(sync)
sync.to_csv(inputfile1[: len(inputfile1) - 4] + "_sync.csv")
# Hilbert-Noda transformation matrix
noda = numpy.zeros((len(spec1), len(spec1)))
for i in range(len(spec1)):
for j in range(len(spec1)):
if i != j: noda[i, j] = 1 / math.pi / (j - i)
# asynchronouse correlation
asyn = pandas.DataFrame(spec1.values.T @ noda @ spec2.values / (len(spec1) - 1))
asyn.index = spec1.columns
asyn.columns = spec2.columns
asyn = asyn.T
contourplot(asyn)
asyn.to_csv(inputfile1[: len(inputfile1) - 4] + "_async.csv")
|
Python
|
2D
|
shigemorita/2Dpy
|
contour.ipynb
|
.ipynb
| 4,357
| 152
|
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import numpy\n",
"import pandas\n",
"from matplotlib import pyplot\n",
"from matplotlib import ticker"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"data_file = \"contour.csv\"\n",
"num_contour = 16\n",
"pyplot.rcParams[\"axes.linewidth\"] = 1.5\n",
"pyplot.rcParams[\"figure.dpi\"] = 100\n",
"pyplot.rcParams[\"figure.figsize\"] = (4, 4)\n",
"pyplot.rcParams[\"font.family\"] = \"serif\"\n",
"pyplot.rcParams[\"font.size\"] = 16\n",
"pyplot.rcParams[\"xtick.major.width\"] = 1.5\n",
"pyplot.rcParams[\"ytick.major.width\"] = 1.5\n",
"pyplot.rcParams[\"xtick.minor.width\"] = 1.5\n",
"pyplot.rcParams[\"ytick.minor.width\"] = 1.5\n",
"pyplot.rcParams[\"xtick.major.size\"] = 6\n",
"pyplot.rcParams[\"ytick.major.size\"] = 6\n",
"pyplot.rcParams[\"xtick.minor.size\"] = 3\n",
"pyplot.rcParams[\"ytick.minor.size\"] = 3\n",
"pyplot.rcParams[\"axes.labelpad\"] = 8\n",
"pyplot.rcParams[\"xtick.major.pad\"] = 12\n",
"pyplot.rcParams[\"ytick.major.pad\"] = 12\n",
"pyplot.rcParams[\"xtick.top\"] = True\n",
"pyplot.rcParams[\"ytick.right\"] = True\n",
"pyplot.rcParams[\"xtick.direction\"] = \"in\"\n",
"pyplot.rcParams[\"ytick.direction\"] = \"in\""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"data = pandas.read_csv(data_file, header=0, index_col=0)\n",
"x = data.columns[0:].astype(float)\n",
"y = data.index[0:].astype(float)\n",
"z = data.values\n",
"zmax = numpy.absolute(z).max()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fig = pyplot.figure()\n",
"ax = fig.add_subplot(1, 1, 1)\n",
"ax.contour(x, y, z, num_contour, cmap=\"bwr\", vmin=-1 * zmax, vmax=zmax)\n",
"\n",
"ax.set_xlim(1200, 1000)\n",
"ax.set_xticks(numpy.arange(1200, 1000 - 1, -50))\n",
"ax.xaxis.set_minor_locator(ticker.MultipleLocator(10))\n",
"\n",
"ax.set_ylim(1200, 1000)\n",
"ax.set_yticks(numpy.arange(1200, 1000 - 1, -50))\n",
"ax.yaxis.set_minor_locator(ticker.MultipleLocator(10))\n",
"\n",
"ax.set_title(\"Synchronous\")\n",
"ax.set_xlabel(r\"$\\nu$${_{1}}$ / cm${^{-1}}$\")\n",
"ax.set_ylabel(r\"$\\nu$${_{2}}$ / cm${^{-1}}$\")\n",
"\n",
"pyplot.savefig(\"contour.png\", dpi=200, bbox_inches=\"tight\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fig = pyplot.figure()\n",
"ax = fig.add_subplot(1, 1, 1)\n",
"ax.contour(x, y, z, num_contour, cmap=\"bwr\", vmin=-1 * zmax, vmax=zmax)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fig = pyplot.figure()\n",
"ax = fig.add_subplot(1, 1, 1)\n",
"ax.pcolormesh(x, y, z, cmap=\"bwr\", vmin=-1 * zmax, vmax=zmax)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fig = pyplot.figure()\n",
"ax = fig.add_subplot(1, 1, 1)\n",
"ax.contour(x, y, z, num_contour, colors=\"black\", linewidths=0.5, linestyles=\"solid\", vmin=-1 * zmax, vmax=zmax)\n",
"ax.pcolormesh(x, y, z, cmap=\"jet\", vmin=-1 * zmax, vmax=zmax)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fig = pyplot.figure()\n",
"ax = fig.add_subplot(1, 1, 1)\n",
"ax.contour(x, y, z, num_contour, colors=\"black\", linewidths=0.5, vmin=-1 * zmax, vmax=zmax)\n",
"ax.contourf(x, y, z, levels=0, colors=[\"gray\", \"white\"], vmin=-1 * zmax, vmax=zmax)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.12"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
|
Unknown
|
2D
|
shigemorita/2Dpy
|
2Dpy.ipynb
|
.ipynb
| 3,678
| 141
|
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import math\n",
"import numpy\n",
"import pandas\n",
"from matplotlib import pyplot"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"hetero = False\n",
"inputfile1 = \"spec.csv\"\n",
"\n",
"# hetero=True\n",
"# inputfile1=\"spec1.csv\"\n",
"# inputfile2=\"spec2.csv\"\n",
"\n",
"left_large = True\n",
"dynamic = True\n",
"num_contour = 16"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# file read\n",
"spec1 = pandas.read_csv(inputfile1, header=0, index_col=0).T\n",
"if hetero == False:\n",
" inputfile2 = inputfile1\n",
"spec2 = pandas.read_csv(inputfile2, header=0, index_col=0).T\n",
"if len(spec1) != len(spec2):\n",
" raise Exception(\"data mismatching\")\n",
"spec1.T.plot(legend=None)\n",
"if left_large: pyplot.xlim(max(spec1.columns), min(spec1.columns))\n",
"if hetero:\n",
" spec2.T.plot(legend=None)\n",
" if left_large: pyplot.xlim(max(spec2.columns), min(spec2.columns))\n",
"if dynamic:\n",
" spec1 = spec1 - spec1.mean()\n",
" spec2 = spec2 - spec2.mean()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def contourplot(spec):\n",
" x = spec.columns[0:].astype(float)\n",
" y = spec.index[0:].astype(float)\n",
" z = spec.values\n",
" zmax = numpy.absolute(z).max()\n",
" pyplot.figure(figsize=(6, 6))\n",
" pyplot.contour(x, y, z, num_contour, cmap=\"bwr\", vmin=-1 * zmax, vmax=zmax)\n",
" # pyplot.pcolormesh(x,y,z,cmap='jet',vmin=-1*zmax,vmax=zmax)\n",
" if left_large:\n",
" pyplot.xlim(max(x), min(x))\n",
" pyplot.ylim(max(y), min(y))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# synchronous correlation\n",
"sync = pandas.DataFrame(spec1.values.T @ spec2.values / (len(spec1) - 1))\n",
"sync.index = spec1.columns\n",
"sync.columns = spec2.columns\n",
"sync = sync.T\n",
"contourplot(sync)\n",
"sync.to_csv(inputfile1[: len(inputfile1) - 4] + \"_sync.csv\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Hilbert-Noda transformation matrix\n",
"noda = numpy.zeros((len(spec1), len(spec1)))\n",
"for i in range(len(spec1)):\n",
" for j in range(len(spec1)):\n",
" if i != j: noda[i, j] = 1 / math.pi / (j - i)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# asynchronouse correlation\n",
"asyn = pandas.DataFrame(spec1.values.T @ noda @ spec2.values / (len(spec1) - 1))\n",
"asyn.index = spec1.columns\n",
"asyn.columns = spec2.columns\n",
"asyn = asyn.T\n",
"contourplot(asyn)\n",
"asyn.to_csv(inputfile1[: len(inputfile1) - 4] + \"_async.csv\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.12"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
|
Unknown
|
2D
|
GiggleLiu/QuantumMPS
|
resolve_env.jl
|
.jl
| 386
| 20
|
using Pkg
deps = ["Yao", "DelimitedFiles", "FileIO", "Fire", "JLD2", "KrylovKit", "StatsBase"]
extras = ["CUDAnative", "CuArrays"]
USE_CUDA = !("nocuda" in ARGS)
if USE_CUDA
deps = vcat(deps, extras)
end
for x in deps
println("Installing $x ...")
Pkg.add(x)
end
if USE_CUDA
println("Installing CuYao ...")
Pkg.clone("https://github.com/QuantumBFS/CuYao.jl")
end
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
j1j2.jl
|
.jl
| 2,133
| 61
|
include("applications.jl")
using Fire
@main function sample_cluster()
m = model(Val(:cluster); nbit=3, B=10)
@show gensample(m, X)
end
"""
julia j1j2.jl train [--symmetry <su2|u1|general>] [--depth <Int>]
Train a 4 x 4 frustrated Heisenberg model with J2 = 0.5.
Available ansatz symmetries includes `general`, `u1` and `su2`.
"""
@main function train(;symmetry::Symbol=:su2, depth::Int=5)
USE_CUDA || @warn "You are not using GPU (35 x speed up), this training may take life long. Turn on the switch in file `applications.jl` if you have a GPU that supports CUDA!"
model = simple_model_j1j2(4, 4)
ansatz = simple_ansatz(16, symmetry, depth; load_params=false)
run_train(ansatz, model; SAVE_ID=Symbol(symmetry,:_d,depth), niter=500, start_point=0)
end
"""
julia j1j2.jl measure <energy|fidelity|szsz> [--symmetry <su2|u1|general>] [--depth <Int>]
Load a pre-trained ansatz for 4 x 4 frustrated Heisenberg model with J2 = 0.5, tasks includes
* energy, sample the energy.
* szsz, calculate the <sz(i)*sz(j)> correlation matrix.
Also, we can obtain some exact quantities in simulation for analysis
* fidelity, calculated the exact fidelity
* energy_exact, calculated the exact energy
Pre-trained ansatz includes
* --symmetry su2, --depth <1-5>
* --symmetry u1, --depth 5
* --symmetry general, --depth 5
"""
@main function measure(task::String; symmetry::Symbol=:su2, depth::Int=5)
model = simple_model_j1j2(4, 4)
ansatz = simple_ansatz(16, symmetry, depth; load_params=true)
nbit = nbit_simulated(ansatz)
if task == "energy"
eng_sample = energy(ansatz, model)/nbit
println("Sampled value of energy/site = $eng_sample")
elseif task == "energy_exact"
eng = energy_exact(ansatz, model)/nbit
println("Exact value of energy/site = $eng")
elseif task == "fidelity"
gs = ground_state(model)
fid = fidelity_exact(ansatz, gs)[]
println("Exact value of fidelity = $fid")
elseif task == "szsz"
correlation_matrix(ansatz; SAVE_ID=symmetry)
else
throw(ArgumentError("$task is not defined!"))
end
end
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
applications.jl
|
.jl
| 4,101
| 126
|
push!(LOAD_PATH, abspath("src"))
using Yao
using QMPS
using DelimitedFiles, JLD2, FileIO, Pkg
# CUDA switch
const USE_CUDA = haskey(Pkg.installed(), "CuYao")
USE_CUDA && println("Hint: Using CUDA since `CuYao` is detected. Edit file `applications.jl` to modify CUDA settings, like switching computing devices.")
USE_CUDA && include("CuChem.jl")
USE_CUDA && device!(CuDevice(0))
"""Heisenberg model without frustration, with open boundary condition."""
simple_model_heis(size...) = Heisenberg(size...; periodic=false)
"""Heisenberg model with frustration strenth J2 = 0.5, with open boundary condition."""
simple_model_j1j2(size...) = J1J2(size...; periodic=false, J2=0.5)
"""
simple_ansatz(nbit::Int, symmetry::Symbol, depth::Int; load_params::Bool=false)
Load a predefined MPS inspired ansatz with 4 virtual qubits, batch size 4096.
If `load_params` is `true`, load parameters in training step 500.
"""
function simple_ansatz(nbit::Int, symmetry::Symbol, depth::Int; load_params::Bool=false)
V = 4 # number of virtual qubits
batch_size = 4096
load_step = 500
ansatz = model(Val(symmetry); nbit=nbit, nlayer=depth, V=V, B=batch_size, pairs=pair_ring(V+1))
USE_CUDA && (ansatz = ansatz |> cu)
if load_params
filename = "data/chem_$(symmetry)_d$(depth)_N$(nbit)_V$(V)_S$(load_step).jld2"
params = load_training(filename)[3]
println("loading file $filename")
println("Number of parameters is ", params |> length)
dispatch!(ansatz.circuit, params)
end
ansatz
end
"""
save_training(filename, qopt::Adam, loss, params, fidelity)
Save training status.
"""
function save_training(filename, qopt::Adam, loss, params, fidelity)
save(filename, "qopt", qopt, "loss", loss, "params", params, "fidelity", fidelity)
end
"""
load_training(filename) -> Tuple
Load training status (qopt, loss, params, fidelity).
"""
function load_training(filename)
res = load(filename)
res["qopt"], res["loss"], res["params"], res["fidelity"]
end
"""
run_train(ansatz, model; SAVE_ID, niter=500, start_point=0, save_step=0)
Run a variational quantum eigensolver to solve a `model` Hamiltonian with MPS inspired `ansatz`
* SAVE_ID, token used for saving data,
* niter, number of training steps,
* start_point, load a save point, default is 0 (random parameters).
* save_step, save the training every `save_step` steps.
"""
function run_train(ansatz, model; SAVE_ID, niter::Int=500, start_point::Int=0, save_step::Int=10)
nbit = nbit_simulated(ansatz)
V = ansatz.nbit_virtual
filename(k::Int) = "data/chem_$(SAVE_ID)_N$(nbit)_V$(V)_S$(k).jld2"
if start_point==0
optimizer = Adam(lr=0.1)
history = Float64[]
fidelities = Float64[]
else
optimizer, history, _params, fidelities = load_training(filename(start_point))
dispatch!(ansatz.circuit, _params)
end
qo = QMPSOptimizer(ansatz, model, optimizer)
gs = ground_state(model)
for (k_, p) in enumerate(qo)
k = k_ + start_point
curr_loss = energy(ansatz, model)/nbit
fid = fidelity_exact(ansatz, gs)[]
push!(history, curr_loss)
push!(fidelities, fid)
println("step = $k, energy/site = $curr_loss, fidelity = $(fid)")
flush(stdout)
if k%save_step == 0 || k == niter
save_training(filename(k), qo.optimizer, history, parameters(ansatz.circuit), fidelities)
k >= niter && break
end
end
end
"""
correlation_matrix(ansatz, op; SAVE_ID)
Calculate and save correlation matrix <Z_i Z_j>.
"""
function correlation_matrix(ansatz; SAVE_ID)
nbit = nbit_simulated(ansatz)
V = ansatz.nbit_virtual
om = zeros(Float64, nbit, nbit)
for i =1:nbit, j=1:nbit
if i!=j
om[i,j] = measure_corr(ansatz, i=>Z, j=>Z) |> real
println("<σz($i)σz($j)> = $(om[i,j])")
end
end
for (token, var) in [
("om", om),
]
writedlm("data/chem_$(SAVE_ID)_$(token)$(tag)_N$(nbit)_V$V.dat", var)
end
end
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
CuChem.jl
|
.jl
| 292
| 10
|
using CUDAnative, CuArrays
using CUDAnative: device!, devices, CuDevice
using CuYao
import CuYao: cu
CuArrays.allowscalar(false)
function cu(chem::QuantumMPS)
QuantumMPS(chem.nbit_measure, chem.nbit_virtual, chem.nbit_ancilla, chem.circuit, chem.initial_reg |> cu, chem.input_state)
end
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
TFI_onefile.jl
|
.jl
| 3,911
| 130
|
using Yao
using Statistics: mean
using LinearAlgebra
rotor(noleading::Bool=false, notrailing::Bool=false) = noleading ? (notrailing ? Rx(0) : chain(Rx(0), Rz(0))) : (notrailing ? chain(Rz(0), Rx(0)) : chain(Rz(0), Rx(0), Rz(0)))
function twoqubit_circuit(nlayer::Int, nrepeat::Int)
nbit_measure = nbit_virtual = 1
nbit_used = nbit_measure + nbit_virtual
circuit = chain(nbit_used)
for i=1:nrepeat
unit = chain(nbit_used)
for j=1:nlayer
push!(unit, put(nbit_used, 1=>rotor(true, false)))
#push!(unit, put(nbit_used, 2=>rotor(true, false)))
push!(unit, control(nbit_used, 1, 2=>(j%2==1 ? X : Z)))
j == nlayer && push!(unit, put(nbit_used, 1=>rotor(false, true)))
#j == nlayer && push!(unit, put(nbit_used, 2=>rotor(false, true)))
end
push!(unit, Measure{nbit_used, 1, AbstractBlock}(Z, (1,), 0, false))
if i==nrepeat
for k=2:nbit_used
push!(unit, Measure{nbit_used, 1, AbstractBlock}(Z, (k,), 0, false))
end
end
push!(circuit, unit)
end
dispatch!(circuit, :random)
end
circuit = twoqubit_circuit(2, 2)
function gensample(circuit, basis; nbatch=1024)
mblocks = collect_blocks(Measure, circuit)
for m in mblocks
m.operator = basis
end
reg = zero_state(nqubits(circuit); nbatch=nbatch)
reg |> circuit
mblocks
end
function energy(circuit, model::TFIChain; nbatch=1024)
# measuring Z basis
mblocks = gensample(circuit, Z; nbatch=nbatch)
local eng = 0.0
for (a, b, v) in ((i, i+1, 1.0) for i=1:model.length-1)
eng += v*mean(mblocks[a].results .* mblocks[b].results)
end
eng/=4
# measuring X basis
mblocks = gensample(circuit, X; nbatch=nbatch)
engx = sum(mean.([m.results for m in mblocks]))
eng + model.h*engx/2
end
struct TFIChain
length::Int
h::Float64
periodic::Bool
TFIChain(length::Int; h::Real, periodic::Bool) = new(length, Float64(h), periodic)
end
function hamiltonian(model::TFIChain)
model.periodic && throw()
nbit = model.length
sum(repeat(nbit, Z, (i,i+1)) for i=1:nbit-1)*0.25 +
sum(put(nbit, i=>X) for i=1:nbit)*0.5model.h
end
using Test, Random
nbit_simulated(qmps) = length(collect_blocks(Measure, qmps))
function expand_circuit(circuit)
nbit = nbit_simulated(circuit)
nm = 1
nv = 1
c = chain(nbit)
for (i, blk) in enumerate(circuit)
blk = chain([b for b in blk if !(b isa Measure)]...)
push!(c, concentrate(nbit, blk, [(i-1)*nm+1:i*nm..., nbit-nv+1:nbit...]))
end
c
end
function train(circuit, model; maxiter=200, α=0.1, nbatch=1024)
rots = collect(RotationGate, circuit)
for i in 1:maxiter
for r in rots
r.theta += π/2
E₊ = energy(circuit, model; nbatch=nbatch)
r.theta -= π
E₋ = energy(circuit, model; nbatch=nbatch)
r.theta += π/2
g = 0.5(E₊ - E₋)
r.theta -= g*α
end
println("Iter $i, E/N = $(energy(circuit, model, nbatch=nbatch)/model.length)")
end
circuit
end
nspin = 4
model = TFIChain(nspin; h=0.5, periodic=false)
h = hamiltonian(model)
EG = eigen(mat(h) |> Matrix).values[1]
@show EG/nspin
circuit = twoqubit_circuit(2, nspin-1)
train(circuit, model; α=0.5)
@testset "energy-goodqn tfi" begin
Random.seed!(4)
hei = TFIChain(4; h=0., periodic=false)
nbit = hei.length
circuit = twoqubit_circuit(2, nbit-1)
println("Number of parameters is ", circuit|> nparameters)
bigc = expand_circuit(circuit)
eng = energy(circuit, hei; nbatch=10000)
hami = hamiltonian(hei)
@show bigc
@show parameters(circuit)
@show parameters(bigc)
eng_exact = expect(hami, zero_state(nbit) |> bigc) |> real
@show eng, eng_exact
@test isapprox(eng, eng_exact, rtol=0.2)
end
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
chainmodel.jl
|
.jl
| 1,080
| 32
|
include("applications.jl")
function train(nsite;depth::Int=2)
symmetry = :twoqubit
model = TFI(nsite; h=0.5, periodic=false)
ansatz = simple_ansatz(nsite, symmetry, depth; load_params=false)
run_train(ansatz, model; SAVE_ID=Symbol(symmetry,:_d,depth), niter=500, start_point=0)
end
function measure(task::String; symmetry::Symbol=:su2, depth::Int=5)
model = simple_model_heis(6)
ansatz = simple_ansatz(6, symmetry, depth; load_params=true)
nbit = nbit_simulated(ansatz)
if task == "energy"
eng_sample = energy(ansatz, model)/nbit
println("Sampled value of energy/site = $eng_sample")
elseif task == "energy_exact"
eng = energy_exact(ansatz, model)/nbit
println("Exact value of energy/site = $eng")
elseif task == "fidelity"
gs = ground_state(model)
fid = fidelity_exact(ansatz, gs)[]
println("Exact value of fidelity = $fid")
elseif task == "szsz"
correlation_matrix(ansatz; SAVE_ID=symmetry)
else
throw(ArgumentError("$task is not defined!"))
end
end
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
src/TFI.jl
|
.jl
| 1,078
| 44
|
export TFI
struct TFI{D} <: AbstractModel{D}
size::NTuple{D, Int}
h::Float64
periodic::Bool
TFI(size::Int...; h::Real, periodic::Bool) = new{length(size)}(size, Float64(h), periodic)
end
function get_bonds(model::TFI{1})
nbit, = model.size
[(i, i%nbit+1, 1.0) for i in 1:(model.periodic ? nbit : nbit-1)]
end
Base.size(model::TFI) = model.size
function hamiltonian(model::TFI{1})
model.periodic && throw()
nbit = nspin(model)
sum(repeat(nbit, Z, (i,i+1)) for i=1:nbit-1)*0.25 +
sum(put(nbit, i=>X) for i=1:nbit)*0.5model.h
end
function energy(chem::QuantumMPS, model::TFI)
energy(chem, Z, model) +
energy(chem, X, model)
end
function energy(chem::QuantumMPS, pauli::ZGate, model::TFI)
res = gensample(chem, pauli)
local eng = 0.0
for bond in ((i, i+1, 1.0) for i=1:nspin(model)-1)
eng += bond[3]*mean(res[:,bond[1]].*res[:,bond[2]])
end
eng/4
end
function energy(chem::QuantumMPS, pauli::XGate, model::TFI)
res = gensample(chem, pauli)
eng = mean(sum(res, dims=2))
model.h*eng/2
end
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
src/Adam.jl
|
.jl
| 972
| 41
|
export Adam, update!
mutable struct Adam
lr::AbstractFloat
gclip::AbstractFloat
beta1::AbstractFloat
beta2::AbstractFloat
eps::AbstractFloat
t::Int
fstm
scndm
end
Adam(; lr=0.001, gclip=0, beta1=0.9, beta2=0.999, eps=1e-8)=Adam(lr, gclip, beta1, beta2, eps, 0, nothing, nothing)
function update!(w, g, p::Adam)
gclip!(g, p.gclip)
if p.fstm===nothing; p.fstm=zero(w); p.scndm=zero(w); end
p.t += 1
lmul!(p.beta1, p.fstm)
BLAS.axpy!(1-p.beta1, g, p.fstm)
lmul!(p.beta2, p.scndm)
BLAS.axpy!(1-p.beta2, g .* g, p.scndm)
fstm_corrected = p.fstm / (1 - p.beta1 ^ p.t)
scndm_corrected = p.scndm / (1 - p.beta2 ^ p.t)
BLAS.axpy!(-p.lr, @.(fstm_corrected / (sqrt(scndm_corrected) + p.eps)), w)
end
function gclip!(g, gclip)
if gclip == 0
g
else
gnorm = vecnorm(g)
if gnorm <= gclip
g
else
BLAS.scale!(gclip/gnorm, g)
end
end
end
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
src/gradient.jl
|
.jl
| 1,173
| 39
|
export QMPSOptimizer, gradients_exact
struct QMPSOptimizer
chem::QuantumMPS
model::AbstractModel
optimizer
diff_blocks
params::Vector
QMPSOptimizer(chem::QuantumMPS, model::AbstractModel, optimizer) = new(chem, model, optimizer, collect_blocks(AbstractDiff, chem.circuit), parameters(chem.circuit))
end
# TODO: setiparameters! throw number of parameters mismatch error!
function gradient(chem::QuantumMPS, db::AbstractDiff, model::AbstractModel)
db.block.theta += π/2
epos = energy(chem, model)
db.block.theta -= π
eneg = energy(chem, model)
db.block.theta += π/2
real(epos-eneg)/2
end
import Base: iterate
function iterate(qo::QMPSOptimizer, state::Int=1)
# initialize the parameters
grad = gradient.(Ref(qo.chem), qo.diff_blocks, Ref(qo.model))
update!(qo.params, grad, qo.optimizer)
dispatch!(qo.chem.circuit, qo.params)
(grad, state+1)
end
function gradients_exact(chem, hami; dbs=nothing)
nbit = nbit_simulated(chem)
circuit = expand_circuit(chem)
if dbs == nothing
dbs = collect_blocks(AbstractDiff, circuit)
end
opdiff.(()->state_exact(chem), dbs, Ref(hami))
end
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
src/correlation.jl
|
.jl
| 1,928
| 60
|
export measure_corr
"""
measure correlator.
e.g. measure_corr(chem, 1=>X, 3=>X) will measure <σₓ¹σₓ³> from a quantum MPS.
"""
function measure_corr(chem::QuantumMPS, si::Pair{Int, <:PauliGate}, sj::Pair{Int, <:PauliGate})
si.first > sj.first && return measure_corr(chem, sj, si)
si.first == sj.first && throw(ArgumentError("Qubit address conflict error!"))
T = datatype(chem.initial_reg)
input_state = chem.input_state
reg = chem.initial_reg |> copy
nv = chem.nbit_virtual + chem.nbit_ancilla
nrep = nrepeat(chem)
for i = nrep+1:nrep+nv
input_state[i] == 1 && apply!(reg, put(nv+1, (i-nrep+1)=>XGate{T}()))
end
local res = nothing
input_state[1] == 1 && apply!(reg, put(nv+1, 1=>XGate{T}()))
for i=1:nrep
reg |> getblock(chem, i)
if i!=nrep
res_i = _measure!(reg, i, [si, sj], input_state, true)
if res_i != nothing
if res != nothing
return mean(res.*res_i)
else
res = res_i
end
end
end
end
for i=1:nv+1-chem.nbit_ancilla
res_i = _measure!(reg, i+nrep-1, [si, sj], input_state, false)
if res_i != nothing
if res != nothing
return mean(res.*res_i)
else
res = res_i
end
end
end
throw()
end
function _measure!(reg::AbstractRegister{B, T}, i, sl, input_state, reset) where {B, T}
for si in sl
if i==si.first
op_i = eigen!(si.second |> mat |>Matrix)
reg |> put(nqubits(reg), 1=>matblock(T.(op_i.vectors' |> Matrix)))
return @inbounds 1 .- 2 .* (reset ? measure_collapseto!(reg, 1; config=input_state[i+1]) : measure_remove!(reg, 1))
end
end
reset ? measure_collapseto!(reg, 1; config=input_state[i+1]) : measure_remove!(reg, 1)
nothing
end
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
src/AbstractModel.jl
|
.jl
| 1,050
| 41
|
export AbstractModel, Heisenberg
export heisenberg_ij, hamiltonian, heisenberg_term, ground_state, energy, energy_exact, get_bonds, energy, heisenberg_2d, nspin
abstract type AbstractModel{D} end
abstract type AbstractHeisenberg{D} <: AbstractModel{D} end
nspin(model::AbstractModel) = prod(size(model))
"""
energy_exact(tc::QuantumMPS, model::AbstractModel) -> Float64
Exact ground state energy.
"""
function energy_exact(tc::QuantumMPS, model::AbstractModel)
nbit = nbit_simulated(tc)
expect(hamiltonian(model), state_exact(tc)) |> real
end
"""
ground_state(model::AbstractModel) -> DefaultRegister
Get the exact ground state of a model.
"""
function ground_state(model::AbstractModel)
# get the ground state
hami = hamiltonian(model)
E, v = eigsolve(mat(hami), 1, :SR)
register(v[1])
end
"""
get_bonds(model::AbstractHeisenberg) -> Vector
Get the weighted bonds of a Heisenberg model in the form Tuple(i,j,w_ij).
"""
function get_bonds end
include("Heisenberg.jl")
include("J1J2.jl")
include("TFI.jl")
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
src/Core.jl
|
.jl
| 2,936
| 90
|
export getblock, nbit_used, nbit_simulated, nrepeat, expand_circuit, QuantumMPS
export state_exact, fidelity_exact
export gensample
"""
QuantumMPS{RT}
Members:
`nbit_measure`, number of qubits measured in a single iteration, or physical qubits.
`nbit_virtual`, number of virtual qubits to represent the virtual bond dimension in quantum MPS.
`circuit`, the circuit structure (measurements are not included).
`initial_reg`, the initial state (GPUReg or a regular one), always prepaired in |0>.
`nbit_ancilla`, number of ancilla qubits.
"""
struct QuantumMPS{RT}
nbit_measure::Int
nbit_virtual::Int
nbit_ancilla::Int
circuit::AbstractBlock
initial_reg::RT
input_state::Vector{Int}
end
getblock(chem::QuantumMPS, i::Int) = chem.circuit[i]
nrepeat(chem::QuantumMPS) = length(chem.circuit)
nbit_used(chem::QuantumMPS) = nqubits(chem.circuit[1])
nbit_simulated(chem::QuantumMPS) = chem.nbit_measure*nrepeat(chem) + chem.nbit_virtual
"""convert a chem circuit to a circuit with no reuse"""
function expand_circuit(tnchem)
nbit = nbit_simulated(tnchem) + tnchem.nbit_ancilla
nm = tnchem.nbit_measure
nv = tnchem.nbit_virtual + tnchem.nbit_ancilla
c = chain(nbit)
for (i, blk) in enumerate(tnchem.circuit)
push!(c, concentrate(nbit, blk, [(i-1)*nm+1:i*nm..., nbit-nv+1:nbit...]))
end
c
end
function state_exact(chem::QuantumMPS)
circuit = expand_circuit(chem)
if chem.nbit_ancilla == 0
return product_state(nqubits(circuit), chem.input_state|>packbits) |> circuit
else
nbit = nqubits(circuit)
product_state(nbit, chem.input_state|>packbits) |> circuit |> focus!((1:nbit-chem.nbit_ancilla)...) |> remove_env!
end
end
function remove_env!(reg::DefaultRegister)
reg.state = dropdims(sum(reg |> rank3, dims=2), dims=2)
reg
end
function fidelity_exact(chem::QuantumMPS, ground_state::AbstractRegister)
fidelity(ground_state, state_exact(chem))
end
function gensample(chem::QuantumMPS, pauli::PauliGate)
input_state = chem.input_state
reg = chem.initial_reg |> copy
nv = chem.nbit_virtual + chem.nbit_ancilla
nrep = nrepeat(chem)
T = datatype(chem.initial_reg)
op = eigen!(pauli |> mat |>Matrix)
G = matblock(T.(op.vectors' |> Matrix))
rotor = put(nv+1, 1=>G)
local res = similar(reg |> state, Int, nbatch(reg), nbit_simulated(chem))
for i = nrep+1:nrep+nv
input_state[i] == 1 && apply!(reg, put(nv+1, (i-nrep+1)=>X))
end
input_state[1] == 1 && apply!(reg, put(nv+1, 1=>X))
for i=1:nrep
reg |> getblock(chem, i)
if i!=nrep
reg |> rotor
@inbounds res[:,i] = 2 .* measure_collapseto!(reg, 1; config=input_state[i+1]) .- 1
end
end
for i=1:nv+1-chem.nbit_ancilla
reg |> put(nqubits(reg), 1=>G)
@inbounds res[:,i+nrep-1] = 2 .* measure_remove!(reg, 1) .- 1
end
res
end
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
src/J1J2.jl
|
.jl
| 1,535
| 55
|
export J1J2
"""
J1J2{D} <: AbstractHeisenberg{D}
frustrated Heisenberg model.
"""
struct J1J2{D} <: AbstractHeisenberg{D}
size::NTuple{D, Int}
periodic::Bool
J2::Float64
J1J2(size::Int...; J2::Real, periodic::Bool) = new{length(size)}(size, periodic, Float64(J2))
end
Base.size(model::J1J2) = model.size
function hamiltonian(model::J1J2)
nbit = nspin(model)
sum(x->x[3]*heisenberg_ij(nbit, x[1], x[2]), get_bonds(model))*0.25
end
@inline function get_site(ij, mn, pbc::Val{true})
Tuple(mod(i-1,m)+1 for (i,m) in zip(ij, mn))
end
@inline function get_site(ij, mn, pbc::Val{false})
Tuple(i<=m ? i : 0 for (i,m) in zip(ij, mn))
end
function get_bonds(model::J1J2{2})
m, n = model.size
cis = LinearIndices(model.size)
bonds = Tuple{Int, Int, Float64}[]
for i=1:m, j=1:n
for (_i, _j) in [(i+1, j), (i, j+1)]
sites = get_site((_i, _j), (m, n), Val(model.periodic))
if all(sites .> 0)
push!(bonds, (cis[i,j], cis[sites...], 1.0))
end
end
for (_i, _j) in [(i-1, j-1), (i-1, j+1)]
sites = get_site((_i, _j), (m, n), Val(model.periodic))
if all(sites .> 0)
push!(bonds, (cis[i,j], cis[sites...], model.J2))
end
end
end
bonds
end
function get_bonds(model::J1J2{1})
nbit, = model.size
vcat([(i, i%nbit+1, 1.0) for i in 1:(model.periodic ? nbit : nbit-1)], [(i, (i+1)%nbit+1, model.J2) for i in 1:(model.periodic ? nbit : nbit-2)])
end
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
src/Heisenberg.jl
|
.jl
| 1,635
| 51
|
struct Heisenberg{D} <: AbstractHeisenberg{D}
size::NTuple{D, Int}
periodic::Bool
Heisenberg(size::Int...; periodic::Bool) = new{length(size)}(size, periodic)
end
Base.size(model::Heisenberg) = model.size
heisenberg_ij(nbit::Int, i::Int, j::Int=i+1) = put(nbit, i=>X)*put(nbit, j=>X) + put(nbit, i=>Y)*put(nbit, j=>Y) + put(nbit, i=>Z)*put(nbit, j=>Z)
const heisenberg_term = repeat(2, X, 1:2) + repeat(2, Y, 1:2) + repeat(2, Z, 1:2)
function hamiltonian(model::Heisenberg)
nbit = nspin(model)
sum(x->heisenberg_ij(nbit, x[1], x[2]), get_bonds(model))*0.25
end
function get_bonds(model::Heisenberg{2})
m, n = model.size
cis = LinearIndices(model.size)
bonds = Tuple{Int, Int, Float64}[]
for i=1:m, j=1:n
(i!=m || model.periodic) && push!(bonds, (cis[i,j], cis[i%m+1,j], 1.0))
(j!=n || model.periodic) && push!(bonds, (cis[i,j], cis[i,j%n+1], 1.0))
end
bonds
end
function get_bonds(model::AbstractModel{1})
nbit, = model.size
[(i, i%nbit+1, 1.0) for i in 1:(model.periodic ? nbit : nbit-1)]
end
"""
energy(chem::QuantumMPS, model::AbstractHeisenberg) -> Float64
Ground state energy by sampling Quantum MPS.
The hamiltonian is limited to Heisenberg and J1J2 Type.
"""
function energy(chem::QuantumMPS, model::AbstractHeisenberg)
energy(chem, X, model) + energy(chem, Y, model) + energy(chem, Z, model)
end
function energy(chem::QuantumMPS, pauli::PauliGate, model::AbstractHeisenberg)
res = gensample(chem, pauli)
local eng = 0.0
for bond in get_bonds(model)
eng += bond[3]*mean(res[:,bond[1]].*res[:,bond[2]])
end
eng/4
end
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
src/QMPS.jl
|
.jl
| 370
| 22
|
module QMPS
using Yao
using Yao.ConstGate: SWAP
using BitBasis: packbits
using StatsBase
using StatsBase: mean
using LinearAlgebra
using KrylovKit
using QuAlgorithmZoo
PauliGate{T} = Union{XGate{T}, YGate{T}, ZGate{T}}
include("Adam.jl")
include("Core.jl")
include("AbstractModel.jl")
include("gradient.jl")
include("correlation.jl")
include("ansatz/ansatz.jl")
end
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
src/ansatz/su2_circuit.jl
|
.jl
| 1,700
| 51
|
function su2_unit(nbit::Int, i::Int, j::Int)
put(nbit, (i,j)=>rot(SWAP, 0.0))
end
"""
su2_circuit(nbit_virtual::Int, nlayer::Int, nrepeat::Int, pairs::Vector) -> Sequence
SU(2) symmetry quantum circuit ansatz for evolving states in S^2 = 0 good quantum number block. It requires `2+nbit_virtual` qubits, `pairs` is the geometry of entanglements.
"""
function su2_circuit(nbit_virtual::Int, nlayer::Int, nrepeat::Int, pairs::Vector)
nbit_used = 2 + nbit_virtual
circuit = chain(nbit_used)
for i=1:nrepeat
unit = chain(nbit_used)
if i==1
for j=2-(nrepeat%2):2:nbit_virtual
push!(unit, singlet_block(nbit_used, j, j+1))
end
end
if i%2 != nrepeat%2
push!(unit, singlet_block(nbit_used, 1, nbit_used))
else
if i!=1
push!(unit, swap(nbit_used, 1, nbit_used)) # fix swap parameter order!
end
end
for j=1:nlayer
nring = nbit_virtual+1
nring <= 1 && continue
ops = [su2_unit(nbit_used, i, j) for (i,j) in pairs]
push!(unit, chain(nbit_used, ops))
end
push!(circuit, unit)
end
dispatch!(circuit, :random)
end
"""construct a circuit for generating singlets."""
function singlet_block(nbit::Int, i::Int, j::Int)
unit = chain(nbit)
push!(unit, put(nbit, i=>chain(X, H)))
push!(unit, control(nbit, -i, j=>X))
end
function model(::Val{:su2}; nbit, V, B=4096, nlayer=5, pairs)
nrepeat = nbit - V
c = su2_circuit(V, nlayer, nrepeat, pairs) |> autodiff(:QC)
chem = QuantumMPS(1, V, 1, c, zero_state(V+2, nbatch=B), zeros(Int, nbit+1))
chem
end
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
src/ansatz/general_circuit.jl
|
.jl
| 2,153
| 62
|
using Yao
export random_circuit, pair_ring
"""
pair_ring(n::Int) -> Vector
Pair ring.
"""
pair_ring(n::Int) = [i=>mod(i, n)+1 for i=1:n]
"""
cnot_entangler(n::Int, pairs::Vector{Pair}) = ChainBlock
Arbitrary entangler unit, support lazy construction.
"""
cnot_entangler(n::Int, pairs) = chain(n, control(n, [ctrl], target=>X) for (ctrl, target) in pairs)
"""
rotor(noleading::Bool=false, notrailing::Bool=false) -> MatrixBlock
`Rz(η)⋅Rx(θ)⋅Rz(ξ)`, remove the first Rz gate if `noleading == true`, remove the last Rz gate if `notrailing == true`.
"""
rotor(noleading::Bool=false, notrailing::Bool=false) = noleading ? (notrailing ? Rx(0) : chain(Rx(0), Rz(0))) : (notrailing ? chain(Rz(0), Rx(0)) : chain(Rz(0), Rx(0), Rz(0)))
"""
rotorset(noleading::Bool=false, notrailing::Bool=false) -> ChainBlock
A sequence of rotors applied on all sites.
"""
rotorset(nbit::Int, noleading::Bool=false, notrailing::Bool=false) = chain(nbit, [put(nbit, j=>rotor(noleading, notrailing)) for j=1:nbit])
"""
A kind of widely used differentiable quantum circuit, angles in the circuit are randomely initialized.
ref:
1. Kandala, A., Mezzacapo, A., Temme, K., Takita, M., Chow, J. M., & Gambetta, J. M. (2017).
Hardware-efficient Quantum Optimizer for Small Molecules and Quantum Magnets. Nature Publishing Group, 549(7671), 242–246.
https://doi.org/10.1038/nature23879.
"""
function random_circuit(nbit_measure::Int, nbit_virtual::Int, nlayer::Int, nrepeat::Int, entangler_pairs)
nbit_used = nbit_measure + nbit_virtual
circuit = chain(nbit_used)
entangler = cnot_entangler(nbit_used, entangler_pairs)
for i=1:nrepeat
unit = chain(nbit_used)
for j=1:nlayer
push!(unit, rotorset(nbit_used, false, false))
push!(unit, entangler)
end
push!(circuit, unit)
end
dispatch!(circuit, :random)
end
function model(::Val{:general}; nbit::Int, V::Int, B::Int=4096, nlayer::Int=5, pairs)
c = random_circuit(1, V, nlayer, nbit-V, pairs) |> autodiff(:QC)
chem = QuantumMPS(1, V, 0, c, zero_state(V+1, nbatch=B), zeros(Int, nbit))
chem
end
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
src/ansatz/ansatz.jl
|
.jl
| 531
| 19
|
export model
"""
model(which::Symbol; nbit::Int, V::Int, B::Int=4096, nlayer::Int=5)
predefined models, `which` should be one of :random, :u1, :su2.
* `nbit` is the system size (length of MPS),
* `V` is the number of virtual qubits,
* `B` is the batch size.
* `nlayer` is the number of layers in a block.
"""
model(which::Symbol, args...; kwargs...) = model(Val(which), args...; kwargs...)
include("general_circuit.jl")
include("u1_circuit.jl")
include("su2_circuit.jl")
include("twoqubit_circuit.jl")
include("cluster.jl")
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
src/ansatz/twoqubit_circuit.jl
|
.jl
| 946
| 28
|
export twoqubit_circuit
function twoqubit_circuit(nlayer::Int, nrepeat::Int)
nbit_measure = nbit_virtual = 1
nbit_used = nbit_measure + nbit_virtual
circuit = chain(nbit_used)
for i=1:nrepeat
unit = chain(nbit_used)
for j=1:nlayer
push!(unit, put(nbit_used, 1=>rotor(true, false)))
#push!(unit, put(nbit_used, 2=>rotor(true, false)))
push!(unit, control(nbit_used, 1, 2=>(j%2==1 ? X : Z)))
j == nlayer && push!(unit, put(nbit_used, 1=>rotor(false, true)))
#j == nlayer && push!(unit, put(nbit_used, 2=>rotor(false, true)))
end
push!(circuit, unit)
end
dispatch!(circuit, :random)
end
function model(::Val{:twoqubit}; nbit::Int, B::Int=4096, nlayer::Int=5, kwargs...)
V = 1
c = twoqubit_circuit(nlayer, nbit-V) |> autodiff(:QC)
chem = QuantumMPS(1, V, 0, c, zero_state(V+1, nbatch=B), zeros(Int, nbit))
chem
end
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
src/ansatz/cluster.jl
|
.jl
| 479
| 14
|
cluster_block(isfirst::Val{true}) = chain(2, [repeat(2, H, 1:2), control(2, 1, 2=>Z)])
cluster_block(isfirst::Val{false}) = chain(2, [swap(2, 1, 2), put(2, 2=>H), control(2, 1, 2=>Z)])
function cluster_circuit(nrepeat::Int)
sequence([cluster_block(Val(i==1)) for i=1:nrepeat])
end
function model(::Val{:cluster}; nbit, B=4096)
nrepeat = nbit - 1
c = cluster_circuit(nrepeat)
chem = QuantumMPS(1, 1, 0, c, zero_state(2, nbatch=B), zeros(Int, nbit))
chem
end
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
src/ansatz/u1_circuit.jl
|
.jl
| 1,115
| 36
|
function u1_unit(nbit::Int, i::Int, j::Int)
chain(nbit, put(nbit, i=>Rz(0)),
put(nbit, j=>Rz(0)),
put(nbit, (i,j)=>rot(SWAP, 0))
)
end
"""
u1_circuit(nbit_measure::Int, nbit_virtual::Int, nlayer::Int, nrepeat::Int, entangler_pairs) -> Sequence
U(1) symmetric quantum circuit ansatz.
"""
function u1_circuit(nbit_measure::Int, nbit_virtual::Int, nlayer::Int, nrepeat::Int, entangler_pairs)
nbit_used = nbit_measure + nbit_virtual
circuit = chain(nbit_used)
for i=1:nrepeat
unit = chain(nbit_used)
for j=1:nlayer
push!(unit, chain(nbit_used, u1_unit(nbit_used, i, j) for (i,j) in entangler_pairs))
for k=1:(i==nrepeat ? nbit_used : nbit_measure)
put(nbit_used, k=>Rz(0))
end
end
push!(circuit, unit)
end
dispatch!(circuit, :random)
end
function model(::Val{:u1}; nbit = 20, V=4, B=4096, nlayer=5, pairs)
nrepeat = (nbit - V)
c = u1_circuit(1, V, nlayer, nrepeat, pairs) |> autodiff(:QC)
chem = QuantumMPS(1, V, 0, c, zero_state(V+1, nbatch=B), [i%2 for i=1:nbit])
chem
end
|
Julia
|
2D
|
GiggleLiu/QuantumMPS
|
test/runtests.jl
|
.jl
| 3,587
| 82
|
push!(LOAD_PATH, abspath("src"))
using Yao
using LinearAlgebra, Statistics
using BitBasis: packbits
using QMPS
using Test, Random
# make it cluster state
@testset "convert wave function check" begin
chem = model(:su2; nbit=9, nlayer=2, B=10, V=5, pairs=pair_ring(5))
c = random_circuit(1, 4, 2, 5, pair_ring(5))
circuit = expand_circuit(chem)
@test zero_state(nqubits(circuit)) |> circuit |> statevec |> length == 2^10
end
@testset "measure check" begin
Random.seed!(5)
chem = model(:su2; nbit=9, nlayer=2, B=10000, V=5, pairs=pair_ring(5))
circuit = expand_circuit(chem)
for (i, j) in [(3,5), (5,3), (3,7), (7,3), (6,8), (8,6)]
@show (i,j)
mean35 = expect(heisenberg_ij(nqubits(circuit), i, j), zero_state(nqubits(circuit)) |> circuit) |> real
eng = sum(g->measure_corr(chem, i=>g, j=>g), [X, Y, Z])
@test isapprox(mean35, eng, rtol=0.4)
end
end
@testset "j1j2" begin
j1j2 = J1J2(4; periodic=false, J2=0.5)
@test get_bonds(j1j2) == [(1, 2, 1.0),(2, 3, 1.0), (3, 4, 1.0), (1,3, 0.5), (2,4, 0.5)]
j1j2 = J1J2(4; periodic=true, J2=0.5)
@test get_bonds(j1j2) == [(1, 2, 1.0), (2, 3, 1.0), (3, 4, 1.0), (4, 1, 1.0), (1,3, 0.5), (2,4, 0.5), (3,1, 0.5), (4,2, 0.5)]
j1j2 = J1J2(3, 3; periodic=false, J2=0.5)
prs = [1=>2, 1=>4, 2=>3, 2=>5, 2=>4, 3=>6, 3=>5, 4=>5, 4=>7, 5=>6, 5=>8, 5=>1, 5=>7, 6=>9, 6=>2, 6=>8, 7=>8, 8=>9, 8=>4, 9=>5]
vs = [1.0, 1, 1, 1, 0.5, 1.0, 0.5, 1.0, 1.0, 1.0, 1.0, 0.5, 0.5, 1.0, 0.5, 0.5, 1.0, 1.0, 0.5, 0.5]
tps = [(i,j,v) for ((i,j), v) in zip(prs, vs)]
@test sort(get_bonds(j1j2)) == sort(tps)
j1j2 = J1J2(3, 3; periodic=true, J2=0.5)
@test sort(get_bonds(j1j2)) == sort([(1,2,1.0), (1,4,1.0), (1,9,0.5), (1,6,0.5), (2,3,1.0), (2,5,1.0), (2,7,0.5), (2,4,0.5), (3,1,1.0), (3,6,1.0), (3,8,0.5), (3,5,0.5),
(4,5,1.0), (4,7,1.0), (4,3,0.5), (4,9,0.5), (5,6,1.0), (5,8,1.0), (5,1,0.5), (5,7,0.5), (6,4,1.0), (6,9,1.0), (6,2,0.5), (6,8,0.5), (7,8,1.0), (7,1,1.0), (7,6,0.5), (7,3,0.5),
(8,9,1.0), (8,2,1.0), (8,4,0.5), (8,1,0.5), (9,7,1.0), (9,3,1.0), (9,5,0.5), (9,2,0.5)])
end
@testset "energy-goodqn" begin
Random.seed!(2)
for hei in [Heisenberg(10; periodic=false), Heisenberg(3, 3; periodic=false), J1J2(3,3; J2=0.5, periodic=false)]
nbit = nspin(hei)
for xmodel in [:u1, :su2]
@show xmodel
pairs = pair_ring(xmodel==:su2 ? 4 : 5)
chem = model(:general; nbit=nbit, B=10000, V=4, pairs=pairs)
println("Number of parameters is ", chem.circuit |> nparameters)
circuit = expand_circuit(chem)
eng = energy(chem, hei)
hami = hamiltonian(hei)
eng_exact = expect(hami, product_state(nbit, chem.input_state |> packbits) |> circuit) |> real
@test isapprox(eng, eng_exact, rtol=0.3)
end
end
end
@testset "energy-goodqn tfi" begin
Random.seed!(11)
for hei in [TFI(2; h=0.5, periodic=false)]
nbit = nspin(hei)
for xmodel in [:twoqubit]
@show xmodel
chem = model(xmodel; nbit=nbit, B=10000)
println("Number of parameters is ", chem.circuit |> nparameters)
circuit = expand_circuit(chem)
eng = energy(chem, hei)
hami = hamiltonian(hei)
@show circuit
eng_exact = expect(hami, product_state(nbit, chem.input_state |> packbits) |> circuit) |> real
@show eng, eng_exact
@test isapprox(eng, eng_exact, rtol=0.3)
end
end
end
|
Julia
|
2D
|
daihui/QuantumWalkSimulation
|
classicalRW.py
|
.py
| 1,583
| 58
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'levitan'
import math
from numpy import *
import numpy as np
import random
from matplotlib import pyplot as plt
def classicalRanNum():
coinX = int(random.choice(['1', '-1']))
coinY = int(random.choice(['1', '-1']))
return coinX, coinY
# print classicalRanNum()
def classicalWalkerPosition():
positionX = 0
positionY = 0
return positionX, positionY
def classicalWalk(walkNum):
walkerPositionX, walkerPositionY = classicalWalkerPosition()
for i in range(0, walkNum):
coinX, coinY = classicalRanNum()
walkerPositionX += coinX
walkerPositionY += coinY
return walkerPositionX, walkerPositionY
def classicalRWDistr(walkNum, matrixNum,satNum):
# positionList = []
walkerCount = zeros([2 *matrixNum + 1, 2 * matrixNum + 1])
for i in range(0, satNum):
walker = classicalWalk(walkNum)
#print walker,walker[0],walker[1]
# positionList.append(walker)
walkerCount[walker[0]+matrixNum][walker[1]+matrixNum] += float(1.0 / satNum)
return walkerCount
def Plot2D(classcialWalker,steps):
plt.figure(1)
ax1=plt.subplot(111)
plt.sca(ax1)
plt.title('2D distribution of %s steps Classical Random Walk' %steps)
plt.xlabel('X Position(started in center)')
plt.ylabel('Y Position(started in center)')
plt.imshow(classcialWalker)
plt.savefig('Fig/CRW_' + str(steps) + '.png')
plt.close()
for i in range(1,11):
classicalWalker=classicalRWDistr(i*10,100,100000)
Plot2D(classicalWalker,i*10)
|
Python
|
2D
|
daihui/QuantumWalkSimulation
|
AnimatedScatter.py
|
.py
| 4,512
| 125
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'levitan'
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from numpy import *
import QWithDiffShift as QDS
import time
class AnimatedScatterQW(object):
"""An animated scatter plot using matplotlib.animations.FuncAnimation."""
def __init__(self, X0, X1, steps, shiftGateNum, node):
self.X0 = X0
self.X1 = X1
self.steps = steps
self.shiftGateNum = shiftGateNum
self.node = node
self.step = 1
self.linedata = zeros([self.node, 1])
self.distri = self.distribution()
# Setup the figure and axes...
self.fig = plt.figure()
self.ax1 = plt.subplot(211)
plt.title('Quantum Walk in Cycle Graph,view in cycle')
self.step_text1 = self.ax1.text(-1.8, 1.2, '')
self.step_text1.set_text('')
self.ax2 = plt.subplot(212)
# self.ax2_axis=self.ax2.axis([1, self.node, 0, 1])
# self.ax2_axis.set_axis()
plt.title('Quantum Walk in Cycle Graph,position 0 probability')
# plt.title('Quantum Walk in Cycle Graph,position probability by step')
# Then setup FuncAnimation.
self.ani = animation.FuncAnimation(self.fig, self.update, frames=200, interval=500,
init_func=self.setup_plot, blit=True)
def setup_plot(self):
"""Initial drawing of the scatter plot."""
data = next(self.distri)
# temp=array([data[:,2]]).T
# print temp
# self.linedata=column_stack((self.linedata,temp))
# print self.linedata
x = data[:, 0]
y = data[:, 1]
d = data[:, 2]
self.ax1.axis([-4.5, 4.5, -1.5, 1.5])
self.scat = self.ax1.scatter(x, y, s=d, c='red', marker='o', animated=True)
self.ax2.axis([1, 5000, 0, 1])
self.line, = self.ax2.plot([], [])
# For FuncAnimation's sake, we need to return the artist we'll be using
# Note that it expects a sequence of artists, thus the trailing comma.
return self.scat, self.line,
def distribution(self):
"""Generate a quantum walk distribution in Cycle Graph . """
step = 1
radius = 1
node = self.node
data = zeros([node, 3], float)
Filename = 'Data/' + time.strftime('%Y%m%d-%H-%M-%S') + '.txt'
distrFlie = open(Filename, 'w+')
for j in range(node):
data[j, 0] = sin(j * 2 * math.pi / node) * radius
data[j, 1] = cos(j * 2 * math.pi / node) * radius
while True:
distribution = QDS.QWCicleDistribution(self.X0, self.X1, step, self.shiftGateNum, node)
# data[:,2]= QDS.ciclePosiTrans(distribution, step, node)
data[:, 2] = distribution
# write distribution to txt file
distrFlie.write(str(step) + '\t')
for x in range(shape(distribution)[0]):
distrFlie.write(str(distribution[x]) + '\t')
distrFlie.write('\n')
self.step = step
print ('step: %s') % step
step += 1
yield data
distrFlie.close()
def update(self, i):
"""Update the scatter plot."""
data = next(self.distri)
# Set x and y data...
temp = array([data[:, 2]]).T
# print temp
self.linedata = column_stack((self.linedata, temp))
m, n = shape(self.linedata)
# print self.linedata
self.scat.set_offsets(data[:, :2])
# self.line.set_offsets(data[:,:2])
# Set sizes...
self.scat._sizes = data[:, 2] * 200
# self.line._sizes = data[:,2]*500
lineResize = self.linedata.copy()
lineResize.resize(1, self.step)
# print lineResize[0]
x = arange(1, self.step + 1)
y = lineResize
# print x,y
self.line.set_data(x, y)
self.step_text1.set_text('Setp:%s' % self.step)
# self.ax2.axis([1, self.step, 0, 1])
# self.ax2_axis.set_axis([[1, self.step, 0, 1]])
# self.scat.set_title(self.Title)
# Set colors..
# self.scat.set_array(data[3])
# We need to return the updated artist for FuncAnimation to draw..
# Note that it expects a sequence of artists, thus the trailing comma.
return self.scat, self.line, self.step_text1,
def show(self):
plt.show()
if __name__ == '__main__':
a = AnimatedScatterQW(1, 0, 100, 3, 8)
a.show()
|
Python
|
2D
|
daihui/QuantumWalkSimulation
|
quantumRWTest.py
|
.py
| 582
| 23
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'levitan'
import quantumRW as QW
from numpy import *
from matplotlib import pyplot as plt
import quantumRWMat as QWM
totalSteps=100
plotSteps=10
# steps=50
# qwalker= QW.distriQW(1/sqrt(2),1j/sqrt(2),1/sqrt(2),1j/sqrt(2),steps,1)
#QW.Plot2D(qwalker)
#QW.PlotX(qwalker,steps)
#QW.writeQW(qwalker,'QW_'+str(steps)+'.txt')
#qwalker=QW.quantumWalker(1/sqrt(2),1j/sqrt(2),1/sqrt(2),1j/sqrt(2),totalSteps,plotSteps)
distribution=QWM.QWDistribution(1/sqrt(2),1j/sqrt(2),1/sqrt(2),1j/sqrt(2),100)
QWM.Plot2D(distribution,100)
|
Python
|
2D
|
daihui/QuantumWalkSimulation
|
quantumRWMat.py
|
.py
| 5,568
| 143
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'levitan'
"""
This is matrix release for 2D quantum walk simulation.
量子游走的基本过程：有一个初始量子态，coin是一个幺正变换，一次游走即coin对量子态变换一次
然后根据量子态walk一步，得到一个位置概率分布，如此反复。
"""
from numpy import *
from matplotlib import pyplot as plt
# 初始化量子态，是一个对角矩阵
def initQuanStat(X0, X1, Y0, Y1):
initQuanStat = zeros([4, 4], complex)
initQuanStat[0][0] = X0
initQuanStat[1][1] = X1
initQuanStat[2][2] = Y0
initQuanStat[3][3] = Y1
return initQuanStat
# 定义2D hadamard coin，实际是2个1D Coin的直积态
def hadamardCoin():
hadamardCoin = array(([1 / sqrt(2), 1 / sqrt(2), 0, 0], [1 / sqrt(2), -1 / sqrt(2), 0, 0]
, [0, 0, 1 / sqrt(2), 1 / sqrt(2)], [0, 0, 1 / sqrt(2), -1 / sqrt(2)]), complex)
return hadamardCoin
# 根据走了的步数定义空位置矩阵
def initPositionMap(steps):
positionMap = zeros([2 * steps + 1, 2 * steps + 1, 4, 4], complex)
return positionMap
# 对量子态经行coin变换
def coinOperator(positionMap, coin):
dimension = shape(positionMap)[0]
for i in range(dimension):
for j in range(dimension):
positionMap[i][j] = dot(positionMap[i][j], coin)
return positionMap
# 根据量子态进行位置变换，相当于一次walk
def shiftOperator(coinMap, step):
newPositionMap = initPositionMap(step)
for i in range(2 * step - 1):
for j in range(2 * step - 1):
newPositionMap[i][j][0][0] += coinMap[i][j][0][0]
newPositionMap[i][j][1][0] += coinMap[i][j][1][0]
newPositionMap[i][j][2][2] += coinMap[i][j][2][2]
newPositionMap[i][j][3][2] += coinMap[i][j][3][2]
newPositionMap[i][j + 2][0][1] += coinMap[i][j][0][1]
newPositionMap[i][j + 2][1][1] += coinMap[i][j][1][1]
newPositionMap[i][j + 2][2][2] += coinMap[i][j][2][2]
newPositionMap[i][j + 2][3][2] += coinMap[i][j][3][2]
newPositionMap[i + 2][j][0][0] += coinMap[i][j][0][0]
newPositionMap[i + 2][j][1][0] += coinMap[i][j][1][0]
newPositionMap[i + 2][j][2][3] += coinMap[i][j][2][3]
newPositionMap[i + 2][j][3][3] += coinMap[i][j][3][3]
newPositionMap[i + 2][j + 2][0][1] += coinMap[i][j][0][1]
newPositionMap[i + 2][j + 2][1][1] += coinMap[i][j][1][1]
newPositionMap[i + 2][j + 2][2][3] += coinMap[i][j][2][3]
newPositionMap[i + 2][j + 2][3][3] += coinMap[i][j][3][3]
return newPositionMap
# quantum walk 的整体封装，返回位置分布的量子态
def quantumWalk(X0, X1, Y0, Y1, steps):
initPositionMap = zeros([1, 1, 4, 4], complex)
initPositionMap[0][0] = initQuanStat(X0, X1, Y0, Y1)
coin = hadamardCoin()
for step in range(1, steps + 1):
positionMap = initPositionMap
coinMap = coinOperator(positionMap, coin)
initPositionMap = shiftOperator(coinMap, step)
return initPositionMap
# 计算QW的位置分布
def QWDistribution(X0, X1, Y0, Y1, steps):
positionMap = quantumWalk(X0, X1, Y0, Y1, steps)
dimension = shape(positionMap)[0]
distribution = zeros([dimension, dimension], dtype=float)
sum = 0.0
for i in range(dimension):
for j in range(dimension):
distribution[i][j] = float((positionMap[i][j][0][0].real ** 2 + positionMap[i][j][0][0].imag ** 2 + \
positionMap[i][j][1][0].real ** 2 + positionMap[i][j][1][0].imag ** 2 + \
positionMap[i][j][0][1].real ** 2 + positionMap[i][j][0][1].imag ** 2 + \
positionMap[i][j][1][1].real ** 2 + positionMap[i][j][1][1].imag ** 2 + \
positionMap[i][j][2][2].real ** 2 + positionMap[i][j][2][2].imag ** 2 + \
positionMap[i][j][3][2].real ** 2 + positionMap[i][j][3][2].imag ** 2 + \
positionMap[i][j][2][3].real ** 2 + positionMap[i][j][2][3].imag ** 2 + \
positionMap[i][j][3][3].real ** 2 + positionMap[i][j][3][3].imag ** 2))
sum += distribution[i][j]
return distribution / sum
def writeQWtoArray(distribution, filename):
distrFlie = open(filename, 'w+')
for x in range(shape(distribution)[0]):
for y in range(shape(distribution)[1]):
distrFlie.write(str(distribution[x][y]) + '\t')
distrFlie.write('\n')
distrFlie.close()
def writeQWtoList(distribution, filename):
distrFlie = open('Data/' + filename, 'w+')
for x in range(shape(distribution)[0]):
for y in range(shape(distribution)[1]):
distrFlie.write(str(x) + '\t' + str(y) + '\t' + str(distribution[x][y]) + '\n')
distrFlie.close()
def Plot2D(qw, steps):
plt.figure(1)
ax1 = plt.subplot(111)
plt.sca(ax1)
plt.title('2D distribution of %s steps Quantum Walk with hadamard coin' % steps)
plt.xlabel('X Position (started in center)')
plt.ylabel('Y Position (started in center)')
plt.imshow(qw)
plt.savefig('Fig/QWM_' + str(steps) + '.png')
plt.close()
def PlotX(qw, Y):
qwX = qw[:][Y]
plt.plot(qwX)
plt.title('a Slice of 2D distribution of Quantum Walk')
plt.xlabel('Position(started in %s)' % Y)
plt.ylabel('Probability')
plt.show()
|
Python
|
2D
|
daihui/QuantumWalkSimulation
|
QWithDiffShiftTest.py
|
.py
| 3,092
| 86
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'levitan'
from numpy import *
from matplotlib import pyplot as plt
import QWithDiffShift as QDS
# distribution=QDS.QWDistribution(1/sqrt(2),1j/sqrt(2),700,1)
# QDS.PlotX(distribution)
def QDSPlot(X0, X1, steps, shiftGateNum):
for step in range(1, steps + 1):
distributionQDS = QDS.QWDistribution(X0, X1, step, shiftGateNum)
distributionQW = QDS.QWDistribution(X0, X1, 7 * step, 1)
QDS.PlotComp(distributionQDS, distributionQW, step, 'QDS-VS-QW-H')
def QDSCPlot(X0, X1, steps, shiftGateNum, node):
for step in range(1, steps + 1):
distribution = QDS.QWCicleDistribution(X0, X1, step, shiftGateNum, node)
distributionTrans = QDS.ciclePosiTrans(distribution, step, shiftGateNum)
QDS.PlotX(distributionTrans, step, 'QDS_CT')
# QDSPlot(1/sqrt(2),1j/sqrt(2),15,3)
# QDSCPlot(1/sqrt(2),1j/sqrt(2),15,3,50)
def QDSCiclePlot(X0, X1, steps, shiftGateNum, node):
for step in range(1, steps + 1):
distribution = QDS.QWCicleDistribution(X0, X1, step, shiftGateNum, node)
distributionTrans = QDS.ciclePosiTrans(distribution, step, shiftGateNum)
QDS.PlotCicle(distributionTrans, step, shiftGateNum, 'QDSCicle_K4_H_')
def QDSCicleContourfPlot(Filename, walkSteps, PiSteps, node, point):
# x,y=ogrid[0:50:PiSteps,1:200:walkSteps]
x = arange(0, 2 * pi, 2 * pi / PiSteps)
y = arange(0, walkSteps, 1)
v = linspace(0, 1, 50, endpoint=True)
# print x,shape(x)
file = open(Filename, 'r')
dataList = zeros([walkSteps * PiSteps, node])
i = 0
for line in file.readlines():
for j in range(node):
dataList[i][j] = line.split('\t')[2 + j]
# print dataList[i]
i += 1
# print dataList[2]
z = zeros([walkSteps, PiSteps], float)
for yi in range(walkSteps):
for xi in range(PiSteps):
z[yi][xi] = float(dataList[xi * walkSteps + yi][point])
file.close()
plt.figure()
plt.title('Distribution of %s steps Quantum Walk in Cicle with different phase' % walkSteps)
plt.xlabel('Phase')
plt.ylabel('Step')
plt.contourf(x, y, z, v, cmap=plt.cm.jet)
x = plt.colorbar(ticks=v)
print x
plt.show()
# QDSCiclePlot(1, 0, 10, 2, 4)
# QDSPlot(1 , 0, 10, 3)
# QDS.QWCicleDistrWrite(1, 0, 2000, 3, 8)
# QDS.QWCicleWithPhaseDistrWrite(1/sqrt(2), 1/sqrt(2), 400, 2, 5, 0, 2)
# QDS.QWCicleWithPhaseLoopDistrWrite(1/sqrt(2), 1j/sqrt(2), 200, 2, 4, pi, 2)
# QDS.QWCicleWithPhaseLoopSearch(1/sqrt(2), 1/sqrt(2), 200, 3, 8, pi, 3)
# for i in range(51):
# QDS.QWCicleWithPhaseLoopSearch(1, 0, 200, 3, 8, 2*pi*i/50, 3)
# for i in range(51):
# QDS.QWCicleWithPhaseLoopDistrWritePosi(1/sqrt(2), 1/sqrt(2), 200, 2, 4, 2*pi*i/50, 2)
# for i in range(51):
# QDS.QWCicleWithPhaseDistrWrite(1/sqrt(2), 1/sqrt(2), 200, 2, 5, 2*pi*i/50, 2)
# for i in range(51):
# QDS.QWCicleWithPhaseSearch(1/sqrt(2), 1/sqrt(2), 200, 2, 4, 2*pi*i/50, 2)
QDSCicleContourfPlot('Data/Search mark_0 X00.707106781187_X10.707106781187_2-4_Steps200Aver.txt', 200, 51,4,2)
|
Python
|
2D
|
daihui/QuantumWalkSimulation
|
classicalRWMat.py
|
.py
| 1,888
| 54
|
#!/usr/bin/env python
#-*- coding: utf-8 -*-
__author__ = 'levitan'
"""
This is a matrix release for 2D classic random walk simulation.
经典随机游走的基本过程：在一个初始位置，投一次coin（随机选择），根据coin的结果，
选择向某一个方向走一步，然后再投一次coin，周而复始。
classicalRanMun():产生一个随机coin
classcalWalkerPosition():walker的初始位置，设为(0,0)
classicalWalk():根据参数walkNum随机游走walkNum步，返回最后位置walkerPosition
classicalRWDistr():重复satNum次随机游走，得到walkerPosition的统计分布
Plot2D():画图函数，画出2D的经典随机游走位置概率分布
"""
from numpy import *
import random
from matplotlib import pyplot as plt
def classicalRanNum():
return mat([[random.choice([1,-1])],[random.choice([1,-1])]],int)
def classicalWalkerPosition():
return mat([[0],[0]],int)
def classicalWalk(walkNum):
walkerPosition = classicalWalkerPosition()
for i in range(0, walkNum):
coin= classicalRanNum()
walkerPosition+=coin
return walkerPosition
def classicalRWDistr(walkNum, matrixNum,satNum):
walkerCount = zeros([2 *matrixNum + 1, 2 * matrixNum + 1])
for i in range(0, satNum):
walker = classicalWalk(walkNum)
walkerCount[int(walker[0])+matrixNum][int(walker[1])+matrixNum] += float(1.0 / satNum)
return walkerCount
def Plot2D(classcialWalker,steps):
plt.figure(1)
ax1=plt.subplot(111)
plt.sca(ax1)
plt.title('2D distribution of %s steps Classical Random Walk' %steps)
plt.xlabel('X Position(started in center)')
plt.ylabel('Y Position(started in center)')
plt.imshow(classcialWalker)
plt.savefig('Fig/CRW_' + str(steps) + '.png')
plt.close()
#for i in range(1,2):
# classicalWalker=classicalRWDistr(i*10,100,100000)
# Plot2D(classicalWalker,i*10)
|
Python
|
2D
|
daihui/QuantumWalkSimulation
|
QWithDiffShift.py
|
.py
| 25,076
| 598
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'levitan'
"""
This is matrix release for 1D quantum walk with different shift simulation(graph).
基本过程：有一个初始量子态，coin是一个幺正变换，一次游走即coin对量子态变换一次
然后根据量子态walk一步，或几步（根据shift而定）得到一个位置概率分布，如此反复。
"""
from numpy import *
from matplotlib import pyplot as plt
import time
import pylab as py
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import animation
# -------------------------------------------
# Quantum walk in line with different shift
# -------------------------------------------
# 初始化量子态，是一个2*1维矩阵
def initQuanStat(X0, X1):
initQuanStat = zeros([2, 1], complex)
initQuanStat[0][0] = X0
initQuanStat[1][0] = X1
return initQuanStat
# 定义1D hadamard coin
def hadamardCoin():
hadamardCoin = array([[1 / sqrt(2), 1 / sqrt(2)], [1 / sqrt(2), -1 / sqrt(2)]], complex)
return hadamardCoin
# 定义1D phase coin
def phaseCoin(Psi):
phaseCoin = array([[1, 0], [0, exp(1j * Psi)]], complex)
return phaseCoin
# 根据shift的最大值和走了的步数定义空位置矩阵
def initPositionMap(steps, shiftNum, shiftGateNum):
stepNum = 0
for j in range(0, shiftGateNum):
stepNum += power(2, j)
dimension = stepNum * (steps - 1) + 1
for i in range(0, shiftNum):
dimension += power(2, i)
positionMap = zeros([dimension, 2, 1], complex)
return positionMap
# 对量子态经行coin变换
def coinOperator(coin, positionMap):
dimension = shape(positionMap)[0]
for i in range(dimension):
positionMap[i] = dot(coin, positionMap[i])
return positionMap
# 根据量子态进行位置变换，相当于一次walk
def shiftOperator(positionMap, step, shiftGateNum):
for shiftNum in range(1, shiftGateNum + 1):
newPositionMap = initPositionMap(step, shiftNum, shiftGateNum)
coin = hadamardCoin()
coinMap = coinOperator(coin, positionMap)
for i in range(shape(coinMap)[0]):
newPositionMap[i][0][0] += coinMap[i][0][0]
newPositionMap[i + power(2, shiftNum - 1)][1][0] += coinMap[i][1][0]
positionMap = newPositionMap
return newPositionMap
# quantum walk 的整体封装，返回位置分布的量子态
def quantumWalk(X0, X1, steps, shiftGateNum):
initPositionMap = zeros([1, 2, 1], complex)
initPositionMap[0] = initQuanStat(X0, X1)
for step in range(1, steps + 1):
positionMap = initPositionMap
initPositionMap = shiftOperator(positionMap, step, shiftGateNum)
return initPositionMap
# 计算QW的位置分布
def QWDistribution(X0, X1, steps, shiftGateNum):
positionMap = quantumWalk(X0, X1, steps, shiftGateNum)
dimension = shape(positionMap)[0]
distribution = zeros([dimension], dtype=float)
sum = 0.0
for i in range(dimension):
distribution[i] = float(positionMap[i][0][0].real ** 2 + positionMap[i][0][0].imag ** 2 + \
positionMap[i][1][0].real ** 2 + positionMap[i][1][0].imag ** 2)
sum += distribution[i]
print('sum: %s') % sum
return distribution
# 将结果写到文本文档
def writeQWtoArray(distribution):
Filename = 'Data/' + time.strftime('%Y%m%d-%H-%M-%S') + '.txt'
distrFlie = open(Filename, 'w+')
for x in range(shape(distribution)[0]):
distrFlie.write(str(distribution[x]) + '\n')
distrFlie.close()
# 画出位置概率分布图
def PlotX(distribution, step, figName):
plt.plot(distribution)
plt.title('The Distribution of %s Quantum Walk with Different Shift') % step
plt.xlabel('Started from the 0')
plt.ylabel('Probability')
# plt.show()
plt.savefig('Fig/' + str(figName) + str(step) + '.png')
plt.close()
# 画出QDS与QW的概率分布对比图
def PlotComp(distributionQDS, distributionQW, step, figName):
QDS, = plt.plot(distributionQDS, 'r')
QW, = plt.plot(distributionQW, 'b')
plt.axis([0, 7 * step, 0, 0.27])
plt.legend([QDS, QW, ], ['QDS', 'QW'])
plt.title('The Compare between QDS and QW')
plt.xlabel('X Position (started from the center)')
plt.ylabel('Probability')
# plt.show()
plt.savefig('Fig/' + str(figName) + str(step) + '.png')
plt.close()
# -------------------------------------------
# Quantum walk in cicle with different shift
# -------------------------------------------
def initQuanStatAverPosiCicle(X0, X1, Node):
initQuanStat = zeros([Node, 2, 1], complex)
for node in range(Node):
initQuanStat[node][0][0] = X0 * 1 / sqrt(Node)
initQuanStat[node][1][0] = X1 * 1 / sqrt(Node)
return initQuanStat
def positionCicleMap(node):
positionCicleMap = zeros([node, 2, 1], complex)
return positionCicleMap
# 根据量子态进行位置变换，相当于一次walk
def shiftCicleOperator(positionMap, step, shiftGateNum, node):
for shiftNum in range(1, shiftGateNum + 1):
newPositionMap = positionCicleMap(node)
coin = hadamardCoin()
coinMap = coinOperator(coin, positionMap)
for i in range(node):
newPositionMap[i][0][0] += coinMap[i][0][0]
if (i + power(2, shiftNum - 1) >= node):
newPositionMap[i + power(2, shiftNum - 1) - node][1][0] += coinMap[i][1][0]
# print('loop')
else:
newPositionMap[i + power(2, shiftNum - 1)][1][0] += coinMap[i][1][0]
positionMap = newPositionMap
return newPositionMap
# 加入phase coin 版本, 修正移位操作，实现complete graph
def shiftCicleWithPhaseOperator(positionMap, step, shiftGateNum, node, Psi, phaseGate):
# 先整体走一步
moveOne = positionMap.copy()
for i in range(1, node):
positionMap[i] = moveOne[i - 1]
positionMap[0] = moveOne[node - 1]
# 根据延时门再各自走对应步数
for shiftNum in range(1, shiftGateNum + 1):
newPositionMap = positionCicleMap(node)
HadamardCoin = hadamardCoin()
PhaseCoin = phaseCoin(Psi)
coinMap = coinOperator(HadamardCoin, positionMap)
if shiftNum == phaseGate:
newMap = coinMap.copy()
coinMap = coinOperator(PhaseCoin, newMap)
print 'gate:%s phase coin' % shiftNum
for i in range(node):
newPositionMap[i][0][0] += coinMap[i][0][0]
if (i + power(2, shiftNum - 1) >= node):
newPositionMap[i + power(2, shiftNum - 1) - node][1][0] += coinMap[i][1][0]
# print('loop')
else:
newPositionMap[i + power(2, shiftNum - 1)][1][0] += coinMap[i][1][0]
positionMap = newPositionMap
return newPositionMap
# phase coin ，complete graph with loop
def shiftCicleWithPhaseLoopOperator(positionMap, step, shiftGateNum, node, Psi, phaseGate):
# 根据延时门各自走对应步数
for shiftNum in range(1, shiftGateNum + 1):
newPositionMap = positionCicleMap(node)
HadamardCoin = hadamardCoin()
PhaseCoin = phaseCoin(Psi)
coinMap = coinOperator(HadamardCoin, positionMap)
if shiftNum == phaseGate:
newMap = coinMap.copy()
coinMap = coinOperator(PhaseCoin, newMap)
print 'gate:%s phase coin' % shiftNum
for i in range(node):
newPositionMap[i][0][0] += coinMap[i][0][0]
if (i + power(2, shiftNum - 1) >= node):
newPositionMap[i + power(2, shiftNum - 1) - node][1][0] += coinMap[i][1][0]
# print('loop')
else:
newPositionMap[i + power(2, shiftNum - 1)][1][0] += coinMap[i][1][0]
positionMap = newPositionMap
return newPositionMap
# search position with marked coin ，complete graph with loop for 2 gate,4 node
def shiftCicleWithPhaseLoopSearchOperator(positionMap, step, shiftGateNum, node, Psi, phaseGate):
# 根据延时门各自走对应步数
for shiftNum in range(1, shiftGateNum + 1):
newPositionMap = positionCicleMap(node)
HadamardCoin = hadamardCoin()
# PhaseCoin = phaseCoin(Psi)
coinMap = coinOperator(HadamardCoin, positionMap)
if shiftNum == phaseGate:
# print 'gate:%s phase coin' % shiftNum
newPositionMap[0][0][0] += coinMap[0][0][0]
newPositionMap[4][1][0] += coinMap[0][1][0] * exp(1j * Psi)
newPositionMap[4][0][0] += coinMap[4][0][0]
newPositionMap[0][1][0] += coinMap[4][1][0] * exp(1j * Psi)
for i in range(1, node):
if i == 4:
print i
else:
newPositionMap[i][0][0] += coinMap[i][0][0]
if (i + power(2, shiftNum - 1) >= node):
newPositionMap[i + power(2, shiftNum - 1) - node][1][0] += coinMap[i][1][0]
# print('loop')
else:
newPositionMap[i + power(2, shiftNum - 1)][1][0] += coinMap[i][1][0]
else:
for i in range(node):
newPositionMap[i][0][0] += coinMap[i][0][0]
if (i + power(2, shiftNum - 1) >= node):
newPositionMap[i + power(2, shiftNum - 1) - node][1][0] += coinMap[i][1][0]
# print('loop')
else:
newPositionMap[i + power(2, shiftNum - 1)][1][0] += coinMap[i][1][0]
positionMap = newPositionMap
return newPositionMap
# search position with marked point 0，实现complete graph
def shiftCicleWithPhaseSearchOperator(positionMap, step, shiftGateNum, node, Psi, phaseGate):
# 先整体走一步
moveOne = positionMap.copy()
for i in range(1, node):
positionMap[i] = moveOne[i - 1]
positionMap[0] = moveOne[node - 1]
# 根据延时门再各自走对应步数
for shiftNum in range(1, shiftGateNum + 1):
newPositionMap = positionCicleMap(node)
HadamardCoin = hadamardCoin()
# PhaseCoin = phaseCoin(Psi)
coinMap = coinOperator(HadamardCoin, positionMap)
for i in range(node):
newPositionMap[i][0][0] += coinMap[i][0][0]
if (i + power(2, shiftNum - 1) >= node):
newPositionMap[i + power(2, shiftNum - 1) - node][1][0] += coinMap[i][1][0]
# print('loop')
else:
newPositionMap[i + power(2, shiftNum - 1)][1][0] += coinMap[i][1][0]
positionMap = newPositionMap
# 标记点0，附加一个Psi的相位
newPositionMap[0] = newPositionMap[0] * exp(1j * Psi)
return newPositionMap
# quantum walk 的整体封装，返回位置分布的量子态
def quantumWalkCicle(X0, X1, steps, shiftGateNum, node):
print 'begin'
initPositionMap = zeros([node, 2, 1], complex)
initPositionMap[0] = initQuanStat(X0, X1)
for step in range(1, steps + 1):
positionMap = initPositionMap
initPositionMap = shiftCicleOperator(positionMap, step, shiftGateNum, node)
return initPositionMap
'''
Release 1, for animate plotting
'''
# 计算概率分布
def QWCicleDistribution(X0, X1, steps, shiftGateNum, node):
positionMap = quantumWalkCicle(X0, X1, steps, shiftGateNum, node)
dimension = shape(positionMap)[0]
distribution = zeros([dimension], dtype=float)
sum = 0.0
for i in range(dimension):
distribution[i] = float(positionMap[i][0][0].real ** 2 + positionMap[i][0][0].imag ** 2 + \
positionMap[i][1][0].real ** 2 + positionMap[i][1][0].imag ** 2)
sum += distribution[i]
print('sum: %s') % sum
return distribution
'''
Release 2 : for write data to txt file
'''
# quantum walk in cycle graph release for write data to txt file(直接将每一步的态与分布写到文件保存)
def QWCicleDistrWrite(X0, X1, steps, shiftGateNum, node):
print 'begin'
initPositionMap = zeros([node, 2, 1], complex)
initPositionMap[0] = initQuanStat(X0, X1)
DsitriFilename = 'Data/' + time.strftime('%Y%m%d-%H-%M-%S_') + 'Position' + str(shiftGateNum) + \
str(node) + str(steps) + '.txt'
StateFilename = 'Data/' + time.strftime('%Y%m%d-%H-%M-%S_') + 'State' + str(shiftGateNum) + \
str(node) + str(steps) + '.txt'
distrFile = open(DsitriFilename, 'w+')
stateFile = open(StateFilename, 'w+')
for step in range(1, steps + 1):
print 'step: %s' % step
positionMap = initPositionMap
initPositionMap = shiftCicleOperator(positionMap, step, shiftGateNum, node)
dimension = shape(initPositionMap)[0]
distribution = zeros([dimension], dtype=float)
sum = 0.0
for i in range(dimension):
distribution[i] = float(initPositionMap[i][0][0].real ** 2 + initPositionMap[i][0][0].imag ** 2 + \
initPositionMap[i][1][0].real ** 2 + initPositionMap[i][1][0].imag ** 2)
sum += distribution[i]
stateFile.write(str(initPositionMap[i][0][0]) + str(initPositionMap[i][1][0]) + '\t')
distrFile.write(str(distribution[i]) + '\t')
print('sum: %s') % sum
distrFile.write('\n')
stateFile.write('\n')
stateFile.close()
distrFile.close()
print 'finish'
'''
Release 3 : add phase coin and modified for complete graph
'''
# quantum walk in cycle graph release for phase coin (添加phase coin，对shift operator进行了修正)
def QWCicleWithPhaseDistrWrite(X0, X1, steps, shiftGateNum, node, Psi, gate):
print 'begin'
initPositionMap = zeros([node, 2, 1], complex)
initPositionMap[0] = initQuanStat(X0, X1)
# initPositionMap = initQuanStatAverPosiCicle(X0, X1,node)
PositionPsiFilename = 'Data/K5_X0' + str(X0) + '_X1' + str(X1) + '_' + str(shiftGateNum) + '-' + str(
node) + '_Steps' + str(steps) + '.txt'
PosiFile = open(PositionPsiFilename, 'a')
# DsitriFilename = 'Data/' + time.strftime('%Y%m%d-%H-%M-%S') + '_Position_' + str(shiftGateNum) + \
# str(node) + str(steps) + '.txt'
# StateFilename = 'Data/' + time.strftime('%Y%m%d-%H-%M-%S') + '_State_' + str(shiftGateNum) + \
# str(node) + str(steps) + '.txt'
# distrFile = open(DsitriFilename, 'w+')
# stateFile = open(StateFilename, 'w+')
# infoS = 'State: X0 %s X1 %s, steps: %s, shiftGateNum: %s, node: %s, Psi: %s, gate: %s\n' % (
# X0, X1, steps, shiftGateNum, node, Psi, gate)
# infoD = 'State: X0 %s X1 %s, steps: %s, shiftGateNum: %s, node: %s, Psi: %s, gate: %s \n' % (
# X0, X1, steps, shiftGateNum, node, Psi, gate)
# stateFile.write(infoS)
# distrFile.write(infoD)
for step in range(1, steps + 1):
print 'step: %s' % step
positionMap = initPositionMap
initPositionMap = shiftCicleWithPhaseOperator(positionMap, step, shiftGateNum, node, Psi, gate)
dimension = shape(initPositionMap)[0]
distribution = zeros([dimension], dtype=float)
sum = 0.0
PosiFile.write(str(Psi) + '\t')
PosiFile.write(str(step) + '\t')
for i in range(dimension):
distribution[i] = float(initPositionMap[i][0][0].real ** 2 + initPositionMap[i][0][0].imag ** 2 + \
initPositionMap[i][1][0].real ** 2 + initPositionMap[i][1][0].imag ** 2)
sum += distribution[i]
PosiFile.write(str(distribution[i]) + '\t')
# stateFile.write(str(initPositionMap[i][0][0]) + str(initPositionMap[i][1][0]) + '\t')
# distrFile.write(str(distribution[i]) + '\t')
PosiFile.write('\n')
print('sum: %s') % sum
# distrFile.write('\n')
# stateFile.write('\n')
# stateFile.close()
# distrFile.close()
PosiFile.close()
print 'finish'
'''
Release 4 : add phase coin and modified for complete graph with loop
'''
# quantum walk in cycle graph with loop release for phase coin
def QWCicleWithPhaseLoopDistrWrite(X0, X1, steps, shiftGateNum, node, Psi, gate):
print 'begin'
initPositionMap = zeros([node, 2, 1], complex)
initPositionMap[0] = initQuanStat(X0, X1)
#initPositionMap=initQuanStatAverPosiCicle(X0,X1,node)
DsitriFilename = 'Data/' + time.strftime('%Y%m%d-%H-%M-%S') + '_Position_' + str(shiftGateNum) + \
str(node) + str(steps) + '.txt'
StateFilename = 'Data/' + time.strftime('%Y%m%d-%H-%M-%S') + '_State_' + str(shiftGateNum) + \
str(node) + str(steps) + '.txt'
distrFile = open(DsitriFilename, 'w+')
stateFile = open(StateFilename, 'w+')
infoS = 'State: X0 %s X1 %s, steps: %s, shiftGateNum: %s, node: %s, Psi: %s, gate: %s\n' % (
X0, X1, steps, shiftGateNum, node, Psi, gate)
infoD = 'State: X0 %s X1 %s, steps: %s, shiftGateNum: %s, node: %s, Psi: %s, gate: %s \n' % (
X0, X1, steps, shiftGateNum, node, Psi, gate)
stateFile.write(infoS)
distrFile.write(infoD)
for step in range(1, steps + 1):
print 'step: %s' % step
positionMap = initPositionMap
initPositionMap = shiftCicleWithPhaseLoopOperator(positionMap, step, shiftGateNum, node, Psi, gate)
dimension = shape(initPositionMap)[0]
distribution = zeros([dimension], dtype=float)
sum = 0.0
for i in range(dimension):
distribution[i] = float(initPositionMap[i][0][0].real ** 2 + initPositionMap[i][0][0].imag ** 2 + \
initPositionMap[i][1][0].real ** 2 + initPositionMap[i][1][0].imag ** 2)
sum += distribution[i]
stateFile.write(str(initPositionMap[i][0][0]) + str(initPositionMap[i][1][0]) + '\t')
distrFile.write(str(distribution[i]) + '\t')
print('sum: %s') % sum
distrFile.write('\n')
stateFile.write('\n')
stateFile.close()
distrFile.close()
print 'finish'
'''
Release 5 : add phase coin and modified for complete graph with loop, write position
probability file with Psi
'''
# quantum walk in cycle graph with loop release for phase coin
def QWCicleWithPhaseLoopDistrWritePosi(X0, X1, steps, shiftGateNum, node, Psi, gate):
print 'begin'
initPositionMap = zeros([node, 2, 1], complex)
# initPositionMap[0] = initQuanStat(X0, X1)
initPositionMap = initQuanStatAverPosiCicle(X0, X1, node)
PositionPsiFilename = 'Data/Loop_X0' + str(X0) + '_X1' + str(X1) + '_' + str(shiftGateNum) + '-' + str(
node) + '_Steps' + str(steps) + 'Aver.txt'
PosiFile = open(PositionPsiFilename, 'a')
for step in range(1, steps + 1):
print 'step: %s' % step
positionMap = initPositionMap
initPositionMap = shiftCicleWithPhaseLoopOperator(positionMap, step, shiftGateNum, node, Psi, gate)
dimension = shape(initPositionMap)[0]
distribution = zeros([dimension], dtype=float)
sum = 0.0
for i in range(dimension):
distribution[i] = float(initPositionMap[i][0][0].real ** 2 + initPositionMap[i][0][0].imag ** 2 + \
initPositionMap[i][1][0].real ** 2 + initPositionMap[i][1][0].imag ** 2)
sum += distribution[i]
if i == 0:
PosiFile.write(str(Psi) + '\t')
PosiFile.write(str(step) + '\t')
PosiFile.write(str(distribution[i]) + '\n')
print('sum: %s') % sum
PosiFile.close()
print 'finish'
'''
Release 6 : Search one position by marked in complete graph with loop
'''
# quantum walk search in cycle graph with loop
def QWCicleWithPhaseLoopSearch(X0, X1, steps, shiftGateNum, node, Psi, gate):
print 'begin'
initPositionMap = zeros([node, 2, 1], complex)
initPositionMap[0] = initQuanStat(X0, X1)
# initPositionMap=initQuanStatAverPosiCicle(X0,X1,node)
# DsitriFilename = 'Data/' + time.strftime('%Y%m%d-%H-%M-%S') + '_Search_Position_' + str(shiftGateNum) + \
# str(node) + str(steps) + '.txt'
# StateFilename = 'Data/' + time.strftime('%Y%m%d-%H-%M-%S') + '_Search_State_' + str(shiftGateNum) + \
# str(node) + str(steps) + '.txt'
# distrFile = open(DsitriFilename, 'w+')
# stateFile = open(StateFilename, 'w+')
# infoS = 'Search State: X0 %s X1 %s, steps: %s, shiftGateNum: %s, node: %s, Psi: %s, gate: %s\n' % (
# X0, X1, steps, shiftGateNum, node, Psi, gate)
# infoD = 'Search State: X0 %s X1 %s, steps: %s, shiftGateNum: %s, node: %s, Psi: %s, gate: %s \n' % (
# X0, X1, steps, shiftGateNum, node, Psi, gate)
# stateFile.write(infoS)
# distrFile.write(infoD)
PositionPsiFilename = 'Data/Loop_Search_X0' + str(X0) + '_X1' + str(X1) + '_' + str(shiftGateNum) + '-' + str(
node) + '_Steps' + str(steps) + '.txt'
PosiFile = open(PositionPsiFilename, 'a')
for step in range(1, steps + 1):
print 'step: %s' % step
positionMap = initPositionMap
initPositionMap = shiftCicleWithPhaseLoopSearchOperator(positionMap, step, shiftGateNum, node, Psi, gate)
dimension = shape(initPositionMap)[0]
distribution = zeros([dimension], dtype=float)
sum = 0.0
for i in range(dimension):
distribution[i] = float(initPositionMap[i][0][0].real ** 2 + initPositionMap[i][0][0].imag ** 2 + \
initPositionMap[i][1][0].real ** 2 + initPositionMap[i][1][0].imag ** 2)
sum += distribution[i]
if i == 1:
PosiFile.write(str(Psi) + '\t')
PosiFile.write(str(step) + '\t')
PosiFile.write(str(distribution[i]) + '\n')
# stateFile.write(str(initPositionMap[i][0][0]) + str(initPositionMap[i][1][0]) + '\t')
# distrFile.write(str(distribution[i]) + '\t')
print('sum: %s') % sum
# distrFile.write('\n')
# stateFile.write('\n')
# stateFile.close()
# distrFile.close()
PosiFile.close()
print 'finish'
'''
Release 7 : Search one position by marked in complete graph
'''
# quantum walk in cycle graph release for phase coin (添加phase coin，对shift operator进行了修正)
def QWCicleWithPhaseSearch(X0, X1, steps, shiftGateNum, node, Psi, gate):
print 'begin'
initPositionMap = zeros([node, 2, 1], complex)
# initPositionMap[0] = initQuanStat(X0, X1)
initPositionMap = initQuanStatAverPosiCicle(X0, X1, node)
PositionPsiFilename = 'Data/Search mark_0 X0' + str(X0) + '_X1' + str(X1) + '_' + str(shiftGateNum) + '-' + str(
node) + '_Steps' + str(steps) + 'Aver.txt'
PosiFile = open(PositionPsiFilename, 'a')
for step in range(1, steps + 1):
print 'step: %s' % step
positionMap = initPositionMap
initPositionMap = shiftCicleWithPhaseSearchOperator(positionMap, step, shiftGateNum, node, Psi, gate)
dimension = shape(initPositionMap)[0]
distribution = zeros([dimension], dtype=float)
sum = 0.0
PosiFile.write(str(Psi) + '\t')
PosiFile.write(str(step) + '\t')
for i in range(dimension):
distribution[i] = float(initPositionMap[i][0][0].real ** 2 + initPositionMap[i][0][0].imag ** 2 + \
initPositionMap[i][1][0].real ** 2 + initPositionMap[i][1][0].imag ** 2)
sum += distribution[i]
PosiFile.write(str(distribution[i]) + '\t')
print('sum: %s') % sum
PosiFile.write('\n')
PosiFile.close()
print 'finish'
# 对位置列表进行位移，使原点保持不变
#TODO 位置变换有点问题，暂时不用
def ciclePosiTrans(positionMap, steps, shiftGateNum):
node = shape(positionMap)[0]
positionMapTrans = zeros([node], float)
initNode = (power(2, shiftGateNum) - 1) * steps % node
for i in range(node):
positionMapTrans[i] = positionMap[(initNode + i) % node]
return positionMapTrans
# 画出2D位置分布图
def PlotCicle(distribution, steps, shiftGateNum, figName):
node = shape(distribution)[0]
radius = 1
x = zeros([node], float)
y = zeros([node], float)
for i in range(node):
x[i] = sin(i * 2 * math.pi / node) * radius
y[i] = cos(i * 2 * math.pi / node) * radius
plt.figure(1, figsize=(20, 9))
ax1 = plt.subplot(121)
plt.sca(ax1)
plt.title('Distribution of %s steps Quantum Walk in Cicle' % steps)
plt.xlabel('X Position')
plt.ylabel('Y Position')
# plt.imshow(positionMap)
# plt.axis([0, 2 * int(radius) + 3, 0, 2 * int(radius) + 3])
# plt.grid(True)
plt.scatter(x, y, distribution * 2000, c='r', marker='o')
plt.axis([-1.5, 1.5, -1.5, 1.5])
plt.subplot(122)
plt.plot(distribution)
plt.axis([0, node - 1, 0, 1])
plt.title('Distribution of %s steps QW with Different Shift' % steps)
plt.xlabel('Started from 0')
plt.ylabel('Probability')
# plt.show()
plt.savefig('Fig/' + str(figName) + str(steps) + '_' + str(shiftGateNum) + '.png')
plt.close()
|
Python
|
2D
|
daihui/QuantumWalkSimulation
|
quantumRW.py
|
.py
| 7,551
| 163
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'levitan'
from numpy import *
from matplotlib import pyplot as plt
import copy
dimension = 1
def initQuantumStateList(X0, X1, Y0, Y1, totalSteps):
initquantumStateList = zeros([2 * totalSteps + 1, 2 * totalSteps + 1, 2, 2], dtype=complex)
initquantumStateList[totalSteps][totalSteps][0][0] = complex(X0)
initquantumStateList[totalSteps][totalSteps][0][1] = complex(X1)
initquantumStateList[totalSteps][totalSteps][1][0] = complex(Y0)
initquantumStateList[totalSteps][totalSteps][1][1] = complex(Y1)
return initquantumStateList
# print quantumState(1,1,0,0,1,1,0,0)
def hadamardCoin(quantumStateList, totalSteps):
global dimension
for x in range(dimension):
for y in range(dimension):
tempState = zeros([2, 2], dtype=complex)
tempState = copy.deepcopy(
quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y])
quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][0][
0] = complex((tempState[0][0] + tempState[0][1]) / sqrt(2))
quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][0][
1] = complex((tempState[0][0] - tempState[0][1]) / sqrt(2))
quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][1][
0] = complex((tempState[1][0] + tempState[1][1]) / sqrt(2))
quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][1][
1] = complex((tempState[1][0] - tempState[1][1]) / sqrt(2))
# print quantumStateList
return quantumStateList
# qs=quantumState(0,1,0,0,0,1,0,0)
# print qs
# print hadamardCoin(qs)
def shiftOperator(quantumStateList, totalSteps):
global dimension
newQuanStatList = zeros([2 * totalSteps + 1, 2 * totalSteps + 1, 2, 2], dtype=complex)
for x in range(dimension):
for y in range(dimension):
newQuanStat1 = zeros([2, 2], dtype=complex)
newQuanStat1[0][0] = \
quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][0][0]
newQuanStat1[0][1] = 0.0
newQuanStat1[1][0] = \
quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][1][0]
newQuanStat1[1][1] = 0.0
newQuanStatList[totalSteps - (dimension - 1) / 2 + x - 1][
totalSteps - (dimension - 1) / 2 + y - 1] += (newQuanStat1 / sqrt(2))
newQuanStat2 = zeros([2, 2], dtype=complex)
newQuanStat2[0][0] = \
quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][0][0]
newQuanStat2[0][1] = 0.0
newQuanStat2[1][0] = 0.0
newQuanStat2[1][1] = \
quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][1][1]
newQuanStatList[totalSteps - (dimension - 1) / 2 + x - 1][
totalSteps - (dimension - 1) / 2 + y + 1] += (newQuanStat2 / sqrt(2))
newQuanStat3 = zeros([2, 2], dtype=complex)
newQuanStat3[0][0] = 0.0
newQuanStat3[0][1] = \
quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][0][1]
newQuanStat3[1][0] = 0.0
newQuanStat3[1][1] = \
quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][1][1]
newQuanStatList[totalSteps - (dimension - 1) / 2 + x + 1][
totalSteps - (dimension - 1) / 2 + y + 1] += (newQuanStat3 / sqrt(2))
newQuanStat4 = zeros([2, 2], dtype=complex)
newQuanStat4[0][0] = 0.0
newQuanStat4[0][1] = \
quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][0][1]
newQuanStat4[1][0] = \
quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][1][0]
newQuanStat4[1][1] = 0.0
newQuanStatList[totalSteps - (dimension - 1) / 2 + x + 1][
totalSteps - (dimension - 1) / 2 + y - 1] += (newQuanStat4 / sqrt(2))
dimension += 2
return newQuanStatList
def quantumWalker(X0, X1, Y0, Y1, totalSteps,plotSteps):
global dimension
initStateList = initQuantumStateList(X0, X1, Y0, Y1, totalSteps)
newQuanStatList = zeros([2 * totalSteps + 1, 2 * totalSteps + 1, 2, 2], dtype=complex)
shiftQuanStatList = initStateList
for i in range(1,totalSteps+1):
newQuanStatList = hadamardCoin(shiftQuanStatList, totalSteps)
shiftQuanStatList = shiftOperator(newQuanStatList, totalSteps)
if (i!=0)&(i%plotSteps == 0) :
print dimension
print i
plotQW=distriQW(shiftQuanStatList,dimension,totalSteps)
Plot2D(plotQW,i)
dimension = 1
return shiftQuanStatList
def distriQW(quantumWalkerList, dim,totalSteps):
distribution = zeros([2 * totalSteps + 1, 2 * totalSteps + 1], dtype=float)
sum = 0.0
# print quantumWalkerList
for x in range(dim):
for y in range(dim):
distribution[totalSteps-(dim-1)/2+x][totalSteps-(dim-1)/2 +y] += float(
abs((quantumWalkerList[totalSteps-(dim-1)/2+x][totalSteps-(dim-1)/2 +y][0][0].real ** 2 + quantumWalkerList[totalSteps-(dim-1)/2+x][totalSteps-(dim-1)/2 +y][0][0].imag ** 2))
+ abs((quantumWalkerList[totalSteps-(dim-1)/2+x][totalSteps-(dim-1)/2 +y][0][1].real ** 2 + quantumWalkerList[totalSteps-(dim-1)/2+x][totalSteps-(dim-1)/2 +y][0][1].imag ** 2))
+ abs((quantumWalkerList[totalSteps-(dim-1)/2+x][totalSteps-(dim-1)/2 +y][1][0].real ** 2 + quantumWalkerList[totalSteps-(dim-1)/2+x][totalSteps-(dim-1)/2 +y][1][0].imag ** 2))
+ abs((quantumWalkerList[totalSteps-(dim-1)/2+x][totalSteps-(dim-1)/2 +y][1][1].real ** 2 + quantumWalkerList[totalSteps-(dim-1)/2+x][totalSteps-(dim-1)/2 +y][1][1].imag ** 2)))
sum += distribution[totalSteps-dim +x][totalSteps-dim +y]
print('Sum= %s' % sum)
return distribution / sum
def writeQWtoArray(distribution, filename):
distrFlie = open(filename, 'w+')
for x in range(shape(distribution)[0]):
for y in range(shape(distribution)[1]):
distrFlie.write(str(distribution[x][y]) + '\t')
distrFlie.write('\n')
distrFlie.close()
def writeQWtoList(distribution, filename):
distrFlie = open('Data/' + filename, 'w+')
for x in range(shape(distribution)[0]):
for y in range(shape(distribution)[1]):
distrFlie.write(str(x) + '\t' + str(y) + '\t' + str(distribution[x][y]) + '\n')
distrFlie.close()
def Plot2D(qw,steps):
plt.figure(1)
ax1 = plt.subplot(111)
plt.sca(ax1)
plt.title('2D distribution of %s steps Quantum Walk with hadamard coin' %steps)
plt.xlabel('X Position (started in center)')
plt.ylabel('Y Position (started in center)')
plt.imshow(qw)
plt.savefig('Fig/QW_' + str(steps) + '.png')
plt.close()
def PlotX(qw, Y):
qwX = qw[:][Y]
plt.plot(qwX)
plt.title('a Slice of 2D distribution of Quantum Walk')
plt.xlabel('Position(started in %s)' % Y)
plt.ylabel('Probability')
plt.show()
|
Python
|
End of preview. Expand
in Data Studio
DATA1: Domain-Specific Code Dataset
Dataset Overview
DATA1 is a large-scale domain-specific code dataset focusing on code samples from interdisciplinary fields such as biology, chemistry, materials science, and related areas. The dataset is collected and organized from GitHub repositories, covering 178 different domain topics with over 1.1 billion lines of code.
Dataset Statistics
- Total Datasets: 178 CSV files
- Total Data Size: ~115 GB
- Total Lines of Code: Over 1.1 billion lines
- Data Format: CSV (Comma-Separated Values)
- Encoding: UTF-8
Dataset Structure
Each CSV file corresponds to a specific domain topic, with the naming format dataset_{Topic}.csv, where {Topic} is the domain keyword (e.g., Protein, Drug, Genomics).
Data Field Description
Each CSV file contains the following fields:
| Field Name | Type | Description |
|---|---|---|
keyword |
String | Domain keyword used to identify the domain of the code sample |
repo_name |
String | GitHub repository name (format: owner/repo) |
file_path |
String | Relative path of the file in the repository |
file_extension |
String | File extension (e.g., .py, .java, .cpp) |
file_size |
Integer | File size in bytes |
line_count |
Integer | Number of lines of code in the file |
content |
String | Complete file content |
language |
String | Programming language (e.g., Python, Java, C++) |
Domain Categories
The dataset covers the following major domain categories:
Biology-Related
- Molecular Biology: Protein, DNA, RNA, Gene, Enzyme, Receptor, Ligand
- Cell Biology: Cell_biology, Single_cell, Cell_atlas, Organoid
- Genomics: Genomics, Genotype, Phenotype, Epigenetics, Metagenomics
- Transcriptomics: Transcriptomics, Spatial_Transcriptomics, Transcription, Translation
- Proteomics: Proteomics, Protein_Protein_Interactions, Folding
- Metabolomics: Metabolomics, Metabolic, Lipidomics, Glycomics
- Systems Biology: System_biology, Signaling, Pathway, Networks
Chemistry-Related
- Computational Chemistry: Computational_Chemistry, Quantum_Chemistry, DFT, QM_MM
- Medicinal Chemistry: Drug, ADMET, QSAR, Docking, Lead_discovery, Lead_optimization
- Materials Chemistry: Material, Crystal, Conformation, Chemical_space
- Reaction Chemistry: Reaction, Kinetics, Mechanism, Redox
Medicine and Pharmacology
- Pharmacology: Pharmacology, Pharmacokinetics, Pharmacogenomics, Pharmacogenetics
- Medicine: Medicine, Disease, Diagnostics, Pathology, Vaccine
- Toxicology: Toxicology, Biomarker, Marker
Computational Methods
- Machine Learning: Transformer, GAN, VAE, Diffusion, Flow_matching, Reinforcement_learning
- Quantum Computing: Quantum_mechanics, Quantum_biology, Electronic_structure
- Modeling Methods: Modeling, Multi_scale_modeling, Agent_based_model, Stochastic_modeling
- Numerical Methods: Monte_Carlo, Finite_element_method, Phase_field_technique
Other Specialized Fields
- Bioinformatics: Bioinformatics, Cheminformatics, Next_generation_sequencing
- Bioengineering: Bioengineering, Biotechnology, Biosensors
- Immunology: Immunology, Antibody, Antigen, Antagonist
- Virology: Viral, Pandemic, Pathogens, AMR (Antimicrobial Resistance)
Data Source
The data is collected from open-source repositories on GitHub through the following process:
- Keyword Search: Search for relevant repositories on GitHub using domain-specific keywords
- Repository Filtering: Filter repositories based on relevance scores and code quality
- File Extraction: Extract code files from filtered repositories
- Categorization: Classify files into corresponding topic datasets based on keywords and domain characteristics
Dataset Characteristics
- Wide Domain Coverage: Covers multiple interdisciplinary fields including biology, chemistry, materials science, and medicine
- Diverse Code Types: Includes multiple programming languages such as Python, Java, C++, R, and MATLAB
- Large Scale: Over 1.1 billion lines of code with a total data size of 115 GB
- Structured Storage: Each domain topic is stored independently as a CSV file for convenient on-demand usage
- Rich Metadata: Contains comprehensive metadata including repository information, file paths, and language types
Usage Guidelines
Data Loading
import pandas as pd
# Load dataset for a specific domain
df = pd.read_csv('dataset_Protein.csv')
# View basic dataset information
print(f"Dataset size: {len(df)} files")
print(f"Programming language distribution: {df['language'].value_counts()}")
print(f"File type distribution: {df['file_extension'].value_counts()}")
Data Filtering
# Filter by programming language
python_files = df[df['language'] == 'Python']
# Filter by file size (e.g., files smaller than 100KB)
small_files = df[df['file_size'] < 100000]
# Filter by line count
medium_files = df[(df['line_count'] > 50) & (df['line_count'] < 1000)]
Domain-Specific Analysis
# Analyze code characteristics for a specific domain
protein_df = pd.read_csv('dataset_Protein.csv')
print(f"Number of code files in Protein domain: {len(protein_df)}")
print(f"Average file size: {protein_df['file_size'].mean():.2f} bytes")
print(f"Average line count: {protein_df['line_count'].mean():.2f} lines")
Important Notes
- File Size: Some dataset files are large (up to several GB), please be mindful of memory usage when loading
- Encoding: All files use UTF-8 encoding; ensure proper handling of special characters if encountered
- Data Quality: Data is sourced from public repositories and may vary in code quality; preprocessing is recommended before use
- License Compliance: Please comply with the license requirements of the original repositories when using the data
- Downloads last month
- 22