def generateCondTurnPath(turnType, target, source, angle, dic):
# xnot
xnotId = AQP.generateXnot(source=source, target=target, dic=dic)
# turn
inverseTurnId = AQP.generateBasicTurn(target=target,
angle=QuantumMath.inverseAngle(
angle / 2),
turnType=turnType,
dic=dic)
turnId = AQP.generateBasicTurn(target=target,
angle=angle / 2,
turnType=turnType,
dic=dic)
# with Z turn it need a recalculation
if turnType == TurnType.Z:
turnIdSource = AQP.generateBasicTurn(target=source,
angle=angle / 2,
turnType=turnType,
dic=dic)
return [xnotId, inverseTurnId, xnotId, turnId, turnIdSource]
else:
#return [xnotId, inverseTurnId, xnotId, turnId]
return [turnId, xnotId, inverseTurnId, xnotId]
def generateSpecialTurnPath(a, b, dic):
module = QuantumMath.vectorModule([a, b])
# normalizing parameters
a /= module
b /= module
# calculating theta x and y
theta = math.asin(QuantumMath.complexModule(b))
y = cmath.phase(b)
x = cmath.phase(a)
lastQubit = dic.getNQubits() - 1
sourceQubits = []
for i in range(lastQubit):
sourceQubits.append(i)
firstGateId = AQP.generateMultipleTurn(turnType=TurnType.Z,
target=lastQubit,
sources=sourceQubits,
angle=(-y + x + math.pi),
dic=dic)
secondGateId = AQP.generateMultipleTurn(turnType=TurnType.X,
target=lastQubit,
sources=sourceQubits,
angle=theta * 2,
dic=dic)
thirdGateId = AQP.generateMultipleTurn(turnType=TurnType.Z,
target=lastQubit,
sources=sourceQubits,
angle=(y + x),
dic=dic)
lastCondId = AQP.generateMultipleTurn(
turnType=TurnType.Z,
target=lastQubit,
sources=sourceQubits,
angle=QuantumMath.inverseAngle(x),
dic=dic)
# is the same with Toffoli or last qubit X
#allToffoliId = AQP.generateToffoli(target=lastQubit, sources=sourceQubits, dic=dic)
allToffoliId = AQP.generateBasic(standarGate=StandarGate.X,
targets=[lastQubit],
dic=dic)
return [
firstGateId, secondGateId, thirdGateId, lastCondId, allToffoliId,
lastCondId, allToffoliId
]
def generateMultipleTurnPath(turnType, target, sources, angle, dic):
# if there is just one source, is like a condTurn
if len(sources) == 1:
return [
AQP.generateCondTurn(turnType=turnType,
target=target,
source=sources[0],
angle=angle,
dic=dic)
]
# if there is two sources the implementation in automatic
elif len(sources) == 2:
nAngle = angle / 2
# conditional turn
condTurnId = AQP.generateCondTurn(turnType=turnType,
target=target,
source=sources[1],
angle=nAngle,
dic=dic)
# xnot
xnotId = AQP.generateXnot(source=sources[0],
target=sources[1],
dic=dic)
# conditional turn inverse
condTurnInvId = AQP.generateCondTurn(
turnType=turnType,
target=target,
source=sources[1],
angle=QuantumMath.inverseAngle(nAngle),
dic=dic)
# conditional turn from above
condTurnAboveId = AQP.generateCondTurn(turnType=turnType,
target=target,
source=sources[0],
angle=nAngle,
dic=dic)
#added to path
return [condTurnId, xnotId, condTurnInvId, xnotId, condTurnAboveId]
else:
nAngle = angle / 2
path = []
# multiple n-1 sources
multipleId = AQP.generateMultipleTurn(turnType=turnType,
target=target,
sources=sources[1:],
angle=nAngle,
dic=dic)
path.append(multipleId)
# create xnot to every qubit source from first source
pathXnot = []
for qubitAux in sources[1:]:
# xnot
xnotId = AQP.generateXnot(source=sources[0],
target=qubitAux,
dic=dic)
#added to path
pathXnot.append(xnotId)
path += pathXnot
# multiple n-1 sources
multipleInvId = AQP.generateMultipleTurn(
turnType=turnType,
target=target,
sources=sources[1:],
angle=QuantumMath.inverseAngle(nAngle),
dic=dic)
path.append(multipleInvId)
# redo xnots
path += pathXnot
# negate last qubit
negateId = AQP.generateBasic(standarGate=StandarGate.X,
targets=[sources[-1]],
dic=dic)
path.append(negateId)
# x not from last qubit
pathInverseXnot = []
for qubitAux in sources[1:-1]:
# xnot
xnotId = AQP.generateXnot(source=sources[-1],
target=qubitAux,
dic=dic)
#added to path
pathInverseXnot.append(xnotId)
path += pathInverseXnot
# create the new multi conditional
multiLowId = AQP.generateMultipleTurn(turnType=turnType,
target=target,
sources=sources[:-1],
angle=nAngle,
dic=dic)
path.append(multiLowId)
# redo the negation
path += pathInverseXnot
path.append(negateId)
return path