def E_s(x_, y_dim): # (2 a_j)^2 xx_derivative = Matrix(9, 1, [0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 0.0, 0.0]) xx_outer = TensorProduct(xx_derivative, xx_derivative.T) # (\frac{1}{2} (2 a_{j+1} x_i + b_{j+1} - 2 a_{j-1} x_i - b_{j-1}))^2 xy_derivative = Matrix( 9, 1, [-2.0 * x, -1.0, 0.0, 0.0, 0.0, 0.0, 2.0 * x, 1.0, 0.0]) xy_derivative = 0.5 * xy_derivative xy_outer = TensorProduct(xy_derivative, xy_derivative.T) # (a_{j+1} x_i^2 + b_{j+1} x_i + c_{j+1} - 2a_{j} x_i^2 - 2 b_{j} x_i - 2 c_{j} + a_{j-1} x_i^2 + b_{j-1} x_i + c_{j-1})^2 yy_derivative = Matrix( 9, 1, [x * x, x, 1.0, -2.0 * x * x, -2.0 * x, -2.0, x * x, x, 1.0]) yy_outer = TensorProduct(yy_derivative, yy_derivative.T) combined = xx_outer + 2.0 * xy_outer + yy_outer A_pattern = np.zeros((9, 9)) for i in x_: A_pattern += np.array(combined.subs(x, i)).astype(np.float64) # Fill along diagonal A_dim = y_dim * 3 * 2 A = np.zeros((A_dim, A_dim)) for i in range(0, y_dim - 2): idx_n = i * 3 A[idx_n:idx_n + 9, idx_n:idx_n + 9] += A_pattern idx_s = i * 3 + y_dim * 3 A[idx_s:idx_s + 9, idx_s:idx_s + 9] += A_pattern return A
def Potential(K1, K2, J, epsilon): ############ LIST OF CONSTANTS USED################# # K1 #Spring constant of Top 1 # K2 #Spring constant of Top2 # J #Eignevalue of J^2 operator # epsilon #Coupling strength of the two tops N = int( 2 * J + 1 ) #Dimension of the Hamiltonian of one top; Number of spin degenerate states permissible N2 = N * N #Dimension of the Tensor Product space #################################################### Jz = [[0 for x in range(N)] for y in range(N)] #To calculate the representation of Jz Identity = [[0 for x in range(N)] for y in range(N)] #To calculate the Identity #To calculate the Jz (Angular Momentum along z axis) for x in range(N): m = -x + J Jz[x][x] = m Identity[x][x] = 1 Identity = np.matrix(Identity) Jz = np.matrix(Jz) Jz_sq = Jz * Jz J1 = (Jz + 0.5 * Identity) J_sq = J1 * J1 Identity = np.matrix(Identity) V = (K1 / (2 * J)) * TensorProduct( Jz_sq, Identity) + (K2 / (2 * J)) * TensorProduct( Identity, J_sq) + (epsilon / J) * TensorProduct( Jz, J1) #To calculate the Fourier Coefficient of the Potential return V
def tensorized_basis_3D(order): total_integration_points = (order + 1) * (order + 1) r,s,t = sym.symbols('r,s,t') r_gll = sym.symbols('r_0:%d' % (order + 1)) s_gll = sym.symbols('s_0:%d' % (order + 1)) t_gll = sym.symbols('t_0:%d' % (order + 1)) # Get N + 1 lagrange polynomials in each direction. generator_r = generating_polynomial_lagrange(order, 'r', r_gll) generator_s = generating_polynomial_lagrange(order, 's', s_gll) generator_t = generating_polynomial_lagrange(order, 't', t_gll) # Get tensorized basis. basis = TensorProduct(generator_t, generator_s, generator_r) gll_coordinates, gll_weights = gauss_lobatto_legendre_quadruature_points_weights(order + 1) basis = basis.subs([(v, c) for v, c in zip(r_gll, gll_coordinates)]) basis = basis.subs([(v, c) for v, c in zip(s_gll, gll_coordinates)]) basis = basis.subs([(v, c) for v, c in zip(t_gll, gll_coordinates)]) # Get gradient of basis functions. basis_gradient_r = sym.Matrix([sym.diff(i, r) for i in basis]) basis_gradient_s = sym.Matrix([sym.diff(i, s) for i in basis]) basis_gradient_t = sym.Matrix([sym.diff(i, t) for i in basis]) routines = [('interpolate_order{}_hex'.format(order),basis), ('interpolate_r_derivative_order{}_hex'.format(order), basis_gradient_r), ('interpolate_s_derivative_order{}_hex'.format(order), basis_gradient_s), ('interpolate_t_derivative_order{}_hex'.format(order), basis_gradient_t)] codegen(routines, "C", "order{}_hex".format(order), to_files=True, project="SALVUS") # fix headers (#include "order4_hex.h" -> #include <Element/HyperCube/Autogen/order3_hex.h>) fixHeader(order,"hex",".")
def setUpTripartiteSystem(d): """ Builds desired tripartite system of 3 qudits """ rho = setUpNQudits(3, d) POVM = setUpPOVMElements(d) tau = TensorProduct(rho[0], rho[1], rho[2]) M = TensorProduct(POVM[0], POVM[1], sympy.eye(d, d)) return (M * tau).trace()
def U(t): U00_t = U00(t) U11_t = U11(t) Up_t = Up(t) Um_t = Um(t) return TensorProduct(o0000, U00_t) + \ TensorProduct(o1111, U11_t) + \ TensorProduct(opp, Up_t) + \ TensorProduct(omm, Um_t)
def tensorized_basis_2D(order): total_integration_points = (order + 1) * (order + 1) eps, eta, rho = sym.symbols('epsilon eta rho') eps_gll = sym.symbols('epsilon_0:%d' % (order + 1)) eta_gll = sym.symbols('eta_0:%d' % (order + 1)) # Get N + 1 lagrange polynomials in each direction. generator_eps = generating_polynomial_lagrange(order, 'epsilon', eps_gll) generator_eta = generating_polynomial_lagrange(order, 'eta', eta_gll) # Get tensorized basis. basis = TensorProduct(generator_eta, generator_eps) gll_coordinates, gll_weights = gauss_lobatto_legendre_quadruature_points_weights(order + 1) basis = basis.subs([(v, c) for v, c in zip(eps_gll, gll_coordinates)]) basis = basis.subs([(v, c) for v, c in zip(eta_gll, gll_coordinates)]) # Get gradient of basis functions. basis_gradient_eps = sym.Matrix([sym.diff(i, eps) for i in basis]) basis_gradient_eta = sym.Matrix([sym.diff(i, eta) for i in basis]) # Get closure mapping. closure = sym.Matrix(generate_closure_mapping(order), dtype=int) # Write code routines = [] autocode = CCodeGen() routines.append(autocode.routine( 'interpolate_order{}_square'.format(order), basis, argument_sequence=None)) routines.append(autocode.routine( 'interpolate_eps_derivative_order{}_square'.format(order), basis_gradient_eps, argument_sequence=None)) routines.append(autocode.routine( 'interpolate_eta_derivative_order{}_square'.format(order), basis_gradient_eta, argument_sequence=None)) routines.append(autocode.routine( 'closure_mapping_order{}_square'.format(order), closure, argument_sequence=None)) routines.append(autocode.routine( 'gll_weights_order{}_square'.format(order), sym.Matrix(gll_weights), argument_sequence=None)) routines.append(autocode.routine( 'gll_coordinates_order{}_square'.format(order), sym.Matrix(gll_coordinates), argument_sequence=None)) autocode.write(routines, 'order{}_square'.format(order), to_files=True) # reformat some code. for code, lend in zip(['order{}_square.c', 'order{}_square.h'], [' {', ';']): with io.open(code.format(order), 'rt') as fh: text = fh.readlines() text = [line.replace('double', 'int') if 'closure' in line else line for line in text] with io.open(code.format(order), 'wt') as fh: fh.writelines(text)
def tensorNqubits(portao, alvo, qubits): #muda o portao de 1 bit para um de N qubits no alvo a escolha i=0 alvo=alvo-1 while i < alvo: #faz produtos tensoriais para os qubits anteriores ao alvo portao=TensorProduct(eye(2), portao) i = i + 1 i=0 while i < qubits - alvo - 1: #faz produtos tensoriais para os qubits posteriores ao alvo portao=TensorProduct(portao, eye(2)) i = i + 1 return portao
def setUpN2QubitSystems(n): r1 = sym.Symbol('r_1') r2 = sym.Symbol('r_2') t = sym.Symbol('theta') rho = sym.Matrix([[1 + r1, 0], [0, 1 - r1]]) sigma = sym.Matrix([[1 + r2 * cos(t), r2 * sin(t)],[r2 * sin(t), 1 - r2 * cos(t)]]) rho_not = rho sigma_not = sigma for i in range(1, n): rho = TensorProduct(rho_not, rho) sigma = TensorProduct(sigma_not, sigma) return (rho, sigma, r1, r2, t)
def Toom_Cook_Kronecker_Matrices(points, kernel_size, output_size, precision): input_size = kernel_size + output_size - 1 points_number = input_size - 1 G, GT = G_Matrix(points, points_number, kernel_size) AT, A = AT_Matrix(points, points_number, output_size) BT, B = BT_Matrix(points, points_number) G_Kronecker = TensorProduct(G, G) AT_Kronecker = TensorProduct(AT, AT) BT_Kronecker = TensorProduct(BT, BT) G_Kronecker = np.array(G_Kronecker).astype(precision) AT_Kronecker = np.array(AT_Kronecker).astype(precision) BT_Kronecker = np.array(BT_Kronecker).astype(precision) print(G_Kronecker) return G_Kronecker, AT_Kronecker, BT_Kronecker
def tensorized_basis_2D(order): total_integration_points = (order + 1) * (order + 1) eps, eta, rho = sym.symbols('epsilon eta rho') eps_gll = sym.symbols('epsilon_0:%d' % (order + 1)) eta_gll = sym.symbols('eta_0:%d' % (order + 1)) # Get N + 1 lagrange polynomials in each direction. generator_eps = generating_polynomial_lagrange(order, 'epsilon', eps_gll) generator_eta = generating_polynomial_lagrange(order, 'eta', eta_gll) # Get tensorized basis. basis = TensorProduct(generator_eta, generator_eps) basis = basis.subs([(v, c) for v, c in zip(eps_gll, gll_coordinates(order))]) basis = basis.subs([(v, c) for v, c in zip(eta_gll, gll_coordinates(order))]) sym.pprint(basis) # Get gradient of basis functions. basis_gradient_eps = sym.Matrix([sym.diff(i, eps) for i in basis]) basis_gradient_eta = sym.Matrix([sym.diff(i, eta) for i in basis]) # Get diagonal mass matrix mass_matrix = rho * basis * basis.T mass_matrix_diagonal = sym.Matrix( [mass_matrix[i, i] for i in range(total_integration_points)]) # Write code routines = [] autocode = CCodeGen() routines.append( autocode.routine('interpolate_order{}_square'.format(order), basis, argument_sequence=None)) routines.append( autocode.routine( 'interpolate_eps_derivative_order{}_square'.format(order), basis_gradient_eps, argument_sequence=None)) routines.append( autocode.routine( 'interpolate_eta_derivative_order{}_square'.format(order), basis_gradient_eta, argument_sequence=None)) routines.append( autocode.routine('diagonal_mass_matrix_order{}_square'.format(order), mass_matrix_diagonal, argument_sequence=None)) autocode.write(routines, 'order{}_square'.format(order), to_files=True)
def E_d(x_shadow, x_nonshadow, pen_inter, y_dim, patch): ############################ # Compute A ############################ # Compute quadratic outer product via sympy quadratic = Matrix(3, 1, [x * x, x, 1.0]) quadratic_outer = TensorProduct(quadratic, quadratic.T) A_nonshadow = np.zeros((3, 3)) # Non-shadow pattern for x_ in x_nonshadow: A_nonshadow += np.array(quadratic_outer.subs(x, x_)).astype(np.float64) # Shadow pattern A_shadow = np.zeros((3, 3)) for x_ in x_shadow: A_shadow += np.array(quadratic_outer.subs(x, x_)).astype(np.float64) # Fill A along diagonal with the two patterns # First half non_shadow, second half shadow pattern A_dim = y_dim * 3 * 2 A = np.zeros((A_dim, A_dim)) for i in np.arange(0, A_dim / 2, 3, dtype=np.int16): A[i:i + 3, i:i + 3] = A_nonshadow for i in np.arange(A_dim / 2, A_dim, 3, dtype=np.int16): A[i:i + 3, i:i + 3] = A_shadow ########################### # Compute b ########################### b = np.zeros(y_dim * 3 * 2) for i in range(0, y_dim): # Cut out nonshadow patch patch_nonshadow = patch[i, int(np.ceil(pen_inter[1])):] # Cut out shadow patch patch_shadow = patch[i, 0:int(np.floor(pen_inter[0])) + 1] # sum_j I_{i,j} * x_i^2 b[3 * i] = np.sum(np.multiply(patch_nonshadow, np.square(x_nonshadow))) # sum_j I_{i,j} * x_i b[3 * i + 1] = np.sum(np.multiply(patch_nonshadow, x_nonshadow)) # sum_j I_{i,j} b[3 * i + 2] = np.sum(patch_nonshadow) b[3 * i + y_dim * 3] = np.sum( np.multiply(patch_shadow, np.square(x_shadow))) b[3 * i + y_dim * 3 + 1] = np.sum(np.multiply(patch_shadow, x_shadow)) b[3 * i + y_dim * 3 + 2] = np.sum(patch_shadow) return A, b
def enlarge_single_opt_sympy(self, opt, qubit, number_of_qubits): """Enlarge single operator to n qubits. It is exponential in the number of qubits. Args: opt (object): the single-qubit opt. qubit (int): the qubit to apply it on counts from 0 and order is q_{n-1} ... otimes q_1 otimes q_0. number_of_qubits (int): the number of qubits in the system. Returns: Matrix: the enlarged matrix that operates on all qubits in the system. """ temp_1 = eye(2**(number_of_qubits - qubit - 1)) temp_2 = eye(2**(qubit)) enlarge_opt = TensorProduct(temp_1, TensorProduct(opt, temp_2)) return enlarge_opt
def test_evaluate_pauli_product(): from sympy.physics.paulialgebra import evaluate_pauli_product assert evaluate_pauli_product(I * sigma2 * sigma3) == -sigma1 # Check issue 6471 assert evaluate_pauli_product(-I * 4 * sigma1 * sigma2) == 4 * sigma3 assert evaluate_pauli_product( 1 + I*sigma1*sigma2*sigma1*sigma2 + \ I*sigma1*sigma2*tau1*sigma1*sigma3 + \ ((tau1**2).subs(tau1, I*sigma1)) + \ sigma3*((tau1**2).subs(tau1, I*sigma1)) + \ TensorProduct(I*sigma1*sigma2*sigma1*sigma2, 1) ) == 1 -I + I*sigma3*tau1*sigma2 - 1 - sigma3 - I*TensorProduct(1,1)
def __init__(self, N, s, kind): self.__N = N self.__s = s self.__kind = kind # First, initialize single-qubit density matrix depending on 'kind' if s * 2 % 1 != 0: raise ValueError('s must be either an integer or a half-integer.') if s < 0: raise ValueError('s cannot be negative.') single_dim = int(2 * s + 1) if kind == 'up': vec = sym.Matrix(basis(single_dim, 0)) dens = sym.Matrix( sym.Matrix(basis(single_dim, 0)) * sym.conjugate(sym.Matrix(basis(single_dim, 0)).T)) #self.__vector = TensorProduct(sym.Matrix(basis(single_dim, 0)), sym.Matrix(basis(single_dim, 0))) #dens = self.__vector * sym.conjugate(self.__vector.T)#np.outer(basis(single_dim, 0), basis(single_dim, 0)) self.__pure = True elif kind == 'down': vec = sym.Matrix(basis(single_dim, single_dim - 1)) dens = sym.Matrix( sym.Matrix(basis(single_dim, single_dim - 1)) * sym.conjugate(sym.Matrix(basis(single_dim, single_dim - 1)).T)) #self.__vector = TensorProduct(sym.Matrix(basis(single_dim, single_dim-1)), sym.Matrix(basis(single_dim, single_dim-1))) #dens = self.__vector * sym.conjugate(self.__vector.T)#np.outer(basis(single_dim, 0), basis(single_dim, 0)) self.__pure = True elif kind == 'mixed': self.__vector = None dens = sym.Matrix(np.identity(single_dim) / single_dim) #qu.maximally_mixed_dm(single_dim) self.__pure = False else: raise ValueError('State kind not recognized.') for ii in range(N): if ii == 0: if self.__pure: vector = vec rho = dens else: if self.__pure: vector = TensorProduct(vector, vec) rho = TensorProduct(rho, dens) #qu.tensor(rho, dens) self.__vector = vector self.__rho = rho
def _setup(self): self._F0_N_ssro, self._F1_N_ssro, self._F0_e_ssro, self._F1_e_ssro, self._F0_RO_pulse, self._F1_RO_pulse, self._P_min1, self._P_0 = \ sympy.symbols('F0_N_ssro F1_N_ssro F0_e_ssro F1_e_ssro F0_RO_pulse F1_RO_pulse P_min1 P_0') self._p_correlations = sympy.DeferredVector('p_correlations') # The total error matrix is the tensor product of the nitrogen and electron error matrices. # The nitrogen error matrix is built up of three matrices RO_err, CNOT_err and Init_err. # RO_err reflects fidelities of the electron RO, # CNOT_err reflects the fidelities in the pi (F0) and 2pi (F1) parts of the pi-2pi pulse (as CNOT gate). # Init_err includes populations in the three nitrogen lines after initialization in -1. #The inverse matrices are calculated before the tensorproduct, since this is much faster. self.error_matrix_N = (sympy.Matrix([[self._F0_N_ssro, 1.-self._F1_N_ssro],[1.-self._F0_N_ssro, self._F1_N_ssro]]) * \ sympy.Matrix([[self._F0_RO_pulse, 1.-self._F1_RO_pulse, 0.],[1.-self._F0_RO_pulse, self._F1_RO_pulse, 1.]]) * \ sympy.Matrix([[self._P_min1,self._P_0],[self._P_0,self._P_min1],[1.-self._P_0-self._P_min1,1.-self._P_0-self._P_min1]])) self.error_matrix_e = (sympy.Matrix( [[self._F0_e_ssro, 1. - self._F1_e_ssro], [1. - self._F0_e_ssro, self._F1_e_ssro]])) self.correction_matrix_N = self.error_matrix_N.inv() self.correction_matrix_e = self.error_matrix_e.inv() self.correction_matrix = TensorProduct(self.correction_matrix_N, self.correction_matrix_e) corr_vec = self.correction_matrix * \ sympy.Matrix([self._p_correlations[0], self._p_correlations[1], self._p_correlations[2], self._p_correlations[3]]) corr_p_correlations = corr_vec self.p0_formula = error.Formula() self.p0_formula.formula = corr_p_correlations
def __init__(self, C0=sp.Symbol('C0', real=True), C2=sp.Symbol('C2', real=True), A=sp.Symbol('A', real=True), R=sp.Symbol('R', real=True), kcut=0, mz=0, n_sheets=sp.Symbol('n_sheets', int=True)): so = sp.Matrix([[1, 0], [0, 1]]) sx = sp.Matrix([[0, 1], [1, 0]]) sy = sp.Matrix([[0, -sp.I], [sp.I, 0]]) sz = sp.Matrix([[1, 0], [0, -1]]) ho = C0 + C2 * (self.kx**2 + self.ky**2) hx = A * self.ky hy = -A * self.kx hz = 2 * R * (self.kx**3 - 3 * self.kx * self.ky**2) + mz if (not np.isclose(kcut, 0)): ratio = (self.kx**2 + self.ky**2) / kcut**2 cutfactor = 1 / (1 + (ratio)) hz *= cutfactor hdiag = ho * so + hx * sx + hy * sy + hz * sz #build hamiltonian with nz sheets diag = sp.eye(n_sheets) h = TensorProduct(diag, hdiag) super().__init__(h, n_sheets)
def solution_space_basis(oper, matrix_M, expr_list, base_expr, pool="", debug=False): '''solve (matrix_F otimes matrix_M)*alpha=alpha for a certain symmetry ####return (list of Matrix): a list of vectors (single column Matrix object) return (list of list of number): a list of lists (each sublist represent a vector) oper (dict): a dictionary with four keys "op3x3", "rep", "is_au" and "name" matrix_M (Matrix): matrix_M matrix expr_list (list of Symbol): a list of expression basis (f_i(k)) base_expr (list of Symbol): three symbols used in expr_list pool (pool): if pool object passed in, then use it debug (boolean): if True, print the progress infomation ''' debug_print(oper["name"], "start", do_print=debug) matrix_F = get_matrix_F(oper["op3x3"], expr_list, base_expr, pool=pool) debug_print(oper["name"], "got matrix_F, calculating (FxM)*alpha=alpha", do_print=debug) matrix_FM = TensorProduct(matrix_F, matrix_M) temp = matrix_FM - sp.eye(matrix_FM.shape[0]) # curr_basis = np.array(mat.nullspace(simplify=sp.nsimplify)).tolist() # solution_basis = [m.T.tolist()[0] for m in nullspace(mat, simplify=sp.nsimplify, pool=pool)] solution_basis = nullspace(temp, pool=pool, debug=debug) debug_print(oper["name"], "end", do_print=debug) return solution_basis
def E_c_hardcoder(y_dim): A_pattern_dim = y_dim * 3 + 9 # (2 a_{j, n} x_i + b_{j, n} - 2 a_{j, s} x_i - b_{j, s})^2 x_derivative = Matrix.zeros(A_pattern_dim, 1) x_derivative[3] = 2.0 * x # 2 a_{j, n} x_derivative[4] = 1.0 # b_{j, n} x_derivative[-6] = -2.0 * x # - 2 a_{j, s} x_i x_derivative[-5] = -1.0 # - b_{j, s} x_outer = TensorProduct(x_derivative, x_derivative.T) # \frac{1}{4} (a_{j+1,n} x_i^2 + b_{j+1,n} x_i + c_{j+1,n} # - a_{j+1,s} x_i^2 - b_{j+1,s} x_i - c_{j+1,s} - a_{j-1,n} x_i^2 # - b_{j-1,n} x_i - c_{j-1,n} + a_{j-1,s} x_i^2 + b_{j-1,s} x_i + c_{j-1,s})^2 y_derivative = Matrix.zeros(A_pattern_dim, 1) y_derivative[6] = x * x # a_{j+1,n} x_i^2 y_derivative[7] = x # b_{j+1,n} x_i y_derivative[8] = 1.0 # c_{j+1,n} y_derivative[-3] = -x * x # - a_{j+1,s} x_i^2 y_derivative[-2] = -x # - b_{j+1,s} x_i y_derivative[-1] = -1.0 # - c_{j+1,s} y_derivative[0] = -x * x #- a_{j-1,n} x_i^2 y_derivative[1] = -x #- b_{j-1,n} x_i y_derivative[2] = -1.0 #- c_{j-1,n} y_derivative[-9] = x * x # a_{j-1,s} x_i^2 y_derivative[-8] = x # b_{j-1,s} x_i y_derivative[-7] = 1.0 # c_{j-1,s} y_derivative = y_derivative * 0.5 y_outer = TensorProduct(y_derivative, y_derivative.T) # Combine x and y derivatives combined = x_outer + y_outer # Convert to numpy array combined_np = np.array(combined.tolist()) # Find indices of nonzero matrix entries idx = np.nonzero(combined_np) # Build sympy array of nonzero entries combined_reduced = Array(combined_np[idx[0], idx[1]]) # Now we have an index list and an sympy expression Array, where # combined_reduced[i] corresponds to matrix position (idx[0,i], idx[1, i]) # Save these two data structures as files file_Ec_sympy = open('Ec_sympy.obj', 'wb') pickle.dump(combined_reduced, file_Ec_sympy) file_Ec_idx = open('Ec_idx.obj', 'wb') pickle.dump(idx, file_Ec_idx)
def tensorized_basis_2D(order): total_integration_points = (order + 1) * (order + 1) eps, eta, rho = sym.symbols("epsilon eta rho") eps_gll = sym.symbols("epsilon_0:%d" % (order + 1)) eta_gll = sym.symbols("eta_0:%d" % (order + 1)) # Get N + 1 lagrange polynomials in each direction. generator_eps = generating_polynomial_lagrange(order, "epsilon", eps_gll) generator_eta = generating_polynomial_lagrange(order, "eta", eta_gll) # Get tensorized basis. basis = TensorProduct(generator_eta, generator_eps) basis = basis.subs([(v, c) for v, c in zip(eps_gll, gll_coordinates(order))]) basis = basis.subs([(v, c) for v, c in zip(eta_gll, gll_coordinates(order))]) sym.pprint(basis) # Get gradient of basis functions. basis_gradient_eps = sym.Matrix([sym.diff(i, eps) for i in basis]) basis_gradient_eta = sym.Matrix([sym.diff(i, eta) for i in basis]) # Get diagonal mass matrix mass_matrix = rho * basis * basis.T mass_matrix_diagonal = sym.Matrix([mass_matrix[i, i] for i in range(total_integration_points)]) # Write code routines = [] autocode = CCodeGen() routines.append(autocode.routine("interpolate_order{}_square".format(order), basis, argument_sequence=None)) routines.append( autocode.routine( "interpolate_eps_derivative_order{}_square".format(order), basis_gradient_eps, argument_sequence=None ) ) routines.append( autocode.routine( "interpolate_eta_derivative_order{}_square".format(order), basis_gradient_eta, argument_sequence=None ) ) routines.append( autocode.routine( "diagonal_mass_matrix_order{}_square".format(order), mass_matrix_diagonal, argument_sequence=None ) ) autocode.write(routines, "order{}_square".format(order), to_files=True)
def kron(self, other): # Kronecker product if self.__cuda: if cupy_is_available: result = cp.kron(self.__matrix, other.get()) else: result = np.kron(self.__matrix, other.get()) else: result = TensorProduct(self.__matrix, other.get()) return Matrix(result, self.__cuda)
def apply_measurement(self, op, input_register, moutputs): # Find the operator of the measurement instance we're running measurement = self.find_measurement(op['operator_id']) # Using the same principle as in apply_gate, obtain a matrix we can # run on all lines before = op['lines'][0] after = self.register_size - op['lines'][-1] - 1 matrix = TensorProduct(eye(2**before), measurement.matrix, eye(2**after)) # To contain the possible states the system could fall into after the # measurement states = [] # For each triple in the eigensystem # Eigenvalue, duplicity (not needed here), eigenvectors for val, dup, vecs in matrix.eigenvects(): # For each vector in the eigenvector basis for vec in vecs: # Obtain a projection operator P = x*x^T p = vec * vec.H # Probability of this outcome Pr = |phi>^T * P * |phi> # [0] because we want the value of a 1x1 matrix probability = (input_register.H * p * input_register)[0] # Don't need to consider this outcome anymore if it # won't happen if probability == 0: continue # Calculate the new register |phi'> = P*|phi> / sqrt(Pr) register = p * input_register / sqrt(probability) # Copy the measurement outputs as we're branching so don't # want to affect other branches moutputs = dict(moutputs) # Store the outcome that's just happened in the measurement # outputs moutputs[op['oid']] = val # Add the state tuple into states state = (register, probability, moutputs) states.append(state) return states
def build_hurwitz_radon_general(n): """ The function gets as input a number 'n' and returns a set of matrices of size n x n that meets the Hurwitz-Radon constraints. Here no assumption is made on 'b', where b is a Hurwitz-Radon parameter""" a, b, c, d = find_hurwitz_radon_parameters(n) mat_set = build_hurwitz_radon(n) if not mat_set: # if the list is empty return mat_set if b > 1: for ind, mat in enumerate(mat_set): mat_set[ind] = TensorProduct(mat, eye(b)) return mat_set
def tensorized_basis_3D(order): total_integration_points = (order + 1) * (order + 1) r, s, t = sym.symbols('r,s,t') r_gll = sym.symbols('r_0:%d' % (order + 1)) s_gll = sym.symbols('s_0:%d' % (order + 1)) t_gll = sym.symbols('t_0:%d' % (order + 1)) # Get N + 1 lagrange polynomials in each direction. generator_r = generating_polynomial_lagrange(order, 'r', r_gll) generator_s = generating_polynomial_lagrange(order, 's', s_gll) generator_t = generating_polynomial_lagrange(order, 't', t_gll) # Get tensorized basis. basis = TensorProduct(generator_t, generator_s, generator_r) gll_coordinates, gll_weights = gauss_lobatto_legendre_quadruature_points_weights( order + 1) basis = basis.subs([(v, c) for v, c in zip(r_gll, gll_coordinates)]) basis = basis.subs([(v, c) for v, c in zip(s_gll, gll_coordinates)]) basis = basis.subs([(v, c) for v, c in zip(t_gll, gll_coordinates)]) # Get gradient of basis functions. basis_gradient_r = sym.Matrix([sym.diff(i, r) for i in basis]) basis_gradient_s = sym.Matrix([sym.diff(i, s) for i in basis]) basis_gradient_t = sym.Matrix([sym.diff(i, t) for i in basis]) routines = [('interpolate_order{}_hex'.format(order), basis), ('interpolate_r_derivative_order{}_hex'.format(order), basis_gradient_r), ('interpolate_s_derivative_order{}_hex'.format(order), basis_gradient_s), ('interpolate_t_derivative_order{}_hex'.format(order), basis_gradient_t)] codegen(routines, "C", "order{}_hex".format(order), to_files=True, project="SALVUS") # fix headers (#include "order4_hex.h" -> #include <Element/HyperCube/Autogen/order3_hex.h>) fixHeader(order, "hex", ".")
def cnot3(psi, qubit_negado): #matriz e produto tensorial se o bit negado for o 1 if qubit_negado == 1: cnotm2= Matrix([[1, 0, 0, 0], #matriz de 2 qubits onde primeiro controla o posterior [0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0]]) cnot=TensorProduct(cnotm2, eye(2))#produto tensorial para operar 3 qubits #matriz e produto tensorial se o bit negado for o 3 else: cnotm2= Matrix([[1, 0, 0, 0], #matriz de 2 qubits onde um qubit controla o anterior [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]) cnot=TensorProduct(eye(2), cnotm2)#produto tensorial para operar 3 qubits psi=np.matrix(psi) #para poder multiplicar o vetor de estado pelo operador psi=psi*cnot #opera a multiplicacao de matrizes return psi.tolist()[0] #transforma a matriz de volta em lista
def unitary_partial_swap(angles, step, n_qubits): inter = int(n_qubits / 2 - 1) if step > inter : raise NameError("Le qubit selectionne est incorrect.") elif step == 0 : return TensorProduct(TensorProduct(eye(2 ** (inter + step)), partial_swap(angles[inter - step])), eye(2 ** (inter - step))) else : U = TensorProduct(TensorProduct(eye(2 ** (inter + step)), partial_swap(angles[inter - step])), eye(2 ** (inter - step))) return TensorProduct(TensorProduct(eye(2 ** (inter - step)), partial_swap(angles[inter + step])), eye(2 ** (inter + step))) * U
def __init__(self, A=sp.Symbol('A', real=True), t=sp.Symbol('t', real=True), tt=sp.Symbol('tt', real=True), m5=sp.Symbol('m5', real=True), n_sheets=sp.Symbol('n_sheets', int=True)): #set of hermitian matrices Gamma1 = sp.Matrix([[0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0], [1, 0, 0, 0]]) Gamma2 = sp.Matrix([[0, 0, 0, -sp.I], [0, 0, sp.I, 0], [0, -sp.I, 0, 0], [sp.I, 0, 0, 0]]) Gamma3 = sp.Matrix([[0, 0, 1, 0], [0, 0, 0, -1], [1, 0, 0, 0], [0, -1, 0, 0]]) Gamma5 = sp.Matrix([[0, 0, -sp.I, 0], [0, 0, 0, -sp.I], [sp.I, 0, 0, 0], [0, sp.I, 0, 0]]) #diagonal part of hamiltonian hdiag = A * ( m5 + t * ( sp.cos(self.kx) + sp.cos(self.ky) ) ) * Gamma5 \ + A * tt * ( sp.sin(self.kx) * Gamma1 + sp.sin(self.ky) * Gamma2 ) #hopping between sheets hoffdiag = A * (1 / 2 * t * Gamma5 + 1 / (2 * sp.I) * tt * Gamma3) #lower offdiag blocks hoffdiag_c = A * (1 / 2 * t * Gamma5 - 1 / (2 * sp.I) * tt * Gamma3) #upper offdiag blocks #build hamiltonian with nz sheets diag = sp.eye(n_sheets) lower = sp.Matrix.jordan_block(n_sheets, 0, band='lower') upper = sp.Matrix.jordan_block(n_sheets, 0, band='upper') h = TensorProduct(diag, hdiag) + TensorProduct( lower, hoffdiag) + TensorProduct(upper, hoffdiag_c) super().__init__(h, n_sheets, degenerate_eigenvalues=True)
def apply_gate(self, op, input_register, moutputs): # Find the operator of the gate instance we're running gate = self.find_gate(op['operator_id']) # Number of lines before the lines we're running on before = op['lines'][0] # Number of lines after the lines we're running on after = self.register_size - op['lines'][-1] - 1 # Obtain an overall matrix by Kronecking together (matrix tensor # product) an identity on (before) lines, the matrix we want to run # and an identity on (after) lines matrix = TensorProduct(eye(2**before), gate.matrix, eye(2**after)) # The only thing running the gate affects is the state, which is just # |phi'> = M|phi> return [(matrix * input_register, 1, moutputs)]
def test_tensor_product(): a11, a12, a21, a22, b11, b12, b21, b22 = sp.symbols( 'a11 a12 a21 a22 b11 b12 b21 b22') A = Matrix([ [a11, a12], [a21, a22], ]) B = Matrix([ [b11, b12], [b21, b22], ]) actual = TensorProduct(A, B) expected = Matrix([ [a11 * b11, a11 * b12, a12 * b11, a12 * b12], [a11 * b21, a11 * b22, a12 * b21, a12 * b22], [a21 * b11, a21 * b12, a22 * b11, a22 * b12], [a21 * b21, a21 * b22, a22 * b21, a22 * b22], ]) assert actual == expected
def apply_controlled(self, op, input_register, moutputs): # Find the operator of the controlled gate instance we're running gate = self.find_controlled_gate(op['operator_id']) # Find the value that was measured by the measurement we're # conditional upon # We need the second line because the sympified value may be different # from the moutputs value. This will affect array indexing, but == # will still find them equal value = moutputs[op['measurement_id']] value = filter(lambda val: val == value, gate.values)[0] # Find the matrix corresponding to that value # TODO Do we need both the parse_expr.str and the filter expression? small_matrix = gate.matrices[custom_parse_expr(str(value))] # Use the same logic as in apply_gate and apply_measurement to tensor # together a large matrix we can apply to all lines before = op['lines'][0] after = self.register_size - op['lines'][-1] - 1 matrix = TensorProduct(eye(2**before), small_matrix, eye(2**after)) # Now just apply the gate like in apply_gate return ([(matrix * input_register, 1, moutputs)])
R = (1 / sqrt(2)) * Matrix([[I, -I], [1, 1]]) # %% R.adjoint() * T * R # %% Omega_T_d = (pi / ((pi / (2 * omega))**2)) * F * T_d * F.adjoint() # %% Omega_T_d # %% Hs = I * hbar * omega * Matrix([[0, 1], [-1, 0]]) # %% J = TensorProduct(hbar * Omega_T_d, eye(2)) + TensorProduct(eye(2), Hs) # %% J # %% J.eigenvects() # %% [markdown] # ## Ordinary quantum theory # %% t = Symbol('t') t0 = Symbol('t_0') # %%
def qsimplify_pauli(e): """ Simplify an expression that includes products of pauli operators. Parameters ========== e : expression An expression that contains products of Pauli operators that is to be simplified. Examples ======== >>> from sympy.physics.quantum.pauli import SigmaX, SigmaY >>> from sympy.physics.quantum.pauli import qsimplify_pauli >>> sx, sy = SigmaX(), SigmaY() >>> sx * sy SigmaX()*SigmaY() >>> qsimplify_pauli(sx * sy) I*SigmaZ() """ if isinstance(e, Operator): return e if isinstance(e, (Add, Pow, exp, TensorProduct)): t = type(e) return t(*[qsimplify_pauli(arg) for arg in e.args]) if isinstance(e, Mul): c, nc = e.args_cnc() nc_s = [] while nc: if not isinstance(nc[0], SigmaOpBase): curr = nc.pop(0) if isinstance(curr, TensorProduct): curr = TensorProduct(*(qsimplify_pauli(arg) for arg in curr.args)) nc_s.append(curr) continue curr = [nc.pop(0)] names = [curr[0].name] while (len(nc) and isinstance(nc[0], SigmaOpBase)): x = nc.pop(0) if x.name in names: idx = names.index(x.name) y = _qsimplify_pauli_product(curr[idx], x) c1, nc1 = y.args_cnc() curr[idx] = Mul(*nc1) c = c + c1 else: curr.append(x) names.append(x.name) # TODO: Don't make assumptions about what the names are. # TODO: This sorted order is properly part of a canonical form which # should be enforced and preserved elsewhere in the module. curr = sorted(curr, key=lambda e: e.name if hasattr(e, 'name') else 0) nc_s.extend(curr) return Mul(*c) * Mul(*nc_s) return e
def mueller_matrix(J): u"""The Mueller matrix corresponding to Jones matrix `J`. Parameters ---------- ``J`` : sympy Matrix A Jones matrix. Returns ------- sympy Matrix The corresponding Mueller matrix. Examples -------- Generic optical components. >>> from sympy import pprint, symbols, pi, simplify >>> from sympy.physics.optics.polarization import (mueller_matrix, ... linear_polarizer, half_wave_retarder, quarter_wave_retarder) >>> theta = symbols("theta", real=True) A linear_polarizer >>> pprint(mueller_matrix(linear_polarizer(theta)), use_unicode=True) ⎡ cos(2⋅θ) sin(2⋅θ) ⎤ ⎢ 1/2 ──────── ──────── 0⎥ ⎢ 2 2 ⎥ ⎢ ⎥ ⎢cos(2⋅θ) cos(4⋅θ) 1 sin(4⋅θ) ⎥ ⎢──────── ──────── + ─ ──────── 0⎥ ⎢ 2 4 4 4 ⎥ ⎢ ⎥ ⎢sin(2⋅θ) sin(4⋅θ) 1 cos(4⋅θ) ⎥ ⎢──────── ──────── ─ - ──────── 0⎥ ⎢ 2 4 4 4 ⎥ ⎢ ⎥ ⎣ 0 0 0 0⎦ A half-wave plate >>> pprint(mueller_matrix(half_wave_retarder(theta)), use_unicode=True) ⎡1 0 0 0 ⎤ ⎢ ⎥ ⎢ 4 2 ⎥ ⎢0 8⋅sin (θ) - 8⋅sin (θ) + 1 sin(4⋅θ) 0 ⎥ ⎢ ⎥ ⎢ 4 2 ⎥ ⎢0 sin(4⋅θ) - 8⋅sin (θ) + 8⋅sin (θ) - 1 0 ⎥ ⎢ ⎥ ⎣0 0 0 -1⎦ A quarter-wave plate >>> pprint(mueller_matrix(quarter_wave_retarder(theta)), use_unicode=True) ⎡1 0 0 0 ⎤ ⎢ ⎥ ⎢ cos(4⋅θ) 1 sin(4⋅θ) ⎥ ⎢0 ──────── + ─ ──────── -sin(2⋅θ)⎥ ⎢ 2 2 2 ⎥ ⎢ ⎥ ⎢ sin(4⋅θ) 1 cos(4⋅θ) ⎥ ⎢0 ──────── ─ - ──────── cos(2⋅θ) ⎥ ⎢ 2 2 2 ⎥ ⎢ ⎥ ⎣0 sin(2⋅θ) -cos(2⋅θ) 0 ⎦ """ A = Matrix([[1, 0, 0, 1], [1, 0, 0, -1], [0, 1, 1, 0], [0, -I, I, 0]]) return simplify(A * TensorProduct(J, J.conjugate()) * A.inv())
l = np.count_nonzero(v) m = np.reshape(v,(3,3)) print (l) print (m) print(m.T) print(inv(m)) print(np.dot(m,inv(m))) print("=============") print(m) swap_col(m,0,2) print(m) print(swap_col_r(m,0,2)) print("===Tensor Product == ") id = Matrix([[1,0],[0,1]]) i = Matrix([[1,0],[-1,0]]) id_i = TensorProduct(id,i) print(id_i) print(np.reshape(id_i,(2,8))) print("===Fun - operation on matrix elemnets") f_id_i = [ fun(x) for x in id_i] print(f_id_i) print("==Reed_Muller Transform==") w= Matrix([[1,0],[1,1]]) w_1 = w.inv() R3 = TensorProduct(w,TensorProduct(w,w)) print(R3) pprint(R3) f = Matrix([1,0,0,1,1,0,1,1]) pprint(f) print("===") s_f = [x%2 for x in R3*f]
The cnot performs the following transformation: |00> -> |00> |01> -> |01> |10> -> |11> |11> -> |10> """ theta = Symbol('theta') X = np.array([[0, 1j], [-1j, 0]]) CNOT = Matrix( np.array([[1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0]])) I = Matrix(np.eye(2)) sigmax = Matrix(1j * X * theta) sigmax_inv = Matrix(-1j * X * theta) R = simplify(exp(sigmax)) R_ = simplify(exp(sigmax_inv)) IX = simplify(TensorProduct(I, R)) IX_ = simplify(TensorProduct(I, R_)) U = IX_ * CNOT * IX M_ij = Matrix([[U[0, 0], U[0, 2]], [U[2, 0], U[2, 2]]]) pprint(simplify(M_ij))