def __qulacs_measure_shots(qstate, qid, shots=1):
# error check
qubit_num = qstate.get_qubit_count()
if max(qid) >= qubit_num:
raise ValueError
# list of binary vectors for len(qid) bit integers
qid_sorted = sorted(qid)
mbits_list = []
for i in range(2**len(qid)):
# ex)
# qid = [5,0,2] -> qid_sorted = [0,2,5]
# i = (0,1,2), idx = (2,0,1)
# bits = [q0,q1,q2] -> mbits = [q1,q2,q0]
bits = list(map(int, list(format(i, '0{}b'.format(len(qid))))))
mbits = [0] * len(qid)
for i, q in enumerate(qid):
idx = qid_sorted.index(q)
mbits[idx] = bits[i]
mbits_list.append(mbits)
# list of probabilities
prob_list = []
prob = 0.0
for mbits in mbits_list:
args = [2] * qubit_num
for j, q in enumerate(qid):
args[q] = mbits[j]
prob += qstate.get_marginal_probability(args)
prob_list.append(prob)
if prob_list[-1] != 1.0:
prob_list[-1] = 1.0
# frequency
mval_data = []
if shots > 1:
for i in range(shots - 1):
rand = random.random()
for mbits, prob in zip(mbits_list, prob_list):
if rand <= prob:
mval = ''.join(map(str, mbits))
mval_data.append(mval)
break
# last quantum state
circ = QuantumCircuit(qubit_num)
for i, q in enumerate(qid):
circ.add_gate(Measurement(q, i))
circ.update_quantum_state(qstate)
last = ''.join(
map(str, [qstate.get_classical_value(i) for i in range(len(qid))]))
mval_data.append(last)
frequency = Counter(mval_data)
return frequency, qstate
def __qulacs_measure(qstate, qubit_num, q):
# error check
if q >= qubit_num:
raise ValueError("measurement qubit id is out of bound")
circ = QuantumCircuit(qubit_num)
circ.add_gate(Measurement(q, 0))
circ.update_quantum_state(qstate)
mval = qstate.get_classical_value(0)
return mval
def __qulacs_reset(qstate, qubit_num, q):
# error check
if q >= qubit_num:
raise ValueError("reset qubit id is out of bound")
circ = QuantumCircuit(qubit_num)
circ.add_gate(Measurement(q, 0))
circ.update_quantum_state(qstate)
circ_flip = QuantumCircuit(qubit_num)
if qstate.get_classical_value(0) == 1:
circ_flip.add_gate(X(q))
circ_flip.update_quantum_state(qstate)
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
I_mat = np.eye(2, dtype=complex)
X_mat = X(0).get_matrix()
Z_mat = Z(0).get_matrix()
# Construct an output gate U_out and initialization.
U_out = ParametricQuantumCircuit(nqubit)
for d in range(c_depth):
for i in range(nqubit):
angle = 2.0 * np.pi * np.random.rand()
U_out.add_parametric_RX_gate(i,angle)
angle = 2.0 * np.pi * np.random.rand()
U_out.add_parametric_RZ_gate(i,angle)
angle = 2.0 * np.pi * np.random.rand()
U_out.add_parametric_RX_gate(i,angle)
meas0 = Measurement(0, 0)
U_out.add_gate(meas0)
meas1 = Measurement(1, 1)
U_out.add_gate(meas1)
#meas2 = Measurement(2, 2)
#U_out.add_gate(meas2)
# Take the initial theta
parameter_count = U_out.get_parameter_count()
theta_init = [U_out.get_parameter(ind) for ind in range(parameter_count)]
# Function to encode x
def U_in(x):
U = QuantumCircuit(nqubit)
circ.update_quantum_state(input_state)
value = qulacs_hamiltonian.get_expectation_value(input_state)
print(" cost -->", value)
return value
method = "COBYLA"
options = {"disp": False, "maxiter": arg_maxiter}
opt = minimize(cost, init_theta_list, method=method, options=options)
print("opt.x =", opt.x)
print(opt.success, opt.status, opt.message, opt.fun)
circ = ansatz_circuit(n_qubit, depth, opt.x)
for i in range(n_qubit):
circ.add_gate(Measurement(i, i))
input_state = QuantumState(n_qubit)
#input_state.set_zero_state()
input_state.set_computational_basis(
int('0b' + '1' * (n_qubit / 2) + '0' * (n_qubit / 2), 2))
circ.update_quantum_state(input_state)
print("Energy =", qulacs_hamiltonian.get_expectation_value(input_state))
exec_time = time.time() - start_time
print('')
print('QUBO of size ' + str(len(Q)) + ' sampled in ' + str(exec_time) + ' s')
samples = {}
sys.stdout.write("Value=")
for i in range(n_qubit):