def single_purification(rho0, rho1):
CCZZ = (
kr(dens(d00), iden(4))
+ kr(dens(d01), kr(iden(2), Z))
+ kr(dens(d10), kr(Z, iden(2)))
+ kr(dens(d11), ZZ)
)
# Joint state of rho0 and rho1
rho = kr(rho0, rho1)
# Apply bilateral CNOT gate
CXrho = gaterho(CCZZ, rho)
# Get chances of ma = mb
p0 = kr(iden(4), dpp)
p1 = kr(iden(4), dmm)
check0 = meas(dens(p0), CXrho)
check1 = meas(dens(p1), CXrho)
# Get post measurement state
rhoPost = check0 * (her(p0) @ CXrho @ p0) + check1 * (her(p1) @ CXrho @ p1)
# normalize state, find Fidelity
(rhoPostn, F) = reconwerner(rhoPost)
# Perform Hadamard
rhopure = gaterho(kr(H, H), rhoPostn)
return (rhopure, F)
def cpcxz(a, b, c, d):
phi = cpair(a, b, c, d)
if a == 1:
Ax = X
elif a == 0:
Ax = iden(2)
else:
print("Input must be 0 or 1")
if b == 1:
Bx = X
elif b == 0:
Bx = iden(2)
else:
print("Input must be 0 or 1")
if c == 1:
Cz = Z
elif c == 0:
Cz = iden(2)
else:
print("Input must be 0 or 1")
if d == 1:
Dz = Z
elif d == 0:
Dz = iden(2)
else:
print("Input must be 0 or 1")
CM = kr(Ax, Bx) @ kr(Cz, Dz)
Cv = kr(phi, CM)
return Cv
def cpair(a, b, c, d):
D = {}
D[0] = s0
D[1] = s1
D[2] = sp
D[3] = sm
D["p"] = sp
D["m"] = sm
phi = kr(kr(D[a], D[b]), kr(D[c], D[d]))
return phi
def initiate_gates():
global X, Y, Z, H, CX, CY, CZ, XX, YY, ZZ
X = vec("0 1; 1 0")
Y = vec("0 -1j; 1j 0")
Z = vec("1 0; 0 -1")
H = (X + Z) / sqrt(2)
CX = kr(dens(s0), iden(2)) + kr(dens(s1), X)
CY = kr(dens(s0), iden(2)) + kr(dens(s1), Y)
CZ = kr(dens(s0), iden(2)) + kr(dens(s1), Z)
XX = kr(X, X)
YY = kr(Y, Y)
ZZ = kr(Z, Z)
def initiate_vects():
global s0, s1, sp, sm, d00, d01, d10, d11, dpp, dmm, Bphip, Bphim, Bpsip, Bpsim
s0 = vec("1;0")
s1 = vec("0;1")
sp = (s0 + s1) / sqrt(2)
sm = (s0 - s1) / sqrt(2)
d00 = kr(s0, s0)
d01 = kr(s0, s1)
d10 = kr(s1, s0)
d11 = kr(s1, s1)
dpp = kr(sp, sp)
dmm = kr(sm, sm)
Bpsip = (d00 + d11) / sqrt(2)
Bpsim = (d00 - d11) / sqrt(2)
Bphip = (d01 + d10) / sqrt(2)
Bphim = (d01 - d10) / sqrt(2)
def double_purification(rho0, rho1, rho2):
CCZZ0 = kr(
kr(dens(d00), iden(4))
+ kr(dens(d01), kr(iden(2), Z))
+ kr(dens(d10), kr(Z, iden(2)))
+ kr(dens(d11), ZZ),
iden(4),
)
CCZZ2 = kr(
iden(4),
kr(iden(4), dens(d00))
+ kr(kr(iden(2), Z), dens(d01))
+ kr(kr(Z, iden(2)), dens(d10))
+ kr(ZZ, dens(d11)),
)
# Joint state of rho0 and rho1
rho = kr(kr(rho0, rho1), rho2)
# Apply bilateral CNOT gate
CXrho = gaterho(CCZZ0, rho)
CXCXrho = gaterho(CCZZ2, CXrho)
# Get chances of ma = mb
p0 = kr(kr(iden(4), dpp), dpp)
p1 = kr(kr(iden(4), dpp), dmm)
p2 = kr(kr(iden(4), dmm), dpp)
p3 = kr(kr(iden(4), dmm), dmm)
check0 = meas(dens(p0), CXCXrho)
check1 = meas(dens(p1), CXCXrho)
check2 = meas(dens(p2), CXCXrho)
check3 = meas(dens(p3), CXCXrho)
# Get post measurement state
rhoPost = (
check0 * (her(p0) @ CXCXrho @ p0)
+ check1 * (her(p1) @ CXCXrho @ p1)
+ check2 * (her(p2) @ CXCXrho @ p2)
+ check3 * (her(p3) @ CXCXrho @ p3)
)
# normalize state, find Fidelity
(rhoPostn, F) = reconwerner(rhoPost)
# Perform Hadamard
rhopure = gaterho(kr(H, H), rhoPostn)
return (rhopure, F)
)
return (reconrho, nbase[0])
initiate_vects()
initiate_gates()
F = 0.6
rhoW = wernerrho(F)
#####################################################
# Parity projection with a shared ancilla
parity_ancilla = False
if parity_ancilla:
rhoAB = rhoW
MXZ = (kr(d00, iden(4)) + kr(d01, ZZ) + kr(d10, XX) + kr(d11, XX @ ZZ)) / 2
rhoABXZ = MXZ @ rhoAB @ MXZ.T
Mh0 = dens(kr(kr(sp, sp), iden(4)))
check_ancilla = meas(Mh0, rhoABXZ)
print(check_ancilla)
#####################################################
# Parity projection with a shared entangled pair
parity_pair = False
if parity_pair:
PrhoAB = rhoW
PMXZ = (
cpcxz(0, 0, 0, 0) + cpcxz(0, 0, 1, 1) + cpcxz(1, 1, 0, 0) + cpcxz(1, 1, 1, 1)