def _learnStep(self): """ Main part of the algorithm. """ I = eye(self.numParameters) self._produceSamples() utilities = self.shapingFunction(self._currentEvaluations) utilities /= sum(utilities) # make the utilities sum to 1 if self.uniformBaseline: utilities -= 1./self.batchSize samples = array(map(self._base2sample, self._population)) dCenter = dot(samples.T, utilities) covGradient = dot(array([outer(s,s) - I for s in samples]).T, utilities) covTrace = trace(covGradient) covGradient -= covTrace/self.numParameters * I dA = 0.5 * (self.scaleLearningRate * covTrace/self.numParameters * I +self.covLearningRate * covGradient) self._lastLogDetA = self._logDetA self._lastInvA = self._invA self._center += self.centerLearningRate * dot(self._A, dCenter) self._A = dot(self._A, expm2(dA)) self._invA = dot(expm2(-dA), self._invA) self._logDetA += 0.5 * self.scaleLearningRate * covTrace if self.storeAllDistributions: self._allDistributions.append((self._center.copy(), self._A.copy()))
def _learnStep(self): """ Main part of the algorithm. """ I = eye(self.numParameters) self._produceSamples() utilities = self.shapingFunction(self._currentEvaluations) utilities /= sum(utilities) # make the utilities sum to 1 if self.uniformBaseline: utilities -= 1. / self.batchSize samples = array(map(self._base2sample, self._population)) dCenter = dot(samples.T, utilities) covGradient = dot( array([outer(s, s) - I for s in samples]).T, utilities) covTrace = trace(covGradient) covGradient -= covTrace / self.numParameters * I dA = 0.5 * (self.scaleLearningRate * covTrace / self.numParameters * I + self.covLearningRate * covGradient) self._lastLogDetA = self._logDetA self._lastInvA = self._invA self._center += self.centerLearningRate * dot(self._A, dCenter) self._A = dot(self._A, expm2(dA)) self._invA = dot(expm2(-dA), self._invA) self._logDetA += 0.5 * self.scaleLearningRate * covTrace if self.storeAllDistributions: self._allDistributions.append( (self._center.copy(), self._A.copy()))
def test_consistency(self): a = array([[0., 1], [-1, 0]]) assert_array_almost_equal(expm(a), expm2(a)) assert_array_almost_equal(expm(a), expm3(a)) a = array([[1j, 1], [-1, -2j]]) assert_array_almost_equal(expm(a), expm2(a)) assert_array_almost_equal(expm(a), expm3(a))
def test_consistency(self): a = array([[0.,1],[-1,0]]) assert_array_almost_equal(expm(a), expm2(a)) assert_array_almost_equal(expm(a), expm3(a)) a = array([[1j,1],[-1,-2j]]) assert_array_almost_equal(expm(a), expm2(a)) assert_array_almost_equal(expm(a), expm3(a))
def rho(t, rho0, W, index=None): """ Calculate the probability vector at time t. :param t: The time :param rho0: Initial condition :param W: Transition matrix :type rho0: numpy 1d array :type W: numpy 2d array """ if index == None: return scipy.dot(linalg.expm2(W * t), rho0) else: return scipy.dot(linalg.expm2(W * t), rho0)[index]
def discretized_exponentials(dtau,k,c,m,values): #{{{ """ Returns a dictionary of the discretized exponentials of the constants Hamiltonian terms, as well as the exponentials of all values the decoupled potential terms can take. """ exp_dictionary['k'] = expm2(-dtau * k) exp_dictionary['c'] = expm2(-dtau * c) exp_dictionary['m'] = expm2(-dtau * m) exp_dictionary['values'] = exp(values) return exp_dictionary #}}}
def discretized_exponentials(dtau, k, c, m, values): #{{{ """ Returns a dictionary of the discretized exponentials of the constants Hamiltonian terms, as well as the exponentials of all values the decoupled potential terms can take. """ exp_dictionary['k'] = expm2(-dtau * k) exp_dictionary['c'] = expm2(-dtau * c) exp_dictionary['m'] = expm2(-dtau * m) exp_dictionary['values'] = exp(values) return exp_dictionary #}}}
def xNES(f, x0, maxEvals=1e6, verbose=False, targetFitness= -1e-10): """ Exponential NES (xNES), as described in Glasmachers, Schaul, Sun, Wierstra and Schmidhuber (GECCO'10). Maximizes a function f. Returns (best solution found, corresponding fitness). """ dim = len(x0) I = eye(dim) learningRate = 0.6 * (3 + log(dim)) / dim / sqrt(dim) batchSize = 4 + int(floor(3 * log(dim))) center = x0.copy() A = eye(dim) # sqrt of the covariance matrix numEvals = 0 bestFound = None bestFitness = -Inf while numEvals + batchSize <= maxEvals and bestFitness < targetFitness: # produce and evaluate samples samples = [randn(dim) for _ in range(batchSize)] fitnesses = [f(dot(A, s) + center) for s in samples] if max(fitnesses) > bestFitness: bestFitness = max(fitnesses) bestFound = samples[argmax(fitnesses)] numEvals += batchSize if verbose: print "Step", numEvals / batchSize, ":", max(fitnesses), "best:", bestFitness #print A # update center and variances utilities = computeUtilities(fitnesses) center += dot(A, dot(utilities, samples)) covGradient = sum([u * (outer(s, s) - I) for (s, u) in zip(samples, utilities)]) A = dot(A, expm2(0.5 * learningRate * covGradient)) return bestFound, bestFitness
def cohenpid(A,B,C,kp): m_t = 0.2 Astate = [[B,A,1],[-1,0,0],[0,-1,0]] Avar = [[-C,0,0],[0,-1,0],[0,0,-1]] forcingfunc = [[kp],[0],[0]] Amat = np.dot(linalg.inv(Astate),Avar) Bmat = np.dot(linalg.inv(Astate),forcingfunc) Xo = -1*np.dot(linalg.inv(Amat),Bmat*m_t) tfinal = 10# simulation period dt = 0.005 t = np.arange(0, tfinal, dt) entries = len(t) x = np.zeros((entries,1)) Astep = m_t Bv = kp*Astep for i in range(0,entries): X = np.dot(1 - linalg.expm2(Amat*t[i]), Xo) x[i] = X[0] t0 = 0 for j in range(0,entries-1): if np.sign(0-x[j])==0: t0 = t[j] if np.sign((0.5*Bv) - x[j]) != np.sign((0.5*Bv) -x[j+1]): t2 = np.interp(0.5*Bv,[x[j][0],x[j+1][0]],[t[j],t[j+1]]) if np.sign((0.632*Bv) - x[j]) != np.sign((0.632*Bv) -x[j+1]): t3 = np.interp(0.632*Bv,[x[j][0],x[j+1][0]],[t[j],t[j+1]]) t1 = (t2 - (np.log(2))*t3)/(1 - np.log(2)) tau = t3-t1 tdel = t1- t0 K= Bv/Astep r = tdel/tau kccc = (1/(r*K))*(0.9 + (r/12)) ticc = tdel*(30 + (3*r))/(9 + (20*r)) return kccc,ticc
def IntervalPdfFromPH(alpha, A, intBounds): """ Returns the approximate probability density function of a continuous phase-type distribution, based on the probability of falling into intervals. Parameters ---------- alpha : vector, shape (1,M) The initial probability vector of the phase-type distribution. A : matrix, shape (M,M) The transient generator matrix of the phase-type distribution. intBounds : vector, shape (K) The array of interval boundaries. The pdf is the probability of falling into an interval divided by the interval length. If the size of intBounds is K, the size of the result is K-1. prec : double, optional Numerical precision to check if the input is a valid phase-type distribution. The default value is 1e-14 Returns ------- x : matrix of doubles, shape(K-1,1) The points at which the pdf is computed. It holds the center of the intervals defined by intBounds. y : matrix of doubles, shape(K-1,1) The values of the density function at the corresponding "x" values Notes ----- This method is more suitable for comparisons with empirical density functions than the exact one (given by PdfFromPH). """ if butools.checkInput and not CheckPHRepresentation(alpha, A): raise Exception( "IntervalPdfFromPH: Input is not a valid PH representation!") steps = len(intBounds) x = [(intBounds[i + 1] + intBounds[i]) / 2.0 for i in range(steps - 1)] y = [(np.sum(alpha * expm2((A * intBounds[i]).A)) - np.sum(alpha * expm2( (A * intBounds[i + 1]).A))) / (intBounds[i + 1] - intBounds[i]) for i in range(steps - 1)] return (np.array(x), np.array(y))
def IntervalPdfFromPH (alpha, A, intBounds): """ Returns the approximate probability density function of a continuous phase-type distribution, based on the probability of falling into intervals. Parameters ---------- alpha : vector, shape (1,M) The initial probability vector of the phase-type distribution. A : matrix, shape (M,M) The transient generator matrix of the phase-type distribution. intBounds : vector, shape (K) The array of interval boundaries. The pdf is the probability of falling into an interval divided by the interval length. If the size of intBounds is K, the size of the result is K-1. prec : double, optional Numerical precision to check if the input is a valid phase-type distribution. The default value is 1e-14 Returns ------- x : matrix of doubles, shape(K-1,1) The points at which the pdf is computed. It holds the center of the intervals defined by intBounds. y : matrix of doubles, shape(K-1,1) The values of the density function at the corresponding "x" values Notes ----- This method is more suitable for comparisons with empirical density functions than the exact one (given by PdfFromPH). """ if butools.checkInput and not CheckPHRepresentation (alpha, A): raise Exception("IntervalPdfFromPH: Input is not a valid PH representation!") steps = len(intBounds) x = [(intBounds[i+1]+intBounds[i])/2.0 for i in range(steps-1)] y = [(np.sum(alpha*expm2((A*intBounds[i]).A)) - np.sum(alpha*expm2((A*intBounds[i+1]).A)))/(intBounds[i+1]-intBounds[i]) for i in range(steps-1)] return (np.array(x), np.array(y))
def get_weights(parent_params, ratemat): mapper = (parent_params > ones(len(parent_params))) weights = expm2(ratemat) m1 = weights[1, 1] m2 = weights[0, 1] if m1 == 0.0: m1 = boundprob(m1) if m2 == 0.0: m2 = boundprob(m2) return m1 * mapper + ~mapper * m2
def tell(self, samples, fitnesses): print fitnesses if max(fitnesses) > self.bestFitness: self.bestFitness = max(fitnesses) self.bestFound = samples[argmax(fitnesses)] self.numEvals += self.batchSize if self.verbose: print "Step", self.numEvals / self.batchSize, ":", max(fitnesses), "best:", self.bestFitness #print A # update center and variances utilities = self.computeUtilities(fitnesses) self.center += dot(self.A, dot(utilities, samples)) covGradient = sum([u * (outer(s, s) - self.I) for (s, u) in zip(samples, utilities)]) self.A = dot(self.A, expm2(0.5 * self.learningRate * covGradient))
def get_prob_t(pi, rates, edges_dict, edges): p_t = defaultdict() for parent, child in edges[::-1]: if args.model == "F81": p_t[parent, child] = subst_models.ptF81(pi, edges_dict[parent, child]) elif args.model == "JC": p_t[parent, child] = subst_models.ptJC(n_chars, edges_dict[parent, child]) elif args.model == "GTR": Q = subst_models.fnGTR(rates, pi) p_t[parent, child] = linalg.expm2(Q * edges_dict[parent, child]) return p_t
def Hamiltonian_timedep_complete(self, targetion, omrabi, phase, detuning, wsec, eta, hspace, LDApprox = False): """ everything in the full interaction frame of the ions including the harmonic oscillation (opposing to the original version from hartmut that still had the phonon energy nonzero) in addition, this version won't omit the exp(+- i omega_z terms t) in attached to creation/annihilation operators this is eqn 3.6 in Christian Roo's thesis. """ # H = exp(i delta_c t+phase) omega(t) (sum_i address_error_i sigma_plus_i) (exp(i eta (a exp(-i omegaz t) + adag exp(i omegaz t)))) + h.c. # !!! note !!! # here eta is assumed to be the same for all qubits. this is # not necessarily the case. #a more correct version would allow for # individual etas for each qubit ... maybe later. not # really required here and would only slow down the code targetion = targetion[::-1] # prefactor including the timedepending omega and the detuning+phase prefac = lambda t: np.exp(1j * (detuning * t + phase)) * omrabi(t) * 1/2. # coupling to the sideband. argument of the exponent/ld approximation LDpart = lambda t: 1j * eta[-1] * (hspace.operator_dict['a'] * np.exp(-1j * wsec * t ) + hspace.operator_dict['a_dag'] * np.exp(1j * wsec * t ) ) # calculate the coupling based on the addressing errors sys = np.zeros((hspace.levels**hspace.nuions,hspace.levels**hspace.nuions)) for k in xrange(hspace.nuions): sys += targetion[k]*hspace.operator_dict['raising'][:,:,k] # Lamb-Dicke approximation yes/no? # kron with qubits to get the hamiltonian if LDApprox: sys_ho = lambda t: npml.kron( sys, np.diag(np.ones(hspace.maxphonons+1)) + LDpart(t) ) else: sys_ho = lambda t: npml.kron( sys, splg.expm2( LDpart(t)) ) # multiply with rabi-frequency part H = lambda t: prefac(t) * sys_ho(t) # add h.c. part HT = lambda t: H(t)+H(t).transpose().conjugate() return HT
def tell(self, samples, fitnesses): print fitnesses if max(fitnesses) > self.bestFitness: self.bestFitness = max(fitnesses) self.bestFound = samples[argmax(fitnesses)] self.numEvals += self.batchSize if self.verbose: print "Step", self.numEvals / self.batchSize, ":", max( fitnesses), "best:", self.bestFitness #print A # update center and variances utilities = self.computeUtilities(fitnesses) self.center += dot(self.A, dot(utilities, samples)) covGradient = sum( [u * (outer(s, s) - self.I) for (s, u) in zip(samples, utilities)]) self.A = dot(self.A, expm2(0.5 * self.learningRate * covGradient))
def compute_matrix_exp(self, rate_matrix, dwell_time): """ Computes ``exp(Qt)`` Parameters ---------- rate_matrix : RateMatrix dwell_time : float Returns ------- expQt_matrix : RateMatrix """ Q = rate_matrix.as_npy_array() expQt = expm2(Q * dwell_time) expQt_matrix = rate_matrix.copy() expQt_matrix.data_frame.values[:, :] = expQt return expQt_matrix
def U_spinchain(xyz,chainlength,J,J1): #function called to get exp(-iH) where H is the spin chain hamiltonian H = 0 expH = 0 if xyz == 'z': H = J1*sigma_n('z',0,chainlength)*sigma_n('z',1,chainlength) for i in range(1,chainlength-1): H = H + J*sigma_n('z',i,chainlength)*sigma_n('z',i+1,chainlength) elif xyz == 'xy': H = J1*(sigma_n('x',0,chainlength)*sigma_n('x',1,chainlength) + sigma_n('y',0,chainlength)*sigma_n('y',1,chainlength)) for i in range(1,chainlength-1): H = H + J*(sigma_n('x',i,chainlength)*sigma_n('x',i+1,chainlength) + sigma_n('y',i,chainlength)*sigma_n('y',i+1,chainlength)) #for closed system where nth qubit interacts with first qubit #H = H + J*(sigma_n('x',chainlength-1,chainlength)*sigma_n('x',0,chainlength) + sigma_n('y',chainlength-1,chainlength)*sigma_n('y',0,chainlength)) else: print('H_spinchain: invalid input') expH = linalg.expm2(-1j*H) return expH
def compute_matrix_exp(self, rate_matrix, dwell_time): """ Computes ``exp(Qt)`` Parameters ---------- rate_matrix : RateMatrix dwell_time : float Returns ------- expQt_matrix : RateMatrix """ Q = rate_matrix.as_npy_array() expQt = expm2(Q * dwell_time) expQt_matrix = rate_matrix.copy() expQt_matrix.data_frame.values[:,:] = expQt return expQt_matrix
def system(k_c,t_i): import numpy as np tfinal = 200 dt = 0.2 t = np.arange(0, tfinal, dt) entries = len(t) x = np.zeros(entries) # k_c = np.zeros(num) # t_i = np.zeros(num) # coefficients of the transfer function Gp = kp/(s^3 + As^2 + Bs +C) A =3 B = 3 C = 1 kp =0.125 SP = 1 kcst = np.arange(0,100,dt) # Relatiopnship btwn kc and Ti obtained through the direct substitution method tist =kp*kcst*A**2/(((A*B) - C - (kp*kcst))*(C + (kp*kcst))) # kczn ,tizn =ZN(A,B,C,kp) # Ziegler-Nichols settings via function ZN kc =k_c ti = t_i firstrow =[(ti/(kp*kc)*(C + (kp*kc))), (ti/(kp*kc))*B, (ti/(kp*kc))*A, (ti/(kp*kc))] mat = [firstrow,[-1 ,0,0,0],[0,-1,0,0],[0, 0 ,-1,0]] Amat = -1*linalg.inv(mat) rootsA = np.array(linalg.eigvals(Amat)) Bmat = np.dot(linalg.inv(mat),[[1],[0] ,[0],[0]]) Xo = -1*np.dot(linalg.inv(Amat),Bmat*SP) print rootsA R = np.sign(rootsA.real) I = np.sign(rootsA.imag) if ((R==-1).all()== True): print rootsA for i in range(0,entries): X = np.dot(1 - linalg.expm2(Amat*t[i]), Xo) x[i] = X[0] else: x = None kc = k_c ti = t_i x = np.transpose(x) return {'x':x ,'kcst':kcst,'tist':tist}
def evolution(self,t=[],**karg): ''' This method returns the matrix representation of the time evolution operator. Parameters: t: 1D array-like The time mesh. karg: dict, optional Other parameters. Returns: result: 2D ndarray The matrix representation of the time evolution operator. ''' nmatrix=len(self.generators['h'].table) result=eye(nmatrix,dtype=complex128) nt=len(t) for i,time in enumerate(t): if i<nt-1: result=dot(expm2(-1j*self.matrix(t=time,**karg)*(t[i+1]-time)),result) return result
def discretize(self, A, B, mthd): if mthd == 1: # Matrix Exponential Ad = linalg.expm2(A * self.dt) eye = np.eye(4) Asinv = linalg.solve(A, eye) Bd = np.dot(np.dot(Asinv, (Ad - eye)), B) elif mthd == 2: # Zero order hold, allows A to be singular, needed for model 3 C = np.eye(self.njts * 4) D = 0 Ad, Bd, Cd, Dd, dt = spicycigs.cont2discrete((A, B, C, D), self.dt, method='bilinear') else: rospy.signal_shutdown('No discretization method selected') Ad = np.matrix(Ad) Bd = np.matrix(Bd) return Ad, Bd
def simulate(kc, ti): tfinal = 100 dt = 0.2 t = np.arange(0, tfinal, dt) entries = len(t) x = np.zeros(entries) Amat, Bmat = simulate_matrices(A, B, C, kp, kc, ti) Xo = -1*np.dot(linalg.inv(Amat), Bmat*SP) if stable(Amat): for i in range(0,entries): X = np.dot(1 - linalg.expm2(Amat*t[i]), Xo) x[i] = X[0] else: x = np.NaN x = np.transpose(x) ik = kcfunction(kc,ti,x,entries,t,tfinal,dt,SP) return x, ik
def U_spinchain(xyz, chainlength, J, J1): #function called to get exp(-iH) where H is the spin chain hamiltonian H = 0 expH = 0 if xyz == 'z': H = J1 * sigma_n('z', 0, chainlength) * sigma_n('z', 1, chainlength) for i in range(1, chainlength - 1): H = H + J * sigma_n('z', i, chainlength) * sigma_n( 'z', i + 1, chainlength) elif xyz == 'xy': H = J1 * (sigma_n('x', 0, chainlength) * sigma_n('x', 1, chainlength) + sigma_n('y', 0, chainlength) * sigma_n('y', 1, chainlength)) for i in range(1, chainlength - 1): H = H + J * (sigma_n('x', i, chainlength) * sigma_n( 'x', i + 1, chainlength) + sigma_n('y', i, chainlength) * sigma_n('y', i + 1, chainlength)) #for closed system where nth qubit interacts with first qubit #H = H + J*(sigma_n('x',chainlength-1,chainlength)*sigma_n('x',0,chainlength) + sigma_n('y',chainlength-1,chainlength)*sigma_n('y',0,chainlength)) else: print('H_spinchain: invalid input') expH = linalg.expm2(-1j * H) return expH
def start(self, maxEvals=1e6, verbose=False, target_fitness= -1e-10, sigma = 1.0, pre_iteration_hook=dummy, post_iteration_hook=dummy_x, best_found_hook=dummy_x): """ Exponential NES (xNES), as described in Glasmachers, Schaul, Sun, Wierstra and Schmidhuber (GECCO'10). Maximizes a function f. Returns (best solution found, corresponding fitness). """ I = eye(self.dim) n_iterations = 0 while self.numEvals + self.population <= maxEvals and self.bestFitness < target_fitness: pre_iteration_hook(self, self.center) # produce and evaluate samples print "n evals:", self.numEvals, self.bestFitness if verbose: print "Current mean:", self.center, "max min cov:", np.max(self.A), np.min(self.A) samples = [randn(self.dim) for _ in range(self.population / 2)] samples.extend([-s for s in samples]) realSamples = [dot(self.A, s) + self.center for s in samples] # realSamples.extend([-dot(self.A, s) + self.center for s in samples]) fitnesses = [self.f(s) for s in realSamples] if max(fitnesses) > self.bestFitness: self.bestFitness = max(fitnesses) self.bestFound = realSamples[argmax(fitnesses)].copy() best_found_hook(self.center, self.A, self.bestFound) self.numEvals += self.population if verbose: print "Step", self.numEvals / self.population, ":", max(fitnesses), "best:", self.bestFitness, realSamples[argmax(fitnesses)] #print A # update self.center and variances utilities = computeUtilities(fitnesses) self.center += dot(self.A, dot(utilities, samples)) * self.center_learning_rate covGradient = sum([u * (outer(s, s) - I) for (s, u) in zip(samples, utilities)]) self.A = dot(self.A, expm2(0.5 * self.learningRate * covGradient)) post_iteration_hook(self.center, self.A, n_iterations) n_iterations += 1 print "Step", self.numEvals / self.population, "best:", self.bestFitness return self.bestFound, self.bestFitness
def update_amplitudes(self, dt, update_ham=True, H=None, Ct=None): """Updates the amplitudes of the trajectory in the bundle. Solves d/dt C = -i H C via the computation of exp(-i H(t) dt) C(t).""" if update_ham: self.update_matrices() # if no Hamiltonian is passed, use the current effective # Hamiltonian if H is None: Hmat = self.Heff else: Hmat = H # if no vector of amplitudes are supplied (to propagate), # propagate the current amplitudes if Ct is None: old_amp = self.amplitudes() else: old_amp = Ct new_amp = np.zeros(self.nalive, dtype=complex) B = -1j * Hmat * dt if self.nalive < 150: # Eigen-decomposition umat = sp_linalg.expm2(B) else: # Pade approximation umat = sp_linalg.expm(B) new_amp = np.dot(umat, old_amp) for i in range(len(self.alive)): self.traj[self.alive[i]].update_amplitude(new_amp[i])
def Ugate(A): return Qobj(expm2(2*np.pi*i*A))
for k in range(0,num): if k==num-1: kc = kczn ti = tizn else: kc =k_c[k] ti = t_i[k] firstrow =[(ti/(kp*kc)*(C + (kp*kc))), (ti/(kp*kc))*B, (ti/(kp*kc))*A, (ti/(kp*kc))] mat = [firstrow,[-1 ,0,0,0],[0,-1,0,0],[0, 0 ,-1,0]] Amat = -1*linalg.inv(mat) rootsA = np.array(linalg.eigvals(Amat)) Bmat = np.dot(linalg.inv(mat),[[1],[0] ,[0],[0]]) Xo = -1*np.dot(linalg.inv(Amat),Bmat*SP) if (rootsA.real < 0).all(): for i in range(0,entries): X = np.dot(1 - linalg.expm2(Amat*t[i]), Xo) x[i,k] = X[0] else: x[:,k] = np.NaN k_c[k] = kc t_i[k] = ti kc = k_c ti = t_i x = x.T fig = plotgraphs(kc,ti,x,num,entries,t,tfinal,dt,SP,kcst,tist)
def Ugate(A, N): return Qobj(expm2(2 * np.pi * i * N * A))
def test_zero(self): a = array([[0.,0],[0,0]]) assert_array_almost_equal(expm(a),[[1,0],[0,1]]) assert_array_almost_equal(expm2(a),[[1,0],[0,1]]) assert_array_almost_equal(expm3(a),[[1,0],[0,1]])
def getRandomElement(self): #exp(alpha_i * A_i) should be randomly distributed #over SU(3) for random alpha_i, A_i generators of SU(3) return linalg.expm2(1j * self.GELLMANN_MATRICES.T.dot(np.random.rand(8)))
def Hamiltonian(self, pulse, params, LDApprox=True): ''' Hamiltonian definition using hspace.operator_dict ''' opdict = params.hspace.operator_dict targetion = pulse.targetion[::-1] omrabi = pulse.omrabi phase = pulse.phase detuning = pulse.detuning wsec = params.omz eta = params.eta hspace = params.hspace # prefactor including the timedepending omega and the detuning+phase prefac = np.exp(1j * phase) * omrabi * 1 / 2. # coupling to the sideband. argument of the exponent/ld approximation LDpart = 1j * eta[-1] * (opdict['a'] + opdict['a_dag']) # calculate the coupling based on the addressing errors # Lamb-Dicke approximation yes/no? # kron with qubits to get the hamiltonian # here we'll use the fact that eta may be different for each ion sys_ho = np.zeros(((hspace.maxphonons+1)*hspace.levels**hspace.nuions, \ (hspace.maxphonons+1)*hspace.levels**hspace.nuions ), \ np.complex128) if LDApprox: for k in xrange(hspace.nuions): #etak = eta[-1] if pulse.ion == -1 else eta[k] sys_ho += npml.kron( targetion[k]*opdict['raising'][:,:,k],\ np.diag(np.ones(hspace.maxphonons+1)) + \ 1j * eta[k] * (opdict['a']+opdict['a_dag']) ) else: for k in xrange(hspace.nuions): #etak = eta[-1] if pulse.ion == -1 else eta[k] sys_ho += npml.kron( targetion[k]*opdict['raising'][:,:,k],\ splg.expm2(1j * eta[k] * (opdict['a']+opdict['a_dag'])) ) # multiply with rabi-frequency part H = prefac * sys_ho # diagonal terms sysz = np.zeros( (hspace.levels**hspace.nuions, hspace.levels**hspace.nuions)) for k in xrange(hspace.nuions): sysz += opdict['sigz'][:, :, k] * 1 / 2. energies = -detuning * npml.kron(sysz, opdict['id_a']) + \ wsec * npml.kron(np.diag(np.ones(hspace.levels**hspace.nuions)), \ np.dot(opdict['a_dag'], opdict['a']) ) # subtract a zero offset energies -= np.diag(energies[0, 0] * np.ones_like(np.diag(energies))) # add h.c. part HT = H + H.transpose().conjugate() + energies # diagonal elements of matrix for basis transformation (lasertoqc) lqc = np.diag(HT) if pulse.type == 'Z': HT = HT + np.diag(self.ACshift_corr(pulse, params)) # to fix discrepancy between lab/Volkmar and here if pulse.theta < 0: HT = -HT lqc = -lqc return HT, lqc
COMPONENT1 = np.kron(COMPONENT1, pauli_x) COMPONENT2 = np.kron(COMPONENT2, pauli_y) elif u == v + 1: COMPONENT1 = np.kron(COMPONENT1, pauli_x) COMPONENT2 = np.kron(COMPONENT2, pauli_y) else: COMPONENT1 = np.kron(COMPONENT1, pauli_i) COMPONENT2 = np.kron(COMPONENT2, pauli_i) if v == 0: CHAIN1 = COMPONENT1 + COMPONENT2 else: CHAIN2 = CHAIN2 + COMPONENT1 + COMPONENT2 A = (J1 * CHAIN1 + J * CHAIN2) A = 1j * A EXP1 = linalg.expm2(-1 * A) EXP2 = linalg.expm2(A) EXP1 = np.kron(I_P, EXP1) EXP2 = np.kron(I_P, EXP2) ###################################### #INITIAL STATE INITIALCOIN = (1 / np.sqrt(2)) * np.matrix([[1], [1]]) INITIALCOIN = np.outer(INITIALCOIN, INITIALCOIN) INITIALCHAIN = np.matrix([[1, 0], [0, 0]]) SYSTEM = np.zeros((2 * STEPS + 1)) SYSTEM[STEPS + 1] = 1 SYSTEM = np.outer(SYSTEM, SYSTEM) A = np.kron(INITIALCOIN, INITIALCHAIN) for z in range(CHAINLENGTH - 2): A = np.kron(A, INITIALCHAIN) SYSTEM = np.kron(SYSTEM, A)
def Generate_Chetans_Prethermal(L, T2, J, epsilon, hz, hy, hx): print("\nUSING CHETAN's FUNCTION\n") # Hamniltonia ########## First Half of evolution # Precession term: Zprecession = np.zeros((2**L, 2**L), dtype='complex') for i in range(L): mat = iden if i == 0: mat = sigmaz for k in range(1, L): if i == k: mat = outer(sigmaz, mat) else: mat = outer(iden, mat) Zprecession += mat * (-hz) Yprecession = np.zeros((2**L, 2**L), dtype='complex') for i in range(L): mat = iden if i == 0: mat = sigmay for k in range(1, L): if i == k: mat = outer(sigmay, mat) else: mat = outer(iden, mat) Zprecession += mat * (-hy) #Interaction term interations = np.zeros((2**L, 2**L), dtype='complex') #np.identity(2**L) * wei[0] for i in range(L): j = (i + 1) % L mat = iden if i == 0 or j == 0: mat = sigmaz for k in range(1, L): if j == k or i == k: mat = outer(sigmaz, mat) else: mat = outer(iden, mat) interations += mat * (-J) ########## Second Half of evolutions Xprecession = np.zeros((2**L, 2**L), dtype='complex') for i in range(L): mat = iden if i == 0: mat = sigmax for k in range(1, L): if i == k: mat = outer(sigmax, mat) else: mat = outer(iden, mat) Xprecession += mat * np.pi / 2 * (1 + epsilon) Uf1 = slinalg.expm2( -1j * (Zprecession + interations + Yprecession + Xprecession * (1 + hx))) Uf2 = slinalg.expm2(-1j * T2 * (interations + Zprecession + hx * Xprecession)) ########## #(U, s, V) = np.linalg.svd( np.dot(Uf2, Uf1)) #print( "SVD: ", np.allclose( U.dot(np.diag(s).dot( V) ) , np.dot(Uf2, Uf1) ) ) #print( s) #print( w) #print( "SVD: ", np.allclose( U.dot(np.diag(w).dot( V_prime) ) , np.dot(Uf2, Uf1) ) ) return (v, w, np.conj(v).T, np.dot(Uf2, Uf1), res)
def Generate_Francisco(args): L = args['L'] Omega = args['Omega'] T = 2 * np.pi / Omega J = args['J'] U = args['U'] A = args['A'] * Omega dA = args['dA'] * Omega fil = args['fil'] print("\n Francisco\n") # Hamiltonian ########## First Half of evolution # Precession term: StaggeredZprecession = np.zeros((2**L, 2**L), dtype='complex64') for i in range(L): StaggeredZprecession += SigmaTerms(sigmaz, L, [i]) * (-1)**(i + 1) #print( StaggeredZprecession) #print( "" ) XXprec = np.zeros((2**L, 2**L), dtype='complex64') for i in range(L - 1): j = (i + 1) XXprec += SigmaTerms(sigmax, L, [i, j]) YYprec = np.zeros((2**L, 2**L), dtype='complex64') for i in range(L - 1): j = (i + 1) YYprec += SigmaTerms(sigmay, L, [i, j]) #print( XXprec + YYprec) #print( "") ZZprec = np.zeros((2**L, 2**L), dtype='complex64') for i in range(L - 1): j = (i + 1) ZZprec += SigmaTerms(sigmaz, L, [i, j]) #print( ZZprec) #print( "" ) LinearTerm = np.zeros((2**L, 2**L), dtype='complex64') for i in range(L): LinearTerm += SigmaTerms(sigmaz, L, [i]) * (i + 1) #print( LinearTerm) #print( "") H1 = -(J / 2) * (XXprec + YYprec) + (U / 4) * ZZprec - ( Omega - A) / 4 * StaggeredZprecession - (dA / 2) * LinearTerm H2 = -(J / 2) * (XXprec + YYprec) + (U / 4) * ZZprec - ( Omega + A) / 4 * StaggeredZprecession + (dA / 2) * LinearTerm print("H1") #print( H1) #print( "") #plt.imshow( np.abs(H1) > 1e-10) #plt.show() #plt.imshow( np.abs(H2) > 1e-10) #plt.show() st = [] for i in range(2**L): counter = 0 temp = i while i > 0: counter += i % 2 i = i / 2 if counter == L / 2: st.append(temp) print(st) print("ST: ", len(st)) for i in st: for o in range(2**L): if np.abs(H1[i][o]) > 1e-10 and (not o in st): print("PROBLEM", i, o) H1 = H1[st, :] H1 = H1[:, st] H2 = H2[st, :] H2 = H2[:, st] ## Only the columns of which are the sum of n different powers of two matter in the half-filling system. Uf1 = slinalg.expm2(-1j * T / 2 * H1) Uf2 = slinalg.expm2(-1j * T / 2 * H2) Floquet = Uf2.dot(Uf1) def xi(x): return 2 * x / np.pi * np.cos(np.pi * x / 2) / (1 - x**2) print("##########\n") print(xi((A - dA) / Omega)) print(xi((A + dA) / Omega)) print("") XXYYOdd = np.zeros((2**L, 2**L), dtype='complex64') XXYYEven = np.zeros((2**L, 2**L), dtype='complex64') for i in range(0, L - 1): j = i + 1 if (i + 1) % 2 == 0: XXYYEven += SigmaTerms(sigmax, L, [i, j]) + SigmaTerms( sigmay, L, [i, j]) else: XXYYOdd += SigmaTerms(sigmax, L, [i, j]) + SigmaTerms( sigmay, L, [i, j]) HPrethermal = -xi((A + dA) / Omega) * (XXYYEven / 2) - xi( (A - dA) / Omega) * (XXYYOdd / 2) + (U / J) * (ZZprec / 4) HPrethermal = HPrethermal / L HPrethermal = HPrethermal[:, st] HPrethermal = HPrethermal[st, :] InfTemp = np.trace(HPrethermal) (w, v) = np.linalg.eigh(HPrethermal) eigHPrethermal = w HPrethermalEigenVectors = v groundstate = np.argmin(w) print("Range of HPrethermal Hamiltonian: ", np.min(w), np.max(w)) states = [] states.append(v[:, groundstate]) rang = np.max(w) - np.min(w) delta = 0.1 for i in range(30): k = randint(0, len(st) - 1) states.append(v[:, k]) #print( len(states)) (w, v) = EigenVectorsUnitary(Floquet) w = w / np.abs(w) eigFloquet = w U = v Udag = np.conj(U).T Diag = np.array(w) # for i in range(2**L): # if np.abs(np.conj(v[:,i]).T.dot(Floquet).dot(v[:,i]) - w[i]) > 2e-6: # print( np.abs(np.conj(v[:,i]).T.dot(Floquet).dot(v[:,i]) - w[i])) # print( "PROBLEM") # for i in range(2**L): # for o in range(2**L): # if i==o: continue # else: # if np.abs(np.conj(v[:,o]).T.dot(Floquet).dot(v[:,i]) ) > 1e-6: # print( np.conj(v[:,o]).T.dot(Floquet).dot(v[:,i]) ) # print( "prob") #plt.imshow(np.log( np.abs(Udag.dot(Floquet).dot(U)) - np.eye(2**L) ) ) #print( np.max(np.abs(Udag.dot(Floquet).dot(U)) - np.eye(2**L))) #plt.show() #wa = np.angle(w) #wa.sort() #wa_ = np.angle(w_test) #wa_.sort() #print( wa) #print( "Major Difference: ", np.max(np.abs(wa-wa_))) #print( "Testing Decomposition") res = True #fig = plt.figure() #plt.imshow( np.real(Udag.dot(U) - np.eye(np.shape(Floquet)[0]))) #fig2 = plt.figure() #plt.imshow( np.real(Udag.dot(U) - np.eye(np.shape(Floquet)[0]))) print(np.max(np.abs(Udag.dot(U) - np.eye(np.shape(Floquet)[0])))) #plt.show() test1 = np.allclose(Udag.dot(U), np.eye(np.shape(Floquet)[0])) test2 = np.allclose(U.dot(Udag), np.eye(np.shape(Floquet)[0])) print(test1, test2) temp_big = np.max(np.abs(U.dot(np.diag(Diag)).dot(Udag) - Floquet)) print("Big Diff Floquet:", temp_big) Obs_0 = [] tempObs = SigmaTerms(sigmaz, L, [0]) tempObs = tempObs[:, st] tempObs = tempObs[st, :] Obs_0.append(tempObs) tempObs = SigmaTerms(sigmaz, L, [L / 4]) tempObs = tempObs[:, st] tempObs = tempObs[st, :] Obs_0.append(tempObs) tempObs = SigmaTerms(sigmaz, L, [L / 2]) tempObs = tempObs[:, st] tempObs = tempObs[st, :] Obs_0.append(tempObs) tempObs = SigmaTerms(sigmaz, L, [L - 1 - L / 4]) tempObs = tempObs[:, st] tempObs = tempObs[st, :] Obs_0.append(tempObs) tempObs = SigmaTerms(sigmaz, L, [L - 1]) tempObs = tempObs[:, st] tempObs = tempObs[st, :] Obs_0.append(tempObs) Obs_0.append(HPrethermal) HPrethermalEvo = HPrethermalEigenVectors.dot( np.diag(np.exp(-1j * T * eigHPrethermal))).dot( np.conj(HPrethermalEigenVectors).T) print("ASDASD") preComputation = { 'HPrethermal': HPrethermal, 'Floquet': Floquet, 'U': U, 'Udag': Udag, 'Diag': Diag, 'Obs': Obs_0, 'ErrorDiag': temp_big, 'res': res, 'L': L, 'InfTemp': InfTemp, 'args': args, 'HPrethermalEvo': HPrethermalEvo, 'eigHPrethermal': eigHPrethermal, 'D_U': HPrethermalEvo, 'D_Udag': np.conj(HPrethermalEvo), 'D_Diag': np.exp(-1j * T * eigHPrethermal), 'states': states } np.save(args['dir'] + 'PreComp_' + fil, preComputation) print("Finished Precomputation") print("Saved to:") print('PreComp_' + fil + '.npy') return (states, 'PreComp_' + fil + '.npy')
def Generate_Floquet_Operator(L, T, W, epsilon, eta): print("\nUSING THE FLOQUET_OPERATOR FUNCTION\n") # Hamniltonia ########## First Half of evolution # Precession term: prec = np.zeros((2**L, 2**L)) for i in range(2**L): n_ones = 0 t = i while t > 0: n_ones += t % 2 t = int(t / 2) prec[i][i] = L - 2 * n_ones prec = eta * prec #Interaction term wei = [complex(0)] for i in range(1, L): wei.append(complex(Ewald(L, i, 1))) interations = np.zeros((2**L, 2**L), dtype='complex') #np.identity(2**L) * wei[0] for i in range(L): for j in range(i + 1, L): mat = iden if i == 0: mat = sigmaz for k in range(1, L): if j == k or i == k: mat = outer(sigmaz, mat) else: mat = outer(iden, mat) interations += mat * wei[j - i] * W Uf1 = slinalg.expm2(-1j * T * (interations + prec)) ########## Second Half of evolutions SingleSpin = iden * np.cos( np.pi / 2 * (1 + epsilon)) - 1j * sigmax * np.sin(np.pi / 2 * (1 + epsilon)) Uf2 = SingleSpin for i in range(1, L): Uf2 = outer(SingleSpin, Uf2) ########## Floquet = np.dot(Uf2, Uf1) (w_t, v_t) = EigenVectorsUnitary(Floquet) (w, v) = np.linalg.eig(Floquet) res = True test = np.allclose(np.conj(v).T.dot(v), np.eye(2**L)) res = res and test print("Unitary: ", test) test = np.allclose(v.dot(np.diag(w).dot(np.conj(v).T)), np.dot(Uf2, Uf1)) res = res and test print("Decomp: ", test) test = np.allclose(v.dot(np.diag(w**2).dot(np.conj(v).T)), np.dot(Uf2, Uf1).dot(Uf2.dot(Uf1))) res = res and test print("Decomp2: ", test) test = np.allclose(v.dot(np.diag(w**3).dot(np.conj(v).T)), np.dot(Uf2, Uf1).dot(Uf2.dot(Uf1)).dot(Uf2.dot(Uf1))) res = res and test print("Decomp3: ", test) return (v, w, np.conj(v).T, np.dot(Uf2, Uf1), res)
pbeta = 0.0 Phi = (np.pi / 2.0 / alpha) ** 0.25 * np.exp(-alpha * (x - xbeta) ** 2 + 1j * pbeta * (x - xbeta) / hbar) xsorted = np.sort(x) xmin = -3 xmax = 3 xminindex = np.where(xsorted > xmin)[0][0] xmaxindex = np.where(xsorted > xmax)[0][0] p = x.argsort() fig = plt.figure(1) plt.cla() plt.ion() plt.plot(xsorted[xminindex:xmaxindex], np.real(Phi[p])[xminindex:xmaxindex], "b-") plt.draw() raw_input("") dt = 1.0 / float(N * 10) timesteps = 100 for i in range(timesteps): plt.cla() Phi = np.dot(U, np.dot(sclinalg.expm2(-1j * HDVR * dt / hbar), np.dot(Ucc, Phi))) plt.plot(xsorted[xminindex:xmaxindex], np.real(Phi[p])[xminindex:xmaxindex], "b-") plt.draw() time.sleep(0.1) plt.show()
def simulationCore(pulseseq, params, dec): """ heart of the computation process. input: pulse sequence, parameters (includes hilbert space def), and decoherence object. output: a database object containing the time evolution of states. """ np = numpy splg = scipy.linalg pi = np.pi qmtools = PyTIQC.core.qmtools simtools = PyTIQC.core.simtools # make list of times and state vector totaltime = pulseseq.totaltime T = np.append(np.arange(0, totaltime, params.stepsize), totaltime) Y = np.zeros((len(T), len(params.y0)), np.complex128) Y[0,:] = params.y0 # initialize indices and temp vars p0 = 0 # p0 is index to current pulse t0 = 0 # t0 is index to current time (in data list T) # tlen is amount of time to compute evolution ycur = np.mat(Y[0,:]).T # convert to matrix to use * tcur = 0 pcur = -1 Ucur = 1 # construct the time-dependent omrabi factors for pulse in pulseseq.seqqc: pulse.maketimedep(params.shape, params.doMSshapingCorr) # initialize the hamiltonian and noise objects ht = qmtools.Hamilton() ns = qmtools.Noise() # pre-fetch the noise dictionary if dec.doRandNtimes > 0: noise_dict = ns.Noise(params, dec) noise_total = [[noise_dict['none'][0]], [noise_dict['none'][1]], [noise_dict['none'][2]]] for key, [mult, add, uni] in noise_dict.iteritems(): if (dec.dict['all'] or dec.dict[key]): # and not pulse.use_ideal: noise_total[0].append(mult) noise_total[1].append(add) noise_total[2].append(uni) noise_mult = ns.prodFunctions(noise_total[0]) noise_add = ns.sumFunctions(noise_total[1]) noise_uni = ns.sumFunctions(noise_total[2]) projtimes = np.union1d(T[np.nonzero(dec.heatingV)], T[np.nonzero(dec.spontdecayV)]) else: noise_mult = lambda t: 1 noise_add = lambda t: params.hspace.operator_dict['zero'] noise_uni = lambda t: params.hspace.operator_dict['zero'] projtimes = np.array([]) # storage of hidden ions hiddenions = np.zeros_like(params.addressing[-1]) hiddenionsErr = np.ones_like(params.addressing[-1]) hiddenionsCount = 0 # a classical register to store intermediate measurements classical_reg = [] if totaltime == 0: #set Y=y0 if no time for evolution Y[0,:] = params.y0 else: ### time evolution starts here while(tcur < totaltime): ### new pulse starts here pulse = pulseseq.seqqc[p0] if pcur != p0: pcur = p0 HTsaved = None if params.printpulse: print "Pulse ", p0, ":", pulse if params.progbar and pulseseq.seqqc[p0].type != 'M': widgets = [progressbar.Percentage(), ' ', progressbar.Bar(),' ', progressbar.ETA()] pbar = progressbar.ProgressBar(widgets=widgets).start() ################# # check for hiding. modify hiding matrix, then treat as delay nuions = params.hspace.nuions if pulse.type == "H": hiddenionsCount += 1 if pulse.hide: hiddenions[nuions-pulse.ion-1] = params.addressing[-1][pulse.ion] else: hiddenions[nuions-pulse.ion-1] = 0 hiddenionsErr[nuions-pulse.ion-1] *= params.hidingerr else: pulse.targetion[np.nonzero(hiddenions)] = 0 if dec.dict['all'] or dec.dict['hiding']: # with some probability some ions are "lost" after unhiding rn = np.random.uniform( size= \ len(np.nonzero(hiddenionsErr-1)[0]) ) for ith, ind in enumerate(np.nonzero(hiddenionsErr-1)[0]): if rn[ith] > hiddenionsErr[np.nonzero(hiddenionsErr-1)[0][ith]]: pulse.targetion[ind] = 0 else: pulse.targetion = \ np.copy(params.addressing[pulse.ion]) pulse.calculateIdealUnitary(params, np.nonzero(hiddenions[::-1])[0]) # check for meas-init. measure and do projection, then treat as delay. if pulse.type == "I": if (dec.dict['all'] or dec.dict['hiding']) \ and pulse.incl_hidingerr: reg = pulse.measure(np.asarray(ycur)) reg[1] += hiddenionsCount*params.hidingMeaserr reg[0] -= hiddenionsCount*params.hidingMeaserr classical_reg.append( reg ) else: classical_reg.append( pulse.measure(np.asarray(ycur)) ) Uproj = pulse.Uinit() U = np.mat(Uproj) ynew = U * ycur ynew = ynew / np.sqrt(np.sum(np.power(abs(ynew),2))) ycur = ynew ################# # check for Uideal and skip time evolution if yes if pulse.use_ideal: ynew = np.dot(pulse.Uid, ycur) ycur = ynew tcur = pulse.endtime # save data and advance pulse t0 = np.searchsorted(T, tcur) if tcur == T[t0]: Y[t0,:] = np.asarray(ynew.T) else: T = np.insert(T, t0, tcur) [Yn1, Yn2] = np.array_split(Y, [t0]) if len(Yn2) != 0: Y = np.concatenate([Yn1, np.asarray(ynew.T), Yn2], axis=0) else: Y = np.concatenate([Yn1, np.asarray(ynew.T)], axis=0) t0 = t0 + 1 p0 = p0 + 1 ################# #### Unitary evolutions elif not pulse.dotimedepPulse and not params.dotimedep: assert tcur >= pulse.starttime \ and tcur <= pulse.endtime \ and abs(pulse.starttime + pulse.duration - pulse.endtime) < 0.001 \ and pulse.duration >= 0, \ "Pulse timing not consistent; missing copy.deepcopy?" tlen = min([pulseseq.seqqc[p0].endtime - tcur, T[t0+1]-tcur]) [HT, lqc] = ht.Hamiltonian(pulse, params, LDApprox = params.LDapproximation) if not pulse.use_ideal: HT = noise_mult(tcur) * HT + noise_add(tcur) lqc = noise_mult(tcur) * lqc + np.diag(noise_add(tcur)) Ugate = splg.expm2(-1j * tlen * HT) Ulqc1 = np.diag(np.exp(-1j * tcur * lqc)) Ulqc2 = np.diag(np.exp(-1j * (-tlen-tcur) * lqc)) U = np.mat(Ulqc2) * np.mat(Ugate) * np.mat(Ulqc1) ynew = U * ycur # normalize in case of jump operators for spontdecay and heating ynew = ynew / np.sqrt(np.sum(np.power(abs(ynew),2))) Ucur = U * Ucur # extra check for projective unitary (spontdecay, heating) if dec.doRandNtimes > 0 and np.sum(noise_uni(tcur)) != 0 \ and not pulse.use_ideal: U = np.mat(noise_uni(tcur)) ynew = U * ycur ynew = ynew / np.sqrt(np.sum(np.power(abs(ynew),2))) ycur = ynew if abs(ynew[-1])**2 > 0.25: print "Warning: further heating will exceed phonon space" ycur = ynew tcur = tcur+tlen # if reached data-point, store data and advance time datasaved = False if tcur == T[t0+1]: Y[t0+1,:] = np.asarray(ynew.T) t0 = t0 + 1 datasaved = True if params.printpulse and params.progbar and pulseseq.seqqc[p0].type != 'M': pbar.update(int(1.*(tcur-pulseseq.seqqc[p0].starttime)*100 \ /(pulseseq.seqqc[p0].duration))) # if pulse ended, advance to next pulse (if both then do both) if tcur == pulseseq.seqqc[p0].endtime: pulseseq.seqqc[p0].U = np.copy(np.asarray(Ucur)) # save current data if not already saved if not datasaved: T = np.insert(T, t0+1, tcur) [Yn1, Yn2] = np.array_split(Y, [t0+1]) Y = np.concatenate([Yn1, np.asarray(ynew.T), Yn2], axis=0) t0 = t0 + 1 # advance to next pulse p0 = p0 + 1 Ucur = 1 ################# #### Time-dependent HT: ODE solving else: # choose time step depending on detuning if pulseseq.seqqc[p0].detuning > 2*pi*2: stepduration = min(2/ (pulseseq.seqqc[p0].detuning/(2*pi)), 1) else: stepduration = params.ODEtimestep # for MS pulse, check and modify omrabi due to hiding if pulse.type == "M" and params.doMShidecorr: nuions = len(pulse.targetion) activeions = len(np.nonzero(pulse.targetion)[0]) omc_fac = params.MShidecorr[activeions, nuions] if omc_fac == -1: print "MS w/ hiding correction factor invalid, ignoring" else: pulse.omrabi_b = params.omc_ms * omc_fac pulse.omrabi_r = params.omc_ms * omc_fac # set up time-dep Hamiltonian if pulse.dobichro: HTblue = ht.Hamiltonian_timedep_complete(pulse.targetion, pulse.omrabi_bt, pulse.phase_light + pulse.phase_rb, pulse.detuning_b, params.omz, params.eta, params.hspace, LDApprox = params.LDapproximation) HTred = ht.Hamiltonian_timedep_complete(pulse.targetion, pulse.omrabi_rt, pulse.phase_light - pulse.phase_rb, pulse.detuning_r, params.omz, params.eta, params.hspace, LDApprox = params.LDapproximation) HTorig = lambda t: HTblue(t) + HTred(t) else: HTorig = ht.Hamiltonian_timedep_complete(pulse.targetion, pulse.omrabi_t , pulse.phase, pulse.detuning, params.omz, params.eta, params.hspace, LDApprox = params.LDapproximation) HT = lambda t: noise_mult(t) * HTorig(t) + noise_add(t) psidot = lambda t,psi: -1j * np.dot(HT(t), psi) # ycur needs to be cast as a 1d array solver = qmtools.SEsolver(params.solver) Tloc = np.array([0.]) Yloc = np.zeros([1,len(np.asarray(ycur))]) # this is to get the dimensions right, but make sure to remove the first row of 0's if params.progbar: widgets = [progressbar.Percentage(), ' ', progressbar.Bar(),' ', progressbar.ETA()] pbar = progressbar.ProgressBar(widgets=widgets).start() else: pbar = None # ODE solver # variable aliases for convenience pstarttime = pulseseq.seqqc[p0].starttime pendtime = pulseseq.seqqc[p0].endtime # first calculate the expected number of datapoints testtime = np.arange(tcur, pendtime, stepduration) testtime = np.append(np.delete(testtime, 0), pendtime) # extra check for projective unitary (spontdecay, heating) projtimes_cur = projtimes[np.intersect1d( \ np.nonzero(projtimes<pendtime)[0], \ np.nonzero(projtimes>pstarttime)[0]) ] for tproj in projtimes_cur: ms_ode = solver(HT, tcur, tproj, stepduration, np.ravel(ycur), \ pbar, pstarttime, pendtime) Tloc = np.append(Tloc, np.delete(ms_ode.time, 0)) Yloc = np.append(Yloc, np.delete(ms_ode.y.transpose(), 0, axis=0), axis=0) tcur = tproj ycur = Yloc[-1,:].T if dec.doRandNtimes > 0 and np.sum(noise_uni(tcur)) != 0 \ and not pulse.use_ideal: U = noise_uni(tcur) ynew = np.dot(U, ycur) ynew = ynew / np.sqrt(np.sum(np.power(abs(ynew),2))) ycur = ynew if abs(ynew[-1])**2 > 0.25: print "Warning: further heating will exceed phonon space" Yloc[-1,:] = np.asarray(ynew.T) ms_ode = solver(HT, tcur, pendtime, stepduration, np.ravel(ycur), \ pbar, pstarttime, pendtime) Tloc = np.append(Tloc, np.delete(ms_ode.time, 0)) Yloc = np.append(Yloc, np.delete(ms_ode.y.transpose(), 0, axis=0), axis=0) Tloc = np.delete(Tloc, 0) Yloc = np.delete(Yloc, 0, axis=0) # check the length w.r.t. expected length of T vector and remove extras while len(Tloc) > len(testtime): for i in range(len(testtime)): if testtime[i] != Tloc[i]: Tloc = np.delete(Tloc, i) Yloc = np.delete(Yloc, i, axis=0) break if not params.saveallpoints: Tloc = [Tloc[-1]] Yloc = np.array([Yloc[-1]]) # now we put the result into original result array # first, update the current time and state tcur = Tloc[-1] ycur = np.mat(Yloc[-1,:]).T # find the end of the pulse in the original T list t1 = np.nonzero(T >= tcur)[0][0] # only replace point if it's already been calculated if T[t1] == tcur: tend = t1+1 else: # T[t1] > tcur tend = t1 # replace the overlapping times in T with Tloc [Tnew1, Tnew2] = np.array_split( np.delete(T, range(t0+1, tend)) , [t0+1]) Tnew = np.concatenate([Tnew1, Tloc, Tnew2]) # mirror with Y and Yloc [Ynew1, Ynew2] = np.array_split( np.delete(Y, range(t0+1, tend), axis=0) , [t0+1]) # seems that concatenate doesn't work on 2d arrays if they're empty if len(Ynew2) == 0: Ynew = np.concatenate([Ynew1, Yloc], axis=0) else: Ynew = np.concatenate([Ynew1, Yloc, Ynew2], axis=0) T = Tnew Y = Ynew p0 = p0 + 1 t0 = np.nonzero(T >= tcur)[0][0] data = simtools.database(T,Y, params.hspace, pulseseq, register=classical_reg) data.creationtime = params.savedataname # timestamp the data if dec.doSQL: sequel.insertJobToDB(data) # get rid of lambda functions in order to send results back through pp for pulse in pulseseq.seqqc: pulse.omrabi_t = 0 pulse.omrabi_bt = 0 pulse.omrabi_rt = 0 return data
def simulationCore(pulseseq, params, dec): """ heart of the computation process. input: pulse sequence, parameters (includes hilbert space def), and decoherence object. output: a database object containing the time evolution of states. """ np = numpy splg = scipy.linalg pi = np.pi qmtools = PyTIQC.core.qmtools simtools = PyTIQC.core.simtools # make list of times and state vector totaltime = pulseseq.totaltime T = np.append(np.arange(0, totaltime, params.stepsize), totaltime) Y = np.zeros((len(T), len(params.y0)), np.complex128) Y[0, :] = params.y0 # initialize indices and temp vars p0 = 0 # p0 is index to current pulse t0 = 0 # t0 is index to current time (in data list T) # tlen is amount of time to compute evolution ycur = np.mat(Y[0, :]).T # convert to matrix to use * tcur = 0 pcur = -1 Ucur = 1 # construct the time-dependent omrabi factors for pulse in pulseseq.seqqc: pulse.maketimedep(params.shape, params.doMSshapingCorr) # initialize the hamiltonian and noise objects ht = qmtools.Hamilton() ns = qmtools.Noise() # pre-fetch the noise dictionary if dec.doRandNtimes > 0: noise_dict = ns.Noise(params, dec) noise_total = [[noise_dict['none'][0]], [noise_dict['none'][1]], [noise_dict['none'][2]]] for key, [mult, add, uni] in noise_dict.iteritems(): if (dec.dict['all'] or dec.dict[key]): # and not pulse.use_ideal: noise_total[0].append(mult) noise_total[1].append(add) noise_total[2].append(uni) noise_mult = ns.prodFunctions(noise_total[0]) noise_add = ns.sumFunctions(noise_total[1]) noise_uni = ns.sumFunctions(noise_total[2]) projtimes = np.union1d(T[np.nonzero(dec.heatingV)], T[np.nonzero(dec.spontdecayV)]) else: noise_mult = lambda t: 1 noise_add = lambda t: params.hspace.operator_dict['zero'] noise_uni = lambda t: params.hspace.operator_dict['zero'] projtimes = np.array([]) # storage of hidden ions hiddenions = np.zeros_like(params.addressing[-1]) hiddenionsErr = np.ones_like(params.addressing[-1]) hiddenionsCount = 0 # a classical register to store intermediate measurements classical_reg = [] if totaltime == 0: #set Y=y0 if no time for evolution Y[0, :] = params.y0 else: ### time evolution starts here while (tcur < totaltime): ### new pulse starts here pulse = pulseseq.seqqc[p0] if pcur != p0: pcur = p0 HTsaved = None if params.printpulse: print "Pulse ", p0, ":", pulse if params.progbar and pulseseq.seqqc[p0].type != 'M': widgets = [ progressbar.Percentage(), ' ', progressbar.Bar(), ' ', progressbar.ETA() ] pbar = progressbar.ProgressBar(widgets=widgets).start() ################# # check for hiding. modify hiding matrix, then treat as delay nuions = params.hspace.nuions if pulse.type == "H": hiddenionsCount += 1 if pulse.hide: hiddenions[nuions - pulse.ion - 1] = params.addressing[-1][pulse.ion] else: hiddenions[nuions - pulse.ion - 1] = 0 hiddenionsErr[nuions - pulse.ion - 1] *= params.hidingerr else: pulse.targetion[np.nonzero(hiddenions)] = 0 if dec.dict['all'] or dec.dict['hiding']: # with some probability some ions are "lost" after unhiding rn = np.random.uniform( size= \ len(np.nonzero(hiddenionsErr-1)[0]) ) for ith, ind in enumerate( np.nonzero(hiddenionsErr - 1)[0]): if rn[ith] > hiddenionsErr[np.nonzero( hiddenionsErr - 1)[0][ith]]: pulse.targetion[ind] = 0 else: pulse.targetion = \ np.copy(params.addressing[pulse.ion]) pulse.calculateIdealUnitary( params, np.nonzero(hiddenions[::-1])[0]) # check for meas-init. measure and do projection, then treat as delay. if pulse.type == "I": if (dec.dict['all'] or dec.dict['hiding']) \ and pulse.incl_hidingerr: reg = pulse.measure(np.asarray(ycur)) reg[1] += hiddenionsCount * params.hidingMeaserr reg[0] -= hiddenionsCount * params.hidingMeaserr classical_reg.append(reg) else: classical_reg.append(pulse.measure(np.asarray(ycur))) Uproj = pulse.Uinit() U = np.mat(Uproj) ynew = U * ycur ynew = ynew / np.sqrt(np.sum(np.power(abs(ynew), 2))) ycur = ynew ################# # check for Uideal and skip time evolution if yes if pulse.use_ideal: ynew = np.dot(pulse.Uid, ycur) ycur = ynew tcur = pulse.endtime # save data and advance pulse t0 = np.searchsorted(T, tcur) if tcur == T[t0]: Y[t0, :] = np.asarray(ynew.T) else: T = np.insert(T, t0, tcur) [Yn1, Yn2] = np.array_split(Y, [t0]) if len(Yn2) != 0: Y = np.concatenate([Yn1, np.asarray(ynew.T), Yn2], axis=0) else: Y = np.concatenate([Yn1, np.asarray(ynew.T)], axis=0) t0 = t0 + 1 p0 = p0 + 1 ################# #### Unitary evolutions elif not pulse.dotimedepPulse and not params.dotimedep: assert tcur >= pulse.starttime \ and tcur <= pulse.endtime \ and abs(pulse.starttime + pulse.duration - pulse.endtime) < 0.001 \ and pulse.duration >= 0, \ "Pulse timing not consistent; missing copy.deepcopy?" tlen = min( [pulseseq.seqqc[p0].endtime - tcur, T[t0 + 1] - tcur]) [HT, lqc] = ht.Hamiltonian(pulse, params, LDApprox=params.LDapproximation) if not pulse.use_ideal: HT = noise_mult(tcur) * HT + noise_add(tcur) lqc = noise_mult(tcur) * lqc + np.diag(noise_add(tcur)) Ugate = splg.expm2(-1j * tlen * HT) Ulqc1 = np.diag(np.exp(-1j * tcur * lqc)) Ulqc2 = np.diag(np.exp(-1j * (-tlen - tcur) * lqc)) U = np.mat(Ulqc2) * np.mat(Ugate) * np.mat(Ulqc1) ynew = U * ycur # normalize in case of jump operators for spontdecay and heating ynew = ynew / np.sqrt(np.sum(np.power(abs(ynew), 2))) Ucur = U * Ucur # extra check for projective unitary (spontdecay, heating) if dec.doRandNtimes > 0 and np.sum(noise_uni(tcur)) != 0 \ and not pulse.use_ideal: U = np.mat(noise_uni(tcur)) ynew = U * ycur ynew = ynew / np.sqrt(np.sum(np.power(abs(ynew), 2))) ycur = ynew if abs(ynew[-1])**2 > 0.25: print "Warning: further heating will exceed phonon space" ycur = ynew tcur = tcur + tlen # if reached data-point, store data and advance time datasaved = False if tcur == T[t0 + 1]: Y[t0 + 1, :] = np.asarray(ynew.T) t0 = t0 + 1 datasaved = True if params.printpulse and params.progbar and pulseseq.seqqc[ p0].type != 'M': pbar.update(int(1.*(tcur-pulseseq.seqqc[p0].starttime)*100 \ /(pulseseq.seqqc[p0].duration))) # if pulse ended, advance to next pulse (if both then do both) if tcur == pulseseq.seqqc[p0].endtime: pulseseq.seqqc[p0].U = np.copy(np.asarray(Ucur)) # save current data if not already saved if not datasaved: T = np.insert(T, t0 + 1, tcur) [Yn1, Yn2] = np.array_split(Y, [t0 + 1]) Y = np.concatenate([Yn1, np.asarray(ynew.T), Yn2], axis=0) t0 = t0 + 1 # advance to next pulse p0 = p0 + 1 Ucur = 1 ################# #### Time-dependent HT: ODE solving else: # choose time step depending on detuning if pulseseq.seqqc[p0].detuning > 2 * pi * 2: stepduration = min( 2 / (pulseseq.seqqc[p0].detuning / (2 * pi)), 1) else: stepduration = params.ODEtimestep # for MS pulse, check and modify omrabi due to hiding if pulse.type == "M" and params.doMShidecorr: nuions = len(pulse.targetion) activeions = len(np.nonzero(pulse.targetion)[0]) omc_fac = params.MShidecorr[activeions, nuions] if omc_fac == -1: print "MS w/ hiding correction factor invalid, ignoring" else: pulse.omrabi_b = params.omc_ms * omc_fac pulse.omrabi_r = params.omc_ms * omc_fac # set up time-dep Hamiltonian if pulse.dobichro: HTblue = ht.Hamiltonian_timedep_complete( pulse.targetion, pulse.omrabi_bt, pulse.phase_light + pulse.phase_rb, pulse.detuning_b, params.omz, params.eta, params.hspace, LDApprox=params.LDapproximation) HTred = ht.Hamiltonian_timedep_complete( pulse.targetion, pulse.omrabi_rt, pulse.phase_light - pulse.phase_rb, pulse.detuning_r, params.omz, params.eta, params.hspace, LDApprox=params.LDapproximation) HTorig = lambda t: HTblue(t) + HTred(t) else: HTorig = ht.Hamiltonian_timedep_complete( pulse.targetion, pulse.omrabi_t, pulse.phase, pulse.detuning, params.omz, params.eta, params.hspace, LDApprox=params.LDapproximation) HT = lambda t: noise_mult(t) * HTorig(t) + noise_add(t) psidot = lambda t, psi: -1j * np.dot(HT(t), psi) # ycur needs to be cast as a 1d array solver = qmtools.SEsolver(params.solver) Tloc = np.array([0.]) Yloc = np.zeros( [1, len(np.asarray(ycur))] ) # this is to get the dimensions right, but make sure to remove the first row of 0's if params.progbar: widgets = [ progressbar.Percentage(), ' ', progressbar.Bar(), ' ', progressbar.ETA() ] pbar = progressbar.ProgressBar(widgets=widgets).start() else: pbar = None # ODE solver # variable aliases for convenience pstarttime = pulseseq.seqqc[p0].starttime pendtime = pulseseq.seqqc[p0].endtime # first calculate the expected number of datapoints testtime = np.arange(tcur, pendtime, stepduration) testtime = np.append(np.delete(testtime, 0), pendtime) # extra check for projective unitary (spontdecay, heating) projtimes_cur = projtimes[np.intersect1d( \ np.nonzero(projtimes<pendtime)[0], \ np.nonzero(projtimes>pstarttime)[0]) ] for tproj in projtimes_cur: ms_ode = solver(HT, tcur, tproj, stepduration, np.ravel(ycur), \ pbar, pstarttime, pendtime) Tloc = np.append(Tloc, np.delete(ms_ode.time, 0)) Yloc = np.append(Yloc, np.delete(ms_ode.y.transpose(), 0, axis=0), axis=0) tcur = tproj ycur = Yloc[-1, :].T if dec.doRandNtimes > 0 and np.sum(noise_uni(tcur)) != 0 \ and not pulse.use_ideal: U = noise_uni(tcur) ynew = np.dot(U, ycur) ynew = ynew / np.sqrt(np.sum(np.power(abs(ynew), 2))) ycur = ynew if abs(ynew[-1])**2 > 0.25: print "Warning: further heating will exceed phonon space" Yloc[-1, :] = np.asarray(ynew.T) ms_ode = solver(HT, tcur, pendtime, stepduration, np.ravel(ycur), \ pbar, pstarttime, pendtime) Tloc = np.append(Tloc, np.delete(ms_ode.time, 0)) Yloc = np.append(Yloc, np.delete(ms_ode.y.transpose(), 0, axis=0), axis=0) Tloc = np.delete(Tloc, 0) Yloc = np.delete(Yloc, 0, axis=0) # check the length w.r.t. expected length of T vector and remove extras while len(Tloc) > len(testtime): for i in range(len(testtime)): if testtime[i] != Tloc[i]: Tloc = np.delete(Tloc, i) Yloc = np.delete(Yloc, i, axis=0) break if not params.saveallpoints: Tloc = [Tloc[-1]] Yloc = np.array([Yloc[-1]]) # now we put the result into original result array # first, update the current time and state tcur = Tloc[-1] ycur = np.mat(Yloc[-1, :]).T # find the end of the pulse in the original T list t1 = np.nonzero(T >= tcur)[0][0] # only replace point if it's already been calculated if T[t1] == tcur: tend = t1 + 1 else: # T[t1] > tcur tend = t1 # replace the overlapping times in T with Tloc [Tnew1, Tnew2] = np.array_split(np.delete(T, range(t0 + 1, tend)), [t0 + 1]) Tnew = np.concatenate([Tnew1, Tloc, Tnew2]) # mirror with Y and Yloc [Ynew1, Ynew2 ] = np.array_split(np.delete(Y, range(t0 + 1, tend), axis=0), [t0 + 1]) # seems that concatenate doesn't work on 2d arrays if they're empty if len(Ynew2) == 0: Ynew = np.concatenate([Ynew1, Yloc], axis=0) else: Ynew = np.concatenate([Ynew1, Yloc, Ynew2], axis=0) T = Tnew Y = Ynew p0 = p0 + 1 t0 = np.nonzero(T >= tcur)[0][0] data = simtools.database(T, Y, params.hspace, pulseseq, register=classical_reg) data.creationtime = params.savedataname # timestamp the data if dec.doSQL: sequel.insertJobToDB(data) # get rid of lambda functions in order to send results back through pp for pulse in pulseseq.seqqc: pulse.omrabi_t = 0 pulse.omrabi_bt = 0 pulse.omrabi_rt = 0 return data
INITIALCHAIN1 = np.outer(INITIALCHAIN,INITIALCHAIN) INITIALCHAIN = np.kron(I_P,I_C) for ad in range(CHAINLENGTH-1): INITIALCHAIN = np.kron(INITIALCHAIN,INITIALCHAIN1) SYSTEM = np.matrix(SYSTEM)*np.matrix(INITIALCOIN)*np.matrix(INITIALCHAIN) del INITIALCHAIN del INITIALCOIN del INITIALCOIN_nochain del INITIALCHAIN1 ################################## ############################################################ #LAST BIT OF CHAIN CODE CHAIN = J1*CHAIN1 + J*CHAIN2 CHAIN = np.kron(I_P,CHAIN) EXP1 = linalg.expm2(-1j*CHAIN) EXP2 = linalg.expm2(1j*CHAIN) #EXP1 = np.kron(I_P,EXP1) #EXP2 = np.kron(I_P,EXP2) ############################################################### #QUANTUM WALK p = np.zeros((POSITIONS,STEPS),dtype=complex) for r in range(STEPS): SYSTEM = np.matrix(EXP1)*np.matrix(SYSTEM)*np.matrix(EXP2) SYSTEM = np.matrix(H)*np.matrix(SYSTEM)*np.matrix(np.matrix.getH(H)) SYSTEM = np.matrix(SHIFT)*np.matrix(SYSTEM)*np.matrix.getH(SHIFT) ################################## #MEASUREMENT for i in range(POSITIONS): ket_i = np.zeros((POSITIONS,1))
def Generate_Floquet_NearestNeighbour(args): print("\nUSING THE NEAREST NEIGHBOUR FUNCTION\n") # Hamniltonia ########## First Half of evolution # Precession term: L = args['L'] T = args['T'] J = args['J'] epsilon = args['epsilon'] hx = args['hx'] hy = args['hy'] hz = args['hz'] Zprecession = np.zeros((2**L, 2**L), dtype='complex') for i in range(L): mat = iden if i == 0: mat = sigmaz for k in range(1, L): if i == k: mat = outer(sigmaz, mat) else: mat = outer(iden, mat) Zprecession += mat Xprecession = np.zeros((2**L, 2**L), dtype='complex') for i in range(L): mat = iden if i == 0: mat = sigmax for k in range(1, L): if i == k: mat = outer(sigmax, mat) else: mat = outer(iden, mat) Xprecession += mat Yprecession = np.zeros((2**L, 2**L), dtype='complex') for i in range(L): mat = iden if i == 0: mat = sigmax for k in range(1, L): if i == k: mat = outer(sigmax, mat) else: mat = outer(iden, mat) Yprecession += mat #Interaction term interactions = np.zeros((2**L, 2**L), dtype='complex') #np.identity(2**L) * wei[0] for i in range(L): j = (i + 1) % L mat = iden if i == 0 or j == 0: mat = sigmaz for k in range(1, L): if j == k or i == k: mat = outer(sigmaz, mat) else: mat = outer(iden, mat) interactions += mat * J Uf1 = slinalg.expm2(-1j * T * (interactions + hz * Zprecession + hy * Yprecession + hx * Xprecession)) ########## Second Half of evolutions SingleSpin = iden * np.cos( np.pi / 2 * (1 + epsilon)) - 1j * sigmax * np.sin(np.pi / 2 * (1 + epsilon)) Uf2 = SingleSpin for i in range(1, L): Uf2 = outer(SingleSpin, Uf2) ########## HPrethermal = interactions + hx * Xprecession return (HPrethermal, Uf2.dot(Uf1))
def y(t,i): #return np.dot(la.expm(A*t),y0)[i]#can be expm3(A, ordrer Taylor) #return np.dot(la.expm3(A*t,n),y0)[i] return np.dot(la.expm2(A*t),y0)[i]
def sqrtm(M): """ Returns the symmetric semi-definite positive square root of a matrix. """ r = real_if_close(expm2(0.5 * logm(M)), 1e-8) return (r + r.T) / 2
def Hamiltonian_timedep_complete(self, targetion, omrabi, phase, detuning, wsec, eta, hspace, LDApprox=False): """ everything in the full interaction frame of the ions including the harmonic oscillation (opposing to the original version from hartmut that still had the phonon energy nonzero) in addition, this version won't omit the exp(+- i omega_z terms t) in attached to creation/annihilation operators this is eqn 3.6 in Christian Roo's thesis. """ # H = exp(i delta_c t+phase) omega(t) (sum_i address_error_i sigma_plus_i) (exp(i eta (a exp(-i omegaz t) + adag exp(i omegaz t)))) + h.c. # !!! note !!! # here eta is assumed to be the same for all qubits. this is # not necessarily the case. #a more correct version would allow for # individual etas for each qubit ... maybe later. not # really required here and would only slow down the code targetion = targetion[::-1] # prefactor including the timedepending omega and the detuning+phase prefac = lambda t: np.exp(1j * (detuning * t + phase)) * omrabi(t) * 1 / 2. # coupling to the sideband. argument of the exponent/ld approximation LDpart = lambda t: 1j * eta[-1] * (hspace.operator_dict['a'] * np.exp( -1j * wsec * t) + hspace.operator_dict['a_dag'] * np.exp(1j * wsec * t)) # calculate the coupling based on the addressing errors sys = np.zeros( (hspace.levels**hspace.nuions, hspace.levels**hspace.nuions)) for k in xrange(hspace.nuions): sys += targetion[k] * hspace.operator_dict['raising'][:, :, k] # Lamb-Dicke approximation yes/no? # kron with qubits to get the hamiltonian if LDApprox: sys_ho = lambda t: npml.kron( sys, np.diag(np.ones(hspace.maxphonons + 1)) + LDpart(t)) else: sys_ho = lambda t: npml.kron(sys, splg.expm2(LDpart(t))) # multiply with rabi-frequency part H = lambda t: prefac(t) * sys_ho(t) # add h.c. part HT = lambda t: H(t) + H(t).transpose().conjugate() return HT
def Hamiltonian(self, pulse, params, LDApprox=True): ''' Hamiltonian definition using hspace.operator_dict ''' opdict = params.hspace.operator_dict targetion = pulse.targetion[::-1] omrabi = pulse.omrabi phase = pulse.phase detuning = pulse.detuning wsec = params.omz eta = params.eta hspace = params.hspace # prefactor including the timedepending omega and the detuning+phase prefac = np.exp(1j * phase) * omrabi * 1/2. # coupling to the sideband. argument of the exponent/ld approximation LDpart = 1j * eta[-1] * (opdict['a']+opdict['a_dag']) # calculate the coupling based on the addressing errors # Lamb-Dicke approximation yes/no? # kron with qubits to get the hamiltonian # here we'll use the fact that eta may be different for each ion sys_ho = np.zeros(((hspace.maxphonons+1)*hspace.levels**hspace.nuions, \ (hspace.maxphonons+1)*hspace.levels**hspace.nuions ), \ np.complex128) if LDApprox: for k in xrange(hspace.nuions): #etak = eta[-1] if pulse.ion == -1 else eta[k] sys_ho += npml.kron( targetion[k]*opdict['raising'][:,:,k],\ np.diag(np.ones(hspace.maxphonons+1)) + \ 1j * eta[k] * (opdict['a']+opdict['a_dag']) ) else: for k in xrange(hspace.nuions): #etak = eta[-1] if pulse.ion == -1 else eta[k] sys_ho += npml.kron( targetion[k]*opdict['raising'][:,:,k],\ splg.expm2(1j * eta[k] * (opdict['a']+opdict['a_dag'])) ) # multiply with rabi-frequency part H = prefac * sys_ho # diagonal terms sysz = np.zeros((hspace.levels**hspace.nuions,hspace.levels**hspace.nuions)) for k in xrange(hspace.nuions): sysz += opdict['sigz'][:,:,k] * 1/2. energies = -detuning * npml.kron(sysz, opdict['id_a']) + \ wsec * npml.kron(np.diag(np.ones(hspace.levels**hspace.nuions)), \ np.dot(opdict['a_dag'], opdict['a']) ) # subtract a zero offset energies -= np.diag(energies[0,0]*np.ones_like(np.diag(energies))) # add h.c. part HT = H + H.transpose().conjugate() + energies # diagonal elements of matrix for basis transformation (lasertoqc) lqc = np.diag(HT) if pulse.type == 'Z': HT = HT+np.diag(self.ACshift_corr(pulse, params)) # to fix discrepancy between lab/Volkmar and here if pulse.theta < 0: HT = -HT lqc = -lqc return HT, lqc
COMPONENT1 = np.kron(COMPONENT1,pauli_x) COMPONENT2 = np.kron(COMPONENT2,pauli_y) elif u==v+1: COMPONENT1 = np.kron(COMPONENT1,pauli_x) COMPONENT2 = np.kron(COMPONENT2,pauli_y) else: COMPONENT1 = np.kron(COMPONENT1,pauli_i) COMPONENT2 = np.kron(COMPONENT2,pauli_i) if v==0: CHAIN1 = COMPONENT1 + COMPONENT2 else: CHAIN2 = CHAIN2 + COMPONENT1 + COMPONENT2 A = (J1*CHAIN1 + J*CHAIN2) A = 1j*A EXP1 = linalg.expm2(-1*A) EXP2 = linalg.expm2(A) EXP1 = np.kron(I_P,EXP1) EXP2 = np.kron(I_P,EXP2) ###################################### #INITIAL STATE INITIALCOIN = (1/np.sqrt(2))*np.matrix([[1], [1]]) INITIALCOIN = np.outer(INITIALCOIN,INITIALCOIN) INITIALCHAIN = np.matrix([[1, 0], [0, 0]]) SYSTEM = np.zeros((2*STEPS+1)) SYSTEM[STEPS+1] = 1 SYSTEM = np.outer(SYSTEM,SYSTEM) A = np.kron(INITIALCOIN,INITIALCHAIN) for z in range(CHAINLENGTH-2):
INITIALCHAIN = (1 / np.sqrt(2)) * np.matrix([[1], [1]]) INITIALCHAIN1 = np.outer(INITIALCHAIN, INITIALCHAIN) INITIALCHAIN = np.kron(I_P, I_C) for ad in range(CHAINLENGTH - 1): INITIALCHAIN = np.kron(INITIALCHAIN, INITIALCHAIN1) SYSTEM = np.matrix(SYSTEM) * np.matrix(INITIALCOIN) * np.matrix(INITIALCHAIN) del INITIALCHAIN del INITIALCOIN del INITIALCHAIN1 ################################## ############################################################ #LAST BIT OF CHAIN CODE CHAIN = J * CHAIN1 + J * CHAIN2 EXP1 = linalg.expm2(-1j * CHAIN) EXP2 = linalg.expm2(1j * CHAIN) EXP1 = np.kron(I_P, EXP1) EXP2 = np.kron(I_P, EXP2) ############################################################### #QUANTUM WALK for r in range(STEPS): SYSTEM = np.matrix(EXP1) * np.matrix(SYSTEM) * np.matrix(EXP2) SYSTEM = np.matrix(H) * np.matrix(SYSTEM) * np.matrix(np.matrix.getH(H)) SYSTEM = np.matrix(SHIFT) * np.matrix(SYSTEM) * np.matrix( np.matrix.getH(SHIFT)) ################################## #MEASUREMENT p = np.zeros((POSITIONS, 1), dtype=complex) for i in range(POSITIONS):
v = mat(random.randn(nTest, 1)) t = 3.0 start_time = time.time() (w, error, hump) = expv(t, lambda x: M * x, v, normM) end_time = time.time() print "Krylov Time: %f" % (end_time - start_time) start_time = time.time() testExp = expm(t * M) testV = testExp * v end_time = time.time() print "Dense Pade Exp Time: %f" % (end_time - start_time) start_time = time.time() testExp2 = expm2(t * M) testV2 = testExp2 * v end_time = time.time() print "Dense Eig Decomp Exp Time: %f" % (end_time - start_time) start_time = time.time() testExp3 = expm3(t * M) testV3 = testExp3 * v end_time = time.time() print "Dense Taylor Exp Time: %f" % (end_time - start_time) relativeErr = norm(testV - w) / norm(testV) print "Relative Difference Between exp(M)*v using Krylov and Dense Pade Approx: %f" % relativeErr if abs(relativeErr) > 1e-6: print "Tolerance Exceeded:"
def Ugate(A,N): return Qobj(expm2(2*np.pi*i*N*A))
v = mat(random.randn(nTest,1)) t = 3.0 start_time = time.time() (w, error, hump) = expv(t, lambda x: M*x, v, normM) end_time = time.time() print "Krylov Time: %f" % (end_time-start_time) start_time = time.time() testExp = expm(t*M) testV = testExp*v end_time = time.time() print "Dense Pade Exp Time: %f" % (end_time - start_time) start_time = time.time() testExp2 = expm2(t*M) testV2 = testExp2*v end_time = time.time() print "Dense Eig Decomp Exp Time: %f" % (end_time - start_time) start_time = time.time() testExp3 = expm3(t*M) testV3 = testExp3*v end_time = time.time() print "Dense Taylor Exp Time: %f" % (end_time - start_time) relativeErr = norm(testV - w)/norm(testV) print "Relative Difference Between exp(M)*v using Krylov and Dense Pade Approx: %f" % relativeErr if abs(relativeErr) > 1e-6: print "Tolerance Exceeded:"
t4 = zeros(size(s)) tt = 0 for i in s: print "Matrix size %d" %(i) m = zeros((i,i), float64) half = int(round(i*i/2))+1 r = random.randint(0,i, (half*2, )) n = random.random((half, )) for z in range(0, half*2, 2): m[r[z], r[z+1]] = n[z/2] start = time() expm(m) t[tt] = time() - start start = time() expm2(m) t2[tt] = time() - start start = time() expm3(m) t3[tt] = time() - start start = time() expf(i, 1, m, i) t4[tt] = time() - start tt += 1 print s print t plot(s, t, label="Pade") plot(s, t2, label="Eigenvalue")