SciCodePile/SciCode-Domain-Code

1"keyword","repo_name","file_path","file_extension","file_size","line_count","content","language"
2"Conjugate","guochu/VQC.jl","src/densitymatrix.jl",".jl","4224","96","struct DensityMatrix{T <: Number}3	data::Vector{T}4	nqubits::Int5 6function DensityMatrix{T}(data::AbstractVector{<:Number}, nqubits::Int) where {T <: Number}7	(length(data) == 2^(2*nqubits)) || throw(DimensionMismatch())8	new{T}(convert(Vector{T}, data), nqubits)9end10 11end12 13function DensityMatrix{T}(m::AbstractMatrix{<:Number}, nqubits::Int) where {T <: Number}14	(size(m, 1) == size(m, 2) == 2^nqubits) || throw(DimensionMismatch())15	return DensityMatrix{T}(reshape(m, length(m)), nqubits)16end17function DensityMatrix{T}(m::AbstractVector{<:Number}) where {T <: Number}18	n = _nqubits(m)19	return DensityMatrix{T}(m, div(n, 2))20end21DensityMatrix{T}(m::AbstractMatrix{<:Number}) where {T <: Number} = DensityMatrix{T}(reshape(m, length(m)))22 23DensityMatrix(data::Union{AbstractVector, AbstractMatrix}, nqubits::Int) = DensityMatrix{eltype(data)}(data, nqubits)24DensityMatrix(data::AbstractVector) = DensityMatrix(data, div(_nqubits(data), 2))25DensityMatrix(data::AbstractMatrix) = DensityMatrix(reshape(data, length(data)))26function DensityMatrix{T}(nqubits::Int) where {T<:Number}27	 v = zeros(T, 2^(2*nqubits))28	 v[1,1] = 129	 return DensityMatrix{T}(v, nqubits)30end31DensityMatrix(::Type{T}, nqubits::Int) where {T<:Number} = DensityMatrix{T}(nqubits)32DensityMatrix(nqubits::Int) = DensityMatrix(ComplexF64, nqubits)33DensityMatrix(x::DensityMatrix) = DensityMatrix(x.data, nqubits(x))34DensityMatrix(x::StateVector) = (x_data = storage(x); DensityMatrix(kron(conj(x_data), x_data), nqubits(x)))35 36 37storage(x::DensityMatrix) = (L = 2^(nqubits(x)); reshape(x.data, L, L))38QuantumCircuits.nqubits(x::DensityMatrix) = x.nqubits39 40Base.eltype(::Type{DensityMatrix{T}}) where T = T41Base.eltype(x::DensityMatrix) = eltype(typeof(x))42Base.getindex(x::DensityMatrix, j::Int...) = getindex(storage(x), j...)43Base.setindex!(x::StateVector, v, j::Int...) = setindex!(storage(x), v, j...)44 45Base.convert(::Type{DensityMatrix{T}}, x::DensityMatrix) where {T<:Number} = DensityMatrix(convert(Vector{T}, x.data), nqubits(x))46Base.copy(x::DensityMatrix) = DensityMatrix(copy(x.data), nqubits(x))47 48 49Base.cat(v::DensityMatrix) = v50function Base.cat(v::DensityMatrix...)51    a, b = _qcat_util(storage.(v)...)52    return DensityMatrix(kron(a, b))53end54 55Base.isapprox(x::DensityMatrix, y::DensityMatrix; kwargs...) = isapprox(x.data, y.data; kwargs...)56Base.:(==)(x::DensityMatrix, y::DensityMatrix) = x.data == y.data57 58Base.:+(x::DensityMatrix, y::DensityMatrix) = DensityMatrix(x.data + y.data, nqubits(x))59Base.:-(x::DensityMatrix, y::DensityMatrix) = DensityMatrix(x.data - y.data, nqubits(x))60Base.:*(x::DensityMatrix, y::Number) = DensityMatrix(x.data * y, nqubits(x))61Base.:*(x::Number, y::DensityMatrix) = y * x62Base.:/(x::DensityMatrix, y::Number) = DensityMatrix(x.data / y, nqubits(x))63 64 65LinearAlgebra.tr(x::DensityMatrix) = tr(storage(x))66LinearAlgebra.dot(x::DensityMatrix, y::DensityMatrix) = dot(storage(x), storage(y))67LinearAlgebra.normalize!(x::DensityMatrix) = (x.data ./= tr(x); x)68LinearAlgebra.normalize(x::DensityMatrix) = normalize!(copy(x))69LinearAlgebra.ishermitian(x::DensityMatrix) = ishermitian(storage(x))70LinearAlgebra.isposdef(x::DensityMatrix) = isposdef(storage(x))71 72fidelity(x::DensityMatrix, y::DensityMatrix) = real(tr(sqrt(storage(x)) * sqrt(storage(y))))73fidelity(x::DensityMatrix, y::StateVector) = real(dot(storage(y), storage(x), storage(y)))74fidelity(x::StateVector, y::DensityMatrix) = fidelity(y, x)75distance2(x::DensityMatrix, y::DensityMatrix) = _distance2(x, y)76distance(x::DensityMatrix, y::DensityMatrix) = _distance(x, y)77schmidt_numbers(x::DensityMatrix) = eigvals(Hermitian(storage(x)))78renyi_entropy(x::DensityMatrix; kwargs...) = renyi_entropy(schmidt_numbers(x); kwargs...)79 80function rand_densitymatrix(::Type{T}, n::Int) where {T <: Number}81    (n >= 1) || error(""number of qubits must be positive."")82    L = 2^n83    v = randn(T, L, L)84    v = v' * v85    return normalize!(DensityMatrix(v' * v, n))86end87rand_densitymatrix(n::Int) = rand_densitymatrix(ComplexF64, n)88 89function QuantumCircuits.permute(x::DensityMatrix, newindex::Vector{Int})90	n = nqubits(x)91	L = length(x.data)92	return DensityMatrix(reshape(permute(reshape(x.data, ntuple(i->2, 2*n)), vcat(newindex, newindex .+ n)), L), n)93end 94 95 96 97","Julia"
98"Conjugate","guochu/VQC.jl","src/measure.jl",".jl","2569","90","""""""99	apply!(x::QMeasure, qstate)100""""""101function apply!(x::QMeasure, qstate::Union{StateVector, DensityMatrix})102	x.keep || error(""only keep mode is implemented."")103	probability, istate = _local_measure(storage(qstate), x.position)104	op = I₂105	if x.auto_reset106		m = kron(op[:, istate], QuantumCircuits.Gates.ZERO)/sqrt(probability)107	else108		m = kron(op[:, istate], op[:, istate])/sqrt(probability)109	end110	m = reshape(m, (2, 2))111	apply!(gate(x.position, m), qstate)112	return istate-1, probability113end114 115 116""""""117	measure!(qstate::StateVector, pos::Int; auto_reset::Bool=true)118Measure the i-th qubit of the quantum state, and return a 2-tuple including the measurement outcome, \n 119and the probability with which we get the outcome. The quantum state is updated inplace. \n 120If auto_reset=true,the measured qubit is reset to 0, otherwise it will be the same as the measurement outcome.121""""""122measure!(qstate::Union{StateVector, DensityMatrix}, pos::Int; auto_reset::Bool=true) = apply!(QMeasure(pos, auto_reset=auto_reset), qstate)123 124 125function apply(s::QMeasure, qstater::StateVector)126	qstate = storage(qstater)127	swap!(qstate, 1, s.position)128	probability, istate = _local_measure(qstate, 1)129	# println(""with probability $probability to get $(istate-1)"")130	ss = div(length(qstate), 2)131	r = (transpose(I₂[:, istate])*reshape(qstate, (2, ss)))/sqrt(probability) 132	swap!(qstate, 1, s.position)133	return StateVector(reshape(r, length(r)), nqubits(qstater)-1), istate-1, probability	134end135 136""""""137	measure(qstate::StateVector, i::Int)138Measure the i-th qubit of the quantum state, and return a 3-tuple including the collapsed quantum state, \n 139the measurement outcome, and the probability with which we get the outcome.140""""""141measure(qstate::StateVector, pos::Int) = apply(QMeasure(pos), qstate)142 143function compute_probability_zero(v::AbstractVector, key::Int)144	L = length(v)145	pos = 2^(key-1)146	stri = pos * 2147	r = 0.148	for i in 0:stri:(L-1)149		@inbounds for j in 0:(pos-1)150			l = i + j + 1151			r += abs2(v[l])152		end153	end154	return r155end156 157 158function _local_measure(v::AbstractVector, key::Int)159	p0 = compute_probability_zero(v, key)160	l = [p0, 1-p0]161	i = discrete_sample(l)162	return l[i], i163end164 165# for density matrix166function compute_probability_zero(v::AbstractMatrix, key::Int)167	L = size(v, 1)168	pos = 2^(key-1)169	stri = pos * 2170	r = 0.171	for i in 0:stri:(L-1)172		@inbounds for j in 0:(pos-1)173			l = i + j + 1174			r += real(v[l, l])175		end176	end177	return r178end179 180 181function _local_measure(v::AbstractMatrix, key::Int)182	p0 = compute_probability_zero(v, key)183	l = [p0, 1-p0]184	i = discrete_sample(l)185	return l[i], i186end187","Julia"
188"Conjugate","guochu/VQC.jl","src/postselect.jl",".jl","2515","72","189 190function apply!(x::QSelect, qstate::StateVector)191	x.state == 0 ? apply!(gate(x.position, QuantumCircuits.Gates.UP), qstate) : apply!(gate(x.position, QuantumCircuits.Gates.DOWN), qstate)192	s = norm(qstate)193	qstate.data ./= s194	return s195end196 197function apply(x::QSelect, qstate::StateVector; keep::Bool=false)198	r = _apply_impl(x, qstate, keep=keep)199	ns = cnorm(storage(r))200	return r / ns, real(ns)201end202 203""""""204	post_select!(qstate::StateVector, key::Int, state::Int=0)205Post-select the i-th qubit of the quantum state, and the quantum state is updated inplace, the probability is returned.206""""""207post_select!(qstate::StateVector, key::Int, state::Int=0) = apply!(QSelect(key, state), qstate)208 209""""""210	post_select(qstate::StateVector, key::Int, state::Int=0; keep::Bool=false)211Return the collapsed quantum state as well as the probability.212""""""213post_select(qstate::StateVector, key::Int, state::Int=0; keep::Bool=false) = apply(QSelect(key, state), qstate, keep=keep)214 215 216 217 218 219function _apply_throw_impl(x::QSelect, qstate::StateVector)220	swap!(storage(qstate), 1, x.position)221	ss = div(length(storage(qstate)), 2)222	tmp = reshape(storage(qstate), (2, ss))223	r = x.state==0 ? QuantumCircuits.Gates.ZERO'*tmp : QuantumCircuits.Gates.ONE'*tmp224	swap!(storage(qstate), 1, x.position)225	return StateVector(reshape(r, length(r)), nqubits(qstate)-1)226end227 228function _apply_keep_impl(x::QSelect, qstate::StateVector)229	tmp = copy(qstate)230	x.state == 0 ? apply!(gate(x.position, QuantumCircuits.Gates.UP), tmp) : apply!(gate(x.position, QuantumCircuits.Gates.DOWN), tmp)231	return StateVector(tmp, nqubits(qstate)-1)232end233 234function _apply_impl(x::QSelect, qstate::StateVector; keep::Bool=false)235	return keep ? _apply_keep_impl(x, qstate) : _apply_throw_impl(x, qstate)236end237 238cnorm(x::AbstractVector) = sqrt(dot(x, x))239 240 241 242@adjoint QSelect(key::Int, state::Int) = QSelect(key, state), z -> (nothing, nothing)243 244@adjoint _apply_throw_impl(x::QSelect, qstate::StateVector) = _apply_throw_impl(x, qstate), z -> begin245    if x.state == 0246        m = StateVector(kron(storage(z), ZERO))247    else248    	m = StateVector(kron(storage(z), ONE))249    end250    swap!(storage(m), 1, x.position)251    return (nothing, m)252end253 254@adjoint _apply_keep_impl(x::QSelect, qstate::StateVector) = _apply_keep_impl(x, qstate), z -> (nothing, _apply_keep_impl(x, StateVector(z, nqubits(qstate))) )255 256@adjoint _apply_impl(x::QSelect, qstate::StateVector; keep::Bool) = begin257	return keep ? Zygote.pullback(_apply_keep_impl, x, qstate) : Zygote.pullback(_apply_throw_impl, x, qstate)258end259","Julia"
260"Conjugate","guochu/VQC.jl","src/statevector.jl",".jl","7557","229","struct StateVector{T <: Number} 261    data::Vector{T}262    nqubits::Int263 264function StateVector{T}(data::AbstractVector{<:Number}, nqubits::Int) where {T <: Number}265    @assert length(data) == 2^nqubits266    new{T}(convert(Vector{T}, data), nqubits)267end268 269end270 271StateVector(data::AbstractVector{T}, nqubits::Int) where {T <: Number} = StateVector{T}(data, nqubits)272StateVector{T}(data::AbstractVector{<:Number}) where T = StateVector{T}(data, _nqubits(data))273StateVector(data::AbstractVector{T}) where {T <: Number} = StateVector{T}(data)274function StateVector{T}(nqubits::Int) where {T<:Number} 275    v = zeros(T, 2^nqubits)276    v[1] = 1277    return StateVector{T}(v, nqubits)278end279StateVector(::Type{T}, nqubits::Int) where {T<:Number} = StateVector{T}(nqubits)280StateVector(nqubits::Int) = StateVector(ComplexF64, nqubits)281StateVector(x::StateVector) = StateVector(x.data, nqubits(x))282 283storage(x::StateVector) = x.data284QuantumCircuits.nqubits(x::StateVector) = x.nqubits285 286Base.eltype(::Type{StateVector{T}}) where T = T287Base.eltype(x::StateVector) = eltype(typeof(x))288Base.getindex(x::StateVector, j::Int) = getindex(storage(x), j)289Base.setindex!(x::StateVector, v, j::Int) = setindex!(storage(x), v, j)290 291Base.convert(::Type{StateVector{T}}, x::StateVector) where {T<:Number} = StateVector(convert(Vector{T}, storage(x)), nqubits(x))292Base.copy(x::StateVector) = StateVector(copy(storage(x)), nqubits(x))293 294Base.cat(v::StateVector) = v295function Base.cat(v::StateVector...)296    a, b = _qcat_util(storage.(v)...)297    return StateVector(kron(a, b))298end299 300Base.isapprox(x::StateVector, y::StateVector; kwargs...) = isapprox(storage(x), storage(y); kwargs...)301Base.:(==)(x::StateVector, y::StateVector) = storage(x) == storage(y)302 303 304Base.:+(x::StateVector, y::StateVector) = StateVector(storage(x) + storage(y), nqubits(x))305Base.:-(x::StateVector, y::StateVector) = StateVector(storage(x) - storage(y), nqubits(x))306Base.:*(x::StateVector, y::Number) = StateVector(storage(x) * y, nqubits(x))307Base.:*(x::Number, y::StateVector) = y * x308Base.:/(x::StateVector, y::Number) = StateVector(storage(x) / y, nqubits(x))309Base.:*(m::AbstractMatrix, x::StateVector) = StateVector( m * storage(x), nqubits(x) )310 311 312LinearAlgebra.norm(x::StateVector) = norm(storage(x))313LinearAlgebra.dot(x::StateVector, y::StateVector) = dot(storage(x), storage(y))314LinearAlgebra.dot(x::StateVector, m::AbstractVector, y::StateVector) = dot(storage(x), m, storage(y))315LinearAlgebra.normalize!(x::StateVector) = (normalize!(storage(x)); x)316LinearAlgebra.normalize(x::StateVector) = StateVector(normalize(storage(x)), nqubits(x))317 318""""""319    fidelity(x, y) 320    tr(√x * √y) if x and y are density matrices321    ⟨x|y⟩^2 if x and y are pure states322""""""323fidelity(x::StateVector, y::StateVector) = abs2(dot(x, y))324distance2(x::StateVector, y::StateVector) = _distance2(x, y)325distance(x::StateVector, y::StateVector) = _distance(x, y)326 327 328# encoding329onehot_encoding(::Type{T}, n::Int) where {T <: Number} = StateVector(onehot(T, 2^n, 1), n)330onehot_encoding(n::Int) = onehot_encoding(ComplexF64, n)331onehot_encoding(::Type{T}, i::AbstractVector{Int}) where {T <: Number} = StateVector(onehot(T, 2^(length(i)), _sub2ind(i)+1), length(i))332onehot_encoding(i::AbstractVector{Int})= onehot_encoding(ComplexF64, i)333 334function onehot(::Type{T}, L::Int, pos::Int) where T335    r = zeros(T, L)336    r[pos] = one(T)337    return r338end339 340 341""""""342    kernal_mapping(s::Real) = [cos(s*pi/2), sin(s*pi/2)]343    This maps 0 -> [1, 0] (|0>), and 1 -> [0, 1] (|1>)344""""""345kernal_mapping(s::Real) = [cos(s*pi/2), sin(s*pi/2)]346 347 348""""""349    qstate(::Type{T}, thetas::AbstractVector{<:Real}) where {T <: Number}350Return a product quantum state of [[cos(pi*theta/2), sin(pi*theta/2)]] for theta in thetas]\n351Example: qstate(Complex{Float64}, [0.5, 0.7])352""""""353function qubit_encoding(::Type{T}, i::AbstractVector{<:Real}) where {T <: Number}354    isempty(i) && throw(""empty input."")355    v = [convert(Vector{T}, item) for item in kernal_mapping.(i)]356    (length(v) == 1) && return StateVector{T}(v[1])357    a, b = _qcat_util(v...)358    return StateVector(kron(a, b))359end  360qubit_encoding(mpsstr::AbstractVector{<:Real}) = qubit_encoding(ComplexF64, mpsstr)361 362function amplitude_encoding(::Type{T}, v::AbstractVector{<:Number}; nqubits::Int=ceil(Int, log2(length(v)))) where {T<:Number}363    vn = norm(v)364    (vn ≈ 1.) || println(""input vector is not normalized, it will be renormalized as a quantum state."")365    vv = zeros(T, 2^nqubits)366    for i in 1:length(v)367        vv[i] = v[i] / vn368    end369    return StateVector(vv, nqubits)370end371amplitude_encoding(v::AbstractVector; kwargs...) = amplitude_encoding(ComplexF64, v; kwargs...)372 373function reset!(x::StateVector)374    fill!(storage(x), zero(eltype(x)))375    x[1] = one(eltype(x))376    return x377end378function reset_onehot!(x::StateVector, i::AbstractVector{Int})379    @assert nqubits(x) == length(i)380    pos = _sub2ind(i) + 1381    fill!(storage(x), zero(eltype(x)))382    x[pos] = one(eltype(x))383    return x384end385 386function reset_qubit!(x::StateVector, i::AbstractVector{<:Real})387    @assert nqubits(x) == length(i)388    if length(i) == 1389        copyto!(storage(x), kernal_mapping(i[1]))390        return x391    end392    a, b = _qcat_util(kernal_mapping.(i)...)393    m = length(a)394    n = length(b)395    xs = storage(x)396    for j in 1:m397        n_start = (j-1) * n + 1398        n_end = j * n399        tmp = a[j]400        @. xs[n_start:n_end] = tmp * b401    end402    return x403end404 405function amplitude(s::StateVector, i::AbstractVector{Int}; scaling::Real=sqrt(2))406    @assert length(i)==nqubits(s)407    idx = _sub2ind(i)408    return scaling==1 ? s[idx] : s[idx] * scaling^(nqubits(s))409end410amplitudes(s::StateVector) = storage(s)411 412function rand_state(::Type{T}, n::Int) where {T <: Number}413    (n >= 1) || error(""number of qubits must be positive."")414    v = randn(T, 2^n)415    v ./= norm(v)416    return StateVector(v, n)417end418rand_state(n::Int) = rand_state(ComplexF64, n)419 420function QuantumCircuits.permute(x::StateVector, newindex::Vector{Int})421    n = nqubits(x)422    L = length(storage(x))423    return StateVector(reshape(permute(reshape(storage(x), ntuple(i->2,n)), newindex), L), n)424end425 426 427function _sub2ind(v::AbstractVector{Int})428    @assert _is_valid_indices(v)429    isempty(v) && error(""input index is empty."")430    L = length(v)431    r = v[1]432    for i in 2:L433        r |= v[i] << (i-1)434    end435    return r436end437 438function _qcat_util(vr::Union{AbstractVector, AbstractMatrix}...)439    v = reverse(vr)440    L = length(v)441    # println(""$(typeof(v)), $L"")442    (L >= 2) || error(""something wrong."")443    Lh = div(L, 2)444    a = v[1]445    for i in 2:Lh446        a = kron(a, v[i])447    end448    b = v[Lh + 1]449    for i in Lh+2 : L450        b = kron(b, v[i])451    end452    return a, b453end454 455function _is_valid_indices(i::AbstractVector{Int})456    for s in i457        (s == 0 || s == 1) || return false 458    end   459    return true460end461 462_nqubits(s::AbstractVector) = begin463    n = round(Int, log2(length(s)))464    (2^n == length(s)) || error(""state can not be interpretted as a qubit state."")465    return n466end467 468 469 470# function reset!(x::AbstractVector, i::AbstractVector{<:AbstractFloat})471#     (nqubits(x) == length(i)) || error(""input basis mismatch with number of qubits."")472#     mpsstr = kernal_mapping.(i)473#     for (pos, item) in enumerate(Iterators.product(mpsstr...))474#         x[pos] = prod(item)475#     end476#     return x477# end478 479 480# function qrandn(::Type{T}, n::Int) where {T <: Number}481# 	(n >= 1) || error(""number of qubits must be positive."")482# 	v = randn(T, 2^n)483# 	v ./= norm(v)484# 	return v485# end486 487# qrandn(n::Int) = qrandn(Complex{Float64}, n)488","Julia"
489"Conjugate","guochu/VQC.jl","src/VQC.jl",".jl","1750","86","module VQC490 491 492using Zygote493using Zygote: @adjoint494 495 496using LinearAlgebra, StaticArrays, QuantumCircuits, QuantumCircuits.Gates497using QuantumCircuits: permute498import LinearAlgebra, QuantumCircuits499 500# using KrylovKit: exponentiate501# using SparseArrays: spzeros, sparse, SparseMatrixCSC502# using Logging: @warn503 504 505 506 507# statevector508export StateVector, DensityMatrix, distance, distance2, onehot_encoding, qubit_encoding, amplitude_encoding, reset!, amplitude, amplitudes509export tr, dot, norm, normalize!, normalize, ishermitian510export reset_qubit!, reset_onehot!, storage, fidelity, rand_state, rand_densitymatrix, permute511export schmidt_numbers, renyi_entropy512 513# gate operations514export apply!515 516# measurement517export measure, measure!518 519 520# hamiltonian521export expectation522 523# AD for post selection may be removed in the future524export post_select, post_select!525 526# partial trace527export partial_tr528 529# utility functions530 531 532 533# auxiliary534include(""auxiliary/distance.jl"")535include(""auxiliary/parallel_for.jl"")536include(""auxiliary/sampling.jl"")537include(""auxiliary/tensorops.jl"")538include(""auxiliary/indexop.jl"")539 540# definitions of pure quantum gate541include(""statevector.jl"")542 543# density matrix representation 544include(""densitymatrix.jl"")545 546# quantum gate operations547include(""applygates/applygates.jl"")548 549 550# measurement and postselection551include(""measure.jl"")552include(""postselect.jl"")553 554# hamiltonian expectation555include(""hamiltonian/util.jl"")556include(""hamiltonian/apply_qterms/apply_qterms.jl"")557include(""hamiltonian/expecs/expecs.jl"")558include(""hamiltonian/expecs_dm/expecs_dm.jl"")559 560 561# differentiation562include(""circuitdiff.jl"")563include(""expecdiff.jl"")564include(""additional_adjoints.jl"")565 566# partial trace567include(""ptrace.jl"")568 569# utility functions570include(""utility/utility.jl"")571 572 573end574","Julia"
575"Conjugate","guochu/VQC.jl","src/expecdiff.jl",".jl","2366","71","# gradient of expectation values576 577 578function _qterm_expec_util(m::QubitsTerm, state::StateVector)579	if length(positions(m)) <= LARGEST_SUPPORTED_NTERMS580	    return expectation(m, state), z -> (nothing, (conj(z) * m + z * m') * state ) 581	else582		v = m * state583		return dot(state, v), z -> begin584		   m1 = conj(z) * m585		   m2 = z * m'586		   _apply_qterm_util!(m1, storage(state), storage(v))587		   v2 = storage( m2 * state )588		   v2 .+= storage(v)589		   return (nothing, StateVector(v2, nqubits(state)))590		end591	end592end593 594# this could be slow595# _qterm_expec_util(m::QubitsTerm, state::DensityMatrix) = expectation(m, state), z -> (596# 	nothing,  storage((conj(z) * m + z * m') *  DensityMatrix(one(storage(state)), nqubits(state)))  )597 598_qterm_expec_util(m::QubitsTerm, state::DensityMatrix) = expectation(m, state), z -> (599			nothing,  (z * m') *  DensityMatrix(one(storage(state)), nqubits(state)))  600 601 602@adjoint expectation(m::QubitsTerm, state::Union{StateVector, DensityMatrix}) = _qterm_expec_util(m, state)603 604function _qop_expec_util(m::QubitsOperator, state_in::StateVector)605	if _largest_nterm(m) <= LARGEST_SUPPORTED_NTERMS606		return expectation(m, state_in), z -> (nothing, (conj(z) * m + z * m') * state_in ) 607	else608		state = storage(state_in)609		workspace = similar(state)610		state_2 = zeros(eltype(state), length(state))611		for (k, v) in m.data612		    for item in v613		    	_apply_qterm_util!(QubitsTerm(k, item[1], item[2]), state, workspace)614		    	state_2 .+= workspace615		    end616		end617		r = dot(state, state_2)618		return r, z -> begin619			if ishermitian(m)620			    state_2 .*= (conj(z) + z)621			else622				state_2 .*= conj(z)623				md = m'624				for (k, v) in md.data625					for item in v626						_apply_qterm_util!(QubitsTerm(k, item[1], item[2]), state, workspace)627						@. state_2 += z * workspace628		    		end629		    	end630			end631		    return (nothing, StateVector(state_2, nqubits(state_in)))632		end633	end	634end635# _qop_expec_util(m::QubitsOperator, state::DensityMatrix) = expectation(m, state), z -> (636# 	nothing, storage( (conj(z) * m + z * m') * DensityMatrix(one(storage(state)), nqubits(state)) ) )637 638_qop_expec_util(m::QubitsOperator, state::DensityMatrix) = expectation(m, state), z -> (639	nothing,  (z * m') * DensityMatrix(one(storage(state)), nqubits(state)) ) 640 641 642@adjoint expectation(m::QubitsOperator, state::Union{StateVector, DensityMatrix}) = _qop_expec_util(m, state)643 644 645","Julia"
646"Conjugate","guochu/VQC.jl","src/additional_adjoints.jl",".jl","968","21","647 648@adjoint storage(x::Union{StateVector, DensityMatrix}) = storage(x), z -> (typeof(x)(z),)649@adjoint nqubits(x::Union{StateVector, DensityMatrix}) = nqubits(x), z -> (nothing,)650@adjoint StateVector(data::AbstractVector{<:Number}, n::Int) = StateVector(data, n), z -> (storage(z), nothing)651@adjoint StateVector(data::AbstractVector{<:Number}) = StateVector(data), z -> (storage(z),)652@adjoint DensityMatrix(data::AbstractMatrix{<:Number}, n::Int) = DensityMatrix(data, n), z -> (storage(z), nothing)653@adjoint DensityMatrix(data::AbstractMatrix{<:Number}) = DensityMatrix(data), z -> (storage(z),)654 655# @adjoint dot(x::StateVector, y::StateVector) = begin656# 	v, back = Zygote.pullback(dot, storage(x), storage(y))657# 	return v, z -> begin658# 		a, b = back(z)659# 		return StateVector(a, nqubits(x)), StateVector(b, nqubits(y))660# 	end661# end662 663# # this is stupid, why should I need it664# @adjoint dot(x::StateVector, y::StateVector) = Zygote.pullback(dot, storage(x), storage(y))665 666","Julia"
667"Conjugate","guochu/VQC.jl","src/ptrace.jl",".jl","1669","55","# partial trace668 669 670function partial_tr(state::DensityMatrix, sites::Vector{Int})671	isempty(sites) && return state672	# some checks673	check_partial_tr_inputs(sites, nqubits(state))674	(length(sites) == nqubits(state)) && return tr(state)675	return DensityMatrix(_partial_tr_impl(storage(state), sites, nqubits(state)), nqubits(state) - length(sites) )676end677 678 679function partial_tr(state::StateVector, sites::Vector{Int})680	isempty(sites) && return DensityMatrix(state)681	n = nqubits(state)682	check_partial_tr_inputs(sites, n)683	(length(sites) == n) && return dot(state, state)684 685	axis = move_selected_index_backward(collect(1:n), sites)686	vt = permute(reshape(storage(state), ntuple(i->2, n)), axis)687	vt_shape = size(vt)688	s1 = prod(vt_shape[1:(n-length(sites))])689	s2 = prod(vt_shape[(n-length(sites)+1):end])690	vt = reshape(vt, s1, s2)691	# vt = vt * vt'692	return DensityMatrix(vt * vt', n - length(sites) )693end694 695 696function check_partial_tr_inputs(sites::Vector{Int}, n::Int)697	tmp = Set(sites)698	(length(sites) == length(tmp)) || throw(ArgumentError(""duplicate sites not allowed.""))699	for item in tmp700	    (item>=1 && item<=n) || throw(ArgumentError(""site out of range.""))701	end	702end703 704function _partial_tr_impl(v::AbstractMatrix, sites::Vector{Int}, n::Int)705	axis = move_selected_index_backward(collect(1:n), sites)706	# rdim = reverse(dim)707	vt = reshape(v, ntuple(i->2, 2*n))708	axis2 = axis .+ n709	vt = permute(vt, [axis..., axis2...])710	vt_shape = size(vt)[1:n]711	s1 = prod(vt_shape[1:(n-length(sites))])712	s2 = prod(vt_shape[(n-length(sites)+1):end])713	vt = permute(reshape(vt, s1,s2,s1,s2), (1,3,2,4))714	r = zeros(eltype(vt), s1, s1)715	for i in 1:s2716	    r .+= view(vt, :, :, i, i)717	end718	return r719end720 721","Julia"
722"Conjugate","guochu/VQC.jl","src/circuitdiff.jl",".jl","2837","91","723@adjoint *(circuit::QCircuit, x::Union{StateVector, DensityMatrix}) = begin724    y = circuit * x725    return y, Δ -> begin726        Δ, grads, y = back_propagate(copy(Δ), circuit, copy(y))727        return grads, Δ728    end729end730 731@adjoint qubit_encoding(::Type{T}, mpsstr::Vector{<:Real}) where {T<:Number} = begin732    y = qubit_encoding(T, mpsstr)733    return y, Δ -> begin734        circuit = QCircuit([RyGate(i, theta*pi, isparas=true) for (i, theta) in enumerate(mpsstr)])735        Δ, grads, y = back_propagate(Δ, circuit, copy(y))736        return nothing, grads .* pi737    end738end739 740# @adjoint amplitude_encoding(::Type{T}, v::AbstractVector{<:Number}; kwargs...) where {T <: Number} = amplitude_encoding(741#     T, v; kwargs...), z -> (nothing, z[1:length(v)])742 743 744function back_propagate(Δ::StateVector, m::Gate, y::StateVector)745    Δ = apply!(m', Δ)746    y = apply!(m', y)747    ∇θs = nothing748    if nparameters(m) > 0749        ∇θs = [real(expectation(y, item, Δ)) for item in differentiate(m)]750    end751    return Δ, ∇θs, y752end753 754# a temporary solution, which requires an additional copy of the density matrix755# we can not assume x or y to be positive or hermitian here, since they may not be physical density matrix756function expectation(x::DensityMatrix, m::Gate, y::DensityMatrix)757    yc = copy(y)758    apply_threaded!(m, yc.data)759    return dot(storage(x)', storage(yc))760end 761 762function back_propagate(Δ::DensityMatrix, m::Gate, y::DensityMatrix)763    Δ = apply!(m', Δ)764    y = apply!(m', y)765    ∇θs = nothing766    if nparameters(m) > 0767        ∇θs = [real(expectation(y, item, Δ) + expectation(Δ, item', y)) for item in differentiate(m)]768    end769    return Δ, ∇θs, y770end771 772function back_propagate(Δ::DensityMatrix, m::QuantumMap, y::DensityMatrix)773    Δ = apply_dagger!(m, Δ)774    y = apply_inverse!(m, y)775    ∇θs = nothing776    return Δ, ∇θs, y777end778 779function back_propagate_util(Δ, circuit::QCircuit, y)780    RT = real(eltype(y))781    grads = Vector{RT}[]782    for item in reverse(circuit)783        Δ, ∇θs, y = back_propagate(Δ, item, y)784        !isnothing(∇θs) && push!(grads, ∇θs)785    end786 787    ∇θs_all = RT[]788    for item in Iterators.reverse(grads)789        append!(∇θs_all, item)790    end791 792    return Δ, ∇θs_all, y793end794 795back_propagate(Δ::StateVector, circuit::QCircuit, y::StateVector) = back_propagate_util(Δ, circuit, y)796back_propagate(Δ::DensityMatrix, circuit::QCircuit, y::DensityMatrix) = back_propagate_util(Δ, circuit, y)797 798 799 800 801# function back_propagate(Δ::AbstractMatrix, m::Gate, y::DensityMatrix)802#     Δ = StateVector(Δ, nqubits(y))803#     Δ = apply!(m', Δ)804#     y = apply!(m', y)805#     ∇θs = nothing806#     if nparameters(m) > 0807#         ∇θs = [real(expectation(y, item, Δ)) for item in differentiate(m)]808#     end809#     return storage(Δ), ∇θs, y810# end811 812","Julia"
813"Conjugate","guochu/VQC.jl","src/utility/groundstate.jl",".jl","1071","25","using KrylovKit: eigsolve, exponentiate814 815 816function ground_state(h::QubitsOperator; kwargs...)817	ishermitian(h) || throw(ArgumentError(""input operator is not hermitian.""))818	n = QuantumCircuits.get_largest_pos(h)819	T = eltype(h)820	init_state = rand_state(T, n)821 822	eigvalues, eigvectors, info = eigsolve(x -> storage(h(StateVector(x, n))), storage(init_state), 1, :SR; ishermitian=true, kwargs...)823	(info.converged>=1) || error(""eigsolve fails to converge."")824	return eigvalues[1], StateVector(eigvectors[1], n)825end826 827 828function time_evolution(h::QubitsOperator, t::Number, v::StateVector; kwargs...)829	ishermitian(h) || throw(ArgumentError(""input operator is not hermitian.""))830	(QuantumCircuits.get_largest_pos(h) <= nqubits(v)) || throw(ArgumentError(""number of qubits mismatch.""))831	n = nqubits(v)832	T = promote_type(eltype(h), typeof(t), eltype(v) )833	v = convert(StateVector{T}, v)834	tmp, info = exponentiate(x -> storage(h(StateVector(x, n))), t, storage(v); ishermitian=true, kwargs...)835	(info.converged>=1) || error(""eigsolve fails to converge."")836	return StateVector(tmp, n)837end","Julia"
838"Conjugate","guochu/VQC.jl","src/utility/variationalcircuit.jl",".jl","4239","149","""""""839	variational_circuit_1d(L::Int, depth::Int; θs::Vector{<:Real})840Return a variational quantum circuit given L qubis and d depth841""""""842function variational_circuit_1d(L::Int, depth::Int; θs::Vector{<:Real}=rand(_nparas(ComplexF64, L, depth)) .* 2π)843	paras = θs844	(length(paras) == _nparas(ComplexF64, L, depth)) || throw(""wrong number of parameters."")845	circuit = QCircuit()846	ncount = 1847	for i in 1:L848		push!(circuit, RzGate(i, paras[ncount], isparas=true))849		ncount += 1850		push!(circuit, RyGate(i, paras[ncount], isparas=true))851		ncount += 1852		push!(circuit, RzGate(i, paras[ncount], isparas=true))853		ncount += 1854	end		855	for i in 1:depth856		if isodd(i)857			for j in 1:(L-1)858		    	push!(circuit, CNOTGate(j, j+1))859			end860		else861			for j in (L-1):-1:1862		    	push!(circuit, CNOTGate(j, j+1))863			end			864		end865		for j in 1:L866			push!(circuit, RzGate(j, paras[ncount], isparas=true))867			ncount += 1868			push!(circuit, RyGate(j, paras[ncount], isparas=true))869			ncount += 1870			push!(circuit, RzGate(j, paras[ncount], isparas=true))871			ncount += 1872		end873	end874	@assert ncount == length(paras)+1875	return circuit	876end877 878function real_variational_circuit_1d(L::Int, depth::Int; θs::Vector{<:Real}=rand(_nparas(Float64, L, depth)) .* 2π)879	paras = θs880	(length(paras) == _nparas(Float64, L, depth)) || throw(""wrong number of parameters."")881	circuit = QCircuit()882	ncount = 1883	for i in 1:L884		push!(circuit, RyGate(i, paras[ncount], isparas=true))885		ncount += 1886	end		887	for i in 1:depth888		if isodd(i)889			for j in 1:(L-1)890		    	push!(circuit, CNOTGate(j, j+1))891			end892		else893			for j in (L-1):-1:1894		    	push!(circuit, CNOTGate(j, j+1))895			end			896		end897		for j in 1:L898			push!(circuit, RyGate(j, paras[ncount], isparas=true))899			ncount += 1900		end901	end902	@assert ncount == length(paras)+1903	return circuit	904end905 906 907# function variational_circuit_2d(m::Int, n::Int, depth::Int; θs::Vector{<:Real}=rand(_nparas(ComplexF64, m*n, depth)) .* 2π)908# 	paras = θs909# 	L = m*n910# 	(length(paras) == _nparas(ComplexF64, L, depth)) || throw(""wrong number of parameters."")911# 	circuit = QCircuit()912# 	ncount = 1913# 	for i in 1:L914# 		push!(circuit, RzGate(i, paras[ncount], isparas=true))915# 		ncount += 1916# 		push!(circuit, RyGate(i, paras[ncount], isparas=true))917# 		ncount += 1918# 		push!(circuit, RzGate(i, paras[ncount], isparas=true))919# 		ncount += 1920# 	end	921 922# 	index = LinearIndices((m, n))923# 	for l in 1:depth924# 		for i in 1:m925# 		    for j in 1:(n-1)926# 		        push!(circuit, CNOTGate(index[i, j], index[i, j+1]))927# 		    end928# 		end929# 		for i in 1:(m-1)930# 		    for j in 1:n931# 		        push!(circuit, CNOTGate(index[i, j], index[i+1, j]))932# 		    end933# 		end934# 		for i in 1:L935# 			push!(circuit, RzGate(i, paras[ncount], isparas=true))936# 			ncount += 1937# 			push!(circuit, RyGate(i, paras[ncount], isparas=true))938# 			ncount += 1939# 			push!(circuit, RzGate(i, paras[ncount], isparas=true))940# 			ncount += 1941# 		end	942# 	end943# 	@assert ncount == length(paras)+1944# 	return circuit945# end946# variational_circuit_2d(shapes::Tuple{Int, Int}, args...; kwargs...) = variational_circuit_2d(shapes[1], shapes[2], args...; kwargs...)947 948# function real_variational_circuit_2d(m::Int, n::Int, depth::Int; θs::Vector{<:Real}=rand(_nparas(Float64, m*n, depth)) .* 2π)949# 	paras = θs950# 	L = m*n951# 	(length(paras) == _nparas(Float64, L, depth)) || throw(""wrong number of parameters."")952# 	circuit = QCircuit()953# 	ncount = 1954# 	for i in 1:L955# 		push!(circuit, RyGate(i, paras[ncount], isparas=true))956# 		ncount += 1957# 	end			958 959# 	index = LinearIndices((m, n))960# 	for l in 1:depth961# 		for i in 1:m962# 		    for j in 1:(n-1)963# 		        push!(circuit, CNOTGate(index[i, j], index[i, j+1]))964# 		    end965# 		end966# 		for i in 1:(m-1)967# 		    for j in 1:n968# 		        push!(circuit, CNOTGate(index[i, j], index[i+1, j]))969# 		    end970# 		end971# 		for i in 1:L972# 			push!(circuit, RyGate(i, paras[ncount], isparas=true))973# 			ncount += 1974# 		end	975# 	end976# 	@assert ncount == length(paras)+1977# 	return circuit978# end979# real_variational_circuit_2d(shapes::Tuple{Int, Int}, args...; kwargs...) = real_variational_circuit_2d(shapes[1], shapes[2], args...; kwargs...)980 981function _nparas(::Type{T}, L::Int, depth::Int) where {T <: Number} 982	n = depth+1983	return (T <: Real) ? n * L : n * L * 3984end 985 986","Julia"
987"Conjugate","guochu/VQC.jl","src/utility/qft.jl",".jl","427","25","export QFT988 989function _nnqft_one_block(L::Int)990	(L<=0) && error(""input size can not be 0"")991	r = QCircuit()992	if L==1993		push!(r, (1, H))994		return r995	else996		append!(r, _nnqft_one_block(L-1))997		push!(r, (((L,L-1), CONTROL(R(L)) * SWAP)))998		return r999	end1000end1001 1002""""""1003	efficient QFT which only contains nearest neighbour gates.1004""""""1005function QFT(L::Int)1006	r = QCircuit()1007	for i = L:-1:11008		append!(r, _nnqft_one_block(i))1009	end1010	return r1011end","Julia"
1012"Conjugate","guochu/VQC.jl","src/utility/utility.jl",".jl","391","19","module Utilities1013 1014using VQC1015using QuantumCircuits, QuantumCircuits.Gates1016 1017export heisenberg_1d, heisenberg_2d, ising_1d, ising_2d, ground_state, time_evolution1018export QFT1019export variational_circuit_1d, real_variational_circuit_1d1020export order_finding1021 1022include(""spin_hamiltonians.jl"")1023include(""groundstate.jl"")1024 1025include(""qft.jl"")1026include(""variationalcircuit.jl"")1027include(""shor/shor.jl"")1028 1029 1030end","Julia"
1031"Conjugate","guochu/VQC.jl","src/utility/spin_hamiltonians.jl",".jl","2615","86","1032 1033 1034""""""1035    heisenberg xxz chain1036""""""1037function heisenberg_chain(L::Int; J::Real=1., Jzz::Real=J, hz::Real=0.)1038    sp, sm, z = QuantumCircuits._get_op.([""+"", ""-"", ""Z""])1039    terms = []1040    # one site terms1041    for i in 1:L1042        push!(terms, QubitsTerm(i=>z, coeff=hz))1043    end1044    # nearest-neighbour interactions1045    for i in 1:L-11046        t = QubitsTerm(i=>sp, i+1=>sm, coeff=2*J)1047        push!(terms, t)1048        push!(terms, t')1049        push!(terms, QubitsTerm(i=>z, i+1=>z, coeff=Jzz))1050    end1051    return simplify(QubitsOperator(terms...))1052end1053heisenberg_1d(L::Int; kwargs...) = heisenberg_chain(L; kwargs...)1054 1055function heisenberg_2d(m::Int, n::Int=m; J::Real=1., Jzz::Real=J, hz::Real=0.)1056    sp, sm, z = QuantumCircuits._get_op.([""+"", ""-"", ""Z""])1057    terms = []1058    for i in 1:m*n1059        push!(terms, QubitsTerm(i=>z, coeff=hz))1060    end1061    index = LinearIndices((m, n))1062    for i in 1:m1063        for j in 1:(n-1)1064            t = QubitsTerm(index[i, j]=>sp, index[i, j+1]=>sm, coeff=2*J)1065            push!(terms, t)1066            push!(terms, t')1067            push!(terms, QubitsTerm(index[i, j]=>z, index[i, j+1]=>z, coeff=Jzz) )1068        end1069    end1070    for i in 1:(m-1) 1071        for j in 1:n1072            t = QubitsTerm(index[i, j]=>sp, index[i+1, j]=>sm, coeff=2*J)1073            push!(terms, t)1074            push!(terms, t')1075            push!(terms, QubitsTerm(index[i, j]=>z, index[i+1, j]=>z, coeff=Jzz) )1076        end1077    end1078    return simplify(QubitsOperator(terms...))1079end1080heisenberg_2d(shapes::Tuple{Int, Int}; kwargs...) = heisenberg_2d(shapes[1], shapes[2]; kwargs...)1081 1082 1083function ising_chain(L::Int; J::Real=1., hz::Real=1.)1084    x, z = QuantumCircuits._get_op.([""X"", ""Z""])1085    terms = []1086    for i in 1:L1087    	push!(terms, QubitsTerm(i=>z, coeff=hz))1088    end1089    for i in 1:L-11090    	push!(terms, QubitsTerm(i=>x, i+1=>x, coeff=J))1091    end1092    return simplify(QubitsOperator(terms...))1093end1094ising_1d(L::Int; kwargs...) = ising_chain(L; kwargs...)1095 1096function ising_2d(m::Int, n::Int=m; J::Real=1., hz::Real=1.)1097    x, z = QuantumCircuits._get_op.([""X"", ""Z""])1098    terms = []1099    for i in 1:m*n1100        push!(terms, QubitsTerm(i=>z, coeff=hz))1101    end1102    index = LinearIndices((m, n))1103    for i in 1:m1104        for j in 1:(n-1)1105            push!(terms, QubitsTerm(index[i, j]=>x, index[i, j+1]=>x, coeff=J) )1106        end1107    end1108    for i in 1:(m-1) 1109        for j in 1:n1110            push!(terms, QubitsTerm(index[i, j]=>x, index[i+1, j]=>x, coeff=J) )1111        end1112    end1113    return simplify(QubitsOperator(terms...))1114end1115ising_2d(shapes::Tuple{Int, Int}; kwargs...) = ising_2d(shapes[1], shapes[2]; kwargs...)1116","Julia"
1117"Conjugate","guochu/VQC.jl","src/utility/shor/shor.jl",".jl","125","8","1118include(""util.jl"")1119include(""Beauregard.jl"")1120include(""Fowler.jl"")1121 1122include(""orderfinding_sqc.jl"")1123include(""orderfinding.jl"")1124","Julia"
1125"Conjugate","guochu/VQC.jl","src/utility/shor/Fowler.jl",".jl","6596","284","1126# using 2n+4 qubits1127 1128const PLUS = [0.5+0.5*im 0.5-0.5*im; 0.5-0.5*im 0.5+0.5*im]1129const MINUS = [0.5-0.5*im 0.5+0.5*im; 0.5+0.5*im 0.5-0.5*im]1130const CONTROL_PLUS = CONTROL(PLUS)1131const CONTROL_MINUS = CONTROL(MINUS)1132 1133""""""1134    n = length(a)1135    n qubits1136    @ input output1137    b[0]1138    b[1]1139    ...1140    b[n-1]1141""""""1142LNNAdderCircuit(a::BinaryInteger) = QCircuit([PHASEGate(i, compute_phase(a, i)) for i in 0:(length(a)-1)])1143 1144""""""1145    n = len(a)1146    n+1 qubits1147    @input1148    c control qubit1149    b[0]1150    b[1]1151    ...1152    b[n-1]1153    @output1154    b[0]1155    b[1]1156    ...1157    b[n-1]1158    c control qubit1159""""""1160LNNCAdderCircuit(a::BinaryInteger; inverse::Bool=false) = inverse ? QCircuit(1161[gate((i+1, i), SWAP * CONTROL(PHASE(compute_phase(a, i)))) for i in (length(a)-1):-1:0]) : QCircuit(1162[gate((i, i+1), SWAP * CONTROL(PHASE(compute_phase(a, i)))) for i in 0:(length(a)-1)])1163 1164""""""1165    this circuit contains n+6 qubits, where n+1 = len(a) = len(N)1166    x11167    MS addition (most significant) qubit in |0> out |0>1168    x21169    ki qubit in |0> out |0>1170    kx qubit1171    b[0]1172    b[1]1173    b[2]1174    ...1175    b[n]1176""""""1177function LNNModAdderCircuit(N::BinaryInteger, a::BinaryInteger)1178    (length(N)==length(a)) || error(""binary integer a and N size mismatch."")1179	L = length(a)1180	n = L-11181	total_circuit = QCircuit()1182    push!(total_circuit, gate((3,4), CONTROL_PLUS))1183    push!(total_circuit, gate((2,3), CNOT))1184    push!(total_circuit, gate((3,4), CONTROL_MINUS))1185	push!(total_circuit, gate((2,3), SWAP*CNOT))1186	push!(total_circuit, gate((3,4), CONTROL_PLUS))1187	append!(total_circuit, shift(LNNCAdderCircuit(a, inverse=false), 4))1188	append!(total_circuit, shift(LNNAdderCircuit(N), 4)')1189	append!(total_circuit, shift(_QFT(L)', 4) )1190	push!(total_circuit, gate((1,2), SWAP))1191	push!(total_circuit, gate((2,3), SWAP))1192	push!(total_circuit, gate((4,3), SWAP * CNOT))1193	append!(total_circuit, move_site(4, n+4))1194	append!(total_circuit, shift(_QFT(L), 3))1195	append!(total_circuit, shift(LNNCAdderCircuit(N, inverse=true), 3) )1196	append!(total_circuit, shift(LNNCAdderCircuit(a, inverse=false)', 4) )1197    append!(total_circuit, shift(_QFT(L)', 5) )1198	append!(total_circuit, move_site(4, n+5))1199	push!(total_circuit, gate(4, X))1200	push!(total_circuit, gate((4,3), CNOT))

Showing the first 1,200 of 10045 lines. Download the file for the rest.