diff --git "a/data/dataset_Conjugate.csv" "b/data/dataset_Conjugate.csv" new file mode 100644--- /dev/null +++ "b/data/dataset_Conjugate.csv" @@ -0,0 +1,10044 @@ +"keyword","repo_name","file_path","file_extension","file_size","line_count","content","language" +"Conjugate","guochu/VQC.jl","src/densitymatrix.jl",".jl","4224","96","struct DensityMatrix{T <: Number} + data::Vector{T} + nqubits::Int + +function DensityMatrix{T}(data::AbstractVector{<:Number}, nqubits::Int) where {T <: Number} + (length(data) == 2^(2*nqubits)) || throw(DimensionMismatch()) + new{T}(convert(Vector{T}, data), nqubits) +end + +end + +function DensityMatrix{T}(m::AbstractMatrix{<:Number}, nqubits::Int) where {T <: Number} + (size(m, 1) == size(m, 2) == 2^nqubits) || throw(DimensionMismatch()) + return DensityMatrix{T}(reshape(m, length(m)), nqubits) +end +function DensityMatrix{T}(m::AbstractVector{<:Number}) where {T <: Number} + n = _nqubits(m) + return DensityMatrix{T}(m, div(n, 2)) +end +DensityMatrix{T}(m::AbstractMatrix{<:Number}) where {T <: Number} = DensityMatrix{T}(reshape(m, length(m))) + +DensityMatrix(data::Union{AbstractVector, AbstractMatrix}, nqubits::Int) = DensityMatrix{eltype(data)}(data, nqubits) +DensityMatrix(data::AbstractVector) = DensityMatrix(data, div(_nqubits(data), 2)) +DensityMatrix(data::AbstractMatrix) = DensityMatrix(reshape(data, length(data))) +function DensityMatrix{T}(nqubits::Int) where {T<:Number} + v = zeros(T, 2^(2*nqubits)) + v[1,1] = 1 + return DensityMatrix{T}(v, nqubits) +end +DensityMatrix(::Type{T}, nqubits::Int) where {T<:Number} = DensityMatrix{T}(nqubits) +DensityMatrix(nqubits::Int) = DensityMatrix(ComplexF64, nqubits) +DensityMatrix(x::DensityMatrix) = DensityMatrix(x.data, nqubits(x)) +DensityMatrix(x::StateVector) = (x_data = storage(x); DensityMatrix(kron(conj(x_data), x_data), nqubits(x))) + + +storage(x::DensityMatrix) = (L = 2^(nqubits(x)); reshape(x.data, L, L)) +QuantumCircuits.nqubits(x::DensityMatrix) = x.nqubits + +Base.eltype(::Type{DensityMatrix{T}}) where T = T +Base.eltype(x::DensityMatrix) = eltype(typeof(x)) +Base.getindex(x::DensityMatrix, j::Int...) = getindex(storage(x), j...) +Base.setindex!(x::StateVector, v, j::Int...) = setindex!(storage(x), v, j...) + +Base.convert(::Type{DensityMatrix{T}}, x::DensityMatrix) where {T<:Number} = DensityMatrix(convert(Vector{T}, x.data), nqubits(x)) +Base.copy(x::DensityMatrix) = DensityMatrix(copy(x.data), nqubits(x)) + + +Base.cat(v::DensityMatrix) = v +function Base.cat(v::DensityMatrix...) + a, b = _qcat_util(storage.(v)...) + return DensityMatrix(kron(a, b)) +end + +Base.isapprox(x::DensityMatrix, y::DensityMatrix; kwargs...) = isapprox(x.data, y.data; kwargs...) +Base.:(==)(x::DensityMatrix, y::DensityMatrix) = x.data == y.data + +Base.:+(x::DensityMatrix, y::DensityMatrix) = DensityMatrix(x.data + y.data, nqubits(x)) +Base.:-(x::DensityMatrix, y::DensityMatrix) = DensityMatrix(x.data - y.data, nqubits(x)) +Base.:*(x::DensityMatrix, y::Number) = DensityMatrix(x.data * y, nqubits(x)) +Base.:*(x::Number, y::DensityMatrix) = y * x +Base.:/(x::DensityMatrix, y::Number) = DensityMatrix(x.data / y, nqubits(x)) + + +LinearAlgebra.tr(x::DensityMatrix) = tr(storage(x)) +LinearAlgebra.dot(x::DensityMatrix, y::DensityMatrix) = dot(storage(x), storage(y)) +LinearAlgebra.normalize!(x::DensityMatrix) = (x.data ./= tr(x); x) +LinearAlgebra.normalize(x::DensityMatrix) = normalize!(copy(x)) +LinearAlgebra.ishermitian(x::DensityMatrix) = ishermitian(storage(x)) +LinearAlgebra.isposdef(x::DensityMatrix) = isposdef(storage(x)) + +fidelity(x::DensityMatrix, y::DensityMatrix) = real(tr(sqrt(storage(x)) * sqrt(storage(y)))) +fidelity(x::DensityMatrix, y::StateVector) = real(dot(storage(y), storage(x), storage(y))) +fidelity(x::StateVector, y::DensityMatrix) = fidelity(y, x) +distance2(x::DensityMatrix, y::DensityMatrix) = _distance2(x, y) +distance(x::DensityMatrix, y::DensityMatrix) = _distance(x, y) +schmidt_numbers(x::DensityMatrix) = eigvals(Hermitian(storage(x))) +renyi_entropy(x::DensityMatrix; kwargs...) = renyi_entropy(schmidt_numbers(x); kwargs...) + +function rand_densitymatrix(::Type{T}, n::Int) where {T <: Number} + (n >= 1) || error(""number of qubits must be positive."") + L = 2^n + v = randn(T, L, L) + v = v' * v + return normalize!(DensityMatrix(v' * v, n)) +end +rand_densitymatrix(n::Int) = rand_densitymatrix(ComplexF64, n) + +function QuantumCircuits.permute(x::DensityMatrix, newindex::Vector{Int}) + n = nqubits(x) + L = length(x.data) + return DensityMatrix(reshape(permute(reshape(x.data, ntuple(i->2, 2*n)), vcat(newindex, newindex .+ n)), L), n) +end + + + +","Julia" +"Conjugate","guochu/VQC.jl","src/measure.jl",".jl","2569","90",""""""" + apply!(x::QMeasure, qstate) +"""""" +function apply!(x::QMeasure, qstate::Union{StateVector, DensityMatrix}) + x.keep || error(""only keep mode is implemented."") + probability, istate = _local_measure(storage(qstate), x.position) + op = I₂ + if x.auto_reset + m = kron(op[:, istate], QuantumCircuits.Gates.ZERO)/sqrt(probability) + else + m = kron(op[:, istate], op[:, istate])/sqrt(probability) + end + m = reshape(m, (2, 2)) + apply!(gate(x.position, m), qstate) + return istate-1, probability +end + + +"""""" + measure!(qstate::StateVector, pos::Int; auto_reset::Bool=true) +Measure the i-th qubit of the quantum state, and return a 2-tuple including the measurement outcome, \n +and the probability with which we get the outcome. The quantum state is updated inplace. \n +If auto_reset=true,the measured qubit is reset to 0, otherwise it will be the same as the measurement outcome. +"""""" +measure!(qstate::Union{StateVector, DensityMatrix}, pos::Int; auto_reset::Bool=true) = apply!(QMeasure(pos, auto_reset=auto_reset), qstate) + + +function apply(s::QMeasure, qstater::StateVector) + qstate = storage(qstater) + swap!(qstate, 1, s.position) + probability, istate = _local_measure(qstate, 1) + # println(""with probability $probability to get $(istate-1)"") + ss = div(length(qstate), 2) + r = (transpose(I₂[:, istate])*reshape(qstate, (2, ss)))/sqrt(probability) + swap!(qstate, 1, s.position) + return StateVector(reshape(r, length(r)), nqubits(qstater)-1), istate-1, probability +end + +"""""" + measure(qstate::StateVector, i::Int) +Measure the i-th qubit of the quantum state, and return a 3-tuple including the collapsed quantum state, \n +the measurement outcome, and the probability with which we get the outcome. +"""""" +measure(qstate::StateVector, pos::Int) = apply(QMeasure(pos), qstate) + +function compute_probability_zero(v::AbstractVector, key::Int) + L = length(v) + pos = 2^(key-1) + stri = pos * 2 + r = 0. + for i in 0:stri:(L-1) + @inbounds for j in 0:(pos-1) + l = i + j + 1 + r += abs2(v[l]) + end + end + return r +end + + +function _local_measure(v::AbstractVector, key::Int) + p0 = compute_probability_zero(v, key) + l = [p0, 1-p0] + i = discrete_sample(l) + return l[i], i +end + +# for density matrix +function compute_probability_zero(v::AbstractMatrix, key::Int) + L = size(v, 1) + pos = 2^(key-1) + stri = pos * 2 + r = 0. + for i in 0:stri:(L-1) + @inbounds for j in 0:(pos-1) + l = i + j + 1 + r += real(v[l, l]) + end + end + return r +end + + +function _local_measure(v::AbstractMatrix, key::Int) + p0 = compute_probability_zero(v, key) + l = [p0, 1-p0] + i = discrete_sample(l) + return l[i], i +end +","Julia" +"Conjugate","guochu/VQC.jl","src/postselect.jl",".jl","2515","72"," + +function apply!(x::QSelect, qstate::StateVector) + x.state == 0 ? apply!(gate(x.position, QuantumCircuits.Gates.UP), qstate) : apply!(gate(x.position, QuantumCircuits.Gates.DOWN), qstate) + s = norm(qstate) + qstate.data ./= s + return s +end + +function apply(x::QSelect, qstate::StateVector; keep::Bool=false) + r = _apply_impl(x, qstate, keep=keep) + ns = cnorm(storage(r)) + return r / ns, real(ns) +end + +"""""" + post_select!(qstate::StateVector, key::Int, state::Int=0) +Post-select the i-th qubit of the quantum state, and the quantum state is updated inplace, the probability is returned. +"""""" +post_select!(qstate::StateVector, key::Int, state::Int=0) = apply!(QSelect(key, state), qstate) + +"""""" + post_select(qstate::StateVector, key::Int, state::Int=0; keep::Bool=false) +Return the collapsed quantum state as well as the probability. +"""""" +post_select(qstate::StateVector, key::Int, state::Int=0; keep::Bool=false) = apply(QSelect(key, state), qstate, keep=keep) + + + + + +function _apply_throw_impl(x::QSelect, qstate::StateVector) + swap!(storage(qstate), 1, x.position) + ss = div(length(storage(qstate)), 2) + tmp = reshape(storage(qstate), (2, ss)) + r = x.state==0 ? QuantumCircuits.Gates.ZERO'*tmp : QuantumCircuits.Gates.ONE'*tmp + swap!(storage(qstate), 1, x.position) + return StateVector(reshape(r, length(r)), nqubits(qstate)-1) +end + +function _apply_keep_impl(x::QSelect, qstate::StateVector) + tmp = copy(qstate) + x.state == 0 ? apply!(gate(x.position, QuantumCircuits.Gates.UP), tmp) : apply!(gate(x.position, QuantumCircuits.Gates.DOWN), tmp) + return StateVector(tmp, nqubits(qstate)-1) +end + +function _apply_impl(x::QSelect, qstate::StateVector; keep::Bool=false) + return keep ? _apply_keep_impl(x, qstate) : _apply_throw_impl(x, qstate) +end + +cnorm(x::AbstractVector) = sqrt(dot(x, x)) + + + +@adjoint QSelect(key::Int, state::Int) = QSelect(key, state), z -> (nothing, nothing) + +@adjoint _apply_throw_impl(x::QSelect, qstate::StateVector) = _apply_throw_impl(x, qstate), z -> begin + if x.state == 0 + m = StateVector(kron(storage(z), ZERO)) + else + m = StateVector(kron(storage(z), ONE)) + end + swap!(storage(m), 1, x.position) + return (nothing, m) +end + +@adjoint _apply_keep_impl(x::QSelect, qstate::StateVector) = _apply_keep_impl(x, qstate), z -> (nothing, _apply_keep_impl(x, StateVector(z, nqubits(qstate))) ) + +@adjoint _apply_impl(x::QSelect, qstate::StateVector; keep::Bool) = begin + return keep ? Zygote.pullback(_apply_keep_impl, x, qstate) : Zygote.pullback(_apply_throw_impl, x, qstate) +end +","Julia" +"Conjugate","guochu/VQC.jl","src/statevector.jl",".jl","7557","229","struct StateVector{T <: Number} + data::Vector{T} + nqubits::Int + +function StateVector{T}(data::AbstractVector{<:Number}, nqubits::Int) where {T <: Number} + @assert length(data) == 2^nqubits + new{T}(convert(Vector{T}, data), nqubits) +end + +end + +StateVector(data::AbstractVector{T}, nqubits::Int) where {T <: Number} = StateVector{T}(data, nqubits) +StateVector{T}(data::AbstractVector{<:Number}) where T = StateVector{T}(data, _nqubits(data)) +StateVector(data::AbstractVector{T}) where {T <: Number} = StateVector{T}(data) +function StateVector{T}(nqubits::Int) where {T<:Number} + v = zeros(T, 2^nqubits) + v[1] = 1 + return StateVector{T}(v, nqubits) +end +StateVector(::Type{T}, nqubits::Int) where {T<:Number} = StateVector{T}(nqubits) +StateVector(nqubits::Int) = StateVector(ComplexF64, nqubits) +StateVector(x::StateVector) = StateVector(x.data, nqubits(x)) + +storage(x::StateVector) = x.data +QuantumCircuits.nqubits(x::StateVector) = x.nqubits + +Base.eltype(::Type{StateVector{T}}) where T = T +Base.eltype(x::StateVector) = eltype(typeof(x)) +Base.getindex(x::StateVector, j::Int) = getindex(storage(x), j) +Base.setindex!(x::StateVector, v, j::Int) = setindex!(storage(x), v, j) + +Base.convert(::Type{StateVector{T}}, x::StateVector) where {T<:Number} = StateVector(convert(Vector{T}, storage(x)), nqubits(x)) +Base.copy(x::StateVector) = StateVector(copy(storage(x)), nqubits(x)) + +Base.cat(v::StateVector) = v +function Base.cat(v::StateVector...) + a, b = _qcat_util(storage.(v)...) + return StateVector(kron(a, b)) +end + +Base.isapprox(x::StateVector, y::StateVector; kwargs...) = isapprox(storage(x), storage(y); kwargs...) +Base.:(==)(x::StateVector, y::StateVector) = storage(x) == storage(y) + + +Base.:+(x::StateVector, y::StateVector) = StateVector(storage(x) + storage(y), nqubits(x)) +Base.:-(x::StateVector, y::StateVector) = StateVector(storage(x) - storage(y), nqubits(x)) +Base.:*(x::StateVector, y::Number) = StateVector(storage(x) * y, nqubits(x)) +Base.:*(x::Number, y::StateVector) = y * x +Base.:/(x::StateVector, y::Number) = StateVector(storage(x) / y, nqubits(x)) +Base.:*(m::AbstractMatrix, x::StateVector) = StateVector( m * storage(x), nqubits(x) ) + + +LinearAlgebra.norm(x::StateVector) = norm(storage(x)) +LinearAlgebra.dot(x::StateVector, y::StateVector) = dot(storage(x), storage(y)) +LinearAlgebra.dot(x::StateVector, m::AbstractVector, y::StateVector) = dot(storage(x), m, storage(y)) +LinearAlgebra.normalize!(x::StateVector) = (normalize!(storage(x)); x) +LinearAlgebra.normalize(x::StateVector) = StateVector(normalize(storage(x)), nqubits(x)) + +"""""" + fidelity(x, y) + tr(√x * √y) if x and y are density matrices + ⟨x|y⟩^2 if x and y are pure states +"""""" +fidelity(x::StateVector, y::StateVector) = abs2(dot(x, y)) +distance2(x::StateVector, y::StateVector) = _distance2(x, y) +distance(x::StateVector, y::StateVector) = _distance(x, y) + + +# encoding +onehot_encoding(::Type{T}, n::Int) where {T <: Number} = StateVector(onehot(T, 2^n, 1), n) +onehot_encoding(n::Int) = onehot_encoding(ComplexF64, n) +onehot_encoding(::Type{T}, i::AbstractVector{Int}) where {T <: Number} = StateVector(onehot(T, 2^(length(i)), _sub2ind(i)+1), length(i)) +onehot_encoding(i::AbstractVector{Int})= onehot_encoding(ComplexF64, i) + +function onehot(::Type{T}, L::Int, pos::Int) where T + r = zeros(T, L) + r[pos] = one(T) + return r +end + + +"""""" + kernal_mapping(s::Real) = [cos(s*pi/2), sin(s*pi/2)] + This maps 0 -> [1, 0] (|0>), and 1 -> [0, 1] (|1>) +"""""" +kernal_mapping(s::Real) = [cos(s*pi/2), sin(s*pi/2)] + + +"""""" + qstate(::Type{T}, thetas::AbstractVector{<:Real}) where {T <: Number} +Return a product quantum state of [[cos(pi*theta/2), sin(pi*theta/2)]] for theta in thetas]\n +Example: qstate(Complex{Float64}, [0.5, 0.7]) +"""""" +function qubit_encoding(::Type{T}, i::AbstractVector{<:Real}) where {T <: Number} + isempty(i) && throw(""empty input."") + v = [convert(Vector{T}, item) for item in kernal_mapping.(i)] + (length(v) == 1) && return StateVector{T}(v[1]) + a, b = _qcat_util(v...) + return StateVector(kron(a, b)) +end +qubit_encoding(mpsstr::AbstractVector{<:Real}) = qubit_encoding(ComplexF64, mpsstr) + +function amplitude_encoding(::Type{T}, v::AbstractVector{<:Number}; nqubits::Int=ceil(Int, log2(length(v)))) where {T<:Number} + vn = norm(v) + (vn ≈ 1.) || println(""input vector is not normalized, it will be renormalized as a quantum state."") + vv = zeros(T, 2^nqubits) + for i in 1:length(v) + vv[i] = v[i] / vn + end + return StateVector(vv, nqubits) +end +amplitude_encoding(v::AbstractVector; kwargs...) = amplitude_encoding(ComplexF64, v; kwargs...) + +function reset!(x::StateVector) + fill!(storage(x), zero(eltype(x))) + x[1] = one(eltype(x)) + return x +end +function reset_onehot!(x::StateVector, i::AbstractVector{Int}) + @assert nqubits(x) == length(i) + pos = _sub2ind(i) + 1 + fill!(storage(x), zero(eltype(x))) + x[pos] = one(eltype(x)) + return x +end + +function reset_qubit!(x::StateVector, i::AbstractVector{<:Real}) + @assert nqubits(x) == length(i) + if length(i) == 1 + copyto!(storage(x), kernal_mapping(i[1])) + return x + end + a, b = _qcat_util(kernal_mapping.(i)...) + m = length(a) + n = length(b) + xs = storage(x) + for j in 1:m + n_start = (j-1) * n + 1 + n_end = j * n + tmp = a[j] + @. xs[n_start:n_end] = tmp * b + end + return x +end + +function amplitude(s::StateVector, i::AbstractVector{Int}; scaling::Real=sqrt(2)) + @assert length(i)==nqubits(s) + idx = _sub2ind(i) + return scaling==1 ? s[idx] : s[idx] * scaling^(nqubits(s)) +end +amplitudes(s::StateVector) = storage(s) + +function rand_state(::Type{T}, n::Int) where {T <: Number} + (n >= 1) || error(""number of qubits must be positive."") + v = randn(T, 2^n) + v ./= norm(v) + return StateVector(v, n) +end +rand_state(n::Int) = rand_state(ComplexF64, n) + +function QuantumCircuits.permute(x::StateVector, newindex::Vector{Int}) + n = nqubits(x) + L = length(storage(x)) + return StateVector(reshape(permute(reshape(storage(x), ntuple(i->2,n)), newindex), L), n) +end + + +function _sub2ind(v::AbstractVector{Int}) + @assert _is_valid_indices(v) + isempty(v) && error(""input index is empty."") + L = length(v) + r = v[1] + for i in 2:L + r |= v[i] << (i-1) + end + return r +end + +function _qcat_util(vr::Union{AbstractVector, AbstractMatrix}...) + v = reverse(vr) + L = length(v) + # println(""$(typeof(v)), $L"") + (L >= 2) || error(""something wrong."") + Lh = div(L, 2) + a = v[1] + for i in 2:Lh + a = kron(a, v[i]) + end + b = v[Lh + 1] + for i in Lh+2 : L + b = kron(b, v[i]) + end + return a, b +end + +function _is_valid_indices(i::AbstractVector{Int}) + for s in i + (s == 0 || s == 1) || return false + end + return true +end + +_nqubits(s::AbstractVector) = begin + n = round(Int, log2(length(s))) + (2^n == length(s)) || error(""state can not be interpretted as a qubit state."") + return n +end + + + +# function reset!(x::AbstractVector, i::AbstractVector{<:AbstractFloat}) +# (nqubits(x) == length(i)) || error(""input basis mismatch with number of qubits."") +# mpsstr = kernal_mapping.(i) +# for (pos, item) in enumerate(Iterators.product(mpsstr...)) +# x[pos] = prod(item) +# end +# return x +# end + + +# function qrandn(::Type{T}, n::Int) where {T <: Number} +# (n >= 1) || error(""number of qubits must be positive."") +# v = randn(T, 2^n) +# v ./= norm(v) +# return v +# end + +# qrandn(n::Int) = qrandn(Complex{Float64}, n) +","Julia" +"Conjugate","guochu/VQC.jl","src/VQC.jl",".jl","1750","86","module VQC + + +using Zygote +using Zygote: @adjoint + + +using LinearAlgebra, StaticArrays, QuantumCircuits, QuantumCircuits.Gates +using QuantumCircuits: permute +import LinearAlgebra, QuantumCircuits + +# using KrylovKit: exponentiate +# using SparseArrays: spzeros, sparse, SparseMatrixCSC +# using Logging: @warn + + + + +# statevector +export StateVector, DensityMatrix, distance, distance2, onehot_encoding, qubit_encoding, amplitude_encoding, reset!, amplitude, amplitudes +export tr, dot, norm, normalize!, normalize, ishermitian +export reset_qubit!, reset_onehot!, storage, fidelity, rand_state, rand_densitymatrix, permute +export schmidt_numbers, renyi_entropy + +# gate operations +export apply! + +# measurement +export measure, measure! + + +# hamiltonian +export expectation + +# AD for post selection may be removed in the future +export post_select, post_select! + +# partial trace +export partial_tr + +# utility functions + + + +# auxiliary +include(""auxiliary/distance.jl"") +include(""auxiliary/parallel_for.jl"") +include(""auxiliary/sampling.jl"") +include(""auxiliary/tensorops.jl"") +include(""auxiliary/indexop.jl"") + +# definitions of pure quantum gate +include(""statevector.jl"") + +# density matrix representation +include(""densitymatrix.jl"") + +# quantum gate operations +include(""applygates/applygates.jl"") + + +# measurement and postselection +include(""measure.jl"") +include(""postselect.jl"") + +# hamiltonian expectation +include(""hamiltonian/util.jl"") +include(""hamiltonian/apply_qterms/apply_qterms.jl"") +include(""hamiltonian/expecs/expecs.jl"") +include(""hamiltonian/expecs_dm/expecs_dm.jl"") + + +# differentiation +include(""circuitdiff.jl"") +include(""expecdiff.jl"") +include(""additional_adjoints.jl"") + +# partial trace +include(""ptrace.jl"") + +# utility functions +include(""utility/utility.jl"") + + +end +","Julia" +"Conjugate","guochu/VQC.jl","src/expecdiff.jl",".jl","2366","71","# gradient of expectation values + + +function _qterm_expec_util(m::QubitsTerm, state::StateVector) + if length(positions(m)) <= LARGEST_SUPPORTED_NTERMS + return expectation(m, state), z -> (nothing, (conj(z) * m + z * m') * state ) + else + v = m * state + return dot(state, v), z -> begin + m1 = conj(z) * m + m2 = z * m' + _apply_qterm_util!(m1, storage(state), storage(v)) + v2 = storage( m2 * state ) + v2 .+= storage(v) + return (nothing, StateVector(v2, nqubits(state))) + end + end +end + +# this could be slow +# _qterm_expec_util(m::QubitsTerm, state::DensityMatrix) = expectation(m, state), z -> ( +# nothing, storage((conj(z) * m + z * m') * DensityMatrix(one(storage(state)), nqubits(state))) ) + +_qterm_expec_util(m::QubitsTerm, state::DensityMatrix) = expectation(m, state), z -> ( + nothing, (z * m') * DensityMatrix(one(storage(state)), nqubits(state))) + + +@adjoint expectation(m::QubitsTerm, state::Union{StateVector, DensityMatrix}) = _qterm_expec_util(m, state) + +function _qop_expec_util(m::QubitsOperator, state_in::StateVector) + if _largest_nterm(m) <= LARGEST_SUPPORTED_NTERMS + return expectation(m, state_in), z -> (nothing, (conj(z) * m + z * m') * state_in ) + else + state = storage(state_in) + workspace = similar(state) + state_2 = zeros(eltype(state), length(state)) + for (k, v) in m.data + for item in v + _apply_qterm_util!(QubitsTerm(k, item[1], item[2]), state, workspace) + state_2 .+= workspace + end + end + r = dot(state, state_2) + return r, z -> begin + if ishermitian(m) + state_2 .*= (conj(z) + z) + else + state_2 .*= conj(z) + md = m' + for (k, v) in md.data + for item in v + _apply_qterm_util!(QubitsTerm(k, item[1], item[2]), state, workspace) + @. state_2 += z * workspace + end + end + end + return (nothing, StateVector(state_2, nqubits(state_in))) + end + end +end +# _qop_expec_util(m::QubitsOperator, state::DensityMatrix) = expectation(m, state), z -> ( +# nothing, storage( (conj(z) * m + z * m') * DensityMatrix(one(storage(state)), nqubits(state)) ) ) + +_qop_expec_util(m::QubitsOperator, state::DensityMatrix) = expectation(m, state), z -> ( + nothing, (z * m') * DensityMatrix(one(storage(state)), nqubits(state)) ) + + +@adjoint expectation(m::QubitsOperator, state::Union{StateVector, DensityMatrix}) = _qop_expec_util(m, state) + + +","Julia" +"Conjugate","guochu/VQC.jl","src/additional_adjoints.jl",".jl","968","21"," + +@adjoint storage(x::Union{StateVector, DensityMatrix}) = storage(x), z -> (typeof(x)(z),) +@adjoint nqubits(x::Union{StateVector, DensityMatrix}) = nqubits(x), z -> (nothing,) +@adjoint StateVector(data::AbstractVector{<:Number}, n::Int) = StateVector(data, n), z -> (storage(z), nothing) +@adjoint StateVector(data::AbstractVector{<:Number}) = StateVector(data), z -> (storage(z),) +@adjoint DensityMatrix(data::AbstractMatrix{<:Number}, n::Int) = DensityMatrix(data, n), z -> (storage(z), nothing) +@adjoint DensityMatrix(data::AbstractMatrix{<:Number}) = DensityMatrix(data), z -> (storage(z),) + +# @adjoint dot(x::StateVector, y::StateVector) = begin +# v, back = Zygote.pullback(dot, storage(x), storage(y)) +# return v, z -> begin +# a, b = back(z) +# return StateVector(a, nqubits(x)), StateVector(b, nqubits(y)) +# end +# end + +# # this is stupid, why should I need it +# @adjoint dot(x::StateVector, y::StateVector) = Zygote.pullback(dot, storage(x), storage(y)) + +","Julia" +"Conjugate","guochu/VQC.jl","src/ptrace.jl",".jl","1669","55","# partial trace + + +function partial_tr(state::DensityMatrix, sites::Vector{Int}) + isempty(sites) && return state + # some checks + check_partial_tr_inputs(sites, nqubits(state)) + (length(sites) == nqubits(state)) && return tr(state) + return DensityMatrix(_partial_tr_impl(storage(state), sites, nqubits(state)), nqubits(state) - length(sites) ) +end + + +function partial_tr(state::StateVector, sites::Vector{Int}) + isempty(sites) && return DensityMatrix(state) + n = nqubits(state) + check_partial_tr_inputs(sites, n) + (length(sites) == n) && return dot(state, state) + + axis = move_selected_index_backward(collect(1:n), sites) + vt = permute(reshape(storage(state), ntuple(i->2, n)), axis) + vt_shape = size(vt) + s1 = prod(vt_shape[1:(n-length(sites))]) + s2 = prod(vt_shape[(n-length(sites)+1):end]) + vt = reshape(vt, s1, s2) + # vt = vt * vt' + return DensityMatrix(vt * vt', n - length(sites) ) +end + + +function check_partial_tr_inputs(sites::Vector{Int}, n::Int) + tmp = Set(sites) + (length(sites) == length(tmp)) || throw(ArgumentError(""duplicate sites not allowed."")) + for item in tmp + (item>=1 && item<=n) || throw(ArgumentError(""site out of range."")) + end +end + +function _partial_tr_impl(v::AbstractMatrix, sites::Vector{Int}, n::Int) + axis = move_selected_index_backward(collect(1:n), sites) + # rdim = reverse(dim) + vt = reshape(v, ntuple(i->2, 2*n)) + axis2 = axis .+ n + vt = permute(vt, [axis..., axis2...]) + vt_shape = size(vt)[1:n] + s1 = prod(vt_shape[1:(n-length(sites))]) + s2 = prod(vt_shape[(n-length(sites)+1):end]) + vt = permute(reshape(vt, s1,s2,s1,s2), (1,3,2,4)) + r = zeros(eltype(vt), s1, s1) + for i in 1:s2 + r .+= view(vt, :, :, i, i) + end + return r +end + +","Julia" +"Conjugate","guochu/VQC.jl","src/circuitdiff.jl",".jl","2837","91"," +@adjoint *(circuit::QCircuit, x::Union{StateVector, DensityMatrix}) = begin + y = circuit * x + return y, Δ -> begin + Δ, grads, y = back_propagate(copy(Δ), circuit, copy(y)) + return grads, Δ + end +end + +@adjoint qubit_encoding(::Type{T}, mpsstr::Vector{<:Real}) where {T<:Number} = begin + y = qubit_encoding(T, mpsstr) + return y, Δ -> begin + circuit = QCircuit([RyGate(i, theta*pi, isparas=true) for (i, theta) in enumerate(mpsstr)]) + Δ, grads, y = back_propagate(Δ, circuit, copy(y)) + return nothing, grads .* pi + end +end + +# @adjoint amplitude_encoding(::Type{T}, v::AbstractVector{<:Number}; kwargs...) where {T <: Number} = amplitude_encoding( +# T, v; kwargs...), z -> (nothing, z[1:length(v)]) + + +function back_propagate(Δ::StateVector, m::Gate, y::StateVector) + Δ = apply!(m', Δ) + y = apply!(m', y) + ∇θs = nothing + if nparameters(m) > 0 + ∇θs = [real(expectation(y, item, Δ)) for item in differentiate(m)] + end + return Δ, ∇θs, y +end + +# a temporary solution, which requires an additional copy of the density matrix +# we can not assume x or y to be positive or hermitian here, since they may not be physical density matrix +function expectation(x::DensityMatrix, m::Gate, y::DensityMatrix) + yc = copy(y) + apply_threaded!(m, yc.data) + return dot(storage(x)', storage(yc)) +end + +function back_propagate(Δ::DensityMatrix, m::Gate, y::DensityMatrix) + Δ = apply!(m', Δ) + y = apply!(m', y) + ∇θs = nothing + if nparameters(m) > 0 + ∇θs = [real(expectation(y, item, Δ) + expectation(Δ, item', y)) for item in differentiate(m)] + end + return Δ, ∇θs, y +end + +function back_propagate(Δ::DensityMatrix, m::QuantumMap, y::DensityMatrix) + Δ = apply_dagger!(m, Δ) + y = apply_inverse!(m, y) + ∇θs = nothing + return Δ, ∇θs, y +end + +function back_propagate_util(Δ, circuit::QCircuit, y) + RT = real(eltype(y)) + grads = Vector{RT}[] + for item in reverse(circuit) + Δ, ∇θs, y = back_propagate(Δ, item, y) + !isnothing(∇θs) && push!(grads, ∇θs) + end + + ∇θs_all = RT[] + for item in Iterators.reverse(grads) + append!(∇θs_all, item) + end + + return Δ, ∇θs_all, y +end + +back_propagate(Δ::StateVector, circuit::QCircuit, y::StateVector) = back_propagate_util(Δ, circuit, y) +back_propagate(Δ::DensityMatrix, circuit::QCircuit, y::DensityMatrix) = back_propagate_util(Δ, circuit, y) + + + + +# function back_propagate(Δ::AbstractMatrix, m::Gate, y::DensityMatrix) +# Δ = StateVector(Δ, nqubits(y)) +# Δ = apply!(m', Δ) +# y = apply!(m', y) +# ∇θs = nothing +# if nparameters(m) > 0 +# ∇θs = [real(expectation(y, item, Δ)) for item in differentiate(m)] +# end +# return storage(Δ), ∇θs, y +# end + +","Julia" +"Conjugate","guochu/VQC.jl","src/utility/groundstate.jl",".jl","1071","25","using KrylovKit: eigsolve, exponentiate + + +function ground_state(h::QubitsOperator; kwargs...) + ishermitian(h) || throw(ArgumentError(""input operator is not hermitian."")) + n = QuantumCircuits.get_largest_pos(h) + T = eltype(h) + init_state = rand_state(T, n) + + eigvalues, eigvectors, info = eigsolve(x -> storage(h(StateVector(x, n))), storage(init_state), 1, :SR; ishermitian=true, kwargs...) + (info.converged>=1) || error(""eigsolve fails to converge."") + return eigvalues[1], StateVector(eigvectors[1], n) +end + + +function time_evolution(h::QubitsOperator, t::Number, v::StateVector; kwargs...) + ishermitian(h) || throw(ArgumentError(""input operator is not hermitian."")) + (QuantumCircuits.get_largest_pos(h) <= nqubits(v)) || throw(ArgumentError(""number of qubits mismatch."")) + n = nqubits(v) + T = promote_type(eltype(h), typeof(t), eltype(v) ) + v = convert(StateVector{T}, v) + tmp, info = exponentiate(x -> storage(h(StateVector(x, n))), t, storage(v); ishermitian=true, kwargs...) + (info.converged>=1) || error(""eigsolve fails to converge."") + return StateVector(tmp, n) +end","Julia" +"Conjugate","guochu/VQC.jl","src/utility/variationalcircuit.jl",".jl","4239","149",""""""" + variational_circuit_1d(L::Int, depth::Int; θs::Vector{<:Real}) +Return a variational quantum circuit given L qubis and d depth +"""""" +function variational_circuit_1d(L::Int, depth::Int; θs::Vector{<:Real}=rand(_nparas(ComplexF64, L, depth)) .* 2π) + paras = θs + (length(paras) == _nparas(ComplexF64, L, depth)) || throw(""wrong number of parameters."") + circuit = QCircuit() + ncount = 1 + for i in 1:L + push!(circuit, RzGate(i, paras[ncount], isparas=true)) + ncount += 1 + push!(circuit, RyGate(i, paras[ncount], isparas=true)) + ncount += 1 + push!(circuit, RzGate(i, paras[ncount], isparas=true)) + ncount += 1 + end + for i in 1:depth + if isodd(i) + for j in 1:(L-1) + push!(circuit, CNOTGate(j, j+1)) + end + else + for j in (L-1):-1:1 + push!(circuit, CNOTGate(j, j+1)) + end + end + for j in 1:L + push!(circuit, RzGate(j, paras[ncount], isparas=true)) + ncount += 1 + push!(circuit, RyGate(j, paras[ncount], isparas=true)) + ncount += 1 + push!(circuit, RzGate(j, paras[ncount], isparas=true)) + ncount += 1 + end + end + @assert ncount == length(paras)+1 + return circuit +end + +function real_variational_circuit_1d(L::Int, depth::Int; θs::Vector{<:Real}=rand(_nparas(Float64, L, depth)) .* 2π) + paras = θs + (length(paras) == _nparas(Float64, L, depth)) || throw(""wrong number of parameters."") + circuit = QCircuit() + ncount = 1 + for i in 1:L + push!(circuit, RyGate(i, paras[ncount], isparas=true)) + ncount += 1 + end + for i in 1:depth + if isodd(i) + for j in 1:(L-1) + push!(circuit, CNOTGate(j, j+1)) + end + else + for j in (L-1):-1:1 + push!(circuit, CNOTGate(j, j+1)) + end + end + for j in 1:L + push!(circuit, RyGate(j, paras[ncount], isparas=true)) + ncount += 1 + end + end + @assert ncount == length(paras)+1 + return circuit +end + + +# function variational_circuit_2d(m::Int, n::Int, depth::Int; θs::Vector{<:Real}=rand(_nparas(ComplexF64, m*n, depth)) .* 2π) +# paras = θs +# L = m*n +# (length(paras) == _nparas(ComplexF64, L, depth)) || throw(""wrong number of parameters."") +# circuit = QCircuit() +# ncount = 1 +# for i in 1:L +# push!(circuit, RzGate(i, paras[ncount], isparas=true)) +# ncount += 1 +# push!(circuit, RyGate(i, paras[ncount], isparas=true)) +# ncount += 1 +# push!(circuit, RzGate(i, paras[ncount], isparas=true)) +# ncount += 1 +# end + +# index = LinearIndices((m, n)) +# for l in 1:depth +# for i in 1:m +# for j in 1:(n-1) +# push!(circuit, CNOTGate(index[i, j], index[i, j+1])) +# end +# end +# for i in 1:(m-1) +# for j in 1:n +# push!(circuit, CNOTGate(index[i, j], index[i+1, j])) +# end +# end +# for i in 1:L +# push!(circuit, RzGate(i, paras[ncount], isparas=true)) +# ncount += 1 +# push!(circuit, RyGate(i, paras[ncount], isparas=true)) +# ncount += 1 +# push!(circuit, RzGate(i, paras[ncount], isparas=true)) +# ncount += 1 +# end +# end +# @assert ncount == length(paras)+1 +# return circuit +# end +# variational_circuit_2d(shapes::Tuple{Int, Int}, args...; kwargs...) = variational_circuit_2d(shapes[1], shapes[2], args...; kwargs...) + +# function real_variational_circuit_2d(m::Int, n::Int, depth::Int; θs::Vector{<:Real}=rand(_nparas(Float64, m*n, depth)) .* 2π) +# paras = θs +# L = m*n +# (length(paras) == _nparas(Float64, L, depth)) || throw(""wrong number of parameters."") +# circuit = QCircuit() +# ncount = 1 +# for i in 1:L +# push!(circuit, RyGate(i, paras[ncount], isparas=true)) +# ncount += 1 +# end + +# index = LinearIndices((m, n)) +# for l in 1:depth +# for i in 1:m +# for j in 1:(n-1) +# push!(circuit, CNOTGate(index[i, j], index[i, j+1])) +# end +# end +# for i in 1:(m-1) +# for j in 1:n +# push!(circuit, CNOTGate(index[i, j], index[i+1, j])) +# end +# end +# for i in 1:L +# push!(circuit, RyGate(i, paras[ncount], isparas=true)) +# ncount += 1 +# end +# end +# @assert ncount == length(paras)+1 +# return circuit +# end +# real_variational_circuit_2d(shapes::Tuple{Int, Int}, args...; kwargs...) = real_variational_circuit_2d(shapes[1], shapes[2], args...; kwargs...) + +function _nparas(::Type{T}, L::Int, depth::Int) where {T <: Number} + n = depth+1 + return (T <: Real) ? n * L : n * L * 3 +end + +","Julia" +"Conjugate","guochu/VQC.jl","src/utility/qft.jl",".jl","427","25","export QFT + +function _nnqft_one_block(L::Int) + (L<=0) && error(""input size can not be 0"") + r = QCircuit() + if L==1 + push!(r, (1, H)) + return r + else + append!(r, _nnqft_one_block(L-1)) + push!(r, (((L,L-1), CONTROL(R(L)) * SWAP))) + return r + end +end + +"""""" + efficient QFT which only contains nearest neighbour gates. +"""""" +function QFT(L::Int) + r = QCircuit() + for i = L:-1:1 + append!(r, _nnqft_one_block(i)) + end + return r +end","Julia" +"Conjugate","guochu/VQC.jl","src/utility/utility.jl",".jl","391","19","module Utilities + +using VQC +using QuantumCircuits, QuantumCircuits.Gates + +export heisenberg_1d, heisenberg_2d, ising_1d, ising_2d, ground_state, time_evolution +export QFT +export variational_circuit_1d, real_variational_circuit_1d +export order_finding + +include(""spin_hamiltonians.jl"") +include(""groundstate.jl"") + +include(""qft.jl"") +include(""variationalcircuit.jl"") +include(""shor/shor.jl"") + + +end","Julia" +"Conjugate","guochu/VQC.jl","src/utility/spin_hamiltonians.jl",".jl","2615","86"," + + +"""""" + heisenberg xxz chain +"""""" +function heisenberg_chain(L::Int; J::Real=1., Jzz::Real=J, hz::Real=0.) + sp, sm, z = QuantumCircuits._get_op.([""+"", ""-"", ""Z""]) + terms = [] + # one site terms + for i in 1:L + push!(terms, QubitsTerm(i=>z, coeff=hz)) + end + # nearest-neighbour interactions + for i in 1:L-1 + t = QubitsTerm(i=>sp, i+1=>sm, coeff=2*J) + push!(terms, t) + push!(terms, t') + push!(terms, QubitsTerm(i=>z, i+1=>z, coeff=Jzz)) + end + return simplify(QubitsOperator(terms...)) +end +heisenberg_1d(L::Int; kwargs...) = heisenberg_chain(L; kwargs...) + +function heisenberg_2d(m::Int, n::Int=m; J::Real=1., Jzz::Real=J, hz::Real=0.) + sp, sm, z = QuantumCircuits._get_op.([""+"", ""-"", ""Z""]) + terms = [] + for i in 1:m*n + push!(terms, QubitsTerm(i=>z, coeff=hz)) + end + index = LinearIndices((m, n)) + for i in 1:m + for j in 1:(n-1) + t = QubitsTerm(index[i, j]=>sp, index[i, j+1]=>sm, coeff=2*J) + push!(terms, t) + push!(terms, t') + push!(terms, QubitsTerm(index[i, j]=>z, index[i, j+1]=>z, coeff=Jzz) ) + end + end + for i in 1:(m-1) + for j in 1:n + t = QubitsTerm(index[i, j]=>sp, index[i+1, j]=>sm, coeff=2*J) + push!(terms, t) + push!(terms, t') + push!(terms, QubitsTerm(index[i, j]=>z, index[i+1, j]=>z, coeff=Jzz) ) + end + end + return simplify(QubitsOperator(terms...)) +end +heisenberg_2d(shapes::Tuple{Int, Int}; kwargs...) = heisenberg_2d(shapes[1], shapes[2]; kwargs...) + + +function ising_chain(L::Int; J::Real=1., hz::Real=1.) + x, z = QuantumCircuits._get_op.([""X"", ""Z""]) + terms = [] + for i in 1:L + push!(terms, QubitsTerm(i=>z, coeff=hz)) + end + for i in 1:L-1 + push!(terms, QubitsTerm(i=>x, i+1=>x, coeff=J)) + end + return simplify(QubitsOperator(terms...)) +end +ising_1d(L::Int; kwargs...) = ising_chain(L; kwargs...) + +function ising_2d(m::Int, n::Int=m; J::Real=1., hz::Real=1.) + x, z = QuantumCircuits._get_op.([""X"", ""Z""]) + terms = [] + for i in 1:m*n + push!(terms, QubitsTerm(i=>z, coeff=hz)) + end + index = LinearIndices((m, n)) + for i in 1:m + for j in 1:(n-1) + push!(terms, QubitsTerm(index[i, j]=>x, index[i, j+1]=>x, coeff=J) ) + end + end + for i in 1:(m-1) + for j in 1:n + push!(terms, QubitsTerm(index[i, j]=>x, index[i+1, j]=>x, coeff=J) ) + end + end + return simplify(QubitsOperator(terms...)) +end +ising_2d(shapes::Tuple{Int, Int}; kwargs...) = ising_2d(shapes[1], shapes[2]; kwargs...) +","Julia" +"Conjugate","guochu/VQC.jl","src/utility/shor/shor.jl",".jl","125","8"," +include(""util.jl"") +include(""Beauregard.jl"") +include(""Fowler.jl"") + +include(""orderfinding_sqc.jl"") +include(""orderfinding.jl"") +","Julia" +"Conjugate","guochu/VQC.jl","src/utility/shor/Fowler.jl",".jl","6596","284"," +# using 2n+4 qubits + +const PLUS = [0.5+0.5*im 0.5-0.5*im; 0.5-0.5*im 0.5+0.5*im] +const MINUS = [0.5-0.5*im 0.5+0.5*im; 0.5+0.5*im 0.5-0.5*im] +const CONTROL_PLUS = CONTROL(PLUS) +const CONTROL_MINUS = CONTROL(MINUS) + +"""""" + n = length(a) + n qubits + @ input output + b[0] + b[1] + ... + b[n-1] +"""""" +LNNAdderCircuit(a::BinaryInteger) = QCircuit([PHASEGate(i, compute_phase(a, i)) for i in 0:(length(a)-1)]) + +"""""" + n = len(a) + n+1 qubits + @input + c control qubit + b[0] + b[1] + ... + b[n-1] + @output + b[0] + b[1] + ... + b[n-1] + c control qubit +"""""" +LNNCAdderCircuit(a::BinaryInteger; inverse::Bool=false) = inverse ? QCircuit( +[gate((i+1, i), SWAP * CONTROL(PHASE(compute_phase(a, i)))) for i in (length(a)-1):-1:0]) : QCircuit( +[gate((i, i+1), SWAP * CONTROL(PHASE(compute_phase(a, i)))) for i in 0:(length(a)-1)]) + +"""""" + this circuit contains n+6 qubits, where n+1 = len(a) = len(N) + x1 + MS addition (most significant) qubit in |0> out |0> + x2 + ki qubit in |0> out |0> + kx qubit + b[0] + b[1] + b[2] + ... + b[n] +"""""" +function LNNModAdderCircuit(N::BinaryInteger, a::BinaryInteger) + (length(N)==length(a)) || error(""binary integer a and N size mismatch."") + L = length(a) + n = L-1 + total_circuit = QCircuit() + push!(total_circuit, gate((3,4), CONTROL_PLUS)) + push!(total_circuit, gate((2,3), CNOT)) + push!(total_circuit, gate((3,4), CONTROL_MINUS)) + push!(total_circuit, gate((2,3), SWAP*CNOT)) + push!(total_circuit, gate((3,4), CONTROL_PLUS)) + append!(total_circuit, shift(LNNCAdderCircuit(a, inverse=false), 4)) + append!(total_circuit, shift(LNNAdderCircuit(N), 4)') + append!(total_circuit, shift(_QFT(L)', 4) ) + push!(total_circuit, gate((1,2), SWAP)) + push!(total_circuit, gate((2,3), SWAP)) + push!(total_circuit, gate((4,3), SWAP * CNOT)) + append!(total_circuit, move_site(4, n+4)) + append!(total_circuit, shift(_QFT(L), 3)) + append!(total_circuit, shift(LNNCAdderCircuit(N, inverse=true), 3) ) + append!(total_circuit, shift(LNNCAdderCircuit(a, inverse=false)', 4) ) + append!(total_circuit, shift(_QFT(L)', 5) ) + append!(total_circuit, move_site(4, n+5)) + push!(total_circuit, gate(4, X)) + push!(total_circuit, gate((4,3), CNOT)) + push!(total_circuit, gate(4, X)) + push!(total_circuit, gate((2,3), SWAP)) + push!(total_circuit, gate((1,2), SWAP)) + push!(total_circuit, gate((0,1), SWAP)) + append!(total_circuit, shift(_QFT(L), 4) ) + append!(total_circuit, shift(LNNCAdderCircuit(a, inverse=true), 4) ) + push!(total_circuit, gate((3,4), CONTROL_MINUS)) + push!(total_circuit, gate((2,3), CNOT * SWAP)) + push!(total_circuit, gate((3,4), CONTROL_PLUS)) + push!(total_circuit, gate((2,3), CNOT)) + push!(total_circuit, gate((1,2), SWAP)) + push!(total_circuit, gate((0,1), SWAP)) + push!(total_circuit, gate((3,4), CONTROL_MINUS)) + return total_circuit +end + +"""""" + this circuit contains 2n+4 qubits, where n+1 = len(a) = len(N) + x[0] + x[1] + ... + x[n-2] + MS + x[n-1] + ki + kx + b[0] n+3 + b[1] + ... + b[n] +"""""" +function LNNCModMultiplierCircuit(N::BinaryInteger, a::BinaryInteger) + (length(N)==length(a)) || error(""binary integer a and N size mismatch."") + L = length(a) + + n = L-1 + + total_circuit = QCircuit() + + # qft = shift(_QFT(L), n+3) + # append!(total_circuit, qft) + + mv = move_site(n-2, 0) + + for i in 0:(n-1) + + apow = modular_multiply(a, 2^i, N) + + madder = LNNModAdderCircuit(N, apow) + + append!(total_circuit, shift(madder, n-2) ) + + append!(total_circuit, mv) + end + + # append!(total_circuit, qft') + + return total_circuit +end + +function _cswap() + circuit = QCircuit() + push!(circuit, gate((2,1), CNOT)) + push!(circuit, gate((1,2), CONTROL_PLUS)) + push!(circuit, gate((0,1), CNOT)) + push!(circuit, gate((1,2), CONTROL_MINUS)) + push!(circuit, gate((0,1), SWAP * CNOT)) + push!(circuit, gate((1,2), SWAP * CONTROL_PLUS)) + push!(circuit, gate((1,0), CNOT)) + return circuit +end + +function mesh(n::Int) + circuit = QCircuit() + for i in 0:(n-2) + append!(circuit, move_site(n+i, 2*i+1)) + end + return circuit +end + +"""""" + 2n+1 qubits + c + a[0] + a[1] + ... + a[n-1] + b[0] + b[1] + ... + b[n-1] +"""""" +function control_swap(n::Int) + total_circuit = QCircuit() + append!(total_circuit, shift(mesh(n), 1) ) + for i in 0:2:(2*n-1) + append!(total_circuit, shift(_cswap(), i) ) + end + append!(total_circuit, mesh(n)') + return total_circuit +end + +"""""" + this circuit contains 2n+4 qubits, where n+1 = len(a) = len(N) + x[0] + x[1] + ... + x[n-2] + MS + x[n-1] + ki + kx + b[0] n+3 + b[1] + ... + b[n] +"""""" +function LNNModUCircuit(N::BinaryInteger, a::BinaryInteger, ra::BinaryInteger) + ((length(N)==length(a)) && (length(N)==length(ra))) || error(""binary integer a, ar and N size mismatch."") + L = length(a) + n = L-1 + + total_circuit = QCircuit() + + append!(total_circuit, LNNCModMultiplierCircuit(N, a)) + + append!(total_circuit, shift(_QFT(L)', n+3) ) + append!(total_circuit, move_site(n-1, 0)) + append!(total_circuit, move_site(n+2, 1)) + append!(total_circuit, move_site(n+2, 2)) + append!(total_circuit, shift(move_site(0, n), n+3)) + + # controled swap + append!(total_circuit, shift(control_swap(n), 2) ) + + append!(total_circuit, move_site(1, n+1)) + append!(total_circuit, move_site(0, n-1)) + append!(total_circuit, move_site(2*n+2, n+1)) + append!(total_circuit, move_site(2*n+3, n+3)) + append!(total_circuit, shift(_QFT(L), n+3)) + + append!(total_circuit, LNNCModMultiplierCircuit(N, ra)') + + return total_circuit +end + + +"""""" + compute fa,N (x) = a^x mod N + 2n+3+m qubits alined as follows + f[0] + f[1] + ... + f[m-1] + x[0] m + x[1] + ... + x[n-2] + MS + x[n-1] m+n + --ki-- + kx m+n+1 + b[0] m+n+2 + b[1] + ... + b[n] + @input + @x m bits qnumber + @b result: n bits qnumber, initialized to be |0> + @output + @b->(a^x)%N +"""""" +function LNNModExponentiatorCircuit(N::BinaryInteger, a::BinaryInteger, m::Int) + (length(N)==length(a)) || error(""binary integer a and N size mismatch."") + + total_circuit = QCircuit() + + L = length(N) + + n = L-1 + + ra = modular_inverse(a, N) + + qft_circuit = shift(_QFT(L), m+n+2) + + append!(total_circuit, qft_circuit) + + for i in (m-1):-1:0 + + mv = move_site(i, m+n) + + append!(total_circuit, mv) + + # central block operations + append!(total_circuit, shift(LNNModUCircuit(N, a, ra), m-1)) + + append!(total_circuit, mv') + + a = modular_multiply(a, a, N) + + ra = modular_multiply(ra, ra, N) + end + + append!(total_circuit, qft_circuit') + + return total_circuit +end +","Julia" +"Conjugate","guochu/VQC.jl","src/utility/shor/util.jl",".jl","1416","61","include(""binaryinteger.jl"") + + +"""""" + circuit to move i to j +"""""" +function move_site(i::Int, j::Int) + circuit = QCircuit() + (i==j) && return circuit + if i < j + for k = i:(j-1) + # push!(circuit, ((k, k+1), SWAP)) + push!(circuit, SWAPGate(k, k+1)) + end + else + for k = i:-1:(j+1) + # push!(circuit, ((k, k-1), SWAP)) + push!(circuit, SWAPGate(k, k-1)) + end + end + return circuit +end + +# function compute_phase(a::BinaryInteger, j::Int) +# s = 1 +# n = length(a) +# for k in 1:(j+1) +# aj = a[n-(j+1-k)] +# s = s*exp(aj*pi*im/2^(k-1)) +# end +# return s +# end +# rotationA(a::BinaryInteger, j::Int) = [1 0; 0 compute_phase(a, j)] +function compute_phase(a::BinaryInteger, j::Int) + s = 0. + n = length(a) + for k in 1:(j+1) + aj = a[n-(j+1-k)] + s += aj / 2^(k-1) + end + return s * pi +end + +function control_swap_block(c::Int, n::Int, i::Int, inci::Int, j::Int, incj::Int) + swap_i_j = QCircuit() + # c_cnot = _row_kron(UP, eye(4)) + _row_kron(DOWN, CNOT) + (i == j) && error(""position not allowed."") + for k in 0:(n-1) + # push!(swap_i_j, gate((j+k*incj, i+k*inci), CNOT)) + push!(swap_i_j, CNOTGate(j+k*incj, i+k*inci)) + # push!(swap_i_j, gate((c, i+k*inci, j+k*incj), c_cnot)) + push!(swap_i_j, TOFFOLIGate(c, i+k*inci, j+k*incj)) + # push!(swap_i_j, gate((j+k*incj, i+k*inci), CNOT)) + push!(swap_i_j, CNOTGate(j+k*incj, i+k*inci)) + end + return swap_i_j +end + + +_QFT(L::Int) = shift(QFT(L), -1) +","Julia" +"Conjugate","guochu/VQC.jl","src/utility/shor/Beauregard.jl",".jl","5369","259"," +# using 2n+3 qubits + +# zero based circuit +# QFTAdderCircuit(a::BinaryInteger) = QCircuit([gate(i, rotationA(a, i)) for i in 0:(length(a)-1)]) +QFTAdderCircuit(a::BinaryInteger) = QCircuit([PHASEGate(i, compute_phase(a, i)) for i in 0:(length(a)-1)]) + +"""""" + n = length(a) + n+1 qubits + b[0] + b[1] + ... + b[n-1] + c control qubit +"""""" +# QFTCAdderCircuit(c::Int, a::BinaryInteger) = QCircuit([gate((c, i), CONTROL(rotationA(a, i))) for i in 0:(length(a)-1)]) +# QFTCAdderCircuit(c::Int, a::BinaryInteger) = QCircuit( +# [CONTROLGate((c, i), rotationA(a, i)) for i in 0:(length(a)-1)]) +QFTCAdderCircuit(c::Int, a::BinaryInteger) = QCircuit( +[CPHASEGate((c, i), compute_phase(a, i)) for i in 0:(length(a)-1)]) + +"""""" + n = length(a) + n+2 qubits + b[0] + b[1] + ... + b[n-1] + c2 control qubit 2 + c1 control qubit 1 +"""""" +# QFTCCAdderCircuit(c1::Int, c2::Int, a::BinaryInteger) = QCircuit( +# [gate((c1, c2, i), CONTROLCONTROL(rotationA(a, i))) for i in 0:(length(a)-1)]) +QFTCCAdderCircuit(c1::Int, c2::Int, a::BinaryInteger) = QCircuit( +[CCPHASEGate((c1, c2, i), compute_phase(a, i)) for i in 0:(length(a)-1)]) + +"""""" + this circuit contains n+4 qubits, where n+1 = length(a) = length(N) + t qubit in |0> out |0> + b[0] addition (most significant) qubit in |0> out |0> + b[1] + b[2] + ... + b[n] + c2 + c1 +"""""" +function QFTCCModAdderCircuit(N::BinaryInteger, a::BinaryInteger) + (length(N)==length(a)) || error(""binary integer a and N size mismatch."") + L = length(a) + n = L-1 + + total_circuit = QCircuit() + + cc_adder = shift(QFTCCAdderCircuit(L+1, L, a), 1) + + c_adder = shift(QFTCAdderCircuit(-1, N), 1) + + adder = shift(QFTAdderCircuit(N), 1) + + qft = shift(_QFT(L), 1) + + append!(total_circuit, cc_adder) + + append!(total_circuit, adder') + + append!(total_circuit, qft') + + # push!(total_circuit, gate((1, 0), CNOT)) + push!(total_circuit, CNOTGate(1, 0)) + + append!(total_circuit, qft) + + append!(total_circuit, c_adder) + + append!(total_circuit, cc_adder') + + append!(total_circuit, qft') + + # push!(total_circuit, gate(1, X)) + push!(total_circuit, XGate(1)) + + # push!(total_circuit, gate((1, 0), CNOT)) + push!(total_circuit, CNOTGate(1, 0)) + + # push!(total_circuit, gate(1, X)) + push!(total_circuit, XGate(1)) + + append!(total_circuit, qft) + + append!(total_circuit, cc_adder) + + return total_circuit +end + +"""""" + this circuit contains 2n+3 qubits, where n+1 = length(a) = length(N) + t qubit in |0> out |0> + b[0] addition (most significant) qubit in |0> out |0> + b[1] + b[2] + ... + b[n] + x[0] + x[1] + ... + x[n-1] + c control qubit +"""""" +function QFTCModMultiplierCircuit(N::BinaryInteger, a::BinaryInteger) + + (length(N)==length(a)) || error(""binary integer a and N size mismatch."") + L = length(a) + + n = L-1 + + total_circuit = QCircuit() + + mv1 = move_site(2*n+2, n+3) + + for i in 0:(n-1) + mv2 = shift(move_site(n-1-i, 0), n+2) + + append!(total_circuit, mv2) + + append!(total_circuit, mv1) + + apow = modular_multiply(a, 2^i, N) + + madder = QFTCCModAdderCircuit(N, apow) + + append!(total_circuit, madder) + + append!(total_circuit, mv1') + + append!(total_circuit, mv2') + end + + return total_circuit +end + +"""""" + this circuit contains 2n+3 qubits, where n+1 = length(a) = length(N) + t qubit in |0> out |0> + b[0] addition (most significant) qubit in |0> out |0> + b[1] + b[2] + ... + b[n] + x[0] + x[1] + ... + x[n-1] + c control qubit +"""""" +function QFTModUCircuit(N::BinaryInteger, a::BinaryInteger, ra::BinaryInteger) + + L = length(a) + n = L-1 + + qft = shift(_QFT(L), 1) + + c_swap = control_swap_block(2*n+2, n, 2, 1, n+2, 1) + + total_circuit = QCircuit() + + mult_circuit = QFTCModMultiplierCircuit(N, a) + + append!(total_circuit, mult_circuit) + + append!(total_circuit, qft') + + append!(total_circuit, c_swap) + + append!(total_circuit, qft) + + rmult_circuit = QFTCModMultiplierCircuit(N, ra) + + append!(total_circuit, rmult_circuit') + + return total_circuit +end + +"""""" + compute fa,N (x) = a^x mod N + 2n+2+m qubits alined as follows + t qubit in |0> out |0> + b[0] addition qubit int |0> out |0> + b[1] + ... + b[n] + t[0] + t[1] + ... + t[n-1] + x[0] + x[1] + ... + x[m-1] + @input + @t n bits temporary qnumber, initialized to be |1> + @x m bits qnumber + @b result: n bits qnumber, initialized to be |0> + @output + @b->(a^x)%N +"""""" +function QFTCModExponentiatorCircuit(N::BinaryInteger, a::BinaryInteger, m::Int) + (length(N)==length(a)) || error(""binary integer a and N size mismatch."") + + L = length(N) + + n = L-1 + + ra = modular_inverse(a, N) + + total_circuit = QCircuit() + + c_swap = control_swap_block(2*n+2, n, 2, 1, n+2, 1) + + qft = shift(_QFT(L), 1) + + append!(total_circuit, qft) + + + for i in (m-1):-1:0 + + mv = shift(move_site(i, 0), 2*n+2) + + append!(total_circuit, mv) + + # central block operations + + mult_circuit = QFTCModMultiplierCircuit(N, a) + + append!(total_circuit, mult_circuit) + + append!(total_circuit, qft') + + append!(total_circuit, c_swap) + + append!(total_circuit, qft) + + rmult_circuit = QFTCModMultiplierCircuit(N, ra) + + append!(total_circuit, rmult_circuit') + + append!(total_circuit, mv') + + a = modular_multiply(a, a, N) + + ra = modular_multiply(ra, ra, N) + end + + append!(total_circuit, qft') + + return total_circuit +end +","Julia" +"Conjugate","guochu/VQC.jl","src/utility/shor/binaryinteger.jl",".jl","1965","64"," + +struct BinaryInteger + value::Int + svalue::Vector{Int} +end + +get_value(x::BinaryInteger) = x.value +get_svalue(x::BinaryInteger) = x.svalue +num_bits(x::BinaryInteger) = length(get_svalue(x)) + +Base.length(x::BinaryInteger) = length(get_svalue(x)) +Base.getindex(x::BinaryInteger, i::Int) = getindex(get_svalue(x), i) +Base.iterate(x::BinaryInteger) = iterate(get_svalue(x)) +Base.iterate(x::BinaryInteger, state) = iterate(get_svalue(x), state) +Base.IndexStyle(::Type{<:BinaryInteger}) = IndexLinear() +Base.firstindex(x::BinaryInteger) = firstindex(get_svalue(x)) +Base.lastindex(x::BinaryInteger) = lastindex(get_svalue(x)) + +function BinaryInteger(v::Int, Nbits::Int) + svalue = digits(v, base=2, pad=Nbits) + (length(svalue) == Nbits) || error(""$Nbits is not enough for integer $v."") + return BinaryInteger(v, reverse(svalue) ) +end + +function modular_inverse(a::BinaryInteger, N::BinaryInteger) + (num_bits(a) == num_bits(N)) || error(""nbits mismatch."") + r = invmod(get_value(a), get_value(N)) + return BinaryInteger(r, num_bits(a)) +end + +function modular_multiply(a::Integer, b::Integer, N::BinaryInteger) + r = (a * b) % get_value(N) + return BinaryInteger(r, num_bits(N)) +end + +function modular_multiply(a::BinaryInteger, b::Integer, N::BinaryInteger) + (num_bits(a) == num_bits(N)) || error(""nbits mismatch."") + return modular_multiply(get_value(a), b, N) +end + +function modular_multiply(a::BinaryInteger, b::BinaryInteger, N::BinaryInteger) + ((num_bits(a) == num_bits(b)) && (num_bits(a) == num_bits(N))) || error(""nbits mismatch."") + return modular_multiply(get_value(a), get_value(b), N) +end + +function modular_pow(bs::Integer, exponent::Integer, modulus::Integer) + (modulus==1) && return 0 + if exponent < 0 + bs = modular_inverse(bs, modulus) + exponent = -exponent + end + result=1 + bs = bs % modulus + while exponent > 0 + if (exponent % 2 == 1) + result = (result*bs) % modulus + end + exponent = exponent >> 1 + bs = (bs*bs) % modulus + end + return result +end +","Julia" +"Conjugate","guochu/VQC.jl","src/utility/shor/orderfinding.jl",".jl","4379","151"," + +"""""" + n = len(a)-1 = len(N)-1 + 4*n+2 qubits is needed +"""""" +function order_finding_qft_circuit(a::BinaryInteger, N::BinaryInteger; verbosity::Int=1) + + ai = get_value(a) + Ni = get_value(N) + (ai==1) && error(""the input a can not be 1."") + (Ni==1) && error(""the input N can not be 1."") + + (gcd(ai, Ni)==1) || error(""a and N are not co-prime to each other."") + # nmax = length(a) + # precision = 2**(-2*nmax-1) + n = length(a) + L = n+1 + a = BinaryInteger(get_value(a), L) + N = BinaryInteger(get_value(N), L) + (verbosity >= 3) && println(""n=$n, total number of qubits $(4*n+2)."") + + + circuit = QCircuit() + push!(circuit, gate(2*n+1, X)) + for i in (2*n+2):(4*n+1) + push!(circuit, gate(i, H)) + end + # circuit = shift(circuit, 2*n+2) + append!(circuit, QFTCModExponentiatorCircuit(N, a, 2*n)) + append!(circuit, shift(_QFT(2*n), 2*n+2)') + + return circuit + # check N +end + +function order_finding_by_qft(::Type{T}, a::Int, N::Int; verbosity::Int=1) where {T<:Number} + L = max(length(digits(a, base=2)), length(digits(N, base=2))) + state = StateVector(T, 4*L+2) + a = BinaryInteger(a, L) + N = BinaryInteger(N, L) + + circuit = shift(order_finding_qft_circuit(a, N, verbosity=verbosity), 1) + # println(""max min position $(max_site(circuit.data)), $(min_site(circuit.data))."") + + # circuit = fuse_gate(circuit) + apply_circuit!(circuit, state) + r = Int[] + for i in 0:(2*L-1) + observer = QMeasure(2*L+i+3) + istate, probability = apply_circuit!(observer, state) + push!(r, istate) + end + # return sum([(r[2 * L - i]*1. / (1 << (i + 1))) for i in 0:(2 * L-1)]) + return to_digits(r) +end + +"""""" + see reference + ""Implementation of Shor’s Algorithm on a Linear Nearest Neighbour Qubit Array"" + n = len(a)-1 = len(N)-1 + 4*n+3 qubits is needed + f[0] + f[1] + ... + f[2n-1] + x[0] 2n + x[1] + ... + x[n-2] + MS + x[n-1] 3n + kx + b[0] + b[1] + ... + b[n] +"""""" +function order_finding_lnn_circuit(a::BinaryInteger, N::BinaryInteger; verbosity::Int=1) + ai = get_value(a) + Ni = get_value(N) + (ai==1) && error(""the input a can not be 1."") + (Ni==1) && error(""the input N can not be 1."") + + (gcd(ai, Ni)==1) || error(""a and N are not co-prime to each other."") + # nmax = length(a) + # precision = 2**(-2*nmax-1) + n = length(a) + L = n+1 + a = BinaryInteger(get_value(a), L) + N = BinaryInteger(get_value(N), L) + (verbosity >= 3) && println(""n=$n, total number of qubits $(4*n+3)."") + + circuit = QCircuit() + push!(circuit, gate(3*n, X)) + for i in 0:(2*n-1) + push!(circuit, gate(i, H)) + end + append!(circuit, LNNModExponentiatorCircuit(N, a, 2*n)) + append!(circuit, _QFT(2*n)') + append!(circuit, move_site(3*n, 3*n-1)) + + return circuit +end + +function order_finding_by_lnn(::Type{T}, a::Int, N::Int; verbosity::Int=1) where {T<:Number} + L = max(length(digits(a, base=2)), length(digits(N, base=2))) + state = StateVector(T, 4*L+3) + a = BinaryInteger(a, L) + N = BinaryInteger(N, L) + circuit = shift(order_finding_lnn_circuit(a, N, verbosity=verbosity), 1) + + # println(""max min position $(max_site(circuit.data)), $(min_site(circuit.data))."") + + # circuit = fuse_gate(circuit) + apply_circuit!(circuit, state) + + # # testing + # println(""testing...."") + # for i in (3*L+1):(4*L+3) + # observer = QMeasure(i) + # istate, probability = apply!(observer, state) + # println(""get $istate with probability $probability at $i-th qubit."") + # end + + r = Int[] + for i in 0:(2*L-1) + observer = QMeasure(i+1) + istate, probability = apply_circuit!(observer, state) + push!(r, istate) + end + # return sum([(r[2 * L - i]*1. / (1 << (i + 1))) for i in 0:(2 * L-1)]) + return to_digits(r) +end + +function order_finding(::Type{T}, a::Int, N::Int; less_qubits::Bool=true, algorithm::Symbol=:lnn, verbosity::Int=1) where {T<:Number} + if less_qubits + return order_finding_scq(T, a, N; algorithm=algorithm, verbosity=verbosity) + else + if algorithm == :lnn + return order_finding_by_lnn(T, a, N; verbosity=verbosity) + elseif algorithm == :qft + return order_finding_by_qft(T, a, N; verbosity=verbosity) + else + error(""algorithm $algorithm not implemented."") + end + end +end + +order_finding(a::Int, N::Int) = order_finding(ComplexF64, a, N) +","Julia" +"Conjugate","guochu/VQC.jl","src/utility/shor/orderfinding_sqc.jl",".jl","5795","224","# sqc : single qubit control to use less qubits + +function to_digits(s::Vector) + r = 0. + for i in 0:(length(s)-1) + r = r + s[i+1]*2.0^(-i-1) + end + return r +end + + +apply_circuit!(gt, state) = apply!(gt, state) + +"""""" + see reference + using the one control qubit trick + this circuit contains 2n+3 qubits, where n+1 = len(a) = len(N) + t qubit in |0> out |0> + b[0] addition (most significant) qubit in |0> out |0> + b[1] + b[2] + ... + b[n] + x[0] + x[1] + ... + x[n-1] + c control qubit +"""""" +function order_finding_by_qft_impl(a::BinaryInteger, N::BinaryInteger, state; verbosity::Int=1) + (length(N)==length(a)) || error(""binary integer a and N size mismatch."") + + ai = get_value(a) + Ni = get_value(N) + (ai==1) && error(""the input a can not be 1."") + (Ni==1) && error(""the input N can not be 1."") + + (gcd(ai, Ni)==1) || error(""a and N are not co-prime to each other."") + # nmax = length(a) + # precision = 2**(-2*nmax-1) + n = length(a) + L = n+1 + a = BinaryInteger(get_value(a), L) + N = BinaryInteger(get_value(N), L) + (verbosity >= 3) && println(""n=$n, total number of qubits $(2*n+3)."") + control_site = 2*n+3 + observer = QMeasure(control_site, auto_reset=true) + + ra = modular_inverse(a, N) + + qft_circuit = shift(_QFT(L), 2) + + apply_circuit!(qft_circuit, state) + + Hgate = gate(control_site, H) + + apply_circuit!(Hgate, state) + + astore = [] + rastore = [] + for i in 1:(2*n) + push!(astore, a) + push!(rastore, ra) + a = modular_multiply(a, a, N) + ra = modular_multiply(ra, ra, N) + end + + r = [] + # print('total number of measurements %s'%(2*n)) + for i in 0:(2*n-1) + apply_circuit!(Hgate, state) + + circuit = shift(QFTModUCircuit(N, astore[2*n-i], rastore[2*n-i]), 1) + + # println(""max min site $(max_site(circuit.data)), $(min_site(circuit.data))."") + + # println(""number of gates $(length(circuit))."") + # circuit = fuse_gate(circuit) + # println(""number of gates after gate fusion $(length(circuit))."") + + apply_circuit!(circuit, state) + + # apply rorate + rot = gate(control_site, [1. 0.; 0. exp(-pi*im*to_digits(reverse(r)))]) + apply_circuit!(rot, state) + + apply_circuit!(Hgate, state) + + istate, probability = apply_circuit!(observer, state) + + push!(r, istate) + + (verbosity >= 2) && println(""measurement outcome at $i-th step is $istate."") + end + + y = sum([(r[2 * n - i]*1. / (1 << (i + 1))) for i in 0:(2 * n-1)]) + return y + + # numerator, d = continuous_fraction(y, Ni-1) + # (verbosity >= 1) && println(""numerator is $numerator, denominator is $d."") + # + # (modular_pow(ai, d, Ni)==1) && return d + # (verbosity >= 2) && println(""order finding failed."") + # + # println(""fraction is $y."") + # return -1 +end + +function scq_order_finding_by_qft(::Type{T}, a::Int, N::Int; verbosity::Int=1) where {T<:Number} + L = max(length(digits(a, base=2)), length(digits(N, base=2))) + state = StateVector(T, 2*L+3) + apply_circuit!(gate(2*L+2, X), state) + return order_finding_by_qft_impl(BinaryInteger(a, L), BinaryInteger(N, L), state; verbosity=verbosity) +end + +"""""" + see reference + using the one control qubit trick + ""Implementation of Shor’s Algorithm on a Linear Nearest Neighbour Qubit Array"" + n = len(a)-1 = len(N)-1 + 2*n+4 qubits is needed + x[0] + x[1] + ... + x[n-2] + MS + x[n-1] n + ki + kx + b[0] + b[1] + ... + b[n] +"""""" +function order_finding_by_lnn_impl(a::BinaryInteger, N::BinaryInteger, state; verbosity::Int=1) + # assert(driver in ['lnn']) + ai = get_value(a) + Ni = get_value(N) + (ai==1) && error(""the input a can not be 1."") + (Ni==1) && error(""the input N can not be 1."") + + (gcd(ai, Ni)==1) || error(""a and N are not co-prime to each other."") + # precision = 2**(-2*nmax-1) + n = length(a) + L = n+1 + + a = BinaryInteger(get_value(a), L) + N = BinaryInteger(get_value(N), L) + (verbosity >= 3) && println(""n=$n, total number of qubits $(2*n+4)."") + + observer = QMeasure(n+2, auto_reset=true) + + ra = modular_inverse(a, N) + + qft_circuit = shift(_QFT(L), n+4) + + apply_circuit!(qft_circuit, state) + + Hgate = gate(n+2, H) + + apply_circuit!(Hgate, state) + + astore = [] + rastore = [] + for i in 1:2*n + push!(astore, a) + push!(rastore, ra) + a = modular_multiply(a, a, N) + ra = modular_multiply(ra, ra, N) + end + + r = [] + for i in 0:(2*n-1) + apply_circuit!(Hgate, state) + + circuit = shift(LNNModUCircuit(N, astore[2*n-i], rastore[2*n-i]), 1) + + # println(""max min site $(max_site(circuit.data)), $(min_site(circuit.data))."") + + # println(""number of gates $(length(circuit))."") + # circuit = fuse_gate(circuit) + # println(""number of gates after gate fusion $(length(circuit))."") + + apply_circuit!(circuit, state) + + # apply rorate + rot = gate(n+2, [1. 0.; 0. exp(-pi*im*to_digits(reverse(r)))]) + apply_circuit!(rot, state) + + apply_circuit!(Hgate, state) + + istate, probability = apply_circuit!(observer, state) + + push!(r, istate) + + (verbosity >= 2) && println(""measurement outcome at $i-th step is $istate."") + end + + y = sum([(r[2 * n - i]*1. / (1 << (i + 1))) for i in 0:(2 * n-1)]) + return y + # println(""fraction is $y."") + # return -1 +end + +function scq_order_finding_by_lnn(::Type{T}, a::Int, N::Int; verbosity::Int=1) where {T<:Number} + L = max(length(digits(a, base=2)), length(digits(N, base=2))) + state = StateVector(T, 2*L+4) + apply_circuit!(gate(L+1, X), state) + return order_finding_by_lnn_impl(BinaryInteger(a, L), BinaryInteger(N, L), state; verbosity=verbosity) +end + +"""""" + quantum order finding algorithm using single control qubits technique. +"""""" +function order_finding_scq(::Type{T}, a::Int, N::Int; algorithm::Symbol=:lnn, verbosity::Int=1) where {T<:Number} + if algorithm == :lnn + return scq_order_finding_by_lnn(T, a, N; verbosity=verbosity) + elseif algorithm == :qft + return scq_order_finding_by_qft(T, a, N; verbosity=verbosity) + else + error(""algorithm $algorithm not implemented."") + end +end +","Julia" +"Conjugate","guochu/VQC.jl","src/auxiliary/tensorops.jl",".jl","1375","53"," +function swap!(qstate::AbstractVector, i::Int, j::Int) + (i == j) && return + if i < j + fsize = 2^(i-1) + msize = 2^(j-i-1) + bsize = div(length(qstate), (fsize*4*msize)) + s = reshape(qstate, (fsize, 2, msize, 2, bsize)) + + # tmp = Tensor{T}(undef, fsize, msize, bsize) + tmp = s[:, 1, :, 2, :] + s[:, 1, :, 2, :] = s[:, 2, :, 1, :] + s[:, 2, :, 1, :] = tmp + else + swap!(qstate, j, i) + end +end + +function _entropy(v::AbstractVector{<:Real}) + a = [(abs(item) <= 1.0e-12) ? 0. : item for item in v] + a = [item for item in a if (item != 0.)] + s = sum(a) + a ./= s + return -dot(a, log2.(a)) +end + +function entropy(v::AbstractArray{T, 1}) where {T <: Real} + a = _check_and_filter(v) + return -dot(a, log2.(a)) +end + +function renyi_entropy(v::AbstractArray{T, 1}; α::Real=1) where T + α = convert(T, α) + if α==one(α) + return entropy(v) + else + a = _check_and_filter(v) + a = v.^(α) + return (1/(1-α)) * log2(sum(a)) + end +end + + +function _check_and_filter(v::AbstractArray{<:Real}; tol::Real=1.0e-12) + (abs(sum(v) - 1) <= tol) || throw(ArgumentError(""sum of singular values not equal to 1"")) + oo = zero(eltype(v)) + tol = convert(eltype(v), tol) + for item in v + ((item < oo) && (-item > tol)) && throw(ArgumentError(""negative singular values"")) + end + # return [(abs(item) <= tol) ? oo : item for item in v] + return [item for item in v if abs(item) > tol] +end","Julia" +"Conjugate","guochu/VQC.jl","src/auxiliary/parallel_for.jl",".jl","2144","62","using Base.Threads + +const MIN_SIZE = 1024 + + +get_size_1(total_itr::Int, n_threads::Int, thread_id::Int) = div(total_itr * thread_id, n_threads) +get_size_2(total_itr::Int, n_threads::Int, thread_id::Int) = div(total_itr * (thread_id + 1), n_threads) + +"""""" + The inner function f is assumed to be Zero Based +"""""" +function parallel_run(total_itr::Int, n_threads::Int, f::Function, args...) + if (total_itr >= MIN_SIZE) && (n_threads > 1) + # nave, resi, jobs = partition_jobs(total_itr, n_threads) + Threads.@threads for thread_id in 0:(n_threads-1) + ist = get_size_1(total_itr, n_threads, thread_id) + ifn = get_size_2(total_itr, n_threads, thread_id) - 1 + f(ist, ifn, args...) + end + else + f(0, total_itr-1, args...) + end +end + +"""""" + The inner function f is assumed to be Zero Based +"""""" +function parallel_sum(::Type{T}, total_itr::Int, n_threads::Int, f::Function, args...) where {T<:Real} + if (total_itr >= MIN_SIZE) && (n_threads > 1) + # nave, resi, jobs = partition_jobs(total_itr, n_threads) + r = Atomic{T}(0) + Threads.@threads for thread_id in 0:(n_threads-1) + ist = get_size_1(total_itr, n_threads, thread_id) + ifn = get_size_2(total_itr, n_threads, thread_id) - 1 + atomic_add!(r, f(ist, ifn, args...)) + end + return r[] + else + return f(0, total_itr-1, args...) + end +end + + +function parallel_sum(::Type{T}, total_itr::Int, n_threads::Int, f::Function, args...) where {T<:Complex} + if (total_itr >= MIN_SIZE) && (n_threads > 1) + # nave, resi, jobs = partition_jobs(total_itr, n_threads) + RT = real(T) + rr = Atomic{RT}(0) + ri = Atomic{RT}(0) + Threads.@threads for thread_id in 0:(n_threads-1) + ist = get_size_1(total_itr, n_threads, thread_id) + ifn = get_size_2(total_itr, n_threads, thread_id) - 1 + tmp = f(ist, ifn, args...) + atomic_add!(rr, real(tmp)) + atomic_add!(ri, imag(tmp)) + end + return Complex(rr[], ri[]) + else + return f(0, total_itr-1, args...) + end +end +","Julia" +"Conjugate","guochu/VQC.jl","src/auxiliary/distance.jl",".jl","168","11"," +function _distance2(x, y) + sA = real(dot(x, x)) + sB = real(dot(y, y)) + c = dot(x, y) + r = sA+sB-2*real(c) + return abs(r) +end + +_distance(x, y) = sqrt(_distance2(x, y)) +","Julia" +"Conjugate","guochu/VQC.jl","src/auxiliary/sampling.jl",".jl","313","18"," +function discrete_sample(l::Vector{Float64}) + isempty(l) && error(""no results."") + s = sum(l) + L = length(l) + l1 = Vector{Float64}(undef, L+1) + l1[1] = 0 + for i=1:L + l1[i+1] = l1[i] + l[i]/s + end + s = rand(Float64) + for i = 1:L + if (s >= l1[i] && s < l1[i+1]) + return i + end + end + return L +end","Julia" +"Conjugate","guochu/VQC.jl","src/auxiliary/indexop.jl",".jl","1509","75"," + +"""""" + move_selected_index_forward(a, I) + move the indexes specified by I to the front of a + # Arguments + @ a::NTuple{N, Int}: the input tensor. + @ I: tuple or vector of integer. +"""""" +function move_selected_index_forward(a::Vector{T}, I) where {T} + na = length(a) + nI = length(I) + b = Vector{T}(undef, na) + k1 = 0 + k2 = nI + for i=1:na + s = 0 + while s != nI + if i == I[s+1] + b[s+1] = a[k1+1] + k1 += 1 + break + end + s += 1 + end + if s == nI + b[k2+1]=a[k1+1] + k1 += 1 + k2 += 1 + end + end + return b +end + +function move_selected_index_forward(a::NTuple{N, T}, I) where {N, T} + return NTuple{N, T}(move_selected_index_forward([a...], I)) +end + +"""""" + move_selected_index_backward(a, I) + move the indexes specified by I to the back of a + # Arguments + @ a::NTuple{N, Int}: the input tensor. + @ I: tuple or vector of integer. +"""""" +function move_selected_index_backward(a::Vector{T}, I) where {T} + na = length(a) + nI = length(I) + nr = na - nI + b = Vector{T}(undef, na) + k1 = 0 + k2 = 0 + for i = 1:na + s = 0 + while s != nI + if i == I[s+1] + b[nr+s+1] = a[k1+1] + k1 += 1 + break + end + s += 1 + end + if s == nI + b[k2+1] = a[k1+1] + k2 += 1 + k1 += 1 + end + end + return b +end + +function move_selected_index_backward(a::NTuple{N, T}, I) where {N, T} + return NTuple{N, T}(move_selected_index_backward([a...], I)) +end +","Julia" +"Conjugate","guochu/VQC.jl","src/hamiltonian/util.jl",".jl","1030","44"," + +_get_mat(x::Tuple{Vector{AbstractMatrix}, Number}) = QuantumCircuits._kron_ops(reverse(x[1])) * x[2] +_get_mat(x::QubitsTerm) = QuantumCircuits._kron_ops(reverse(oplist(x))) * coeff(x) + +function _get_mat(n::Int, x::QuantumCircuits.QOP_DATA_VALUE_TYPE) + isempty(x) && error(""bond is empty."") + m = zeros(_scalar_type(x), 2^n, 2^n) + for item in x + tmp = QuantumCircuits._kron_ops(reverse(item[1])) + alpha = item[2] + @. m += alpha * tmp + end + return m +end + + +function _scalar_type(x::QuantumCircuits.QOP_DATA_VALUE_TYPE) + T = Int + for (k, coef) in x + T = promote_type(T, typeof(coef)) + for item in k + T = promote_type(T, eltype(item)) + end + end + return T +end + + +function LinearAlgebra.ishermitian(x::QubitsTerm) + (imag(coeff(x)) ≈ 0.) || return false + for item in oplist(x) + ishermitian(item) || return false + end + return true +end +function LinearAlgebra.ishermitian(x::QubitsOperator) + for (k, v) in x.data + m = _get_mat(length(k), v) + ishermitian(m) || return false + end + return true +end +","Julia" +"Conjugate","guochu/VQC.jl","src/hamiltonian/expecs_dm/expecs_dm.jl",".jl","585","28"," +include(""expec_dm_serial.jl"") +include(""apply_qterms_dm.jl"") + + + +function expectation(m::QubitsTerm, state::DensityMatrix) + isempty(m) && return tr(state) + if length(positions(m)) <= 3 + return expectation_value_serial(Tuple(positions(m)), _get_mat(m), storage(state)) + else + return tr(m * state) + end +end + + +function expectation(m::QubitsOperator, state::DensityMatrix) + if _largest_nterm(m) <= 3 + r = zero(eltype(state)) + for (k, v) in m.data + r += expectation_value_serial(k, _get_mat(length(k), v), storage(state)) + end + return r + else + return tr(m * state) + end +end +","Julia" +"Conjugate","guochu/VQC.jl","src/hamiltonian/expecs_dm/apply_qterms_dm.jl",".jl","713","34"," + + +# apply hamiltonian term on density matrix + + +function (m::QubitsTerm)(vr::DensityMatrix) + v = vr.data + vout = similar(v) + _apply_qterm_util!(m, v, vout) + return DensityMatrix(vout, nqubits(vr)) +end + +function (m::QubitsOperator)(vr::DensityMatrix) + v = vr.data + vout = zeros(eltype(v), length(v)) + if _largest_nterm(m) <= LARGEST_SUPPORTED_NTERMS + _apply_util!(m, v, vout) + else + workspace = similar(v) + for (k, dd) in m.data + for item in dd + _apply_qterm_util!(QubitsTerm(k, item[1], item[2]), v, workspace) + vout .+= workspace + end + end + end + return DensityMatrix(vout, nqubits(vr)) +end + + +Base.:*(m::QubitsOperator, v::DensityMatrix) = m(v) +Base.:*(m::QubitsTerm, v::DensityMatrix) = m(v) +","Julia" +"Conjugate","guochu/VQC.jl","src/hamiltonian/expecs_dm/expec_dm_serial.jl",".jl","7876","182"," +@inline get_2_by_2(state::AbstractMatrix, posa::Int, posb::Int) = SMatrix{2,2}(state[posa, posa], state[posb, posa], state[posa, posb], state[posb, posb]) + +@inline function get_4_by_4(state::AbstractMatrix, pos1::Int, pos2::Int, pos3::Int, pos4::Int) + return SMatrix{4,4}(state[pos1, pos1], state[pos2, pos1], state[pos3, pos1], state[pos4, pos1], + state[pos1, pos2], state[pos2, pos2], state[pos3, pos2], state[pos4, pos2], + state[pos1, pos3], state[pos2, pos3], state[pos3, pos3], state[pos4, pos3], + state[pos1, pos4], state[pos2, pos4], state[pos3, pos4], state[pos4, pos4]) +end + +@inline function get_8_by_8(state::AbstractMatrix, pos1::Int, pos2::Int, pos3::Int, pos4::Int, pos5::Int, pos6::Int, pos7::Int, pos8::Int) + return SMatrix{8,8}(state[pos1, pos1], state[pos2, pos1], state[pos3, pos1], state[pos4, pos1], state[pos5, pos1], state[pos6, pos1], state[pos7, pos1], state[pos8, pos1], + state[pos1, pos2], state[pos2, pos2], state[pos3, pos2], state[pos4, pos2], state[pos5, pos2], state[pos6, pos2], state[pos7, pos2], state[pos8, pos2], + state[pos1, pos3], state[pos2, pos3], state[pos3, pos3], state[pos4, pos3], state[pos5, pos3], state[pos6, pos3], state[pos7, pos3], state[pos8, pos3], + state[pos1, pos4], state[pos2, pos4], state[pos3, pos4], state[pos4, pos4], state[pos5, pos4], state[pos6, pos4], state[pos7, pos4], state[pos8, pos4], + state[pos1, pos5], state[pos2, pos5], state[pos3, pos5], state[pos4, pos5], state[pos5, pos5], state[pos6, pos5], state[pos7, pos5], state[pos8, pos5], + state[pos1, pos6], state[pos2, pos6], state[pos3, pos6], state[pos4, pos6], state[pos5, pos6], state[pos6, pos6], state[pos7, pos6], state[pos8, pos6], + state[pos1, pos7], state[pos2, pos7], state[pos3, pos7], state[pos4, pos7], state[pos5, pos7], state[pos6, pos7], state[pos7, pos7], state[pos8, pos7], + state[pos1, pos8], state[pos2, pos8], state[pos3, pos8], state[pos4, pos8], state[pos5, pos8], state[pos6, pos8], state[pos7, pos8], state[pos8, pos8]) +end + + +function _expectation_value_util(pos::Int, m::AbstractMatrix, state::AbstractMatrix) + (size(m, 1) == size(m, 2)) || error(""observable must be a square matrix."") + (size(m, 1) == 2) || error(""input must be a 2 by 2 matrix."") + sj = 2 + s1 = 2^(pos-1) + s2 = s1 * sj + L = size(state, 1) + r = zero(eltype(state)) + for i in 0:s2:(L-1) + for j in 0:(s1-1) + pos_start = i + j + 1 + v = get_2_by_2(state, pos_start, pos_start + s1) + @fastmath r += tr(m * v) + end + end + return r +end + +# function _expectation_value_util(pos::Int, m::AbstractMatrix, state::AbstractMatrix, state_c::AbstractMatrix) +# (size(m, 1) == size(m, 2)) || error(""observable must be a square matrix."") +# (size(m, 1) == 2) || error(""input must be a 2 by 2 matrix."") +# sj = 2 +# s1 = 2^(pos-1) +# s2 = s1 * sj +# L = size(state, 1) +# r = zero(eltype(state)) +# for i in 0:s2:(L-1) +# for j in 0:(s1-1) +# pos_start = i + j + 1 +# pos_b = pos_start + s1 +# v = get_2_by_2(state, pos_start, pos_b) +# v_c = get_2_by_2(state_c, pos_start, pos_b) +# @fastmath r += dot(v_c, m, v) +# end +# end +# return r +# end + +function _expectation_value_util(key::Tuple{Int, Int}, m::AbstractMatrix, v::AbstractMatrix) + (size(m, 1) == size(m, 2)) || error(""observable must be a square matrix."") + (size(m, 1) == 4) || error(""input must be a 4 by 4 matrix."") + L = size(v, 1) + q1, q2 = key + pos1, pos2 = 2^(q1-1), 2^(q2-1) + stride1, stride2 = 2 * pos1, 2 * pos2 + r = zero(eltype(v)) + for i in 0:stride2:(L-1) + for j in 0:stride1:(pos2-1) + @inbounds for k in 0:(pos1-1) + l = i + j + k + 1 + vi = get_4_by_4(v, l, l + pos1, l + pos2, l + pos1 + pos2) + @fastmath r += tr(m * vi) + end + end + end + return r +end + + +# function _expectation_value_util(key::Tuple{Int, Int}, m::AbstractMatrix, v::AbstractMatrix, v_c::AbstractMatrix) +# (size(m, 1) == size(m, 2)) || error(""observable must be a square matrix."") +# (size(m, 1) == 4) || error(""input must be a 4 by 4 matrix."") +# L = size(v, 1) +# q1, q2 = key +# pos1, pos2 = 2^(q1-1), 2^(q2-1) +# stride1, stride2 = 2 * pos1, 2 * pos2 +# r = zero(eltype(v)) +# for i in 0:stride2:(L-1) +# for j in 0:stride1:(pos2-1) +# @inbounds for k in 0:(pos1-1) +# l = i + j + k + 1 +# vi = get_4_by_4(v, l, l + pos1, l + pos2, l + pos1 + pos2) +# vi_c = get_4_by_4(v_c, l, l + pos1, l + pos2, l + pos1 + pos2) +# @fastmath r += dot(vi_c, m, vi) +# end +# end +# end +# return r +# end + +function _expectation_value_util(key::Tuple{Int, Int, Int}, m::AbstractMatrix, v::AbstractMatrix) + L = size(v, 1) + q1, q2, q3 = key + pos1, pos2, pos3 = 2^(q1-1), 2^(q2-1), 2^(q3-1) + stride1, stride2, stride3 = 2 * pos1, 2 * pos2, 2 * pos3 + r = zero(eltype(v)) + for h in 0:stride3:(L-1) + for i in 0:stride2:(pos3-1) + for j in 0:stride1:(pos2-1) + @inbounds for k in 0:(pos1-1) + l000 = h + i + j + k + 1 + l100 = l000 + pos1 + l010 = l000 + pos2 + l110 = l010 + pos1 + + l001 = l000 + pos3 + l101 = l001 + pos1 + l011 = l001 + pos2 + l111 = l011 + pos1 + vi = get_8_by_8(v, l000, l100, l010, l110, l001, l101, l011, l111) + @fastmath r += tr(m * vi) + end + end + end + end + return r +end + + +# function _expectation_value_util(key::Tuple{Int, Int, Int}, m::AbstractMatrix, v::AbstractMatrix, v_c::AbstractMatrix) +# L = size(v, 1) +# q1, q2, q3 = key +# pos1, pos2, pos3 = 2^(q1-1), 2^(q2-1), 2^(q3-1) +# stride1, stride2, stride3 = 2 * pos1, 2 * pos2, 2 * pos3 +# r = zero(eltype(v)) +# for h in 0:stride3:(L-1) +# for i in 0:stride2:(pos3-1) +# for j in 0:stride1:(pos2-1) +# @inbounds for k in 0:(pos1-1) +# l000 = h + i + j + k + 1 +# l100 = l000 + pos1 +# l010 = l000 + pos2 +# l110 = l010 + pos1 + +# l001 = l000 + pos3 +# l101 = l001 + pos1 +# l011 = l001 + pos2 +# l111 = l011 + pos1 +# vi = get_8_by_8(v, l000, l100, l010, l110, l001, l101, l011, l111) +# vi_c = get_8_by_8(v_c, l000, l100, l010, l110, l001, l101, l011, l111) +# @fastmath r += dot(vi_c, m, vi) +# end +# end +# end +# end +# return r +# end + +# expectation_value_serial(pos::Int, m::AbstractMatrix, state::AbstractMatrix, state_c::AbstractMatrix) = _expectation_value_util( +# pos, SMatrix{2,2, eltype(state)}(m), state, state_c) +expectation_value_serial(pos::Int, m::AbstractMatrix, state::AbstractMatrix) = _expectation_value_util( + pos, SMatrix{2,2, eltype(state)}(m), state) + + +# expectation_value_serial(pos::Tuple{Int}, m::AbstractMatrix, state::AbstractMatrix, state_c::AbstractMatrix) = expectation_value_serial( +# pos[1], m, state, state_c) +expectation_value_serial(pos::Tuple{Int}, m::AbstractMatrix, state::AbstractMatrix) = expectation_value_serial( + pos[1], m, state) + +# expectation_value_serial(pos::Tuple{Int, Int}, m::AbstractMatrix, state::AbstractMatrix, state_c::AbstractMatrix) = _expectation_value_util( +# pos, SMatrix{4,4, eltype(state)}(m), state, state_c) +expectation_value_serial(pos::Tuple{Int, Int}, m::AbstractMatrix, state::AbstractMatrix) = _expectation_value_util( + pos, SMatrix{4,4, eltype(state)}(m), state) + +# expectation_value_serial(pos::Tuple{Int, Int, Int}, m::AbstractMatrix, state::AbstractMatrix, state_c::AbstractMatrix) = _expectation_value_util( +# pos, m, state, state_c) +expectation_value_serial(pos::Tuple{Int, Int, Int}, m::AbstractMatrix, state::AbstractMatrix) = _expectation_value_util( + pos, SMatrix{8,8, eltype(state)}(m), state) + +","Julia" +"Conjugate","guochu/VQC.jl","src/hamiltonian/expecs/expec_high_qubit_terms.jl",".jl","4926","127"," + +function _expectation_value_fourbody_util(key::Tuple{Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) + L = length(v) + q1, q2, q3, q4 = key + pos1, pos2, pos3, pos4 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1), 1 << (q4-1) + # stride2, stride3 = pos1 << 1, pos2 << 1 + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(pos3 - 1, 2 * pos2 - 1) + mask3 = xor(pos4 - 1, 2 * pos3 - 1) + mask4 = xor(L - 1, 2 * pos4 - 1) + # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"") + + + function f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, posd::Int, m1::Int, m2::Int, m3::Int, + m4::Int, m5::Int, mat::AbstractMatrix, p::AbstractVector) + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l0000 = (16 * i & m5) | (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1 + l1000 = l0000 + posa + l0100 = l0000 + posb + l0010 = l0000 + posc + l0001 = l0000 + posd + + l1100 = l0100 + posa + l1010 = l0010 + posa + l1001 = l1000 + posd + l0110 = l0010 + posb + l0101 = l0100 + posd + l0011 = l0010 + posd + + l1110 = l1100 + posc + l1101 = l1100 + posd + l1011 = l1010 + posd + l0111 = l0110 + posd + + l1111 = l1110 + posd + + vi = SVector(p[l0000], p[l1000], p[l0100], p[l1100], p[l0010], p[l1010], p[l0110], p[l1110], + p[l0001], p[l1001], p[l0101], p[l1101], p[l0011], p[l1011], p[l0111], p[l1111]) + + @fastmath r += dot(vi, mat, vi) + end + return r + end + total_itr = div(L, 16) + return parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, pos1, pos2, pos3, pos4, mask0, mask1, mask2, mask3, mask4, U, v) +end + +expectation_value_threaded(key::Tuple{Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) = _expectation_value_fourbody_util( + key, SMatrix{16,16, eltype(v)}(U), v) + + +function _expectation_value_fivebody_util(key::Tuple{Int, Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) + L = length(v) + q1, q2, q3, q4, q5 = key + pos1, pos2, pos3, pos4, pos5 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1), 1 << (q4-1), 1 << (q5-1) + # stride2, stride3 = pos1 << 1, pos2 << 1 + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(pos3 - 1, 2 * pos2 - 1) + mask3 = xor(pos4 - 1, 2 * pos3 - 1) + mask4 = xor(pos5 - 1, 2 * pos4 - 1) + mask5 = xor(L - 1, 2 * pos5 - 1) + # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"") + + function f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, posd::Int, pose::Int, + m1::Int, m2::Int, m3::Int, m4::Int, m5::Int, m6::Int, mat::AbstractMatrix, p::AbstractVector) + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l00000 = (32 * i & m6) | (16 * i & m5) | (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1 + l10000 = l00000 + posa + l01000 = l00000 + posb + l00100 = l00000 + posc + l00010 = l00000 + posd + l00001 = l00000 + pose + + l11000 = l01000 + posa + l10100 = l00100 + posa + l10010 = l10000 + posd + l10001 = l10000 + pose + l01100 = l00100 + posb + l01010 = l01000 + posd + l01001 = l01000 + pose + l00110 = l00100 + posd + l00101 = l00100 + pose + l00011 = l00010 + pose + + + l11100 = l11000 + posc + l11010 = l11000 + posd + l11001 = l11000 + pose + l10110 = l10100 + posd + l10101 = l10100 + pose + l10011 = l10010 + pose + l01110 = l01100 + posd + l01101 = l01100 + pose + l01011 = l01010 + pose + l00111 = l00110 + pose + + l11110 = l11100 + posd + l11101 = l11100 + pose + l11011 = l11010 + pose + l10111 = l10110 + pose + l01111 = l01110 + pose + + l11111 = l11110 + pose + + vi = SVector(p[l00000], p[l10000], p[l01000], p[l11000], p[l00100], p[l10100], p[l01100], p[l11100], + p[l00010], p[l10010], p[l01010], p[l11010], p[l00110], p[l10110], p[l01110], p[l11110], + p[l00001], p[l10001], p[l01001], p[l11001], p[l00101], p[l10101], p[l01101], p[l11101], + p[l00011], p[l10011], p[l01011], p[l11011], p[l00111], p[l10111], p[l01111], p[l11111]) + + + @fastmath r += dot(vi, mat, vi) + end + return r + end + total_itr = div(L, 32) + parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, pos1, pos2, pos3, pos4, pos5, mask0, mask1, mask2, mask3, mask4, mask5, U, v) +end + + +expectation_value_threaded(key::Tuple{Int, Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) = _expectation_value_fivebody_util( + key, SMatrix{32,32, eltype(v)}(U), v) +","Julia" +"Conjugate","guochu/VQC.jl","src/hamiltonian/expecs/expec_serial.jl",".jl","4890","130"," +function _expectation_value_util(pos::Int, m::AbstractMatrix, state::AbstractVector) + (size(m, 1) == size(m, 2)) || error(""observable must be a square matrix."") + (size(m, 1) == 2) || error(""input must be a 2 by 2 matrix."") + sj = 2 + s1 = 2^(pos-1) + s2 = s1 * sj + r = zero(eltype(state)) + for i in 0:s2:(length(state)-1) + for j in 0:(s1-1) + pos_start = i + j + 1 + v = SVector(state[pos_start], state[pos_start + s1]) + @fastmath r += dot(v, m, v) + end + end + return r +end + +function _expectation_value_util(pos::Int, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) + (size(m, 1) == size(m, 2)) || error(""observable must be a square matrix."") + (size(m, 1) == 2) || error(""input must be a 2 by 2 matrix."") + sj = 2 + s1 = 2^(pos-1) + s2 = s1 * sj + r = zero(eltype(state)) + for i in 0:s2:(length(state)-1) + for j in 0:(s1-1) + pos_start = i + j + 1 + v = SVector(state[pos_start], state[pos_start + s1]) + v_c = SVector(state_c[pos_start], state_c[pos_start + s1]) + @fastmath r += dot(v_c, m, v) + end + end + return r +end + +function _expectation_value_util(key::Tuple{Int, Int}, m::AbstractMatrix, v::AbstractVector) + (size(m, 1) == size(m, 2)) || error(""observable must be a square matrix."") + (size(m, 1) == 4) || error(""input must be a 4 by 4 matrix."") + L = length(v) + q1, q2 = key + pos1, pos2 = 2^(q1-1), 2^(q2-1) + stride1, stride2 = 2 * pos1, 2 * pos2 + r = zero(eltype(v)) + for i in 0:stride2:(L-1) + for j in 0:stride1:(pos2-1) + @inbounds for k in 0:(pos1-1) + l = i + j + k + 1 + vi = SVector(v[l], v[l + pos1], v[l + pos2], v[l + pos1 + pos2]) + @fastmath r += dot(vi, m, vi) + end + end + end + return r +end + + +function _expectation_value_util(key::Tuple{Int, Int}, m::AbstractMatrix, v::AbstractVector, v_c::AbstractVector) + (size(m, 1) == size(m, 2)) || error(""observable must be a square matrix."") + (size(m, 1) == 4) || error(""input must be a 4 by 4 matrix."") + L = length(v) + q1, q2 = key + pos1, pos2 = 2^(q1-1), 2^(q2-1) + stride1, stride2 = 2 * pos1, 2 * pos2 + r = zero(eltype(v)) + for i in 0:stride2:(L-1) + for j in 0:stride1:(pos2-1) + @inbounds for k in 0:(pos1-1) + l = i + j + k + 1 + vi = SVector(v[l], v[l + pos1], v[l + pos2], v[l + pos1 + pos2]) + vi_c = SVector(v_c[l], v_c[l + pos1], v_c[l + pos2], v_c[l + pos1 + pos2]) + @fastmath r += dot(vi_c, m, vi) + end + end + end + return r +end + + +function _expectation_value_util(key::Tuple{Int, Int, Int}, m::AbstractMatrix, v::AbstractVector, v_c::AbstractVector) + L = length(v) + q1, q2, q3 = key + pos1, pos2, pos3 = 2^(q1-1), 2^(q2-1), 2^(q3-1) + stride1, stride2, stride3 = 2 * pos1, 2 * pos2, 2 * pos3 + r = zero(eltype(v)) + for h in 0:stride3:(L-1) + for i in 0:stride2:(pos3-1) + for j in 0:stride1:(pos2-1) + @inbounds for k in 0:(pos1-1) + l000 = h + i + j + k + 1 + l100 = l000 + pos1 + l010 = l000 + pos2 + l110 = l010 + pos1 + + l001 = l000 + pos3 + l101 = l001 + pos1 + l011 = l001 + pos2 + l111 = l011 + pos1 + vi = SVector(v[l000], v[l100], v[l010], v[l110], v[l001], v[l101], v[l011], v[l111]) + vi_c = SVector(v_c[l000], v_c[l100], v_c[l010], v_c[l110], v_c[l001], v_c[l101], v_c[l011], v_c[l111]) + @fastmath r += dot(vi_c, m, vi) + end + end + end + end + return r +end + +expectation_value_serial(pos::Int, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = _expectation_value_util( + pos, SMatrix{2,2, eltype(state)}(m), state, state_c) +expectation_value_serial(pos::Int, m::AbstractMatrix, state::AbstractVector) = _expectation_value_util( + pos, SMatrix{2,2, eltype(state)}(m), state) + + +expectation_value_serial(pos::Tuple{Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = expectation_value_serial( + pos[1], m, state, state_c) +expectation_value_serial(pos::Tuple{Int}, m::AbstractMatrix, state::AbstractVector) = expectation_value_serial( + pos[1], m, state) + +expectation_value_serial(pos::Tuple{Int, Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = _expectation_value_util( + pos, SMatrix{4,4, eltype(state)}(m), state, state_c) +expectation_value_serial(pos::Tuple{Int, Int}, m::AbstractMatrix, state::AbstractVector) = _expectation_value_util( + pos, SMatrix{4,4, eltype(state)}(m), state) + +expectation_value_serial(pos::Tuple{Int, Int, Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = _expectation_value_util( + pos, m, state, state_c) +expectation_value_serial(pos::Tuple{Int, Int, Int}, m::AbstractMatrix, state::AbstractVector) = expectation_value_serial( + pos, m, state, state) + +","Julia" +"Conjugate","guochu/VQC.jl","src/hamiltonian/expecs/expec_threaded.jl",".jl","25008","654"," +"""""" + applys when key > 3, U is the transposed op +"""""" +function _expectation_value_util_H(key::Int, U::AbstractMatrix, v::AbstractVector) + L = length(v) + sizek = 1 << (key - 1) + mask0 = sizek - 1 + mask1 = xor(L - 1, 2 * sizek - 1) + f(ist::Int, ifn::Int, pos::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (16 * i & m2) | (8 * i & m1) + 1 + l1 = l + pos + vi = SMatrix{8, 2}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7]) + + vi_t = transpose(vi) + @fastmath r += dot(vi_t, mat, vi_t) + end + return r + end + + return parallel_sum(eltype(v), div(L, 16), Threads.nthreads(), f, sizek, mask0, mask1, U, v) +end + +"""""" + applys when key <= 3, U is the transposed op +"""""" +function _expectation_value_util_L(key::Int, U::AbstractMatrix, v::AbstractVector) + L = length(v) + f1(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 16 * i + 1 + vi = SMatrix{2, 8}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15]) + + @fastmath r += dot(vi, mat, vi) + end + return r + end + f2(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 16 * i + 1 + vi = SMatrix{2, 8}(p[l], p[l+2], p[l+1], p[l+3], p[l+4], p[l+6], p[l+5], p[l+7], + p[l+8], p[l+10], p[l+9], p[l+11], p[l+12], p[l+14], p[l+13], p[l+15]) + + @fastmath r += dot(vi, mat, vi) + end + return r + end + f3(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 16 * i + 1 + vi = SMatrix{2, 8}(p[l], p[l+4], p[l+1], p[l+5], p[l+2], p[l+6], p[l+3], p[l+7], + p[l+8], p[l+12], p[l+9], p[l+13], p[l+10], p[l+14], p[l+11], p[l+15]) + + @fastmath r += dot(vi, mat, vi) + end + return r + end + if key == 1 + f = f1 + elseif key == 2 + f = f2 + elseif key == 3 + f = f3 + else + error(""qubit position $key not allowed for L."") + end + + parallel_sum(eltype(v), div(L, 16), Threads.nthreads(), f, U, v) +end + +function _expectation_value_threaded_util(q0::Int, U::AbstractMatrix, v::AbstractVector) + if q0 > 3 + return _expectation_value_util_H(q0, SMatrix{2,2, eltype(v)}(U), v) + else + return _expectation_value_util_L(q0, SMatrix{2,2, eltype(v)}(U), v) + end +end +_expectation_value_threaded_util(q0::Tuple{Int}, U::AbstractMatrix, v::AbstractVector) = _expectation_value_threaded_util( + q0[1], U, v) + + + +"""""" + applys when both keys > 3, U is the transposed op +"""""" +function _expectation_value_util_HH(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector) + L = length(v) + q1, q2 = key + pos1, pos2 = 1 << (q1-1), 1 << (q2-1) + # stride2, stride3 = pos1 << 1, pos2 << 1 + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(L - 1, 2 * pos2 - 1) + # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"") + + total_itr = div(L, 32) + f(ist::Int, ifn::Int, posa::Int, posb::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1) + 1 + # l = div(l, 2) + 1 + l1 = l + posa + l2 = l + posb + l3 = l2 + posa + # println(""l0=$l, l1=$l1, l2=$l2, l3=$l3"") + vi = SMatrix{8, 4}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7], + p[l2], p[l2+1], p[l2+2], p[l2+3], p[l2+4], p[l2+5], p[l2+6], p[l2+7], + p[l3], p[l3+1], p[l3+2], p[l3+3], p[l3+4], p[l3+5], p[l3+6], p[l3+7]) + + vi_t = transpose(vi) + @fastmath r += dot(vi_t, mat, vi_t) + end + return r + end + + parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, pos1, pos2, mask0, mask1, mask2, U, v) +end + + +"""""" + applys when q1 <= 3 and q2 > 4, U is the transposed op +"""""" +function _expectation_value_util_LH(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector) + L = length(v) + q1, q2 = key + sizej = 1 << (q2-1) + mask0 = sizej - 1 + mask1 = xor(L - 1, 2 * sizej - 1) + + f1H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{8, 4}(p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15], + p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16], + p[l1+1], p[l1+3], p[l1+5], p[l1+7], p[l1+9], p[l1+11], p[l1+13], p[l1+15], + p[l1+2], p[l1+4], p[l1+6], p[l1+8], p[l1+10], p[l1+12], p[l1+14], p[l1+16]) + + vi_t = transpose(vi) + @fastmath r += dot(vi_t, mat, vi_t) + end + return r + end + + f2H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14], + p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16], + p[l1+1], p[l1+2], p[l1+5], p[l1+6], p[l1+9], p[l1+10], p[l1+13], p[l1+14], + p[l1+3], p[l1+4], p[l1+7], p[l1+8], p[l1+11], p[l1+12], p[l1+15], p[l1+16]) + + vi_t = transpose(vi) + @fastmath r += dot(vi_t, mat, vi_t) + end + return r + end + + f3H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12], + p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16], + p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+9], p[l1+10], p[l1+11], p[l1+12], + p[l1+5], p[l1+6], p[l1+7], p[l1+8], p[l1+13], p[l1+14], p[l1+15], p[l1+16]) + + vi_t = transpose(vi) + @fastmath r += dot(vi_t, mat, vi_t) + end + return r + end + + if q1 == 1 + f = f1H + elseif q1 == 2 + f = f2H + elseif q1 == 3 + f = f3H + else + error(""qubit position $q1 not allowed for LH."") + end + total_itr = div(L, 32) + + parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, sizej, mask0, mask1, U, v) +end + +"""""" + applys when both keys <= 4 +"""""" +function _expectation_value_util_LL(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector) + L = length(v) + q1, q2 = key + f12(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 32 * i + 1 + vi = SMatrix{4, 8}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15], + p[l+16], p[l+17], p[l+18], p[l+19], p[l+20], p[l+21], p[l+22], p[l+23], + p[l+24], p[l+25], p[l+26], p[l+27], p[l+28], p[l+29], p[l+30], p[l+31]) + + @fastmath r += dot(vi, mat, vi) + end + return r + end + f13(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 32 * i + 1 + vi = SMatrix{4, 8}(p[l], p[l+1], p[l+4], p[l+5], p[l+2], p[l+3], p[l+6], p[l+7], + p[l+8], p[l+9], p[l+12], p[l+13], p[l+10], p[l+11], p[l+14], p[l+15], + p[l+16], p[l+17], p[l+20], p[l+21], p[l+18], p[l+19], p[l+22], p[l+23], + p[l+24], p[l+25], p[l+28], p[l+29], p[l+26], p[l+27], p[l+30], p[l+31]) + + @fastmath r += dot(vi, mat, vi) + end + return r + end + f14(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+9], p[l+10], p[l+3], p[l+4], p[l+11], p[l+12], + p[l+5], p[l+6], p[l+13], p[l+14], p[l+7], p[l+8], p[l+15], p[l+16], + p[l+17], p[l+18], p[l+25], p[l+26], p[l+19], p[l+20], p[l+27], p[l+28], + p[l+21], p[l+22], p[l+29], p[l+30], p[l+23], p[l+24], p[l+31], p[l+32]) + + @fastmath r += dot(vi, mat, vi) + end + return r + end + f23(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 32 * i + 1 + vi = SMatrix{4, 8}(p[l], p[l+2], p[l+4], p[l+6], p[l+1], p[l+3], p[l+5], p[l+7], + p[l+8], p[l+10], p[l+12], p[l+14], p[l+9], p[l+11], p[l+13], p[l+15], + p[l+16], p[l+18], p[l+20], p[l+22], p[l+17], p[l+19], p[l+21], p[l+23], + p[l+24], p[l+26], p[l+28], p[l+30], p[l+25], p[l+27], p[l+29], p[l+31]) + + @fastmath r += dot(vi, mat, vi) + end + return r + end + f24(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+9], p[l+11], p[l+2], p[l+4], p[l+10], p[l+12], + p[l+5], p[l+7], p[l+13], p[l+15], p[l+6], p[l+8], p[l+14], p[l+16], + p[l+17], p[l+19], p[l+25], p[l+27], p[l+18], p[l+20], p[l+26], p[l+28], + p[l+21], p[l+23], p[l+29], p[l+31], p[l+22], p[l+24], p[l+30], p[l+32]) + + @fastmath r += dot(vi, mat, vi) + end + return r + end + f34(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{4, 8}(p[l+1], p[l+5], p[l+9], p[l+13], p[l+2], p[l+6], p[l+10], p[l+14], + p[l+3], p[l+7], p[l+11], p[l+15], p[l+4], p[l+8], p[l+12], p[l+16], + p[l+17], p[l+21], p[l+25], p[l+29], p[l+18], p[l+22], p[l+26], p[l+30], + p[l+19], p[l+23], p[l+27], p[l+31], p[l+20], p[l+24], p[l+28], p[l+32]) + + @fastmath r += dot(vi, mat, vi) + end + return r + end + if q1==1 && q2 == 2 + f = f12 + elseif q1==1 && q2 == 3 + f = f13 + elseif q1==1 && q2 == 4 + f = f14 + elseif q1==2 && q2 == 3 + f = f23 + elseif q1==2 && q2 == 4 + f = f24 + elseif q1==3 && q2 == 4 + f = f34 + else + error(""qubit position $q1 and $q2 not allowed for LL."") + end + total_itr = div(L, 32) + + parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, U, v) +end + + +function _expectation_value_threaded_util(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector) + q0, q1 = key + if q0 > 3 + return _expectation_value_util_HH(key, SMatrix{4,4, eltype(v)}(U), v) + elseif q1 > 4 + return _expectation_value_util_LH(key, SMatrix{4,4, eltype(v)}(U), v) + else + return _expectation_value_util_LL(key, SMatrix{4,4, eltype(v)}(U), v) + end +end + + +"""""" + applys when both keys > 2, U is assumed to be transposed +"""""" +function _expectation_value_util_HHH(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) + L = length(v) + q1, q2, q3 = key + pos1, pos2, pos3 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1) + # stride2, stride3 = pos1 << 1, pos2 << 1 + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(pos3 - 1, 2 * pos2 - 1) + mask3 = xor(L - 1, 2 * pos3 - 1) + # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"") + + total_itr = div(L, 32) + f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, m4::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l000 = (32 * i & m4) | (16 * i & m3) | (8 * i & m2) | (4 * i & m1) + 1 + l100 = l000 + posa + l010 = l000 + posb + l110 = l010 + posa + + l001 = l000 + posc + l101 = l001 + posa + l011 = l001 + posb + l111 = l011 + posa + + # println(""$l000, $l100, $l010, $l110, $l001, $l101, $l011, $l111"") + vi = SMatrix{4, 8}(p[l000], p[l000+1], p[l000+2], p[l000+3], + p[l100], p[l100+1], p[l100+2], p[l100+3], + p[l010], p[l010+1], p[l010+2], p[l010+3], + p[l110], p[l110+1], p[l110+2], p[l110+3], + p[l001], p[l001+1], p[l001+2], p[l001+3], + p[l101], p[l101+1], p[l101+2], p[l101+3], + p[l011], p[l011+1], p[l011+2], p[l011+3], + p[l111], p[l111+1], p[l111+2], p[l111+3]) + + vi_t = transpose(vi) + + @fastmath r += dot(vi_t, mat, vi_t) + end + return r + end + + parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, pos1, pos2, pos3, mask0, mask1, mask2, mask3, U, v) +end + + +"""""" + applys when q1 <= 2 and q2 > 3, U is the transposed op +"""""" +function _expectation_value_util_LHH(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) + L = length(v) + q1, q2, q3 = key + sizej, sizel = 1 << (q2-1), 1 << (q3-1) + mask0 = sizej - 1 + mask1 = xor(sizel - 1, 2 * sizej - 1) + mask2 = xor(L-1, 2 * sizel - 1) + + f1H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1) + l1 = l + posb + l2 = l + posc + l3 = l2 + posb + # println(""$l, $l1, $l2, $l3"") + vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+5], p[l+7], + p[l+2], p[l+4], p[l+6], p[l+8], + p[l1+1], p[l1+3], p[l1+5], p[l1+7], + p[l1+2], p[l1+4], p[l1+6], p[l1+8], + p[l2+1], p[l2+3], p[l2+5], p[l2+7], + p[l2+2], p[l2+4], p[l2+6], p[l2+8], + p[l3+1], p[l3+3], p[l3+5], p[l3+7], + p[l3+2], p[l3+4], p[l3+6], p[l3+8]) + + vi_t = transpose(vi) + @fastmath r += dot(vi_t, mat, vi_t) + end + return r + end + + f2H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1) + l1 = l + posb + l2 = l + posc + l3 = l2 + posb + vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+5], p[l+6], + p[l+3], p[l+4], p[l+7], p[l+8], + p[l1+1], p[l1+2], p[l1+5], p[l1+6], + p[l1+3], p[l1+4], p[l1+7], p[l1+8], + p[l2+1], p[l2+2], p[l2+5], p[l2+6], + p[l2+3], p[l2+4], p[l2+7], p[l2+8], + p[l3+1], p[l3+2], p[l3+5], p[l3+6], + p[l3+3], p[l3+4], p[l3+7], p[l3+8]) + + vi_t = transpose(vi) + @fastmath r += dot(vi_t, mat, vi_t) + end + return r + end + + f3H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1) + l1 = l + posb + l2 = l + posc + l3 = l2 + posb + vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+3], p[l+4], + p[l+5], p[l+6], p[l+7], p[l+8], + p[l1+1], p[l1+2], p[l1+3], p[l1+4], + p[l1+5], p[l1+6], p[l1+7], p[l1+8], + p[l2+1], p[l2+2], p[l2+3], p[l2+4], + p[l2+5], p[l2+6], p[l2+7], p[l2+8], + p[l3+1], p[l3+2], p[l3+3], p[l3+4], + p[l3+5], p[l3+6], p[l3+7], p[l3+8]) + + vi_t = transpose(vi) + @fastmath r += dot(vi_t, mat, vi_t) + end + return r + end + + if q1 == 1 + f = f1H + elseif q1 == 2 + f = f2H + elseif q1 == 3 + f = f3H + else + error(""qubit position $q1 not allowed for LHH."") + end + (q2 > 3) || error(""qubit 2 position $q2 not allowed for LHH."") + total_itr = div(L, 32) + + parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, sizej, sizel, mask0, mask1, mask2, U, v) +end + +"""""" + applys when q1, q2 <= 3 and q3 > 4, U is the transposed op +"""""" +function _expectation_value_util_LLH(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) + L = length(v) + q1, q2, q3 = key + sizej = 1 << (q3-1) + mask0 = sizej - 1 + mask1 = xor(L - 1, 2 * sizej - 1) + + f12H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{4, 8}(p[l+1], p[l+5], p[l+9], p[l+13], + p[l+2], p[l+6], p[l+10], p[l+14], + p[l+3], p[l+7], p[l+11], p[l+15], + p[l+4], p[l+8], p[l+12], p[l+16], + p[l1+1], p[l1+5], p[l1+9], p[l1+13], + p[l1+2], p[l1+6], p[l1+10], p[l1+14], + p[l1+3], p[l1+7], p[l1+11], p[l1+15], + p[l1+4], p[l1+8], p[l1+12], p[l1+16]) + + vi_t = transpose(vi) + @fastmath r += dot(vi_t, mat, vi_t) + end + return r + end + + f13H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+9], p[l+11], + p[l+2], p[l+4], p[l+10], p[l+12], + p[l+5], p[l+7], p[l+13], p[l+15], + p[l+6], p[l+8], p[l+14], p[l+16], + p[l1+1], p[l1+3], p[l1+9], p[l1+11], + p[l1+2], p[l1+4], p[l1+10], p[l1+12], + p[l1+5], p[l1+7], p[l1+13], p[l1+15], + p[l1+6], p[l1+8], p[l1+14], p[l1+16]) + + vi_t = transpose(vi) + @fastmath r += dot(vi_t, mat, vi_t) + end + return r + end + + f23H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+9], p[l+10], + p[l+3], p[l+4], p[l+11], p[l+12], + p[l+5], p[l+6], p[l+13], p[l+14], + p[l+7], p[l+8], p[l+15], p[l+16], + p[l1+1], p[l1+2], p[l1+9], p[l1+10], + p[l1+3], p[l1+4], p[l1+11], p[l1+12], + p[l1+5], p[l1+6], p[l1+13], p[l1+14], + p[l1+7], p[l1+8], p[l1+15], p[l1+16]) + + vi_t = transpose(vi) + @fastmath r += dot(vi_t, mat, vi_t) + end + return r + end + + if q1 == 1 && q2 == 2 + f = f12H + elseif q1 == 1 && q2 == 3 + f = f13H + elseif q1 == 2 && q2 == 3 + f = f23H + else + error(""qubit position $q1 not allowed for LH."") + end + total_itr = div(L, 32) + + parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, sizej, mask0, mask1, U, v) +end + + +"""""" + applys when both keys <= 4 +"""""" +function _expectation_value_util_LLL(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) + L = length(v) + q1, q2, q3 = key + f123(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 32 * i + 1 + vi = SMatrix{8, 4}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15], + p[l+16], p[l+17], p[l+18], p[l+19], p[l+20], p[l+21], p[l+22], p[l+23], + p[l+24], p[l+25], p[l+26], p[l+27], p[l+28], p[l+29], p[l+30], p[l+31]) + + @fastmath r += dot(vi, mat, vi) + end + return r + end + f124(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12], + p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16], + p[l+17], p[l+18], p[l+19], p[l+20], p[l+25], p[l+26], p[l+27], p[l+28], + p[l+21], p[l+22], p[l+23], p[l+24], p[l+29], p[l+30], p[l+31], p[l+32]) + + @fastmath r += dot(vi, mat, vi) + end + return r + end + f134(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14], + p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16], + p[l+17], p[l+18], p[l+21], p[l+22], p[l+25], p[l+26], p[l+29], p[l+30], + p[l+19], p[l+20], p[l+23], p[l+24], p[l+27], p[l+28], p[l+31], p[l+32]) + + @fastmath r += dot(vi, mat, vi) + end + return r + end + f234(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{8, 4}(p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15], + p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16], + p[l+17], p[l+19], p[l+21], p[l+23], p[l+25], p[l+27], p[l+29], p[l+31], + p[l+18], p[l+20], p[l+22], p[l+24], p[l+26], p[l+28], p[l+30], p[l+32]) + + @fastmath r += dot(vi, mat, vi) + end + return r + end + if q1==1 && q2 == 2 && q3 == 3 + f = f123 + elseif q1==1 && q2 == 2 && q3 == 4 + f = f124 + elseif q1==1 && q2 == 3 && q3 == 4 + f = f134 + elseif q1==2 && q2 == 3 && q3 == 4 + f = f234 + else + error(""qubit position $q1 and $q2 not allowed for LL."") + end + total_itr = div(L, 32) + + parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, U, v) +end + +function _expectation_value_threaded_util(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) + q0, q1, q2 = key + if q0 > 2 + return _expectation_value_util_HHH(key, SMatrix{8,8, eltype(v)}(U), v) + elseif q1 > 3 + return _expectation_value_util_LHH(key, SMatrix{8,8, eltype(v)}(U), v) + elseif q2 > 4 + return _expectation_value_util_LLH(key, SMatrix{8,8, eltype(v)}(U), v) + else + return _expectation_value_util_LLL(key, SMatrix{8,8, eltype(v)}(U), v) + end +end + + +expectation_value_threaded(pos::Int, m::AbstractMatrix, state::AbstractVector) = _expectation_value_threaded_util( + pos, m, state) + +expectation_value_threaded(pos::Tuple{Int}, m::AbstractMatrix, state::AbstractVector) = expectation_value_threaded( + pos[1], m, state) + +expectation_value_threaded(pos::Tuple{Int, Int}, m::AbstractMatrix, state::AbstractVector) = _expectation_value_threaded_util( + pos, m, state) + +expectation_value_threaded(pos::Tuple{Int, Int, Int}, m::AbstractMatrix, state::AbstractVector) = _expectation_value_threaded_util( + pos, m, state) + + + + + +","Julia" +"Conjugate","guochu/VQC.jl","src/hamiltonian/expecs/expec_threaded_2.jl",".jl","35736","792"," + + +"""""" + applys when key > 3, U is the transposed op +"""""" +function _expectation_value_util_H(key::Int, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + sizek = 1 << (key - 1) + mask0 = sizek - 1 + mask1 = xor(L - 1, 2 * sizek - 1) + f(ist::Int, ifn::Int, pos::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (16 * i & m2) | (8 * i & m1) + 1 + l1 = l + pos + vi = SMatrix{8, 2}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7]) + + vo = SMatrix{8, 2}(po[l], po[l+1], po[l+2], po[l+3], po[l+4], po[l+5], po[l+6], po[l+7], + po[l1], po[l1+1], po[l1+2], po[l1+3], po[l1+4], po[l1+5], po[l1+6], po[l1+7]) + + + @fastmath r += dot(transpose(vo), mat, transpose(vi)) + end + return r + end + + return parallel_sum(eltype(v), div(L, 16), Threads.nthreads(), f, sizek, mask0, mask1, U, v, vout) +end + +"""""" + applys when key <= 3, U is the transposed op +"""""" +function _expectation_value_util_L(key::Int, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + f1(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 16 * i + 1 + vi = SMatrix{2, 8}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15]) + + vo = SMatrix{2, 8}(po[l], po[l+1], po[l+2], po[l+3], po[l+4], po[l+5], po[l+6], po[l+7], + po[l+8], po[l+9], po[l+10], po[l+11], po[l+12], po[l+13], po[l+14], po[l+15]) + + @fastmath r += dot(vo, mat, vi) + end + return r + end + f2(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 16 * i + 1 + vi = SMatrix{2, 8}(p[l], p[l+2], p[l+1], p[l+3], p[l+4], p[l+6], p[l+5], p[l+7], + p[l+8], p[l+10], p[l+9], p[l+11], p[l+12], p[l+14], p[l+13], p[l+15]) + + vo = SMatrix{2, 8}(po[l], po[l+2], po[l+1], po[l+3], po[l+4], po[l+6], po[l+5], po[l+7], + po[l+8], po[l+10], po[l+9], po[l+11], po[l+12], po[l+14], po[l+13], po[l+15]) + + @fastmath r += dot(vo, mat, vi) + end + return r + end + f3(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 16 * i + 1 + vi = SMatrix{2, 8}(p[l], p[l+4], p[l+1], p[l+5], p[l+2], p[l+6], p[l+3], p[l+7], + p[l+8], p[l+12], p[l+9], p[l+13], p[l+10], p[l+14], p[l+11], p[l+15]) + + vo = SMatrix{2, 8}(po[l], po[l+4], po[l+1], po[l+5], po[l+2], po[l+6], po[l+3], po[l+7], + po[l+8], po[l+12], po[l+9], po[l+13], po[l+10], po[l+14], po[l+11], po[l+15]) + + @fastmath r += dot(vo, mat, vi) + end + return r + end + if key == 1 + f = f1 + elseif key == 2 + f = f2 + elseif key == 3 + f = f3 + else + error(""qubit position $key not allowed for L."") + end + + parallel_sum(eltype(v), div(L, 16), Threads.nthreads(), f, U, v, vout) +end + +function _expectation_value_threaded_util(q0::Int, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + if q0 > 3 + return _expectation_value_util_H(q0, SMatrix{2,2, eltype(v)}(U), v, vout) + else + return _expectation_value_util_L(q0, SMatrix{2,2, eltype(v)}(U), v, vout) + end +end +_expectation_value_threaded_util(q0::Tuple{Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _expectation_value_threaded_util( + q0[1], U, v, vout) + + + + +"""""" + applys when both keys > 3, U is the transposed op +"""""" +function _expectation_value_util_HH(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + q1, q2 = key + pos1, pos2 = 1 << (q1-1), 1 << (q2-1) + # stride2, stride3 = pos1 << 1, pos2 << 1 + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(L - 1, 2 * pos2 - 1) + # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"") + + total_itr = div(L, 32) + f(ist::Int, ifn::Int, posa::Int, posb::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1) + 1 + # l = div(l, 2) + 1 + l1 = l + posa + l2 = l + posb + l3 = l2 + posa + # println(""l0=$l, l1=$l1, l2=$l2, l3=$l3"") + vi = SMatrix{8, 4}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7], + p[l2], p[l2+1], p[l2+2], p[l2+3], p[l2+4], p[l2+5], p[l2+6], p[l2+7], + p[l3], p[l3+1], p[l3+2], p[l3+3], p[l3+4], p[l3+5], p[l3+6], p[l3+7]) + + vo = SMatrix{8, 4}(po[l], po[l+1], po[l+2], po[l+3], po[l+4], po[l+5], po[l+6], po[l+7], + po[l1], po[l1+1], po[l1+2], po[l1+3], po[l1+4], po[l1+5], po[l1+6], po[l1+7], + po[l2], po[l2+1], po[l2+2], po[l2+3], po[l2+4], po[l2+5], po[l2+6], po[l2+7], + po[l3], po[l3+1], po[l3+2], po[l3+3], po[l3+4], po[l3+5], po[l3+6], po[l3+7]) + + + @fastmath r += dot(transpose(vo), mat, transpose(vi)) + end + return r + end + + parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, pos1, pos2, mask0, mask1, mask2, U, v, vout) +end + + +"""""" + applys when q1 <= 3 and q2 > 4, U is the transposed op +"""""" +function _expectation_value_util_LH(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + q1, q2 = key + sizej = 1 << (q2-1) + mask0 = sizej - 1 + mask1 = xor(L - 1, 2 * sizej - 1) + + f1H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{8, 4}(p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15], + p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16], + p[l1+1], p[l1+3], p[l1+5], p[l1+7], p[l1+9], p[l1+11], p[l1+13], p[l1+15], + p[l1+2], p[l1+4], p[l1+6], p[l1+8], p[l1+10], p[l1+12], p[l1+14], p[l1+16]) + + vo = SMatrix{8, 4}(po[l+1], po[l+3], po[l+5], po[l+7], po[l+9], po[l+11], po[l+13], po[l+15], + po[l+2], po[l+4], po[l+6], po[l+8], po[l+10], po[l+12], po[l+14], po[l+16], + po[l1+1], po[l1+3], po[l1+5], po[l1+7], po[l1+9], po[l1+11], po[l1+13], po[l1+15], + po[l1+2], po[l1+4], po[l1+6], po[l1+8], po[l1+10], po[l1+12], po[l1+14], po[l1+16]) + + @fastmath r += dot(transpose(vo), mat, transpose(vi)) + end + return r + end + + f2H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14], + p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16], + p[l1+1], p[l1+2], p[l1+5], p[l1+6], p[l1+9], p[l1+10], p[l1+13], p[l1+14], + p[l1+3], p[l1+4], p[l1+7], p[l1+8], p[l1+11], p[l1+12], p[l1+15], p[l1+16]) + + vo = SMatrix{8, 4}(po[l+1], po[l+2], po[l+5], po[l+6], po[l+9], po[l+10], po[l+13], po[l+14], + po[l+3], po[l+4], po[l+7], po[l+8], po[l+11], po[l+12], po[l+15], po[l+16], + po[l1+1], po[l1+2], po[l1+5], po[l1+6], po[l1+9], po[l1+10], po[l1+13], po[l1+14], + po[l1+3], po[l1+4], po[l1+7], po[l1+8], po[l1+11], po[l1+12], po[l1+15], po[l1+16]) + + @fastmath r += dot(transpose(vo), mat, transpose(vi)) + end + return r + end + + f3H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12], + p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16], + p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+9], p[l1+10], p[l1+11], p[l1+12], + p[l1+5], p[l1+6], p[l1+7], p[l1+8], p[l1+13], p[l1+14], p[l1+15], p[l1+16]) + + vo = SMatrix{8, 4}(po[l+1], po[l+2], po[l+3], po[l+4], po[l+9], po[l+10], po[l+11], po[l+12], + po[l+5], po[l+6], po[l+7], po[l+8], po[l+13], po[l+14], po[l+15], po[l+16], + po[l1+1], po[l1+2], po[l1+3], po[l1+4], po[l1+9], po[l1+10], po[l1+11], po[l1+12], + po[l1+5], po[l1+6], po[l1+7], po[l1+8], po[l1+13], po[l1+14], po[l1+15], po[l1+16]) + + @fastmath r += dot(transpose(vo), mat, transpose(vi)) + end + return r + end + + if q1 == 1 + f = f1H + elseif q1 == 2 + f = f2H + elseif q1 == 3 + f = f3H + else + error(""qubit position $q1 not allowed for LH."") + end + total_itr = div(L, 32) + + parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, sizej, mask0, mask1, U, v, vout) +end + +"""""" + applys when both keys <= 4 +"""""" +function _expectation_value_util_LL(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + q1, q2 = key + f12(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 32 * i + 1 + vi = SMatrix{4, 8}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15], + p[l+16], p[l+17], p[l+18], p[l+19], p[l+20], p[l+21], p[l+22], p[l+23], + p[l+24], p[l+25], p[l+26], p[l+27], p[l+28], p[l+29], p[l+30], p[l+31]) + + vo = SMatrix{4, 8}(po[l], po[l+1], po[l+2], po[l+3], po[l+4], po[l+5], po[l+6], po[l+7], + po[l+8], po[l+9], po[l+10], po[l+11], po[l+12], po[l+13], po[l+14], po[l+15], + po[l+16], po[l+17], po[l+18], po[l+19], po[l+20], po[l+21], po[l+22], po[l+23], + po[l+24], po[l+25], po[l+26], po[l+27], po[l+28], po[l+29], po[l+30], po[l+31]) + + @fastmath r += dot(vo, mat, vi) + end + return r + end + f13(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 32 * i + 1 + vi = SMatrix{4, 8}(p[l], p[l+1], p[l+4], p[l+5], p[l+2], p[l+3], p[l+6], p[l+7], + p[l+8], p[l+9], p[l+12], p[l+13], p[l+10], p[l+11], p[l+14], p[l+15], + p[l+16], p[l+17], p[l+20], p[l+21], p[l+18], p[l+19], p[l+22], p[l+23], + p[l+24], p[l+25], p[l+28], p[l+29], p[l+26], p[l+27], p[l+30], p[l+31]) + + vo = SMatrix{4, 8}(po[l], po[l+1], po[l+4], po[l+5], po[l+2], po[l+3], po[l+6], po[l+7], + po[l+8], po[l+9], po[l+12], po[l+13], po[l+10], po[l+11], po[l+14], po[l+15], + po[l+16], po[l+17], po[l+20], po[l+21], po[l+18], po[l+19], po[l+22], po[l+23], + po[l+24], po[l+25], po[l+28], po[l+29], po[l+26], po[l+27], po[l+30], po[l+31]) + + @fastmath r += dot(vo, mat, vi) + end + return r + end + f14(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+9], p[l+10], p[l+3], p[l+4], p[l+11], p[l+12], + p[l+5], p[l+6], p[l+13], p[l+14], p[l+7], p[l+8], p[l+15], p[l+16], + p[l+17], p[l+18], p[l+25], p[l+26], p[l+19], p[l+20], p[l+27], p[l+28], + p[l+21], p[l+22], p[l+29], p[l+30], p[l+23], p[l+24], p[l+31], p[l+32]) + + vo = SMatrix{4, 8}(po[l+1], po[l+2], po[l+9], po[l+10], po[l+3], po[l+4], po[l+11], po[l+12], + po[l+5], po[l+6], po[l+13], po[l+14], po[l+7], po[l+8], po[l+15], po[l+16], + po[l+17], po[l+18], po[l+25], po[l+26], po[l+19], po[l+20], po[l+27], po[l+28], + po[l+21], po[l+22], po[l+29], po[l+30], po[l+23], po[l+24], po[l+31], po[l+32]) + + @fastmath r += dot(vo, mat, vi) + end + return r + end + f23(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 32 * i + 1 + vi = SMatrix{4, 8}(p[l], p[l+2], p[l+4], p[l+6], p[l+1], p[l+3], p[l+5], p[l+7], + p[l+8], p[l+10], p[l+12], p[l+14], p[l+9], p[l+11], p[l+13], p[l+15], + p[l+16], p[l+18], p[l+20], p[l+22], p[l+17], p[l+19], p[l+21], p[l+23], + p[l+24], p[l+26], p[l+28], p[l+30], p[l+25], p[l+27], p[l+29], p[l+31]) + + vo = SMatrix{4, 8}(po[l], po[l+2], po[l+4], po[l+6], po[l+1], po[l+3], po[l+5], po[l+7], + po[l+8], po[l+10], po[l+12], po[l+14], po[l+9], po[l+11], po[l+13], po[l+15], + po[l+16], po[l+18], po[l+20], po[l+22], po[l+17], po[l+19], po[l+21], po[l+23], + po[l+24], po[l+26], po[l+28], po[l+30], po[l+25], po[l+27], po[l+29], po[l+31]) + + @fastmath r += dot(vo, mat, vi) + end + return r + end + f24(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+9], p[l+11], p[l+2], p[l+4], p[l+10], p[l+12], + p[l+5], p[l+7], p[l+13], p[l+15], p[l+6], p[l+8], p[l+14], p[l+16], + p[l+17], p[l+19], p[l+25], p[l+27], p[l+18], p[l+20], p[l+26], p[l+28], + p[l+21], p[l+23], p[l+29], p[l+31], p[l+22], p[l+24], p[l+30], p[l+32]) + + vo = SMatrix{4, 8}(po[l+1], po[l+3], po[l+9], po[l+11], po[l+2], po[l+4], po[l+10], po[l+12], + po[l+5], po[l+7], po[l+13], po[l+15], po[l+6], po[l+8], po[l+14], po[l+16], + po[l+17], po[l+19], po[l+25], po[l+27], po[l+18], po[l+20], po[l+26], po[l+28], + po[l+21], po[l+23], po[l+29], po[l+31], po[l+22], po[l+24], po[l+30], po[l+32]) + + @fastmath r += dot(vo, mat, vi) + end + return r + end + f34(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{4, 8}(p[l+1], p[l+5], p[l+9], p[l+13], p[l+2], p[l+6], p[l+10], p[l+14], + p[l+3], p[l+7], p[l+11], p[l+15], p[l+4], p[l+8], p[l+12], p[l+16], + p[l+17], p[l+21], p[l+25], p[l+29], p[l+18], p[l+22], p[l+26], p[l+30], + p[l+19], p[l+23], p[l+27], p[l+31], p[l+20], p[l+24], p[l+28], p[l+32]) + + vo = SMatrix{4, 8}(po[l+1], po[l+5], po[l+9], po[l+13], po[l+2], po[l+6], po[l+10], po[l+14], + po[l+3], po[l+7], po[l+11], po[l+15], po[l+4], po[l+8], po[l+12], po[l+16], + po[l+17], po[l+21], po[l+25], po[l+29], po[l+18], po[l+22], po[l+26], po[l+30], + po[l+19], po[l+23], po[l+27], po[l+31], po[l+20], po[l+24], po[l+28], po[l+32]) + + @fastmath r += dot(vo, mat, vi) + end + return r + end + if q1==1 && q2 == 2 + f = f12 + elseif q1==1 && q2 == 3 + f = f13 + elseif q1==1 && q2 == 4 + f = f14 + elseif q1==2 && q2 == 3 + f = f23 + elseif q1==2 && q2 == 4 + f = f24 + elseif q1==3 && q2 == 4 + f = f34 + else + error(""qubit position $q1 and $q2 not allowed for LL."") + end + total_itr = div(L, 32) + + parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, U, v, vout) +end + + +function _expectation_value_threaded_util(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + q0, q1 = key + if q0 > 3 + return _expectation_value_util_HH(key, SMatrix{4,4, eltype(v)}(U), v, vout) + elseif q1 > 4 + return _expectation_value_util_LH(key, SMatrix{4,4, eltype(v)}(U), v, vout) + else + return _expectation_value_util_LL(key, SMatrix{4,4, eltype(v)}(U), v, vout) + end +end + + +"""""" + applys when both keys > 2, U is assumed to be transposed +"""""" +function _expectation_value_util_HHH(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + q1, q2, q3 = key + pos1, pos2, pos3 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1) + # stride2, stride3 = pos1 << 1, pos2 << 1 + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(pos3 - 1, 2 * pos2 - 1) + mask3 = xor(L - 1, 2 * pos3 - 1) + # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"") + + total_itr = div(L, 32) + f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, m4::Int, mat, p, po) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l000 = (32 * i & m4) | (16 * i & m3) | (8 * i & m2) | (4 * i & m1) + 1 + l100 = l000 + posa + l010 = l000 + posb + l110 = l010 + posa + + l001 = l000 + posc + l101 = l001 + posa + l011 = l001 + posb + l111 = l011 + posa + + # println(""$l000, $l100, $l010, $l110, $l001, $l101, $l011, $l111"") + vi = SMatrix{4, 8}(p[l000], p[l000+1], p[l000+2], p[l000+3], + p[l100], p[l100+1], p[l100+2], p[l100+3], + p[l010], p[l010+1], p[l010+2], p[l010+3], + p[l110], p[l110+1], p[l110+2], p[l110+3], + p[l001], p[l001+1], p[l001+2], p[l001+3], + p[l101], p[l101+1], p[l101+2], p[l101+3], + p[l011], p[l011+1], p[l011+2], p[l011+3], + p[l111], p[l111+1], p[l111+2], p[l111+3]) + + vo = SMatrix{4, 8}(po[l000], po[l000+1], po[l000+2], po[l000+3], + po[l100], po[l100+1], po[l100+2], po[l100+3], + po[l010], po[l010+1], po[l010+2], po[l010+3], + po[l110], po[l110+1], po[l110+2], po[l110+3], + po[l001], po[l001+1], po[l001+2], po[l001+3], + po[l101], po[l101+1], po[l101+2], po[l101+3], + po[l011], po[l011+1], po[l011+2], po[l011+3], + po[l111], po[l111+1], po[l111+2], po[l111+3]) + + + @fastmath r += dot(transpose(vo), mat, transpose(vi)) + end + return r + end + + parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, pos1, pos2, pos3, mask0, mask1, mask2, mask3, U, v, vout) +end + + +"""""" + applys when q1 <= 2 and q2 > 3, U is the transposed op +"""""" +function _expectation_value_util_LHH(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + q1, q2, q3 = key + sizej, sizel = 1 << (q2-1), 1 << (q3-1) + mask0 = sizej - 1 + mask1 = xor(sizel - 1, 2 * sizej - 1) + mask2 = xor(L-1, 2 * sizel - 1) + + f1H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat, p, po) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1) + l1 = l + posb + l2 = l + posc + l3 = l2 + posb + # println(""$l, $l1, $l2, $l3"") + vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+5], p[l+7], + p[l+2], p[l+4], p[l+6], p[l+8], + p[l1+1], p[l1+3], p[l1+5], p[l1+7], + p[l1+2], p[l1+4], p[l1+6], p[l1+8], + p[l2+1], p[l2+3], p[l2+5], p[l2+7], + p[l2+2], p[l2+4], p[l2+6], p[l2+8], + p[l3+1], p[l3+3], p[l3+5], p[l3+7], + p[l3+2], p[l3+4], p[l3+6], p[l3+8]) + + vo = SMatrix{4, 8}(po[l+1], po[l+3], po[l+5], po[l+7], + po[l+2], po[l+4], po[l+6], po[l+8], + po[l1+1], po[l1+3], po[l1+5], po[l1+7], + po[l1+2], po[l1+4], po[l1+6], po[l1+8], + po[l2+1], po[l2+3], po[l2+5], po[l2+7], + po[l2+2], po[l2+4], po[l2+6], po[l2+8], + po[l3+1], po[l3+3], po[l3+5], po[l3+7], + po[l3+2], po[l3+4], po[l3+6], po[l3+8]) + + + @fastmath r += dot(transpose(vo), mat, transpose(vi)) + end + return r + end + + f2H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat, p, po) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1) + l1 = l + posb + l2 = l + posc + l3 = l2 + posb + vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+5], p[l+6], + p[l+3], p[l+4], p[l+7], p[l+8], + p[l1+1], p[l1+2], p[l1+5], p[l1+6], + p[l1+3], p[l1+4], p[l1+7], p[l1+8], + p[l2+1], p[l2+2], p[l2+5], p[l2+6], + p[l2+3], p[l2+4], p[l2+7], p[l2+8], + p[l3+1], p[l3+2], p[l3+5], p[l3+6], + p[l3+3], p[l3+4], p[l3+7], p[l3+8]) + + vo = SMatrix{4, 8}(po[l+1], po[l+2], po[l+5], po[l+6], + po[l+3], po[l+4], po[l+7], po[l+8], + po[l1+1], po[l1+2], po[l1+5], po[l1+6], + po[l1+3], po[l1+4], po[l1+7], po[l1+8], + po[l2+1], po[l2+2], po[l2+5], po[l2+6], + po[l2+3], po[l2+4], po[l2+7], po[l2+8], + po[l3+1], po[l3+2], po[l3+5], po[l3+6], + po[l3+3], po[l3+4], po[l3+7], po[l3+8]) + + @fastmath r += dot(transpose(vo), mat, transpose(vi)) + end + return r + end + + f3H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat, p, po) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1) + l1 = l + posb + l2 = l + posc + l3 = l2 + posb + vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+3], p[l+4], + p[l+5], p[l+6], p[l+7], p[l+8], + p[l1+1], p[l1+2], p[l1+3], p[l1+4], + p[l1+5], p[l1+6], p[l1+7], p[l1+8], + p[l2+1], p[l2+2], p[l2+3], p[l2+4], + p[l2+5], p[l2+6], p[l2+7], p[l2+8], + p[l3+1], p[l3+2], p[l3+3], p[l3+4], + p[l3+5], p[l3+6], p[l3+7], p[l3+8]) + + vo = SMatrix{4, 8}(po[l+1], po[l+2], po[l+3], po[l+4], + po[l+5], po[l+6], po[l+7], po[l+8], + po[l1+1], po[l1+2], po[l1+3], po[l1+4], + po[l1+5], po[l1+6], po[l1+7], po[l1+8], + po[l2+1], po[l2+2], po[l2+3], po[l2+4], + po[l2+5], po[l2+6], po[l2+7], po[l2+8], + po[l3+1], po[l3+2], po[l3+3], po[l3+4], + po[l3+5], po[l3+6], po[l3+7], po[l3+8]) + + @fastmath r += dot(transpose(vo), mat, transpose(vi)) + end + return r + end + + if q1 == 1 + f = f1H + elseif q1 == 2 + f = f2H + elseif q1 == 3 + f = f3H + else + error(""qubit position $q1 not allowed for LHH."") + end + (q2 > 3) || error(""qubit 2 position $q2 not allowed for LHH."") + total_itr = div(L, 32) + + parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, sizej, sizel, mask0, mask1, mask2, U, v, vout) +end + +"""""" + applys when q1, q2 <= 3 and q3 > 4, U is the transposed op +"""""" +function _expectation_value_util_LLH(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + q1, q2, q3 = key + sizej = 1 << (q3-1) + mask0 = sizej - 1 + mask1 = xor(L - 1, 2 * sizej - 1) + + f12H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat, p, po) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{4, 8}(p[l+1], p[l+5], p[l+9], p[l+13], + p[l+2], p[l+6], p[l+10], p[l+14], + p[l+3], p[l+7], p[l+11], p[l+15], + p[l+4], p[l+8], p[l+12], p[l+16], + p[l1+1], p[l1+5], p[l1+9], p[l1+13], + p[l1+2], p[l1+6], p[l1+10], p[l1+14], + p[l1+3], p[l1+7], p[l1+11], p[l1+15], + p[l1+4], p[l1+8], p[l1+12], p[l1+16]) + + vo = SMatrix{4, 8}(po[l+1], po[l+5], po[l+9], po[l+13], + po[l+2], po[l+6], po[l+10], po[l+14], + po[l+3], po[l+7], po[l+11], po[l+15], + po[l+4], po[l+8], po[l+12], po[l+16], + po[l1+1], po[l1+5], po[l1+9], po[l1+13], + po[l1+2], po[l1+6], po[l1+10], po[l1+14], + po[l1+3], po[l1+7], po[l1+11], po[l1+15], + po[l1+4], po[l1+8], po[l1+12], po[l1+16]) + + @fastmath r += dot(transpose(vo), mat, transpose(vi)) + end + return r + end + + f13H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat, p, po) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+9], p[l+11], + p[l+2], p[l+4], p[l+10], p[l+12], + p[l+5], p[l+7], p[l+13], p[l+15], + p[l+6], p[l+8], p[l+14], p[l+16], + p[l1+1], p[l1+3], p[l1+9], p[l1+11], + p[l1+2], p[l1+4], p[l1+10], p[l1+12], + p[l1+5], p[l1+7], p[l1+13], p[l1+15], + p[l1+6], p[l1+8], p[l1+14], p[l1+16]) + + vo = SMatrix{4, 8}(po[l+1], po[l+3], po[l+9], po[l+11], + po[l+2], po[l+4], po[l+10], po[l+12], + po[l+5], po[l+7], po[l+13], po[l+15], + po[l+6], po[l+8], po[l+14], po[l+16], + po[l1+1], po[l1+3], po[l1+9], po[l1+11], + po[l1+2], po[l1+4], po[l1+10], po[l1+12], + po[l1+5], po[l1+7], po[l1+13], po[l1+15], + po[l1+6], po[l1+8], po[l1+14], po[l1+16]) + + @fastmath r += dot(transpose(vo), mat, transpose(vi)) + end + return r + end + + f23H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat, p, po) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+9], p[l+10], + p[l+3], p[l+4], p[l+11], p[l+12], + p[l+5], p[l+6], p[l+13], p[l+14], + p[l+7], p[l+8], p[l+15], p[l+16], + p[l1+1], p[l1+2], p[l1+9], p[l1+10], + p[l1+3], p[l1+4], p[l1+11], p[l1+12], + p[l1+5], p[l1+6], p[l1+13], p[l1+14], + p[l1+7], p[l1+8], p[l1+15], p[l1+16]) + + vo = SMatrix{4, 8}(po[l+1], po[l+2], po[l+9], po[l+10], + po[l+3], po[l+4], po[l+11], po[l+12], + po[l+5], po[l+6], po[l+13], po[l+14], + po[l+7], po[l+8], po[l+15], po[l+16], + po[l1+1], po[l1+2], po[l1+9], po[l1+10], + po[l1+3], po[l1+4], po[l1+11], po[l1+12], + po[l1+5], po[l1+6], po[l1+13], po[l1+14], + po[l1+7], po[l1+8], po[l1+15], po[l1+16]) + + @fastmath r += dot(transpose(vo), mat, transpose(vi)) + end + return r + end + + if q1 == 1 && q2 == 2 + f = f12H + elseif q1 == 1 && q2 == 3 + f = f13H + elseif q1 == 2 && q2 == 3 + f = f23H + else + error(""qubit position $q1 not allowed for LH."") + end + total_itr = div(L, 32) + + parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, sizej, mask0, mask1, U, v, vout) +end + + +"""""" + applys when both keys <= 4 +"""""" +function _expectation_value_util_LLL(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + q1, q2, q3 = key + f123(ist::Int, ifn::Int, mat::AbstractMatrix, p, po) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 32 * i + 1 + vi = SMatrix{8, 4}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15], + p[l+16], p[l+17], p[l+18], p[l+19], p[l+20], p[l+21], p[l+22], p[l+23], + p[l+24], p[l+25], p[l+26], p[l+27], p[l+28], p[l+29], p[l+30], p[l+31]) + + vo = SMatrix{8, 4}(po[l], po[l+1], po[l+2], po[l+3], po[l+4], po[l+5], po[l+6], po[l+7], + po[l+8], po[l+9], po[l+10], po[l+11], po[l+12], po[l+13], po[l+14], po[l+15], + po[l+16], po[l+17], po[l+18], po[l+19], po[l+20], po[l+21], po[l+22], po[l+23], + po[l+24], po[l+25], po[l+26], po[l+27], po[l+28], po[l+29], po[l+30], po[l+31]) + + @fastmath r += dot(vo, mat, vi) + end + return r + end + f124(ist::Int, ifn::Int, mat::AbstractMatrix, p, po) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12], + p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16], + p[l+17], p[l+18], p[l+19], p[l+20], p[l+25], p[l+26], p[l+27], p[l+28], + p[l+21], p[l+22], p[l+23], p[l+24], p[l+29], p[l+30], p[l+31], p[l+32]) + + vo = SMatrix{8, 4}(po[l+1], po[l+2], po[l+3], po[l+4], po[l+9], po[l+10], po[l+11], po[l+12], + po[l+5], po[l+6], po[l+7], po[l+8], po[l+13], po[l+14], po[l+15], po[l+16], + po[l+17], po[l+18], po[l+19], po[l+20], po[l+25], po[l+26], po[l+27], po[l+28], + po[l+21], po[l+22], po[l+23], po[l+24], po[l+29], po[l+30], po[l+31], po[l+32]) + + @fastmath r += dot(vo, mat, vi) + end + return r + end + f134(ist::Int, ifn::Int, mat::AbstractMatrix, p, po) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14], + p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16], + p[l+17], p[l+18], p[l+21], p[l+22], p[l+25], p[l+26], p[l+29], p[l+30], + p[l+19], p[l+20], p[l+23], p[l+24], p[l+27], p[l+28], p[l+31], p[l+32]) + + vo = SMatrix{8, 4}(po[l+1], po[l+2], po[l+5], po[l+6], po[l+9], po[l+10], po[l+13], po[l+14], + po[l+3], po[l+4], po[l+7], po[l+8], po[l+11], po[l+12], po[l+15], po[l+16], + po[l+17], po[l+18], po[l+21], po[l+22], po[l+25], po[l+26], po[l+29], po[l+30], + po[l+19], po[l+20], po[l+23], po[l+24], po[l+27], po[l+28], po[l+31], po[l+32]) + + @fastmath r += dot(vo, mat, vi) + end + return r + end + f234(ist::Int, ifn::Int, mat::AbstractMatrix, p, po) = begin + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{8, 4}(p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15], + p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16], + p[l+17], p[l+19], p[l+21], p[l+23], p[l+25], p[l+27], p[l+29], p[l+31], + p[l+18], p[l+20], p[l+22], p[l+24], p[l+26], p[l+28], p[l+30], p[l+32]) + + vo = SMatrix{8, 4}(po[l+1], po[l+3], po[l+5], po[l+7], po[l+9], po[l+11], po[l+13], po[l+15], + po[l+2], po[l+4], po[l+6], po[l+8], po[l+10], po[l+12], po[l+14], po[l+16], + po[l+17], po[l+19], po[l+21], po[l+23], po[l+25], po[l+27], po[l+29], po[l+31], + po[l+18], po[l+20], po[l+22], po[l+24], po[l+26], po[l+28], po[l+30], po[l+32]) + + @fastmath r += dot(vo, mat, vi) + end + return r + end + if q1==1 && q2 == 2 && q3 == 3 + f = f123 + elseif q1==1 && q2 == 2 && q3 == 4 + f = f124 + elseif q1==1 && q2 == 3 && q3 == 4 + f = f134 + elseif q1==2 && q2 == 3 && q3 == 4 + f = f234 + else + error(""qubit position $q1 and $q2 not allowed for LL."") + end + total_itr = div(L, 32) + + parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, U, v, vout) +end + +function _expectation_value_threaded_util(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + q0, q1, q2 = key + if q0 > 2 + return _expectation_value_util_HHH(key, SMatrix{8,8, eltype(v)}(U), v, vout) + elseif q1 > 3 + return _expectation_value_util_LHH(key, SMatrix{8,8, eltype(v)}(U), v, vout) + elseif q2 > 4 + return _expectation_value_util_LLH(key, SMatrix{8,8, eltype(v)}(U), v, vout) + else + return _expectation_value_util_LLL(key, SMatrix{8,8, eltype(v)}(U), v, vout) + end +end + +expectation_value_threaded(pos::Int, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = _expectation_value_threaded_util( + pos, m, state, state_c) + + +expectation_value_threaded(pos::Tuple{Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = expectation_value_threaded( + pos[1], m, state, state_c) + + +expectation_value_threaded(pos::Tuple{Int, Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = _expectation_value_threaded_util( + pos, m, state, state_c) + +expectation_value_threaded(pos::Tuple{Int, Int, Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = _expectation_value_threaded_util( + pos, m, state, state_c) + + + +","Julia" +"Conjugate","guochu/VQC.jl","src/hamiltonian/expecs/expec_high_qubit_terms_2.jl",".jl","5747","135"," + +function _expectation_value_fourbody_util(key::Tuple{Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + q1, q2, q3, q4 = key + pos1, pos2, pos3, pos4 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1), 1 << (q4-1) + # stride2, stride3 = pos1 << 1, pos2 << 1 + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(pos3 - 1, 2 * pos2 - 1) + mask3 = xor(pos4 - 1, 2 * pos3 - 1) + mask4 = xor(L - 1, 2 * pos4 - 1) + # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"") + + + function f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, posd::Int, m1::Int, m2::Int, m3::Int, + m4::Int, m5::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l0000 = (16 * i & m5) | (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1 + l1000 = l0000 + posa + l0100 = l0000 + posb + l0010 = l0000 + posc + l0001 = l0000 + posd + + l1100 = l0100 + posa + l1010 = l0010 + posa + l1001 = l1000 + posd + l0110 = l0010 + posb + l0101 = l0100 + posd + l0011 = l0010 + posd + + l1110 = l1100 + posc + l1101 = l1100 + posd + l1011 = l1010 + posd + l0111 = l0110 + posd + + l1111 = l1110 + posd + + vi = SVector(p[l0000], p[l1000], p[l0100], p[l1100], p[l0010], p[l1010], p[l0110], p[l1110], + p[l0001], p[l1001], p[l0101], p[l1101], p[l0011], p[l1011], p[l0111], p[l1111]) + + vo = SVector(po[l0000], po[l1000], po[l0100], po[l1100], po[l0010], po[l1010], po[l0110], po[l1110], + po[l0001], po[l1001], po[l0101], po[l1101], po[l0011], po[l1011], po[l0111], po[l1111]) + + @fastmath r += dot(vo, mat, vi) + end + return r + end + total_itr = div(L, 16) + parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, pos1, pos2, pos3, pos4, mask0, mask1, mask2, mask3, mask4, U, v, vout) +end + +expectation_value_threaded(key::Tuple{Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _expectation_value_fourbody_util( + key, SMatrix{16,16, eltype(v)}(U), v, vout) + +function _expectation_value_fivebody_util(key::Tuple{Int, Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + q1, q2, q3, q4, q5 = key + pos1, pos2, pos3, pos4, pos5 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1), 1 << (q4-1), 1 << (q5-1) + # stride2, stride3 = pos1 << 1, pos2 << 1 + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(pos3 - 1, 2 * pos2 - 1) + mask3 = xor(pos4 - 1, 2 * pos3 - 1) + mask4 = xor(pos5 - 1, 2 * pos4 - 1) + mask5 = xor(L - 1, 2 * pos5 - 1) + # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"") + + function f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, posd::Int, pose::Int, + m1::Int, m2::Int, m3::Int, m4::Int, m5::Int, m6::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) + r = zero(eltype(p)) + @inbounds for i in ist:ifn + l00000 = (32 * i & m6) | (16 * i & m5) | (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1 + l10000 = l00000 + posa + l01000 = l00000 + posb + l00100 = l00000 + posc + l00010 = l00000 + posd + l00001 = l00000 + pose + + l11000 = l01000 + posa + l10100 = l00100 + posa + l10010 = l10000 + posd + l10001 = l10000 + pose + l01100 = l00100 + posb + l01010 = l01000 + posd + l01001 = l01000 + pose + l00110 = l00100 + posd + l00101 = l00100 + pose + l00011 = l00010 + pose + + + l11100 = l11000 + posc + l11010 = l11000 + posd + l11001 = l11000 + pose + l10110 = l10100 + posd + l10101 = l10100 + pose + l10011 = l10010 + pose + l01110 = l01100 + posd + l01101 = l01100 + pose + l01011 = l01010 + pose + l00111 = l00110 + pose + + l11110 = l11100 + posd + l11101 = l11100 + pose + l11011 = l11010 + pose + l10111 = l10110 + pose + l01111 = l01110 + pose + + l11111 = l11110 + pose + + vi = SVector(p[l00000], p[l10000], p[l01000], p[l11000], p[l00100], p[l10100], p[l01100], p[l11100], + p[l00010], p[l10010], p[l01010], p[l11010], p[l00110], p[l10110], p[l01110], p[l11110], + p[l00001], p[l10001], p[l01001], p[l11001], p[l00101], p[l10101], p[l01101], p[l11101], + p[l00011], p[l10011], p[l01011], p[l11011], p[l00111], p[l10111], p[l01111], p[l11111]) + + vo = SVector(po[l00000], po[l10000], po[l01000], po[l11000], po[l00100], po[l10100], po[l01100], po[l11100], + po[l00010], po[l10010], po[l01010], po[l11010], po[l00110], po[l10110], po[l01110], po[l11110], + po[l00001], po[l10001], po[l01001], po[l11001], po[l00101], po[l10101], po[l01101], po[l11101], + po[l00011], po[l10011], po[l01011], po[l11011], po[l00111], po[l10111], po[l01111], po[l11111]) + + + @fastmath r += dot(vo, mat, vi) + end + return r + end + total_itr = div(L, 32) + parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, pos1, pos2, pos3, pos4, pos5, mask0, mask1, mask2, mask3, mask4, mask5, U, v, vout) +end + + +expectation_value_threaded(key::Tuple{Int, Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _expectation_value_fivebody_util( + key, SMatrix{32,32, eltype(v)}(U), v, vout) + +","Julia" +"Conjugate","guochu/VQC.jl","src/hamiltonian/expecs/expecs.jl",".jl","6158","132"," + +include(""expec_serial.jl"") +include(""expec_threaded.jl"") +include(""expec_threaded_2.jl"") + +include(""expec_high_qubit_terms.jl"") +include(""expec_high_qubit_terms_2.jl"") + + + +function expectation(m::QubitsTerm, state::StateVector) + isempty(m) && return dot(state, state) + if length(positions(m)) <= LARGEST_SUPPORTED_NTERMS + return expectation_value(Tuple(positions(m)), _get_mat(m), storage(state)) + else + return dot(state, m * state) + end +end + + +function expectation(m::QubitsOperator, state::StateVector) + if _largest_nterm(m) <= LARGEST_SUPPORTED_NTERMS + r = zero(eltype(state)) + for (k, v) in m.data + r += expectation_value(k, _get_mat(length(k), v), storage(state)) + end + return r + else + # state = storage(state) + # workspace = similar(state) + # state_2 = zeros(eltype(state), length(state)) + # for (k, v) in m.data + # for item in v + # _apply_qterm_util!(QubitsTerm(k, item[1], item[2]), state, workspace) + # state_2 .+= workspace + # end + # end + # return dot(state, state_2) + return dot(state, m * state) + end +end + + +function expectation(state_c::StateVector, m::QubitsTerm, state::StateVector) + isempty(m) && return dot(state_c, state) + if length(positions(m)) <= LARGEST_SUPPORTED_NTERMS + return expectation_value(Tuple(positions(m)), _get_mat(m), storage(state), storage(state_c)) + else + return dot(state_c, m * state) + end +end + +function expectation(state_c::StateVector, m::QubitsOperator, state::StateVector) + if _largest_nterm(m) <= LARGEST_SUPPORTED_NTERMS + r = zero(eltype(state)) + for (k, v) in m.data + r += expectation_value(k, _get_mat(length(k), v), storage(state), storage(state_c)) + end + return r + else + # state = storage(state) + # workspace = similar(state) + # state_2 = zeros(eltype(state), length(state)) + # for (k, v) in m.data + # for item in v + # _apply_qterm_util!(QubitsTerm(k, item[1], item[2]), state, workspace) + # state_2 .+= workspace + # end + # end + # return dot(state_c, state_2) + return dot(state_c, m * state) + end +end + +expectation(m::Gate, state::StateVector) = expectation_value(ordered_positions(m), ordered_mat(m), storage(state)) +expectation(state_c::StateVector, m::Gate, state::StateVector) = expectation_value( + ordered_positions(m), ordered_mat(m), storage(state), storage(state_c)) + +expectation(state_c::StateVector, m::AbstractMatrix, state::StateVector) = dot(storage(state_c), m, storage(state)) +expectation(m::AbstractMatrix, state::StateVector) = dot(state, m, state) + + + +expectation_value(pos::Int, m::AbstractMatrix, state::AbstractVector) = (length(state) >= 32) ? expectation_value_threaded( + pos, m, state) : expectation_value_serial(pos, m, state) +expectation_value(pos::Int, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = (length(state) >= 32) ? expectation_value_threaded( + pos, m, state, state_c) : expectation_value_serial(pos, m, state, state_c) +expectation_value(pos::Tuple{Int}, m::AbstractMatrix, state::AbstractVector) = expectation_value(pos[1], m, state) +expectation_value(pos::Tuple{Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = expectation_value( + pos[1], m, state, state_c) + +expectation_value(pos::Tuple{Int, Int}, m::AbstractMatrix, state::AbstractVector) = (length(state) >= 32) ? expectation_value_threaded( + pos, m, state) : expectation_value_serial(pos, m, state) +expectation_value(pos::Tuple{Int, Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = (length(state) >= 32) ? expectation_value_threaded( + pos, m, state, state_c) : expectation_value_serial(pos, m, state, state_c) +expectation_value(pos::Tuple{Int, Int}, m::AbstractArray{T, 4}, state::AbstractVector) where T = expectation_value( + pos, reshape(m, 4, 4), state) +expectation_value(pos::Tuple{Int, Int}, m::AbstractArray{T, 4}, state::AbstractVector, state_c::AbstractVector) where T = expectation_value( + pos, reshape(m, 4, 4), state, state_c) + + +expectation_value(pos::Tuple{Int, Int, Int}, m::AbstractMatrix, state::AbstractVector) = (length(state) >= 32) ? expectation_value_threaded( + pos, m, state) : expectation_value_serial(pos, m, state) +expectation_value(pos::Tuple{Int, Int, Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = (length(state) >= 32) ? expectation_value_threaded( + pos, m, state, state_c) : expectation_value_serial(pos, m, state, state_c) +expectation_value(pos::Tuple{Int, Int, Int}, m::AbstractArray{T, 6}, state::AbstractVector) where T = expectation_value( + pos, reshape(m, 8, 8), state) +expectation_value(pos::Tuple{Int, Int, Int}, m::AbstractArray{T, 6}, state::AbstractVector, state_c::AbstractVector) where T = expectation_value( + pos, reshape(m, 8, 8), state, state_c) + + +expectation_value(pos::Tuple{Int, Int, Int, Int}, m::AbstractMatrix, state::AbstractVector) = expectation_value_threaded( + pos, m, state) +expectation_value(pos::Tuple{Int, Int, Int, Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = expectation_value_threaded( + pos, m, state, state_c) +expectation_value(pos::Tuple{Int, Int, Int, Int}, m::AbstractArray{T, 8}, state::AbstractVector) where T = expectation_value( + pos, Matrix{eltype(state)}(reshape(m, 16, 16)), state) +expectation_value(pos::Tuple{Int, Int, Int, Int}, m::AbstractArray{T, 8}, state::AbstractVector, state_c::AbstractVector) where T = expectation_value( + pos, Matrix{eltype(state)}(reshape(m, 16, 16)), state, state_c) + + +expectation_value(pos::Tuple{Int, Int, Int, Int, Int}, m::AbstractMatrix, state::AbstractVector) = expectation_value_threaded( + pos, m, state) +expectation_value(pos::Tuple{Int, Int, Int, Int, Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = expectation_value_threaded( + pos, m, state, state_c) +expectation_value(pos::Tuple{Int, Int, Int, Int, Int}, m::AbstractArray{T, 10}, state::AbstractVector) where T = expectation_value( + pos, Matrix{eltype(state)}(reshape(m, 32, 32)), state) +expectation_value(pos::Tuple{Int, Int, Int, Int, Int}, m::AbstractArray{T, 10}, state::AbstractVector, state_c::AbstractVector) where T = expectation_value( + pos, Matrix{eltype(state)}(reshape(m, 32, 32)), state, state_c) + +","Julia" +"Conjugate","guochu/VQC.jl","src/hamiltonian/apply_qterms/long_range_threaded.jl",".jl","6932","181"," + +function _apply_fourbody_term_impl!(key::Tuple{Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + q1, q2, q3, q4 = key + pos1, pos2, pos3, pos4 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1), 1 << (q4-1) + # stride2, stride3 = pos1 << 1, pos2 << 1 + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(pos3 - 1, 2 * pos2 - 1) + mask3 = xor(pos4 - 1, 2 * pos3 - 1) + mask4 = xor(L - 1, 2 * pos4 - 1) + # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"") + + + function f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, posd::Int, m1::Int, m2::Int, m3::Int, + m4::Int, m5::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) + @inbounds for i in ist:ifn + l0000 = (16 * i & m5) | (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1 + l1000 = l0000 + posa + l0100 = l0000 + posb + l0010 = l0000 + posc + l0001 = l0000 + posd + + l1100 = l0100 + posa + l1010 = l0010 + posa + l1001 = l1000 + posd + l0110 = l0010 + posb + l0101 = l0100 + posd + l0011 = l0010 + posd + + l1110 = l1100 + posc + l1101 = l1100 + posd + l1011 = l1010 + posd + l0111 = l0110 + posd + + l1111 = l1110 + posd + + vi = SVector(p[l0000], p[l1000], p[l0100], p[l1100], p[l0010], p[l1010], p[l0110], p[l1110], + p[l0001], p[l1001], p[l0101], p[l1101], p[l0011], p[l1011], p[l0111], p[l1111]) + + @fastmath begin + vo = mat * vi + po[l0000] += vo[1] + po[l1000] += vo[2] + po[l0100] += vo[3] + po[l1100] += vo[4] + po[l0010] += vo[5] + po[l1010] += vo[6] + po[l0110] += vo[7] + po[l1110] += vo[8] + po[l0001] += vo[9] + po[l1001] += vo[10] + po[l0101] += vo[11] + po[l1101] += vo[12] + po[l0011] += vo[13] + po[l1011] += vo[14] + po[l0111] += vo[15] + po[l1111] += vo[16] + end + end + end + total_itr = div(L, 16) + parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, pos3, pos4, mask0, mask1, mask2, mask3, mask4, U, v, vout) +end + + +_apply_gate_threaded2!(key::Tuple{Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _apply_fourbody_term_impl!( + key, SMatrix{16,16, eltype(v)}(U), v, vout) + + +_apply_gate_2!(key::Tuple{Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _apply_gate_threaded2!( + key, U, v, vout) + +function _apply_fivebody_term_impl!(key::Tuple{Int, Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + q1, q2, q3, q4, q5 = key + pos1, pos2, pos3, pos4, pos5 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1), 1 << (q4-1), 1 << (q5-1) + # stride2, stride3 = pos1 << 1, pos2 << 1 + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(pos3 - 1, 2 * pos2 - 1) + mask3 = xor(pos4 - 1, 2 * pos3 - 1) + mask4 = xor(pos5 - 1, 2 * pos4 - 1) + mask5 = xor(L - 1, 2 * pos5 - 1) + # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"") + + function f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, posd::Int, pose::Int, + m1::Int, m2::Int, m3::Int, m4::Int, m5::Int, m6::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) + @inbounds for i in ist:ifn + l00000 = (32 * i & m6) | (16 * i & m5) | (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1 + l10000 = l00000 + posa + l01000 = l00000 + posb + l00100 = l00000 + posc + l00010 = l00000 + posd + l00001 = l00000 + pose + + l11000 = l01000 + posa + l10100 = l00100 + posa + l10010 = l10000 + posd + l10001 = l10000 + pose + l01100 = l00100 + posb + l01010 = l01000 + posd + l01001 = l01000 + pose + l00110 = l00100 + posd + l00101 = l00100 + pose + l00011 = l00010 + pose + + + l11100 = l11000 + posc + l11010 = l11000 + posd + l11001 = l11000 + pose + l10110 = l10100 + posd + l10101 = l10100 + pose + l10011 = l10010 + pose + l01110 = l01100 + posd + l01101 = l01100 + pose + l01011 = l01010 + pose + l00111 = l00110 + pose + + l11110 = l11100 + posd + l11101 = l11100 + pose + l11011 = l11010 + pose + l10111 = l10110 + pose + l01111 = l01110 + pose + + l11111 = l11110 + pose + + vi = SVector(p[l00000], p[l10000], p[l01000], p[l11000], p[l00100], p[l10100], p[l01100], p[l11100], + p[l00010], p[l10010], p[l01010], p[l11010], p[l00110], p[l10110], p[l01110], p[l11110], + p[l00001], p[l10001], p[l01001], p[l11001], p[l00101], p[l10101], p[l01101], p[l11101], + p[l00011], p[l10011], p[l01011], p[l11011], p[l00111], p[l10111], p[l01111], p[l11111]) + + @fastmath begin + vo = mat * vi + + po[l00000] += vo[1] + po[l10000] += vo[2] + po[l01000] += vo[3] + po[l11000] += vo[4] + po[l00100] += vo[5] + po[l10100] += vo[6] + po[l01100] += vo[7] + po[l11100] += vo[8] + po[l00010] += vo[9] + po[l10010] += vo[10] + po[l01010] += vo[11] + po[l11010] += vo[12] + po[l00110] += vo[13] + po[l10110] += vo[14] + po[l01110] += vo[15] + po[l11110] += vo[16] + po[l00001] += vo[17] + po[l10001] += vo[18] + po[l01001] += vo[19] + po[l11001] += vo[20] + po[l00101] += vo[21] + po[l10101] += vo[22] + po[l01101] += vo[23] + po[l11101] += vo[24] + po[l00011] += vo[25] + po[l10011] += vo[26] + po[l01011] += vo[27] + po[l11011] += vo[28] + po[l00111] += vo[29] + po[l10111] += vo[30] + po[l01111] += vo[31] + po[l11111] += vo[32] + end + end + end + total_itr = div(L, 32) + parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, pos3, pos4, pos5, mask0, mask1, mask2, mask3, mask4, mask5, U, v, vout) +end + +_apply_gate_threaded2!(key::Tuple{Int, Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _apply_fivebody_term_impl!( + key, SMatrix{32,32, eltype(v)}(U), v, vout) + + + +","Julia" +"Conjugate","guochu/VQC.jl","src/hamiltonian/apply_qterms/apply_qterms.jl",".jl","1440","65","include(""short_range_serial.jl"") +include(""short_range_threaded.jl"") +include(""long_range_threaded.jl"") + + +function (m::QubitsTerm)(vr::StateVector) + v = storage(vr) + vout = similar(v) + _apply_qterm_util!(m, v, vout) + return StateVector(vout, nqubits(vr)) +end + +function (m::QubitsOperator)(vr::StateVector) + v = storage(vr) + vout = zeros(eltype(v), length(v)) + if _largest_nterm(m) <= LARGEST_SUPPORTED_NTERMS + _apply_util!(m, v, vout) + else + workspace = similar(v) + for (k, dd) in m.data + for item in dd + _apply_qterm_util!(QubitsTerm(k, item[1], item[2]), v, workspace) + vout .+= workspace + end + end + end + return StateVector(vout, nqubits(vr)) +end + + +Base.:*(m::QubitsOperator, v::StateVector) = m(v) +Base.:*(m::QubitsTerm, v::StateVector) = m(v) + + + +const LARGEST_SUPPORTED_NTERMS = 5 + + +function _largest_nterm(x::QubitsOperator) + n = 0 + for (k, v) in x.data + n = max(n, length(k)) + end + return n +end + +function _apply_qterm_util!(m::QubitsTerm, v::AbstractVector, vout::AbstractVector) + tmp = coeff(m) + @. vout = tmp * v + if length(v) >= 32 + for (pos, mat) in zip(positions(m), oplist(m)) + _apply_gate_threaded2!(pos, mat, vout) + end + else + for (pos, mat) in zip(positions(m), oplist(m)) + _apply_gate_2!(pos, mat, vout) + end + end +end + + +_apply_util!(m::QubitsOperator, v::AbstractVector, vout::AbstractVector) = (length(v) >= 32) ? _apply_threaded_util!( + m, v, vout) : _apply_serial_util!(m, v, vout) + +","Julia" +"Conjugate","guochu/VQC.jl","src/hamiltonian/apply_qterms/short_range_threaded.jl",".jl","58807","1528"," + + +"""""" + applys when key > 3, U is the transposed op +"""""" +function _apply_onebody_gate_H!(key::Int, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + sizek = 1 << (key - 1) + mask0 = sizek - 1 + mask1 = xor(L - 1, 2 * sizek - 1) + f(ist::Int, ifn::Int, pos::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (16 * i & m2) | (8 * i & m1) + 1 + l1 = l + pos + vi = SMatrix{8, 2}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7]) + + @fastmath begin + vo = vi * mat + + po[l] += vo[1] + po[l+1] += vo[2] + po[l+2] += vo[3] + po[l+3] += vo[4] + po[l+4] += vo[5] + po[l+5] += vo[6] + po[l+6] += vo[7] + po[l+7] += vo[8] + po[l1] += vo[9] + po[l1+1] += vo[10] + po[l1+2] += vo[11] + po[l1+3] += vo[12] + po[l1+4] += vo[13] + po[l1+5] += vo[14] + po[l1+6] += vo[15] + po[l1+7] += vo[16] + end + end + end + + parallel_run(div(L, 16), Threads.nthreads(), f, sizek, mask0, mask1, U, v, vout) +end + +"""""" + applys when key <= 3, U is the transposed op +"""""" +function _apply_onebody_gate_L!(key::Int, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + f1(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 16 * i + 1 + vi = SMatrix{2, 8}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15]) + + @fastmath begin + vo = mat * vi + + po[l] += vo[1] + po[l+1] += vo[2] + po[l+2] += vo[3] + po[l+3] += vo[4] + po[l+4] += vo[5] + po[l+5] += vo[6] + po[l+6] += vo[7] + po[l+7] += vo[8] + po[l+8] += vo[9] + po[l+9] += vo[10] + po[l+10] += vo[11] + po[l+11] += vo[12] + po[l+12] += vo[13] + po[l+13] += vo[14] + po[l+14] += vo[15] + po[l+15] += vo[16] + end + + # @fastmath po[l:(l+15)] .+= mat * vi + end + end + f2(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 16 * i + 1 + vi = SMatrix{2, 8}(p[l], p[l+2], p[l+1], p[l+3], p[l+4], p[l+6], p[l+5], p[l+7], + p[l+8], p[l+10], p[l+9], p[l+11], p[l+12], p[l+14], p[l+13], p[l+15]) + + @fastmath begin + vo = mat * vi + + po[l] += vo[1] + po[l+2] += vo[2] + po[l+1] += vo[3] + po[l+3] += vo[4] + po[l+4] += vo[5] + po[l+6] += vo[6] + po[l+5] += vo[7] + po[l+7] += vo[8] + po[l+8] += vo[9] + po[l+10] += vo[10] + po[l+9] += vo[11] + po[l+11] += vo[12] + po[l+12] += vo[13] + po[l+14] += vo[14] + po[l+13] += vo[15] + po[l+15] += vo[16] + end + + # @fastmath p[l], p[l+2], p[l+1], p[l+3], p[l+4], p[l+6], p[l+5], p[l+7], + # p[l+8], p[l+10], p[l+9], p[l+11], p[l+12], p[l+14], p[l+13], p[l+15] = mat * vi + end + end + f3(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 16 * i + 1 + vi = SMatrix{2, 8}(p[l], p[l+4], p[l+1], p[l+5], p[l+2], p[l+6], p[l+3], p[l+7], + p[l+8], p[l+12], p[l+9], p[l+13], p[l+10], p[l+14], p[l+11], p[l+15]) + + @fastmath begin + + vo = mat * vi + + po[l] += vo[1] + po[l+4] += vo[2] + po[l+1] += vo[3] + po[l+5] += vo[4] + po[l+2] += vo[5] + po[l+6] += vo[6] + po[l+3] += vo[7] + po[l+7] += vo[8] + po[l+8] += vo[9] + po[l+12] += vo[10] + po[l+9] += vo[11] + po[l+13] += vo[12] + po[l+10] += vo[13] + po[l+14] += vo[14] + po[l+11] += vo[15] + po[l+15] += vo[16] + end + # @fastmath p[l], p[l+4], p[l+1], p[l+5], p[l+2], p[l+6], p[l+3], p[l+7], + # p[l+8], p[l+12], p[l+9], p[l+13], p[l+10], p[l+14], p[l+11], p[l+15] = mat * vi + end + end + if key == 1 + f = f1 + elseif key == 2 + f = f2 + elseif key == 3 + f = f3 + else + error(""qubit position $key not allowed for L."") + end + + parallel_run(div(L, 16), Threads.nthreads(), f, U, v, vout) +end + +function _apply_gate_threaded2!(q0::Int, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + if q0 > 3 + return _apply_onebody_gate_H!(q0, SMatrix{2,2, eltype(v)}(transpose(U)), v, vout) + else + return _apply_onebody_gate_L!(q0, SMatrix{2,2, eltype(v)}(U), v, vout) + end +end + +_apply_gate_threaded2!(q0::Tuple{Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _apply_gate_threaded2!( + q0[1], U, v, vout) + +"""""" + applys when both keys > 3, U is the transposed op +"""""" +function _apply_twobody_gate_HH!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + q1, q2 = key + pos1, pos2 = 1 << (q1-1), 1 << (q2-1) + # stride2, stride3 = pos1 << 1, pos2 << 1 + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(L - 1, 2 * pos2 - 1) + # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"") + + total_itr = div(L, 32) + f(ist::Int, ifn::Int, posa::Int, posb::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1) + 1 + # l = div(l, 2) + 1 + l1 = l + posa + l2 = l + posb + l3 = l2 + posa + # println(""l0=$l, l1=$l1, l2=$l2, l3=$l3"") + vi = SMatrix{8, 4}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7], + p[l2], p[l2+1], p[l2+2], p[l2+3], p[l2+4], p[l2+5], p[l2+6], p[l2+7], + p[l3], p[l3+1], p[l3+2], p[l3+3], p[l3+4], p[l3+5], p[l3+6], p[l3+7]) + + @fastmath begin + vo = vi * mat + + po[l] += vo[1] + po[l+1] += vo[2] + po[l+2] += vo[3] + po[l+3] += vo[4] + po[l+4] += vo[5] + po[l+5] += vo[6] + po[l+6] += vo[7] + po[l+7] += vo[8] + po[l1] += vo[9] + po[l1+1] += vo[10] + po[l1+2] += vo[11] + po[l1+3] += vo[12] + po[l1+4] += vo[13] + po[l1+5] += vo[14] + po[l1+6] += vo[15] + po[l1+7] += vo[16] + po[l2] += vo[17] + po[l2+1] += vo[18] + po[l2+2] += vo[19] + po[l2+3] += vo[20] + po[l2+4] += vo[21] + po[l2+5] += vo[22] + po[l2+6] += vo[23] + po[l2+7] += vo[24] + po[l3] += vo[25] + po[l3+1] += vo[26] + po[l3+2] += vo[27] + po[l3+3] += vo[28] + po[l3+4] += vo[29] + po[l3+5] += vo[30] + po[l3+6] += vo[31] + po[l3+7] += vo[32] + end + + # @fastmath p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + # p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7], + # p[l2], p[l2+1], p[l2+2], p[l2+3], p[l2+4], p[l2+5], p[l2+6], p[l2+7], + # p[l3], p[l3+1], p[l3+2], p[l3+3], p[l3+4], p[l3+5], p[l3+6], p[l3+7] = vi * mat + end + end + + parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, mask0, mask1, mask2, U, v, vout) +end + +"""""" + applys when q1 <= 3 and q2 > 4, U is the transposed op +"""""" +function _apply_twobody_gate_LH!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + q1, q2 = key + sizej = 1 << (q2-1) + mask0 = sizej - 1 + mask1 = xor(L - 1, 2 * sizej - 1) + + f1H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{8, 4}(p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15], + p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16], + p[l1+1], p[l1+3], p[l1+5], p[l1+7], p[l1+9], p[l1+11], p[l1+13], p[l1+15], + p[l1+2], p[l1+4], p[l1+6], p[l1+8], p[l1+10], p[l1+12], p[l1+14], p[l1+16]) + + @fastmath begin + vo = vi * mat + + po[l+1] += vo[1] + po[l+3] += vo[2] + po[l+5] += vo[3] + po[l+7] += vo[4] + po[l+9] += vo[5] + po[l+11] += vo[6] + po[l+13] += vo[7] + po[l+15] += vo[8] + po[l+2] += vo[9] + po[l+4] += vo[10] + po[l+6] += vo[11] + po[l+8] += vo[12] + po[l+10] += vo[13] + po[l+12] += vo[14] + po[l+14] += vo[15] + po[l+16] += vo[16] + po[l1+1] += vo[17] + po[l1+3] += vo[18] + po[l1+5] += vo[19] + po[l1+7] += vo[20] + po[l1+9] += vo[21] + po[l1+11] += vo[22] + po[l1+13] += vo[23] + po[l1+15] += vo[24] + po[l1+2] += vo[25] + po[l1+4] += vo[26] + po[l1+6] += vo[27] + po[l1+8] += vo[28] + po[l1+10] += vo[29] + po[l1+12] += vo[30] + po[l1+14] += vo[31] + po[l1+16] += vo[32] + end + + # @fastmath p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15], + # p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16], + # p[l1+1], p[l1+3], p[l1+5], p[l1+7], p[l1+9], p[l1+11], p[l1+13], p[l1+15], + # p[l1+2], p[l1+4], p[l1+6], p[l1+8], p[l1+10], p[l1+12], p[l1+14], p[l1+16] = vi * mat + end + end + + f2H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14], + p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16], + p[l1+1], p[l1+2], p[l1+5], p[l1+6], p[l1+9], p[l1+10], p[l1+13], p[l1+14], + p[l1+3], p[l1+4], p[l1+7], p[l1+8], p[l1+11], p[l1+12], p[l1+15], p[l1+16]) + + @fastmath begin + vo = vi * mat + + po[l+1] += vo[1] + po[l+2] += vo[2] + po[l+5] += vo[3] + po[l+6] += vo[4] + po[l+9] += vo[5] + po[l+10] += vo[6] + po[l+13] += vo[7] + po[l+14] += vo[8] + po[l+3] += vo[9] + po[l+4] += vo[10] + po[l+7] += vo[11] + po[l+8] += vo[12] + po[l+11] += vo[13] + po[l+12] += vo[14] + po[l+15] += vo[15] + po[l+16] += vo[16] + po[l1+1] += vo[17] + po[l1+2] += vo[18] + po[l1+5] += vo[19] + po[l1+6] += vo[20] + po[l1+9] += vo[21] + po[l1+10] += vo[22] + po[l1+13] += vo[23] + po[l1+14] += vo[24] + po[l1+3] += vo[25] + po[l1+4] += vo[26] + po[l1+7] += vo[27] + po[l1+8] += vo[28] + po[l1+11] += vo[29] + po[l1+12] += vo[30] + po[l1+15] += vo[31] + po[l1+16] += vo[32] + end + + # @fastmath p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14], + # p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16], + # p[l1+1], p[l1+2], p[l1+5], p[l1+6], p[l1+9], p[l1+10], p[l1+13], p[l1+14], + # p[l1+3], p[l1+4], p[l1+7], p[l1+8], p[l1+11], p[l1+12], p[l1+15], p[l1+16] = vi * mat + end + end + + f3H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12], + p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16], + p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+9], p[l1+10], p[l1+11], p[l1+12], + p[l1+5], p[l1+6], p[l1+7], p[l1+8], p[l1+13], p[l1+14], p[l1+15], p[l1+16]) + + @fastmath begin + vo = vi * mat + + po[l+1] += vo[1] + po[l+2] += vo[2] + po[l+3] += vo[3] + po[l+4] += vo[4] + po[l+9] += vo[5] + po[l+10] += vo[6] + po[l+11] += vo[7] + po[l+12] += vo[8] + po[l+5] += vo[9] + po[l+6] += vo[10] + po[l+7] += vo[11] + po[l+8] += vo[12] + po[l+13] += vo[13] + po[l+14] += vo[14] + po[l+15] += vo[15] + po[l+16] += vo[16] + po[l1+1] += vo[17] + po[l1+2] += vo[18] + po[l1+3] += vo[19] + po[l1+4] += vo[20] + po[l1+9] += vo[21] + po[l1+10] += vo[22] + po[l1+11] += vo[23] + po[l1+12] += vo[24] + po[l1+5] += vo[25] + po[l1+6] += vo[26] + po[l1+7] += vo[27] + po[l1+8] += vo[28] + po[l1+13] += vo[29] + po[l1+14] += vo[30] + po[l1+15] += vo[31] + po[l1+16] += vo[32] + end + + # @fastmath p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12], + # p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16], + # p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+9], p[l1+10], p[l1+11], p[l1+12], + # p[l1+5], p[l1+6], p[l1+7], p[l1+8], p[l1+13], p[l1+14], p[l1+15], p[l1+16] = vi * mat + end + end + + if q1 == 1 + f = f1H + elseif q1 == 2 + f = f2H + elseif q1 == 3 + f = f3H + else + error(""qubit position $q1 not allowed for LH."") + end + total_itr = div(L, 32) + + parallel_run(total_itr, Threads.nthreads(), f, sizej, mask0, mask1, U, v, vout) +end + + +"""""" + applys when both keys <= 4 +"""""" +function _apply_twobody_gate_LL!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + q1, q2 = key + f12(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 32 * i + 1 + vi = SMatrix{4, 8}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15], + p[l+16], p[l+17], p[l+18], p[l+19], p[l+20], p[l+21], p[l+22], p[l+23], + p[l+24], p[l+25], p[l+26], p[l+27], p[l+28], p[l+29], p[l+30], p[l+31]) + + @fastmath begin + vo = mat * vi + + po[l] += vo[1] + po[l+1] += vo[2] + po[l+2] += vo[3] + po[l+3] += vo[4] + po[l+4] += vo[5] + po[l+5] += vo[6] + po[l+6] += vo[7] + po[l+7] += vo[8] + po[l+8] += vo[9] + po[l+9] += vo[10] + po[l+10] += vo[11] + po[l+11] += vo[12] + po[l+12] += vo[13] + po[l+13] += vo[14] + po[l+14] += vo[15] + po[l+15] += vo[16] + po[l+16] += vo[17] + po[l+17] += vo[18] + po[l+18] += vo[19] + po[l+19] += vo[20] + po[l+20] += vo[21] + po[l+21] += vo[22] + po[l+22] += vo[23] + po[l+23] += vo[24] + po[l+24] += vo[25] + po[l+25] += vo[26] + po[l+26] += vo[27] + po[l+27] += vo[28] + po[l+28] += vo[29] + po[l+29] += vo[30] + po[l+30] += vo[31] + po[l+31] += vo[32] + end + + # @fastmath po[l:(l+31)] = mat * vi + end + end + f13(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 32 * i + 1 + vi = SMatrix{4, 8}(p[l], p[l+1], p[l+4], p[l+5], p[l+2], p[l+3], p[l+6], p[l+7], + p[l+8], p[l+9], p[l+12], p[l+13], p[l+10], p[l+11], p[l+14], p[l+15], + p[l+16], p[l+17], p[l+20], p[l+21], p[l+18], p[l+19], p[l+22], p[l+23], + p[l+24], p[l+25], p[l+28], p[l+29], p[l+26], p[l+27], p[l+30], p[l+31]) + + @fastmath begin + vo = mat * vi + + po[l] += vo[1] + po[l+1] += vo[2] + po[l+4] += vo[3] + po[l+5] += vo[4] + po[l+2] += vo[5] + po[l+3] += vo[6] + po[l+6] += vo[7] + po[l+7] += vo[8] + po[l+8] += vo[9] + po[l+9] += vo[10] + po[l+12] += vo[11] + po[l+13] += vo[12] + po[l+10] += vo[13] + po[l+11] += vo[14] + po[l+14] += vo[15] + po[l+15] += vo[16] + po[l+16] += vo[17] + po[l+17] += vo[18] + po[l+20] += vo[19] + po[l+21] += vo[20] + po[l+18] += vo[21] + po[l+19] += vo[22] + po[l+22] += vo[23] + po[l+23] += vo[24] + po[l+24] += vo[25] + po[l+25] += vo[26] + po[l+28] += vo[27] + po[l+29] += vo[28] + po[l+26] += vo[29] + po[l+27] += vo[30] + po[l+30] += vo[31] + po[l+31] += vo[32] + end + + # @fastmath p[l], p[l+1], p[l+4], p[l+5], p[l+2], p[l+3], p[l+6], p[l+7], + # p[l+8], p[l+9], p[l+12], p[l+13], p[l+10], p[l+11], p[l+14], p[l+15], + # p[l+16], p[l+17], p[l+20], p[l+21], p[l+18], p[l+19], p[l+22], p[l+23], + # p[l+24], p[l+25], p[l+28], p[l+29], p[l+26], p[l+27], p[l+30], p[l+31] = mat * vi + end + end + f14(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+9], p[l+10], p[l+3], p[l+4], p[l+11], p[l+12], + p[l+5], p[l+6], p[l+13], p[l+14], p[l+7], p[l+8], p[l+15], p[l+16], + p[l+17], p[l+18], p[l+25], p[l+26], p[l+19], p[l+20], p[l+27], p[l+28], + p[l+21], p[l+22], p[l+29], p[l+30], p[l+23], p[l+24], p[l+31], p[l+32]) + + @fastmath begin + vo = mat * vi + + po[l+1] += vo[1] + po[l+2] += vo[2] + po[l+9] += vo[3] + po[l+10] += vo[4] + po[l+3] += vo[5] + po[l+4] += vo[6] + po[l+11] += vo[7] + po[l+12] += vo[8] + po[l+5] += vo[9] + po[l+6] += vo[10] + po[l+13] += vo[11] + po[l+14] += vo[12] + po[l+7] += vo[13] + po[l+8] += vo[14] + po[l+15] += vo[15] + po[l+16] += vo[16] + po[l+17] += vo[17] + po[l+18] += vo[18] + po[l+25] += vo[19] + po[l+26] += vo[20] + po[l+19] += vo[21] + po[l+20] += vo[22] + po[l+27] += vo[23] + po[l+28] += vo[24] + po[l+21] += vo[25] + po[l+22] += vo[26] + po[l+29] += vo[27] + po[l+30] += vo[28] + po[l+23] += vo[29] + po[l+24] += vo[30] + po[l+31] += vo[31] + po[l+32] += vo[32] + end + + # @fastmath p[l+1], p[l+2], p[l+9], p[l+10], p[l+3], p[l+4], p[l+11], p[l+12], + # p[l+5], p[l+6], p[l+13], p[l+14], p[l+7], p[l+8], p[l+15], p[l+16], + # p[l+17], p[l+18], p[l+25], p[l+26], p[l+19], p[l+20], p[l+27], p[l+28], + # p[l+21], p[l+22], p[l+29], p[l+30], p[l+23], p[l+24], p[l+31], p[l+32] = mat * vi + end + end + f23(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 32 * i + 1 + vi = SMatrix{4, 8}(p[l], p[l+2], p[l+4], p[l+6], p[l+1], p[l+3], p[l+5], p[l+7], + p[l+8], p[l+10], p[l+12], p[l+14], p[l+9], p[l+11], p[l+13], p[l+15], + p[l+16], p[l+18], p[l+20], p[l+22], p[l+17], p[l+19], p[l+21], p[l+23], + p[l+24], p[l+26], p[l+28], p[l+30], p[l+25], p[l+27], p[l+29], p[l+31]) + + @fastmath begin + vo = mat * vi + + po[l] += vo[1] + po[l+2] += vo[2] + po[l+4] += vo[3] + po[l+6] += vo[4] + po[l+1] += vo[5] + po[l+3] += vo[6] + po[l+5] += vo[7] + po[l+7] += vo[8] + po[l+8] += vo[9] + po[l+10] += vo[10] + po[l+12] += vo[11] + po[l+14] += vo[12] + po[l+9] += vo[13] + po[l+11] += vo[14] + po[l+13] += vo[15] + po[l+15] += vo[16] + po[l+16] += vo[17] + po[l+18] += vo[18] + po[l+20] += vo[19] + po[l+22] += vo[20] + po[l+17] += vo[21] + po[l+19] += vo[22] + po[l+21] += vo[23] + po[l+23] += vo[24] + po[l+24] += vo[25] + po[l+26] += vo[26] + po[l+28] += vo[27] + po[l+30] += vo[28] + po[l+25] += vo[29] + po[l+27] += vo[30] + po[l+29] += vo[31] + po[l+31] += vo[32] + end + + # @fastmath p[l], p[l+2], p[l+4], p[l+6], p[l+1], p[l+3], p[l+5], p[l+7], + # p[l+8], p[l+10], p[l+12], p[l+14], p[l+9], p[l+11], p[l+13], p[l+15], + # p[l+16], p[l+18], p[l+20], p[l+22], p[l+17], p[l+19], p[l+21], p[l+23], + # p[l+24], p[l+26], p[l+28], p[l+30], p[l+25], p[l+27], p[l+29], p[l+31] = mat * vi + end + end + f24(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+9], p[l+11], p[l+2], p[l+4], p[l+10], p[l+12], + p[l+5], p[l+7], p[l+13], p[l+15], p[l+6], p[l+8], p[l+14], p[l+16], + p[l+17], p[l+19], p[l+25], p[l+27], p[l+18], p[l+20], p[l+26], p[l+28], + p[l+21], p[l+23], p[l+29], p[l+31], p[l+22], p[l+24], p[l+30], p[l+32]) + + @fastmath begin + vo = mat * vi + + po[l+1] += vo[1] + po[l+3] += vo[2] + po[l+9] += vo[3] + po[l+11] += vo[4] + po[l+2] += vo[5] + po[l+4] += vo[6] + po[l+10] += vo[7] + po[l+12] += vo[8] + po[l+5] += vo[9] + po[l+7] += vo[10] + po[l+13] += vo[11] + po[l+15] += vo[12] + po[l+6] += vo[13] + po[l+8] += vo[14] + po[l+14] += vo[15] + po[l+16] += vo[16] + po[l+17] += vo[17] + po[l+19] += vo[18] + po[l+25] += vo[19] + po[l+27] += vo[20] + po[l+18] += vo[21] + po[l+20] += vo[22] + po[l+26] += vo[23] + po[l+28] += vo[24] + po[l+21] += vo[25] + po[l+23] += vo[26] + po[l+29] += vo[27] + po[l+31] += vo[28] + po[l+22] += vo[29] + po[l+24] += vo[30] + po[l+30] += vo[31] + po[l+32] += vo[32] + end + + # @fastmath p[l+1], p[l+3], p[l+9], p[l+11], p[l+2], p[l+4], p[l+10], p[l+12], + # p[l+5], p[l+7], p[l+13], p[l+15], p[l+6], p[l+8], p[l+14], p[l+16], + # p[l+17], p[l+19], p[l+25], p[l+27], p[l+18], p[l+20], p[l+26], p[l+28], + # p[l+21], p[l+23], p[l+29], p[l+31], p[l+22], p[l+24], p[l+30], p[l+32] = mat * vi + end + end + f34(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{4, 8}(p[l+1], p[l+5], p[l+9], p[l+13], p[l+2], p[l+6], p[l+10], p[l+14], + p[l+3], p[l+7], p[l+11], p[l+15], p[l+4], p[l+8], p[l+12], p[l+16], + p[l+17], p[l+21], p[l+25], p[l+29], p[l+18], p[l+22], p[l+26], p[l+30], + p[l+19], p[l+23], p[l+27], p[l+31], p[l+20], p[l+24], p[l+28], p[l+32]) + + @fastmath begin + vo = mat * vi + + po[l+1] += vo[1] + po[l+5] += vo[2] + po[l+9] += vo[3] + po[l+13] += vo[4] + po[l+2] += vo[5] + po[l+6] += vo[6] + po[l+10] += vo[7] + po[l+14] += vo[8] + po[l+3] += vo[9] + po[l+7] += vo[10] + po[l+11] += vo[11] + po[l+15] += vo[12] + po[l+4] += vo[13] + po[l+8] += vo[14] + po[l+12] += vo[15] + po[l+16] += vo[16] + po[l+17] += vo[17] + po[l+21] += vo[18] + po[l+25] += vo[19] + po[l+29] += vo[20] + po[l+18] += vo[21] + po[l+22] += vo[22] + po[l+26] += vo[23] + po[l+30] += vo[24] + po[l+19] += vo[25] + po[l+23] += vo[26] + po[l+27] += vo[27] + po[l+31] += vo[28] + po[l+20] += vo[29] + po[l+24] += vo[30] + po[l+28] += vo[31] + po[l+32] += vo[32] + end + + # @fastmath p[l+1], p[l+5], p[l+9], p[l+13], p[l+2], p[l+6], p[l+10], p[l+14], + # p[l+3], p[l+7], p[l+11], p[l+15], p[l+4], p[l+8], p[l+12], p[l+16], + # p[l+17], p[l+21], p[l+25], p[l+29], p[l+18], p[l+22], p[l+26], p[l+30], + # p[l+19], p[l+23], p[l+27], p[l+31], p[l+20], p[l+24], p[l+28], p[l+32] = mat * vi + end + end + if q1==1 && q2 == 2 + f = f12 + elseif q1==1 && q2 == 3 + f = f13 + elseif q1==1 && q2 == 4 + f = f14 + elseif q1==2 && q2 == 3 + f = f23 + elseif q1==2 && q2 == 4 + f = f24 + elseif q1==3 && q2 == 4 + f = f34 + else + error(""qubit position $q1 and $q2 not allowed for LL."") + end + total_itr = div(L, 32) + + parallel_run(total_itr, Threads.nthreads(), f, U, v, vout) +end + +function _apply_gate_threaded2!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + q0, q1 = key + if q0 > 3 + return _apply_twobody_gate_HH!(key, SMatrix{4,4, eltype(v)}(transpose(U)), v, vout) + elseif q1 > 4 + return _apply_twobody_gate_LH!(key, SMatrix{4,4, eltype(v)}(transpose(U)), v, vout) + else + return _apply_twobody_gate_LL!(key, SMatrix{4,4, eltype(v)}(U), v, vout) + end +end + + +"""""" + applys when both keys > 2, U is assumed to be transposed +"""""" +function _apply_threebody_gate_HHH!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + q1, q2, q3 = key + pos1, pos2, pos3 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1) + # stride2, stride3 = pos1 << 1, pos2 << 1 + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(pos3 - 1, 2 * pos2 - 1) + mask3 = xor(L - 1, 2 * pos3 - 1) + # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"") + + total_itr = div(L, 32) + f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, m4::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l000 = (32 * i & m4) | (16 * i & m3) | (8 * i & m2) | (4 * i & m1) + 1 + l100 = l000 + posa + l010 = l000 + posb + l110 = l010 + posa + + l001 = l000 + posc + l101 = l001 + posa + l011 = l001 + posb + l111 = l011 + posa + + # println(""$l000, $l100, $l010, $l110, $l001, $l101, $l011, $l111"") + vi = SMatrix{4, 8}(p[l000], p[l000+1], p[l000+2], p[l000+3], + p[l100], p[l100+1], p[l100+2], p[l100+3], + p[l010], p[l010+1], p[l010+2], p[l010+3], + p[l110], p[l110+1], p[l110+2], p[l110+3], + p[l001], p[l001+1], p[l001+2], p[l001+3], + p[l101], p[l101+1], p[l101+2], p[l101+3], + p[l011], p[l011+1], p[l011+2], p[l011+3], + p[l111], p[l111+1], p[l111+2], p[l111+3]) + + @fastmath begin + vo = vi * mat + + po[l000] += vo[1] + po[l000+1] += vo[2] + po[l000+2] += vo[3] + po[l000+3] += vo[4] + po[l100] += vo[5] + po[l100+1] += vo[6] + po[l100+2] += vo[7] + po[l100+3] += vo[8] + po[l010] += vo[9] + po[l010+1] += vo[10] + po[l010+2] += vo[11] + po[l010+3] += vo[12] + po[l110] += vo[13] + po[l110+1] += vo[14] + po[l110+2] += vo[15] + po[l110+3] += vo[16] + po[l001] += vo[17] + po[l001+1] += vo[18] + po[l001+2] += vo[19] + po[l001+3] += vo[20] + po[l101] += vo[21] + po[l101+1] += vo[22] + po[l101+2] += vo[23] + po[l101+3] += vo[24] + po[l011] += vo[25] + po[l011+1] += vo[26] + po[l011+2] += vo[27] + po[l011+3] += vo[28] + po[l111] += vo[29] + po[l111+1] += vo[30] + po[l111+2] += vo[31] + po[l111+3] += vo[32] + end + + # @fastmath p[l000], p[l000+1], p[l000+2], p[l000+3], + # p[l100], p[l100+1], p[l100+2], p[l100+3], + # p[l010], p[l010+1], p[l010+2], p[l010+3], + # p[l110], p[l110+1], p[l110+2], p[l110+3], + # p[l001], p[l001+1], p[l001+2], p[l001+3], + # p[l101], p[l101+1], p[l101+2], p[l101+3], + # p[l011], p[l011+1], p[l011+2], p[l011+3], + # p[l111], p[l111+1], p[l111+2], p[l111+3] = vi * mat + end + end + + parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, pos3, mask0, mask1, mask2, mask3, U, v, vout) +end + +"""""" + applys when q1 <= 2 and q2 > 3, U is the transposed op +"""""" +function _apply_threebody_gate_LHH!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + q1, q2, q3 = key + sizej, sizel = 1 << (q2-1), 1 << (q3-1) + mask0 = sizej - 1 + mask1 = xor(sizel - 1, 2 * sizej - 1) + mask2 = xor(L-1, 2 * sizel - 1) + + f1H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1) + l1 = l + posb + l2 = l + posc + l3 = l2 + posb + # println(""$l, $l1, $l2, $l3"") + vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+5], p[l+7], + p[l+2], p[l+4], p[l+6], p[l+8], + p[l1+1], p[l1+3], p[l1+5], p[l1+7], + p[l1+2], p[l1+4], p[l1+6], p[l1+8], + p[l2+1], p[l2+3], p[l2+5], p[l2+7], + p[l2+2], p[l2+4], p[l2+6], p[l2+8], + p[l3+1], p[l3+3], p[l3+5], p[l3+7], + p[l3+2], p[l3+4], p[l3+6], p[l3+8]) + + @fastmath begin + vo = vi * mat + + po[l+1] += vo[1] + po[l+3] += vo[2] + po[l+5] += vo[3] + po[l+7] += vo[4] + po[l+2] += vo[5] + po[l+4] += vo[6] + po[l+6] += vo[7] + po[l+8] += vo[8] + po[l1+1] += vo[9] + po[l1+3] += vo[10] + po[l1+5] += vo[11] + po[l1+7] += vo[12] + po[l1+2] += vo[13] + po[l1+4] += vo[14] + po[l1+6] += vo[15] + po[l1+8] += vo[16] + po[l2+1] += vo[17] + po[l2+3] += vo[18] + po[l2+5] += vo[19] + po[l2+7] += vo[20] + po[l2+2] += vo[21] + po[l2+4] += vo[22] + po[l2+6] += vo[23] + po[l2+8] += vo[24] + po[l3+1] += vo[25] + po[l3+3] += vo[26] + po[l3+5] += vo[27] + po[l3+7] += vo[28] + po[l3+2] += vo[29] + po[l3+4] += vo[30] + po[l3+6] += vo[31] + po[l3+8] += vo[32] + end + + # @fastmath p[l+1], p[l+3], p[l+5], p[l+7], + # p[l+2], p[l+4], p[l+6], p[l+8], + # p[l1+1], p[l1+3], p[l1+5], p[l1+7], + # p[l1+2], p[l1+4], p[l1+6], p[l1+8], + # p[l2+1], p[l2+3], p[l2+5], p[l2+7], + # p[l2+2], p[l2+4], p[l2+6], p[l2+8], + # p[l3+1], p[l3+3], p[l3+5], p[l3+7], + # p[l3+2], p[l3+4], p[l3+6], p[l3+8] = vi * mat + end + end + + f2H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1) + l1 = l + posb + l2 = l + posc + l3 = l2 + posb + vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+5], p[l+6], + p[l+3], p[l+4], p[l+7], p[l+8], + p[l1+1], p[l1+2], p[l1+5], p[l1+6], + p[l1+3], p[l1+4], p[l1+7], p[l1+8], + p[l2+1], p[l2+2], p[l2+5], p[l2+6], + p[l2+3], p[l2+4], p[l2+7], p[l2+8], + p[l3+1], p[l3+2], p[l3+5], p[l3+6], + p[l3+3], p[l3+4], p[l3+7], p[l3+8]) + + @fastmath begin + vo = vi * mat + + po[l+1] += vo[1] + po[l+2] += vo[2] + po[l+5] += vo[3] + po[l+6] += vo[4] + po[l+3] += vo[5] + po[l+4] += vo[6] + po[l+7] += vo[7] + po[l+8] += vo[8] + po[l1+1] += vo[9] + po[l1+2] += vo[10] + po[l1+5] += vo[11] + po[l1+6] += vo[12] + po[l1+3] += vo[13] + po[l1+4] += vo[14] + po[l1+7] += vo[15] + po[l1+8] += vo[16] + po[l2+1] += vo[17] + po[l2+2] += vo[18] + po[l2+5] += vo[19] + po[l2+6] += vo[20] + po[l2+3] += vo[21] + po[l2+4] += vo[22] + po[l2+7] += vo[23] + po[l2+8] += vo[24] + po[l3+1] += vo[25] + po[l3+2] += vo[26] + po[l3+5] += vo[27] + po[l3+6] += vo[28] + po[l3+3] += vo[29] + po[l3+4] += vo[30] + po[l3+7] += vo[31] + po[l3+8] += vo[32] + end + + # @fastmath p[l+1], p[l+2], p[l+5], p[l+6], + # p[l+3], p[l+4], p[l+7], p[l+8], + # p[l1+1], p[l1+2], p[l1+5], p[l1+6], + # p[l1+3], p[l1+4], p[l1+7], p[l1+8], + # p[l2+1], p[l2+2], p[l2+5], p[l2+6], + # p[l2+3], p[l2+4], p[l2+7], p[l2+8], + # p[l3+1], p[l3+2], p[l3+5], p[l3+6], + # p[l3+3], p[l3+4], p[l3+7], p[l3+8] = vi * mat + end + end + + f3H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1) + l1 = l + posb + l2 = l + posc + l3 = l2 + posb + vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+3], p[l+4], + p[l+5], p[l+6], p[l+7], p[l+8], + p[l1+1], p[l1+2], p[l1+3], p[l1+4], + p[l1+5], p[l1+6], p[l1+7], p[l1+8], + p[l2+1], p[l2+2], p[l2+3], p[l2+4], + p[l2+5], p[l2+6], p[l2+7], p[l2+8], + p[l3+1], p[l3+2], p[l3+3], p[l3+4], + p[l3+5], p[l3+6], p[l3+7], p[l3+8]) + + @fastmath begin + vo = vi * mat + + po[l+1] += vo[1] + po[l+2] += vo[2] + po[l+3] += vo[3] + po[l+4] += vo[4] + po[l+5] += vo[5] + po[l+6] += vo[6] + po[l+7] += vo[7] + po[l+8] += vo[8] + po[l1+1] += vo[9] + po[l1+2] += vo[10] + po[l1+3] += vo[11] + po[l1+4] += vo[12] + po[l1+5] += vo[13] + po[l1+6] += vo[14] + po[l1+7] += vo[15] + po[l1+8] += vo[16] + po[l2+1] += vo[17] + po[l2+2] += vo[18] + po[l2+3] += vo[19] + po[l2+4] += vo[20] + po[l2+5] += vo[21] + po[l2+6] += vo[22] + po[l2+7] += vo[23] + po[l2+8] += vo[24] + po[l3+1] += vo[25] + po[l3+2] += vo[26] + po[l3+3] += vo[27] + po[l3+4] += vo[28] + po[l3+5] += vo[29] + po[l3+6] += vo[30] + po[l3+7] += vo[31] + po[l3+8] += vo[32] + end + + # @fastmath p[l+1], p[l+2], p[l+3], p[l+4], + # p[l+5], p[l+6], p[l+7], p[l+8], + # p[l1+1], p[l1+2], p[l1+3], p[l1+4], + # p[l1+5], p[l1+6], p[l1+7], p[l1+8], + # p[l2+1], p[l2+2], p[l2+3], p[l2+4], + # p[l2+5], p[l2+6], p[l2+7], p[l2+8], + # p[l3+1], p[l3+2], p[l3+3], p[l3+4], + # p[l3+5], p[l3+6], p[l3+7], p[l3+8] = vi * mat + end + end + + if q1 == 1 + f = f1H + elseif q1 == 2 + f = f2H + elseif q1 == 3 + f = f3H + else + error(""qubit position $q1 not allowed for LHH."") + end + (q2 > 3) || error(""qubit 2 position $q2 not allowed for LHH."") + total_itr = div(L, 32) + + parallel_run(total_itr, Threads.nthreads(), f, sizej, sizel, mask0, mask1, mask2, U, v, vout) +end + +"""""" + applys when q1, q2 <= 3 and q3 > 4, U is the transposed op +"""""" +function _apply_threebody_gate_LLH!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + q1, q2, q3 = key + sizej = 1 << (q3-1) + mask0 = sizej - 1 + mask1 = xor(L - 1, 2 * sizej - 1) + + f12H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{4, 8}(p[l+1], p[l+5], p[l+9], p[l+13], + p[l+2], p[l+6], p[l+10], p[l+14], + p[l+3], p[l+7], p[l+11], p[l+15], + p[l+4], p[l+8], p[l+12], p[l+16], + p[l1+1], p[l1+5], p[l1+9], p[l1+13], + p[l1+2], p[l1+6], p[l1+10], p[l1+14], + p[l1+3], p[l1+7], p[l1+11], p[l1+15], + p[l1+4], p[l1+8], p[l1+12], p[l1+16]) + + @fastmath begin + vo = vi * mat + + po[l+1] += vo[1] + po[l+5] += vo[2] + po[l+9] += vo[3] + po[l+13] += vo[4] + po[l+2] += vo[5] + po[l+6] += vo[6] + po[l+10] += vo[7] + po[l+14] += vo[8] + po[l+3] += vo[9] + po[l+7] += vo[10] + po[l+11] += vo[11] + po[l+15] += vo[12] + po[l+4] += vo[13] + po[l+8] += vo[14] + po[l+12] += vo[15] + po[l+16] += vo[16] + po[l1+1] += vo[17] + po[l1+5] += vo[18] + po[l1+9] += vo[19] + po[l1+13] += vo[20] + po[l1+2] += vo[21] + po[l1+6] += vo[22] + po[l1+10] += vo[23] + po[l1+14] += vo[24] + po[l1+3] += vo[25] + po[l1+7] += vo[26] + po[l1+11] += vo[27] + po[l1+15] += vo[28] + po[l1+4] += vo[29] + po[l1+8] += vo[30] + po[l1+12] += vo[31] + po[l1+16] += vo[32] + end + + # @fastmath p[l+1], p[l+5], p[l+9], p[l+13], + # p[l+2], p[l+6], p[l+10], p[l+14], + # p[l+3], p[l+7], p[l+11], p[l+15], + # p[l+4], p[l+8], p[l+12], p[l+16], + # p[l1+1], p[l1+5], p[l1+9], p[l1+13], + # p[l1+2], p[l1+6], p[l1+10], p[l1+14], + # p[l1+3], p[l1+7], p[l1+11], p[l1+15], + # p[l1+4], p[l1+8], p[l1+12], p[l1+16] = vi * mat + end + end + + f13H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+9], p[l+11], + p[l+2], p[l+4], p[l+10], p[l+12], + p[l+5], p[l+7], p[l+13], p[l+15], + p[l+6], p[l+8], p[l+14], p[l+16], + p[l1+1], p[l1+3], p[l1+9], p[l1+11], + p[l1+2], p[l1+4], p[l1+10], p[l1+12], + p[l1+5], p[l1+7], p[l1+13], p[l1+15], + p[l1+6], p[l1+8], p[l1+14], p[l1+16]) + + @fastmath begin + vo = vi * mat + + po[l+1] += vo[1] + po[l+3] += vo[2] + po[l+9] += vo[3] + po[l+11] += vo[4] + po[l+2] += vo[5] + po[l+4] += vo[6] + po[l+10] += vo[7] + po[l+12] += vo[8] + po[l+5] += vo[9] + po[l+7] += vo[10] + po[l+13] += vo[11] + po[l+15] += vo[12] + po[l+6] += vo[13] + po[l+8] += vo[14] + po[l+14] += vo[15] + po[l+16] += vo[16] + po[l1+1] += vo[17] + po[l1+3] += vo[18] + po[l1+9] += vo[19] + po[l1+11] += vo[20] + po[l1+2] += vo[21] + po[l1+4] += vo[22] + po[l1+10] += vo[23] + po[l1+12] += vo[24] + po[l1+5] += vo[25] + po[l1+7] += vo[26] + po[l1+13] += vo[27] + po[l1+15] += vo[28] + po[l1+6] += vo[29] + po[l1+8] += vo[30] + po[l1+14] += vo[31] + po[l1+16] += vo[32] + end + + # @fastmath p[l+1], p[l+3], p[l+9], p[l+11], + # p[l+2], p[l+4], p[l+10], p[l+12], + # p[l+5], p[l+7], p[l+13], p[l+15], + # p[l+6], p[l+8], p[l+14], p[l+16], + # p[l1+1], p[l1+3], p[l1+9], p[l1+11], + # p[l1+2], p[l1+4], p[l1+10], p[l1+12], + # p[l1+5], p[l1+7], p[l1+13], p[l1+15], + # p[l1+6], p[l1+8], p[l1+14], p[l1+16] = vi * mat + end + end + + f23H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+9], p[l+10], + p[l+3], p[l+4], p[l+11], p[l+12], + p[l+5], p[l+6], p[l+13], p[l+14], + p[l+7], p[l+8], p[l+15], p[l+16], + p[l1+1], p[l1+2], p[l1+9], p[l1+10], + p[l1+3], p[l1+4], p[l1+11], p[l1+12], + p[l1+5], p[l1+6], p[l1+13], p[l1+14], + p[l1+7], p[l1+8], p[l1+15], p[l1+16]) + + @fastmath begin + vo = vi * mat + + po[l+1] += vo[1] + po[l+2] += vo[2] + po[l+9] += vo[3] + po[l+10] += vo[4] + po[l+3] += vo[5] + po[l+4] += vo[6] + po[l+11] += vo[7] + po[l+12] += vo[8] + po[l+5] += vo[9] + po[l+6] += vo[10] + po[l+13] += vo[11] + po[l+14] += vo[12] + po[l+7] += vo[13] + po[l+8] += vo[14] + po[l+15] += vo[15] + po[l+16] += vo[16] + po[l1+1] += vo[17] + po[l1+2] += vo[18] + po[l1+9] += vo[19] + po[l1+10] += vo[20] + po[l1+3] += vo[21] + po[l1+4] += vo[22] + po[l1+11] += vo[23] + po[l1+12] += vo[24] + po[l1+5] += vo[25] + po[l1+6] += vo[26] + po[l1+13] += vo[27] + po[l1+14] += vo[28] + po[l1+7] += vo[29] + po[l1+8] += vo[30] + po[l1+15] += vo[31] + po[l1+16] += vo[32] + end + + # @fastmath p[l+1], p[l+2], p[l+9], p[l+10], + # p[l+3], p[l+4], p[l+11], p[l+12], + # p[l+5], p[l+6], p[l+13], p[l+14], + # p[l+7], p[l+8], p[l+15], p[l+16], + # p[l1+1], p[l1+2], p[l1+9], p[l1+10], + # p[l1+3], p[l1+4], p[l1+11], p[l1+12], + # p[l1+5], p[l1+6], p[l1+13], p[l1+14], + # p[l1+7], p[l1+8], p[l1+15], p[l1+16] = vi * mat + end + end + + if q1 == 1 && q2 == 2 + f = f12H + elseif q1 == 1 && q2 == 3 + f = f13H + elseif q1 == 2 && q2 == 3 + f = f23H + else + error(""qubit position $q1 not allowed for LH."") + end + total_itr = div(L, 32) + + parallel_run(total_itr, Threads.nthreads(), f, sizej, mask0, mask1, U, v, vout) +end + +"""""" + applys when both keys <= 4 +"""""" +function _apply_threebody_gate_LLL!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + q1, q2, q3 = key + f123(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 32 * i + 1 + vi = SMatrix{8, 4}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15], + p[l+16], p[l+17], p[l+18], p[l+19], p[l+20], p[l+21], p[l+22], p[l+23], + p[l+24], p[l+25], p[l+26], p[l+27], p[l+28], p[l+29], p[l+30], p[l+31]) + + @fastmath begin + vo = mat * vi + + po[l] += vo[1] + po[l+1] += vo[2] + po[l+2] += vo[3] + po[l+3] += vo[4] + po[l+4] += vo[5] + po[l+5] += vo[6] + po[l+6] += vo[7] + po[l+7] += vo[8] + po[l+8] += vo[9] + po[l+9] += vo[10] + po[l+10] += vo[11] + po[l+11] += vo[12] + po[l+12] += vo[13] + po[l+13] += vo[14] + po[l+14] += vo[15] + po[l+15] += vo[16] + po[l+16] += vo[17] + po[l+17] += vo[18] + po[l+18] += vo[19] + po[l+19] += vo[20] + po[l+20] += vo[21] + po[l+21] += vo[22] + po[l+22] += vo[23] + po[l+23] += vo[24] + po[l+24] += vo[25] + po[l+25] += vo[26] + po[l+26] += vo[27] + po[l+27] += vo[28] + po[l+28] += vo[29] + po[l+29] += vo[30] + po[l+30] += vo[31] + po[l+31] += vo[32] + end + # @fastmath p[l:(l+31)]= mat * vi + end + end + f124(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12], + p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16], + p[l+17], p[l+18], p[l+19], p[l+20], p[l+25], p[l+26], p[l+27], p[l+28], + p[l+21], p[l+22], p[l+23], p[l+24], p[l+29], p[l+30], p[l+31], p[l+32]) + + @fastmath begin + vo = mat * vi + + po[l+1] += vo[1] + po[l+2] += vo[2] + po[l+3] += vo[3] + po[l+4] += vo[4] + po[l+9] += vo[5] + po[l+10] += vo[6] + po[l+11] += vo[7] + po[l+12] += vo[8] + po[l+5] += vo[9] + po[l+6] += vo[10] + po[l+7] += vo[11] + po[l+8] += vo[12] + po[l+13] += vo[13] + po[l+14] += vo[14] + po[l+15] += vo[15] + po[l+16] += vo[16] + po[l+17] += vo[17] + po[l+18] += vo[18] + po[l+19] += vo[19] + po[l+20] += vo[20] + po[l+25] += vo[21] + po[l+26] += vo[22] + po[l+27] += vo[23] + po[l+28] += vo[24] + po[l+21] += vo[25] + po[l+22] += vo[26] + po[l+23] += vo[27] + po[l+24] += vo[28] + po[l+29] += vo[29] + po[l+30] += vo[30] + po[l+31] += vo[31] + po[l+32] += vo[32] + end + + # @fastmath p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12], + # p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16], + # p[l+17], p[l+18], p[l+19], p[l+20], p[l+25], p[l+26], p[l+27], p[l+28], + # p[l+21], p[l+22], p[l+23], p[l+24], p[l+29], p[l+30], p[l+31], p[l+32] = mat * vi + end + end + f134(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14], + p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16], + p[l+17], p[l+18], p[l+21], p[l+22], p[l+25], p[l+26], p[l+29], p[l+30], + p[l+19], p[l+20], p[l+23], p[l+24], p[l+27], p[l+28], p[l+31], p[l+32]) + + @fastmath begin + vo = mat * vi + + po[l+1] += vo[1] + po[l+2] += vo[2] + po[l+5] += vo[3] + po[l+6] += vo[4] + po[l+9] += vo[5] + po[l+10] += vo[6] + po[l+13] += vo[7] + po[l+14] += vo[8] + po[l+3] += vo[9] + po[l+4] += vo[10] + po[l+7] += vo[11] + po[l+8] += vo[12] + po[l+11] += vo[13] + po[l+12] += vo[14] + po[l+15] += vo[15] + po[l+16] += vo[16] + po[l+17] += vo[17] + po[l+18] += vo[18] + po[l+21] += vo[19] + po[l+22] += vo[20] + po[l+25] += vo[21] + po[l+26] += vo[22] + po[l+29] += vo[23] + po[l+30] += vo[24] + po[l+19] += vo[25] + po[l+20] += vo[26] + po[l+23] += vo[27] + po[l+24] += vo[28] + po[l+27] += vo[29] + po[l+28] += vo[30] + po[l+31] += vo[31] + po[l+32] += vo[32] + end + + # @fastmath p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14], + # p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16], + # p[l+17], p[l+18], p[l+21], p[l+22], p[l+25], p[l+26], p[l+29], p[l+30], + # p[l+19], p[l+20], p[l+23], p[l+24], p[l+27], p[l+28], p[l+31], p[l+32] = mat * vi + end + end + f234(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{8, 4}(p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15], + p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16], + p[l+17], p[l+19], p[l+21], p[l+23], p[l+25], p[l+27], p[l+29], p[l+31], + p[l+18], p[l+20], p[l+22], p[l+24], p[l+26], p[l+28], p[l+30], p[l+32]) + + @fastmath begin + vo = mat * vi + + po[l+1] += vo[1] + po[l+3] += vo[2] + po[l+5] += vo[3] + po[l+7] += vo[4] + po[l+9] += vo[5] + po[l+11] += vo[6] + po[l+13] += vo[7] + po[l+15] += vo[8] + po[l+2] += vo[9] + po[l+4] += vo[10] + po[l+6] += vo[11] + po[l+8] += vo[12] + po[l+10] += vo[13] + po[l+12] += vo[14] + po[l+14] += vo[15] + po[l+16] += vo[16] + po[l+17] += vo[17] + po[l+19] += vo[18] + po[l+21] += vo[19] + po[l+23] += vo[20] + po[l+25] += vo[21] + po[l+27] += vo[22] + po[l+29] += vo[23] + po[l+31] += vo[24] + po[l+18] += vo[25] + po[l+20] += vo[26] + po[l+22] += vo[27] + po[l+24] += vo[28] + po[l+26] += vo[29] + po[l+28] += vo[30] + po[l+30] += vo[31] + po[l+32] += vo[32] + end + + # @fastmath p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15], + # p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16], + # p[l+17], p[l+19], p[l+21], p[l+23], p[l+25], p[l+27], p[l+29], p[l+31], + # p[l+18], p[l+20], p[l+22], p[l+24], p[l+26], p[l+28], p[l+30], p[l+32] = mat * vi + end + end + if q1==1 && q2 == 2 && q3 == 3 + f = f123 + elseif q1==1 && q2 == 2 && q3 == 4 + f = f124 + elseif q1==1 && q2 == 3 && q3 == 4 + f = f134 + elseif q1==2 && q2 == 3 && q3 == 4 + f = f234 + else + error(""qubit position $q1 and $q2 not allowed for LL."") + end + total_itr = div(L, 32) + + parallel_run(total_itr, Threads.nthreads(), f, U, v, vout) +end + +function _apply_gate_threaded2!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + q0, q1, q2 = key + if q0 > 2 + return _apply_threebody_gate_HHH!(key, SMatrix{8,8, eltype(v)}(transpose(U)), v, vout) + elseif q1 > 3 + return _apply_threebody_gate_LHH!(key, SMatrix{8,8, eltype(v)}(transpose(U)), v, vout) + elseif q2 > 4 + return _apply_threebody_gate_LLH!(key, SMatrix{8,8, eltype(v)}(transpose(U)), v, vout) + else + return _apply_threebody_gate_LLL!(key, SMatrix{8,8, eltype(v)}(U), v, vout) + end +end + + +# assume vout is initialized with 0s +function _apply_threaded_util!(m::QubitsOperator, v::AbstractVector, vout::AbstractVector) + for (k, bond) in m.data + _apply_gate_threaded2!(k, _get_mat(length(k), bond), v, vout) + end + return vout +end + + + +","Julia" +"Conjugate","guochu/VQC.jl","src/hamiltonian/apply_qterms/short_range_serial.jl",".jl","3442","99"," + +function _apply_gate_2_impl!(key::Int, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + pos = 2^(key-1) + strid = pos * 2 + for i in 0:strid:(L-1) + @inbounds for j in 0:(pos-1) + l = i + j + 1 + vi1 = v[l] + vi2 = v[l + pos] + @fastmath vo1 = U[1,1] * vi1 + U[1,2] * vi2 + @fastmath vo2 = U[2,1] * vi1 + U[2,2] * vi2 + vout[l] += vo1 + vout[l + pos] += vo2 + end + end +end + +_apply_gate_2!(key::Int, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _apply_gate_2_impl!( + key, SMatrix{2,2, eltype(v)}(U), v, vout) +_apply_gate_2!(key::Tuple{Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _apply_gate_2!( + key[1], U, v, vout) + + +function _apply_gate_2_impl!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + # U = Matrix(transpose(reshape(U, 4, 4))) + L = length(v) + q1, q2 = key + pos1, pos2 = 2^(q1-1), 2^(q2-1) + stride1, stride2 = 2 * pos1, 2 * pos2 + for i in 0:stride2:(L-1) + for j in 0:stride1:(pos2-1) + @inbounds for k in 0:(pos1-1) + l = i + j + k + 1 + vi = SVector(v[l], v[l + pos1], v[l + pos2], v[l + pos1 + pos2]) + @fastmath vo = U * vi + + vout[l] += vo[1] + vout[l + pos1] += vo[2] + vout[l + pos2] += vo[3] + vout[l + pos1 + pos2] += vo[4] + end + end + end +end + +_apply_gate_2!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _apply_gate_2_impl!( +key, SMatrix{4,4, eltype(v)}(U), v, vout) + +function _apply_gate_2_impl!(key::Tuple{Int, Int, Int}, m::AbstractMatrix, v::AbstractVector, vout::AbstractVector) + L = length(v) + q1, q2, q3 = key + pos1, pos2, pos3 = 2^(q1-1), 2^(q2-1), 2^(q3-1) + stride1, stride2, stride3 = 2 * pos1, 2 * pos2, 2 * pos3 + for h in 0:stride3:(L-1) + for i in 0:stride2:(pos3-1) + for j in 0:stride1:(pos2-1) + @inbounds for k in 0:(pos1-1) + l000 = h + i + j + k + 1 + l100 = l000 + pos1 + l010 = l000 + pos2 + l110 = l010 + pos1 + + l001 = l000 + pos3 + l101 = l001 + pos1 + l011 = l001 + pos2 + l111 = l011 + pos1 + vi = SVector(v[l000], v[l100], v[l010], v[l110], v[l001], v[l101], v[l011], v[l111]) + + @fastmath begin + vo = m * vi + vout[l000] += vo[1] + vout[l100] += vo[2] + vout[l010] += vo[3] + vout[l110] += vo[4] + vout[l001] += vo[5] + vout[l101] += vo[6] + vout[l011] += vo[7] + vout[l111] += vo[8] + end + end + end + end + end +end + +_apply_gate_2!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _apply_gate_2_impl!( +key, SMatrix{8,8, eltype(v)}(U), v, vout) + +function _apply_serial_util!(m::QubitsOperator, v::AbstractVector, vout::AbstractVector) + for (k, bond) in m.data + _apply_gate_2!(k, _get_mat(length(k), bond), v, vout) + end + return vout +end + + +","Julia" +"Conjugate","guochu/VQC.jl","src/applygates/applygates.jl",".jl","89","5"," +include(""generic/generic.jl"") +include(""specific/specific.jl"") + +include(""apply_qmaps.jl"")","Julia" +"Conjugate","guochu/VQC.jl","src/applygates/apply_qmaps.jl",".jl","2439","87"," + + +"""""" + apply!(x::QuantumMap, state::DensityMatrix) + apply a generc quantum channel on the quantum state +"""""" +function apply!(x::QuantumMap, state::DensityMatrix) + @assert _check_pos_range(x, nqubits(state)) + T = eltype(state) + if (eltype(x) <: Complex) && (T <: Real) + state = convert(DensityMatrix{Complex{T}}, state) + end + _qmap_apply_threaded!(x, state.data, nqubits(state)) + return state +end + +apply!(x::QuantumMap, state::StateVector) = apply!(x, DensityMatrix(state)) + +"""""" + apply_dagger!(x::QuantumMap, state::DensityMatrix) + apply the hermitian conjugate of quantum map on rho + this function is needed for auto-differentiation +"""""" +function apply_dagger!(x::QuantumMap, state::DensityMatrix) + @assert _check_pos_range(x, nqubits(state)) + T = eltype(state) + if (eltype(x) <: Complex) && (T <: Real) + state = convert(DensityMatrix{Complex{T}}, state) + end + _qmap_apply_dagger_threaded!(x, state.data, nqubits(state)) + return state +end + +"""""" + apply_inverse!(x::QuantumMap, state::DensityMatrix) + apply the inverse of quantum map on rho, this requires the supermatrix to be invertable. + this function is needed for auto-differentiation +"""""" +function apply_inverse!(x::QuantumMap, state::DensityMatrix) + @assert _check_pos_range(x, nqubits(state)) + T = eltype(state) + if (eltype(x) <: Complex) && (T <: Real) + state = convert(DensityMatrix{Complex{T}}, state) + end + _qmap_apply_inverse_threaded!(x, state.data, nqubits(state)) + return state +end + + +# unitary gate operation on density matrix +function _qmap_apply_threaded!(x::QuantumMap{N}, s::AbstractVector, n::Int) where N + pos = ordered_positions(x) + pos2 = ntuple(i->pos[i]+n, N) + all_pos = (pos..., pos2...) + m = ordered_supermat(x) + if length(s) >= 32 + _apply_gate_threaded2!(all_pos, m, s) + else + _apply_gate_2!(all_pos, m, s) + end +end + +function _qmap_apply_dagger_threaded!(x::QuantumMap{N}, s::AbstractVector, n::Int) where N + pos = ordered_positions(x) + pos2 = ntuple(i->pos[i]+n, N) + all_pos = (pos..., pos2...) + m = ordered_supermat(x) + if length(s) >= 32 + _apply_gate_threaded2!(all_pos, m', s) + else + _apply_gate_2!(all_pos, m', s) + end +end + +function _qmap_apply_inverse_threaded!(x::QuantumMap{N}, s::AbstractVector, n::Int) where N + pos = ordered_positions(x) + pos2 = ntuple(i->pos[i]+n, N) + all_pos = (pos..., pos2...) + m = ordered_supermat(x) + if length(s) >= 32 + _apply_gate_threaded2!(all_pos, inv(m), s) + else + _apply_gate_2!(all_pos, inv(m), s) + end +end +","Julia" +"Conjugate","guochu/VQC.jl","src/applygates/specific/phasegate.jl",".jl","1323","44"," + +"""""" + specialization for PHASEGate +"""""" +function apply_threaded!(gt::PHASEGate, v::AbstractVector) + (length(v) < 32) && return apply_serial!(gt, v) + L = length(v) + sizek = 1 << (ordered_positions(gt)[1] - 1) + mask0 = sizek - 1 + mask1 = xor(L - 1, 2 * sizek - 1) + f(ist::Int, ifn::Int, pos::Int, m1::Int, m2::Int, alpha::Number, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (2 * i & m2) | (i & m1) + pos + @fastmath p[l] *= alpha + end + end + + exp_phi = convert(eltype(v), exp(im * parameters(gt)[1] )) + total_itr = div(L, 2) + parallel_run(total_itr, Threads.nthreads(), f, sizek+1, mask0, mask1, exp_phi, v) +end + +"""""" + specialization for XGate +"""""" +function apply_threaded!(gt::XGate, v::AbstractVector) + (length(v) < 32) && return apply_serial!(gt, v) + L = length(v) + sizek = 1 << (ordered_positions(gt)[1] - 1) + mask0 = sizek - 1 + mask1 = xor(L - 1, 2 * sizek - 1) + f(ist::Int, ifn::Int, pos::Int, m1::Int, m2::Int, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (2 * i & m2) | (i & m1) + 1 + l1 = l + pos + @fastmath p[l], p[l1] = p[l1], p[l] + end + end + + total_itr = div(L, 2) + parallel_run(total_itr, Threads.nthreads(), f, sizek, mask0, mask1, v) +end +","Julia" +"Conjugate","guochu/VQC.jl","src/applygates/specific/fredkingate.jl",".jl","3455","105"," + + +function apply_threaded!(gt::FREDKINGate, v::AbstractVector) + (length(v) < 32) && return apply_serial!(gt, v) + + L = length(v) + q1, q2, q3 = ordered_positions(gt) + pos1, pos2, pos3 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1) + # stride2, stride3 = pos1 << 1, pos2 << 1 + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(pos3 - 1, 2 * pos2 - 1) + mask3 = xor(L - 1, 2 * pos3 - 1) + # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"") + + f_f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, m4::Int, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l000 = (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1 + # l100 = l000 + posa + l010 = l000 + posb + l110 = l010 + posa + + l001 = l000 + posc + l101 = l001 + posa + # l011 = l001 + posb + # l111 = l011 + posa + + @fastmath p[l110], p[l101] = p[l101], p[l110] + end + end + + f_m(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, m4::Int, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l000 = (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1 + # l100 = l000 + posa + l010 = l000 + posb + l110 = l010 + posa + + l001 = l000 + posc + # l101 = l001 + posa + l011 = l001 + posb + # l111 = l011 + posa + + @fastmath p[l110], p[l011] = p[l011], p[l110] + end + end + + f_e(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, m4::Int, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l000 = (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1 + # l100 = l000 + posa + # l010 = l000 + posb + # l110 = l010 + posa + + l001 = l000 + posc + l101 = l001 + posa + l011 = l001 + posb + # l111 = l011 + posa + + @fastmath p[l101], p[l011] = p[l011], p[l101] + end + end + + target = positions(gt)[1] + if target == q1 + f = f_f + elseif target == q2 + f = f_m + elseif target == q3 + f = f_e + else + error(""target $target does not exist in $key."") + end + total_itr = div(L, 8) + parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, pos3, mask0, mask1, mask2, mask3, v) +end + + +function apply_threaded!(gt::CCPHASEGate, v::AbstractVector) + (length(v) < 32) && return apply_serial!(gt, v) + + L = length(v) + q1, q2, q3 = ordered_positions(gt) + pos1, pos2, pos3 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1) + # stride2, stride3 = pos1 << 1, pos2 << 1 + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(pos3 - 1, 2 * pos2 - 1) + mask3 = xor(L - 1, 2 * pos3 - 1) + # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"") + + f(ist::Int, ifn::Int, posabc1::Int, m1::Int, m2::Int, m3::Int, m4::Int, alpha::Number, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l111 = (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + posabc1 + + @fastmath p[l111] *= alpha + end + end + exp_phi = convert(eltype(v), exp(im * parameters(gt)[1] )) + + total_itr = div(L, 8) + parallel_run(total_itr, Threads.nthreads(), f, pos1+pos2+pos3+1, mask0, mask1, mask2, mask3, exp_phi, v) +end +","Julia" +"Conjugate","guochu/VQC.jl","src/applygates/specific/specific.jl",".jl","116","7"," +include(""swapgates.jl"") + +# specialized gates +include(""phasegate.jl"") +include(""czgate.jl"") +include(""fredkingate.jl"")","Julia" +"Conjugate","guochu/VQC.jl","src/applygates/specific/swapgates.jl",".jl","1763","50"," + +function apply_threaded!(gt::SWAPGate, v::AbstractVector) + (length(v) < 32) && return apply_serial!(gt, v) + L = length(v) + q1, q2 = ordered_positions(gt) + pos1, pos2 = 1 << (q1-1), 1 << (q2-1) + + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(L - 1, 2 * pos2 - 1) + + f(ist::Int, ifn::Int, posa::Int, posb::Int, m1::Int, m2::Int, m3::Int, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (4 * i & m3) | (2 * i & m2) | (i & m1) + 1 + l1 = l + posa + l2 = l + posb + p[l1], p[l2] = p[l2], p[l1] + end + end + total_itr = div(L, 4) + parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, mask0, mask1, mask2, v) +end + +function _apply_iswap_util!(gt, v::AbstractVector, coef::Number) + L = length(v) + q1, q2 = ordered_positions(gt) + pos1, pos2 = 1 << (q1-1), 1 << (q2-1) + + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(L - 1, 2 * pos2 - 1) + + f(ist::Int, ifn::Int, posa::Int, posb::Int, m1::Int, m2::Int, m3::Int, coeff::Number, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (4 * i & m3) | (2 * i & m2) | (i & m1) + 1 + l1 = l + posa + l2 = l + posb + @fastmath p[l1], p[l2] = coeff*p[l2], coeff*p[l1] + end + end + total_itr = div(L, 4) + parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, mask0, mask1, mask2, convert(eltype(v), coef), v) +end + +apply_threaded!(gt::iSWAPGate, v::AbstractVector) = (length(v) >= 32) ? _apply_iswap_util!( + gt, v, im) : apply_serial!(gt, v) +apply_threaded!(gt::AdjointQuantumGate{iSWAPGate}, v::AbstractVector) = (length(v) >= 32) ? _apply_iswap_util!( + gt, v, -im) : apply_serial!(gt, v) +","Julia" +"Conjugate","guochu/VQC.jl","src/applygates/specific/czgate.jl",".jl","2746","96"," + +"""""" + specialized for CZ gate +"""""" +function apply_threaded!(gt::CZGate, v::AbstractVector) + (length(v) < 32) && return apply_serial!(gt, v) + L = length(v) + q1, q2 = ordered_positions(gt) + pos1, pos2 = 1 << (q1-1), 1 << (q2-1) + + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(L - 1, 2 * pos2 - 1) + + f(ist::Int, ifn::Int, posab1::Int, m1::Int, m2::Int, m3::Int, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (4 * i & m3) | (2 * i & m2) | (i & m1) + posab1 + p[l] = -p[l] + end + end + + total_itr = div(L, 4) + parallel_run(total_itr, Threads.nthreads(), f, pos1+pos2+1, mask0, mask1, mask2, v) +end + +"""""" + specialized for CNOT gate +"""""" +function apply_threaded!(gt::CNOTGate, v::AbstractVector) + (length(v) < 32) && return apply_serial!(gt, v) + L = length(v) + q1, q2 = ordered_positions(gt) + pos1, pos2 = 1 << (q1-1), 1 << (q2-1) + + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(L - 1, 2 * pos2 - 1) + + f_f(ist::Int, ifn::Int, posa::Int, posb::Int, m1::Int, m2::Int, m3::Int, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l00 = (4 * i & m3) | (2 * i & m2) | (i & m1) + 1 + l10 = l00 + posa + l01 = l00 + posb + l11 = l01 + posa + p[l10], p[l11] = p[l11], p[l10] + end + end + + f_e(ist::Int, ifn::Int, posa::Int, posb::Int, m1::Int, m2::Int, m3::Int, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l00 = (4 * i & m3) | (2 * i & m2) | (i & m1) + 1 + l10 = l00 + posa + l01 = l00 + posb + l11 = l01 + posa + p[l01], p[l11] = p[l11], p[l01] + end + end + + if positions(gt)[1] == q1 + f = f_f + else + f = f_e + end + + total_itr = div(L, 4) + parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, mask0, mask1, mask2, v) +end + +"""""" + specialized for CPHASE gate +"""""" +function apply_threaded!(gt::CPHASEGate, v::AbstractVector) + (length(v) < 32) && return apply_serial!(gt, v) + + L = length(v) + q1, q2 = ordered_positions(gt) + pos1, pos2 = 1 << (q1-1), 1 << (q2-1) + + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(L - 1, 2 * pos2 - 1) + + f(ist::Int, ifn::Int, posab1::Int, m1::Int, m2::Int, m3::Int, alpha::Number, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (4 * i & m3) | (2 * i & m2) | (i & m1) + posab1 + @fastmath p[l] *= alpha + end + end + + exp_phi = convert(eltype(v), exp(im * parameters(gt)[1] )) + + total_itr = div(L, 4) + parallel_run(total_itr, Threads.nthreads(), f, pos1+pos2+1, mask0, mask1, mask2, exp_phi, v) +end +","Julia" +"Conjugate","guochu/VQC.jl","src/applygates/generic/threaded_long_range.jl",".jl","5741","135","# experimental support for 4-qubit and 5-qubit gate operation + +function _apply_fourbody_gate_impl!(key::Tuple{Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) + L = length(v) + q1, q2, q3, q4 = key + pos1, pos2, pos3, pos4 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1), 1 << (q4-1) + # stride2, stride3 = pos1 << 1, pos2 << 1 + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(pos3 - 1, 2 * pos2 - 1) + mask3 = xor(pos4 - 1, 2 * pos3 - 1) + mask4 = xor(L - 1, 2 * pos4 - 1) + # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"") + + f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, posd::Int, m1::Int, m2::Int, m3::Int, m4::Int, m5::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l0000 = (16 * i & m5) | (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1 + l1000 = l0000 + posa + l0100 = l0000 + posb + l0010 = l0000 + posc + l0001 = l0000 + posd + + l1100 = l0100 + posa + l1010 = l0010 + posa + l1001 = l1000 + posd + l0110 = l0010 + posb + l0101 = l0100 + posd + l0011 = l0010 + posd + + l1110 = l1100 + posc + l1101 = l1100 + posd + l1011 = l1010 + posd + l0111 = l0110 + posd + + l1111 = l1110 + posd + + + + # println(""$l000, $l100, $l010, $l110, $l001, $l101, $l011, $l111"") + vi = SVector(p[l0000], p[l1000], p[l0100], p[l1100], p[l0010], p[l1010], p[l0110], p[l1110], + p[l0001], p[l1001], p[l0101], p[l1101], p[l0011], p[l1011], p[l0111], p[l1111]) + + @fastmath p[l0000], p[l1000], p[l0100], p[l1100], p[l0010], p[l1010], p[l0110], p[l1110], + p[l0001], p[l1001], p[l0101], p[l1101], p[l0011], p[l1011], p[l0111], p[l1111] = mat * vi + end + end + total_itr = div(L, 16) + parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, pos3, pos4, mask0, mask1, mask2, mask3, mask4, U, v) +end + +_apply_gate_threaded2!(key::Tuple{Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) = _apply_fourbody_gate_impl!( + key, SMatrix{16,16, eltype(v)}(U), v) + +# used in apply_serial when n = 4 +_apply_gate_2!(key::Tuple{Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) = _apply_gate_threaded2!(key, U, v) + + +# This takes forever to compile +function _apply_fivebody_gate_impl!(key::Tuple{Int, Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) + L = length(v) + q1, q2, q3, q4, q5 = key + pos1, pos2, pos3, pos4, pos5 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1), 1 << (q4-1), 1 << (q5-1) + # stride2, stride3 = pos1 << 1, pos2 << 1 + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(pos3 - 1, 2 * pos2 - 1) + mask3 = xor(pos4 - 1, 2 * pos3 - 1) + mask4 = xor(pos5 - 1, 2 * pos4 - 1) + mask5 = xor(L - 1, 2 * pos5 - 1) + # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"") + + function f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, posd::Int, pose::Int, + m1::Int, m2::Int, m3::Int, m4::Int, m5::Int, m6::Int, mat::AbstractMatrix, p::AbstractVector) + @inbounds for i in ist:ifn + l00000 = (32 * i & m6) | (16 * i & m5) | (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1 + l10000 = l00000 + posa + l01000 = l00000 + posb + l00100 = l00000 + posc + l00010 = l00000 + posd + l00001 = l00000 + pose + + l11000 = l01000 + posa + l10100 = l00100 + posa + l10010 = l10000 + posd + l10001 = l10000 + pose + l01100 = l00100 + posb + l01010 = l01000 + posd + l01001 = l01000 + pose + l00110 = l00100 + posd + l00101 = l00100 + pose + l00011 = l00010 + pose + + + l11100 = l11000 + posc + l11010 = l11000 + posd + l11001 = l11000 + pose + l10110 = l10100 + posd + l10101 = l10100 + pose + l10011 = l10010 + pose + l01110 = l01100 + posd + l01101 = l01100 + pose + l01011 = l01010 + pose + l00111 = l00110 + pose + + l11110 = l11100 + posd + l11101 = l11100 + pose + l11011 = l11010 + pose + l10111 = l10110 + pose + l01111 = l01110 + pose + + l11111 = l11110 + pose + + + + # println(""$l000, $l100, $l010, $l110, $l001, $l101, $l011, $l111"") + vi = SVector(p[l00000], p[l10000], p[l01000], p[l11000], p[l00100], p[l10100], p[l01100], p[l11100], + p[l00010], p[l10010], p[l01010], p[l11010], p[l00110], p[l10110], p[l01110], p[l11110], + p[l00001], p[l10001], p[l01001], p[l11001], p[l00101], p[l10101], p[l01101], p[l11101], + p[l00011], p[l10011], p[l01011], p[l11011], p[l00111], p[l10111], p[l01111], p[l11111]) + + @fastmath p[l00000], p[l10000], p[l01000], p[l11000], p[l00100], p[l10100], p[l01100], p[l11100], + p[l00010], p[l10010], p[l01010], p[l11010], p[l00110], p[l10110], p[l01110], p[l11110], + p[l00001], p[l10001], p[l01001], p[l11001], p[l00101], p[l10101], p[l01101], p[l11101], + p[l00011], p[l10011], p[l01011], p[l11011], p[l00111], p[l10111], p[l01111], p[l11111] = mat * vi + end + end + total_itr = div(L, 32) + parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, pos3, pos4, pos5, mask0, mask1, mask2, mask3, mask4, mask5, U, v) +end + +_apply_gate_threaded2!(key::Tuple{Int, Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) = _apply_fivebody_gate_impl!( + key, SMatrix{32,32, eltype(v)}(U), v) + + +","Julia" +"Conjugate","guochu/VQC.jl","src/applygates/generic/threaded_short_range.jl",".jl","34508","768","# one, two, three-qubit gate operations + + +"""""" + applys when key > 3, U is the transposed op +"""""" +function _apply_onebody_gate_H!(key::Int, U::AbstractMatrix, v::AbstractVector) + L = length(v) + sizek = 1 << (key - 1) + mask0 = sizek - 1 + mask1 = xor(L - 1, 2 * sizek - 1) + f(ist::Int, ifn::Int, pos::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (16 * i & m2) | (8 * i & m1) + 1 + l1 = l + pos + vi = SMatrix{8, 2}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7]) + + @fastmath p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7] = vi * mat + end + end + + total_itr = div(L, 16) + # n_threads = Threads.nthreads() + # if (total_itr >= MIN_SIZE) && (n_threads > 1) + # # println(""2*****************************"") + # nave, resi, jobs = partition_jobs(total_itr, n_threads) + # Threads.@threads for s in 1:n_threads + # ist = jobs[s] + # ifn = jobs[s+1] - 1 + # f(ist, ifn, sizek, mask0, mask1, U, v) + # end + # else + # # println(""1*****************************"") + # f(0, total_itr-1, sizek, mask0, mask1, U, v) + # end + parallel_run(total_itr, Threads.nthreads(), f, sizek, mask0, mask1, U, v) +end + +"""""" + applys when key <= 3, U is the transposed op +"""""" +function _apply_onebody_gate_L!(key::Int, U::AbstractMatrix, v::AbstractVector) + L = length(v) + f1(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 16 * i + 1 + vi = SMatrix{2, 8}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15]) + @fastmath p[l:(l+15)]= mat * vi + end + end + f2(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 16 * i + 1 + vi = SMatrix{2, 8}(p[l], p[l+2], p[l+1], p[l+3], p[l+4], p[l+6], p[l+5], p[l+7], + p[l+8], p[l+10], p[l+9], p[l+11], p[l+12], p[l+14], p[l+13], p[l+15]) + + @fastmath p[l], p[l+2], p[l+1], p[l+3], p[l+4], p[l+6], p[l+5], p[l+7], + p[l+8], p[l+10], p[l+9], p[l+11], p[l+12], p[l+14], p[l+13], p[l+15] = mat * vi + end + end + f3(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 16 * i + 1 + vi = SMatrix{2, 8}(p[l], p[l+4], p[l+1], p[l+5], p[l+2], p[l+6], p[l+3], p[l+7], + p[l+8], p[l+12], p[l+9], p[l+13], p[l+10], p[l+14], p[l+11], p[l+15]) + + @fastmath p[l], p[l+4], p[l+1], p[l+5], p[l+2], p[l+6], p[l+3], p[l+7], + p[l+8], p[l+12], p[l+9], p[l+13], p[l+10], p[l+14], p[l+11], p[l+15] = mat * vi + end + end + if key == 1 + f = f1 + elseif key == 2 + f = f2 + elseif key == 3 + f = f3 + else + error(""qubit position $key not allowed for L."") + end + total_itr = div(L, 16) + # n_threads = Threads.nthreads() + # if (total_itr >= MIN_SIZE) && (n_threads > 1) + # # println(""2*****************************"") + # nave, resi, jobs = partition_jobs(total_itr, n_threads) + # Threads.@threads for s in 1:n_threads + # ist = jobs[s] + # ifn = jobs[s+1] - 1 + # f(ist, ifn, U, v) + # end + # else + # # println(""1*****************************"") + # f(0, total_itr-1, U, v) + # end + parallel_run(total_itr, Threads.nthreads(), f, U, v) +end + +function _apply_gate_threaded2!(q0::Int, U::AbstractMatrix, v::AbstractVector) + if q0 > 3 + return _apply_onebody_gate_H!(q0, SMatrix{2,2, eltype(v)}(transpose(U)), v) + else + return _apply_onebody_gate_L!(q0, SMatrix{2,2, eltype(v)}(U), v) + end +end + +_apply_gate_threaded2!(q0::Tuple{Int}, U::AbstractMatrix, v::AbstractVector) = _apply_gate_threaded2!(q0[1], U, v) + +"""""" + applys when both keys > 3, U is the transposed op +"""""" +function _apply_twobody_gate_HH!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector) + L = length(v) + q1, q2 = key + pos1, pos2 = 1 << (q1-1), 1 << (q2-1) + # stride2, stride3 = pos1 << 1, pos2 << 1 + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(L - 1, 2 * pos2 - 1) + # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"") + + total_itr = div(L, 32) + f(ist::Int, ifn::Int, posa::Int, posb::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1) + 1 + # l = div(l, 2) + 1 + l1 = l + posa + l2 = l + posb + l3 = l2 + posa + # println(""l0=$l, l1=$l1, l2=$l2, l3=$l3"") + vi = SMatrix{8, 4}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7], + p[l2], p[l2+1], p[l2+2], p[l2+3], p[l2+4], p[l2+5], p[l2+6], p[l2+7], + p[l3], p[l3+1], p[l3+2], p[l3+3], p[l3+4], p[l3+5], p[l3+6], p[l3+7]) + + @fastmath p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7], + p[l2], p[l2+1], p[l2+2], p[l2+3], p[l2+4], p[l2+5], p[l2+6], p[l2+7], + p[l3], p[l3+1], p[l3+2], p[l3+3], p[l3+4], p[l3+5], p[l3+6], p[l3+7] = vi * mat + end + end + # n_threads = Threads.nthreads() + # if (total_itr >= MIN_SIZE) && (n_threads > 1) + # # println(""2*****************************"") + # nave, resi, jobs = partition_jobs(total_itr, n_threads) + # Threads.@threads for s in 1:n_threads + # ist = jobs[s] + # ifn = jobs[s+1] - 1 + # f(ist, ifn, pos1, pos2, mask0, mask1, mask2, U, v) + # end + # else + # # println(""1*****************************"") + # f(0, total_itr-1, pos1, pos2, mask0, mask1, mask2, U, v) + # end + parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, mask0, mask1, mask2, U, v) +end + +"""""" + applys when q1 <= 3 and q2 > 4, U is the transposed op +"""""" +function _apply_twobody_gate_LH!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector) + L = length(v) + q1, q2 = key + sizej = 1 << (q2-1) + mask0 = sizej - 1 + mask1 = xor(L - 1, 2 * sizej - 1) + + f1H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{8, 4}(p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15], + p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16], + p[l1+1], p[l1+3], p[l1+5], p[l1+7], p[l1+9], p[l1+11], p[l1+13], p[l1+15], + p[l1+2], p[l1+4], p[l1+6], p[l1+8], p[l1+10], p[l1+12], p[l1+14], p[l1+16]) + + @fastmath p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15], + p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16], + p[l1+1], p[l1+3], p[l1+5], p[l1+7], p[l1+9], p[l1+11], p[l1+13], p[l1+15], + p[l1+2], p[l1+4], p[l1+6], p[l1+8], p[l1+10], p[l1+12], p[l1+14], p[l1+16] = vi * mat + end + end + + f2H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14], + p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16], + p[l1+1], p[l1+2], p[l1+5], p[l1+6], p[l1+9], p[l1+10], p[l1+13], p[l1+14], + p[l1+3], p[l1+4], p[l1+7], p[l1+8], p[l1+11], p[l1+12], p[l1+15], p[l1+16]) + + @fastmath p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14], + p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16], + p[l1+1], p[l1+2], p[l1+5], p[l1+6], p[l1+9], p[l1+10], p[l1+13], p[l1+14], + p[l1+3], p[l1+4], p[l1+7], p[l1+8], p[l1+11], p[l1+12], p[l1+15], p[l1+16] = vi * mat + end + end + + f3H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12], + p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16], + p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+9], p[l1+10], p[l1+11], p[l1+12], + p[l1+5], p[l1+6], p[l1+7], p[l1+8], p[l1+13], p[l1+14], p[l1+15], p[l1+16]) + + @fastmath p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12], + p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16], + p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+9], p[l1+10], p[l1+11], p[l1+12], + p[l1+5], p[l1+6], p[l1+7], p[l1+8], p[l1+13], p[l1+14], p[l1+15], p[l1+16] = vi * mat + end + end + + if q1 == 1 + f = f1H + elseif q1 == 2 + f = f2H + elseif q1 == 3 + f = f3H + else + error(""qubit position $q1 not allowed for LH."") + end + total_itr = div(L, 32) + + # n_threads = Threads.nthreads() + # if (total_itr >= MIN_SIZE) && (n_threads > 1) + # # println(""2*****************************"") + # nave, resi, jobs = partition_jobs(total_itr, n_threads) + # Threads.@threads for s in 1:n_threads + # ist = jobs[s] + # ifn = jobs[s+1] - 1 + # f(ist, ifn, sizej, mask0, mask1, U, v) + # end + # else + # # println(""1*****************************"") + # f(0, total_itr-1, sizej, mask0, mask1, U, v) + # end + parallel_run(total_itr, Threads.nthreads(), f, sizej, mask0, mask1, U, v) +end + + +"""""" + applys when both keys <= 4 +"""""" +function _apply_twobody_gate_LL!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector) + L = length(v) + q1, q2 = key + f12(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 32 * i + 1 + vi = SMatrix{4, 8}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15], + p[l+16], p[l+17], p[l+18], p[l+19], p[l+20], p[l+21], p[l+22], p[l+23], + p[l+24], p[l+25], p[l+26], p[l+27], p[l+28], p[l+29], p[l+30], p[l+31]) + @fastmath p[l:(l+31)]= mat * vi + end + end + f13(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 32 * i + 1 + vi = SMatrix{4, 8}(p[l], p[l+1], p[l+4], p[l+5], p[l+2], p[l+3], p[l+6], p[l+7], + p[l+8], p[l+9], p[l+12], p[l+13], p[l+10], p[l+11], p[l+14], p[l+15], + p[l+16], p[l+17], p[l+20], p[l+21], p[l+18], p[l+19], p[l+22], p[l+23], + p[l+24], p[l+25], p[l+28], p[l+29], p[l+26], p[l+27], p[l+30], p[l+31]) + + @fastmath p[l], p[l+1], p[l+4], p[l+5], p[l+2], p[l+3], p[l+6], p[l+7], + p[l+8], p[l+9], p[l+12], p[l+13], p[l+10], p[l+11], p[l+14], p[l+15], + p[l+16], p[l+17], p[l+20], p[l+21], p[l+18], p[l+19], p[l+22], p[l+23], + p[l+24], p[l+25], p[l+28], p[l+29], p[l+26], p[l+27], p[l+30], p[l+31] = mat * vi + end + end + f14(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+9], p[l+10], p[l+3], p[l+4], p[l+11], p[l+12], + p[l+5], p[l+6], p[l+13], p[l+14], p[l+7], p[l+8], p[l+15], p[l+16], + p[l+17], p[l+18], p[l+25], p[l+26], p[l+19], p[l+20], p[l+27], p[l+28], + p[l+21], p[l+22], p[l+29], p[l+30], p[l+23], p[l+24], p[l+31], p[l+32]) + + @fastmath p[l+1], p[l+2], p[l+9], p[l+10], p[l+3], p[l+4], p[l+11], p[l+12], + p[l+5], p[l+6], p[l+13], p[l+14], p[l+7], p[l+8], p[l+15], p[l+16], + p[l+17], p[l+18], p[l+25], p[l+26], p[l+19], p[l+20], p[l+27], p[l+28], + p[l+21], p[l+22], p[l+29], p[l+30], p[l+23], p[l+24], p[l+31], p[l+32] = mat * vi + end + end + f23(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 32 * i + 1 + vi = SMatrix{4, 8}(p[l], p[l+2], p[l+4], p[l+6], p[l+1], p[l+3], p[l+5], p[l+7], + p[l+8], p[l+10], p[l+12], p[l+14], p[l+9], p[l+11], p[l+13], p[l+15], + p[l+16], p[l+18], p[l+20], p[l+22], p[l+17], p[l+19], p[l+21], p[l+23], + p[l+24], p[l+26], p[l+28], p[l+30], p[l+25], p[l+27], p[l+29], p[l+31]) + + @fastmath p[l], p[l+2], p[l+4], p[l+6], p[l+1], p[l+3], p[l+5], p[l+7], + p[l+8], p[l+10], p[l+12], p[l+14], p[l+9], p[l+11], p[l+13], p[l+15], + p[l+16], p[l+18], p[l+20], p[l+22], p[l+17], p[l+19], p[l+21], p[l+23], + p[l+24], p[l+26], p[l+28], p[l+30], p[l+25], p[l+27], p[l+29], p[l+31] = mat * vi + end + end + f24(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+9], p[l+11], p[l+2], p[l+4], p[l+10], p[l+12], + p[l+5], p[l+7], p[l+13], p[l+15], p[l+6], p[l+8], p[l+14], p[l+16], + p[l+17], p[l+19], p[l+25], p[l+27], p[l+18], p[l+20], p[l+26], p[l+28], + p[l+21], p[l+23], p[l+29], p[l+31], p[l+22], p[l+24], p[l+30], p[l+32]) + + @fastmath p[l+1], p[l+3], p[l+9], p[l+11], p[l+2], p[l+4], p[l+10], p[l+12], + p[l+5], p[l+7], p[l+13], p[l+15], p[l+6], p[l+8], p[l+14], p[l+16], + p[l+17], p[l+19], p[l+25], p[l+27], p[l+18], p[l+20], p[l+26], p[l+28], + p[l+21], p[l+23], p[l+29], p[l+31], p[l+22], p[l+24], p[l+30], p[l+32] = mat * vi + end + end + f34(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{4, 8}(p[l+1], p[l+5], p[l+9], p[l+13], p[l+2], p[l+6], p[l+10], p[l+14], + p[l+3], p[l+7], p[l+11], p[l+15], p[l+4], p[l+8], p[l+12], p[l+16], + p[l+17], p[l+21], p[l+25], p[l+29], p[l+18], p[l+22], p[l+26], p[l+30], + p[l+19], p[l+23], p[l+27], p[l+31], p[l+20], p[l+24], p[l+28], p[l+32]) + + @fastmath p[l+1], p[l+5], p[l+9], p[l+13], p[l+2], p[l+6], p[l+10], p[l+14], + p[l+3], p[l+7], p[l+11], p[l+15], p[l+4], p[l+8], p[l+12], p[l+16], + p[l+17], p[l+21], p[l+25], p[l+29], p[l+18], p[l+22], p[l+26], p[l+30], + p[l+19], p[l+23], p[l+27], p[l+31], p[l+20], p[l+24], p[l+28], p[l+32] = mat * vi + end + end + if q1==1 && q2 == 2 + f = f12 + elseif q1==1 && q2 == 3 + f = f13 + elseif q1==1 && q2 == 4 + f = f14 + elseif q1==2 && q2 == 3 + f = f23 + elseif q1==2 && q2 == 4 + f = f24 + elseif q1==3 && q2 == 4 + f = f34 + else + error(""qubit position $q1 and $q2 not allowed for LL."") + end + total_itr = div(L, 32) + # n_threads = Threads.nthreads() + # if (total_itr >= MIN_SIZE) && (n_threads > 1) + # nave, resi, jobs = partition_jobs(total_itr, n_threads) + # Threads.@threads for s in 1:n_threads + # ist = jobs[s] + # ifn = jobs[s+1] - 1 + # f(ist, ifn, U, v) + # end + # else + # f(0, total_itr-1, U, v) + # end + parallel_run(total_itr, Threads.nthreads(), f, U, v) +end + +function _apply_gate_threaded2!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector) + q0, q1 = key + if q0 > 3 + return _apply_twobody_gate_HH!(key, SMatrix{4,4, eltype(v)}(transpose(U)), v) + elseif q1 > 4 + return _apply_twobody_gate_LH!(key, SMatrix{4,4, eltype(v)}(transpose(U)), v) + else + return _apply_twobody_gate_LL!(key, SMatrix{4,4, eltype(v)}(U), v) + end +end + +"""""" + applys when both keys > 2, U is assumed to be transposed +"""""" +function _apply_threebody_gate_HHH!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) + L = length(v) + q1, q2, q3 = key + pos1, pos2, pos3 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1) + # stride2, stride3 = pos1 << 1, pos2 << 1 + mask0 = pos1 - 1 + mask1 = xor(pos2 - 1, 2 * pos1 - 1) + mask2 = xor(pos3 - 1, 2 * pos2 - 1) + mask3 = xor(L - 1, 2 * pos3 - 1) + # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"") + + total_itr = div(L, 32) + f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, m4::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l000 = (32 * i & m4) | (16 * i & m3) | (8 * i & m2) | (4 * i & m1) + 1 + l100 = l000 + posa + l010 = l000 + posb + l110 = l010 + posa + + l001 = l000 + posc + l101 = l001 + posa + l011 = l001 + posb + l111 = l011 + posa + + # println(""$l000, $l100, $l010, $l110, $l001, $l101, $l011, $l111"") + vi = SMatrix{4, 8}(p[l000], p[l000+1], p[l000+2], p[l000+3], + p[l100], p[l100+1], p[l100+2], p[l100+3], + p[l010], p[l010+1], p[l010+2], p[l010+3], + p[l110], p[l110+1], p[l110+2], p[l110+3], + p[l001], p[l001+1], p[l001+2], p[l001+3], + p[l101], p[l101+1], p[l101+2], p[l101+3], + p[l011], p[l011+1], p[l011+2], p[l011+3], + p[l111], p[l111+1], p[l111+2], p[l111+3]) + + @fastmath p[l000], p[l000+1], p[l000+2], p[l000+3], + p[l100], p[l100+1], p[l100+2], p[l100+3], + p[l010], p[l010+1], p[l010+2], p[l010+3], + p[l110], p[l110+1], p[l110+2], p[l110+3], + p[l001], p[l001+1], p[l001+2], p[l001+3], + p[l101], p[l101+1], p[l101+2], p[l101+3], + p[l011], p[l011+1], p[l011+2], p[l011+3], + p[l111], p[l111+1], p[l111+2], p[l111+3] = vi * mat + end + end + # n_threads = Threads.nthreads() + # if (total_itr >= MIN_SIZE) && (n_threads > 1) + # # println(""2*****************************"") + # nave, resi, jobs = partition_jobs(total_itr, n_threads) + # Threads.@threads for s in 1:n_threads + # ist = jobs[s] + # ifn = jobs[s+1] - 1 + # f(ist, ifn, pos1, pos2, pos3, mask0, mask1, mask2, mask3, U, v) + # end + # else + # # println(""1*****************************"") + # f(0, total_itr-1, pos1, pos2, pos3, mask0, mask1, mask2, mask3, U, v) + # end + parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, pos3, mask0, mask1, mask2, mask3, U, v) +end + +"""""" + applys when q1 <= 2 and q2 > 3, U is the transposed op +"""""" +function _apply_threebody_gate_LHH!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) + L = length(v) + q1, q2, q3 = key + sizej, sizel = 1 << (q2-1), 1 << (q3-1) + mask0 = sizej - 1 + mask1 = xor(sizel - 1, 2 * sizej - 1) + mask2 = xor(L-1, 2 * sizel - 1) + + f1H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1) + l1 = l + posb + l2 = l + posc + l3 = l2 + posb + # println(""$l, $l1, $l2, $l3"") + vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+5], p[l+7], + p[l+2], p[l+4], p[l+6], p[l+8], + p[l1+1], p[l1+3], p[l1+5], p[l1+7], + p[l1+2], p[l1+4], p[l1+6], p[l1+8], + p[l2+1], p[l2+3], p[l2+5], p[l2+7], + p[l2+2], p[l2+4], p[l2+6], p[l2+8], + p[l3+1], p[l3+3], p[l3+5], p[l3+7], + p[l3+2], p[l3+4], p[l3+6], p[l3+8]) + + @fastmath p[l+1], p[l+3], p[l+5], p[l+7], + p[l+2], p[l+4], p[l+6], p[l+8], + p[l1+1], p[l1+3], p[l1+5], p[l1+7], + p[l1+2], p[l1+4], p[l1+6], p[l1+8], + p[l2+1], p[l2+3], p[l2+5], p[l2+7], + p[l2+2], p[l2+4], p[l2+6], p[l2+8], + p[l3+1], p[l3+3], p[l3+5], p[l3+7], + p[l3+2], p[l3+4], p[l3+6], p[l3+8] = vi * mat + end + end + + f2H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1) + l1 = l + posb + l2 = l + posc + l3 = l2 + posb + vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+5], p[l+6], + p[l+3], p[l+4], p[l+7], p[l+8], + p[l1+1], p[l1+2], p[l1+5], p[l1+6], + p[l1+3], p[l1+4], p[l1+7], p[l1+8], + p[l2+1], p[l2+2], p[l2+5], p[l2+6], + p[l2+3], p[l2+4], p[l2+7], p[l2+8], + p[l3+1], p[l3+2], p[l3+5], p[l3+6], + p[l3+3], p[l3+4], p[l3+7], p[l3+8]) + + @fastmath p[l+1], p[l+2], p[l+5], p[l+6], + p[l+3], p[l+4], p[l+7], p[l+8], + p[l1+1], p[l1+2], p[l1+5], p[l1+6], + p[l1+3], p[l1+4], p[l1+7], p[l1+8], + p[l2+1], p[l2+2], p[l2+5], p[l2+6], + p[l2+3], p[l2+4], p[l2+7], p[l2+8], + p[l3+1], p[l3+2], p[l3+5], p[l3+6], + p[l3+3], p[l3+4], p[l3+7], p[l3+8] = vi * mat + end + end + + f3H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1) + l1 = l + posb + l2 = l + posc + l3 = l2 + posb + vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+3], p[l+4], + p[l+5], p[l+6], p[l+7], p[l+8], + p[l1+1], p[l1+2], p[l1+3], p[l1+4], + p[l1+5], p[l1+6], p[l1+7], p[l1+8], + p[l2+1], p[l2+2], p[l2+3], p[l2+4], + p[l2+5], p[l2+6], p[l2+7], p[l2+8], + p[l3+1], p[l3+2], p[l3+3], p[l3+4], + p[l3+5], p[l3+6], p[l3+7], p[l3+8]) + + @fastmath p[l+1], p[l+2], p[l+3], p[l+4], + p[l+5], p[l+6], p[l+7], p[l+8], + p[l1+1], p[l1+2], p[l1+3], p[l1+4], + p[l1+5], p[l1+6], p[l1+7], p[l1+8], + p[l2+1], p[l2+2], p[l2+3], p[l2+4], + p[l2+5], p[l2+6], p[l2+7], p[l2+8], + p[l3+1], p[l3+2], p[l3+3], p[l3+4], + p[l3+5], p[l3+6], p[l3+7], p[l3+8] = vi * mat + end + end + + if q1 == 1 + f = f1H + elseif q1 == 2 + f = f2H + elseif q1 == 3 + f = f3H + else + error(""qubit position $q1 not allowed for LHH."") + end + (q2 > 3) || error(""qubit 2 position $q2 not allowed for LHH."") + total_itr = div(L, 32) + + # n_threads = Threads.nthreads() + # if (total_itr >= MIN_SIZE) && (n_threads > 1) + # # println(""2*****************************"") + # nave, resi, jobs = partition_jobs(total_itr, n_threads) + # Threads.@threads for s in 1:n_threads + # ist = jobs[s] + # ifn = jobs[s+1] - 1 + # f(ist, ifn, sizej, sizel, mask0, mask1, mask2, U, v) + # end + # else + # # println(""1*****************************"") + # f(0, total_itr-1, sizej, sizel, mask0, mask1, mask2, U, v) + # end + parallel_run(total_itr, Threads.nthreads(), f, sizej, sizel, mask0, mask1, mask2, U, v) +end + +"""""" + applys when q1, q2 <= 3 and q3 > 4, U is the transposed op +"""""" +function _apply_threebody_gate_LLH!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) + L = length(v) + q1, q2, q3 = key + sizej = 1 << (q3-1) + mask0 = sizej - 1 + mask1 = xor(L - 1, 2 * sizej - 1) + + f12H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{4, 8}(p[l+1], p[l+5], p[l+9], p[l+13], + p[l+2], p[l+6], p[l+10], p[l+14], + p[l+3], p[l+7], p[l+11], p[l+15], + p[l+4], p[l+8], p[l+12], p[l+16], + p[l1+1], p[l1+5], p[l1+9], p[l1+13], + p[l1+2], p[l1+6], p[l1+10], p[l1+14], + p[l1+3], p[l1+7], p[l1+11], p[l1+15], + p[l1+4], p[l1+8], p[l1+12], p[l1+16]) + + @fastmath p[l+1], p[l+5], p[l+9], p[l+13], + p[l+2], p[l+6], p[l+10], p[l+14], + p[l+3], p[l+7], p[l+11], p[l+15], + p[l+4], p[l+8], p[l+12], p[l+16], + p[l1+1], p[l1+5], p[l1+9], p[l1+13], + p[l1+2], p[l1+6], p[l1+10], p[l1+14], + p[l1+3], p[l1+7], p[l1+11], p[l1+15], + p[l1+4], p[l1+8], p[l1+12], p[l1+16] = vi * mat + end + end + + f13H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+9], p[l+11], + p[l+2], p[l+4], p[l+10], p[l+12], + p[l+5], p[l+7], p[l+13], p[l+15], + p[l+6], p[l+8], p[l+14], p[l+16], + p[l1+1], p[l1+3], p[l1+9], p[l1+11], + p[l1+2], p[l1+4], p[l1+10], p[l1+12], + p[l1+5], p[l1+7], p[l1+13], p[l1+15], + p[l1+6], p[l1+8], p[l1+14], p[l1+16]) + + @fastmath p[l+1], p[l+3], p[l+9], p[l+11], + p[l+2], p[l+4], p[l+10], p[l+12], + p[l+5], p[l+7], p[l+13], p[l+15], + p[l+6], p[l+8], p[l+14], p[l+16], + p[l1+1], p[l1+3], p[l1+9], p[l1+11], + p[l1+2], p[l1+4], p[l1+10], p[l1+12], + p[l1+5], p[l1+7], p[l1+13], p[l1+15], + p[l1+6], p[l1+8], p[l1+14], p[l1+16] = vi * mat + end + end + + f23H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = (32 * i & m2) | (16 * i & m1) + l1 = l + posb + # println(""l=$l, l1=$l1"") + vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+9], p[l+10], + p[l+3], p[l+4], p[l+11], p[l+12], + p[l+5], p[l+6], p[l+13], p[l+14], + p[l+7], p[l+8], p[l+15], p[l+16], + p[l1+1], p[l1+2], p[l1+9], p[l1+10], + p[l1+3], p[l1+4], p[l1+11], p[l1+12], + p[l1+5], p[l1+6], p[l1+13], p[l1+14], + p[l1+7], p[l1+8], p[l1+15], p[l1+16]) + + @fastmath p[l+1], p[l+2], p[l+9], p[l+10], + p[l+3], p[l+4], p[l+11], p[l+12], + p[l+5], p[l+6], p[l+13], p[l+14], + p[l+7], p[l+8], p[l+15], p[l+16], + p[l1+1], p[l1+2], p[l1+9], p[l1+10], + p[l1+3], p[l1+4], p[l1+11], p[l1+12], + p[l1+5], p[l1+6], p[l1+13], p[l1+14], + p[l1+7], p[l1+8], p[l1+15], p[l1+16] = vi * mat + end + end + + if q1 == 1 && q2 == 2 + f = f12H + elseif q1 == 1 && q2 == 3 + f = f13H + elseif q1 == 2 && q2 == 3 + f = f23H + else + error(""qubit position $q1 not allowed for LH."") + end + total_itr = div(L, 32) + + # n_threads = Threads.nthreads() + # if (total_itr >= MIN_SIZE) && (n_threads > 1) + # # println(""2*****************************"") + # nave, resi, jobs = partition_jobs(total_itr, n_threads) + # Threads.@threads for s in 1:n_threads + # ist = jobs[s] + # ifn = jobs[s+1] - 1 + # f(ist, ifn, sizej, mask0, mask1, U, v) + # end + # else + # # println(""1*****************************"") + # f(0, total_itr-1, sizej, mask0, mask1, U, v) + # end + parallel_run(total_itr, Threads.nthreads(), f, sizej, mask0, mask1, U, v) +end + +"""""" + applys when both keys <= 4 +"""""" +function _apply_threebody_gate_LLL!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) + L = length(v) + q1, q2, q3 = key + f123(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 32 * i + 1 + vi = SMatrix{8, 4}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7], + p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15], + p[l+16], p[l+17], p[l+18], p[l+19], p[l+20], p[l+21], p[l+22], p[l+23], + p[l+24], p[l+25], p[l+26], p[l+27], p[l+28], p[l+29], p[l+30], p[l+31]) + @fastmath p[l:(l+31)]= mat * vi + end + end + f124(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12], + p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16], + p[l+17], p[l+18], p[l+19], p[l+20], p[l+25], p[l+26], p[l+27], p[l+28], + p[l+21], p[l+22], p[l+23], p[l+24], p[l+29], p[l+30], p[l+31], p[l+32]) + + @fastmath p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12], + p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16], + p[l+17], p[l+18], p[l+19], p[l+20], p[l+25], p[l+26], p[l+27], p[l+28], + p[l+21], p[l+22], p[l+23], p[l+24], p[l+29], p[l+30], p[l+31], p[l+32] = mat * vi + end + end + f134(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14], + p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16], + p[l+17], p[l+18], p[l+21], p[l+22], p[l+25], p[l+26], p[l+29], p[l+30], + p[l+19], p[l+20], p[l+23], p[l+24], p[l+27], p[l+28], p[l+31], p[l+32]) + + @fastmath p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14], + p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16], + p[l+17], p[l+18], p[l+21], p[l+22], p[l+25], p[l+26], p[l+29], p[l+30], + p[l+19], p[l+20], p[l+23], p[l+24], p[l+27], p[l+28], p[l+31], p[l+32] = mat * vi + end + end + f234(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin + @inbounds for i in ist:ifn + l = 32 * i + vi = SMatrix{8, 4}(p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15], + p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16], + p[l+17], p[l+19], p[l+21], p[l+23], p[l+25], p[l+27], p[l+29], p[l+31], + p[l+18], p[l+20], p[l+22], p[l+24], p[l+26], p[l+28], p[l+30], p[l+32]) + + @fastmath p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15], + p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16], + p[l+17], p[l+19], p[l+21], p[l+23], p[l+25], p[l+27], p[l+29], p[l+31], + p[l+18], p[l+20], p[l+22], p[l+24], p[l+26], p[l+28], p[l+30], p[l+32] = mat * vi + end + end + if q1==1 && q2 == 2 && q3 == 3 + f = f123 + elseif q1==1 && q2 == 2 && q3 == 4 + f = f124 + elseif q1==1 && q2 == 3 && q3 == 4 + f = f134 + elseif q1==2 && q2 == 3 && q3 == 4 + f = f234 + else + error(""qubit position $q1 and $q2 not allowed for LL."") + end + total_itr = div(L, 32) + + # n_threads = Threads.nthreads() + # if (total_itr >= MIN_SIZE) && (n_threads > 1) + # nave, resi, jobs = partition_jobs(total_itr, n_threads) + # Threads.@threads for s in 1:n_threads + # ist = jobs[s] + # ifn = jobs[s+1] - 1 + # f(ist, ifn, U, v) + # end + # else + # f(0, total_itr-1, U, v) + # end + parallel_run(total_itr, Threads.nthreads(), f, U, v) +end + +function _apply_gate_threaded2!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) + q0, q1, q2 = key + if q0 > 2 + return _apply_threebody_gate_HHH!(key, SMatrix{8,8, eltype(v)}(transpose(U)), v) + elseif q1 > 3 + return _apply_threebody_gate_LHH!(key, SMatrix{8,8, eltype(v)}(transpose(U)), v) + elseif q2 > 4 + return _apply_threebody_gate_LLH!(key, SMatrix{8,8, eltype(v)}(transpose(U)), v) + else + return _apply_threebody_gate_LLL!(key, SMatrix{8,8, eltype(v)}(U), v) + end +end + + + +","Julia" +"Conjugate","guochu/VQC.jl","src/applygates/generic/serial_short_range.jl",".jl","2549","75"," +function _apply_gate_2_impl!(key::Int, U::AbstractMatrix, v::AbstractVector) + L = length(v) + pos = 2^(key-1) + strid = pos * 2 + for i in 0:strid:(L-1) + @inbounds for j in 0:(pos-1) + l = i + j + 1 + vi1 = v[l] + vi2 = v[l + pos] + vo1 = U[1,1] * vi1 + U[1,2] * vi2 + vo2 = U[2,1] * vi1 + U[2,2] * vi2 + v[l] = vo1 + v[l + pos] = vo2 + end + end +end + +_apply_gate_2!(key::Int, U::AbstractMatrix, v::AbstractVector) = _apply_gate_2_impl!( +key, SMatrix{2,2, eltype(v)}(U), v) +_apply_gate_2!(key::Tuple{Int}, U::AbstractMatrix, v::AbstractVector) = _apply_gate_2!(key[1], U, v) + +function _apply_gate_2_impl!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector) + # U = Matrix(transpose(reshape(U, 4, 4))) + L = length(v) + q1, q2 = key + pos1, pos2 = 2^(q1-1), 2^(q2-1) + stride1, stride2 = 2 * pos1, 2 * pos2 + for i in 0:stride2:(L-1) + for j in 0:stride1:(pos2-1) + @inbounds for k in 0:(pos1-1) + l = i + j + k + 1 + vi = SVector(v[l], v[l + pos1], v[l + pos2], v[l + pos1 + pos2]) + v[l], v[l + pos1], v[l + pos2], v[l + pos1 + pos2] = U * vi + end + end + end +end + +function _apply_gate_2_impl!(key::Tuple{Int, Int, Int}, m::AbstractMatrix, v::AbstractVector) + L = length(v) + q1, q2, q3 = key + pos1, pos2, pos3 = 2^(q1-1), 2^(q2-1), 2^(q3-1) + stride1, stride2, stride3 = 2 * pos1, 2 * pos2, 2 * pos3 + for h in 0:stride3:(L-1) + for i in 0:stride2:(pos3-1) + for j in 0:stride1:(pos2-1) + @inbounds for k in 0:(pos1-1) + l000 = h + i + j + k + 1 + l100 = l000 + pos1 + l010 = l000 + pos2 + l110 = l010 + pos1 + + l001 = l000 + pos3 + l101 = l001 + pos1 + l011 = l001 + pos2 + l111 = l011 + pos1 + vi = SVector(v[l000], v[l100], v[l010], v[l110], v[l001], v[l101], v[l011], v[l111]) + + @fastmath v[l000], v[l100], v[l010], v[l110], v[l001], v[l101], v[l011], v[l111] = m * vi + + end + end + end + end +end + +_apply_gate_2!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector) = _apply_gate_2_impl!( +key, SMatrix{4,4, eltype(v)}(U), v) +_apply_gate_2!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) = _apply_gate_2_impl!( +key, SMatrix{8,8, eltype(v)}(U), v) + + + +","Julia" +"Conjugate","guochu/VQC.jl","src/applygates/generic/generic.jl",".jl","1867","65"," +include(""serial_short_range.jl"") +include(""threaded_short_range.jl"") +include(""threaded_long_range.jl"") + +function apply!(x::Gate, state::StateVector) + @assert _check_pos_range(x, nqubits(state)) + T = eltype(state) + if (eltype(x) <: Complex) && (T <: Real) + state = convert(StateVector{Complex{T}}, state) + end + apply_threaded!(x, storage(state)) + return state +end + +function apply!(x::Gate, state::DensityMatrix) + @assert _check_pos_range(x, nqubits(state)) + T = eltype(state) + if (eltype(x) <: Complex) && (T <: Real) + state = convert(DensityMatrix{Complex{T}}, state) + end + _dm_apply_threaded!(x, state.data, nqubits(state)) + return state +end + +function apply!(circuit::QCircuit, state::Union{StateVector, DensityMatrix}) + for gate in circuit + state = apply!(gate, state) + end + return state +end + +Base.:*(circuit::QCircuit, state::Union{StateVector, DensityMatrix}) = apply!(circuit, copy(state)) + +function _check_pos_range(x, n::Int) + pos = ordered_positions(x) + (length(pos) > 5) && throw(""only implement 5-qubit gates and less currently."") + return (pos[1] >= 1) && (pos[end] <= n) +end + + + +apply_serial!(x::Gate, s::AbstractVector) = _apply_gate_2!(ordered_positions(x), ordered_mat(x), s) +apply_serial!(x::Gate, state::StateVector) = (apply_serial!(x, storage(state)); state) + + +"""""" + currently support mostly 5-qubit gate +"""""" +apply_threaded!(x::Gate, s::AbstractVector) = (length(s) >= 32) ? _apply_gate_threaded2!(ordered_positions(x), ordered_mat(x), s) : apply_serial!(x, s) + + +# unitary gate operation on density matrix +function _dm_apply_threaded!(x::Gate{N}, s::AbstractVector, n::Int) where N + pos = ordered_positions(x) + m = ordered_mat(x) + if length(s) >= 32 + _apply_gate_threaded2!(pos, m, s) + _apply_gate_threaded2!(ntuple(i->pos[i]+n, N), conj(m), s) + else + _apply_gate_2!(pos, m, s) + _apply_gate_2!(ntuple(i->pos[i]+n, N), conj(m), s) + end +end +","Julia" +"Conjugate","guochu/VQC.jl","test/check_high_qubit_gate.jl",".jl","8640","208"," + + + +function check_fourbody_single(::Type{T}, L::Int, j::Int, k::Int, l::Int, m::Int) where T + state1 = rand_state(T, L) + m1 = random_unitary(1) + m2 = random_unitary(1) + m3 = random_unitary(1) + m4 = random_unitary(1) + gate1 = from_external((j, k, l, m), kron(m1, m2, m3, m4)) + h = QubitsTerm(j=>m1, k=>m2, l=>m3, m=>m4) + state2 = matrix(L, h) * state1 + apply!(gate1, state1) + return maximum(abs.(storage(state1 - state2)) ) +end + +function check_fourbody(::Type{T}, L::Int, i::Int, j::Int, k::Int, l::Int) where T + errs = [] + push!(errs, check_fourbody_single(ComplexF64, L, i,j,k,l)) + push!(errs, check_fourbody_single(ComplexF64, L, i,j,l,k)) + push!(errs, check_fourbody_single(ComplexF64, L, j,i,k,l)) + push!(errs, check_fourbody_single(ComplexF64, L, j,i,l,k)) + push!(errs, check_fourbody_single(ComplexF64, L, l,k,j,i)) + push!(errs, check_fourbody_single(ComplexF64, L, k,i,l,j)) + return all(errs .< 1.0e-6) +end + +function check_fivebody_single(::Type{T}, L::Int, j::Int, k::Int, l::Int, m::Int, n::Int) where T + state1 = rand_state(T, L) + m1 = random_unitary(1) + m2 = random_unitary(1) + m3 = random_unitary(1) + m4 = random_unitary(1) + m5 = random_unitary(1) + gate1 = from_external((j, k, l, m, n), kron(m1, m2, m3, m4, m5)) + h = QubitsTerm(j=>m1, k=>m2, l=>m3, m=>m4, n=>m5) + state2 = matrix(L, h) * state1 + apply!(gate1, state1) + return maximum(abs.(storage(state1 - state2)) ) +end + +function check_fivebody(::Type{T}, L::Int, i::Int, j::Int, k::Int, l::Int, n::Int) where T + errs = [] + push!(errs, check_fivebody_single(ComplexF64, L, i,j,k,l,n)) + push!(errs, check_fivebody_single(ComplexF64, L, i,j,l,n,k)) + push!(errs, check_fivebody_single(ComplexF64, L, j,i,n,k,l)) + push!(errs, check_fivebody_single(ComplexF64, L, j,n,i,l,k)) + push!(errs, check_fivebody_single(ComplexF64, L, l,k,j,n,i)) + push!(errs, check_fivebody_single(ComplexF64, L, n,k,i,l,j)) + return all(errs .< 1.0e-6) +end + + +function check_qham_fourbody_single(::Type{T}, L::Int, j::Int, k::Int, l::Int, m::Int) where T + state1 = rand_state(T, L) + m1 = random_unitary(1) + m2 = random_unitary(1) + m3 = random_unitary(1) + m4 = random_unitary(1) + gate1 = from_external((j, k, l, m), kron(m1, m2, m3, m4)) + h = QubitsTerm(j=>m1, k=>m2, l=>m3, m=>m4) + state2 = h * state1 + apply!(gate1, state1) + return maximum(abs.(storage(state1 - state2)) ) +end + +function check_qham_fourbody(::Type{T}, L::Int, i::Int, j::Int, k::Int, l::Int) where T + errs = [] + push!(errs, check_qham_fourbody_single(ComplexF64, L, i,j,k,l)) + push!(errs, check_qham_fourbody_single(ComplexF64, L, i,j,l,k)) + push!(errs, check_qham_fourbody_single(ComplexF64, L, j,i,k,l)) + push!(errs, check_qham_fourbody_single(ComplexF64, L, j,i,l,k)) + push!(errs, check_qham_fourbody_single(ComplexF64, L, l,k,j,i)) + push!(errs, check_qham_fourbody_single(ComplexF64, L, k,i,l,j)) + return all(errs .< 1.0e-6) +end + +function check_qham_fivebody_single(::Type{T}, L::Int, j::Int, k::Int, l::Int, m::Int, n::Int) where T + state1 = rand_state(T, L) + m1 = random_unitary(1) + m2 = random_unitary(1) + m3 = random_unitary(1) + m4 = random_unitary(1) + m5 = random_unitary(1) + gate1 = from_external((j, k, l, m, n), kron(m1, m2, m3, m4, m5)) + h = QubitsTerm(j=>m1, k=>m2, l=>m3, m=>m4, n=>m5) + state2 = h * state1 + apply!(gate1, state1) + return maximum(abs.(storage(state1 - state2)) ) +end + + +function check_qham_fivebody(::Type{T}, L::Int, i::Int, j::Int, k::Int, l::Int, n::Int) where T + errs = [] + push!(errs, check_qham_fivebody_single(ComplexF64, L, i,j,k,l,n)) + push!(errs, check_qham_fivebody_single(ComplexF64, L, i,j,l,n,k)) + push!(errs, check_qham_fivebody_single(ComplexF64, L, j,i,n,k,l)) + push!(errs, check_qham_fivebody_single(ComplexF64, L, j,n,i,l,k)) + push!(errs, check_qham_fivebody_single(ComplexF64, L, l,k,j,n,i)) + push!(errs, check_qham_fivebody_single(ComplexF64, L, n,k,i,l,j)) + return all(errs .< 1.0e-6) +end + +function check_expec_fourbody_single(::Type{T}, L::Int, j::Int, k::Int, l::Int, m::Int) where T + state = rand_state(T, L) + m = QubitsTerm(j=>random_unitary(1), k=>random_unitary(1), l=>random_unitary(1), + m=>random_unitary(1), coeff=0.9) + + return abs(expectation(m, state) - expectation(matrix(L, m), state)) +end + + +function check_expec_fourbody(::Type{T}, L::Int, i::Int, j::Int, k::Int, l::Int) where T + errs = [] + push!(errs, check_expec_fourbody_single(T, L, i,j,k,l)) + push!(errs, check_expec_fourbody_single(T, L, i,j,l,k)) + push!(errs, check_expec_fourbody_single(T, L, j,i,k,l)) + push!(errs, check_expec_fourbody_single(T, L, j,i,l,k)) + push!(errs, check_expec_fourbody_single(T, L, l,k,j,i)) + push!(errs, check_expec_fourbody_single(T, L, k,i,l,j)) + return all(errs .< 1.0e-6) +end + +function check_expec_fourbody_single_2(::Type{T}, L::Int, j::Int, k::Int, l::Int, m::Int) where T + state1 = rand_state(T, L) + state2 = rand_state(T, L) + m = QubitsTerm(j=>random_unitary(1), k=>random_unitary(1), l=>random_unitary(1), + m=>random_unitary(1), coeff=0.7) + + return abs(expectation(state2, m, state1) - expectation(state2, matrix(L, m), state1)) +end + +function check_expec_fourbody_2(::Type{T}, L::Int, i::Int, j::Int, k::Int, l::Int) where T + errs = [] + push!(errs, check_expec_fourbody_single_2(T, L, i,j,k,l)) + push!(errs, check_expec_fourbody_single_2(T, L, i,j,l,k)) + push!(errs, check_expec_fourbody_single_2(T, L, j,i,k,l)) + push!(errs, check_expec_fourbody_single_2(T, L, j,i,l,k)) + push!(errs, check_expec_fourbody_single_2(T, L, l,k,j,i)) + push!(errs, check_expec_fourbody_single_2(T, L, k,i,l,j)) + return all(errs .< 1.0e-6) +end + +function check_expec_fivebody_single(::Type{T}, L::Int, j::Int, k::Int, l::Int, m::Int, n::Int) where T + state = rand_state(T, L) + m = QubitsTerm(j=>random_unitary(1), k=>random_unitary(1), l=>random_unitary(1), + m=>random_unitary(1), n=>random_unitary(1), coeff=0.77) + + return abs(expectation(m, state) - expectation(matrix(L, m), state)) +end + +function check_expec_fivebody_single_2(::Type{T}, L::Int, j::Int, k::Int, l::Int, m::Int, n::Int) where T + state1 = rand_state(T, L) + state2 = rand_state(T, L) + m = QubitsTerm(j=>random_unitary(1), k=>random_unitary(1), l=>random_unitary(1), + m=>random_unitary(1), n=>random_unitary(1), coeff=1.23) + + return abs(expectation(state2, m, state1) - expectation(state2, matrix(L, m), state1)) +end + +function check_expec_fivebody(::Type{T}, L::Int, i::Int, j::Int, k::Int, l::Int, n::Int) where T + errs = [] + push!(errs, check_expec_fivebody_single(T, L, j,i,n,k,l)) + push!(errs, check_expec_fivebody_single(T, L, j,n,i,l,k)) + push!(errs, check_expec_fivebody_single(T, L, j,n,i,k,l)) + push!(errs, check_expec_fivebody_single(T, L, l,k,j,n,i)) + push!(errs, check_expec_fivebody_single(T, L, n,k,i,l,j)) + push!(errs, check_expec_fivebody_single(T, L, i,j,k,l,n)) + return all(errs .< 1.0e-6) +end + +function check_expec_fivebody_2(::Type{T}, L::Int, i::Int, j::Int, k::Int, l::Int, n::Int) where T + errs = [] + push!(errs, check_expec_fivebody_single_2(T, L, j,i,n,k,l)) + push!(errs, check_expec_fivebody_single_2(T, L, j,n,i,l,k)) + push!(errs, check_expec_fivebody_single_2(T, L, j,n,i,k,l)) + push!(errs, check_expec_fivebody_single_2(T, L, l,k,j,n,i)) + push!(errs, check_expec_fivebody_single_2(T, L, n,k,i,l,j)) + push!(errs, check_expec_fivebody_single_2(T, L, i,j,k,l,n)) + return all(errs .< 1.0e-6) +end + +@testset ""check high-qubit gate operations"" begin + @test check_fourbody(ComplexF32, 4,1,2,3,4) + @test check_fourbody(ComplexF64, 10,10,7,1,4) + @test check_fivebody(ComplexF32, 5,1,2,3,5,4) + @test check_fivebody(ComplexF32, 10,9,7,10,1,4) +end + +@testset ""check high-qubit hamiltonian term operations"" begin + @test check_qham_fourbody(ComplexF32, 4,1,2,3,4) + @test check_qham_fourbody(ComplexF64, 10,6,7,1,4) + @test check_qham_fivebody(ComplexF32, 5,1,2,3,5,4) + @test check_qham_fivebody(ComplexF32, 11,9,11,10,1,4) +end + +@testset ""check hamiltonion high-qubit term expectation value"" begin + @test check_expec_fourbody(ComplexF64, 4, 1,2,3,4) + @test check_expec_fourbody(ComplexF64, 9, 7,8,1,5) + @test check_expec_fivebody(ComplexF64, 5, 1,2,3,5,4) + @test check_expec_fivebody(ComplexF64, 10, 7,10,2,5,8) + @test check_expec_fourbody_2(ComplexF32, 4, 1,2,3,4) + @test check_expec_fourbody_2(ComplexF64, 10, 7,10,1,5) + @test check_expec_fivebody_2(ComplexF64, 5, 1,2,3,5,4) + @test check_expec_fivebody_2(ComplexF32, 10, 7,10,2,5,8) +end +","Julia" +"Conjugate","guochu/VQC.jl","test/check_state_init.jl",".jl","2164","48"," +function check_statevector_init_1() + a0 = storage(StateVector(1)) == Gates.ZERO + a1 = storage(onehot_encoding([1])) == Gates.ONE + a2 = storage(onehot_encoding([0])) == Gates.ZERO + a3 = storage(onehot_encoding(2)) == kron(Gates.ZERO, Gates.ZERO) + a4 = storage(onehot_encoding([1, 0])) == kron(Gates.ZERO, Gates.ONE) + a5 = storage(onehot_encoding([0, 1])) == kron(Gates.ONE, Gates.ZERO) + a6 = storage(onehot_encoding([1, 1])) == kron(Gates.ONE, Gates.ONE) + a7 = storage(onehot_encoding([1,0,0])) == kron(Gates.ZERO, Gates.ZERO, Gates.ONE) + a8 = storage(reset_onehot!(onehot_encoding([1, 1]), [0, 1])) == kron(Gates.ONE, Gates.ZERO) + a9 = storage(reset_onehot!(onehot_encoding([1,0,1]), [0,0,1])) == kron(Gates.ONE, Gates.ZERO, Gates.ZERO) + return a0 && a1 && a2 && a3 && a4 && a5 && a6 && a7 && a8 && a9 +end + + +function check_statevector_init_2() + v = [sqrt(2)/2, sqrt(2)/2] + a0 = isapprox(onehot_encoding([0]), qubit_encoding([0.]) ) + a1 = isapprox(onehot_encoding([1]), qubit_encoding([1.])) + a2 = isapprox(onehot_encoding([1,0]), qubit_encoding([1.,0.])) + a3 = isapprox(onehot_encoding([1,1]), qubit_encoding([1.,1.])) + a4 = isapprox(storage(qubit_encoding([0.5])), v) + a5 = isapprox(storage(qubit_encoding([0.5, 1])), kron(Gates.ONE, v)) + a6 = isapprox(storage(reset_qubit!(onehot_encoding([0, 1]), [0, 0.5])), kron(v, Gates.ZERO)) + a7 = isapprox(storage(reset_qubit!(onehot_encoding([1,1,1]), [0, 0.5, 0.5])), kron(v, v, Gates.ZERO)) + a8 = isapprox(storage(reset_qubit!(onehot_encoding([1,1,1,0,1]), [0, 0.5, 0.5, 1, 0])), kron(Gates.ZERO, Gates.ONE, v, v, Gates.ZERO)) + return a0 && a1 && a2 && a3 && a4 && a5 && a6 && a7 && a8 +end + + +function check_statevector_init_3(L::Int) + v = randn(L) + a0 = isapprox(StateVector(qubit_encoding(v)), qubit_encoding(v), atol=1.0e-8) + v = rand(0:1, L) + a2 = isapprox(StateVector(onehot_encoding(v)), onehot_encoding(v), atol=1.0e-8) + return a0 && a2 +end + + +@testset ""check qubit encoding initialization of quantum state"" begin + @test check_statevector_init_1() + @test check_statevector_init_2() + for L in [3,4] + @test check_statevector_init_3(L) + end +end +","Julia" +"Conjugate","guochu/VQC.jl","test/check_measure.jl",".jl","1765","76"," +function check_measure_1() + state = rand_state(Float64, 3) + i, p = measure!(state, 1, auto_reset=true) + tmp, i1, p1 = measure(state, 1) + return i1 == 0 && isapprox(p1, 1, atol=1.0e-10) +end + +function check_measure_2() + state = rand_state(ComplexF64, 3) + i, p = measure!(state, 2, auto_reset=false) + tmp, i1, p1 = measure(state, 2) + return i1 == i && isapprox(p1, 1, atol=1.0e-10) +end + +function check_select_1() + state = rand_state(Float64, 3) + post_select!(state, 2, 0) + tmp, i1, p1 = measure(state, 2) + return i1 == 0 && isapprox(p1, 1, atol=1.0e-10) +end + +function check_select_2() + state = rand_state(Float64, 3) + post_select!(state, 3, 1) + tmp, i1, p1 = measure(state, 3) + return i1 == 1 && isapprox(p1, 1, atol=1.0e-10) +end + +function check_select_3() + state = (sqrt(2)/2) * (qubit_encoding([0, 0]) + qubit_encoding([1, 1])) + r, p = post_select(state, 1, 0) + return isapprox(storage(r), Gates.ZERO) +end + +function check_select_4() + state = (sqrt(2)/2) * (qubit_encoding([0, 0]) + qubit_encoding([1, 1])) + r, p = post_select(state, 1, 1) + return isapprox(storage(r), Gates.ONE) +end + +function check_select_grad() + initial_state = qubit_encoding([0, 1]) + function loss(s) + r, p = post_select(s, 2, 1) + return distance(r, initial_state) + p^2 + end + loss_fd(θs) = loss(StateVector(θs)) + + x = rand_state(ComplexF64, 3) + grad1 = storage(gradient(loss, x)[1]) + grad2 = fdm_gradient(loss_fd, storage(x)) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + +@testset ""check quantum measure"" begin + @test check_measure_1() + @test check_measure_2() +end + +@testset ""check quantum select"" begin + @test check_select_1() + @test check_select_2() + @test check_select_3() + @test check_select_4() +end + +@testset ""check quantum select grad"" begin + @test check_select_grad() +end + + + + + +","Julia" +"Conjugate","guochu/VQC.jl","test/parameter.jl",".jl","1332","55"," +function test_parameter(L::Int, depth::Int) + circuit = QCircuit() + counts = 0 + vars = [] + for i in 1:L + push!(circuit, HGate(i)) + end + for i in 1:L + parameter = randn(Float64) + # variable indicate a parameter + push!(circuit, RxGate(i, parameter, isparas=true)) + counts += 1 + push!(vars, parameter) + # this is not a parameter + push!(circuit, RxGate(i, parameter + 1, isparas=false)) + end + for d in 1:depth + for i in 1:(L-1) + push!(circuit, CNOTGate(i, i+1)) + end + for i in 1:L + parameter = randn(Float64) + # variable indicate a parameter + push!(circuit, RxGate(i, parameter, isparas=true)) + counts += 1 + push!(vars, parameter) + # this is not a parameter + push!(circuit, RxGate(i, parameter + 1, isparas=false)) + end + end + check1 = (nparameters(circuit) == counts) + check2 = (active_parameters(circuit) == vars) + new_vars = randn(Float64, size(vars)...) + reset_parameters!(circuit, new_vars) + check3 = (nparameters(circuit) == counts) + check4 = (active_parameters(circuit) == new_vars) + + # println(""check1 $check1, check2 $check2, check3 $check3, check4 $check4"") + return check1 && check2 && check3 && check4 +end + + + +@testset ""set the parameters of quantum circuit"" begin + for L in 2:10 + for depth in 0:7 + @test test_parameter(L, depth) + end + end +end + + + +","Julia" +"Conjugate","guochu/VQC.jl","test/check_utility.jl",".jl","271","15"," + +function check_ptrace(sites) + a = rand_state(6) + b = DensityMatrix(a) + return partial_tr(a, sites) ≈ partial_tr(b, sites) +end + +@testset ""check partial trace of quantum state"" begin + @test check_ptrace([1,2]) + @test check_ptrace([2,5]) + @test check_ptrace([6,3]) +end + +","Julia" +"Conjugate","guochu/VQC.jl","test/stategrad.jl",".jl","3059","117"," +"""""" + state gradient with distance loss function +"""""" +function state_grad_dot_real(L::Int, depth::Int) + target_state = rand_state(ComplexF64, L) + initial_state = rand_state(ComplexF64, L) + circuit = variational_circuit_1d(L, depth) + + loss(x) = real(dot(target_state, circuit * x)) + loss_fd(θs) = loss(StateVector(θs)) + + grad1 = storage(gradient(loss, initial_state)[1]) + grad2 = fdm_gradient(loss_fd, amplitudes(initial_state)) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + +"""""" + state gradient with distance loss function +"""""" +function state_grad_dot_imag(L::Int, depth::Int) + target_state = rand_state(ComplexF64, L) + initial_state = rand_state(ComplexF64, L) + circuit = variational_circuit_1d(L, depth) + + loss(x) = imag(dot(target_state, circuit * x)) + loss_fd(θs) = loss(StateVector(θs)) + + grad1 = storage(gradient(loss, initial_state)[1]) + grad2 = fdm_gradient(loss_fd, amplitudes(initial_state)) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + +"""""" + state gradient with distance loss function +"""""" +function state_grad_dot_abs(L::Int, depth::Int) + target_state = rand_state(ComplexF64, L) + initial_state = rand_state(ComplexF64, L) + circuit = variational_circuit_1d(L, depth) + + loss(x) = abs(dot(target_state, circuit * x)) + loss_fd(θs) = loss(StateVector(θs)) + + grad1 = storage(gradient(loss, initial_state)[1]) + grad2 = fdm_gradient(loss_fd, amplitudes(initial_state)) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + +"""""" + state gradient with distance loss function +"""""" +function state_grad_distance(L::Int, depth::Int) + target_state = rand_state(ComplexF64, L) + initial_state = rand_state(ComplexF64, L) + circuit = variational_circuit_1d(L, depth) + + loss(x) = distance(target_state, circuit * x) + loss_fd(θs) = loss(StateVector(θs)) + + grad1 = storage(gradient(loss, initial_state)[1]) + grad2 = fdm_gradient(loss_fd, amplitudes(initial_state)) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + + +function qstate_grad(::Type{T}, L::Int) where {T<:Number} + target_state = rand_state(T, L) + loss(v) = abs(dot(target_state, qubit_encoding(T, v))) + x = randn(L) + + grad1 = gradient(loss, x)[1] + grad2 = fdm_gradient(loss, x) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + +@testset ""gradient of quantum state with loss function real(dot(a, circuit*x))"" begin + for L in 2:5 + for depth in 0:5 + @test state_grad_dot_real(L, depth) + end + end +end + +@testset ""gradient of quantum state with loss function imag(dot(a, circuit*x))"" begin + for L in 2:5 + for depth in 0:5 + @test state_grad_dot_imag(L, depth) + end + end +end + +@testset ""gradient of quantum state with loss function abs(dot(a, circuit*x))"" begin + for L in 2:5 + for depth in 0:5 + @test state_grad_dot_abs(L, depth) + end + end +end + +@testset ""gradient of quantum state with loss function distance(a, circuit*x)"" begin + for L in 2:5 + for depth in 0:5 + @test state_grad_distance(L, depth) + end + end +end + + +@testset ""gradient of quantum state initializer qstate"" begin + for L in 2:5 + for T in [Float64, Complex{Float64}] + @test qstate_grad(T, L) + end + end +end +","Julia" +"Conjugate","guochu/VQC.jl","test/runtests.jl",".jl","1824","85","push!(LOAD_PATH, ""../src"") + +include(""util.jl"") + +using Test +using Zygote, LinearAlgebra + +using QuantumCircuits, QuantumCircuits.Gates +using QuantumCircuits: n_qubits_mat_from_external +using VQC, VQC.Utilities +using VQC: apply_serial! + +_check_unitary(m::AbstractMatrix) = isapprox(m' * m, LinearAlgebra.I) + +function from_external(key::NTuple{N, Int}, m::AbstractMatrix; check_unitary::Bool=true) where N + (size(m, 1) == 2^N) || error(""wrong input matrix size."") + if check_unitary + _check_unitary(m) || error(""input matrix is not unitary."") + end + return QuantumGate(key, n_qubits_mat_from_external(m)) +end + +function random_unitary(n::Int) + L = 2^n + m = randn(ComplexF64, L, L) + return exp(im * (m + m')) +end + + +@testset ""test quantum gate operations"" begin + include(""check_gateop.jl"") + include(""check_high_qubit_gate.jl"") +end + +@testset ""test quantum state initialization"" begin + include(""check_state_init.jl"") +end + + +@testset ""test qubit hamiltonian operations"" begin + include(""check_qubits_ham.jl"") +end + +@testset ""test circuit parameters"" begin + include(""parameter.jl"") +end + +@testset ""test measure and select"" begin + include(""check_measure.jl"") +end + + +@testset ""test quantum algorithm"" begin + include(""algs.jl"") +end + +@testset ""test utility"" begin + include(""check_utility.jl"") +end + + +@testset ""test quantum circuit gradient"" begin + include(""circuitgrad.jl"") + include(""crxgategrad.jl"") +end + + +@testset ""test expectation value gradient"" begin + include(""check_ham_expec_diff.jl"") +end + +@testset ""test quantum state gradient (may not variable via a quantum computer)"" begin + include(""stategrad.jl"") +end + + +@testset ""test density matrix operations"" begin + include(""stategrad.jl"") +end + +@testset ""test noisy quantum circuit"" begin + include(""check_noisy_grad.jl"") +end + +","Julia" +"Conjugate","guochu/VQC.jl","test/algs.jl",".jl","1954","88"," +function to_digits(s::Vector{Int}) + r = 0. + for i = 1:length(s) + r = r + s[i]*(2.)^(-i) + end + return r +end + +function phase_estimate_circuit(j::Vector{Int}) + L = length(j) + circuit = QCircuit() + phi = to_digits(j) + U = [exp(2*pi*im*phi) 0; 0. 1.] + for i = 1:L + push!(circuit, (i, H)) + end + + tmp = U + for i = L:-1:1 + push!(circuit, ((i, L+1), Gates.CONTROL(tmp))) + tmp = tmp * tmp + end + push!(circuit, QFT(L)') + return circuit +end + + +function simple_phase_estimation_1(L::Int, auto_reset::Bool=false) + j = rand(0:1, L) + state = StateVector(L+1) + phi = to_digits(j) + circuit = phase_estimate_circuit(j) + apply!(circuit, state) + res = Int[] + for i = 1:(L+1) + i, p = measure!(state, i, auto_reset=auto_reset) + push!(res, i) + end + phi_out = to_digits(res) + return (phi == phi_out) && (j[1:L] == res[1:L]) +end + +function simple_phase_estimation_1_dm(L::Int, auto_reset::Bool=false) + j = rand(0:1, L) + state = DensityMatrix(L+1) + phi = to_digits(j) + circuit = phase_estimate_circuit(j) + apply!(circuit, state) + res = Int[] + for i = 1:(L+1) + i, p = measure!(state, i, auto_reset=auto_reset) + push!(res, i) + end + phi_out = to_digits(res) + return (phi == phi_out) && (j[1:L] == res[1:L]) +end + +function simple_phase_estimation_2(L::Int) + + j = rand(0:1, L) + state = StateVector(L+1) + phi = to_digits(j) + circuit = phase_estimate_circuit(j) + apply!(circuit, state) + res = Int[] + for i = 1:(L+1) + state, i, p = measure(state, 1) + push!(res, i) + end + phi_out = to_digits(res) + return length(storage(state))==1 && isapprox(state[1], 1, atol=1.0e-10) && (phi == phi_out) && (j[1:L] == res[1:L]) +end + +@testset ""simple phase estimation"" begin + for L in 2:15 + @test simple_phase_estimation_1(L, false) + @test simple_phase_estimation_1(L, true) + end + for L in 2:6 + @test simple_phase_estimation_1_dm(L, false) + @test simple_phase_estimation_1_dm(L, true) + end + for L in 2:15 + @test simple_phase_estimation_2(L) + end +end +","Julia" +"Conjugate","guochu/VQC.jl","test/check_gateop.jl",".jl","6318","186"," + + + +function check_onebody_single(::Type{T}, L::Int, c::Int) where {T<:Number} + state1 = rand_state(T, L) + state2 = copy(state1) + gate = QuantumGate(c, random_unitary(1)) + apply_serial!(gate, state1) + apply!(gate, state2) + return maximum(abs.(storage(state1 - state2)) ) +end + +function check_onebody(::Type{T}, L::Int) where {T<:Number} + errs = [] + for c in 1:L + push!(errs, check_onebody_single(T, L, c)) + end + # println(""total number of tests $(length(errs))."") + return all(errs .< 1.0e-6) +end + +function check_twobody_single(::Type{T}, L::Int, c::Int, t::Int) where {T<:Number} + state1 = rand_state(T, L) + state2 = copy(state1) + gate = QuantumGate((c, t), random_unitary(2)) + apply_serial!(gate, state1) + apply!(gate, state2) + return maximum(abs.(storage(state1 - state2)) ) +end + +function check_twobody(::Type{T}, L::Int) where {T<:Number} + errs = [] + for c in 1:2:L + for t in 2:2:L + if c != t + push!(errs, check_twobody_single(T, L, c, t)) + end + end + end + # println(""total number of tests $(length(errs))."") + return all(errs .< 1.0e-6) +end + +function check_threebody_single(::Type{T}, L::Int, a::Int, b::Int, c::Int) where {T<:Number} + state1 = rand_state(T, L) + state2 = copy(state1) + gate = QuantumGate((a, b, c), random_unitary(3)) + apply_serial!(gate, state1) + apply!(gate, state2) + return maximum(abs.(storage(state1 - state2)) ) +end + +function check_threebody(::Type{T}, L::Int) where {T<:Number} + errs = [] + for a in 1:2:L + for b in 2:3:L + for c in 3:5:L + if a != b && a != c && b != c + push!(errs, check_threebody_single(T, L, a, b, c)) + end + end + end + end + # println(""total number of tests $(length(errs))."") + return all(errs .< 1.0e-6) +end + +function check_single_gate(::Type{T}, L::Int, gt) where {T<:Number} + state1 = rand_state(T, L) + state2 = copy(state1) + apply!(gt, state1) + apply!(gate(ordered_positions(gt), ordered_mat(gt)), state2) + return maximum(abs.(storage(state1 - state2)) ) +end + +function check_specialized_onebody_gates(::Type{T}, L::Int) where {T<:Number} + errs = [] + for c in 1:L + gt = XGate(c) + push!(errs, check_single_gate(T, L, gt)) + push!(errs, check_single_gate(T, L, gt')) + gt = YGate(c) + push!(errs, check_single_gate(T, L, gt)) + push!(errs, check_single_gate(T, L, gt')) + gt = ZGate(c) + push!(errs, check_single_gate(T, L, gt)) + push!(errs, check_single_gate(T, L, gt')) + gt = TGate(c) + push!(errs, check_single_gate(T, L, gt)) + push!(errs, check_single_gate(T, L, gt')) + gt = PHASEGate(c, randn()) + push!(errs, check_single_gate(T, L, gt)) + push!(errs, check_single_gate(T, L, gt')) + end + return all(errs .< 1.0e-6) +end + +function check_specialized_twobody_gates(::Type{T}, L::Int) where {T<:Number} + errs = [] + for c in 1:2:L + for t in 2:2:L + if c != t + gt = CONTROLGate((c, t), random_unitary(1)) + push!(errs, check_single_gate(T, L, gt)) + push!(errs, check_single_gate(T, L, gt')) + gt = CRxGate(c, t, randn()) + push!(errs, check_single_gate(T, L, gt)) + push!(errs, check_single_gate(T, L, gt')) + gt = CRyGate(c, t, randn()) + push!(errs, check_single_gate(T, L, gt)) + push!(errs, check_single_gate(T, L, gt')) + gt = CRzGate(c, t, randn()) + push!(errs, check_single_gate(T, L, gt)) + push!(errs, check_single_gate(T, L, gt')) + + gt = CZGate(c, t) + push!(errs, check_single_gate(T, L, gt)) + push!(errs, check_single_gate(T, L, gt')) + gt = CNOTGate(c, t) + push!(errs, check_single_gate(T, L, gt)) + push!(errs, check_single_gate(T, L, gt')) + + gt = CPHASEGate(c, t, randn()) + push!(errs, check_single_gate(T, L, gt)) + push!(errs, check_single_gate(T, L, gt')) + + gt = SWAPGate(c, t) + push!(errs, check_single_gate(T, L, gt)) + push!(errs, check_single_gate(T, L, gt')) + gt = iSWAPGate(c, t) + push!(errs, check_single_gate(T, L, gt)) + push!(errs, check_single_gate(T, L, gt')) + + gt = FSIMGate(c, t, randn(5)) + push!(errs, check_single_gate(T, L, gt)) + push!(errs, check_single_gate(T, L, gt')) + end + end + end + return all(errs .< 1.0e-6) +end + +function check_specialized_threebody_gates(::Type{T}, L::Int) where {T<:Number} + errs = [] + for a in 1:2:L + for b in 2:3:L + for c in 3:5:L + if a != b && a != c && b != c + gt = CONTROLCONTROLGate(a, b, c, random_unitary(1)) + push!(errs, check_single_gate(T, L, gt)) + push!(errs, check_single_gate(T, L, gt')) + gt = TOFFOLIGate(a, b, c) + push!(errs, check_single_gate(T, L, gt)) + push!(errs, check_single_gate(T, L, gt')) + gt = FREDKINGate(a, b, c) + push!(errs, check_single_gate(T, L, gt)) + push!(errs, check_single_gate(T, L, gt')) + + gt = CCPHASEGate(a, b, c, randn()) + push!(errs, check_single_gate(T, L, gt)) + push!(errs, check_single_gate(T, L, gt')) + end + end + end + end + return all(errs .< 1.0e-6) +end + +@testset ""check generic gate operations"" begin + @test check_onebody(ComplexF32, 16) + @test check_onebody(ComplexF64, 15) + for L in 5:10:15 + @test check_twobody(ComplexF32, L) + @test check_twobody(ComplexF64, L) + end + @test check_threebody(ComplexF32, 16) + @test check_threebody(ComplexF64, 15) +end + +@testset ""check specialized gate operations"" begin + @test check_specialized_onebody_gates(ComplexF32, 16) + @test check_specialized_twobody_gates(ComplexF32, 16) + @test check_specialized_threebody_gates(ComplexF64, 15) +end +","Julia" +"Conjugate","guochu/VQC.jl","test/check_noisy_grad.jl",".jl","1728","60"," + +function noisy_circuit(L, depth; kwargs...) + circuit = variational_circuit_1d(L, depth; kwargs...) + for i in 1:L + push!(circuit, Depolarizing(i, p=0.1)) + end + return circuit +end + +function check_noisy_circuit_grad(L, depth) + circuit = noisy_circuit(L, depth) + initial_state = DensityMatrix(ComplexF64, L) + + loss(x) = real( sum(storage(x * initial_state)) ) + loss_fd(θs) = loss(noisy_circuit(L, depth, θs=θs)) + + grad1 = gradient(loss, circuit)[1] + grad2 = fdm_gradient(loss_fd, active_parameters(circuit)) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + +function check_noisy_circuit_expec_grad(L, depth) + circuit = noisy_circuit(L, depth) + m = QubitsTerm(1=>""+"", L-1=>""-"", coeff=0.7) + QubitsTerm(1=>""-"", L-1=>""+"", coeff=0.77) + QubitsTerm(1=>""X"", L=>""Y"", coeff=0.36) + initial_state = DensityMatrix(ComplexF64, L) + + loss(x) = real(expectation(m, x * initial_state)) + loss_fd(θs) = loss(noisy_circuit(L, depth, θs=θs)) + + grad1 = gradient(loss, circuit)[1] + grad2 = fdm_gradient(loss_fd, active_parameters(circuit)) + # println(""error is $(maximum(abs.(grad1 - grad2)))"") + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + +function check_ham_term_grad(::Type{T}, L) where T + state = rand_densitymatrix(T, L) + + m = QubitsTerm(1=>""+"", L-1=>""Y"", coeff=0.36) + + loss(x) = abs(expectation(m, x)) + loss_fd(θs) = loss(DensityMatrix(θs)) + + grad1 = storage(gradient(loss, state)[1]) + grad2 = fdm_gradient(loss_fd, storage(state)) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + + + +@testset ""gradient of noisy quantum circuit"" begin + for L in 2:5 + @test check_ham_term_grad(ComplexF64, L) + for depth in 0:5 + @test check_noisy_circuit_grad(L, depth) + @test check_noisy_circuit_expec_grad(L, depth) + end + end +end","Julia" +"Conjugate","guochu/VQC.jl","test/check_ham_expec_diff.jl",".jl","2292","78"," +function check_ham_term_grad(::Type{T}, L) where T + state = rand_state(T, L) + + m = QubitsTerm(1=>""+"", L-1=>""Y"", coeff=0.36) + loss(x) = abs(expectation(m, x)) + loss_fd(θs) = loss(StateVector(θs)) + + grad1 = storage(gradient(loss, state)[1]) + grad2 = fdm_gradient(loss_fd, amplitudes(state)) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + +function check_ham_expec_grad(::Type{T}, L) where T + state = rand_state(T, L) + + m = QubitsTerm(1=>""+"", L-1=>""-"", coeff=0.77) + QubitsTerm(1=>""-"", L-1=>""+"", coeff=0.77) + QubitsTerm(1=>""X"", L=>""Y"", coeff=0.36) + loss(x) = abs(expectation(m, x)) + loss_fd(θs) = loss(StateVector(θs)) + + grad1 = storage(gradient(loss, state)[1]) + grad2 = fdm_gradient(loss_fd, amplitudes(state)) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + +function check_qterm_expec_grad_long(::Type{T}, L, n) where T + state = rand_state(T, L) + + m = QubitsTerm(Dict(i=>""X"" for i in 1:n), coeff=0.77) + loss(x) = abs(expectation(m, x)) + loss_fd(θs) = loss(StateVector(θs)) + + grad1 = storage(gradient(loss, state)[1]) + grad2 = fdm_gradient(loss_fd, amplitudes(state)) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + +function check_ham_expec_grad_long(::Type{T}, L, n) where T + state = rand_state(T, L) + + m = QubitsTerm(Dict(i=>""X"" for i in 1:n), coeff=0.77) + QubitsTerm(1=>""X"", coeff=1.2) + QubitsTerm(1=>""X"", 2=>""Z"", coeff=0.3) + loss(x) = abs(expectation(m, x)) + loss_fd(θs) = loss(StateVector(θs)) + + grad1 = storage(gradient(loss, state)[1]) + grad2 = fdm_gradient(loss_fd, amplitudes(state)) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + +function check_mps_ham_expec_grad(::Type{T}, L::Int) where {T<:Number} + observer = QubitsTerm(1=>""Z"", 3=>""Z"") + loss(v) = real(expectation(observer, qubit_encoding(T, v))) + + v = randn(L) + + grad1 = gradient(loss, v)[1] + grad2 = fdm_gradient(loss, v) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + + +@testset ""gradient of quantum operator expectation value"" begin + for L in 3:6 + @test check_ham_term_grad(ComplexF64, L) + @test check_ham_expec_grad(ComplexF64, L) + for n in 1:L + @test check_qterm_expec_grad_long(ComplexF64, L, n) + @test check_ham_expec_grad_long(ComplexF64, L, n) + end + end + for T in [Float64, ComplexF64] + for L in 3:6 + @test check_mps_ham_expec_grad(ComplexF64, L) + end + end +end + +","Julia" +"Conjugate","guochu/VQC.jl","test/util.jl",".jl","2855","110"," + +using FiniteDifferences + + +fdm_gradient(f, v; kwargs...) = error(""fdm_gradient not implemented for type $(typeof(v))"") + +fdm_gradient(f, v::Real; order::Int=5, kwargs...) = central_fdm(order, 1; kwargs...)(f, v) +fdm_gradient(f, v::Complex; order::Int=5, kwargs...) = begin + f_real(vr::Real) = f(complex(vr, imag(v))) + f_imag(vi::Real) = f(complex(real(v), vi)) + m = central_fdm(order, 1; kwargs...) + da = m(f_real, real(v)) + db = m(f_imag, imag(v)) + return complex(da, db) +end + +fdm_gradient(f, v::AbstractArray; kwargs...) = begin + # x = copy(v) + tmp = copy(v) + r = similar(v) + for l in 1:length(v) + g(s) = begin + tmp[l] = s + d = f(tmp) + tmp[l] = v[l] + return d + end + r[l] = fdm_gradient(g, v[l]; kwargs...) + # tmp[l] = v[l] + end + return r +end + + +function fdm_gradient(f, args...; kwargs...) + r = [] + v0 = f(args...) + # args = [args...] + L = length(args) + for l in 1:L + g(x) = f(args[1:(l-1)]..., x, args[(l+1):L]...) + push!(r, fdm_gradient(g, args[l]; kwargs...)) + end + return (r...,) +end + +# collect_variables_impl!(a::Vector, b::Nothing) = nothing +# collect_variables_impl!(a::Vector, b::Number) = push!(a, b) +# function collect_variables_impl!(a::Vector, b::AbstractArray) +# for item in b +# collect_variables_impl!(a, item) +# end +# end + +# function collect_variables_impl!(a::Vector, b::AbstractDict) +# for (k, v) in b +# collect_variables_impl!(a, v) +# end +# end + +# function collect_variables_impl!(a::Vector, b::NamedTuple) +# for v in b +# collect_variables_impl!(a, v) +# end +# end + +# function collect_variables_impl!(a::Vector, b::Tuple) +# for v in b +# collect_variables_impl!(a, v) +# end +# end + +# """""" +# collect_variables(args...) +# Collect variables from args... +# """""" +# function collect_variables(args...) +# a = Number[] +# for item in args +# collect_variables_impl!(a, item) +# end +# return a +# end + + + +# """""" +# check_gradient(f, args...; verbosity::Int=0) +# Check the gradient of a function f with arguments args... +# """""" +# function check_gradient(f, args...; verbosity::Int=0) +# grad = collect_variables(gradient(f, args...)) +# tmpargs = collect(args) +# f2(x) = begin +# set_parameters!(x, tmpargs) +# return f(tmpargs...) +# end +# grad1 = simple_gradient(f2, collect_variables(tmpargs), dt=dt)[1] + +# diffmax = maximum(abs.(grad - grad1)) +# v = diffmax <= atol +# if (!v) && (verbosity > 0) +# println(""largest difference is $diffmax."") +# println(""auto gradient is $grad."") +# println(""---------------------------------------------------------------------"") +# println(""finite difference gradient is $grad1"") +# end +# return v +# end","Julia" +"Conjugate","guochu/VQC.jl","test/crxgategrad.jl",".jl","3816","150"," + +function crx_circuit(L::Int, depth::Int) + n = 0 + circuit = QCircuit() + for d in 1:depth + for i in 1:L-1 + push!(circuit, CNOTGate((i, i+1))) + push!(circuit, CRxGate((i, i+1), randn(), isparas=true)) + push!(circuit, CNOTGate((i, i+1))) + n += 1 + end + end + return circuit, n +end + +"""""" + circuit gradient with dot loss function +"""""" +function crx_circuit_grad_dot_real(L::Int, depth::Int) + target_state = rand_state(ComplexF64, L) + initial_state = StateVector(ComplexF64, L) + circuit, n = crx_circuit(L, depth) + + loss(x) = real(dot(target_state, x * initial_state)) + loss_fd(θs) = begin + reset_parameters!(circuit, θs) + return loss(circuit) + end + + grad1 = gradient(loss, circuit)[1] + grad2 = fdm_gradient(loss_fd, active_parameters(circuit)) + + return nparameters(circuit)==n && maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + + +function gfsim1_circuit(L::Int, depth::Int) + circuit = QCircuit() + for i in 1:L + push!(circuit, HGate(i)) + end + for d in 1:depth + for i in 1:L-1 + push!(circuit, CNOTGate((i, i+1))) + push!(circuit, FSIMGate((i, i+1), randn(5), isparas=[true, false, false, false, false])) + push!(circuit, CNOTGate((i, i+1))) + end + end + return circuit +end + +function gfsim2_circuit(L::Int, depth::Int) + circuit = QCircuit() + for i in 1:L + push!(circuit, HGate(i)) + end + for d in 1:depth + for i in 1:L-1 + push!(circuit, CNOTGate((i, i+1))) + push!(circuit, FSIMGate((i, i+1), randn(5), isparas=[true, true, false, false, false])) + push!(circuit, CNOTGate((i, i+1))) + end + end + return circuit +end + +function gfsim5_circuit(L::Int, depth::Int) + circuit = QCircuit() + for i in 1:L + push!(circuit, HGate(i)) + end + for d in 1:depth + for i in 1:L-1 + push!(circuit, CNOTGate((i, i+1))) + push!(circuit, FSIMGate((i, i+1), randn(5), isparas=[true, true, true, true, true])) + push!(circuit, CNOTGate((i, i+1))) + end + end + return circuit +end + +function bf_circuit_gfims1_grad_dot_abs(L::Int, depth::Int) + target_state = rand_state(ComplexF64, L) + initial_state = StateVector(ComplexF64, L) + circuit = gfsim1_circuit(L, depth) + + loss(x) = abs(dot(target_state, x * initial_state)) + loss_fd(θs) = begin + reset_parameters!(circuit, θs) + return loss(circuit) + end + + grad1 = gradient(loss, circuit)[1] + grad2 = fdm_gradient(loss_fd, active_parameters(circuit)) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + +function bf_circuit_gfims2_grad_dot_abs(L::Int, depth::Int) + target_state = rand_state(ComplexF64, L) + initial_state = StateVector(ComplexF64, L) + circuit = gfsim2_circuit(L, depth) + + loss(x) = abs(dot(target_state, x * initial_state)) + loss_fd(θs) = begin + reset_parameters!(circuit, θs) + return loss(circuit) + end + + grad1 = gradient(loss, circuit)[1] + grad2 = fdm_gradient(loss_fd, active_parameters(circuit)) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + +function bf_circuit_gfims5_grad_dot_abs(L::Int, depth::Int) + target_state = rand_state(ComplexF64, L) + initial_state = StateVector(ComplexF64, L) + circuit = gfsim5_circuit(L, depth) + + loss(x) = abs(dot(target_state, x * initial_state)) + loss_fd(θs) = begin + reset_parameters!(circuit, θs) + return loss(circuit) + end + + grad1 = gradient(loss, circuit)[1] + grad2 = fdm_gradient(loss_fd, active_parameters(circuit)) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + + +@testset ""gradient of variable quantum circuit with parameterized controled rotational gate"" begin + for L in 2:5 + for depth in 1:5 + @test crx_circuit_grad_dot_real(L, depth) + end + end +end + +@testset ""gradient of brute force quantum circuit with FSIM gate"" begin + for L in 2:5 + for depth in 1:3 + @test bf_circuit_gfims1_grad_dot_abs(L, depth) + @test bf_circuit_gfims2_grad_dot_abs(L, depth) + @test bf_circuit_gfims5_grad_dot_abs(L, depth) + end + end +end + +","Julia" +"Conjugate","guochu/VQC.jl","test/check_dm.jl",".jl","1038","61"," + + +function check_dm_expec_1() + psi = rand_state(ComplexF64, 7) + rho = DensityMatrix(psi) + + h = QubitsTerm(1=>""X"") + + a1 = expectation(h, psi) + a2 = expectation(h, rho) + + return abs(a1 - a2) < 1.0e-6 +end + +function check_dm_expec_2() + psi = rand_state(ComplexF64, 7) + rho = DensityMatrix(psi) + + h = QubitsTerm(1=>""X"", 2=>""+"") + + a1 = expectation(h, psi) + a2 = expectation(h, rho) + + return abs(a1 - a2) < 1.0e-6 +end + + +function check_dm_expec_3() + psi = rand_state(ComplexF64, 7) + rho = DensityMatrix(psi) + + h = QubitsTerm(1=>""X"", 2=>""+"", 4=>""-"") + + a1 = expectation(h, psi) + a2 = expectation(h, rho) + + return abs(a1 - a2) < 1.0e-6 +end + +function check_dm_expec_4() + psi = rand_state(ComplexF64, 8) + rho = DensityMatrix(psi) + + h = QubitsTerm(1=>""X"", 2=>""+"", 4=>""-"", 8=>""Z"") + + a1 = expectation(h, psi) + a2 = expectation(h, rho) + + return abs(a1 - a2) < 1.0e-6 +end + + +@testset ""check density matrix expectation value"" begin + @test check_dm_expec_1() + @test check_dm_expec_2() + @test check_dm_expec_3() + @test check_dm_expec_4() + +end +","Julia" +"Conjugate","guochu/VQC.jl","test/check_qubits_ham.jl",".jl","8612","265"," + +function check_qham_onebody_single(::Type{T}, L::Int, j::Int) where T + state1 = rand_state(T, L) + m = random_unitary(1) + gate1 = QuantumGate(j, m) + h = QubitsOperator(QubitsTerm(j=>m)) + state2 = h * state1 + apply!(gate1, state1) + return maximum(abs.(storage(state1 - state2)) ) +end + +function check_qham_onebody(::Type{T}, L::Int) where {T<:Number} + errs = [] + for c in 1:L + push!(errs, check_qham_onebody_single(T, L, c)) + end + # println(""total number of tests $(length(errs))."") + return all(errs .< 1.0e-6) +end + +function check_qham_twobody_single(::Type{T}, L::Int, j::Int, k::Int) where T + state1 = rand_state(T, L) + m1 = random_unitary(1) + m2 = random_unitary(1) + gate1 = QuantumGate((j, k), kron(m1, m2)) + h = QubitsOperator(QubitsTerm(j=>m2, k=>m1)) + state2 = h * state1 + apply!(gate1, state1) + return maximum(abs.(storage(state1 - state2)) ) +end + +function check_qham_twobody(::Type{T}, L::Int) where {T<:Number} + errs = [] + for c in 1:2:L + for t in 2:2:L + if c != t + push!(errs, check_qham_twobody_single(T, L, c, t)) + end + end + end + # println(""total number of tests $(length(errs))."") + return all(errs .< 1.0e-6) +end + +function check_qham_threebody_single(::Type{T}, L::Int, a::Int, b::Int, c::Int) where {T<:Number} + state1 = rand_state(T, L) + m1 = random_unitary(1) + m2 = random_unitary(1) + m3 = random_unitary(1) + gate1 = QuantumGate((a, b, c), kron(m1, m2, m3)) + h = QubitsOperator(QubitsTerm(a=>m3, b=>m2, c=>m1)) + state2 = h * state1 + apply!(gate1, state1) + return maximum(abs.(storage(state1 - state2)) ) +end + +function check_qham_threebody(::Type{T}, L::Int) where {T<:Number} + errs = [] + for a in 1:2:L + for b in 2:3:L + for c in 3:5:L + if a != b && a != c && b != c + push!(errs, check_qham_threebody_single(T, L, a, b, c)) + end + end + end + end + # println(""total number of tests $(length(errs))."") + return all(errs .< 1.0e-6) +end + +function check_term_matrix(L::Int) + state = rand_state(ComplexF64, L) + m = QubitsTerm(1=>""+"", L-1=>""-"", coeff=0.77) + return maximum(abs.(storage(m * state - matrix(L, m) * state))) < 1.0e-6 +end + +function check_ham_matrix(L::Int) + state = rand_state(ComplexF64, L) + m = QubitsTerm(1=>""+"", L-1=>""-"", coeff=0.77) + QubitsTerm(1=>""-"", L-1=>""+"", coeff=0.77) + QubitsTerm(1=>""X"", L=>""Y"", coeff=0.36) + return maximum(abs.(storage(m * state - matrix(L, m) * state))) < 1.0e-6 +end + +function check_term_expec(L::Int) + state = rand_state(ComplexF64, L) + m = QubitsTerm(1=>""+"", L-1=>""-"", coeff=0.77) + return abs(expectation(m, state) - expectation(matrix(L, m), state)) < 1.0e-6 +end + +function check_ham_expec(L::Int) + state = rand_state(ComplexF64, L) + m = QubitsTerm(1=>""+"", 2=>""-"", coeff=0.77) + QubitsTerm(1=>""-"", 2=>""+"", coeff=0.77) + QubitsTerm(1=>""X"", L-1=>""Y"", coeff=0.36) + return abs(expectation(m, state) - expectation(matrix(L, m), state)) < 1.0e-6 +end + +function check_ham_expec_long(L::Int, n::Int) + state = rand_state(ComplexF64, L) + m = QubitsTerm(Dict(i=>""X"" for i in 1:n), coeff=0.77) + QubitsTerm(1=>""X"", coeff=1.2) + QubitsTerm(1=>""X"", 2=>""Z"", coeff=0.3) + return abs(expectation(m, state) - expectation(matrix(L, m), state)) < 1.0e-6 +end + +function check_expec_onebody_single(::Type{T}, L::Int, j::Int) where T + state = rand_state(T, L) + m = QubitsTerm(j=>random_unitary(1)) + + return abs(expectation(m, state) - expectation(matrix(L, m), state)) +end + +function check_expec_onebody(::Type{T}, L::Int) where {T<:Number} + errs = [] + for c in 1:L + push!(errs, check_expec_onebody_single(T, L, c)) + end + return all(errs .< 1.0e-6) +end + +function check_expec_twobody_single(::Type{T}, L::Int, j::Int, k::Int) where T + state = rand_state(T, L) + m = QubitsTerm(j=>random_unitary(1), k=>random_unitary(1), coeff=0.73) + + return abs(expectation(m, state) - expectation(matrix(L, m), state)) +end + +function check_expec_twobody(::Type{T}, L::Int) where {T<:Number} + errs = [] + for c in 1:2:L + for t in 2:2:L + if c != t + push!(errs, check_expec_twobody_single(T, L, c, t)) + end + end + end + # println(""total number of tests $(length(errs))."") + return all(errs .< 1.0e-6) +end + +function check_expec_threebody_single(::Type{T}, L::Int, j::Int, k::Int, l::Int) where T + state = rand_state(T, L) + m = QubitsTerm(j=>random_unitary(1), k=>random_unitary(1), l=>random_unitary(1), coeff=0.9) + + return abs(expectation(m, state) - expectation(matrix(L, m), state)) +end + +function check_expec_threebody(::Type{T}, L::Int) where {T<:Number} + errs = [] + for a in 1:L + for b in 1:L + for c in 1:L + if a != b && a != c && b != c + push!(errs, check_expec_threebody_single(T, L, a, b, c)) + end + end + end + end + # println(""total number of tests $(length(errs))."") + return all(errs .< 1.0e-6) +end + +function check_expec_onebody_single_2(::Type{T}, L::Int, j::Int) where T + state1 = rand_state(T, L) + state2 = rand_state(T, L) + m = QubitsTerm(j=>random_unitary(1)) + + return abs(expectation(state2, m, state1) - expectation(state2, matrix(L, m), state1)) +end + +function check_expec_onebody_2(::Type{T}, L::Int) where {T<:Number} + errs = [] + for c in 1:L + push!(errs, check_expec_onebody_single_2(T, L, c)) + end + return all(errs .< 1.0e-6) +end + +function check_expec_twobody_single_2(::Type{T}, L::Int, j::Int, k::Int) where T + state1 = rand_state(T, L) + state2 = rand_state(T, L) + m = QubitsTerm(j=>random_unitary(1), k=>random_unitary(1), coeff=0.73) + + return abs(expectation(state2, m, state1) - expectation(state2, matrix(L, m), state1)) +end + +function check_expec_twobody_2(::Type{T}, L::Int) where {T<:Number} + errs = [] + for c in 1:2:L + for t in 2:2:L + if c != t + push!(errs, check_expec_twobody_single_2(T, L, c, t)) + end + end + end + # println(""total number of tests $(length(errs))."") + return all(errs .< 1.0e-6) +end + +function check_expec_threebody_single_2(::Type{T}, L::Int, j::Int, k::Int, l::Int) where T + state1 = rand_state(T, L) + state2 = rand_state(T, L) + m = QubitsTerm(j=>random_unitary(1), k=>random_unitary(1), l=>random_unitary(1), coeff=0.9) + + return abs(expectation(state2, m, state1) - expectation(state2, matrix(L, m), state1)) +end + +function check_expec_threebody_2(::Type{T}, L::Int) where {T<:Number} + errs = [] + for a in 1:L + for b in 1:L + for c in 1:L + if a != b && a != c && b != c + push!(errs, check_expec_threebody_single_2(T, L, a, b, c)) + end + end + end + end + # println(""total number of tests $(length(errs))."") + return all(errs .< 1.0e-6) +end + +@testset ""check hamiltonion term expectation value"" begin + @test check_term_matrix(16) + @test check_term_matrix(15) + @test check_ham_matrix(6) + @test check_ham_matrix(3) + @test check_term_expec(16) + @test check_term_expec(15) + @test check_ham_expec(6) + @test check_ham_expec(3) + @test check_ham_expec_long(6, 5) + @test check_ham_expec_long(6, 6) + @test check_ham_expec_long(8, 8) +end + +@testset ""check generic hamiltonion term operations"" begin + @test check_qham_onebody(ComplexF32, 16) + @test check_qham_onebody(ComplexF64, 15) + for L in 5:10:15 + @test check_qham_twobody(ComplexF32, L) + @test check_qham_twobody(ComplexF64, L) + end + @test check_qham_threebody(ComplexF32, 16) + @test check_qham_threebody(ComplexF64, 15) + + @test (check_qham_onebody_single(ComplexF64, 2,2) < 1.0e-6) + @test (check_qham_onebody_single(ComplexF64, 4,2) < 1.0e-6) + @test (check_qham_twobody_single(ComplexF64, 2,2,1) < 1.0e-6) + @test (check_qham_twobody_single(ComplexF64, 3,1,3) < 1.0e-6) + @test (check_qham_threebody_single(ComplexF64, 3, 3,1,2) < 1.0e-6) + @test (check_qham_threebody_single(ComplexF64, 4, 3,4,1) < 1.0e-6) +end + + +@testset ""check generic hamiltonion expectation value"" begin + for L in 5:10:15 + @test check_expec_onebody(ComplexF64, L) + @test check_expec_twobody(ComplexF64, L) + @test check_expec_threebody(ComplexF64, L) + + @test check_expec_onebody_2(ComplexF64, L) + @test check_expec_twobody_2(ComplexF64, L) + @test check_expec_threebody_2(ComplexF64, L) + end +end + +","Julia" +"Conjugate","guochu/VQC.jl","test/circuitgrad.jl",".jl","3423","130"," + + +"""""" + circuit gradient with dot loss function +"""""" +function circuit_grad_dot_real(L::Int, depth::Int) + target_state = rand_state(ComplexF64, L) + initial_state = StateVector(ComplexF64, L) + circuit = variational_circuit_1d(L, depth) + + loss(x) = real(dot(target_state, x * initial_state)) + loss_fd(θs) = loss(variational_circuit_1d(L, depth, θs=θs)) + + grad1 = gradient(loss, circuit)[1] + grad2 = fdm_gradient(loss_fd, active_parameters(circuit)) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + + +"""""" + circuit gradient with dot loss function +"""""" +function circuit_grad_dot_imag(L::Int, depth::Int) + target_state = rand_state(ComplexF64, L) + initial_state = StateVector(ComplexF64, L) + circuit = variational_circuit_1d(L, depth) + + loss(x) = imag(dot(target_state, x * initial_state)) + loss_fd(θs) = loss(variational_circuit_1d(L, depth, θs=θs)) + + grad1 = gradient(loss, circuit)[1] + grad2 = fdm_gradient(loss_fd, active_parameters(circuit)) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + +"""""" + circuit gradient with dot loss function +"""""" +function circuit_grad_dot_abs(L::Int, depth::Int) + target_state = rand_state(ComplexF64, L) + initial_state = StateVector(ComplexF64, L) + circuit = variational_circuit_1d(L, depth) + + loss(x) = abs(dot(target_state, x * initial_state)) + loss_fd(θs) = loss(variational_circuit_1d(L, depth, θs=θs)) + + grad1 = gradient(loss, circuit)[1] + grad2 = fdm_gradient(loss_fd, active_parameters(circuit)) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + +"""""" + circuit gradient with dot loss function +"""""" +function circuit_grad_dot_abs2(L::Int, depth::Int) + target_state = rand_state(ComplexF64, L) + initial_state = StateVector(ComplexF64, L) + circuit = variational_circuit_1d(L, depth) + + loss(x) = abs2(dot(target_state, x * initial_state)) + loss_fd(θs) = loss(variational_circuit_1d(L, depth, θs=θs)) + + grad1 = gradient(loss, circuit)[1] + grad2 = fdm_gradient(loss_fd, active_parameters(circuit)) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + + +"""""" + circuit gradient with distance loss function +"""""" +function circuit_grad_distance(L::Int, depth::Int) + target_state = rand_state(ComplexF64, L) + initial_state = StateVector(ComplexF64, L) + circuit = variational_circuit_1d(L, depth) + + loss(x) = distance(target_state, x * initial_state) + loss_fd(θs) = loss(variational_circuit_1d(L, depth, θs=θs)) + + grad1 = gradient(loss, circuit)[1] + grad2 = fdm_gradient(loss_fd, active_parameters(circuit)) + return maximum(abs.(grad1 - grad2)) < 1.0e-6 +end + + +@testset ""gradient of quantum circuit with loss function real(dot(x, circuit*y))"" begin + for L in 2:5 + for depth in 0:5 + @test circuit_grad_dot_real(L, depth) + end + end +end + +@testset ""gradient of quantum circuit with loss function imag(dot(x, circuit*y))"" begin + for L in 2:5 + for depth in 0:5 + @test circuit_grad_dot_imag(L, depth) + end + end +end + +@testset ""gradient of quantum circuit with loss function abs(dot(x, circuit*y))"" begin + for L in 2:5 + for depth in 0:5 + @test circuit_grad_dot_abs(L, depth) + end + end +end + + +@testset ""gradient of quantum circuit with loss function abs2(dot(x, circuit*y))"" begin + for L in 2:5 + for depth in 0:5 + @test circuit_grad_dot_abs2(L, depth) + end + end +end + + +@testset ""gradient of quantum circuit with loss function distance(x, circuit*y)"" begin + for L in 2:5 + for depth in 0:5 + @test circuit_grad_distance(L, depth) + end + end +end + + +","Julia" +"Conjugate","guochu/VQC.jl","docs/make.jl",".jl","294","17","push!(LOAD_PATH, ""../src"") + +using Documenter +using VQC + +makedocs( + sitename=""VQC.jl"", + authors = ""Guo Chu"", + pages=[""Home"" => ""index.md"", + ""gettingstarted.md"", + ""variational.md"", + ""ham.md"", + ""qctrl.md""], + format = Documenter.HTML( + prettyurls = get(ENV, ""CI"", nothing) == ""true"" + ) + )","Julia" +"Conjugate","guochu/VQC.jl","docs/src/variational.md",".md","2007","80","# Variational Quantum Circuit + +In this section we will provide a simple pipeline to demonstrate how to +use VQC to build variational quantum circuits + + +## Creating a variational quantum circuit +```@example +push!(LOAD_PATH, ""../../src"") +using VQC +L = 3 +depth = 2 +circuit = QCircuit() +for i in 1:L + push!(circuit, RzGate(i, Variable(rand()))) + push!(circuit, RyGate(i, Variable(rand()))) + push!(circuit, RzGate(i, Variable(rand()))) +end +for l in 1:depth + for i in 1:L-1 + push!(circuit, CNOTGate((i, i+1))) + end + for i in 1:L + push!(circuit, RzGate(i, Variable(rand()))) + push!(circuit, RyGate(i, Variable(rand()))) + push!(circuit, RzGate(i, Variable(rand()))) + end +end +# all the parameters of the circuit +paras = parameters(circuit) + +# reset all the parameters of the circuit +new_paras = zeros(length(paras)) +set_parameters!(new_paras, circuit) +paras = parameters(circuit) + +# compute the gradient +using Zygote +target_state = qrandn(L) +initial_state = qstate(L) +loss(c) = distance(target_state, c * initial_state) +grad = gradient(loss, circuit) +``` +The above definition has been predefined by the function variational_circuit +```@docs +variational_circuit(L::Int, depth::Int, g::Function=rand) +``` + +## A simple application of VQC and Flux +```@example +using VQC +using Zygote +using Flux.Optimise + +circuit = variational_circuit(3, 2) +target_state = (sqrt(2)/2) * (qstate([1,1,1]) + qstate([0,0,0])) +initial_state = qstate([0,0,0]) +loss(c) = distance(target_state, c * initial_state) + +opt = ADAM() +epoches = 10 +x0 = parameters(circuit) +for i in 1:epoches + grad = collect_variables(gradient(loss, circuit)) + Optimise.update!(opt, x0, grad) + set_parameters!(x0, circuit) + println(""loss value at $i-th iteration is $(loss(circuit))."") +end +``` + +## Some utility functions +```@docs +collect_variables(args...) +parameters(args...) +set_parameters!(coeff::AbstractVector{<:Number}, args...) +simple_gradient(f, args...; dt::Real=1.0e-6) +check_gradient(f, args...; dt::Real=1.0e-6, atol::Real=1.0e-4, verbose::Int=0) +``` + +","Markdown" +"Conjugate","guochu/VQC.jl","docs/src/qctrl.md",".md","645","35","# Quantum Control + + + +VQC support variational hamiltonian evolutions. + +```@docs +ctrlham(a::AbstractMatrix, b::Vector{<:AbstractMatrix}, nparas::Int) +``` + +The variational hamiltonian object can be used in the same way as a variational quantum circuit +```@example +push!(LOAD_PATH, ""../../src"") +using VQC +using Zygote + +random_hermitian(n) = begin + a = randn(n, n) + return a + a' +end + +H0 = random_hermitian(2) +H1 = [random_hermitian(2) for i in 1:2] +h = ctrlham(H0, H1, 5) + +initial_state = [1, 0] +target_state = randn(2) + +loss(c) = distance(target_state, c * initial_state) + +grad = gradient(loss, h) + +# Check the gradient +check_gradient(loss, h) +```","Markdown" +"Conjugate","guochu/VQC.jl","docs/src/index.md",".md","1780","87"," + +Variational quantum circuit simulator in julia + +# VQC.jl's documentation + +VQC is a julia library for variational quantum circuit simulations. VQC +aims to supprot automatic differentiation and allow users to easily build +hybrid quantum-classical algorithms. Current VQC also has a basic support +for variational Hamiltonian simulation. + +A simple code snippet to create a two-qubit bell state +```@example +push!(LOAD_PATH, ""../../src"") +using VQC + +state = qstate(2) +circuit = QCircuit() +push!(circuit, (1, H)) +push!(circuit, ((1, 2), CNOT)) + +apply!(circuit, state) +amplitudes(state) + +# Perform quantum measurement +i, prob = measure!(state, 1) +println(""probability of the 1-th qubit in state $i is $prob."") + +# Obtain a particular amplitude +p = amplitude(state, [0, 1]) +``` + +Build a variational quantum circuit is as simple as a normal quantum state +```@example +using VQC +using Zygote +L = 3 +state = qstate(L) +circuit = QCircuit() +for i in 1:L + push!(circuit, RzGate(i, Variable(rand()))) + push!(circuit, RyGate(i, Variable(rand()))) + push!(circuit, RzGate(i, Variable(rand()))) +end + +for depth in 1:2 + for i in 1:L-1 + push!(circuit, CNOTGate((i, i+1))) + end + for i in 1:L + push!(circuit, RzGate(i, Variable(rand()))) + push!(circuit, RxGate(i, Variable(rand()))) + push!(circuit, RzGate(i, Variable(rand()))) + end +end + +# Create a random quantum state of 3 qubits +target_state = qrandn(L) +loss(c) = distance(target_state, c * state) +v = loss(circuit) +grad = gradient(loss, circuit) +check_gradient(loss, circuit) +``` + + +Start to use Meteor.jl from ""Getting Started"" section. + +```@contents +Pages = [""gettingstarted.md""] +Depth = 2 +``` + +```@contents +Pages = [""variational.md""] +Depth = 2 +``` + +```@contents +Pages = [""ham.md""] +Depth = 2 +``` + +```@contents +Pages = [""qctrl.md""] +Depth = 2 +``` +","Markdown" +"Conjugate","guochu/VQC.jl","docs/src/ham.md",".md","683","30","# Hamiltonian + + +VQC also has preliminary suport for hamiltonian evolution. + +## A simple hamiltonian simulation +```@example +push!(LOAD_PATH, ""../../src"") +using VQC +ps = spin_half() +pb = boson(d=4) +ham = Hamiltonian([ps, pb]) + +add!(ham, (1,2), (""sp"", ""a""), coeff=1) +add!(ham, (1,2), (""sm"", ""adag""), coeff=1) +add!(ham, (1,), (""sz"",), coeff=0.5) +add!(ham, (2,), (""n"",), coeff=2) + +state = kron(spin_half_state(0), fock_state(4, 2)) + +# unitary evolution +state = apply(ham, 0.5, state) + +# Create an observer +observer = Observers(ham) +add!(observer, (1,), (""sz"",), name=""z"") +add!(observer, (2,), (""n"",), name=""n"") +add!(observer, (1,2), (""sp"", ""a""), name=""j"") +obs = apply(observer, state) +```","Markdown" +"Conjugate","guochu/VQC.jl","docs/src/gettingstarted.md",".md","2585","109","# Getting Started + +In this section we will provide a simple pipeline to demonstrate how to +use VQC to build quantum computing applications + + +Pipeline for quantum circuit simulation + +## Initialize a quantum state +Definition of function qstate +```@docs +qstate(::Type{T}, thetas::AbstractVector{<:Real}) where {T <: Number} +qstate(thetas::AbstractVector{<:Real}) +qstate(::Type{T}, n::Int) where {T <: Number} +qstate(n::Int) +``` +Extract amplitudes from quantum state +```@docs +amplitude(s::AbstractVector, i::AbstractVector{Int}) +amplitudes(s::AbstractVector) +``` + + +Examples +```@example +push!(LOAD_PATH, ""../../src"") +using VQC +state = qstate(2) +state = qstate([1, 0]) +state = qstate([0.5, 0.7]) +``` + + +## Quantum gate +Predefined elementary gates ""X, Y, Z, S, H, sqrtX, sqrtY, T, Rx, Ry, Rz, CONTROL, CZ, CNOT, CX, SWAP, iSWAP, XGate, YGate, ZGate, HGate, SGate, TGate, SqrtXGate, SqrtYGate, RxGate, RyGate, RzGate, CZGate, CNOTGate, SWAPGate, iSWAPGate, CRxGate, CRyGate, CRzGate, TOFFOLIGate"" + +```@example +using VQC + +circuit = QCircuit() + +# standard one-qubit gate +push!(circuit, (1, H)) +empty!(circuit) +push!(circuit, HGate(1)) +empty!(circuit) +push!(circuit, gate(1, H)) +empty!(circuit) +# standard two-qubit gate +push!(circuit, ((1, 2), CZ)) +empty!(circuit) +push!(circuit, CZGate((1, 2))) +empty!(circuit) +push!(circuit, gate((1,2), CZ)) +empty!(circuit) +# a parameteric one-qubit gate +push!(circuit, RxGate(1, Variable(0.5))) +empty!(circuit) +# a parameteric two-qubit gate +push!(circuit, CRxGate((1,2), Variable(0.5))) +empty!(circuit) +# This will create a non-parameteric gate instead +push!(circuit, RxGate(1, 0.5)) +``` + +## Quantum circuit +Adding new gates +```@docs +add!(x::AbstractCircuit, s) +Base.push!(x::AbstractCircuit, s::AbstractGate) +Base.append!(x::AbstractCircuit, y::AbstractCircuit) +Base.append!(x::AbstractCircuit, y::Vector{T}) where {T<:AbstractGate} +``` + +Circuit manipulations +```@example +using VQC +circuit = QCircuit() +push!(circuit, (1, H)) +push!(circuit, ((1, 2), CZ)) +c1 = transpose(circuit) +c2 = conj(circuit) +c3 = circuit' +``` + +## Apply quantum circuit to state +```@docs +apply!(circuit::AbstractCircuit, v::Vector) +*(circuit::AbstractCircuit, v::AbstractVector) +*(v::AbstractVector, circuit::AbstractCircuit) +``` + +## Quantum measurement +Measure and collapse a quantum state +```@docs +measure(qstate::AbstractVector, pos::Int) +measure!(qstate::AbstractVector, pos::Int; auto_reset::Bool=true) +``` + +Postselection +```@docs +post_select!(qstate::AbstractVector, key::Int, state::Int=0) +post_select(qstate::AbstractVector, key::Int, state::Int=0; keep::Bool=false) +``` + + + + +","Markdown"