Пример #1
0
from converter.qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute

qr = QuantumRegister(2)
qr2 = QuantumRegister(1)
cr = ClassicalRegister(2)
cr2 = ClassicalRegister(1)
qc = QuantumCircuit(qr, qr2, cr, cr2)

#qc.ccx(qr[0], qr[1], qr2[0])
#qc.x(qr[0])
#qc.ccx(qr[0], qr[1], qr[2])
#qc.x(qr[1])
#qc.ccx(qr[0], qr[1], qr[2])
#qc.ccx(qr[0], qr[1], qr[2])
#qc.ccx(qr[0], qr[1], qr[2])
#qc.x(qr[0])
#qc.ccx(qr[0], qr[1], qr[2])

for i in range(16):
    qc.ccx(qr[0], qr[1], qr2[0])
'''
qc.ccx(qr[0],qr[1],qr2[0])
qc.ccx(qr[1],qr[2],qr2[0])
qc.ccx(qr[0],qr[1],qr2[0])
qc.ccx(qr[0],qr[1],qr2[0])
qc.ccx(qr[0],qr[2],qr2[0])
'''
qc.measure(qr2, cr2)

execute(qc)
Пример #2
0
from converter.qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute

qr1 = QuantumRegister(1)
qr2 = QuantumRegister(1)
cr1 = ClassicalRegister(1)
cr2 = ClassicalRegister(1)
qc = QuantumCircuit(qr1, qr2, cr1, cr2)

qc.cx(qr1[0], qr2[0])
qc.x(qr2[0])

qc.measure(qr2, cr2)

execute(qc)
from converter.qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute

c = QuantumRegister(1)
t1 = QuantumRegister(1)
t2 = QuantumRegister(1)
cc = ClassicalRegister(1)
t1c = ClassicalRegister(1)
t2c = ClassicalRegister(1)

circuit = QuantumCircuit(c, t1, t2, cc, t1c, t2c)

circuit.cswap(c[0], t1[0], t2[0])

circuit.measure(c, cc)
circuit.measure(t1, t1c)
circuit.measure(t2, t2c)

execute(circuit)
Пример #4
0
from converter.qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister

qr = QuantumRegister(1)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr, cr)

qc.x(qr)

qc.measure(qr, cr)
Пример #5
0
from converter.qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute

qr1 = QuantumRegister(1)
qr2 = QuantumRegister(1)
cr1 = ClassicalRegister(1)
cr2 = ClassicalRegister(1)

qc = QuantumCircuit(qr1, qr2, cr1, cr2)

for i in range(16):
    qc.cx(qr1, qr2)
'''
qc.cx(qr1,qr2)
qc.cx(qr1,qr2)
qc.cx(qr1,qr2)
qc.cx(qr1,qr2)
qc.cx(qr1,qr2)
qc.cx(qr1,qr2)
qc.cx(qr1,qr2)
qc.cx(qr1,qr2)
qc.cx(qr1,qr2)
qc.cx(qr1,qr2)
qc.cx(qr1,qr2)
'''
#qc.x(qr1)
#qc.x(qr2)
#qc.x(qr2)
#qc.x(qr2)
#qc.x(qr2)
#qc.x(qr1)
Пример #6
0
from converter.qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute

a = QuantumRegister(2)
b = QuantumRegister(2)
ci = QuantumRegister(1)
s = QuantumRegister(2)
co = QuantumRegister(1)

a_ = ClassicalRegister(2)
b_ = ClassicalRegister(2)
ci_ = ClassicalRegister(1)
s_ = ClassicalRegister(2)
co_ = ClassicalRegister(1)

circuit = QuantumCircuit(a, b, ci, s, co, a_, b_, ci_, s_, co_)

circuit.ccx(a[0], b[0], ci[0])
circuit.cx(a[0], s[0])
circuit.cx(b[0], s[0])

circuit.ccx(ci[0], a[1], co[0])
circuit.ccx(ci[0], b[1], co[0])
circuit.ccx(a[1], b[1], co[0])
circuit.cx(ci[0], s[1])
circuit.cx(a[1], s[1])
circuit.cx(b[1], s[1])

circuit.measure(ci, ci_)
circuit.measure(s, s_)
circuit.measure(co, co_)
from sys import argv

qin1 = QuantumRegister(1)
cin1 = ClassicalRegister(1)
qin2 = QuantumRegister(1)
cin2 = ClassicalRegister(1)

#output bit: function XORed onto this
qz = QuantumRegister(1)
cz = ClassicalRegister(1)

#output bit: function XORed onto this
tmp = QuantumRegister(1)

#beginning of the circuit
circuit = QuantumCircuit(qin1,qin2,qz,tmp,cin1,cin2,cz)

#initialize temp
circuit.x(tmp)

circuit.cx(tmp, qz)
circuit.ccx(qin1, tmp, qz)
circuit.ccx(qin2, tmp, qz)

#reversing tmp
circuit.x(tmp)

#circuit.measure(qin1, cin1)
#circuit.measure(qin2, cin2)
circuit.measure(qz, cz)
Пример #8
0
from converter.qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute

t1 = QuantumRegister(1)
t2 = QuantumRegister(1)
t1c = ClassicalRegister(1)
t2c = ClassicalRegister(1)

circuit = QuantumCircuit(t1, t2, t1c, t2c)

circuit.swap(t1[0], t2[0])
circuit.swap(t1[0], t2[0])

circuit.measure(t1, t1c)
circuit.measure(t2, t2c)

execute(circuit)
Пример #9
0
from converter.qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute

qi = QuantumRegister(3) # a = qi[0]; b = qi[1]; ci = qi[2]
qo = QuantumRegister(2) # so = qo[0]; co = qo[1]
ci = ClassicalRegister(3)
co = ClassicalRegister(2)

circuit = QuantumCircuit(qi,qo,ci,co)


for idx in range(3):
    circuit.ccx(qi[idx], qi[(idx+1)%3], qo[1])
for idx in range(3):
    circuit.cx(qi[idx], qo[0])

circuit.measure(qo, co)

execute(circuit)
from converter.qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute

n = 4
a = QuantumRegister(n)
b = QuantumRegister(n)

C = QuantumRegister(n)
S = QuantumRegister(n)

ac = ClassicalRegister(n)
bc = ClassicalRegister(n)
Cc = ClassicalRegister(n)
Sc = ClassicalRegister(n)

circuit = QuantumCircuit(a, b, C, S, ac, bc, Cc, Sc)

circuit.ccx(a[n-1], b[n-1], C[n-1])
circuit.cx(a[n-1], S[n-1])
circuit.cx(b[n-1], S[n-1])

for i in range(1,n):
    circuit.ccx(a[n-1-i],b[n-1-i],C[n-1-i])
    circuit.ccx(b[n-1-i],C[n-1-(i-1)],C[n-1-i])
    circuit.ccx(a[n-1-i],C[n-1-(i-1)],C[n-1-i])
    circuit.cx(a[n-1-i], S[n-1-i])
    circuit.cx(b[n-1-i], S[n-1-i])
    circuit.cx(C[n-1-(i-1)], S[n-1-i])

circuit.measure(C, Cc)
circuit.measure(S, Sc)
Пример #11
0
from converter.qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute

qin1 = QuantumRegister(1)
cin1 = ClassicalRegister(1)
qin2 = QuantumRegister(1)
cin2 = ClassicalRegister(1)

#output bit: function XORed onto this
qz = QuantumRegister(1)
cz = ClassicalRegister(1)

tmpq = QuantumRegister(1)
tmpc = ClassicalRegister(1)
#beginning of the circuit
circuit = QuantumCircuit(qin1,qin2,qz,tmpq,cin1,cin2,cz,tmpc)

#initialize example values
circuit.x(qin1)
circuit.x(qin2)

#initialize temp
circuit.x(tmpq)

circuit.cx(tmpq, qz)
circuit.ccx(qin1, tmpq, qz)
circuit.ccx(qin2, tmpq, qz)

#reversing tmp
circuit.x(tmpq)

#circuit.measure(qin1, cin1)
from converter.qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute

qr1 = QuantumRegister(1)
cr1 = ClassicalRegister(1)
qc = QuantumCircuit(qr1, cr1)

qc.h(qr1[0])
qc.measure(qr1, cr1)

execute(qc)
n = 5
qin1 = QuantumRegister(n)
cin1 = ClassicalRegister(n)
qin2 = QuantumRegister(n)
cin2 = ClassicalRegister(n)

#output bit: function XORed onto this
qz = QuantumRegister(1)
cz = ClassicalRegister(1)

#output bit: function XORed onto this
tmp = QuantumRegister(1)
tmpc = ClassicalRegister(1)

#beginning of the circuit
circuit = QuantumCircuit(qin1, qin2, qz, tmp, cin1, cin2, cz, tmpc)

#initialize example values
circuit.x(qin1)
circuit.x(qin2[1])
circuit.x(qin2[3])

#initialize temp
circuit.x(tmp)

#actually compare
equal_nway(qin1, qin2, tmp, qz, n, circuit)

#reversing tmp
circuit.x(tmp)
from converter.qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister

qr = QuantumRegister(2)
cr = ClassicalRegister(2)
qc = QuantumCircuit(qr, cr)

qc.swap(qr[0], qr[1])
qc.x(qr[0])
qc.swap(qr[0], qr[1])
qc.swap(qr[0], qr[1])
qc.x(qr[1])
qc.swap(qr[0], qr[1])

qc.measure(qr, cr)
t0c = ClassicalRegister(1)

c1 = QuantumRegister(1)
c1c = ClassicalRegister(1)

c2 = QuantumRegister(1)
c2c = ClassicalRegister(1)

t1 = QuantumRegister(1)
t1c = ClassicalRegister(1)

c3 = QuantumRegister(1)
c3c = ClassicalRegister(1)

#beginning of the circuit
circuit = QuantumCircuit(a1, a0, b1, b0, c3, c2, c1, c0, t0, t1, a1c, a0c, b1c,
                         b0c, c3c, c2c, c1c, c0c, t0c, t1c)

circuit.ccx(a0[0], b1[0], t0[0])
circuit.ccx(a0[0], b0[0], c0[0])
circuit.ccx(a1[0], b1[0], t1[0])
circuit.ccx(a1[0], b0[0], c1[0])
circuit.ccx(t0[0], c1[0], c2[0])
circuit.cx(t0[0], c1[0])
circuit.ccx(t1[0], c2[0], c3[0])
circuit.cx(t1[0], c2[0])

#uncompute temporary qubits
circuit.ccx(a1[0], b1[0], t1[0])
circuit.ccx(a0[0], b1[0], t0[0])

circuit.measure(c0, c0c)
Пример #16
0
from converter.qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister

qr = QuantumRegister(3)
cr = ClassicalRegister(3)
qc = QuantumCircuit(qr, cr)

qc.ccx(qr[0], qr[1], qr[2])
qc.x(qr[0])
qc.ccx(qr[0], qr[1], qr[2])
qc.x(qr[1])
qc.ccx(qr[0], qr[1], qr[2])
qc.ccx(qr[0], qr[1], qr[2])
qc.ccx(qr[0], qr[1], qr[2])
qc.x(qr[0])
qc.ccx(qr[0], qr[1], qr[2])

qc.measure(qr, cr)
Пример #17
0
from converter.qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute

qr1 = QuantumRegister(1)
cr1 = ClassicalRegister(1)

qc = QuantumCircuit(qr1, cr1)

qc.x(qr1)
qc.x(qr1)
qc.x(qr1)
qc.measure(qr1, cr1)

execute(qc)