def writeAsm(id, dic, fileName, reset=True, compress=False):
Debug.debug("id:" + str(id), DebugLevel.Function)
path = WriterAsm.getPath(id, dic)
Debug.debug("path:" + str(path), DebugLevel.Debug)
if reset:
file = open(fileName, "w")
else:
file = open(fileName, "a")
if not compress:
file.write(
Assembler.comment("Assembler file: " + fileName + " to id: " +
str(id)))
file.write(Assembler.iniAsm(nQubits=dic.getNQubits()))
for i in path:
file.write(dic.getGate(i).getAsm(compress))
file.write(Assembler.finAsm(nQubits=dic.getNQubits()))
file.close()
return len(path)
def getLimitedPath(id, dic, deepEnd=True, deep=0, autoReference=False):
Debug.debug(
"id:" + str(id) + " deep:" + str(deep) + " autoReference:" +
str(autoReference), DebugLevel.Function)
if deepEnd and deep == 0:
if autoReference:
return [(GateDominio.Open, id), (GateDominio.Close, id)]
else:
return [id]
path = dic.getGate(id).getPath()
if path is []:
if autoReference:
return [(GateDominio.Open, id), (GateDominio.Close, id)]
else:
return [id]
res = []
if autoReference:
res.append((GateDominio.Open, id))
for i in path:
res += Visualizer.getLimitedPath(i, dic, deepEnd, deep - 1,
autoReference)
if autoReference:
res.append((GateDominio.Close, id))
return res
def round(npObject, decimals=None):
Debug.debug(str(npObject) + " ; " + str(decimals), DebugLevel.Function)
if decimals is not None:
return np.round(npObject, decimals=decimals)
else:
return npObject
def probeAll(filename, nQubits, index, viewMatrix, compress):
Debug.debug(
filename + " ; " + str(nQubits) + " ; " + str(index) + " ; " +
str(viewMatrix), DebugLevel.Function)
array = [0, 0, 0]
for i in range(index + 1):
print(Colors.BOLD.value +
"\n\n******************************************\n TEST " +
str(i) + "\n" + Colors.ENDC.value)
array[probeMatrix(filename, nQubits, i, viewMatrix, compress)] += 1
print(Colors.BOLD.value +
"\n\n******************************************\n END TEST " +
str(i) + "\n\n" + Colors.ENDC.value)
print(Colors.BOLD.value +
"\n\n******************************************\n ALL TEST UNDER " +
str(index) + "\n" + Colors.ENDC.value)
print(Colors.GREEN.value + " EQUAL:" + str(array[0]) + "\n" +
Colors.ENDC.value)
print(Colors.BLUE.value + " CLOSE:" + str(array[1]) + "\n" +
Colors.ENDC.value)
print(Colors.RED.value + " ERROR:" + str(array[2]) + "\n" +
Colors.ENDC.value)
print(Colors.BOLD.value +
"******************************************\n END ALL TEST\n\n" +
Colors.ENDC.value)
def generateMatrix(filename, nQubits, index, compress):
Debug.debug(filename + " ; " + str(nQubits) + " ; " + str(index),
DebugLevel.Function)
# inicializa un diccionario para 4 qubits
dic = DictionarySearcher(nQubits=nQubits)
# genera una puerta de giro condicionado multiple y las subpuertas necesarias
#id = AQP.generateMultipleTurn(sources=[0,1,2], target=3, angle=math.pi, turnType=TurnType.Z, dic=dic)
gate = generateGate(index, nQubits, dic)
if isinstance(gate, tuple):
matrix = gate[1]
gateId = gate[0]
else:
gateId = gate
# genera el fichero .qasm para crear esta puerta
numberGates = WriterAsm.writeAsm(gateId,
dic,
filename,
reset=True,
compress=compress)
print(Colors.BOLD.value + "\nAssembler written with " + str(numberGates) +
" gates\n" + Colors.ENDC.value)
if gate is tuple:
return matrix
else:
return dic.getGate(gateId).getMatrix()
return dic.getGate(gateId).getMatrix()
def getId(self, gateType, params):
Debug.debug("gateType:" + str(gateType) + " params" + str(params),
DebugLevel.Function)
if gateType in self.stDic.keys():
return GateDictionary.getIdRecursive(self.stDic[gateType], params)
else:
return NO_ID
def codingQubits(qubits):
Debug.debug(qubits, DebugLevel.Function)
code = 0
for i in qubits:
code += 2**i
return code
def getOracleMatrix(nQubits, targets):
Debug.debug("nQubits:" + str(nQubits) + " targets:" + str(targets),
DebugLevel.Function)
matrix = np.eye(2**nQubits, dtype=complex)
for i in targets:
matrix[i][i] = -1
return matrix
def generateGate(index, nQubits, dic):
Debug.debug(str(index) + " ; " + str(nQubits), DebugLevel.Function)
array = []
for i in range(nQubits):
array.append(i)
if index == 0:
return AQP.generateBasic(standarGate=StandarGate.X,
targets=array,
dic=dic)
elif index == 1:
return AQP.generateXnot(source=0, target=nQubits - 1, dic=dic)
elif index == 2:
return AQP.generateBasicTurn(target=nQubits - 1,
angle=math.pi / 2,
turnType=TurnType.X,
dic=dic)
elif index == 3:
return AQP.generateCondTurn(turnType=TurnType.X,
target=nQubits - 1,
source=nQubits - 2,
angle=math.pi / 2,
dic=dic)
elif index == 4:
return AQP.generateMultipleTurn(turnType=TurnType.X,
target=nQubits - 1,
sources=array[:-1],
angle=math.pi / 2,
dic=dic)
elif index == 5:
return AQP.generateToffoli(target=nQubits - 1,
sources=array[:-1],
dic=dic)
elif index == 6:
return AQP.generateSpecialTurn(a=1j, b=-1, dic=dic)
elif index == 7:
return AQP.generateRowReverse(target1=1,
target2=2**nQubits - 2,
dic=dic)
elif index == 8:
matrix = QuantumMath.getOracleMatrix(
nQubits=nQubits, targets=[0, nQubits, 2**nQubits - 1])
return (AQP.generateSpecial(name="oracle", matrix=matrix,
dic=dic), matrix)
elif index == 9:
matrix = QuantumMath.getAmplitudAmplifier(nQubits=nQubits)
return (AQP.generateSpecial(name="aa", matrix=matrix, dic=dic), matrix)
def getPath(id, dic):
Debug.debug("id:" + str(id), DebugLevel.Function)
path = dic.getGate(id).getPath()
if not path:
return [id]
res = []
for i in path:
res += WriterAsm.getPath(i, dic)
return res
def generateGate(index, rowReverse, nQubits, dic):
Debug.debug(str(index) + " ; " + str(nQubits), DebugLevel.Function)
if rowReverse:
return AQP.generateRowReverse(target1=0, target2=index, dic=dic)
else:
matrix = QuantumMath.getOracleMatrix(nQubits=nQubits, targets=[]) #generate a diagonal matrix
matrix[0,0] = 1/math.sqrt(2)
matrix[0,index] = 1/math.sqrt(2)
matrix[index,0] = 1/math.sqrt(2)
matrix[index,index] = -1/math.sqrt(2)
return AQP.generateSpecial(name="2superpoitionGate", matrix=matrix, dic=dic)
def addGate(self, gate, gateType, params):
idExist = self.getId(gateType, params)
if idExist != NO_ID:
return idExist
else:
Debug.debug(
"Adding gate [" + str(self.idActual) + "]<" +
str(gateType.name) + ">: " + str(params), DebugLevel.Debug)
gate.setId(self.idActual)
self.idDic[self.idActual] = gate
GateDictionary.addGateRecursive(self.idActual, self.stDic,
[gateType] + params)
self.idActual += 1
return self.idActual - 1
def toBinary(number, digits):
Debug.debug("number:" + str(number) + " digits:" + str(digits),
DebugLevel.Function)
binary = []
for i in range(digits):
if number % 2 == 0:
binary.append(0)
else:
binary.append(1)
number //= 2
binary.reverse()
return binary
def decodingQubits(code):
Debug.debug(code, DebugLevel.Function)
ind = 0
qubits = []
while code > 0:
if code % 2 == 1:
qubits.append(ind)
code //= 2
ind += 1
return qubits
def printPath(id, dic, deepEnd=True, deep=0, printGate=False):
Debug.debug(
"id:" + str(id) + " dic:" + str(dic) + " deepEnd:" + str(deepEnd) +
" deep:" + str(deep), DebugLevel.Function)
if deepEnd and deep < 0:
return ""
if printGate:
st = "[" + str(dic.getGate(id)) + ": "
else:
st = "[" + str(id) + ": "
for i in dic.getGate(id).getPath():
st += Visualizer.printPath(id=i,
dic=dic,
deepEnd=deepEnd,
deep=deep - 1)
return st + " ]"
plt.xticks(_keys, keys) # set labels manually
plt.show()
except QISKitError as ex:
print ("EXCEPCION Error = {}".format(ex))
if __name__ == "__main__":
np.set_printoptions(precision=2, linewidth=200, suppress=True)
Debug.startDebug(fileOutputLevel=DebugLevel.Nothing, stdOutputLevel=DebugLevel.Nothing, autoDebugLevel=True, autoTime=True)
if "-h" in sys.argv[1:] or "--help" in sys.argv[1:]:
print("This script execute QCMD to get a determined circuit, execute this circuit in a QISKit simulator and then compares these results with an execution in a real quantum computer IBM-Q of 5 qubits.")
print(" Every argument is OPTIONAL and they do not need to be sorted. [-m and -r] should not be active together ")
print("-n <qubits> : number of qubits (over 3 qubits the result are almost random) -> default = 2")
print("-f <filename> : filename where the qasm will be generated -> default = 'prueba.qasm'")
print("-s <shots> : number of shots to execute in the computer -> default = 1000")
print("[-m or -r] <index> -> default = -r 1")
print("-m <index>: active: generate a matrix of superposition of two states 0 and i")
print("-r <index>: genererate a row reverse matrix fomr 0 to i")
print("-v : active to view the matrix generated")
print("-c : active to write the qasm in a compress way (compress the out file, not the number of gates)")
quit()
if not "-f" in sys.argv[1:]:
def matrixDot(matrixArray):
Debug.debug(matrixArray, DebugLevel.Function)
m = matrixArray[0]
for i in matrixArray[1:]:
m = np.dot(m, i)
return m
def tensorDot(matrixArray):
Debug.debug(matrixArray, DebugLevel.Function)
m = matrixArray[0]
for i in matrixArray[1:]:
m = np.kron(m, i)
return m
def printCompress(id,
dic,
deepEnd=True,
deep=0,
autoReference=False,
interLineSpace=False,
typed=True):
Debug.debug(
"id:" + str(id) + " dic:" + str(dic) + " deepEnd:" + str(deepEnd) +
" deep:" + str(deep) + " autoReference:" + str(autoReference) +
" interLineSpace:" + str(interLineSpace) + " typed:" + str(typed),
DebugLevel.Function)
nq = dic.getNQubits()
nSt = []
for i in range(nq):
nSt.append("")
path = Visualizer.getLimitedPath(id, dic, deepEnd, deep, autoReference)
Debug.debug("path:" + str(path), DebugLevel.Debug)
for i in path:
#autoref close
if autoReference and isinstance(
i, (tuple, )) and i[0] == GateDominio.Close:
stAux = str(i[1])
nSt[0] += " " + stAux + ")"
for j in range(nq - 1):
for k in range(len(stAux) + 2):
nSt[j + 1] += "-"
continue
#initial chain
for j in range(nq):
nSt[j] += "-"
#autoref open
if autoReference and isinstance(
i, (tuple, )) and i[0] == GateDominio.Open:
stAux = str(i[1])
nSt[0] += "(" + stAux + " "
for j in range(nq - 1):
for k in range(len(stAux) + 2):
nSt[j + 1] += "-"
i = i[1]
#string
if typed:
maxS, l = dic.getGate(i).getStringTypedPerQubit()
Debug.debug("maxS:" + str(maxS) + " l:" + str(l),
DebugLevel.Debug)
maxS += 2
for j, value in enumerate(l):
type = value[0]
if type is QubitStringType.Empty:
for k in range(maxS):
nSt[j] += "-"
elif type is QubitStringType.Source:
for k in range((maxS - 1) // 2):
nSt[j] += "-"
nSt[j] += "O"
for k in range((maxS) // 2):
nSt[j] += "-"
elif type is QubitStringType.Target:
nSt[j] += "[" + value[1] + "]"
else:
for j, value in enumerate(dic.getGate(i).getStringPerQubit()):
nSt[j] += value
#final chain
for j in range(nq):
nSt[j] += "-"
st = "\n"
for i in nSt:
st += i
if interLineSpace:
st += "\n"
st += "\n"
return st
def getGate(self, id):
Debug.debug(id, DebugLevel.Function)
return self.idDic[id]
