├── .gitignore ├── .idea ├── .name ├── encodings.xml ├── misc.xml ├── modules.xml ├── physics.iml └── vcs.xml ├── AnimatedScatter.py ├── CRW.gif ├── QDS-VS-DW.gif ├── QW.gif ├── QWithDiffShift.py ├── QWithDiffShiftTest.py ├── Quantum Walk in Graph K5.nb ├── README.md ├── classicalRW.py ├── classicalRWMat.py ├── quantumRW.py ├── quantumRWMat.py └── quantumRWTest.py /.gitignore: -------------------------------------------------------------------------------- 1 | /QWM_100.png 2 | /QDS_1.png 3 | /QDS_2.png 4 | /QDS_4.png 5 | /QDS_5.png 6 | /QDS_3.png 7 | /QW_50.txt 8 | /QW_25.txt 9 | /QW_85.txt 10 | /QW_50.png 11 | /QW_20.png 12 | /QW_55.txt 13 | /QW_80.txt 14 | /QW_100.txt 15 | /QW_20.txt 16 | /QW_70.png 17 | /QW_30.txt 18 | /QW_95.txt 19 | /QW_30.png 20 | /QW_90.txt 21 | /QW_60.txt 22 | /QW_90.png 23 | /QW_5.txt 24 | /QW_60.png 25 | /QW_15.txt 26 | /QW_65.txt 27 | /QW_70.txt 28 | /QW_35.txt 29 | /QW_40.png 30 | /QW_10.png 31 | /QW_40.txt 32 | /QW_10.txt 33 | /QW_45.txt 34 | /QW_100.png 35 | /QW_49.txt 36 | /QW_80.png 37 | /QW_75.txt 38 | /CRW_100.png 39 | /CRW_40.png 40 | /CRW_70.png 41 | /CRW_30.png 42 | /CRW_80.png 43 | /CRW_20.png 44 | /CRW_60.png 45 | /CRW_90.png 46 | /CRW_10.png 47 | /CRW_50.png 48 | 49 | # Created by .ignore support plugin (hsz.mobi) 50 | -------------------------------------------------------------------------------- /.idea/.name: -------------------------------------------------------------------------------- 1 | physics -------------------------------------------------------------------------------- /.idea/encodings.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | -------------------------------------------------------------------------------- /.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /.idea/physics.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /AnimatedScatter.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | __author__ = 'levitan' 4 | 5 | import matplotlib.pyplot as plt 6 | import matplotlib.animation as animation 7 | from numpy import * 8 | import QWithDiffShift as QDS 9 | import time 10 | 11 | 12 | class AnimatedScatterQW(object): 13 | """An animated scatter plot using matplotlib.animations.FuncAnimation.""" 14 | 15 | def __init__(self, X0, X1, steps, shiftGateNum, node): 16 | self.X0 = X0 17 | self.X1 = X1 18 | self.steps = steps 19 | self.shiftGateNum = shiftGateNum 20 | self.node = node 21 | self.step = 1 22 | self.linedata = zeros([self.node, 1]) 23 | self.distri = self.distribution() 24 | 25 | # Setup the figure and axes... 26 | self.fig = plt.figure() 27 | self.ax1 = plt.subplot(211) 28 | plt.title('Quantum Walk in Cycle Graph,view in cycle') 29 | self.step_text1 = self.ax1.text(-1.8, 1.2, '') 30 | self.step_text1.set_text('') 31 | self.ax2 = plt.subplot(212) 32 | # self.ax2_axis=self.ax2.axis([1, self.node, 0, 1]) 33 | # self.ax2_axis.set_axis() 34 | plt.title('Quantum Walk in Cycle Graph,position 0 probability') 35 | # plt.title('Quantum Walk in Cycle Graph,position probability by step') 36 | # Then setup FuncAnimation. 37 | self.ani = animation.FuncAnimation(self.fig, self.update, frames=200, interval=500, 38 | init_func=self.setup_plot, blit=True) 39 | 40 | def setup_plot(self): 41 | """Initial drawing of the scatter plot.""" 42 | data = next(self.distri) 43 | # temp=array([data[:,2]]).T 44 | # print temp 45 | # self.linedata=column_stack((self.linedata,temp)) 46 | # print self.linedata 47 | x = data[:, 0] 48 | y = data[:, 1] 49 | d = data[:, 2] 50 | self.ax1.axis([-4.5, 4.5, -1.5, 1.5]) 51 | self.scat = self.ax1.scatter(x, y, s=d, c='red', marker='o', animated=True) 52 | 53 | self.ax2.axis([1, 5000, 0, 1]) 54 | self.line, = self.ax2.plot([], []) 55 | # For FuncAnimation's sake, we need to return the artist we'll be using 56 | # Note that it expects a sequence of artists, thus the trailing comma. 57 | return self.scat, self.line, 58 | 59 | def distribution(self): 60 | """Generate a quantum walk distribution in Cycle Graph . """ 61 | step = 1 62 | radius = 1 63 | node = self.node 64 | data = zeros([node, 3], float) 65 | Filename = 'Data/' + time.strftime('%Y%m%d-%H-%M-%S') + '.txt' 66 | distrFlie = open(Filename, 'w+') 67 | for j in range(node): 68 | data[j, 0] = sin(j * 2 * math.pi / node) * radius 69 | data[j, 1] = cos(j * 2 * math.pi / node) * radius 70 | while True: 71 | distribution = QDS.QWCicleDistribution(self.X0, self.X1, step, self.shiftGateNum, node) 72 | # data[:,2]= QDS.ciclePosiTrans(distribution, step, node) 73 | data[:, 2] = distribution 74 | # write distribution to txt file 75 | distrFlie.write(str(step) + '\t') 76 | for x in range(shape(distribution)[0]): 77 | distrFlie.write(str(distribution[x]) + '\t') 78 | distrFlie.write('\n') 79 | self.step = step 80 | print ('step: %s') % step 81 | step += 1 82 | yield data 83 | distrFlie.close() 84 | 85 | def update(self, i): 86 | """Update the scatter plot.""" 87 | data = next(self.distri) 88 | # Set x and y data... 89 | temp = array([data[:, 2]]).T 90 | # print temp 91 | self.linedata = column_stack((self.linedata, temp)) 92 | m, n = shape(self.linedata) 93 | # print self.linedata 94 | self.scat.set_offsets(data[:, :2]) 95 | # self.line.set_offsets(data[:,:2]) 96 | # Set sizes... 97 | self.scat._sizes = data[:, 2] * 200 98 | # self.line._sizes = data[:,2]*500 99 | lineResize = self.linedata.copy() 100 | lineResize.resize(1, self.step) 101 | # print lineResize[0] 102 | x = arange(1, self.step + 1) 103 | y = lineResize 104 | # print x,y 105 | self.line.set_data(x, y) 106 | 107 | self.step_text1.set_text('Setp:%s' % self.step) 108 | # self.ax2.axis([1, self.step, 0, 1]) 109 | # self.ax2_axis.set_axis([[1, self.step, 0, 1]]) 110 | # self.scat.set_title(self.Title) 111 | # Set colors.. 112 | # self.scat.set_array(data[3]) 113 | 114 | # We need to return the updated artist for FuncAnimation to draw.. 115 | # Note that it expects a sequence of artists, thus the trailing comma. 116 | return self.scat, self.line, self.step_text1, 117 | 118 | def show(self): 119 | plt.show() 120 | 121 | 122 | if __name__ == '__main__': 123 | a = AnimatedScatterQW(1, 0, 100, 3, 8) 124 | a.show() 125 | -------------------------------------------------------------------------------- /CRW.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/daihui/QuantumWalkSimulation/56b664f2de5bc06425ee15aee97d95522ae8fcfe/CRW.gif -------------------------------------------------------------------------------- /QDS-VS-DW.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/daihui/QuantumWalkSimulation/56b664f2de5bc06425ee15aee97d95522ae8fcfe/QDS-VS-DW.gif -------------------------------------------------------------------------------- /QW.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/daihui/QuantumWalkSimulation/56b664f2de5bc06425ee15aee97d95522ae8fcfe/QW.gif -------------------------------------------------------------------------------- /QWithDiffShift.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | __author__ = 'levitan' 4 | 5 | """ 6 | This is matrix release for 1D quantum walk with different shift simulation(graph). 7 | 基本过程：有一个初始量子态，coin是一个幺正变换，一次游走即coin对量子态变换一次 8 | 然后根据量子态walk一步，或几步（根据shift而定）得到一个位置概率分布，如此反复。 9 | """ 10 | 11 | from numpy import * 12 | from matplotlib import pyplot as plt 13 | import time 14 | import pylab as py 15 | from mpl_toolkits.mplot3d import Axes3D 16 | from matplotlib import animation 17 | 18 | # ------------------------------------------- 19 | # Quantum walk in line with different shift 20 | # ------------------------------------------- 21 | 22 | 23 | # 初始化量子态，是一个2*1维矩阵 24 | def initQuanStat(X0, X1): 25 | initQuanStat = zeros([2, 1], complex) 26 | initQuanStat[0][0] = X0 27 | initQuanStat[1][0] = X1 28 | return initQuanStat 29 | 30 | 31 | # 定义1D hadamard coin 32 | def hadamardCoin(): 33 | hadamardCoin = array([[1 / sqrt(2), 1 / sqrt(2)], [1 / sqrt(2), -1 / sqrt(2)]], complex) 34 | return hadamardCoin 35 | 36 | 37 | # 定义1D phase coin 38 | def phaseCoin(Psi): 39 | phaseCoin = array([[1, 0], [0, exp(1j * Psi)]], complex) 40 | return phaseCoin 41 | 42 | # 根据shift的最大值和走了的步数定义空位置矩阵 43 | def initPositionMap(steps, shiftNum, shiftGateNum): 44 | stepNum = 0 45 | for j in range(0, shiftGateNum): 46 | stepNum += power(2, j) 47 | dimension = stepNum * (steps - 1) + 1 48 | for i in range(0, shiftNum): 49 | dimension += power(2, i) 50 | positionMap = zeros([dimension, 2, 1], complex) 51 | return positionMap 52 | 53 | 54 | # 对量子态经行coin变换 55 | def coinOperator(coin, positionMap): 56 | dimension = shape(positionMap)[0] 57 | for i in range(dimension): 58 | positionMap[i] = dot(coin, positionMap[i]) 59 | return positionMap 60 | 61 | 62 | # 根据量子态进行位置变换，相当于一次walk 63 | def shiftOperator(positionMap, step, shiftGateNum): 64 | for shiftNum in range(1, shiftGateNum + 1): 65 | newPositionMap = initPositionMap(step, shiftNum, shiftGateNum) 66 | coin = hadamardCoin() 67 | coinMap = coinOperator(coin, positionMap) 68 | for i in range(shape(coinMap)[0]): 69 | newPositionMap[i][0][0] += coinMap[i][0][0] 70 | newPositionMap[i + power(2, shiftNum - 1)][1][0] += coinMap[i][1][0] 71 | positionMap = newPositionMap 72 | return newPositionMap 73 | 74 | 75 | # quantum walk 的整体封装，返回位置分布的量子态 76 | def quantumWalk(X0, X1, steps, shiftGateNum): 77 | initPositionMap = zeros([1, 2, 1], complex) 78 | initPositionMap[0] = initQuanStat(X0, X1) 79 | for step in range(1, steps + 1): 80 | positionMap = initPositionMap 81 | initPositionMap = shiftOperator(positionMap, step, shiftGateNum) 82 | return initPositionMap 83 | 84 | 85 | # 计算QW的位置分布 86 | def QWDistribution(X0, X1, steps, shiftGateNum): 87 | positionMap = quantumWalk(X0, X1, steps, shiftGateNum) 88 | dimension = shape(positionMap)[0] 89 | distribution = zeros([dimension], dtype=float) 90 | sum = 0.0 91 | for i in range(dimension): 92 | distribution[i] = float(positionMap[i][0][0].real ** 2 + positionMap[i][0][0].imag ** 2 + \ 93 | positionMap[i][1][0].real ** 2 + positionMap[i][1][0].imag ** 2) 94 | sum += distribution[i] 95 | print('sum: %s') % sum 96 | return distribution 97 | 98 | 99 | # 将结果写到文本文档 100 | def writeQWtoArray(distribution): 101 | Filename = 'Data/' + time.strftime('%Y%m%d-%H-%M-%S') + '.txt' 102 | distrFlie = open(Filename, 'w+') 103 | for x in range(shape(distribution)[0]): 104 | distrFlie.write(str(distribution[x]) + '\n') 105 | distrFlie.close() 106 | 107 | 108 | # 画出位置概率分布图 109 | def PlotX(distribution, step, figName): 110 | plt.plot(distribution) 111 | plt.title('The Distribution of %s Quantum Walk with Different Shift') % step 112 | plt.xlabel('Started from the 0') 113 | plt.ylabel('Probability') 114 | # plt.show() 115 | plt.savefig('Fig/' + str(figName) + str(step) + '.png') 116 | plt.close() 117 | 118 | 119 | # 画出QDS与QW的概率分布对比图 120 | def PlotComp(distributionQDS, distributionQW, step, figName): 121 | QDS, = plt.plot(distributionQDS, 'r') 122 | QW, = plt.plot(distributionQW, 'b') 123 | plt.axis([0, 7 * step, 0, 0.27]) 124 | plt.legend([QDS, QW, ], ['QDS', 'QW']) 125 | plt.title('The Compare between QDS and QW') 126 | plt.xlabel('X Position (started from the center)') 127 | plt.ylabel('Probability') 128 | # plt.show() 129 | plt.savefig('Fig/' + str(figName) + str(step) + '.png') 130 | plt.close() 131 | 132 | 133 | # ------------------------------------------- 134 | # Quantum walk in cicle with different shift 135 | # ------------------------------------------- 136 | def initQuanStatAverPosiCicle(X0, X1, Node): 137 | initQuanStat = zeros([Node, 2, 1], complex) 138 | for node in range(Node): 139 | initQuanStat[node][0][0] = X0 * 1 / sqrt(Node) 140 | initQuanStat[node][1][0] = X1 * 1 / sqrt(Node) 141 | return initQuanStat 142 | 143 | def positionCicleMap(node): 144 | positionCicleMap = zeros([node, 2, 1], complex) 145 | return positionCicleMap 146 | 147 | 148 | # 根据量子态进行位置变换，相当于一次walk 149 | def shiftCicleOperator(positionMap, step, shiftGateNum, node): 150 | for shiftNum in range(1, shiftGateNum + 1): 151 | newPositionMap = positionCicleMap(node) 152 | coin = hadamardCoin() 153 | coinMap = coinOperator(coin, positionMap) 154 | for i in range(node): 155 | newPositionMap[i][0][0] += coinMap[i][0][0] 156 | if (i + power(2, shiftNum - 1) >= node): 157 | newPositionMap[i + power(2, shiftNum - 1) - node][1][0] += coinMap[i][1][0] 158 | # print('loop') 159 | else: 160 | newPositionMap[i + power(2, shiftNum - 1)][1][0] += coinMap[i][1][0] 161 | positionMap = newPositionMap 162 | return newPositionMap 163 | 164 | 165 | # 加入phase coin 版本, 修正移位操作，实现complete graph 166 | def shiftCicleWithPhaseOperator(positionMap, step, shiftGateNum, node, Psi, phaseGate): 167 | # 先整体走一步 168 | moveOne = positionMap.copy() 169 | for i in range(1, node): 170 | positionMap[i] = moveOne[i - 1] 171 | positionMap[0] = moveOne[node - 1] 172 | 173 | # 根据延时门再各自走对应步数 174 | for shiftNum in range(1, shiftGateNum + 1): 175 | newPositionMap = positionCicleMap(node) 176 | HadamardCoin = hadamardCoin() 177 | PhaseCoin = phaseCoin(Psi) 178 | coinMap = coinOperator(HadamardCoin, positionMap) 179 | if shiftNum == phaseGate: 180 | newMap = coinMap.copy() 181 | coinMap = coinOperator(PhaseCoin, newMap) 182 | print 'gate:%s phase coin' % shiftNum 183 | for i in range(node): 184 | newPositionMap[i][0][0] += coinMap[i][0][0] 185 | if (i + power(2, shiftNum - 1) >= node): 186 | newPositionMap[i + power(2, shiftNum - 1) - node][1][0] += coinMap[i][1][0] 187 | # print('loop') 188 | else: 189 | newPositionMap[i + power(2, shiftNum - 1)][1][0] += coinMap[i][1][0] 190 | positionMap = newPositionMap 191 | return newPositionMap 192 | 193 | 194 | # phase coin ，complete graph with loop 195 | def shiftCicleWithPhaseLoopOperator(positionMap, step, shiftGateNum, node, Psi, phaseGate): 196 | # 根据延时门各自走对应步数 197 | for shiftNum in range(1, shiftGateNum + 1): 198 | newPositionMap = positionCicleMap(node) 199 | HadamardCoin = hadamardCoin() 200 | PhaseCoin = phaseCoin(Psi) 201 | coinMap = coinOperator(HadamardCoin, positionMap) 202 | if shiftNum == phaseGate: 203 | newMap = coinMap.copy() 204 | coinMap = coinOperator(PhaseCoin, newMap) 205 | print 'gate:%s phase coin' % shiftNum 206 | for i in range(node): 207 | newPositionMap[i][0][0] += coinMap[i][0][0] 208 | if (i + power(2, shiftNum - 1) >= node): 209 | newPositionMap[i + power(2, shiftNum - 1) - node][1][0] += coinMap[i][1][0] 210 | # print('loop') 211 | else: 212 | newPositionMap[i + power(2, shiftNum - 1)][1][0] += coinMap[i][1][0] 213 | positionMap = newPositionMap 214 | return newPositionMap 215 | 216 | 217 | # search position with marked coin ，complete graph with loop for 2 gate,4 node 218 | def shiftCicleWithPhaseLoopSearchOperator(positionMap, step, shiftGateNum, node, Psi, phaseGate): 219 | # 根据延时门各自走对应步数 220 | for shiftNum in range(1, shiftGateNum + 1): 221 | newPositionMap = positionCicleMap(node) 222 | HadamardCoin = hadamardCoin() 223 | # PhaseCoin = phaseCoin(Psi) 224 | coinMap = coinOperator(HadamardCoin, positionMap) 225 | if shiftNum == phaseGate: 226 | # print 'gate:%s phase coin' % shiftNum 227 | newPositionMap[0][0][0] += coinMap[0][0][0] 228 | newPositionMap[4][1][0] += coinMap[0][1][0] * exp(1j * Psi) 229 | newPositionMap[4][0][0] += coinMap[4][0][0] 230 | newPositionMap[0][1][0] += coinMap[4][1][0] * exp(1j * Psi) 231 | for i in range(1, node): 232 | if i == 4: 233 | print i 234 | else: 235 | newPositionMap[i][0][0] += coinMap[i][0][0] 236 | if (i + power(2, shiftNum - 1) >= node): 237 | newPositionMap[i + power(2, shiftNum - 1) - node][1][0] += coinMap[i][1][0] 238 | # print('loop') 239 | else: 240 | newPositionMap[i + power(2, shiftNum - 1)][1][0] += coinMap[i][1][0] 241 | else: 242 | for i in range(node): 243 | newPositionMap[i][0][0] += coinMap[i][0][0] 244 | if (i + power(2, shiftNum - 1) >= node): 245 | newPositionMap[i + power(2, shiftNum - 1) - node][1][0] += coinMap[i][1][0] 246 | # print('loop') 247 | else: 248 | newPositionMap[i + power(2, shiftNum - 1)][1][0] += coinMap[i][1][0] 249 | positionMap = newPositionMap 250 | return newPositionMap 251 | 252 | 253 | # search position with marked point 0，实现complete graph 254 | def shiftCicleWithPhaseSearchOperator(positionMap, step, shiftGateNum, node, Psi, phaseGate): 255 | # 先整体走一步 256 | moveOne = positionMap.copy() 257 | for i in range(1, node): 258 | positionMap[i] = moveOne[i - 1] 259 | positionMap[0] = moveOne[node - 1] 260 | 261 | # 根据延时门再各自走对应步数 262 | for shiftNum in range(1, shiftGateNum + 1): 263 | newPositionMap = positionCicleMap(node) 264 | HadamardCoin = hadamardCoin() 265 | # PhaseCoin = phaseCoin(Psi) 266 | coinMap = coinOperator(HadamardCoin, positionMap) 267 | for i in range(node): 268 | newPositionMap[i][0][0] += coinMap[i][0][0] 269 | if (i + power(2, shiftNum - 1) >= node): 270 | newPositionMap[i + power(2, shiftNum - 1) - node][1][0] += coinMap[i][1][0] 271 | # print('loop') 272 | else: 273 | newPositionMap[i + power(2, shiftNum - 1)][1][0] += coinMap[i][1][0] 274 | positionMap = newPositionMap 275 | # 标记点0，附加一个Psi的相位 276 | newPositionMap[0] = newPositionMap[0] * exp(1j * Psi) 277 | return newPositionMap 278 | 279 | 280 | # quantum walk 的整体封装，返回位置分布的量子态 281 | def quantumWalkCicle(X0, X1, steps, shiftGateNum, node): 282 | print 'begin' 283 | initPositionMap = zeros([node, 2, 1], complex) 284 | initPositionMap[0] = initQuanStat(X0, X1) 285 | for step in range(1, steps + 1): 286 | positionMap = initPositionMap 287 | initPositionMap = shiftCicleOperator(positionMap, step, shiftGateNum, node) 288 | return initPositionMap 289 | 290 | 291 | ''' 292 | Release 1, for animate plotting 293 | ''' 294 | # 计算概率分布 295 | def QWCicleDistribution(X0, X1, steps, shiftGateNum, node): 296 | positionMap = quantumWalkCicle(X0, X1, steps, shiftGateNum, node) 297 | dimension = shape(positionMap)[0] 298 | distribution = zeros([dimension], dtype=float) 299 | sum = 0.0 300 | for i in range(dimension): 301 | distribution[i] = float(positionMap[i][0][0].real ** 2 + positionMap[i][0][0].imag ** 2 + \ 302 | positionMap[i][1][0].real ** 2 + positionMap[i][1][0].imag ** 2) 303 | sum += distribution[i] 304 | print('sum: %s') % sum 305 | return distribution 306 | 307 | 308 | ''' 309 | Release 2 : for write data to txt file 310 | ''' 311 | # quantum walk in cycle graph release for write data to txt file(直接将每一步的态与分布写到文件保存) 312 | def QWCicleDistrWrite(X0, X1, steps, shiftGateNum, node): 313 | print 'begin' 314 | initPositionMap = zeros([node, 2, 1], complex) 315 | initPositionMap[0] = initQuanStat(X0, X1) 316 | DsitriFilename = 'Data/' + time.strftime('%Y%m%d-%H-%M-%S_') + 'Position' + str(shiftGateNum) + \ 317 | str(node) + str(steps) + '.txt' 318 | StateFilename = 'Data/' + time.strftime('%Y%m%d-%H-%M-%S_') + 'State' + str(shiftGateNum) + \ 319 | str(node) + str(steps) + '.txt' 320 | distrFile = open(DsitriFilename, 'w+') 321 | stateFile = open(StateFilename, 'w+') 322 | for step in range(1, steps + 1): 323 | print 'step: %s' % step 324 | positionMap = initPositionMap 325 | initPositionMap = shiftCicleOperator(positionMap, step, shiftGateNum, node) 326 | dimension = shape(initPositionMap)[0] 327 | distribution = zeros([dimension], dtype=float) 328 | sum = 0.0 329 | for i in range(dimension): 330 | distribution[i] = float(initPositionMap[i][0][0].real ** 2 + initPositionMap[i][0][0].imag ** 2 + \ 331 | initPositionMap[i][1][0].real ** 2 + initPositionMap[i][1][0].imag ** 2) 332 | sum += distribution[i] 333 | stateFile.write(str(initPositionMap[i][0][0]) + str(initPositionMap[i][1][0]) + '\t') 334 | distrFile.write(str(distribution[i]) + '\t') 335 | print('sum: %s') % sum 336 | distrFile.write('\n') 337 | stateFile.write('\n') 338 | stateFile.close() 339 | distrFile.close() 340 | print 'finish' 341 | 342 | 343 | ''' 344 | Release 3 : add phase coin and modified for complete graph 345 | ''' 346 | # quantum walk in cycle graph release for phase coin (添加phase coin，对shift operator进行了修正) 347 | def QWCicleWithPhaseDistrWrite(X0, X1, steps, shiftGateNum, node, Psi, gate): 348 | print 'begin' 349 | initPositionMap = zeros([node, 2, 1], complex) 350 | initPositionMap[0] = initQuanStat(X0, X1) 351 | # initPositionMap = initQuanStatAverPosiCicle(X0, X1,node) 352 | PositionPsiFilename = 'Data/K5_X0' + str(X0) + '_X1' + str(X1) + '_' + str(shiftGateNum) + '-' + str( 353 | node) + '_Steps' + str(steps) + '.txt' 354 | PosiFile = open(PositionPsiFilename, 'a') 355 | # DsitriFilename = 'Data/' + time.strftime('%Y%m%d-%H-%M-%S') + '_Position_' + str(shiftGateNum) + \ 356 | # str(node) + str(steps) + '.txt' 357 | # StateFilename = 'Data/' + time.strftime('%Y%m%d-%H-%M-%S') + '_State_' + str(shiftGateNum) + \ 358 | # str(node) + str(steps) + '.txt' 359 | # distrFile = open(DsitriFilename, 'w+') 360 | # stateFile = open(StateFilename, 'w+') 361 | # infoS = 'State: X0 %s X1 %s, steps: %s, shiftGateNum: %s, node: %s, Psi: %s, gate: %s\n' % ( 362 | # X0, X1, steps, shiftGateNum, node, Psi, gate) 363 | # infoD = 'State: X0 %s X1 %s, steps: %s, shiftGateNum: %s, node: %s, Psi: %s, gate: %s \n' % ( 364 | # X0, X1, steps, shiftGateNum, node, Psi, gate) 365 | # stateFile.write(infoS) 366 | # distrFile.write(infoD) 367 | for step in range(1, steps + 1): 368 | print 'step: %s' % step 369 | positionMap = initPositionMap 370 | initPositionMap = shiftCicleWithPhaseOperator(positionMap, step, shiftGateNum, node, Psi, gate) 371 | dimension = shape(initPositionMap)[0] 372 | distribution = zeros([dimension], dtype=float) 373 | sum = 0.0 374 | PosiFile.write(str(Psi) + '\t') 375 | PosiFile.write(str(step) + '\t') 376 | for i in range(dimension): 377 | distribution[i] = float(initPositionMap[i][0][0].real ** 2 + initPositionMap[i][0][0].imag ** 2 + \ 378 | initPositionMap[i][1][0].real ** 2 + initPositionMap[i][1][0].imag ** 2) 379 | sum += distribution[i] 380 | PosiFile.write(str(distribution[i]) + '\t') 381 | # stateFile.write(str(initPositionMap[i][0][0]) + str(initPositionMap[i][1][0]) + '\t') 382 | # distrFile.write(str(distribution[i]) + '\t') 383 | PosiFile.write('\n') 384 | print('sum: %s') % sum 385 | # distrFile.write('\n') 386 | # stateFile.write('\n') 387 | # stateFile.close() 388 | # distrFile.close() 389 | PosiFile.close() 390 | print 'finish' 391 | 392 | 393 | ''' 394 | Release 4 : add phase coin and modified for complete graph with loop 395 | ''' 396 | 397 | 398 | # quantum walk in cycle graph with loop release for phase coin 399 | def QWCicleWithPhaseLoopDistrWrite(X0, X1, steps, shiftGateNum, node, Psi, gate): 400 | print 'begin' 401 | initPositionMap = zeros([node, 2, 1], complex) 402 | initPositionMap[0] = initQuanStat(X0, X1) 403 | #initPositionMap=initQuanStatAverPosiCicle(X0,X1,node) 404 | DsitriFilename = 'Data/' + time.strftime('%Y%m%d-%H-%M-%S') + '_Position_' + str(shiftGateNum) + \ 405 | str(node) + str(steps) + '.txt' 406 | StateFilename = 'Data/' + time.strftime('%Y%m%d-%H-%M-%S') + '_State_' + str(shiftGateNum) + \ 407 | str(node) + str(steps) + '.txt' 408 | distrFile = open(DsitriFilename, 'w+') 409 | stateFile = open(StateFilename, 'w+') 410 | infoS = 'State: X0 %s X1 %s, steps: %s, shiftGateNum: %s, node: %s, Psi: %s, gate: %s\n' % ( 411 | X0, X1, steps, shiftGateNum, node, Psi, gate) 412 | infoD = 'State: X0 %s X1 %s, steps: %s, shiftGateNum: %s, node: %s, Psi: %s, gate: %s \n' % ( 413 | X0, X1, steps, shiftGateNum, node, Psi, gate) 414 | stateFile.write(infoS) 415 | distrFile.write(infoD) 416 | for step in range(1, steps + 1): 417 | print 'step: %s' % step 418 | positionMap = initPositionMap 419 | initPositionMap = shiftCicleWithPhaseLoopOperator(positionMap, step, shiftGateNum, node, Psi, gate) 420 | dimension = shape(initPositionMap)[0] 421 | distribution = zeros([dimension], dtype=float) 422 | sum = 0.0 423 | for i in range(dimension): 424 | distribution[i] = float(initPositionMap[i][0][0].real ** 2 + initPositionMap[i][0][0].imag ** 2 + \ 425 | initPositionMap[i][1][0].real ** 2 + initPositionMap[i][1][0].imag ** 2) 426 | sum += distribution[i] 427 | stateFile.write(str(initPositionMap[i][0][0]) + str(initPositionMap[i][1][0]) + '\t') 428 | distrFile.write(str(distribution[i]) + '\t') 429 | print('sum: %s') % sum 430 | distrFile.write('\n') 431 | stateFile.write('\n') 432 | stateFile.close() 433 | distrFile.close() 434 | print 'finish' 435 | 436 | 437 | ''' 438 | Release 5 : add phase coin and modified for complete graph with loop, write position 439 | probability file with Psi 440 | ''' 441 | 442 | 443 | # quantum walk in cycle graph with loop release for phase coin 444 | def QWCicleWithPhaseLoopDistrWritePosi(X0, X1, steps, shiftGateNum, node, Psi, gate): 445 | print 'begin' 446 | initPositionMap = zeros([node, 2, 1], complex) 447 | # initPositionMap[0] = initQuanStat(X0, X1) 448 | initPositionMap = initQuanStatAverPosiCicle(X0, X1, node) 449 | PositionPsiFilename = 'Data/Loop_X0' + str(X0) + '_X1' + str(X1) + '_' + str(shiftGateNum) + '-' + str( 450 | node) + '_Steps' + str(steps) + 'Aver.txt' 451 | PosiFile = open(PositionPsiFilename, 'a') 452 | for step in range(1, steps + 1): 453 | print 'step: %s' % step 454 | positionMap = initPositionMap 455 | initPositionMap = shiftCicleWithPhaseLoopOperator(positionMap, step, shiftGateNum, node, Psi, gate) 456 | dimension = shape(initPositionMap)[0] 457 | distribution = zeros([dimension], dtype=float) 458 | sum = 0.0 459 | for i in range(dimension): 460 | distribution[i] = float(initPositionMap[i][0][0].real ** 2 + initPositionMap[i][0][0].imag ** 2 + \ 461 | initPositionMap[i][1][0].real ** 2 + initPositionMap[i][1][0].imag ** 2) 462 | sum += distribution[i] 463 | if i == 0: 464 | PosiFile.write(str(Psi) + '\t') 465 | PosiFile.write(str(step) + '\t') 466 | PosiFile.write(str(distribution[i]) + '\n') 467 | print('sum: %s') % sum 468 | PosiFile.close() 469 | print 'finish' 470 | 471 | 472 | ''' 473 | Release 6 : Search one position by marked in complete graph with loop 474 | ''' 475 | 476 | 477 | # quantum walk search in cycle graph with loop 478 | def QWCicleWithPhaseLoopSearch(X0, X1, steps, shiftGateNum, node, Psi, gate): 479 | print 'begin' 480 | initPositionMap = zeros([node, 2, 1], complex) 481 | initPositionMap[0] = initQuanStat(X0, X1) 482 | # initPositionMap=initQuanStatAverPosiCicle(X0,X1,node) 483 | # DsitriFilename = 'Data/' + time.strftime('%Y%m%d-%H-%M-%S') + '_Search_Position_' + str(shiftGateNum) + \ 484 | # str(node) + str(steps) + '.txt' 485 | # StateFilename = 'Data/' + time.strftime('%Y%m%d-%H-%M-%S') + '_Search_State_' + str(shiftGateNum) + \ 486 | # str(node) + str(steps) + '.txt' 487 | # distrFile = open(DsitriFilename, 'w+') 488 | # stateFile = open(StateFilename, 'w+') 489 | # infoS = 'Search State: X0 %s X1 %s, steps: %s, shiftGateNum: %s, node: %s, Psi: %s, gate: %s\n' % ( 490 | # X0, X1, steps, shiftGateNum, node, Psi, gate) 491 | # infoD = 'Search State: X0 %s X1 %s, steps: %s, shiftGateNum: %s, node: %s, Psi: %s, gate: %s \n' % ( 492 | # X0, X1, steps, shiftGateNum, node, Psi, gate) 493 | # stateFile.write(infoS) 494 | # distrFile.write(infoD) 495 | PositionPsiFilename = 'Data/Loop_Search_X0' + str(X0) + '_X1' + str(X1) + '_' + str(shiftGateNum) + '-' + str( 496 | node) + '_Steps' + str(steps) + '.txt' 497 | PosiFile = open(PositionPsiFilename, 'a') 498 | for step in range(1, steps + 1): 499 | print 'step: %s' % step 500 | positionMap = initPositionMap 501 | initPositionMap = shiftCicleWithPhaseLoopSearchOperator(positionMap, step, shiftGateNum, node, Psi, gate) 502 | dimension = shape(initPositionMap)[0] 503 | distribution = zeros([dimension], dtype=float) 504 | sum = 0.0 505 | for i in range(dimension): 506 | distribution[i] = float(initPositionMap[i][0][0].real ** 2 + initPositionMap[i][0][0].imag ** 2 + \ 507 | initPositionMap[i][1][0].real ** 2 + initPositionMap[i][1][0].imag ** 2) 508 | sum += distribution[i] 509 | if i == 1: 510 | PosiFile.write(str(Psi) + '\t') 511 | PosiFile.write(str(step) + '\t') 512 | PosiFile.write(str(distribution[i]) + '\n') 513 | # stateFile.write(str(initPositionMap[i][0][0]) + str(initPositionMap[i][1][0]) + '\t') 514 | # distrFile.write(str(distribution[i]) + '\t') 515 | print('sum: %s') % sum 516 | # distrFile.write('\n') 517 | # stateFile.write('\n') 518 | # stateFile.close() 519 | # distrFile.close() 520 | PosiFile.close() 521 | print 'finish' 522 | 523 | 524 | ''' 525 | Release 7 : Search one position by marked in complete graph 526 | ''' 527 | 528 | 529 | # quantum walk in cycle graph release for phase coin (添加phase coin，对shift operator进行了修正) 530 | def QWCicleWithPhaseSearch(X0, X1, steps, shiftGateNum, node, Psi, gate): 531 | print 'begin' 532 | initPositionMap = zeros([node, 2, 1], complex) 533 | # initPositionMap[0] = initQuanStat(X0, X1) 534 | initPositionMap = initQuanStatAverPosiCicle(X0, X1, node) 535 | PositionPsiFilename = 'Data/Search mark_0 X0' + str(X0) + '_X1' + str(X1) + '_' + str(shiftGateNum) + '-' + str( 536 | node) + '_Steps' + str(steps) + 'Aver.txt' 537 | PosiFile = open(PositionPsiFilename, 'a') 538 | for step in range(1, steps + 1): 539 | print 'step: %s' % step 540 | positionMap = initPositionMap 541 | initPositionMap = shiftCicleWithPhaseSearchOperator(positionMap, step, shiftGateNum, node, Psi, gate) 542 | dimension = shape(initPositionMap)[0] 543 | distribution = zeros([dimension], dtype=float) 544 | sum = 0.0 545 | PosiFile.write(str(Psi) + '\t') 546 | PosiFile.write(str(step) + '\t') 547 | for i in range(dimension): 548 | distribution[i] = float(initPositionMap[i][0][0].real ** 2 + initPositionMap[i][0][0].imag ** 2 + \ 549 | initPositionMap[i][1][0].real ** 2 + initPositionMap[i][1][0].imag ** 2) 550 | sum += distribution[i] 551 | PosiFile.write(str(distribution[i]) + '\t') 552 | print('sum: %s') % sum 553 | PosiFile.write('\n') 554 | PosiFile.close() 555 | print 'finish' 556 | 557 | # 对位置列表进行位移，使原点保持不变 558 | #TODO 位置变换有点问题，暂时不用 559 | def ciclePosiTrans(positionMap, steps, shiftGateNum): 560 | node = shape(positionMap)[0] 561 | positionMapTrans = zeros([node], float) 562 | initNode = (power(2, shiftGateNum) - 1) * steps % node 563 | for i in range(node): 564 | positionMapTrans[i] = positionMap[(initNode + i) % node] 565 | return positionMapTrans 566 | 567 | 568 | # 画出2D位置分布图 569 | def PlotCicle(distribution, steps, shiftGateNum, figName): 570 | node = shape(distribution)[0] 571 | radius = 1 572 | x = zeros([node], float) 573 | y = zeros([node], float) 574 | for i in range(node): 575 | x[i] = sin(i * 2 * math.pi / node) * radius 576 | y[i] = cos(i * 2 * math.pi / node) * radius 577 | 578 | plt.figure(1, figsize=(20, 9)) 579 | ax1 = plt.subplot(121) 580 | plt.sca(ax1) 581 | plt.title('Distribution of %s steps Quantum Walk in Cicle' % steps) 582 | plt.xlabel('X Position') 583 | plt.ylabel('Y Position') 584 | # plt.imshow(positionMap) 585 | # plt.axis([0, 2 * int(radius) + 3, 0, 2 * int(radius) + 3]) 586 | # plt.grid(True) 587 | plt.scatter(x, y, distribution * 2000, c='r', marker='o') 588 | plt.axis([-1.5, 1.5, -1.5, 1.5]) 589 | plt.subplot(122) 590 | plt.plot(distribution) 591 | plt.axis([0, node - 1, 0, 1]) 592 | plt.title('Distribution of %s steps QW with Different Shift' % steps) 593 | plt.xlabel('Started from 0') 594 | plt.ylabel('Probability') 595 | # plt.show() 596 | plt.savefig('Fig/' + str(figName) + str(steps) + '_' + str(shiftGateNum) + '.png') 597 | plt.close() 598 | -------------------------------------------------------------------------------- /QWithDiffShiftTest.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | __author__ = 'levitan' 4 | 5 | from numpy import * 6 | from matplotlib import pyplot as plt 7 | import QWithDiffShift as QDS 8 | 9 | 10 | # distribution=QDS.QWDistribution(1/sqrt(2),1j/sqrt(2),700,1) 11 | # QDS.PlotX(distribution) 12 | 13 | def QDSPlot(X0, X1, steps, shiftGateNum): 14 | for step in range(1, steps + 1): 15 | distributionQDS = QDS.QWDistribution(X0, X1, step, shiftGateNum) 16 | distributionQW = QDS.QWDistribution(X0, X1, 7 * step, 1) 17 | QDS.PlotComp(distributionQDS, distributionQW, step, 'QDS-VS-QW-H') 18 | 19 | 20 | def QDSCPlot(X0, X1, steps, shiftGateNum, node): 21 | for step in range(1, steps + 1): 22 | distribution = QDS.QWCicleDistribution(X0, X1, step, shiftGateNum, node) 23 | distributionTrans = QDS.ciclePosiTrans(distribution, step, shiftGateNum) 24 | QDS.PlotX(distributionTrans, step, 'QDS_CT') 25 | 26 | # QDSPlot(1/sqrt(2),1j/sqrt(2),15,3) 27 | # QDSCPlot(1/sqrt(2),1j/sqrt(2),15,3,50) 28 | 29 | def QDSCiclePlot(X0, X1, steps, shiftGateNum, node): 30 | for step in range(1, steps + 1): 31 | distribution = QDS.QWCicleDistribution(X0, X1, step, shiftGateNum, node) 32 | distributionTrans = QDS.ciclePosiTrans(distribution, step, shiftGateNum) 33 | QDS.PlotCicle(distributionTrans, step, shiftGateNum, 'QDSCicle_K4_H_') 34 | 35 | 36 | def QDSCicleContourfPlot(Filename, walkSteps, PiSteps, node, point): 37 | # x,y=ogrid[0:50:PiSteps,1:200:walkSteps] 38 | x = arange(0, 2 * pi, 2 * pi / PiSteps) 39 | y = arange(0, walkSteps, 1) 40 | v = linspace(0, 1, 50, endpoint=True) 41 | # print x,shape(x) 42 | file = open(Filename, 'r') 43 | dataList = zeros([walkSteps * PiSteps, node]) 44 | i = 0 45 | for line in file.readlines(): 46 | for j in range(node): 47 | dataList[i][j] = line.split('\t')[2 + j] 48 | # print dataList[i] 49 | i += 1 50 | # print dataList[2] 51 | z = zeros([walkSteps, PiSteps], float) 52 | for yi in range(walkSteps): 53 | for xi in range(PiSteps): 54 | z[yi][xi] = float(dataList[xi * walkSteps + yi][point]) 55 | file.close() 56 | plt.figure() 57 | plt.title('Distribution of %s steps Quantum Walk in Cicle with different phase' % walkSteps) 58 | plt.xlabel('Phase') 59 | plt.ylabel('Step') 60 | plt.contourf(x, y, z, v, cmap=plt.cm.jet) 61 | x = plt.colorbar(ticks=v) 62 | print x 63 | plt.show() 64 | 65 | 66 | # QDSCiclePlot(1, 0, 10, 2, 4) 67 | # QDSPlot(1 , 0, 10, 3) 68 | # QDS.QWCicleDistrWrite(1, 0, 2000, 3, 8) 69 | # QDS.QWCicleWithPhaseDistrWrite(1/sqrt(2), 1/sqrt(2), 400, 2, 5, 0, 2) 70 | # QDS.QWCicleWithPhaseLoopDistrWrite(1/sqrt(2), 1j/sqrt(2), 200, 2, 4, pi, 2) 71 | # QDS.QWCicleWithPhaseLoopSearch(1/sqrt(2), 1/sqrt(2), 200, 3, 8, pi, 3) 72 | 73 | # for i in range(51): 74 | # QDS.QWCicleWithPhaseLoopSearch(1, 0, 200, 3, 8, 2*pi*i/50, 3) 75 | 76 | # for i in range(51): 77 | # QDS.QWCicleWithPhaseLoopDistrWritePosi(1/sqrt(2), 1/sqrt(2), 200, 2, 4, 2*pi*i/50, 2) 78 | 79 | # for i in range(51): 80 | # QDS.QWCicleWithPhaseDistrWrite(1/sqrt(2), 1/sqrt(2), 200, 2, 5, 2*pi*i/50, 2) 81 | 82 | # for i in range(51): 83 | # QDS.QWCicleWithPhaseSearch(1/sqrt(2), 1/sqrt(2), 200, 2, 4, 2*pi*i/50, 2) 84 | 85 | QDSCicleContourfPlot('Data/Search mark_0 X00.707106781187_X10.707106781187_2-4_Steps200Aver.txt', 200, 51,4,2) 86 | -------------------------------------------------------------------------------- /Quantum Walk in Graph K5.nb: -------------------------------------------------------------------------------- 1 | (* Content-type: application/vnd.wolfram.mathematica *) 2 | 3 | (*** Wolfram Notebook File ***) 4 | (* http://www.wolfram.com/nb *) 5 | 6 | (* CreatedBy='Mathematica 8.0' *) 7 | 8 | (*CacheID: 234*) 9 | (* Internal cache information: 10 | NotebookFileLineBreakTest 11 | NotebookFileLineBreakTest 12 | NotebookDataPosition[ 157, 7] 13 | NotebookDataLength[ 25108, 672] 14 | NotebookOptionsPosition[ 24822, 658] 15 | NotebookOutlinePosition[ 25167, 673] 16 | CellTagsIndexPosition[ 25124, 670] 17 | WindowFrame->Normal*) 18 | 19 | (* Beginning of Notebook Content *) 20 | Notebook[{ 21 | Cell[BoxData[ 22 | RowBox[{ 23 | RowBox[{"(*", 24 | RowBox[{ 25 | RowBox[{ 26 | RowBox[{"--", 27 | RowBox[{"--", 28 | RowBox[{"--", 29 | RowBox[{"--", 30 | RowBox[{"--", 31 | RowBox[{"--", 32 | RowBox[{"--", 33 | RowBox[{"--", 34 | RowBox[{"--", 35 | RowBox[{"--", 36 | RowBox[{"--", 37 | RowBox[{"--", 38 | RowBox[{"--", 39 | RowBox[{"--", 40 | RowBox[{"--", 41 | RowBox[{"--", 42 | RowBox[{"--", 43 | RowBox[{"--", 44 | RowBox[{"--", 45 | RowBox[{"--", 46 | RowBox[{"--", 47 | RowBox[{"--", 48 | RowBox[{"--", 49 | RowBox[{ 50 | "-", "\[IndentingNewLine]", 51 | "Quantum"}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}], 52 | " ", "Walk", " ", "Matrix", " ", 53 | RowBox[{"Simulation", " ", ":", " ", 54 | RowBox[{"Graph", " ", 55 | RowBox[{"K5", "\[IndentingNewLine]", "--"}], 56 | RowBox[{"--", 57 | RowBox[{"--", 58 | RowBox[{"--", 59 | RowBox[{"--", 60 | RowBox[{"--", 61 | RowBox[{"--", 62 | RowBox[{"--", 63 | RowBox[{"--", 64 | RowBox[{"-", 65 | RowBox[{"-", 66 | RowBox[{"-", 67 | RowBox[{"--", 68 | RowBox[{"--", 69 | RowBox[{"--", 70 | RowBox[{"--", 71 | RowBox[{"--", 72 | RowBox[{"--", 73 | RowBox[{"--", 74 | RowBox[{"--", 75 | RowBox[{"-", 76 | RowBox[{"--", 77 | RowBox[{"--", 78 | RowBox[{"-", 79 | RowBox[{"-", 80 | RowBox[{"--", 81 | RowBox[{"--", 82 | RowBox[{"--", 83 | RowBox[{"--", 84 | RowBox[{"--", 85 | RowBox[{"-", "\[IndentingNewLine]", 86 | RowBox[{"Shift", ":", " ", 87 | RowBox[{ 88 | "Shift", " ", 89 | "Matrix"}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}] 90 | }]}]}]}]}]}]}]}]}]}], ",", " ", 91 | RowBox[{"Coin", ":", " ", 92 | RowBox[{"Coin", " ", "Matrix"}]}], ",", " ", 93 | RowBox[{"\[Psi]", ":", 94 | RowBox[{"Quantum", " ", "State"}]}], ",", " ", 95 | RowBox[{"Posi", ":", 96 | RowBox[{"Position", " ", "State"}]}]}], "\[IndentingNewLine]", "*)"}], 97 | "\[IndentingNewLine]", "\[IndentingNewLine]", 98 | RowBox[{ 99 | RowBox[{ 100 | RowBox[{"\[Psi]", "=", 101 | RowBox[{ 102 | RowBox[{"{", 103 | RowBox[{ 104 | RowBox[{"{", "1", "}"}], ",", 105 | RowBox[{"{", "0", "}"}]}], "}"}], "//", "MatrixForm"}]}], " ", ";"}], 106 | "\[IndentingNewLine]", 107 | RowBox[{ 108 | RowBox[{"Posi", "=", 109 | RowBox[{ 110 | RowBox[{"{", 111 | RowBox[{ 112 | RowBox[{"{", "1", "}"}], ",", 113 | RowBox[{"{", "0", "}"}], ",", 114 | RowBox[{"{", "0", "}"}], ",", 115 | RowBox[{"{", "0", "}"}], ",", 116 | RowBox[{"{", "0", "}"}]}], "}"}], "//", "MatrixForm"}]}], ";"}], 117 | "\[IndentingNewLine]", 118 | RowBox[{ 119 | RowBox[{"ShiftMoveOne", "=", 120 | RowBox[{ 121 | RowBox[{"Transpose", "[", 122 | RowBox[{"{", 123 | RowBox[{ 124 | RowBox[{"{", 125 | RowBox[{ 126 | "0", ",", "1", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", 127 | ",", "0", ",", "0", ",", "0"}], "}"}], ",", 128 | RowBox[{"{", 129 | RowBox[{ 130 | "0", ",", "0", ",", "1", ",", "0", ",", "0", ",", "0", ",", "0", 131 | ",", "0", ",", "0", ",", "0"}], "}"}], ",", 132 | RowBox[{"{", 133 | RowBox[{ 134 | "0", ",", "0", ",", "0", ",", "1", ",", "0", ",", "0", ",", "0", 135 | ",", "0", ",", "0", ",", "0"}], "}"}], ",", 136 | RowBox[{"{", 137 | RowBox[{ 138 | "0", ",", "0", ",", "0", ",", "0", ",", "1", ",", "0", ",", "0", 139 | ",", "0", ",", "0", ",", "0"}], "}"}], ",", 140 | RowBox[{"{", 141 | RowBox[{ 142 | "1", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", 143 | ",", "0", ",", "0", ",", "0"}], "}"}], ",", 144 | RowBox[{"{", 145 | RowBox[{ 146 | "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "1", 147 | ",", "0", ",", "0", ",", "0"}], "}"}], ",", 148 | RowBox[{"{", 149 | RowBox[{ 150 | "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", 151 | ",", "1", ",", "0", ",", "0"}], "}"}], ",", 152 | RowBox[{"{", 153 | RowBox[{ 154 | "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", 155 | ",", "0", ",", "1", ",", "0"}], "}"}], ",", 156 | RowBox[{"{", 157 | RowBox[{ 158 | "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", 159 | ",", "0", ",", "0", ",", "1"}], "}"}], ",", 160 | RowBox[{"{", 161 | RowBox[{ 162 | "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "1", ",", "0", 163 | ",", "0", ",", "0", ",", "0"}], "}"}]}], "}"}], "]"}], "//", 164 | "MatrixForm"}]}], ";"}], "\[IndentingNewLine]", 165 | RowBox[{ 166 | RowBox[{"Shift1", "=", 167 | RowBox[{ 168 | RowBox[{"Transpose", "[", 169 | RowBox[{"{", 170 | RowBox[{ 171 | RowBox[{"{", 172 | RowBox[{ 173 | "1", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", 174 | ",", "0", ",", "0", ",", "0"}], "}"}], ",", 175 | RowBox[{"{", 176 | RowBox[{ 177 | "0", ",", "1", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", 178 | ",", "0", ",", "0", ",", "0"}], "}"}], ",", 179 | RowBox[{"{", 180 | RowBox[{ 181 | "0", ",", "0", ",", "1", ",", "0", ",", "0", ",", "0", ",", "0", 182 | ",", "0", ",", "0", ",", "0"}], "}"}], ",", 183 | RowBox[{"{", 184 | RowBox[{ 185 | "0", ",", "0", ",", "0", ",", "1", ",", "0", ",", "0", ",", "0", 186 | ",", "0", ",", "0", ",", "0"}], "}"}], ",", 187 | RowBox[{"{", 188 | RowBox[{ 189 | "0", ",", "0", ",", "0", ",", "0", ",", "1", ",", "0", ",", "0", 190 | ",", "0", ",", "0", ",", "0"}], "}"}], ",", 191 | RowBox[{"{", 192 | RowBox[{ 193 | "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "1", 194 | ",", "0", ",", "0", ",", "0"}], "}"}], ",", 195 | RowBox[{"{", 196 | RowBox[{ 197 | "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", 198 | ",", "1", ",", "0", ",", "0"}], "}"}], ",", 199 | RowBox[{"{", 200 | RowBox[{ 201 | "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", 202 | ",", "0", ",", "1", ",", "0"}], "}"}], ",", 203 | RowBox[{"{", 204 | RowBox[{ 205 | "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", 206 | ",", "0", ",", "0", ",", "1"}], "}"}], ",", 207 | RowBox[{"{", 208 | RowBox[{ 209 | "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "1", ",", "0", 210 | ",", "0", ",", "0", ",", "0"}], "}"}]}], "}"}], "]"}], "//", 211 | "MatrixForm"}]}], ";"}], "\[IndentingNewLine]", 212 | RowBox[{ 213 | RowBox[{"Shift2", "=", 214 | RowBox[{ 215 | RowBox[{"Transpose", "[", 216 | RowBox[{"{", 217 | RowBox[{ 218 | RowBox[{"{", 219 | RowBox[{ 220 | "1", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", 221 | ",", "0", ",", "0", ",", "0"}], "}"}], ",", 222 | RowBox[{"{", 223 | RowBox[{ 224 | "0", ",", "1", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", 225 | ",", "0", ",", "0", ",", "0"}], "}"}], ",", 226 | RowBox[{"{", 227 | RowBox[{ 228 | "0", ",", "0", ",", "1", ",", "0", ",", "0", ",", "0", ",", "0", 229 | ",", "0", ",", "0", ",", "0"}], "}"}], ",", 230 | RowBox[{"{", 231 | RowBox[{ 232 | "0", ",", "0", ",", "0", ",", "1", ",", "0", ",", "0", ",", "0", 233 | ",", "0", ",", "0", ",", "0"}], "}"}], ",", 234 | RowBox[{"{", 235 | RowBox[{ 236 | "0", ",", "0", ",", "0", ",", "0", ",", "1", ",", "0", ",", "0", 237 | ",", "0", ",", "0", ",", "0"}], "}"}], ",", 238 | RowBox[{"{", 239 | RowBox[{ 240 | "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", 241 | ",", "1", ",", "0", ",", "0"}], "}"}], ",", 242 | RowBox[{"{", 243 | RowBox[{ 244 | "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", 245 | ",", "0", ",", "1", ",", "0"}], "}"}], ",", 246 | RowBox[{"{", 247 | RowBox[{ 248 | "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", 249 | ",", "0", ",", "0", ",", "1"}], "}"}], ",", 250 | RowBox[{"{", 251 | RowBox[{ 252 | "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "1", ",", "0", 253 | ",", "0", ",", "0", ",", "0"}], "}"}], ",", 254 | RowBox[{"{", 255 | RowBox[{ 256 | "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "1", 257 | ",", "0", ",", "0", ",", "0"}], "}"}]}], "}"}], "]"}], "//", 258 | "MatrixForm"}]}], ";"}], "\[IndentingNewLine]", 259 | RowBox[{ 260 | RowBox[{"HadamardCoin1", "=", 261 | RowBox[{ 262 | TagBox[ 263 | RowBox[{"(", "\[NoBreak]", GridBox[{ 264 | { 265 | FractionBox["1", 266 | SqrtBox["2"]], "0", "0", "0", "0", 267 | FractionBox["1", 268 | SqrtBox["2"]], "0", "0", "0", "0"}, 269 | {"0", 270 | FractionBox["1", 271 | SqrtBox["2"]], "0", "0", "0", "0", 272 | FractionBox["1", 273 | SqrtBox["2"]], "0", "0", "0"}, 274 | {"0", "0", 275 | FractionBox["1", 276 | SqrtBox["2"]], "0", "0", "0", "0", 277 | FractionBox["1", 278 | SqrtBox["2"]], "0", "0"}, 279 | {"0", "0", "0", 280 | FractionBox["1", 281 | SqrtBox["2"]], "0", "0", "0", "0", 282 | FractionBox["1", 283 | SqrtBox["2"]], "0"}, 284 | {"0", "0", "0", "0", 285 | FractionBox["1", 286 | SqrtBox["2"]], "0", "0", "0", "0", 287 | FractionBox["1", 288 | SqrtBox["2"]]}, 289 | { 290 | FractionBox["1", 291 | SqrtBox["2"]], "0", "0", "0", "0", 292 | RowBox[{"-", 293 | FractionBox["1", 294 | SqrtBox["2"]]}], "0", "0", "0", "0"}, 295 | {"0", 296 | FractionBox["1", 297 | SqrtBox["2"]], "0", "0", "0", "0", 298 | RowBox[{"-", 299 | FractionBox["1", 300 | SqrtBox["2"]]}], "0", "0", "0"}, 301 | {"0", "0", 302 | FractionBox["1", 303 | SqrtBox["2"]], "0", "0", "0", "0", 304 | RowBox[{"-", 305 | FractionBox["1", 306 | SqrtBox["2"]]}], "0", "0"}, 307 | {"0", "0", "0", 308 | FractionBox["1", 309 | SqrtBox["2"]], "0", "0", "0", "0", 310 | RowBox[{"-", 311 | FractionBox["1", 312 | SqrtBox["2"]]}], "0"}, 313 | {"0", "0", "0", "0", 314 | FractionBox["1", 315 | SqrtBox["2"]], "0", "0", "0", "0", 316 | RowBox[{"-", 317 | FractionBox["1", 318 | SqrtBox["2"]]}]} 319 | }, 320 | GridBoxAlignment -> { 321 | "Columns" -> {{Center}}, "ColumnsIndexed" -> {}, 322 | "Rows" -> {{Baseline}}, "RowsIndexed" -> {}}, 323 | GridBoxSpacings -> {"Columns" -> { 324 | Offset[0.27999999999999997`], { 325 | Offset[0.7]}, 326 | Offset[0.27999999999999997`]}, "ColumnsIndexed" -> {}, "Rows" -> { 327 | Offset[0.2], { 328 | Offset[0.4]}, 329 | Offset[0.2]}, "RowsIndexed" -> {}}], "\[NoBreak]", ")"}], 330 | Function[BoxForm`e$, 331 | MatrixForm[BoxForm`e$]]], "//", "MatrixForm"}]}], ";"}], 332 | "\[IndentingNewLine]", 333 | RowBox[{ 334 | RowBox[{"HadamardCoin2", "=", 335 | RowBox[{ 336 | TagBox[ 337 | RowBox[{"(", "\[NoBreak]", GridBox[{ 338 | { 339 | FractionBox["1", 340 | SqrtBox["2"]], "0", "0", "0", "0", 341 | FractionBox["1", 342 | SqrtBox["2"]], "0", "0", "0", "0"}, 343 | {"0", 344 | FractionBox["1", 345 | SqrtBox["2"]], "0", "0", "0", "0", 346 | FractionBox["1", 347 | SqrtBox["2"]], "0", "0", "0"}, 348 | {"0", "0", 349 | FractionBox["1", 350 | SqrtBox["2"]], "0", "0", "0", "0", 351 | FractionBox["1", 352 | SqrtBox["2"]], "0", "0"}, 353 | {"0", "0", "0", 354 | FractionBox["1", 355 | SqrtBox["2"]], "0", "0", "0", "0", 356 | FractionBox["1", 357 | SqrtBox["2"]], "0"}, 358 | {"0", "0", "0", "0", 359 | FractionBox["1", 360 | SqrtBox["2"]], "0", "0", "0", "0", 361 | FractionBox["1", 362 | SqrtBox["2"]]}, 363 | { 364 | FractionBox["1", 365 | SqrtBox["2"]], "0", "0", "0", "0", 366 | RowBox[{"-", 367 | FractionBox["1", 368 | SqrtBox["2"]]}], "0", "0", "0", "0"}, 369 | {"0", 370 | FractionBox["1", 371 | SqrtBox["2"]], "0", "0", "0", "0", 372 | RowBox[{"-", 373 | FractionBox["1", 374 | SqrtBox["2"]]}], "0", "0", "0"}, 375 | {"0", "0", 376 | FractionBox["1", 377 | SqrtBox["2"]], "0", "0", "0", "0", 378 | RowBox[{"-", 379 | FractionBox["1", 380 | SqrtBox["2"]]}], "0", "0"}, 381 | {"0", "0", "0", 382 | FractionBox["1", 383 | SqrtBox["2"]], "0", "0", "0", "0", 384 | RowBox[{"-", 385 | FractionBox["1", 386 | SqrtBox["2"]]}], "0"}, 387 | {"0", "0", "0", "0", 388 | FractionBox["1", 389 | SqrtBox["2"]], "0", "0", "0", "0", 390 | RowBox[{"-", 391 | FractionBox["1", 392 | SqrtBox["2"]]}]} 393 | }, 394 | GridBoxAlignment -> { 395 | "Columns" -> {{Center}}, "ColumnsIndexed" -> {}, 396 | "Rows" -> {{Baseline}}, "RowsIndexed" -> {}}, 397 | GridBoxSpacings -> {"Columns" -> { 398 | Offset[0.27999999999999997`], { 399 | Offset[0.7]}, 400 | Offset[0.27999999999999997`]}, "ColumnsIndexed" -> {}, "Rows" -> { 401 | Offset[0.2], { 402 | Offset[0.4]}, 403 | Offset[0.2]}, "RowsIndexed" -> {}}], "\[NoBreak]", ")"}], 404 | Function[BoxForm`e$, 405 | MatrixForm[BoxForm`e$]]], "//", "MatrixForm"}]}], ";"}], 406 | "\[IndentingNewLine]", 407 | RowBox[{ 408 | RowBox[{"I2", "=", 409 | RowBox[{ 410 | RowBox[{"{", 411 | RowBox[{ 412 | RowBox[{"{", 413 | RowBox[{"1", ",", "0"}], "}"}], ",", 414 | RowBox[{"{", 415 | RowBox[{"0", ",", "1"}], "}"}]}], "}"}], "//", "MatrixForm"}]}], 416 | ";"}], "\[IndentingNewLine]", 417 | RowBox[{ 418 | RowBox[{"I5", "=", 419 | RowBox[{ 420 | RowBox[{"{", 421 | RowBox[{ 422 | RowBox[{"{", 423 | RowBox[{"1", ",", "0", ",", "0", ",", "0", ",", "0"}], "}"}], ",", 424 | RowBox[{"{", 425 | RowBox[{"0", ",", "1", ",", "0", ",", "0", ",", "0"}], "}"}], ",", 426 | RowBox[{"{", 427 | RowBox[{"0", ",", "0", ",", "1", ",", "0", ",", "0"}], "}"}], ",", 428 | RowBox[{"{", 429 | RowBox[{"0", ",", "0", ",", "0", ",", "1", ",", "0"}], "}"}], ",", 430 | RowBox[{"{", 431 | RowBox[{"0", ",", "0", ",", "0", ",", "0", ",", "1"}], "}"}]}], 432 | "}"}], "//", "MatrixForm"}]}], ";"}], "\[IndentingNewLine]", 433 | RowBox[{ 434 | RowBox[{ 435 | RowBox[{"PhaseCoin", "[", "Psi_", "]"}], ":=", 436 | RowBox[{ 437 | TagBox[ 438 | RowBox[{"(", "\[NoBreak]", GridBox[{ 439 | {"1", "0", "0", "0", "0", "0", "0", "0", "0", "0"}, 440 | {"0", "1", "0", "0", "0", "0", "0", "0", "0", "0"}, 441 | {"0", "0", "1", "0", "0", "0", "0", "0", "0", "0"}, 442 | {"0", "0", "0", "1", "0", "0", "0", "0", "0", "0"}, 443 | {"0", "0", "0", "0", "1", "0", "0", "0", "0", "0"}, 444 | {"0", "0", "0", "0", "0", 445 | SuperscriptBox["\[ExponentialE]", 446 | RowBox[{"\[ImaginaryI]", " ", "Psi"}]], "0", "0", "0", "0"}, 447 | {"0", "0", "0", "0", "0", "0", 448 | SuperscriptBox["\[ExponentialE]", 449 | RowBox[{"\[ImaginaryI]", " ", "Psi"}]], "0", "0", "0"}, 450 | {"0", "0", "0", "0", "0", "0", "0", 451 | SuperscriptBox["\[ExponentialE]", 452 | RowBox[{"\[ImaginaryI]", " ", "Psi"}]], "0", "0"}, 453 | {"0", "0", "0", "0", "0", "0", "0", "0", 454 | SuperscriptBox["\[ExponentialE]", 455 | RowBox[{"\[ImaginaryI]", " ", "Psi"}]], "0"}, 456 | {"0", "0", "0", "0", "0", "0", "0", "0", "0", 457 | SuperscriptBox["\[ExponentialE]", 458 | RowBox[{"\[ImaginaryI]", " ", "Psi"}]]} 459 | }, 460 | GridBoxAlignment -> { 461 | "Columns" -> {{Center}}, "ColumnsIndexed" -> {}, 462 | "Rows" -> {{Baseline}}, "RowsIndexed" -> {}}, 463 | GridBoxSpacings -> {"Columns" -> { 464 | Offset[0.27999999999999997`], { 465 | Offset[0.7]}, 466 | Offset[0.27999999999999997`]}, "ColumnsIndexed" -> {}, "Rows" -> { 467 | Offset[0.2], { 468 | Offset[0.4]}, 469 | Offset[0.2]}, "RowsIndexed" -> {}}], "\[NoBreak]", ")"}], 470 | Function[BoxForm`e$, 471 | MatrixForm[BoxForm`e$]]], "//", "MatrixForm"}]}], ";"}], 472 | "\[IndentingNewLine]", 473 | RowBox[{ 474 | RowBox[{"\[Phi]", "=", 475 | RowBox[{ 476 | TagBox[ 477 | RowBox[{"(", "\[NoBreak]", GridBox[{ 478 | {"1"}, 479 | {"0"}, 480 | {"0"}, 481 | {"0"}, 482 | {"0"}, 483 | {"0"}, 484 | {"0"}, 485 | {"0"}, 486 | {"0"}, 487 | {"0"} 488 | }, 489 | GridBoxAlignment -> { 490 | "Columns" -> {{Center}}, "ColumnsIndexed" -> {}, 491 | "Rows" -> {{Baseline}}, "RowsIndexed" -> {}}, 492 | GridBoxSpacings -> {"Columns" -> { 493 | Offset[0.27999999999999997`], { 494 | Offset[0.7]}, 495 | Offset[0.27999999999999997`]}, "ColumnsIndexed" -> {}, "Rows" -> { 496 | Offset[0.2], { 497 | Offset[0.4]}, 498 | Offset[0.2]}, "RowsIndexed" -> {}}], "\[NoBreak]", ")"}], 499 | Function[BoxForm`e$, 500 | MatrixForm[BoxForm`e$]]], "//", "MatrixForm"}]}], ";"}], 501 | "\[IndentingNewLine]", 502 | RowBox[{"(*", 503 | RowBox[{ 504 | "\:5b9a\:4e49K5\:7684\:53d8\:6362\:77e9\:9635U", ",", 505 | "\:4ee5\:53ca\:5e26\:76f8\:4f4dcoin\:7684UPhase"}], "*)"}], 506 | "\[IndentingNewLine]", 507 | RowBox[{ 508 | RowBox[{"U", "=", 509 | RowBox[{ 510 | RowBox[{ 511 | "ShiftMoveOne", ".", "Shift2", ".", "HadamardCoin2", ".", "Shift1", ".", 512 | "HadamardCoin1"}], "//", "MatrixForm"}]}], ";"}], 513 | "\[IndentingNewLine]", 514 | RowBox[{ 515 | RowBox[{ 516 | RowBox[{"UPhase", "[", "Psi_", "]"}], ":=", 517 | RowBox[{ 518 | RowBox[{"ShiftMoveOne", ".", 519 | RowBox[{"PhaseCoin", "[", "Psi", "]"}], ".", "Shift2", ".", 520 | "HadamardCoin2", ".", "Shift1", ".", "HadamardCoin1"}], "//", 521 | "MatrixForm"}]}], ";"}], "\[IndentingNewLine]", 522 | RowBox[{"(*", 523 | RowBox[{ 524 | RowBox[{"\:5b9a\:4e49QuantumWalkK5", " ", "\:51fd\:6570"}], "\:ff0c", 525 | "\:53c2\:6570\:4e3a\:6b65\:6570", "\:ff0c", 526 | RowBox[{ 527 | "\:7ed9\:51fa\:4f4d\:7f6e\:6001", "\[IndentingNewLine]", 528 | "\:5b9a\:4e49QuantumWalkK5Phase", " ", "\:51fd\:6570"}], "\:ff0c", 529 | "\:53c2\:6570\:4e3a\:6b65\:6570", "\:ff0c", "\:53ca\:76f8\:4f4dPsi", ",", 530 | " ", 531 | RowBox[{ 532 | RowBox[{"marked", " ", "line", " ", "\:4e3a"}], "+", 533 | RowBox[{"2", "\:7ed9\:51fa\:4f4d\:7f6e\:6001"}]}]}], 534 | "\[IndentingNewLine]", "*)"}], "\[IndentingNewLine]", 535 | RowBox[{"Clear", "[", "QuantumWalkK5", "]"}], "\[IndentingNewLine]", 536 | RowBox[{"Clear", "[", "QuantumWalkK5Phase", "]"}], "\[IndentingNewLine]", 537 | RowBox[{ 538 | RowBox[{ 539 | RowBox[{"QuantumWalkK5", "[", "0", "]"}], "=", 540 | RowBox[{ 541 | TagBox[ 542 | RowBox[{"(", "\[NoBreak]", GridBox[{ 543 | {"1"}, 544 | {"0"}, 545 | {"0"}, 546 | {"0"}, 547 | {"0"}, 548 | {"0"}, 549 | {"0"}, 550 | {"0"}, 551 | {"0"}, 552 | {"0"} 553 | }, 554 | GridBoxAlignment -> { 555 | "Columns" -> {{Center}}, "ColumnsIndexed" -> {}, 556 | "Rows" -> {{Baseline}}, "RowsIndexed" -> {}}, 557 | GridBoxSpacings -> {"Columns" -> { 558 | Offset[0.27999999999999997`], { 559 | Offset[0.7]}, 560 | Offset[0.27999999999999997`]}, "ColumnsIndexed" -> {}, "Rows" -> { 561 | Offset[0.2], { 562 | Offset[0.4]}, 563 | Offset[0.2]}, "RowsIndexed" -> {}}], "\[NoBreak]", ")"}], 564 | Function[BoxForm`e$, 565 | MatrixForm[BoxForm`e$]]], "//", "MatrixForm"}]}], ";"}], 566 | "\[IndentingNewLine]", "\[IndentingNewLine]", 567 | RowBox[{ 568 | RowBox[{ 569 | RowBox[{"QuantumWalkK5", "[", "steps_", "]"}], ":=", " ", 570 | RowBox[{ 571 | RowBox[{"QuantumWalkK5", "[", "steps", "]"}], "=", 572 | RowBox[{ 573 | RowBox[{"U", ".", 574 | RowBox[{"QuantumWalkK5", "[", 575 | RowBox[{"steps", "-", "1"}], "]"}]}], "//", "MatrixForm"}]}]}], 576 | ";"}], "\[IndentingNewLine]", 577 | RowBox[{ 578 | RowBox[{ 579 | RowBox[{"QuantumWalkK5Phase", "[", 580 | RowBox[{"0", ",", "Psi_"}], "]"}], "=", 581 | RowBox[{ 582 | TagBox[ 583 | RowBox[{"(", "\[NoBreak]", GridBox[{ 584 | {"1"}, 585 | {"0"}, 586 | {"0"}, 587 | {"0"}, 588 | {"0"}, 589 | {"0"}, 590 | {"0"}, 591 | {"0"}, 592 | {"0"}, 593 | {"0"} 594 | }, 595 | GridBoxAlignment -> { 596 | "Columns" -> {{Center}}, "ColumnsIndexed" -> {}, 597 | "Rows" -> {{Baseline}}, "RowsIndexed" -> {}}, 598 | GridBoxSpacings -> {"Columns" -> { 599 | Offset[0.27999999999999997`], { 600 | Offset[0.7]}, 601 | Offset[0.27999999999999997`]}, "ColumnsIndexed" -> {}, "Rows" -> { 602 | Offset[0.2], { 603 | Offset[0.4]}, 604 | Offset[0.2]}, "RowsIndexed" -> {}}], "\[NoBreak]", ")"}], 605 | Function[BoxForm`e$, 606 | MatrixForm[BoxForm`e$]]], "//", "MatrixForm"}]}], ";"}], 607 | "\[IndentingNewLine]", 608 | RowBox[{ 609 | RowBox[{ 610 | RowBox[{"QuantumWalkK5Phase", "[", 611 | RowBox[{"steps_", ",", "Psi_"}], "]"}], ":=", 612 | RowBox[{ 613 | RowBox[{"QuantumWalkK5Phase", "[", "steps", "]"}], "=", 614 | RowBox[{ 615 | RowBox[{ 616 | RowBox[{"UPhase", "[", "Psi", "]"}], ".", 617 | RowBox[{"QuantumWalkK5Phase", "[", 618 | RowBox[{ 619 | RowBox[{"steps", "-", "1"}], ",", "Psi"}], "]"}]}], "//", 620 | "MatrixForm"}]}]}], ";"}], "\[IndentingNewLine]"}]}]], "Input", 621 | CellChangeTimes -> {{3.6690867707743993`*^9, 3.6690868112430534`*^9}, { 622 | 3.669086870588075*^9, 3.6690869893622427`*^9}, {3.669087024571819*^9, 623 | 3.6690872861065645`*^9}, {3.6690873588917885`*^9, 3.669087360294672*^9}, { 624 | 3.6690874572237663`*^9, 3.6690875662601657`*^9}, 3.66908761280852*^9, { 625 | 3.6690879686862674`*^9, 3.6690880074249277`*^9}, {3.669088101217921*^9, 626 | 3.669088325461237*^9}, {3.669088372852105*^9, 3.6690883832183523`*^9}, 627 | 3.669088439952918*^9, {3.6690903232998047`*^9, 3.669090337348643*^9}, { 628 | 3.669090647371254*^9, 3.6690907254245033`*^9}, {3.669090757321968*^9, 629 | 3.6690908128498917`*^9}, {3.6690908635229907`*^9, 630 | 3.6690909049929028`*^9}, {3.6690910358752174`*^9, 3.669091053235268*^9}, { 631 | 3.6690911836810856`*^9, 3.669091186232604*^9}, {3.669091230074918*^9, 632 | 3.6690912895373955`*^9}, {3.6690913636040154`*^9, 633 | 3.6690913721966267`*^9}, {3.6690915232129154`*^9, 3.669091600249637*^9}, { 634 | 3.6690918844111853`*^9, 3.669091892388918*^9}, {3.6690919879595594`*^9, 635 | 3.669092094729249*^9}, {3.669092861613515*^9, 3.669092928186165*^9}, { 636 | 3.6690932126519856`*^9, 3.6690932138551655`*^9}, {3.669093308117559*^9, 637 | 3.669093343365827*^9}, {3.669093400664897*^9, 3.6690934287682705`*^9}, { 638 | 3.669093489593053*^9, 3.669093521182536*^9}, 3.6690936298262887`*^9, { 639 | 3.669093743147219*^9, 3.669093756912764*^9}, {3.669094017258934*^9, 640 | 3.6690940477867365`*^9}, {3.669094129593167*^9, 3.6690942150325317`*^9}, { 641 | 3.6690943231927776`*^9, 3.669094383961775*^9}, {3.6690944155374827`*^9, 642 | 3.6690944614739485`*^9}, {3.6690945038518915`*^9, 643 | 3.6690945061217413`*^9}, {3.6690945372191963`*^9, 644 | 3.6690945491942263`*^9}, {3.6690945962530174`*^9, 3.669094787308114*^9}, 645 | 3.6690948934357414`*^9, {3.6690949417288847`*^9, 3.6690949461002207`*^9}, { 646 | 3.6690949866302967`*^9, 3.669095007383213*^9}, {3.669095895784773*^9, 647 | 3.669095898858717*^9}, {3.6690959637508683`*^9, 3.6690959701081066`*^9}, { 648 | 3.669096159997595*^9, 3.669096216510341*^9}, {3.669096273678705*^9, 649 | 3.6690962918294325`*^9}}], 650 | 651 | Cell[BoxData[ 652 | RowBox[{"QuantumWalkK5Phase", "[", 653 | RowBox[{"2", ",", 654 | RowBox[{"Pi", "/", "2"}]}], "]"}]], "Input", 655 | CellChangeTimes -> {{3.66909481424232*^9, 3.6690948292998123`*^9}, { 656 | 3.66909603811162*^9, 3.6690960383271446`*^9}, {3.669096352675271*^9, 657 | 3.669096352944249*^9}}] 658 | }, 659 | WindowSize -> {851, 514}, 660 | WindowMargins -> {{100, Automatic}, {Automatic, 29}}, 661 | FrontEndVersion -> "8.0 for Microsoft Windows (64-bit) (November 7, 2010)", 662 | StyleDefinitions -> "Default.nb" 663 | ] 664 | (* End of Notebook Content *) 665 | 666 | (* Internal cache information *) 667 | (*CellTagsOutline 668 | CellTagsIndex->{} 669 | *) 670 | (*CellTagsIndex 671 | CellTagsIndex->{} 672 | *) 673 | (*NotebookFileOutline 674 | Notebook[{ 675 | Cell[557, 20, 23973, 628, 2094, "Input"], 676 | Cell[24533, 650, 285, 6, 31, "Input"] 677 | } 678 | ] 679 | *) 680 | 681 | (* End of internal cache information *) 682 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # 2D Quantum Walk Simulation 2 | This is a simple 2D classical random walk and quantum walk simulation project. 3 | There are two parts of simulation: 4 | 5 | - Classical Random walk 6 | 7 | See [Classical Random Walk](https://github.com/daihui/QuantumWalkSimulation/blob/master/classicalRWMat.py) 8 | 9 | - Quantum walk 10 | 11 | See [Quantum Walk](https://github.com/daihui/QuantumWalkSimulation/blob/master/quantumRWMat.py) 12 | 13 | Based on this simulation I have made two GIF which can do a intresting compare [Classical](https://github.com/daihui/QuantumWalkSimulation/blob/master/CRW.gif) VS [Quantum](https://github.com/daihui/QuantumWalkSimulation/blob/master/QW.gif) 14 | -------------------------------------------------------------------------------- /classicalRW.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | __author__ = 'levitan' 5 | import math 6 | from numpy import * 7 | import numpy as np 8 | import random 9 | from matplotlib import pyplot as plt 10 | 11 | 12 | def classicalRanNum(): 13 | coinX = int(random.choice(['1', '-1'])) 14 | coinY = int(random.choice(['1', '-1'])) 15 | return coinX, coinY 16 | 17 | 18 | # print classicalRanNum() 19 | 20 | def classicalWalkerPosition(): 21 | positionX = 0 22 | positionY = 0 23 | return positionX, positionY 24 | 25 | 26 | def classicalWalk(walkNum): 27 | walkerPositionX, walkerPositionY = classicalWalkerPosition() 28 | for i in range(0, walkNum): 29 | coinX, coinY = classicalRanNum() 30 | walkerPositionX += coinX 31 | walkerPositionY += coinY 32 | return walkerPositionX, walkerPositionY 33 | 34 | 35 | def classicalRWDistr(walkNum, matrixNum,satNum): 36 | # positionList = [] 37 | walkerCount = zeros([2 *matrixNum + 1, 2 * matrixNum + 1]) 38 | for i in range(0, satNum): 39 | walker = classicalWalk(walkNum) 40 | #print walker,walker[0],walker[1] 41 | # positionList.append(walker) 42 | walkerCount[walker[0]+matrixNum][walker[1]+matrixNum] += float(1.0 / satNum) 43 | return walkerCount 44 | 45 | def Plot2D(classcialWalker,steps): 46 | plt.figure(1) 47 | ax1=plt.subplot(111) 48 | plt.sca(ax1) 49 | plt.title('2D distribution of %s steps Classical Random Walk' %steps) 50 | plt.xlabel('X Position(started in center)') 51 | plt.ylabel('Y Position(started in center)') 52 | plt.imshow(classcialWalker) 53 | plt.savefig('Fig/CRW_' + str(steps) + '.png') 54 | plt.close() 55 | 56 | for i in range(1,11): 57 | classicalWalker=classicalRWDistr(i*10,100,100000) 58 | Plot2D(classicalWalker,i*10) -------------------------------------------------------------------------------- /classicalRWMat.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | #-*- coding: utf-8 -*- 3 | 4 | __author__ = 'levitan' 5 | 6 | """ 7 | This is a matrix release for 2D classic random walk simulation. 8 | 经典随机游走的基本过程：在一个初始位置，投一次coin（随机选择），根据coin的结果， 9 | 选择向某一个方向走一步，然后再投一次coin，周而复始。 10 | classicalRanMun():产生一个随机coin 11 | classcalWalkerPosition():walker的初始位置，设为(0,0) 12 | classicalWalk():根据参数walkNum随机游走walkNum步，返回最后位置walkerPosition 13 | classicalRWDistr():重复satNum次随机游走，得到walkerPosition的统计分布 14 | Plot2D():画图函数，画出2D的经典随机游走位置概率分布 15 | """ 16 | 17 | from numpy import * 18 | import random 19 | from matplotlib import pyplot as plt 20 | 21 | def classicalRanNum(): 22 | return mat([[random.choice([1,-1])],[random.choice([1,-1])]],int) 23 | 24 | def classicalWalkerPosition(): 25 | return mat([[0],[0]],int) 26 | 27 | def classicalWalk(walkNum): 28 | walkerPosition = classicalWalkerPosition() 29 | for i in range(0, walkNum): 30 | coin= classicalRanNum() 31 | walkerPosition+=coin 32 | return walkerPosition 33 | 34 | def classicalRWDistr(walkNum, matrixNum,satNum): 35 | walkerCount = zeros([2 *matrixNum + 1, 2 * matrixNum + 1]) 36 | for i in range(0, satNum): 37 | walker = classicalWalk(walkNum) 38 | walkerCount[int(walker[0])+matrixNum][int(walker[1])+matrixNum] += float(1.0 / satNum) 39 | return walkerCount 40 | 41 | def Plot2D(classcialWalker,steps): 42 | plt.figure(1) 43 | ax1=plt.subplot(111) 44 | plt.sca(ax1) 45 | plt.title('2D distribution of %s steps Classical Random Walk' %steps) 46 | plt.xlabel('X Position(started in center)') 47 | plt.ylabel('Y Position(started in center)') 48 | plt.imshow(classcialWalker) 49 | plt.savefig('Fig/CRW_' + str(steps) + '.png') 50 | plt.close() 51 | 52 | #for i in range(1,2): 53 | # classicalWalker=classicalRWDistr(i*10,100,100000) 54 | # Plot2D(classicalWalker,i*10) -------------------------------------------------------------------------------- /quantumRW.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | __author__ = 'levitan' 5 | 6 | from numpy import * 7 | from matplotlib import pyplot as plt 8 | import copy 9 | 10 | dimension = 1 11 | 12 | 13 | def initQuantumStateList(X0, X1, Y0, Y1, totalSteps): 14 | initquantumStateList = zeros([2 * totalSteps + 1, 2 * totalSteps + 1, 2, 2], dtype=complex) 15 | initquantumStateList[totalSteps][totalSteps][0][0] = complex(X0) 16 | initquantumStateList[totalSteps][totalSteps][0][1] = complex(X1) 17 | initquantumStateList[totalSteps][totalSteps][1][0] = complex(Y0) 18 | initquantumStateList[totalSteps][totalSteps][1][1] = complex(Y1) 19 | return initquantumStateList 20 | 21 | 22 | # print quantumState(1,1,0,0,1,1,0,0) 23 | 24 | def hadamardCoin(quantumStateList, totalSteps): 25 | global dimension 26 | for x in range(dimension): 27 | for y in range(dimension): 28 | tempState = zeros([2, 2], dtype=complex) 29 | tempState = copy.deepcopy( 30 | quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y]) 31 | quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][0][ 32 | 0] = complex((tempState[0][0] + tempState[0][1]) / sqrt(2)) 33 | quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][0][ 34 | 1] = complex((tempState[0][0] - tempState[0][1]) / sqrt(2)) 35 | quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][1][ 36 | 0] = complex((tempState[1][0] + tempState[1][1]) / sqrt(2)) 37 | quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][1][ 38 | 1] = complex((tempState[1][0] - tempState[1][1]) / sqrt(2)) 39 | # print quantumStateList 40 | return quantumStateList 41 | 42 | 43 | # qs=quantumState(0,1,0,0,0,1,0,0) 44 | # print qs 45 | # print hadamardCoin(qs) 46 | 47 | def shiftOperator(quantumStateList, totalSteps): 48 | global dimension 49 | newQuanStatList = zeros([2 * totalSteps + 1, 2 * totalSteps + 1, 2, 2], dtype=complex) 50 | for x in range(dimension): 51 | for y in range(dimension): 52 | newQuanStat1 = zeros([2, 2], dtype=complex) 53 | newQuanStat1[0][0] = \ 54 | quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][0][0] 55 | newQuanStat1[0][1] = 0.0 56 | newQuanStat1[1][0] = \ 57 | quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][1][0] 58 | newQuanStat1[1][1] = 0.0 59 | newQuanStatList[totalSteps - (dimension - 1) / 2 + x - 1][ 60 | totalSteps - (dimension - 1) / 2 + y - 1] += (newQuanStat1 / sqrt(2)) 61 | 62 | newQuanStat2 = zeros([2, 2], dtype=complex) 63 | newQuanStat2[0][0] = \ 64 | quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][0][0] 65 | newQuanStat2[0][1] = 0.0 66 | newQuanStat2[1][0] = 0.0 67 | newQuanStat2[1][1] = \ 68 | quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][1][1] 69 | newQuanStatList[totalSteps - (dimension - 1) / 2 + x - 1][ 70 | totalSteps - (dimension - 1) / 2 + y + 1] += (newQuanStat2 / sqrt(2)) 71 | 72 | newQuanStat3 = zeros([2, 2], dtype=complex) 73 | newQuanStat3[0][0] = 0.0 74 | newQuanStat3[0][1] = \ 75 | quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][0][1] 76 | newQuanStat3[1][0] = 0.0 77 | newQuanStat3[1][1] = \ 78 | quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][1][1] 79 | newQuanStatList[totalSteps - (dimension - 1) / 2 + x + 1][ 80 | totalSteps - (dimension - 1) / 2 + y + 1] += (newQuanStat3 / sqrt(2)) 81 | 82 | newQuanStat4 = zeros([2, 2], dtype=complex) 83 | newQuanStat4[0][0] = 0.0 84 | newQuanStat4[0][1] = \ 85 | quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][0][1] 86 | newQuanStat4[1][0] = \ 87 | quantumStateList[totalSteps - (dimension - 1) / 2 + x][totalSteps - (dimension - 1) / 2 + y][1][0] 88 | newQuanStat4[1][1] = 0.0 89 | newQuanStatList[totalSteps - (dimension - 1) / 2 + x + 1][ 90 | totalSteps - (dimension - 1) / 2 + y - 1] += (newQuanStat4 / sqrt(2)) 91 | dimension += 2 92 | return newQuanStatList 93 | 94 | def quantumWalker(X0, X1, Y0, Y1, totalSteps,plotSteps): 95 | global dimension 96 | initStateList = initQuantumStateList(X0, X1, Y0, Y1, totalSteps) 97 | newQuanStatList = zeros([2 * totalSteps + 1, 2 * totalSteps + 1, 2, 2], dtype=complex) 98 | shiftQuanStatList = initStateList 99 | for i in range(1,totalSteps+1): 100 | newQuanStatList = hadamardCoin(shiftQuanStatList, totalSteps) 101 | shiftQuanStatList = shiftOperator(newQuanStatList, totalSteps) 102 | if (i!=0)&(i%plotSteps == 0) : 103 | print dimension 104 | print i 105 | plotQW=distriQW(shiftQuanStatList,dimension,totalSteps) 106 | Plot2D(plotQW,i) 107 | dimension = 1 108 | return shiftQuanStatList 109 | 110 | 111 | def distriQW(quantumWalkerList, dim,totalSteps): 112 | distribution = zeros([2 * totalSteps + 1, 2 * totalSteps + 1], dtype=float) 113 | sum = 0.0 114 | # print quantumWalkerList 115 | for x in range(dim): 116 | for y in range(dim): 117 | distribution[totalSteps-(dim-1)/2+x][totalSteps-(dim-1)/2 +y] += float( 118 | abs((quantumWalkerList[totalSteps-(dim-1)/2+x][totalSteps-(dim-1)/2 +y][0][0].real ** 2 + quantumWalkerList[totalSteps-(dim-1)/2+x][totalSteps-(dim-1)/2 +y][0][0].imag ** 2)) 119 | + abs((quantumWalkerList[totalSteps-(dim-1)/2+x][totalSteps-(dim-1)/2 +y][0][1].real ** 2 + quantumWalkerList[totalSteps-(dim-1)/2+x][totalSteps-(dim-1)/2 +y][0][1].imag ** 2)) 120 | + abs((quantumWalkerList[totalSteps-(dim-1)/2+x][totalSteps-(dim-1)/2 +y][1][0].real ** 2 + quantumWalkerList[totalSteps-(dim-1)/2+x][totalSteps-(dim-1)/2 +y][1][0].imag ** 2)) 121 | + abs((quantumWalkerList[totalSteps-(dim-1)/2+x][totalSteps-(dim-1)/2 +y][1][1].real ** 2 + quantumWalkerList[totalSteps-(dim-1)/2+x][totalSteps-(dim-1)/2 +y][1][1].imag ** 2))) 122 | sum += distribution[totalSteps-dim +x][totalSteps-dim +y] 123 | print('Sum= %s' % sum) 124 | return distribution / sum 125 | 126 | 127 | def writeQWtoArray(distribution, filename): 128 | distrFlie = open(filename, 'w+') 129 | for x in range(shape(distribution)[0]): 130 | for y in range(shape(distribution)[1]): 131 | distrFlie.write(str(distribution[x][y]) + '\t') 132 | distrFlie.write('\n') 133 | distrFlie.close() 134 | 135 | 136 | def writeQWtoList(distribution, filename): 137 | distrFlie = open('Data/' + filename, 'w+') 138 | for x in range(shape(distribution)[0]): 139 | for y in range(shape(distribution)[1]): 140 | distrFlie.write(str(x) + '\t' + str(y) + '\t' + str(distribution[x][y]) + '\n') 141 | distrFlie.close() 142 | 143 | 144 | def Plot2D(qw,steps): 145 | plt.figure(1) 146 | ax1 = plt.subplot(111) 147 | plt.sca(ax1) 148 | plt.title('2D distribution of %s steps Quantum Walk with hadamard coin' %steps) 149 | plt.xlabel('X Position (started in center)') 150 | plt.ylabel('Y Position (started in center)') 151 | plt.imshow(qw) 152 | plt.savefig('Fig/QW_' + str(steps) + '.png') 153 | plt.close() 154 | 155 | 156 | def PlotX(qw, Y): 157 | qwX = qw[:][Y] 158 | plt.plot(qwX) 159 | plt.title('a Slice of 2D distribution of Quantum Walk') 160 | plt.xlabel('Position(started in %s)' % Y) 161 | plt.ylabel('Probability') 162 | plt.show() 163 | -------------------------------------------------------------------------------- /quantumRWMat.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | __author__ = 'levitan' 4 | 5 | """ 6 | This is matrix release for 2D quantum walk simulation. 7 | 量子游走的基本过程：有一个初始量子态，coin是一个幺正变换，一次游走即coin对量子态变换一次 8 | 然后根据量子态walk一步，得到一个位置概率分布，如此反复。 9 | """ 10 | 11 | from numpy import * 12 | from matplotlib import pyplot as plt 13 | 14 | 15 | # 初始化量子态，是一个对角矩阵 16 | def initQuanStat(X0, X1, Y0, Y1): 17 | initQuanStat = zeros([4, 4], complex) 18 | initQuanStat[0][0] = X0 19 | initQuanStat[1][1] = X1 20 | initQuanStat[2][2] = Y0 21 | initQuanStat[3][3] = Y1 22 | return initQuanStat 23 | 24 | 25 | # 定义2D hadamard coin，实际是2个1D Coin的直积态 26 | def hadamardCoin(): 27 | hadamardCoin = array(([1 / sqrt(2), 1 / sqrt(2), 0, 0], [1 / sqrt(2), -1 / sqrt(2), 0, 0] 28 | , [0, 0, 1 / sqrt(2), 1 / sqrt(2)], [0, 0, 1 / sqrt(2), -1 / sqrt(2)]), complex) 29 | return hadamardCoin 30 | 31 | 32 | # 根据走了的步数定义空位置矩阵 33 | def initPositionMap(steps): 34 | positionMap = zeros([2 * steps + 1, 2 * steps + 1, 4, 4], complex) 35 | return positionMap 36 | 37 | 38 | # 对量子态经行coin变换 39 | def coinOperator(positionMap, coin): 40 | dimension = shape(positionMap)[0] 41 | for i in range(dimension): 42 | for j in range(dimension): 43 | positionMap[i][j] = dot(positionMap[i][j], coin) 44 | return positionMap 45 | 46 | 47 | # 根据量子态进行位置变换，相当于一次walk 48 | def shiftOperator(coinMap, step): 49 | newPositionMap = initPositionMap(step) 50 | for i in range(2 * step - 1): 51 | for j in range(2 * step - 1): 52 | newPositionMap[i][j][0][0] += coinMap[i][j][0][0] 53 | newPositionMap[i][j][1][0] += coinMap[i][j][1][0] 54 | newPositionMap[i][j][2][2] += coinMap[i][j][2][2] 55 | newPositionMap[i][j][3][2] += coinMap[i][j][3][2] 56 | 57 | newPositionMap[i][j + 2][0][1] += coinMap[i][j][0][1] 58 | newPositionMap[i][j + 2][1][1] += coinMap[i][j][1][1] 59 | newPositionMap[i][j + 2][2][2] += coinMap[i][j][2][2] 60 | newPositionMap[i][j + 2][3][2] += coinMap[i][j][3][2] 61 | 62 | newPositionMap[i + 2][j][0][0] += coinMap[i][j][0][0] 63 | newPositionMap[i + 2][j][1][0] += coinMap[i][j][1][0] 64 | newPositionMap[i + 2][j][2][3] += coinMap[i][j][2][3] 65 | newPositionMap[i + 2][j][3][3] += coinMap[i][j][3][3] 66 | 67 | newPositionMap[i + 2][j + 2][0][1] += coinMap[i][j][0][1] 68 | newPositionMap[i + 2][j + 2][1][1] += coinMap[i][j][1][1] 69 | newPositionMap[i + 2][j + 2][2][3] += coinMap[i][j][2][3] 70 | newPositionMap[i + 2][j + 2][3][3] += coinMap[i][j][3][3] 71 | 72 | return newPositionMap 73 | 74 | 75 | # quantum walk 的整体封装，返回位置分布的量子态 76 | def quantumWalk(X0, X1, Y0, Y1, steps): 77 | initPositionMap = zeros([1, 1, 4, 4], complex) 78 | initPositionMap[0][0] = initQuanStat(X0, X1, Y0, Y1) 79 | coin = hadamardCoin() 80 | for step in range(1, steps + 1): 81 | positionMap = initPositionMap 82 | coinMap = coinOperator(positionMap, coin) 83 | initPositionMap = shiftOperator(coinMap, step) 84 | return initPositionMap 85 | 86 | 87 | # 计算QW的位置分布 88 | def QWDistribution(X0, X1, Y0, Y1, steps): 89 | positionMap = quantumWalk(X0, X1, Y0, Y1, steps) 90 | dimension = shape(positionMap)[0] 91 | distribution = zeros([dimension, dimension], dtype=float) 92 | sum = 0.0 93 | for i in range(dimension): 94 | for j in range(dimension): 95 | distribution[i][j] = float((positionMap[i][j][0][0].real ** 2 + positionMap[i][j][0][0].imag ** 2 + \ 96 | positionMap[i][j][1][0].real ** 2 + positionMap[i][j][1][0].imag ** 2 + \ 97 | positionMap[i][j][0][1].real ** 2 + positionMap[i][j][0][1].imag ** 2 + \ 98 | positionMap[i][j][1][1].real ** 2 + positionMap[i][j][1][1].imag ** 2 + \ 99 | positionMap[i][j][2][2].real ** 2 + positionMap[i][j][2][2].imag ** 2 + \ 100 | positionMap[i][j][3][2].real ** 2 + positionMap[i][j][3][2].imag ** 2 + \ 101 | positionMap[i][j][2][3].real ** 2 + positionMap[i][j][2][3].imag ** 2 + \ 102 | positionMap[i][j][3][3].real ** 2 + positionMap[i][j][3][3].imag ** 2)) 103 | sum += distribution[i][j] 104 | return distribution / sum 105 | 106 | 107 | def writeQWtoArray(distribution, filename): 108 | distrFlie = open(filename, 'w+') 109 | for x in range(shape(distribution)[0]): 110 | for y in range(shape(distribution)[1]): 111 | distrFlie.write(str(distribution[x][y]) + '\t') 112 | distrFlie.write('\n') 113 | distrFlie.close() 114 | 115 | 116 | def writeQWtoList(distribution, filename): 117 | distrFlie = open('Data/' + filename, 'w+') 118 | for x in range(shape(distribution)[0]): 119 | for y in range(shape(distribution)[1]): 120 | distrFlie.write(str(x) + '\t' + str(y) + '\t' + str(distribution[x][y]) + '\n') 121 | distrFlie.close() 122 | 123 | 124 | def Plot2D(qw, steps): 125 | plt.figure(1) 126 | ax1 = plt.subplot(111) 127 | plt.sca(ax1) 128 | plt.title('2D distribution of %s steps Quantum Walk with hadamard coin' % steps) 129 | plt.xlabel('X Position (started in center)') 130 | plt.ylabel('Y Position (started in center)') 131 | plt.imshow(qw) 132 | plt.savefig('Fig/QWM_' + str(steps) + '.png') 133 | plt.close() 134 | 135 | 136 | def PlotX(qw, Y): 137 | qwX = qw[:][Y] 138 | plt.plot(qwX) 139 | plt.title('a Slice of 2D distribution of Quantum Walk') 140 | plt.xlabel('Position(started in %s)' % Y) 141 | plt.ylabel('Probability') 142 | plt.show() 143 | -------------------------------------------------------------------------------- /quantumRWTest.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | __author__ = 'levitan' 4 | 5 | import quantumRW as QW 6 | from numpy import * 7 | from matplotlib import pyplot as plt 8 | import quantumRWMat as QWM 9 | 10 | totalSteps=100 11 | plotSteps=10 12 | # steps=50 13 | # qwalker= QW.distriQW(1/sqrt(2),1j/sqrt(2),1/sqrt(2),1j/sqrt(2),steps,1) 14 | 15 | #QW.Plot2D(qwalker) 16 | #QW.PlotX(qwalker,steps) 17 | #QW.writeQW(qwalker,'QW_'+str(steps)+'.txt') 18 | 19 | 20 | #qwalker=QW.quantumWalker(1/sqrt(2),1j/sqrt(2),1/sqrt(2),1j/sqrt(2),totalSteps,plotSteps) 21 | 22 | distribution=QWM.QWDistribution(1/sqrt(2),1j/sqrt(2),1/sqrt(2),1j/sqrt(2),100) 23 | QWM.Plot2D(distribution,100) --------------------------------------------------------------------------------