def test_bellpair() -> None:
state = QuantumState(2)
circ = Circuit(2).H(0).CX(0, 1)
qulacs_circ = tk_to_qulacs(circ)
qulacs_circ.update_quantum_state(state)
state0 = QuantumState(2)
state0.set_computational_basis(0)
probability = inner_product(state0, state)**2
assert np.isclose(probability, 0.5)
state1 = QuantumState(2)
state1.set_computational_basis(1)
probability = inner_product(state1, state)**2
assert np.isclose(probability, 0)
state2 = QuantumState(2)
state2.set_computational_basis(2)
probability = inner_product(state2, state)**2
assert np.isclose(probability, 0)
state3 = QuantumState(2)
state3.set_computational_basis(3)
probability = inner_product(state3, state)**2
assert np.isclose(probability, 0.5)
def S2Proj(Quket, Q, threshold=1e-8):
"""Function
Perform spin-projection to QuantumState |Q>
|Q'> = Ps |Q>
where Ps is a spin-projection operator (non-unitary).
Ps = \sum_i^ng wg[i] Ug[i]
This function provides a shortcut to |Q'>, which is unreal.
One actually needs to develop a quantum circuit for this
(See PRR 2, 043142 (2020)).
Author(s): Takashi Tsuchimochi
"""
spin = Quket.projection.spin
s = (spin - 1) / 2
Ms = Quket.projection.Ms / 2
n_qubits = Q.get_qubit_count()
state_P = QuantumState(n_qubits)
state_P.multiply_coef(0)
nalpha = max(Quket.projection.euler_ngrids[0], 1)
nbeta = max(Quket.projection.euler_ngrids[1], 1)
ngamma = max(Quket.projection.euler_ngrids[2], 1)
for ialpha in range(nalpha):
alpha = Quket.projection.sp_angle[0][ialpha]
alpha_coef = Quket.projection.sp_weight[0][ialpha] * np.exp(
1j * alpha * Ms)
for ibeta in range(nbeta):
beta = Quket.projection.sp_angle[1][ibeta]
beta_coef = (Quket.projection.sp_weight[1][ibeta] *
Quket.projection.dmm[ibeta])
for igamma in range(ngamma):
gamma = Quket.projection.sp_angle[2][igamma]
gamma_coef = (Quket.projection.sp_weight[2][igamma] *
np.exp(1j * gamma * Ms))
# Total Weight
coef = (2 * s + 1) / (8 * np.pi) * (alpha_coef * beta_coef *
gamma_coef)
state_g = QuantumState(n_qubits)
state_g.load(Q)
circuit_Rg = QuantumCircuit(n_qubits)
set_circuit_Rg(circuit_Rg, n_qubits, alpha, beta, gamma)
circuit_Rg.update_quantum_state(state_g)
state_g.multiply_coef(coef)
state_P.add_state(state_g)
# Normalize
norm2 = state_P.get_squared_norm()
if norm2 < threshold:
error(
"Norm of spin-projected state is too small!\n",
"This usually means the broken-symmetry state has NO component ",
"of the target spin.")
state_P.normalize(norm2)
# print_state(state_P,name="P|Q>",threshold=1e-6)
return state_P
def test_H() -> None:
state = QuantumState(1)
state.set_zero_state()
circ = Circuit(1).H(0)
qulacs_circ = tk_to_qulacs(circ)
qulacs_circ.update_quantum_state(state)
state0 = QuantumState(1)
state0.set_computational_basis(0)
probability = inner_product(state0, state)**2
assert np.isclose(probability, 0.5)
def main():
import numpy as np
n_qubit = 2
obs = Observable(n_qubit)
initial_state = QuantumState(n_qubit)
obs.add_operator(1, "Z 0 Z 1")
circuit_list = []
p_list = [0.02, 0.04, 0.06, 0.08]
#prepare circuit list
for p in p_list:
circuit = QuantumCircuit(n_qubit)
circuit.add_H_gate(0)
circuit.add_RY_gate(1, np.pi / 6)
circuit.add_CNOT_gate(0, 1)
circuit.add_gate(
Probabilistic([p / 4, p / 4, p / 4],
[X(0), Y(0), Z(0)])) #depolarizing noise
circuit.add_gate(
Probabilistic([p / 4, p / 4, p / 4],
[X(1), Y(1), Z(1)])) #depolarizing noise
circuit_list.append(circuit)
#get mitigated output
mitigated, non_mitigated_array, fit_coefs = error_mitigation_extrapolate_linear(
circuit_list,
p_list,
initial_state,
obs,
n_circuit_sample=100000,
return_full=True)
#plot the result
p = np.linspace(0, max(p_list), 100)
plt.plot(p,
fit_coefs[0] * p + fit_coefs[1],
linestyle="--",
label="linear fit")
plt.scatter(p_list, non_mitigated_array, label="un-mitigated")
plt.scatter(0, mitigated, label="mitigated output")
#prepare the clean result
state = QuantumState(n_qubit)
circuit = QuantumCircuit(n_qubit)
circuit.add_H_gate(0)
circuit.add_RY_gate(1, np.pi / 6)
circuit.add_CNOT_gate(0, 1)
circuit.update_quantum_state(state)
plt.scatter(0, obs.get_expectation_value(state), label="True output")
plt.xlabel("error rate")
plt.ylabel("expectation value")
plt.legend()
plt.show()
def test_circuit_add_gate(self):
from qulacs import QuantumCircuit, QuantumState
from qulacs.gate import Identity, X, Y, Z, H, S, Sdag, T, Tdag, sqrtX, sqrtXdag, sqrtY, sqrtYdag
from qulacs.gate import P0, P1, U1, U2, U3, RX, RY, RZ, CNOT, CZ, SWAP, TOFFOLI, FREDKIN, Pauli, PauliRotation
from qulacs.gate import DenseMatrix, SparseMatrix, DiagonalMatrix, RandomUnitary, ReversibleBoolean, StateReflection
from qulacs.gate import BitFlipNoise, DephasingNoise, IndependentXZNoise, DepolarizingNoise, TwoQubitDepolarizingNoise, AmplitudeDampingNoise, Measurement
from qulacs.gate import merge, add, to_matrix_gate, Probabilistic, CPTP, Instrument, Adaptive
from scipy.sparse import lil_matrix
qc = QuantumCircuit(3)
qs = QuantumState(3)
ref = QuantumState(3)
sparse_mat = lil_matrix((4, 4))
sparse_mat[0, 0] = 1
sparse_mat[1, 1] = 1
def func(v, d):
return (v + 1) % d
def adap(v):
return True
gates = [
Identity(0), X(0), Y(0), Z(0), H(0), S(0), Sdag(0), T(0), Tdag(0), sqrtX(0), sqrtXdag(0), sqrtY(0), sqrtYdag(0),
Probabilistic([0.5, 0.5], [X(0), Y(0)]), CPTP([P0(0), P1(0)]), Instrument([P0(0), P1(0)], 1), Adaptive(X(0), adap),
CNOT(0, 1), CZ(0, 1), SWAP(0, 1), TOFFOLI(0, 1, 2), FREDKIN(0, 1, 2), Pauli([0, 1], [1, 2]), PauliRotation([0, 1], [1, 2], 0.1),
DenseMatrix(0, np.eye(2)), DenseMatrix([0, 1], np.eye(4)), SparseMatrix([0, 1], sparse_mat),
DiagonalMatrix([0, 1], np.ones(4)), RandomUnitary([0, 1]), ReversibleBoolean([0, 1], func), StateReflection(ref),
BitFlipNoise(0, 0.1), DephasingNoise(0, 0.1), IndependentXZNoise(0, 0.1), DepolarizingNoise(0, 0.1), TwoQubitDepolarizingNoise(0, 1, 0.1),
AmplitudeDampingNoise(0, 0.1), Measurement(0, 1), merge(X(0), Y(1)), add(X(0), Y(1)), to_matrix_gate(X(0)),
P0(0), P1(0), U1(0, 0.), U2(0, 0., 0.), U3(0, 0., 0., 0.), RX(0, 0.), RY(0, 0.), RZ(0, 0.),
]
gates.append(merge(gates[0], gates[1]))
gates.append(add(gates[0], gates[1]))
ref = None
for gate in gates:
qc.add_gate(gate)
for gate in gates:
qc.add_gate(gate)
qc.update_quantum_state(qs)
qc = None
qs = None
for gate in gates:
gate = None
gates = None
parametric_gates = None
def create_sa_state(n_qubits,
n_electrons,
noa,
nob,
nva,
nvb,
rho,
DS,
kappa_list,
theta_list,
occ_list,
vir_list,
threshold=1e-4):
"""Function
Create a spin-free Jeziorski-Monkhorst UCC state based on theta_list.
Author(s): Yuto Mori
"""
from .hflib import set_circuit_rhf, set_circuit_rohf, set_circuit_uhf
state = QuantumState(n_qubits)
if noa == nob:
circuit_rhf = set_circuit_rhf(n_qubits, n_electrons)
else:
circuit_rhf = set_circuit_rohf(n_qubits, noa, nob)
circuit_rhf.update_quantum_state(state)
theta_list_rho = theta_list / rho
circuit = set_circuit_sauccsdX(n_qubits, noa, nob, nva, nvb, DS,
theta_list_rho, occ_list, vir_list)
if np.linalg.norm(kappa_list) > threshold:
circuit_uhf = set_circuit_uhf(n_qubits, noa, nob, nva, nvb, kappa_list)
circuit_uhf.update_quantum_state(state)
for i in range(rho):
circuit.update_quantum_state(state)
return state
def sample_observable_noisy_circuit(circuit, initial_state, obs,
n_circuit_sample=1000,
n_sample_per_circuit=1):
"""
Args:
circuit (:class:`qulacs.QuantumCircuit`)
initial_state (:class:`qulacs.QuantumState`)
obs (:class:`qulacs.Observable`)
n_circuit_sample (:class:`int`): number of circuit samples
n_sample (:class:`int`): number of samples per one circuit samples
Return:
:float: sampled expectation value of the observable
Author(s): Unknown
"""
exp = 0
state = QuantumState(obs.get_qubit_count())
for _ in range(n_circuit_sample):
state.load(initial_state)
circuit.update_quantum_state(state)
exp += sample_observable(state, obs, n_sample_per_circuit)
exp /= n_circuit_sample
return exp
def create_uccsd_state(n_qubits,
rho,
DS,
theta_list,
det,
ndim1,
SpinProj=False):
"""Function
Prepare a UCC state based on theta_list.
The initial determinant 'det' contains the base-10 integer
specifying the bit string for occupied orbitals.
Author(s): Yuto Mori, Takashi Tsuchimochi
"""
from .init import get_occvir_lists
### Form RHF bits
state = QuantumState(n_qubits)
state.set_computational_basis(det)
occ_list, vir_list = get_occvir_lists(n_qubits, det)
theta_list_rho = theta_list / rho
circuit = set_circuit_uccsdX(n_qubits, DS, theta_list_rho, occ_list,
vir_list, ndim1)
for i in range(rho):
circuit.update_quantum_state(state)
if SpinProj:
from .phflib import S2Proj
state = S2Proj(Quket, state)
return state
def test_Toffoli(benchmark, nqubits):
benchmark.group = "Toffoli"
toffoli = DenseMatrix(0, [[0, 1], [1, 0]])
toffoli.add_control_qubit(1, 1)
toffoli.add_control_qubit(2, 1)
st = QuantumState(nqubits)
benchmark(toffoli.update_quantum_state, st)
def test_add_same_gate_multiple_time(self):
from qulacs import QuantumCircuit, QuantumState
from qulacs.gate import X, DepolarizingNoise, DephasingNoise, Probabilistic, RX
state = QuantumState(1)
circuit = QuantumCircuit(1)
noise = DepolarizingNoise(0, 0)
circuit.add_gate(noise)
circuit.add_gate(noise.copy())
circuit.add_gate(DephasingNoise(0, 0))
circuit.add_gate(Probabilistic([0.1], [RX(0, 0)]))
gate = RX(0, 0)
circuit.add_gate(gate)
circuit.add_gate(gate)
circuit.add_gate(gate)
circuit.add_gate(gate)
circuit.add_gate(gate)
del gate
circuit.update_quantum_state(state)
circuit.update_quantum_state(state)
circuit.update_quantum_state(state)
circuit.update_quantum_state(state)
circuit.update_quantum_state(state)
circuit.update_quantum_state(state)
circuit.update_quantum_state(state)
circuit.to_string()
del circuit
del state
def create_icmr_uccsd_state_spinfree(n_qubits,
v_n,
a_n,
c_n,
rho,
DS,
theta_list,
det,
ndim1,
act2act=False,
SpinProj=False):
"""
"""
state = QuantumState(n_qubits)
state.set_computational_basis(det)
theta_list_rho = theta_list / rho
circuit = set_circuit_ic_mrucc_spinfree(n_qubits, v_n, a_n, c_n, DS,
theta_list_rho, ndim1, act2act)
for i in range(rho):
circuit.update_quantum_state(state)
if SpinProj:
from .phflib import S2Proj
state_P = S2Proj(state)
return state_P
else:
return state
def suspend_test_phase_estimation_debug(self):
theta = 5*np.pi/16
n_qubits = 2
a_idx = 1
k = 2
circuit = QuantumCircuit(n_qubits)
psi = QuantumState(n_qubits) # |ancilla>|logical>
phi = 1.25/2
print('k={}, phi={} mod (np.pi)'.format(k, phi))
# Apply H to ancilla bit to get |+> state
circuit.add_H_gate(a_idx)
# Apply kickback phase rotation to ancilla bit
circuit.add_RZ_gate(a_idx, -np.pi * phi)
# Apply C-U(Z0)
theta_k = 2 ** (k-1) * theta
print('phase:{} mod (np.pi)'.format(theta_k/np.pi))
circuit.add_RZ_gate(0, -theta_k)
circuit.add_CNOT_gate(a_idx, 0)
circuit.add_RZ_gate(0, theta_k)
circuit.add_CNOT_gate(a_idx, 0)
# Apply H to ancilla bit to get |+> state
circuit.add_H_gate(a_idx)
# run circuit
circuit.update_quantum_state(psi)
print(psi.get_vector())
# partial trace
p0 = psi.get_marginal_probability([2, 0])
p1 = psi.get_marginal_probability([2, 1])
print(p0, p1)
def test_rotations() -> None:
# https://github.com/CQCL/pytket/issues/35
circ = Circuit(1).Rx(0.5, 0)
qulacs_circ = tk_to_qulacs(circ)
state = QuantumState(1)
qulacs_circ.update_quantum_state(state)
v = state.get_vector()
assert np.isclose(v[0], np.sqrt(0.5))
assert np.isclose(v[1], -1j * np.sqrt(0.5))
def test_ibm_gateset() -> None:
state = QuantumState(3)
state.set_zero_state()
circ = Circuit(3)
circ.add_gate(OpType.U1, 0.19, [0])
circ.add_gate(OpType.U2, [0.19, 0.24], [1])
circ.add_gate(OpType.U3, [0.19, 0.24, 0.32], [2])
qulacs_circ = tk_to_qulacs(circ)
qulacs_circ.update_quantum_state(state)
state1 = QuantumState(3)
state1.set_zero_state()
qulacs_circ1 = QuantumCircuit(3)
qulacs_circ1.add_U1_gate(0, 0.19 * np.pi)
qulacs_circ1.add_U2_gate(1, 0.19 * np.pi, 0.24 * np.pi)
qulacs_circ1.add_U3_gate(2, 0.19 * np.pi, 0.24 * np.pi, 0.32 * np.pi)
qulacs_circ1.update_quantum_state(state1)
overlap = inner_product(state1, state)
assert np.isclose(1, overlap)
def cost_upccgsd(Quket, print_level, kappa_list, theta_list, k):
"""Function:
Energy functional of UpCCGSD
Author(s): Takahiro Yoshikura
"""
t1 = time.time()
norbs = Quket.n_orbitals
n_qubits = Quket.n_qubits
det = Quket.det
ndim1 = Quket.ndim1
ndim2 = Quket.ndim2
ndim = Quket.ndim
state = QuantumState(n_qubits)
state.set_computational_basis(det)
if "epccgsd" in Quket.ansatz:
circuit = set_circuit_epccgsd(n_qubits, norbs, theta_list, ndim1,
ndim2, k)
else:
circuit = set_circuit_upccgsd(n_qubits, norbs, theta_list, ndim1,
ndim2, k)
circuit.update_quantum_state(state)
if Quket.projection.SpinProj:
from .phflib import S2Proj
state_P = S2Proj(Quket, state)
state = state_P.copy()
Eupccgsd = Quket.qulacs.Hamiltonian.get_expectation_value(state)
cost = Eupccgsd
### Project out the states contained in 'lower_states'
cost += orthogonal_constraint(Quket, state)
S2 = Quket.qulacs.S2.get_expectation_value(state)
t2 = time.time()
cpu1 = t2 - t1
if print_level == 1:
cput = t2 - cf.t_old
cf.t_old = t2
cf.icyc += 1
prints(f"{cf.icyc:5d}: "
f"E[{k}-UpCCGSD] = {Eupccgsd:.12f} <S**2> = {S2:17.15f} "
f"CPU Time = {cput:5.2f} ({cpu1:2.2f} / step)")
SaveTheta(ndim, theta_list, cf.tmp)
if print_level > 1:
prints(f"Final: "
f"E[{k}-UpCCGSD] = {Eupccgsd:.12f} <S**2> = {S2:17.15f}")
prints(f"\n({k}-UpCCGSD state)")
print_state(state, threshold=Quket.print_amp_thres)
# Store UpCCGSD wave function
Quket.state = state
return cost, S2
def visualize_probability(self):
state = QuantumState(self.G.n_qubit)
self.G.ansatz.update_quantum_state(state)
measured_list = [
list(map(int, list(format(x, f"0{self.G.n_qubit}b"))))
for x in range(2**self.G.n_qubit)
]
prob_list = []
for lis in measured_list:
prob_list.append(state.get_marginal_probability(lis))
plt.plot(range(2**self.G.n_qubit), prob_list)
def set_input_state(self, x_list):
"""List of input state"""
x_list_normalized = min_max_scaling(x_list) # x within [-1, 1]
st_list = []
for x in x_list_normalized:
st = QuantumState(self.nqubit)
input_gate = self.create_input_gate(x)
input_gate.update_quantum_state(st)
st_list.append(st.copy())
self.input_state_list = st_list
def set_input_state(self, x_list):
"""入力状態のリストを作成"""
x_list_normalized = min_max_scaling(x_list) # xを[-1, 1]の範囲にスケール
st_list = []
for x in x_list_normalized:
st = QuantumState(self.nqubit)
input_gate = self.create_input_gate(x)
input_gate.update_quantum_state(st)
st_list.append(st.copy())
self.input_state_list = st_list
def test_CU_Y0Y1(self):
n_qubits = 3
a_idx = 2
theta = np.pi/4
state = QuantumState(n_qubits)
input_states_bin = [0b001, 0b010, 0b101, 0b110]
input_states = []
output_states = []
circuit = QuantumCircuit(n_qubits)
# change basis from Z to Y
circuit.add_S_gate(0)
circuit.add_S_gate(1)
circuit.add_H_gate(0)
circuit.add_H_gate(1)
circuit.add_CNOT_gate(1, 0)
# RZ
circuit.add_RZ_gate(0, -0.5*theta)
circuit.add_CNOT_gate(a_idx, 0)
circuit.add_RZ_gate(0, 0.5*theta)
circuit.add_CNOT_gate(a_idx, 0)
circuit.add_CNOT_gate(1, 0)
# change basis from Z to Y
circuit.add_H_gate(0)
circuit.add_H_gate(1)
circuit.add_Sdag_gate(0)
circuit.add_Sdag_gate(1)
for b in input_states_bin:
psi = state.copy()
psi.set_computational_basis(b)
input_states += [psi]
psi_out = psi.copy()
circuit.update_quantum_state(psi_out)
output_states += [psi_out]
p_list = []
for in_state in input_states:
for out_state in output_states:
prod = inner_product(in_state, out_state)
p_list += [prod]
# |001>
exp_list = [1.0, 0.0, 0.0, 0.0]
# |010>
exp_list += [0.0, 1.0, 0.0, 0.0]
# |101>
exp_list += [0.0, 0.0, np.cos(theta/2), complex(0, -np.sin(theta/2))]
# |110>
exp_list += [0.0, 0.0, complex(0, -np.sin(theta/2)), np.cos(theta/2)]
for result, expected in zip(p_list, exp_list):
self.assertAlmostEqual(result, expected, places=6)
def NProj(Quket, Q, threshold=1e-8):
"""Function
Perform number-projection to QuantumState |Q>
|Q'> = PN |Q>
where PN is a number-projection operator (non-unitary).
PN = \sum_i^ng wg[i] Ug[i]
This function provides a shortcut to |Q'>, which is unreal.
One actually needs to develop a quantum circuit for this
(See QST 6, 014004 (2021)).
Author(s): Takashi Tsuchimochi
"""
n_qubits = Q.get_qubit_count()
state_P = QuantumState(n_qubits)
state_P.multiply_coef(0)
state_g = QuantumState(n_qubits)
nphi = max(Quket.projection.number_ngrids, 1)
#print_state(Q)
for iphi in range(nphi):
coef = (Quket.projection.np_weight[iphi] *
np.exp(1j * Quket.projection.np_angle[iphi] *
(Quket.projection.n_active_electrons -
Quket.projection.n_active_orbitals)))
state_g = Q.copy()
circuit = QuantumCircuit(n_qubits)
set_circuit_ExpNa(circuit, n_qubits, Quket.projection.np_angle[iphi])
set_circuit_ExpNb(circuit, n_qubits, Quket.projection.np_angle[iphi])
circuit.update_quantum_state(state_g)
state_g.multiply_coef(coef)
state_P.add_state(state_g)
norm2 = state_P.get_squared_norm()
if norm2 < threshold:
error(
"Norm of number-projected state is too small!\n",
"This usually means the broken-symmetry state has NO component ",
"of the target number.")
state_P.normalize(norm2)
return state_P
def cost_uhf(Quket, print_level, kappa_list):
"""Function:
Energy functional of UHF
Author(s): Takashi Tsuchimochi
"""
noa = Quket.noa
nob = Quket.nob
nva = Quket.nva
nvb = Quket.nvb
ndim1 = Quket.ndim1
# 全部の電子使う?
# n_electrons = Quket.n_active_electrons
n_electrons = Quket.n_electrons
n_qubit_system = Quket.n_qubits
t1 = time.time()
state = QuantumState(n_qubit_system)
if noa == nob:
circuit_rhf = set_circuit_rhf(n_qubit_system, n_electrons)
else:
circuit_rhf = set_circuit_rohf(n_qubit_system, noa, nob)
circuit_rhf.update_quantum_state(state)
circuit_uhf = set_circuit_uhf(n_qubit_system, noa, nob, nva, nvb,
kappa_list)
circuit_uhf.update_quantum_state(state)
Euhf = Quket.qulacs.Hamiltonian.get_expectation_value(state)
cost = Euhf
### Project out the states contained in 'lower_states'
cost += orthogonal_constraint(Quket, state)
S2 = Quket.qulacs.S2.get_expectation_value(state)
t2 = time.time()
cpu1 = t2 - t1
if print_level > 0:
cput = t2 - cf.t_old
cf.t_old = t2
cf.icyc += 1
prints(f"{cf.icyc:5d}: "
f"E[UHF] = {Euhf:.12f} "
f"<S**2> = {S2:17.15f} "
f"CPU Time = {cput:2.5f} ({cpu1:2.5f} / step)")
SaveTheta(ndim1, kappa_list, cf.tmp)
if print_level > 1:
prints("(UHF state)")
print_state(state, n_qubits=n_qubits)
# Store HF wave function
Quket.state = state
# 返すのはcostではない?
# return cost, S2
return Euhf, S2
def set_input_state(self, x_list, uin_type):
"""List of input state"""
x_list_normalized = min_max_scaling(x_list) # x within [-1, 1]
#x_list_normalized_0to2pi = min_max_scaling_0to2pi(x_list) # x within [0, 2pi]
#print('x_list_normalized_0to2pi=',x_list_normalized_0to2pi)
st_list = []
for x in x_list_normalized:
#for x in x_list_normalized_0to2pi:
st = QuantumState(self.nqubit)
input_gate = self.create_input_gate(x, uin_type)
input_gate.update_quantum_state(st)
st_list.append(st.copy())
self.input_state_list = st_list
def test_sparse_matrix(self):
from qulacs import QuantumState
from qulacs.gate import SparseMatrix
from scipy.sparse import lil_matrix
n = 5
state = QuantumState(n)
matrix = lil_matrix((4, 4), dtype=np.complex128)
matrix[0, 0] = 1 + 1.j
matrix[1, 1] = 1. + 1.j
gate = SparseMatrix([0, 1], matrix)
gate.update_quantum_state(state)
del gate
del state
def qcl_pred(x, U_out):
state = QuantumState(nqubit)
state.set_zero_state()
# Input state
U_in(x).update_quantum_state(state)
# Output state
U_out.update_quantum_state(state)
# Output from the model
res = obs.get_expectation_value(state)
return res
def cost_uhf_sample(Quket, print_level, qulacs_hamiltonian, qulacs_s2,
kappa_list, samplelist):
"""Function:
Sample Hamiltonian and S**2 expectation values with UHF.
Write out the statistics in csv files.
Author(s): Takashi Tsuchimochi
"""
noa = Quket.noa
nob = Quket.nob
nva = Quket.nva
nvb = Quket.nvb
n_electrons = Quket.n_electrons
n_qubit_system = n_qubits
n_qubits = Quket.n_qubits + 1
anc = n_qubit_system
ncyc = 13
opt = f"0{n_qubit_system}b"
prints("", filepath="./log.txt", opentype="w")
for i_sample in samplelist:
sampleEn = np.zeros((ncyc, 1))
sampleS2 = np.zeros((ncyc, 1))
for icyc in range(ncyc):
prints(f"n_sample = {i_sample} ({icyc:3d} / {ncyc})",
filepath="./log.txt")
state = QuantumState(n_qubit_system)
circuit_rhf = set_circuit_rhf(n_qubit_system, n_electrons)
circuit_rhf.update_quantum_state(state)
circuit = set_circuit_uhf(n_qubit_system, noa, nob, nva, nvb,
kappa_list)
circuit.update_quantum_state(state)
Euhf = sample_observable(state, qulacs_hamiltonian, i_sample).real
#S2 = sample_observable(state, qulacs_s2, i_sample).real
#Euhf = adaptive_sample_observable(state,
# qulacs_hamiltonian,
# i_sample).real
#S2 = adaptive_sample_observable(state, qulacs_s2, i_sample).real
sampleEn[icyc, 0] = Euhf
#sampleS2[icyc,0] = S2
S2 = 0
with open(f"./UEn_{i_sample}.csv", "w") as fEn:
writer = csv.writer(fEn)
writer.writerows(sampleEn)
#with open('./US2_%d.csv' % i_sample, 'w') as fS2:
# writer = csv.writer(fS2)
# writer.writerows(sampleS2)
return Euhf, S2
def __init__(self, wires, gpu=False, **kwargs):
super().__init__(wires=wires)
if gpu:
if not GPU_SUPPORTED:
raise DeviceError(
'GPU not supported with installed version of qulacs. '
'Please install "qulacs-gpu" to use GPU simulation.')
self._state = QuantumStateGpu(wires)
else:
self._state = QuantumState(wires)
self._circuit = QuantumCircuit(wires)
self._first_operation = True
def test_state_reflection(self):
from qulacs import QuantumState
from qulacs.gate import StateReflection
n = 5
s1 = QuantumState(n)
def gen_gate():
s2 = QuantumState(n)
gate = StateReflection(s2)
del s2
return gate
gate = gen_gate()
gate.update_quantum_state(s1)
del gate
del s1
def qtest(angle):
state = QuantumState(3)
state.set_Haar_random_state()
circuit = QuantumCircuit(3)
circuit.add_X_gate(0)
merged_gate = merge(CNOT(0, 1), Y(1))
circuit.add_gate(merged_gate)
circuit.add_RX_gate(1, angle)
circuit.update_quantum_state(state)
observable = Observable(3)
observable.add_operator(2.0, "X 2 Y 1 Z 0")
observable.add_operator(-3.0, "Z 2")
result = observable.get_expectation_value(state)
output = {'energy': result}
return (output)
def __init__(self, wires, shots=1000, analytic=True, gpu=False, **kwargs):
super().__init__(wires=wires, shots=shots, analytic=analytic)
if gpu:
if not QulacsDevice.gpu_supported:
raise DeviceError(
"GPU not supported with installed version of qulacs. "
"Please install 'qulacs-gpu' to use GPU simulation.")
self._state = QuantumStateGpu(self.num_wires)
else:
self._state = QuantumState(self.num_wires)
self._circuit = QuantumCircuit(self.num_wires)
self._pre_rotated_state = self._state.copy()
def test_prepstate(self):
n_qubit = 4
dim = 2**n_qubit
from qulacs import QuantumState
from qulacs.state import inner_product
s0 = QuantumState(n_qubit)
s0.set_Haar_random_state()
s1 = freqerica.circuit.universal.prepstate(n_qubit, s0.get_vector())
print(inner_product(s0, s1))
civec = {0b0011: .5, 0b0101: +.5j, 0b1001: -.5j, 0b0110: -.5}
s2 = freqerica.circuit.universal.prepstate(n_qubit, civec)
print(s2)
assert True