examples

Author: J-C-Q

examples/Fibonacci/entanglement.jl

@@ -0,0 +1,46 @@
+using MonitoredQuantumCircuits
+import JLD2
+import ProgressMeter
+function simulate(path::String; depth=100, L=12, averaging=10, resolution=100, boundary=Open)
+
+    # points = point_distribution(resolution; ratio_in_high_density_region=0.7, high_density_center=0.39, high_density_width=0.1)
+    points = point_distribution(resolution; ratio_in_high_density_region=0.7, high_density_center=0.43, high_density_width=0.15)
+
+
+    geometry = ChainGeometry(boundary, L)
+    progressMeter = ProgressMeter.Progress(length(points) * averaging; dt=1.0)
+    Threads.@threads for p in points
+        circuit = compile(MeasurementOnlyFibonacciDrive(geometry, p; depth))
+
+        sim = QuantumClifford.TableauSimulator(nQubits(geometry); mixed=false, basis=:X)
+        entropies = zeros(L + 1)
+        for _ in 1:averaging
+            result = execute(circuit, sim)
+            for i in 0:L
+                entropies[i+1] += QuantumClifford.entanglement_entropy(result.stab, 1:i)
+            end
+            ProgressMeter.next!(progressMeter)
+        end
+        entropies ./= averaging
+        JLD2.save(
+            "$path/$(L)_$(depth)/ENT_L=$(L)_averaging=$(averaging)_p=$(p)_depth=$(depth).jld2",
+            "entropies", entropies, "p", p)
+    end
+end
+
+
+function point_distribution(n; ratio_in_high_density_region=0.5, high_density_center=0.3, high_density_width=0.1)
+    d = ratio_in_high_density_region / 2high_density_width
+    a = high_density_center
+    b = high_density_width
+    equal_points = range(0, 1, n)
+    f1(x) = (a - b) / (-b * d + a) * x
+    f2(x) = 1 / d * (x - a) + a
+
+    f3(x) = (1 - a - b) / (1 - d * b - a) * (x - b * d - a) + a + b
+
+    cross12 = (-a / d + a) / ((a - b) / (-b * d + a) - 1 / d)
+    cross23 = ((1 - a - b) / (1 - b * d - a) * (b * d + a) - b - a / d) / ((1 - a - b) / (1 - d * b - a) - 1 / d)
+    f(x) = x < cross12 ? f1(x) : x < cross23 ? f2(x) : f3(x)
+    return [f(x) for x in equal_points]
+end

examples/Fibonacci/entanglement_half.jl

@@ -0,0 +1,44 @@
+using MonitoredQuantumCircuits
+import Statistics
+import UUIDs
+import JLD2
+import ProgressMeter
+function simulate(path::String; depth=15, L=128, averaging=10000, resolution=24)
+
+    # define the p values to sample
+    rg = (1+sqrt(5))/2
+    left = 1/(1+rg)
+    right = (1+rg)^2/2rg - sqrt(((1+rg)^2/2rg)^2 - (1+rg)/rg)
+    points = range(left, right+0.01, resolution)
+
+    # construct the geometry
+    geometry = ChainGeometry(Open, L)
+
+    # create the progress meter
+    progressMeter = ProgressMeter.Progress(length(points) * averaging; dt=1.0)
+
+    # simulate the circuit for each probability point
+    Threads.@threads for p in points
+
+        # construct circuit and simulator
+        circuit = compile(MeasurementOnlyFibonacciDrive(geometry, p; depth))
+        sim = QuantumClifford.TableauSimulator(nQubits(geometry); mixed=false, basis=:X)
+
+        entropies = zeros(averaging)
+        for i in 1:averaging
+            result = execute(circuit, sim)
+            entropies[i] = QuantumClifford.entanglement_entropy(result.stab, 1:L÷2)
+            ProgressMeter.next!(progressMeter)
+        end
+        average = sum(entropies) / averaging
+        error = Statistics.std(entropies) / sqrt(averaging)
+        JLD2.save(
+            "$path/L$(L)_D$(depth)/ENTh_avg$(averaging)_p$(p)_$(UUIDs.uuid4().value).jld2",
+            "probability", p,
+            "entanglement", average,
+            "error", error,
+            "depth", depth,
+            "system_size", L,
+            "samples", averaging)
+    end
+end

examples/Fibonacci/entanglement_half_peaks.jl

@@ -0,0 +1,90 @@
+using LinearRegression
+function entanglementPlotPeaks(file::String, data_path::String; depths=[100], Ls=[100], averagings=[100], resolutions=[24])
+
+
+
+
+    fig = Figure()
+    ax = Axis(fig[1, 1], xlabel=L"$1/L$", ylabel=L"$$peak probability",
+        title=L"$$Entanglement Entropy for Fibonacci Drive, depth=%$(depths[1])",)
+
+    hlines!(ax, [0.38196601125010515], color=:orange)
+    data_xs = Float64[]
+    data_ys = Float64[]
+    for (d, l, a, resolution) in zip(depths, Ls, averagings, resolutions)
+        points = point_distribution(resolution; ratio_in_high_density_region=0.7, high_density_center=0.43, high_density_width=0.15)
+
+        entropies = Float64[]
+        for (i, p) in enumerate(points)
+            push!(entropies, JLD2.load("$data_path/ENT_L=$(l)_averaging=$(a)_p=$(p)_depth=$(d).jld2")["entropies"][div(l, 2)+1])
+        end
+        # scatterlines!(ax, points, entropies, color=l, colormap=:blues, colorrange=(32, 512), label=L"%$l")
+
+        # cubic_spline interpolation
+        itp = cubic_spline(points, entropies)
+        x_interp = range(0, 1, 10000)
+        y_interp = itp(x_interp)
+
+        push!(data_xs, 1 / l)
+        push!(data_ys, x_interp[argmax(y_interp)])
+
+
+    end
+
+
+    # fit = linregress(data_xs[end-2:end], data_ys[end-2:end])
+    # fit = linregress(data_xs, data_ys)
+    fit = linregress(data_xs[end-3:end], data_ys[end-3:end])
+
+    xs = range(0, 1 / minimum(Ls), 1000)
+    lines!(ax, xs, LinearRegression.slope(fit) .* xs .+ LinearRegression.bias(fit), color=:black)
+    hlines!(ax, [LinearRegression.bias(fit)], color=:orange)
+
+
+    text!(ax, [0.01], [LinearRegression.bias(fit)], text=L"$$linear fit intercept=%$(LinearRegression.bias(fit))", color=:orange)
+
+    text!(ax, [0.02], [0.38196601125010515], text=L"$$golden ratio", color=:orange)
+
+
+    scatter!(ax, data_xs, data_ys, color=1.0 ./ data_xs, colormap=:reds, colorrange=(32, 1024))
+
+    limits!(ax, 0, nothing,nothing,nothing)
+    # axislegend(ax, L"system size $L$", position=:lb,)
+    save("$file.svg", fig)
+    save("$file.png", fig)
+    save("$file.pdf", fig)
+    display(fig)
+end
+
+using Dierckx
+function cubic_spline(x::AbstractVector{<:Real},
+    y::AbstractVector{<:Real})
+
+    length(x) == length(y) ||
+        throw(ArgumentError("x and y must have the same length"))
+
+    # Ensure the nodes are strictly increasing
+    idx = sortperm(x)
+    xs = collect(Float64, x[idx])   # force concrete arrays
+    ys = collect(Float64, y[idx])
+
+    # sitp = Spline1D(xs, ys, xs[5:2:end-12]; w=ones(length(xs)), k=3, bc="nearest")
+    sitp = Spline1D(xs, ys; w=ones(length(xs)), k=3, bc="nearest", s=0.0)
+    return sitp
+end
+
+function point_distribution(n; ratio_in_high_density_region=0.5, high_density_center=0.3, high_density_width=0.1)
+    d = ratio_in_high_density_region / 2high_density_width
+    a = high_density_center
+    b = high_density_width
+    equal_points = range(0, 1, n)
+    f1(x) = (a - b) / (-b * d + a) * x
+    f2(x) = 1 / d * (x - a) + a
+
+    f3(x) = (1 - a - b) / (1 - d * b - a) * (x - b * d - a) + a + b
+
+    cross12 = (-a / d + a) / ((a - b) / (-b * d + a) - 1 / d)
+    cross23 = ((1 - a - b) / (1 - b * d - a) * (b * d + a) - b - a / d) / ((1 - a - b) / (1 - d * b - a) - 1 / d)
+    f(x) = x < cross12 ? f1(x) : x < cross23 ? f2(x) : f3(x)
+    return [f(x) for x in equal_points]
+end

examples/Fibonacci/entanglement_half_plot.jl

@@ -0,0 +1,42 @@
+using CairoMakie
+using JLD2
+using LinearAlgebra
+
+function entanglementPlot(file::String, data_path::String; depth=100, L=100, averaging=100, resolution=100)
+
+    # points = point_distribution(resolution; ratio_in_high_density_region=0.7, high_density_center=0.43, high_density_width=0.15)
+    points = point_distribution(resolution; ratio_in_high_density_region=0.7, high_density_center=0.39, high_density_width=0.1)
+
+    entropies = Float64[]
+    for (i, p) in enumerate(points)
+        push!(entropies, JLD2.load("$data_path/ENT_L=$(L)_averaging=$(averaging)_p=$(p)_depth=$depth.jld2")["entropies"][div(L,2)+1])
+    end
+
+
+    fig = Figure()
+    ax = Axis(fig[1, 1], xlabel=L"measurement ratio $p$", ylabel=L"entanglement entropy $S_{L/2}$",
+              title="Entanglement Entropy for Fibonacci Drive")
+
+    scatterlines!(ax, points, entropies)
+
+    vlines!(ax, [0.38196601125010515])
+    save("$file.svg", fig)
+    save("$file.png", fig)
+    display(fig)
+end
+
+function point_distribution(n; ratio_in_high_density_region=0.5, high_density_center=0.3, high_density_width=0.1)
+    d = ratio_in_high_density_region/2high_density_width
+    a = high_density_center
+    b = high_density_width
+    equal_points = range(0, 1, n)
+    f1(x) = (a-b)/(-b*d+a)*x
+    f2(x) = 1/d*(x-a)+a
+
+    f3(x) = (1-a-b)/(1-d*b-a)*(x-b*d-a)+a+b
+
+    cross12 = (-a/d+a)/((a-b)/(-b*d+a)-1/d)
+    cross23 = ((1-a-b)/(1-b*d-a)*(b*d+a)-b-a/d)/((1-a-b)/(1-d*b-a)-1/d)
+    f(x) = x < cross12 ? f1(x) : x < cross23 ? f2(x) : f3(x)
+    return [f(x) for x in equal_points]
+end

examples/Fibonacci/entanglement_half_plot_together.jl

@@ -0,0 +1,76 @@
+function entanglementPlotTogether(file::String, data_path::String; depths=[100], Ls=[100], averagings=[100], resolutions=[24])
+
+    # points = point_distribution(resolution; ratio_in_high_density_region=0.7, high_density_center=0.43, high_density_width=0.15)
+
+
+
+    fig = Figure()
+    ax = Axis(fig[1, 1], xlabel=L"measurement rate $p$", ylabel=L"entanglement entropy $S_{L/2}$",
+        title=L"$$Entanglement Entropy for Fibonacci Drive, depth=%$(depths[1])",)
+
+
+    l1 = vlines!(ax, [0.38196601125010515], color=:orange)
+    l2 = vlines!(ax, [0.41279780151928236], color=:red)
+    l3 =vlines!(ax, [0.4245069034188409], color=:black)
+    for (d, l, a, resolution) in reverse(collect(zip(depths, Ls, averagings, resolutions)))
+        points = point_distribution(resolution; ratio_in_high_density_region=0.7, high_density_center=0.43, high_density_width=0.15)
+
+        entropies = Float64[]
+        for (i, p) in enumerate(points)
+            push!(entropies, JLD2.load("$data_path/ENT_L=$(l)_averaging=$(a)_p=$(p)_depth=$(d).jld2")["entropies"][div(l, 2)+1])
+        end
+        plot = scatterlines!(ax, points, entropies, color=l, colormap=:blues, colorrange=(32, 1024), label=L"%$l")
+        translate!(plot, 0,0,1/l)
+
+        # cubic_spline interpolation
+        itp = cubic_spline(points, entropies; bc=:flat)
+        x_interp = range(0, 1, 10000)
+        y_interp = itp(x_interp)
+
+
+        int = lines!(ax, x_interp, y_interp, color=l, colormap=:reds, colorrange=(32, 1024))
+        translate!(int, 0,0,1/l+0.001)
+
+    end
+    # text!(ax, [0.38196601125010515], [0.5], text=L"$$golden ratio", color=:orange, rotation=pi / 2)
+
+    axislegend(ax, L"system size $L$", position=:rt,)
+    axislegend(ax, [l1,l2,l3], [L"golden ratio $1/(1+\phi)$", L"$$numerical extrapolation", L"$$theoretical value"], position = :lb)
+    save("$file.svg", fig)
+    save("$file.png", fig)
+    save("$file.pdf", fig)
+    display(fig)
+end
+
+using Dierckx
+function cubic_spline(x::AbstractVector{<:Real},
+    y::AbstractVector{<:Real};
+    bc::Symbol=:flat)
+
+    length(x) == length(y) ||
+        throw(ArgumentError("x and y must have the same length"))
+
+    # Ensure the nodes are strictly increasing
+    idx = sortperm(x)
+    xs = collect(Float64, x[idx])   # force concrete arrays
+    ys = collect(Float64, y[idx])
+
+    sitp = Spline1D(xs, ys; w=ones(length(xs)), k=3, bc="nearest", s=0.0)
+    return sitp
+end
+
+function point_distribution(n; ratio_in_high_density_region=0.5, high_density_center=0.3, high_density_width=0.1)
+    d = ratio_in_high_density_region / 2high_density_width
+    a = high_density_center
+    b = high_density_width
+    equal_points = range(0, 1, n)
+    f1(x) = (a - b) / (-b * d + a) * x
+    f2(x) = 1 / d * (x - a) + a
+
+    f3(x) = (1 - a - b) / (1 - d * b - a) * (x - b * d - a) + a + b
+
+    cross12 = (-a / d + a) / ((a - b) / (-b * d + a) - 1 / d)
+    cross23 = ((1 - a - b) / (1 - b * d - a) * (b * d + a) - b - a / d) / ((1 - a - b) / (1 - d * b - a) - 1 / d)
+    f(x) = x < cross12 ? f1(x) : x < cross23 ? f2(x) : f3(x)
+    return [f(x) for x in equal_points]
+end

examples/Fibonacci/entanglent_plot.jl

@@ -0,0 +1,24 @@
+using CairoMakie
+using JLD2
+using LinearAlgebra
+
+function entanglementPlot(file::String, data_path::String; depth=100, L=100, averaging=100, resolution=100)
+
+    points = range(0, 1, resolution)
+    entropies = Vector{Float64}[]
+    for (i, p) in enumerate(points)
+        push!(entropies, JLD2.load("$data_path/ENT_L=$(L)_averaging=$(averaging)_p=$(p)_depth=$depth.jld2")["entropies"])
+    end
+
+
+    fig = Figure()
+    ax = Axis(fig[1, 1], xlabel=L"subsystem size $l$", ylabel=L"entanglement entropy $S_l$",
+              title="Entanglement Entropy for Fibonacci Drive")
+    for (i,e) in enumerate(entropies)
+        scatterlines!(ax, 0:L, e, label="p=$(round(points[i], digits=2))", color = 1-points[i], colormap = :blues, colorrange = (0,1))
+    end
+    axislegend(ax)
+    save("$file.svg", fig)
+    save("$file.png", fig)
+    display(fig)
+end

examples/Nishimori/NishimorisCat.jl

@@ -1,7 +1,7 @@
 using MonitoredQuantumCircuits
 import JLD2
 import ProgressMeter
-function simulate(; path="", L=12, averaging=10)
+function simulate(; path="", L=12, averaging=10, tApi=1/4)
     geometry = HoneycombGeometry(Open, L, L)
-    circuit = compile(NishimorisCat(geometry))
+    circuit = compile(NishimorisCat(geometry; tApi))
 end