Tensor chain decomposition-based homomorphic operation method and device in cloud computing scene

Abstract

The invention provides a homomorphic operation method and device based on tensor chain decomposition in a cloud computing scene, which are used for storing tensor kernels in different cloud services in a distributed manner on the basis of combining tensor chain decomposition and homomorphic operation, and utilizing the characteristics that different cloud services are semi-honesty and are not colluded with each other to improve the cloud computing efficiency. Therefore, the processing efficiency of large-scale cloud computing is improved, the storage space occupation of the ciphertext in the cloud server side can be remarkably reduced, a new strategy is provided for large-scale cloud computing service, and the high-quality cloud computing service requirement can be met through low application cost under the actual condition.

Description

Technical Field

[0001] The present application relates to the field of cloud computing, and specifically to a homomorphic computing method and device based on tensor chain decomposition in a cloud computing scenario. Background Art

[0002] Although cloud computing can effectively alleviate the problem of insufficient computing power of local devices, it also brings significant data security challenges. The complexity of data processing and storage in cloud environments increases the risk of facing various security threats, from traditional network attacks to new privacy and data leakage issues, which may endanger personal privacy, disclose business secrets, erode consumer trust, and even expose vulnerabilities in critical infrastructure.

[0003] Although encryption technology can be used to ensure the effective transmission of data and secure computing in the cloud, as the scale, diversity and complexity of big data continue to grow, new challenges have emerged in ensuring the authenticity and integrity of data in cloud environments. These challenges not only highlight data quality issues, but also increase the risk of potential tampering.

[0004] The inventors of this application have found that in cloud computing scenarios, existing homomorphic encryption technologies have failed to demonstrate optimal performance and have encountered many problems when processing large-scale tensor data. For example, when encrypting large tensor data, fully homomorphic and semi-homomorphic encryption may be inefficient due to the limitations of local computing resources. In addition, although cloud computing resources have good scalability, their computing costs are often proportional to the computing time and the memory usage of the ciphertext.

[0005] Therefore, in the cloud computing scenario, how to significantly reduce cloud computing costs while ensuring data security by reducing the time for data homomorphic encryption and performing homomorphic operations in the cloud is an urgent problem to be solved. Summary of the invention

[0006] The present application provides a homomorphic operation method and device based on tensor chain decomposition in a cloud computing scenario, which is used to store tensor cores in different cloud services in a distributed manner based on the combination of tensor chain decomposition and homomorphic operation, and utilizes the semi-honest and non-collusive characteristics between different cloud services. This not only improves the processing efficiency of large-scale cloud computing, but also can significantly reduce the storage space occupied by ciphertext on the cloud service side, providing a new strategy for large-scale cloud computing services, which can actually meet the needs of high-quality cloud computing services at a lower application cost.

[0007] In a first aspect, the present application provides a homomorphic computing method based on tensor chain decomposition in a cloud computing scenario, the method comprising:

[0008] After determining homomorphic operation tasks for data X on the user terminal a side and data Y on the user terminal b side, the user terminal a performs tensor chain decomposition on the data X to obtain a ciphertext tensor chain A, and the user terminal b performs tensor chain decomposition on the data Y to obtain a ciphertext tensor chain B;

[0009] The user end a performs obfuscation and orthogonalization operations on the ciphertext tensor chain A to obtain a non-orthogonal central tensor kernel Ak and an orthogonal tensor kernel An, and the user end b performs obfuscation and orthogonalization operations on the ciphertext tensor chain B to obtain a non-orthogonal central tensor kernel Bk and an orthogonal tensor kernel Bn;

[0010] User a sends a non-orthogonal central tensor core Ak to cloud service c1 and an orthogonal tensor core An to cloud service c2, and user b sends a non-orthogonal central tensor core Bk to cloud service c1 and an orthogonal tensor core Bn to cloud service c2, and cloud service c1 and cloud service c2 are set according to a semi-honest model;

[0011] The cloud service c1 performs corresponding homomorphic operations based on the non-orthogonal central tensor core Ak and the non-orthogonal central tensor core Bk, and sends the obtained non-orthogonal central tensor core Ck to the user terminal a, and the cloud service c2 performs corresponding homomorphic operations based on the orthogonal tensor core An and the orthogonal tensor core Bn, and sends the obtained orthogonal tensor core Cn to the user terminal a;

[0012] The user end a performs a tensor core restoration operation based on the received non-orthogonal central tensor core Ck and orthogonal tensor core Cn to obtain a calculation result D of the data X and the data Y.

[0013] In a second aspect, the present application provides a homomorphic computing device based on tensor chain decomposition in a cloud computing scenario, the device comprising:

[0014] A decomposition unit is used for, after determining homomorphic operation tasks for data X on the user terminal a side and data Y on the user terminal b side, performing tensor chain decomposition on data X to obtain a ciphertext tensor chain A, and performing tensor chain decomposition on data Y to obtain a ciphertext tensor chain B;

[0015] An operation unit, used for performing subscript obfuscation and orthogonalization operations on the ciphertext tensor chain A to obtain a non-orthogonal central tensor core Ak and an orthogonal tensor core An, and performing subscript obfuscation and orthogonalization operations on the ciphertext tensor chain B to obtain a non-orthogonal central tensor core Bk and an orthogonal tensor core Bn;

[0016] A sending unit, configured to send the non-orthogonal central tensor core Ak to the cloud service c1 and the orthogonal tensor core An to the cloud service c2, and to send the non-orthogonal central tensor core Bk to the cloud service c1 and the orthogonal tensor core Bn to the cloud service c2, wherein the cloud service c1 and the cloud service c2 are set according to a semi-honest model;

[0017] A computing unit, configured to perform corresponding homomorphic operations based on the non-orthogonal central tensor core Ak and the non-orthogonal central tensor core Bk, and send the obtained non-orthogonal central tensor core Ck to the user terminal a, and to perform corresponding homomorphic operations based on the orthogonal tensor core An and the orthogonal tensor core Bn, and send the obtained orthogonal tensor core Cn to the user terminal a;

[0018] The restoration unit is used to perform a tensor core restoration operation based on the received non-orthogonal central tensor core Ck and orthogonal tensor core Cn to obtain a calculation result D of the data X and the data Y.

[0019] In a third aspect, the present application provides a processing system, which includes a user terminal a, a user terminal b, a cloud service c1 and a cloud service c2, and is used to execute the method provided by the first aspect of the present application or any possible implementation method of the first aspect of the present application.

[0020] In a fourth aspect, the present application provides a computer-readable storage medium, which stores multiple instructions, and the instructions are suitable for a processor to load to execute the method provided by the first aspect of the present application or any possible implementation of the first aspect of the present application.

[0021] From the above content, it can be concluded that the present application has the following beneficial effects:

[0022] Aiming at the goal of homomorphic computing in cloud computing scenarios, this application combines tensor chain decomposition and homomorphic computing to distribute the tensor cores in different cloud services, and utilizes the semi-honest and non-collusive characteristics between different cloud services. This not only improves the processing efficiency of large-scale cloud computing, but also significantly reduces the storage space occupied by ciphertext on the cloud service side, providing a new strategy for large-scale cloud computing services, which can actually meet the needs of high-quality cloud computing services at a lower application cost. BRIEF DESCRIPTION OF THE DRAWINGS

[0023] In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings required for use in the description of the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present application. For those skilled in the art, other drawings can be obtained based on these drawings without creative work.

[0024] Figure 1 A flowchart of a homomorphic computing method based on tensor chain decomposition in the cloud computing scenario of this application;

[0025] Figure 2 A schematic diagram of the architecture of the application scheme;

[0026] Figure 3A structural schematic diagram of a homomorphic computing device based on tensor chain decomposition in the cloud computing scenario of this application;

[0027] Figure 4 A structural schematic diagram of a processing device in the processing system of this application. DETAILED DESCRIPTION

[0028] The following will be combined with the drawings in the embodiments of the present application to clearly and completely describe the technical solutions in the embodiments of the present application. Obviously, the described embodiments are only part of the embodiments of the present application, not all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without creative work are within the scope of protection of this application.

[0029] The terms "first", "second", etc. in the specification and claims of this application and the above-mentioned drawings are used to distinguish similar objects, and are not necessarily used to describe a specific order or sequence. It should be understood that the data used in this way can be interchangeable where appropriate, so that the embodiments described here can be implemented in an order other than that illustrated or described here. In addition, the terms "including" and "having" and any of their variations are intended to cover non-exclusive inclusions, for example, a process, method, system, product or device that includes a series of steps or modules is not necessarily limited to those steps or modules clearly listed, but may include other steps or modules that are not clearly listed or inherent to these processes, methods, products or devices. The naming or numbering of steps in this application does not mean that the steps in the method flow must be executed in the time / logical sequence indicated by the naming or numbering. The process steps that have been named or numbered can change the execution order according to the technical purpose to be achieved, as long as the same or similar technical effects can be achieved.

[0030] The division of modules in this application is a logical division. There may be other division methods when it is implemented in actual applications. For example, multiple modules can be combined or integrated into another system, or some features can be ignored or not executed. In addition, the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, and the indirect coupling or communication connection between modules can be electrical or other similar forms, which are not limited in this application. In addition, the modules or submodules described as separate components may or may not be physically separated, may or may not be physical modules, or may be distributed in multiple circuit modules, and some or all of the modules may be selected according to actual needs to achieve the purpose of the present application.

[0031] Before introducing the homomorphic operation method based on tensor chain decomposition in the cloud computing scenario provided by this application, the background content involved in this application is first introduced.

[0032] The homomorphic operation method, device and computer-readable storage medium based on tensor chain decomposition in the cloud computing scenario provided by the present application can be applied to the processing system, and is used to store tensor cores in different cloud services in a distributed manner based on the combination of tensor chain decomposition and homomorphic operation, and utilize the semi-honest and non-collusive characteristics between different cloud services. This not only improves the processing efficiency of large-scale cloud computing, but also can significantly reduce the storage space occupied by ciphertext on the cloud service side, providing a new strategy for large-scale cloud computing services, which can actually meet the needs of high-quality cloud computing services at a lower application cost.

[0033] The homomorphic computing method based on tensor chain decomposition in the cloud computing scenario mentioned in the present application may be executed by a homomorphic computing device based on tensor chain decomposition in the cloud computing scenario, or a processing system integrated with the homomorphic computing device based on tensor chain decomposition in the cloud computing scenario. The processing system includes two user terminals, namely user terminal a (corresponding to user Alice) and user terminal b (corresponding to user Bob), and also includes cloud service c1 and cloud service c2 (both of which are specifically configured through corresponding cloud servers). Through this system architecture, the efficient, low-cost, high-quality cloud computing service of the present application is realized.

[0034] Next, we will introduce the homomorphic computing method based on tensor chain decomposition in the cloud computing scenario provided by this application.

[0035] First, see Figure 1 , Figure 1 A schematic flow chart of a homomorphic computing method based on tensor chain decomposition in a cloud computing scenario of the present application is shown. The homomorphic computing method based on tensor chain decomposition in a cloud computing scenario provided by the present application may specifically include the following steps S101 to S105:

[0036] Step S101, after determining homomorphic operation tasks for data X on the user terminal a side and data Y on the user terminal b side, the user terminal a performs tensor chain decomposition on the data X to obtain a ciphertext tensor chain A, and the user terminal b performs tensor chain decomposition on the data Y to obtain a ciphertext tensor chain B;

[0037] It can be understood that for homomorphic operations, homomorphic encryption allows direct calculations on encrypted data and ensures that the encrypted results match the results of the same operations performed on the original data after decryption. This feature not only protects data privacy, but also supports data processing and analysis. For example, encrypted data in cloud computing scenarios can be processed directly without decryption. This ability to balance privacy protection and functional operations allows data owners to securely share encrypted data with third parties (such as cloud service providers), and these third parties can perform predetermined operations and return encrypted results without knowing the specific content of the data.

[0038] Although existing homomorphic encryption technologies allow calculations to be performed without decrypting data, and have demonstrated their unique advantages in specific application scenarios such as data privacy protection, these algorithms have encountered obvious challenges when processing large-scale tensor data, especially technologies such as fully homomorphic encryption and semi-homomorphic encryption. When encrypting large tensor data, they face a series of limitations, such as time-consuming encryption and decryption, and high computational costs. These limitations are often related to the limitations of local computing resources, the complexity of the homomorphic encryption algorithm itself, and many other factors, and have become a bottleneck that cannot be ignored. Given that computing resources on the user side may be limited, unevenly distributed, or even unstable, how to find an encryption solution that can both ensure data security and be as efficient as possible in terms of computation has become an urgent problem to be solved.

[0039] In this context, it can be seen from step S101 here that the present application introduces tensor chain decomposition technology to achieve data encryption on the user side, laying the foundation for the subsequent lightweight goal of efficient and low-cost homomorphic operations.

[0040] Among them, tensor is a basic concept in mathematics and physics, and is widely used in various fields, including quantum physics, material science, machine learning, etc. In a broad sense, a tensor can be regarded as a form of multidimensional data array, which is a generalization of scalars, vectors, and matrices in higher dimensions. In the strict definition of mathematics, tensors are constructed based on multiple linear maps on multiple vector spaces and their dual spaces.

[0041] Tensor chain decomposition, also known as tensor train decomposition or TT decomposition, is an efficient tensor decomposition technique that decomposes a high-order tensor into the product of a series of low-order tensors. These low-order tensors are connected to each other in a chain structure, and each tensor core (TT core) is directly connected only to the previous and next tensors. The main advantage of tensor chain decomposition is that it can significantly reduce the number of parameters required, which not only reduces the storage space requirements, but also reduces the computational burden, while maintaining a high-precision approximation of the original data. These features make tensor chain decomposition an important tool in many fields such as multidimensional signal processing and data compression. Specifically, for an N-order tensor, the decomposition process can be expressed by the following formula:

[0042] T(i1,i2,...,i N )=T1(i1)T2(i2)...T N (i N )

[0043]

[0044] On the right side of the equation, we see a sequence of matrix slice products of tensor kernels, designed to produce exactly the right element using the matrix multiplication rules.

[0045] These tensor cores form the basic structure of tensor chain decomposition, where the tensor rank specifies the matching of dimensions between tensor cores, which critically affects the complexity of decomposition. For high-order tensors, the tensor chain decomposition can be expressed as follows: the generation of each element is similar to the multiplication of a column of connected matrices, which effectively maps the structure of high-dimensional data and optimizes storage and computing efficiency. This is why tensor chain decomposition is called tensor train decomposition.

[0046] In tensor chain decomposition, the low-order tensors obtained by decomposition are collectively referred to as tensor cores or TT cores. Structurally, these tensor cores are usually second-order tensors (matrix form) at the beginning and end, while the tensor cores in the middle form a sequence of third-order tensors. Except for the final core tensor, all preceding tensor cores exhibit left-orthogonal properties, ensuring the mathematical elegance and computational efficiency of the decomposition. The central dimension of each tensor core directly corresponds to a specific dimension of the original high-order tensor, while the other two dimensions are usually called virtual dimensions or ranks. The tensor rank often determines the fineness of the decomposition and the ability to compress data.

[0047] Tensor chain decomposition can be achieved based on the tensor chain decomposition method of singular value decomposition (Tensor-Train-Singular Value Decomposition, TT-SVD), which is an extension of the traditional matrix SVD decomposition. Matrix SVD decomposition is a technique for decomposing a matrix into a left singular vector matrix, a singular value diagonal matrix, and a right singular vector matrix, where the singular values ​​are non-negative and arranged in order. TT-SVD extends this process to the decomposition of arbitrary high-order tensors, and can effectively decompose high-order tensors into a sequence of multiple low-order tensor cores, achieving efficient data compression and concise expression.

[0048] That is to say, as an exemplary embodiment of the present application, the tensor chain decomposition can specifically adopt a tensor chain decomposition method based on singular values ​​to achieve a better tensor chain decomposition effect.

[0049] The corresponding calculation processes are:

[0050] In the initialization phase of the algorithm, the truncation threshold of the singular value decomposition is set according to the established target accuracy, and the original tensor to be processed is assigned to a temporary variable. Subsequently, the algorithm enters a loop process, the number of iterations of which matches the order of the tensor. In each iteration, the algorithm first performs a tensor expansion operation, which converts the tensor into a matrix form according to the current processing dimension and the rank determined in the previous iteration. The expanded dimension depends on the result of the previous round of rank and the current processing dimension. Then, the SVD operation is performed on this expanded matrix, and the result matrix is ​​clipped according to the preset truncation threshold, and the rank value is updated at the same time. Subsequently, the left singular matrix obtained by SVD is reconstructed into a tensor, which constitutes the tensor core of the current iteration. Finally, the product of the singular value and the right singular matrix is ​​used as the input tensor for the next iteration. When the loop ends, the algorithm finally returns an approximate tensor composed of all tensor cores.

[0051] In addition, it can be seen from step S101 here that the homomorphic computing based on cloud computing performed by the present application solution is initiated in the form of a task under actual circumstances. The homomorphic computing task clearly states that corresponding operations must be performed on the data X on the user side a and the data Y on the user side b.

[0052] For data X and data Y, the ciphertext tensor chains A are obtained by decomposing the tensor chains. and ciphertext tensor chain B In tensor chain format it can be represented as follows:

[0053] A(i1,i2...i N )=A1(i1)A2(i2)...A N (i N )

[0054] B(j1,j2...j N )=B1(j1)B2(j2)...B N (j N ).

[0055] Step S102: User end a performs subscript obfuscation and orthogonalization operations on the ciphertext tensor chain A to obtain a non-orthogonal central tensor kernel Ak and an orthogonal tensor kernel An, and user end b performs subscript obfuscation and orthogonalization operations on the ciphertext tensor chain B to obtain a non-orthogonal central tensor kernel Bk and an orthogonal tensor kernel Bn;

[0056] When executing homomorphic computing tasks, for user terminals a and b, the ciphertext tensor chain A obtained by performing tensor chain decomposition on the original data X and the ciphertext tensor chain B obtained by performing tensor chain decomposition on the original data Y are not directly sent to the cloud service side, but further processing is required.

[0057] Specifically, the present application believes that in the process of tensor chain decomposition, non-orthogonal central tensor cores often carry the most critical information in the data, which makes them an ideal choice for encryption. If a random tensor core is used to replace the non-orthogonal central tensor core in the tensor chain decomposition, the decrypted data will be very different from the original data. On the contrary, if the orthogonal core is replaced, the decrypted data remains similar to the original data to a certain extent. This finding shows that choosing non-orthogonal central tensor cores as encryption keys is a feasible strategy.

[0058] In this regard, the present application can take advantage of the orthogonal properties of tensor cores and can move non-orthogonal central tensor cores to the left or right. It can not only effectively utilize the core information in the tensor chain decomposition for data encryption, but also optimize the encryption process by adjusting the position of the non-orthogonal central tensor core, thereby improving the efficiency of the encryption algorithm while ensuring data security.

[0059] Correspondingly, the obfuscation subscript and orthogonalization operations involved in this application can be applied at this time to achieve this processing goal.

[0060] Step S103, the user terminal a sends the non-orthogonal central tensor core Ak to the cloud service c1 and sends the orthogonal tensor core An to the cloud service c2, and the user terminal b sends the non-orthogonal central tensor core Bk to the cloud service c1 and sends the orthogonal tensor core Bn to the cloud service c2, and the cloud service c1 and the cloud service c2 are set according to the semi-honest model;

[0061] It is easy to see that after obtaining both the non-orthogonal central tensor core and the orthogonal tensor core of the ciphertext tensor chain through the obfuscation subscript and orthogonalization operations specially designed in this application, they need to be sent to different cloud services on the cloud service side.

[0062] It should be noted that in the framework designed by the present application, all participants, including cloud servers and, follow the semi-honest model. Specifically in the cloud computing scenario (also known as the cloud-edge environment), first assume that there are two clouds, namely c1 and c2, which will neither collude with each other nor are both semi-honest. There is no clear collusion or conspiracy between them, and they will not cooperate with each other to share or pool any information obtained, and have the characteristics of not colluding with each other.

[0063] In this way, under this architectural design, tensor cores can be distributedly stored in different cloud services, and the semi-honest and non-collusive characteristics of different cloud services can be used to achieve a high degree of confidentiality and data security, and combined with tensor core-based data processing to effectively improve processing efficiency and effectively reduce storage space occupancy.

[0064] Step S104, cloud service c1 performs corresponding homomorphic operations based on non-orthogonal central tensor core Ak and non-orthogonal central tensor core Bk, and sends the obtained non-orthogonal central tensor core Ck to user terminal a, and cloud service c2 performs corresponding homomorphic operations based on orthogonal tensor core An and orthogonal tensor core Bn, and sends the obtained orthogonal tensor core Cn to user terminal a;

[0065] After the cloud service c1 receives the non-orthogonal central tensor core Ak from the user end a and the non-orthogonal central tensor core Bk from the user end b, it can perform homomorphic operations on the two in an encrypted state (implemented by tensor chain decomposition), and obtain the homomorphic operation results of the two according to the specific operation logic specified by the task or the specific operation logic defaulted by the cloud service side, and obtain the corresponding non-orthogonal central tensor core Ck.

[0066] Similarly, the cloud service c2 performs the same homomorphic operation on the orthogonal tensor core An and the orthogonal tensor core Bn to obtain the corresponding non-orthogonal central tensor core Cn.

[0067] After cloud services c1 and c2 obtain the calculation results respectively, they can be fed back to the task-specified / default calculation result obtaining party (the party that performs the tensor core restoration operation to achieve decryption), that is, the user terminal a.

[0068] In step S105, the user terminal a performs a tensor core restoration operation based on the received non-orthogonal central tensor core Ck and orthogonal tensor core Cn to obtain a calculation result D of the data X and the data Y.

[0069] It can be understood that the non-orthogonal central tensor core Ck and the orthogonal tensor core Cn issued by the cloud service side constitute a complete tensor core, which corresponds to the tensor chain obtained by decomposing the calculation results of data X and data Y in plain text state (unencrypted state) through the tensor chain.

[0070] In this regard, the key SK corresponding to the previously performed obfuscation subscript and orthogonalization operations can be used to perform tensor core restoration operations on the non-orthogonal central tensor core Ck and the orthogonal tensor core Cn to achieve decryption and obtain the final calculation result D.

[0071] Specifically, for the above solutions, you can also combine Figure 2 A schematic diagram of the architecture of the present application solution is shown for a more vivid understanding.

[0072] from Figure 1 It can be seen from the illustrated embodiments that, for the homomorphic computing goal based on cloud computing scenarios, the present application, based on the combination of tensor chain decomposition and homomorphic computing, stores tensor cores in different cloud services in a distributed manner, and utilizes the semi-honest and non-collusive characteristics between different cloud services. This not only improves the processing efficiency of large-scale cloud computing, but also can significantly reduce the storage space occupied by ciphertext on the cloud service side, providing a new strategy for large-scale cloud computing services, which can actually meet the needs of high-quality cloud computing services with lower application costs.

[0073] Continue to the above Figure 1 Each step of the illustrated embodiment and possible embodiments thereof in practical application are explained in detail.

[0074] As an exemplary embodiment, the present application specially designs the subscript obfuscation and orthogonalization operations in step S102, wherein the orthogonalization operation is specifically a tensor core left-right orthogonalization operation.

[0075] Specifically, the orthogonal property of tensor cores is an important concept in the tensor chain decomposition technique, which is related to how some of the kernels in the tensor chain decomposition process can be converted into orthogonal matrices through linear transformations. Tensor chain decomposition itself is a powerful mathematical tool for decomposing a high-order tensor (i.e., a multidimensional array) into the product of a series of lower-order tensors, which are called tensor cores. This decomposition significantly reduces the complexity of the original tensor while preserving key structure and information.

[0076] In tensor chain decomposition, the orthogonality of a tensor core usually means that the tensor core can be reconstructed into a matrix whose column vectors (or row vectors) are orthogonal to each other. This orthogonality means that the column vectors (or row vectors) of the matrix are not only independent of each other, but also that the inner product between them is zero. This property is very important in mathematics and computation because it ensures the numerical stability and computational efficiency of tensor chain decomposition. Numerical stability refers to the ability of the algorithm to resist the accumulation of errors caused by numerical operations (such as rounding errors) when performing mathematical calculations. Orthogonality improves the numerical stability of tensor chain decomposition by ensuring that the tensor core does not introduce additional numerical errors during the decomposition and reconstruction process. In addition, the existence of orthogonal tensor cores simplifies some mathematical operations, such as the inner product calculation of tensors in tensor format, because the inverse matrix of an orthogonal matrix is ​​equal to its transpose, which makes certain calculations more efficient and direct.

[0077] Specifically, the left expansion of the left orthogonal tensor core forms a column-orthogonal matrix, which means that each column of the matrix is ​​orthogonal to other columns and the norm of each column is 1. Similarly, the right expansion of the right orthogonal tensor core forms a row-orthogonal matrix, where each row is orthogonal to other rows and the norm of each row is also 1. This column-orthogonal or row-orthogonal property not only makes the tensor core more compact, but also provides additional computational convenience when performing algorithm design and data analysis. Given these advantages of orthogonal tensor cores, they occupy a core position in the design of tensor chain decomposition and related algorithms. Using orthogonal tensor cores can greatly improve the efficiency of tensor chain decomposition algorithms and reduce the required computing resources while maintaining or improving the accuracy of the decomposition. This is especially critical when dealing with large-scale data sets and complex models, as it makes tensor chain decomposition technology show more powerful application potential in many fields such as machine learning, data compression, and multidimensional data analysis.

[0078] The left and right orthogonalization operation of the tensor core can specifically include the following processing contents:

[0079] Assume a tensor core A k (Tensor column kernel) is left-orthogonal, and the left expansion and right expansion can be expressed by the following formulas:

[0080]

[0081] in, <m>Indicates the order in which the expansion is performed. The expanded matrix is ​​orthogonal and satisfies:

[0082]

[0083] Assume a tensor represented in tensor format is X = A1A2…A n …A N , where A N For non-orthogonal central tensor cores, QR decomposition / RQ decomposition (two existing matrix decomposition methods) can be used to move the non-orthogonal central tensor core A N If the non-orthogonal central tensor kernel A N Move to the right, then expand the left matrix An L =QR Perform QR decomposition and combine R with the next kernel An+1=RA n+1 Multiply, as shown below:

[0084] X=A1...A n-1 A n (RA n+1 )...A N ,

[0085] If the non-orthogonal central tensor kernel A N Move to the left, then expand the matrix An on the right R = RQ to perform RQ decomposition and combine R with the previous kernel An-1 = RA n-1 Multiply, as shown below:

[0086] X=A1...(A n-1 R)A n A n+1 ...A N ,

[0087] Among them, An=Q, the size of the tensor core does not change, but the position of the non-orthogonal center tensor core changes.

[0088] As another exemplary embodiment, the obfuscated subscript operation in the obfuscated subscript and orthogonalization operation is specifically an obfuscated tensor core subscript operation, and the obfuscated tensor core subscript operation may include the following processing contents:

[0089] Find the position subscript k of the non-orthogonal central tensor kernel;

[0090] Based on the need to identify the correspondence between tensor cores in non-orthogonal central tensor cores and orthogonal tensor cores, the index of each tensor core is permuted, and a permuted coordinate list is introduced, represented as Pair;

[0091] Returns the decryption key pair Sk = {k, Pair}.

[0092] Specifically, after obtaining the input data, i.e., the tensor X, the following processing is performed to obtain the position subscript k of the non-orthogonal central tensor core:

[0093] 1: Calculate the order and shape of tensor X

[0094] 2: Calculate the truncation parameter

[0095] 3: Set temporary tensor C = X, r0 = 1

[0096] 4: for s=1 to N-1 do

[0097] 5:

[0098] 6: Calculate the SVD after δ truncation: C = USV T +E,||E|| F ≤δ, r k =rank δ (C)

[0099] 7: Get the new tensor core:

[0100] 8: C=SV T

[0101] 9: end for

[0102] 10: A N (i N )=C

[0103] 11: Return the decomposed tensor chain:

[0104] 12: Locate the subscript of the non-orthogonal center tensor core movement and move it to the target position A k (i k )

[0105] 13: Send ciphertext tensor core Send non-orthogonal central tensor core A to cloud service c2 k (i k ) to cloud service c1

[0106] In order to perform homomorphic operations on ciphertext tensors in the cloud, both cloud service c1 and cloud service c2 need to identify the correspondence between the tensor cores in the two ciphertext tensor chains. Therefore, in this application, consider permuting the index of each tensor core and further introduce a permutation coordinate list, represented as Pair. Taking user end a as an example, the specific processing is as follows:

[0107] 1: Calculate the ciphertext tensor chain [[A1(i1)]], ..., [[A k-1 (i k-1 )]],[[A k+1 (i k+1 )]],...,[[A N (i N )]]The number of tensor cores Z

[0108] 2: if Z≠N do:

[0109] 3: Output error information and return

[0110] 4: else

[0111] 5: Cloud service c1 generates a corresponding number of random data Z, each data b satisfies b∈N +

[0112] 6: Composition of key pair Pair = {(1, u1), (2, u2), ..., (N, u N )}

[0113] 7: for s=1 to N do

[0114] 8:

[0115] 9: end for

[0116] 10: end if

[0117] 11: Send the obfuscated ciphertext tensor chain to cloud service c2 Send to cloud service c1

[0118] 12: Return Sk = {k, Pair}

[0119] Clients a and b specify a specific tensor operation type operation to cloud services c1 and c2, and submit ciphertext tensor kernels [[A1(i1)]], ..., [[A k-1 (i k-1 )]],[[A k+1 (i k+1 )]],...,[[A N (i N )]] and [[B1(i1)]], ..., [[B k-1 (i k-1 )]],[[B k+1 (i k+1 )]],...,[[B N (i N )]], submit the non-orthogonal central tensor core A to cloud service c1 k (i k ) and B k (i k ) After that, the computing processing of cloud service c1 and cloud service c2 is:

[0120] 1: Calculate the dimension and order size len1 of the original tensor corresponding to user end a and user end b

[0121] 2: if len1 == len2, output error message and return

[0122] 3: else

[0123] 4: Perform specific tensor operations

[0124] 5: end if

[0125] 6: [[C i1 (i1)]],..,[[Ci k-1 (i k-1 )]],[[Ci k+1 (i k+1 )]],...,[[Ci N (i N )]]←C2,Ci k (i k )←C1

[0126] 7: Return the result of a specific operation

[0127] Assume that two clients encrypt their plaintext data X and Y independently before transmitting them to cloud service c1 and the cloud service layer. After receiving the data, the cloud service performs homomorphic computation on the received data, and then returns the processed ciphertext tensor core to client a (client a in this scenario, client a needs these homomorphic computation results). Therefore, client a can use the key pair Sk = {Sk a , Sk b }Decrypt the received data and retrieve the final calculation result Decrypt. This process can be:

[0128]

[0129] Sk={k,Pair}

[0130] Decrypt(Cipher c ,Sk)≈TensorComputation(X,Y)

[0131] That is, as an exemplary embodiment, in step S105, the user terminal a performs a tensor core restoration operation based on the received non-orthogonal central tensor core Ck and orthogonal tensor core Cn to obtain a calculation result D of the data X and the data Y, which may specifically include:

[0132] Based on the received non-orthogonal central tensor core Ck and orthogonal tensor core Cn, the user end a obtains the key pair Sk through the ciphertext tensor chain A by the confusion tensor core subscript operation. a The key pair Sk obtained by the ciphertext tensor chain B through the confusion tensor core subscript operation b The secret key pair Sk composed of the two is Sk a ,Sk b }, perform the tensor core reduction operation to obtain the calculation results of data X and data Y.

[0133] It should be noted that the key pair Sk = {Sk a ,Sk b }, the composition processing requires user a and user b to share the key pair Sk b .

[0134] For tensor core reduction operations (i.e. decryption operations), the specific ones are:

[0135] 1: The processed ciphertext Ci1(i1), Ci2(i2), ..., Ci N (i N ) is sent to the client a

[0136] 2: User a locates the target key pair: Sk = {k, Pair}

[0137] 3: Pair={(1,u1),(2,u2),...,(N,u N )}

[0138] 4: for s=1 to N do

[0139] 5:

[0140] 6: end for

[0141] 7: Locate the position coordinate k to which the non-orthogonal center tensor core needs to be moved

[0142] 8: Leftorthogonalize()←Ci k (i k )→Rightorthogonalize()

[0143] 9: Return the ciphertext tensor chain Ci1(i1), Ci2(i2), ..., Ci N (i N )

[0144] 10: Client a performs decryption operation based on the key

[0145] 11:TT-Contraction(Ci1(i1),Ci2(i2),...,Ci N (i N ))→Z

[0146] 12: Return the plaintext result tensor Z obtained after decryption

[0147] In addition, the present application also proposes a method of generating a noise tensor core of a specified shape, and performing addition based on the tensor format on the noise tensor and the tensor core generated by the user through tensor chain decomposition, thereby destroying the regularity of the tensor rank. The core of this strategy is to interfere with and hinder attackers from observing and utilizing the regularity of the tensor rank by introducing a noise tensor before uploading the tensor core to the cloud service. In this way, even if the attacker can intercept the encrypted ciphertext tensor core, it will be difficult to accurately determine the relative position relationship between these tensor cores, which not only effectively guarantees the security of the data, but also significantly increases the difficulty for attackers to crack the encryption, thereby effectively reducing the risk of data being attacked by brute force. In addition, this encryption strategy enhances the encryption strength while maintaining data compression efficiency, achieving a relative balance between encryption efficiency and security, and providing a new idea for encryption research on large-scale data.

[0148] Specifically, as an exemplary embodiment, the method of the present application may further include:

[0149] The user end a and the user end b respectively generate a noise tensor kernel NoiseTT, wherein the noise tensor kernel NoiseTT is composed of random values ​​following the state distribution;

[0150] The user end adds the data X to the corresponding noise tensor core NoiseTT, and the user end b adds the data Y to the corresponding noise tensor core NoiseTT.

[0151] Specifically, in order to further improve the security of data during transmission and storage, this application scheme uses the orthogonal properties of tensor cores to add an extra layer of protection to the data by hiding the positions of non-orthogonal central tensor cores. This method effectively reduces the risk of information leakage. The orthogonalization process masks the direct connection between tensor cores, making it difficult for external attackers to infer the structure and content of the original data based on the encrypted data. TT The representation form is (α1, α2, ..., α k , ..., α N-1 ), where each α i represents the rank of the corresponding dimension in the tensor chain decomposition. This rank sequence not only reflects the efficiency of data compression, but is also a key parameter for evaluating encryption quality. In tensor chain decomposition, the choice of rank directly affects the efficiency of data compression and the strength of encryption. Therefore, the appropriate selection and adjustment of these ranks is an important factor in ensuring data security and transmission efficiency, which aims to maximize the data transmission and operation efficiency while destroying the regularity of tensor rank. In short, in the cloud computing environment, by adopting the noise processing based on the tensor chain decomposition results and combining with the orthogonalization technology, the security and efficiency of data in the transmission and storage process can be effectively improved. This method not only takes advantage of the data compression of tensor chain decomposition, but also enhances the security of data through orthogonalization and noise processing, providing users with an efficient and secure cloud computing service.

[0152] Correspondingly, there are:

[0153] X≈A1A2...A k ...A N k∈[1,N]

[0154] rank TT (X)=(α1,α2,...,α k ,...,α N-1 )

[0155] In order to crack the fixed regularity of tensor rank under encrypted tensor format data, this application proposes to generate a noise tensor of a specified shape and perform an addition operation based on the tensor chain format with the tensor core obtained after tensor chain decomposition, thereby destroying the original regularity and significantly enhancing the security of the data. This process first determines the shape of the noise tensor core according to the dimension and shape of the original tensor core to ensure the compatibility of the two when performing the addition operation. Then, a series of carefully designed noise tensor cores are generated. Each tensor core is composed of random values ​​that follow a normal distribution, and these values ​​are adjusted to be close to the numerical range of the original tensor core. The purpose of this is to introduce randomness without significantly changing the overall characteristics of the data, thereby interfering with the prediction and analysis capabilities of potential attackers. After adding these noise tensor cores to the original tensor core, the ciphertext tensor core obtained not only retains the key information of the original data, but also significantly improves the defense capability against external attacks by adding noise. The specific implementation of this strategy can be expressed by the following calculation process and the above formula:

[0156] NoiseTT={ζ1(i1),ζ2(i2),...,ζ N (i N )}

[0157] User→Generate(ζ1(i1),ζ2(i2),...,ζ N (i N ))

[0158]

[0159] TT rank (C) = {β1,β2,...,β N-1 }

[0160] β1=β2=...=β N-1 =max(α k )+1

[0161] Taking client a as an example, the process from adding noise to data X that needs to be homomorphically operated to sending data to the cloud service is as follows:

[0162] 1: Calculate the order and shape of tensor X

[0163] 2: TT(X)→{A1(i1),A2(i2),...,A n (i N )}

[0164] 3: Locate the subscript k and move the non-orthogonal center tensor core to the target position A k (i k )

[0165] 4: Calculate the size len of the tensor core corresponding to A a The size of the tensor core corresponding to NoiseTT is len b

[0166] 5: if len a ≠len b

[0167] 6: Output error information and return

[0168] 7: end if

[0169] 8: else

[0170] 9: for u = 1 to len a do

[0171] 10: if s == 1

[0172] 11: Ci u (i u )=[ζ u (i u )A u (i u )]

[0173] 12: end if

[0174] 13: if s == len a

[0175] 14:

[0176] 15: end if

[0177] 16: else

[0178] 17:

[0179] 18: end for

[0180] 19: for s = 1 to N do

[0181] 20:

[0182] 21: end for

[0183] 22: Send the ciphertext tensor chain with noise and obfuscation to cloud service c2 Send to cloud service c1

[0184] It can be understood that the changing trend of the tensor rank between cores after tensor chain decomposition may become a vulnerability exploited by cloud attackers. This application proposes the above-mentioned noisy orthogonal processing encryption algorithm based on tensor chain decomposition in a cloud computing environment. Before the tensor core is distributed and uploaded to the cloud, a noise tensor of a specified shape is introduced to perform an addition operation based on the tensor chain format with the ciphertext tensor core, thereby changing the regular characteristic of the tensor rank increasing first and then decreasing, and enhancing the privacy protection of ciphertext data in the cloud computing environment.

[0185] As another exemplary embodiment, the homomorphic operation that can be performed on the cloud service side can specifically be a homomorphic addition operation, a homomorphic Hadamard multiplication operation or a homomorphic inner product operation. That is to say, the range of homomorphic operations that can be performed on the cloud service side of the present application is a homomorphic addition operation, a homomorphic Hadamard multiplication operation and a homomorphic inner product operation. It should be noted that in the process of executing homomorphic operations based on tensor chain decomposition, it can be found in the previous introduction that the different positions of the position subscript k of the non-orthogonal central tensor core are involved. The position k of the non-orthogonal central tensor core, whether at the beginning, the end or the middle, determines the specific operation to be performed.

[0186] (1) For the homomorphic addition operation protocol, the input is:

[0187] Non-orthogonal central tensor kernel A k (i k ), B k (i k ), non-orthogonal central tensor core subscript k, ciphertext tensor chain [[A1(i1)]], ..., [[A k-1 (i k-1 )]],[[A k+1 (i k+1 )]],...,[[A N (i N )]],[[B1(i1)]],...,[[B k-1 (i k-1 )]],[[B k+1 (i k+1 )]],...,[[B N (i N )]],

[0188] Integer set U = {1, ..., k-1, k+1, ..., N}.

[0189] The calculation process is:

[0190] 1: if k = 1

[0191] 2:C1:Ci k (i k )=A1(i1)B1(i1)

[0192] 3: for u=2 to N-1 do:

[0193] 4:

[0194] 5: if u=N

[0195] 6:

[0196] 7: end if

[0197] 8: end for

[0198] 9: if k≠1∩k≠N

[0199] 10:

[0200] 11: if u=1

[0201] 12:C2:Ci u (i u )=[[A1(i1)]][[B1(i1))]]

[0202] 13: if u=2,...,N-1∩u≠k

[0203] 14:

[0204] 15: if u=N

[0205] 16:

[0206] 17: end if

[0207] 18: end if

[0208] 19: if k = N

[0209] 20:

[0210] 21: for u=1 to N-1

[0211] 22: if u=1

[0212] 23:C2:Ci u (i u )=[[(A1(i1)]]×[[B1(i1))]]

[0213] 24: else

[0214] 25:

[0215] 26: end if

[0216] 27: end for

[0217] 28: end if

[0218] 29: Return the processed non-orthogonal central tensor core Ci k (i k ), returns the processed ciphertext tensor core [[Ci1(i1)]], [[Ci2(i2)]], ..., [[Ci N (i N )]]

[0219] (2) For the homomorphic Hadamard multiplication protocol, the input is:

[0220] Non-orthogonal central tensor kernel A k (i k ), B k (i k ), the ciphertext tensor chain [[A1(i1)]], ..., [[A k-1 (i k-1 )]],[[A k+1 (i k+1 )]],...,[[A N (i N )]],[[B1(i1)]],...,[[B k-1 (i k-1 )]],[[B k+1 (i k+1 )]],...,[[B N (i N )]].

[0221] The calculation process is:

[0222]

[0223] (3) For the homomorphic inner product operation protocol, the input is:

[0224] Non-orthogonal central tensor kernel A k (i k ), B k (i k ), non-orthogonal central tensor core subscript k, ciphertext tensor chain [[A1(i1)]], ..., [[A k-1 (i k-1 )]],[[A k+1 (i k+1 )]],...,[[A N (i N )]],[[B1(i1)]],...,[[B k-1 (i k-1 )]],[[B k+1 (i k+1 )]],...,[[B N (i N )]], integer set U = {1, ..., k-1, k+1, ..., N}, and the type of homomorphic operation Ty performed.

[0225] The calculation process is:

[0226] 1: if Ty=1

[0227] 2: Perform homomorphic Hadamard multiplication:

[0228] 3:

[0229] 4:

[0230] 5: else if Ty=2

[0231] 6: Perform homomorphic inner product operation:

[0232] 7:

[0233] 8:

[0234] 9: User: ←Ci1Ci2…Ci N

[0235] 10: User: W = Ci1Ci k-1 Ci k+1 … N

[0236] 11: end if

[0237] 12: Return the ciphertext result after operation

[0238] It can be understood that the above three specific homomorphic operation configuration protocols enable data to be encrypted through a lightweight encryption algorithm based on tensor chain decomposition, while also enabling effective homomorphic calculations on ciphertext data in a cloud computing environment, thereby expanding the application scope of cloud computing in processing sensitive data and improving the computing efficiency of performing homomorphic operations in the cloud.

[0239] The above is an introduction to the homomorphic computing method based on tensor chain decomposition in the cloud computing scenario provided by this application. In order to better implement the homomorphic computing method based on tensor chain decomposition in the cloud computing scenario provided by this application, this application also provides a homomorphic computing device based on tensor chain decomposition in a cloud computing scenario from the perspective of functional modules.

[0240] See also Figure 3 , Figure 3 This is a structural diagram of a homomorphic computing device based on tensor chain decomposition in the cloud computing scenario of the present application. In the present application, the homomorphic computing device 300 based on tensor chain decomposition in the cloud computing scenario may specifically include the following structure:

[0241] The decomposition unit 301 is used for performing tensor chain decomposition on the data X to obtain a ciphertext tensor chain A, and performing tensor chain decomposition on the data Y to obtain a ciphertext tensor chain B after determining the homomorphic operation tasks for the data X on the user terminal a side and the data Y on the user terminal b side;

[0242] An operation unit 302 is used to perform subscript obfuscation and orthogonalization operations on the ciphertext tensor chain A to obtain a non-orthogonal central tensor kernel Ak and an orthogonal tensor kernel An, and to perform subscript obfuscation and orthogonalization operations on the ciphertext tensor chain B to obtain a non-orthogonal central tensor kernel Bk and an orthogonal tensor kernel Bn;

[0243] A sending unit 303, configured to send the non-orthogonal central tensor core Ak to the cloud service c1 and the orthogonal tensor core An to the cloud service c2, and to send the non-orthogonal central tensor core Bk to the cloud service c1 and the orthogonal tensor core Bn to the cloud service c2, wherein the cloud service c1 and the cloud service c2 are set according to a semi-honest model;

[0244] The operation unit 304 is used to perform corresponding homomorphic operations based on the non-orthogonal central tensor core Ak and the non-orthogonal central tensor core Bk, and send the obtained non-orthogonal central tensor core Ck to the user terminal a, and perform corresponding homomorphic operations based on the orthogonal tensor core An and the orthogonal tensor core Bn, and send the obtained orthogonal tensor core Cn to the user terminal a;

[0245] The restoration unit 305 is used to perform a tensor core restoration operation based on the received non-orthogonal central tensor core Ck and orthogonal tensor core Cn to obtain a calculation result D of the data X and the data Y.

[0246] In an exemplary embodiment, the tensor chain decomposition specifically adopts a tensor chain decomposition method based on singular values.

[0247] In another exemplary embodiment, the left-right orthogonalization operation of the tensor core in the subscript confusion and orthogonalization operation includes the following processing contents:

[0248] Assume a tensor core A k It is left orthogonal, and the left expansion and right expansion are expressed by the following formulas:

[0249]

[0250] in, <m>Indicates the order in which the expansion is performed. The expanded matrix is ​​orthogonal and satisfies:

[0251]

[0252] Assume a tensor represented in tensor format is X = A1A2…A n …A N , use QR decomposition / RQ decomposition to move the non-orthogonal central tensor core A N If the non-orthogonal central tensor kernel A N Move to the right, then expand the left matrix An L =QR Perform QR decomposition and combine R with the next kernel An+1=RA n+1 Multiply, as shown below:

[0253] X=A1...A n-1 A n (RA n+1 )...A N ,

[0254] If the non-orthogonal central tensor kernel A N Move to the left, then expand the matrix An on the right R = RQ to perform RQ decomposition and combine R with the previous kernel An-1 = RA n-1 Multiply, as shown below:

[0255] X=A1...(A n-1 R)A n A n+1 ...A N ,

[0256] Among them, A n =Q.

[0257] In another exemplary embodiment, the operation of confusing tensor core subscripts in the subscript confusion and orthogonalization operation includes the following processing contents:

[0258] Find the position subscript k of the non-orthogonal central tensor kernel;

[0259] Based on the need to identify the correspondence between tensor cores in non-orthogonal central tensor cores and orthogonal tensor cores, the index of each tensor core is permuted, and a permuted coordinate list is introduced, represented as Pair;

[0260] Return the key pair Sk={k,Pair} used for decryption.

[0261] In another exemplary embodiment, the reduction unit is specifically used for:

[0262] Based on the received non-orthogonal central tensor core Ck and orthogonal tensor core Cn, the user end a obtains the key pair Sk through the ciphertext tensor chain A by the confusion tensor core subscript operation. a The key pair Sk obtained by the confusion tensor core subscript operation and the ciphertext tensor chain B b The key pair Sk composed of the two is Sk a ,Sk b }, perform the tensor core reduction operation to obtain the calculation result D of data X and data Y.

[0263] In another exemplary embodiment, the apparatus further includes a noise adding unit 306, configured to:

[0264] Generate noise tensor kernels NoiseTT respectively, wherein the noise tensor kernel NoiseTT is composed of random values ​​following the state distribution;

[0265] Add the data X to the corresponding noise tensor kernel NoiseTT, and add the data Y to the corresponding noise tensor kernel NoiseTT.

[0266] In yet another exemplary embodiment, the homomorphic operation includes a homomorphic addition operation, a homomorphic Hadamard multiplication operation, or a homomorphic inner product operation.

[0267] The present application also provides a processing system from the perspective of hardware structure. The processing system includes a user terminal a, a user terminal b, a cloud service c1 and a cloud service c2. For the convenience of explanation, the four aspects of the processing system are collectively referred to as processing devices. Figure 4 , Figure 4 A schematic diagram of the structure of a processing device in the processing system of the present application is shown. Specifically, the processing device of the present application may include a processor 401, a memory 402, and an input / output device 403. The processor 401 is used to execute the computer program stored in the memory 402 to implement the following Figure 1 The steps of the corresponding execution subject of the homomorphic operation method based on tensor chain decomposition in the cloud computing scenario in the corresponding embodiment; or, when the processor 401 is used to execute the computer program stored in the memory 402, the following is implemented Figure 3 Corresponding to the functions of each unit in the embodiment, the memory 402 is used to store the processor 401 executing the above Figure 1 The homomorphic operation method based on tensor chain decomposition in the cloud computing scenario in the corresponding embodiment corresponds to the computer program required by the execution subject.

[0268] Exemplarily, the computer program may be divided into one or more modules / units, one or more modules / units are stored in the memory 402, and executed by the processor 401 to complete the present application. One or more modules / units may be a series of computer program instruction segments capable of completing specific functions, and the instruction segments are used to describe the execution process of the computer program in the computer device.

[0269] The processing device may include, but is not limited to, a processor 401, a memory 402, and an input / output device 403. Those skilled in the art will appreciate that the illustration is merely an example of a processing device and does not constitute a limitation on the processing device, and may include more or fewer components than shown in the illustration, or a combination of certain components, or different components. For example, the processing device may also include a network access device, a bus, etc., and the processor 401, the memory 402, the input / output device 403, etc. are connected via a bus.

[0270] The processor 401 may be a central processing unit (CPU), or other general-purpose processors, digital signal processors (DSP), application-specific integrated circuits (ASIC), field-programmable gate arrays (FPGA) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. A general-purpose processor may be a microprocessor or any conventional processor, etc. The processor is the control center of the processing device, and uses various interfaces and lines to connect various parts of the entire device.

[0271] The memory 402 can be used to store computer programs and / or modules. The processor 401 implements various functions of the computer device by running or executing the computer programs and / or modules stored in the memory 402 and calling the data stored in the memory 402. The memory 402 can mainly include a program storage area and a data storage area, wherein the program storage area can store an operating system, at least one application required for a function, etc.; the data storage area can store data created according to the use of the processing system, etc. In addition, the memory can include a high-speed random access memory, and can also include a non-volatile memory, such as a hard disk, a memory, a plug-in hard disk, a smart memory card (Smart Media Card, SMC), a secure digital (SecureDigital, SD) card, a flash card (Flash Card), at least one disk storage device, a flash memory device, or other volatile solid-state storage devices.

[0272] When the processor 401 is used to execute the computer program stored in the memory 402, it can specifically implement the following functions of the corresponding execution subject:

[0273] After determining homomorphic operation tasks for data X on the user terminal a side and data Y on the user terminal b side, the user terminal a performs tensor chain decomposition on the data X to obtain a ciphertext tensor chain A, and the user terminal b performs tensor chain decomposition on the data Y to obtain a ciphertext tensor chain B;

[0274] The user end a performs obfuscation and orthogonalization operations on the ciphertext tensor chain A to obtain a non-orthogonal central tensor kernel Ak and an orthogonal tensor kernel An, and the user end b performs obfuscation and orthogonalization operations on the ciphertext tensor chain B to obtain a non-orthogonal central tensor kernel Bk and an orthogonal tensor kernel Bn;

[0275] User a sends a non-orthogonal central tensor core Ak to cloud service c1 and an orthogonal tensor core An to cloud service c2, and user b sends a non-orthogonal central tensor core Bk to cloud service c1 and an orthogonal tensor core Bn to cloud service c2, and cloud service c1 and cloud service c2 are set according to a semi-honest model;

[0276] The cloud service c1 performs corresponding homomorphic operations based on the non-orthogonal central tensor core Ak and the non-orthogonal central tensor core Bk, and sends the obtained non-orthogonal central tensor core Ck to the user terminal a, and the cloud service c2 performs corresponding homomorphic operations based on the orthogonal tensor core An and the orthogonal tensor core Bn, and sends the obtained orthogonal tensor core Cn to the user terminal a;

[0277] The user end a performs a tensor core restoration operation based on the received non-orthogonal central tensor core Ck and orthogonal tensor core Cn to obtain a calculation result D of the data X and the data Y.

[0278] Those skilled in the art can clearly understand that for the convenience and simplicity of description, the specific working process of the homomorphic computing device, processing system and its corresponding units based on tensor chain decomposition in the cloud computing scenario described above can refer to the following. Figure 1 The description of the homomorphic operation method based on tensor chain decomposition in the cloud computing scenario in the corresponding embodiment will not be repeated here.

[0279] A person of ordinary skill in the art will appreciate that all or part of the steps in the various methods of the above embodiments may be completed by instructions, or by controlling related hardware through instructions. The instructions may be stored in a computer-readable storage medium and loaded and executed by a processor.

[0280] To this end, the present application provides a computer-readable storage medium, in which a plurality of instructions are stored, and the instructions can be loaded by a processor to execute the present application as follows: Figure 1 The steps of the homomorphic computing method based on tensor chain decomposition in the cloud computing scenario in the corresponding embodiment, the specific operations can be referred to as follows Figure 1 The description of the homomorphic operation method based on tensor chain decomposition in the cloud computing scenario in the corresponding embodiment will not be repeated here.

[0281] The computer-readable storage medium may include: a read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk, etc.

[0282] Due to the instructions stored in the computer-readable storage medium, the present application can be executed. Figure 1 The steps of the homomorphic computing method based on tensor chain decomposition in the cloud computing scenario in the corresponding embodiment, therefore, the present application can be implemented as follows Figure 1 The beneficial effects that can be achieved by the homomorphic operation method based on tensor chain decomposition in the cloud computing scenario in the corresponding embodiment are detailed in the previous description and will not be repeated here.

[0283] The above is a detailed introduction to the homomorphic computing method, device, processing system and computer-readable storage medium based on tensor chain decomposition in the cloud computing scenario provided by the present application. Specific examples are used in this article to illustrate the principles and implementation methods of the present application. The description of the above embodiments is only used to help understand the method of the present application and its core idea; at the same time, for technical personnel in this field, according to the idea of ​​the present application, there will be changes in the specific implementation method and application scope. In summary, the content of this specification should not be understood as a limitation on the present application.< / m> < / m>

Claims

1. A homomorphic computing method based on tensor chain decomposition in a cloud computing scenario, characterized in that: The method comprises: After determining homomorphic operation tasks for data X on the user terminal a side and data Y on the user terminal b side, the user terminal a performs tensor chain decomposition on the data X to obtain a ciphertext tensor chain A, and the user terminal b performs the tensor chain decomposition on the data Y to obtain a ciphertext tensor chain B; The user terminal a performs the subscript obfuscation and orthogonalization operations on the ciphertext tensor chain A to obtain a non-orthogonal central tensor core Ak and an orthogonal tensor core An, and the user terminal b performs the subscript obfuscation and orthogonalization operations on the ciphertext tensor chain B to obtain a non-orthogonal central tensor core Bk and an orthogonal tensor core Bn; The user terminal a sends the non-orthogonal central tensor core Ak to the cloud service c1 and sends the orthogonal tensor core An to the cloud service c2, and the user terminal b sends the non-orthogonal central tensor core Bk to the cloud service c1 and sends the orthogonal tensor core Bn to the cloud service c2, and the cloud service c1 and the cloud service c2 are set according to the semi-honest model; The cloud service c1 performs corresponding homomorphic operations based on the non-orthogonal central tensor core Ak and the non-orthogonal central tensor core Bk, and sends the obtained non-orthogonal central tensor core Ck to the user terminal a, and the cloud service c2 performs corresponding homomorphic operations based on the orthogonal tensor core An and the orthogonal tensor core Bn, and sends the obtained orthogonal tensor core Cn to the user terminal a; The user terminal a performs a tensor core restoration operation based on the received non-orthogonal central tensor core Ck and the orthogonal tensor core Cn to obtain a calculation result D of the data X and the data Y.

2. The method according to claim 1, characterized in that: The tensor chain decomposition specifically adopts a tensor chain decomposition method based on singular values.

3. The method according to claim 1, characterized in that The left and right orthogonalization operations of the tensor cores in the subscript confusion and orthogonalization operations include the following processing contents: Assume a tensor core A k It is left orthogonal, and the left expansion and right expansion are expressed by the following formulas: in, <m> Indicates the order in which the expansion is performed. The expanded matrix is ​​orthogonal and satisfies:< / m> Assume a tensor represented in tensor format is X = A1A2…A n …A N , use QR decomposition / RQ decomposition to move the non-orthogonal central tensor core A N If the non-orthogonal central tensor kernel A N Move to the right, then expand the left matrix An L =QR Perform QR decomposition and combine R with the next kernel An+1=RA n+1 Multiply, as shown below: X=A1...An-1An(RAn+1)....AN If the non-orthogonal central tensor kernel A N Move to the left, then expand the matrix An on the right R = RQ performs RQ decomposition and combines the R with the previous kernel An-1 = RA n-1 Multiply, as shown below: X=A...(An-1R)AnnAn+1...A, Among them, A n =Q.

4. The method according to claim 1, characterized in that: The operation of confusing tensor core subscripts in the confusion subscript and orthogonalization operation includes the following processing contents: Find the position subscript k of the non-orthogonal central tensor kernel; Based on the need to identify the correspondence between the tensor cores in the non-orthogonal central tensor core and the orthogonal tensor core, the index of each tensor core is permuted, and a permutation coordinate list is introduced, which is represented as a Pair; Returns the decryption key pair Sk = {k, Pair}.

5. The method according to claim 4, characterized in that The user terminal a performs a tensor core restoration operation based on the received non-orthogonal central tensor core Ck and the orthogonal tensor core Cn to obtain a calculation result D of the data X and the data Y, including: The user end a obtains the key pair Sk through the ciphertext tensor chain A by the subscript operation of the obfuscated tensor core based on the received non-orthogonal central tensor core Ck and the orthogonal tensor core Cn. a and the key pair Sk obtained by the ciphertext tensor chain B through the subscript operation of the obfuscated tensor core b The secret key pair Sk composed of the two is Sk a ,Sk b }, execute the tensor core reduction operation to obtain the calculation result D of the data X and the data Y.

6. The method according to claim 1, characterized in that The method further comprises: The user end a and the user end b respectively generate a noise tensor kernel NoiseTT, wherein the noise tensor kernel NoiseTT is composed of random values ​​following a state distribution; The user end a adds the data X to the corresponding noise tensor core NoiseTT, and the user end b adds the data Y to the corresponding noise tensor core NoiseTT.

7. The method according to claim 1, characterized in that The homomorphic operation includes a homomorphic addition operation, a homomorphic Hadamard multiplication operation or a homomorphic inner product operation.

8. A homomorphic computing device based on tensor chain decomposition in a cloud computing scenario, characterized in that: The device comprises: A decomposition unit, configured to, after determining homomorphic operation tasks for data X on the user terminal a side and data Y on the user terminal b side, perform tensor chain decomposition on the data X to obtain a ciphertext tensor chain A, and perform the tensor chain decomposition on the data Y to obtain a ciphertext tensor chain B; An operation unit, configured to perform subscript obfuscation and orthogonalization operations on the ciphertext tensor chain A to obtain a non-orthogonal central tensor core Ak and an orthogonal tensor core An, and to perform subscript obfuscation and orthogonalization operations on the ciphertext tensor chain B to obtain a non-orthogonal central tensor core Bk and an orthogonal tensor core Bn; A sending unit, configured to send the non-orthogonal central tensor core Ak to the cloud service c1 and the orthogonal tensor core An to the cloud service c2, and to send the non-orthogonal central tensor core Bk to the cloud service c1 and the orthogonal tensor core Bn to the cloud service c2, wherein the cloud service c1 and the cloud service c2 are set according to a semi-honest model; A computing unit, configured to perform corresponding homomorphic operations based on the non-orthogonal central tensor core Ak and the non-orthogonal central tensor core Bk, and send the obtained non-orthogonal central tensor core Ck to the user terminal a, and to perform corresponding homomorphic operations based on the orthogonal tensor core An and the orthogonal tensor core Bn, and send the obtained orthogonal tensor core Cn to the user terminal a; The restoration unit is used to perform a tensor core restoration operation based on the received non-orthogonal central tensor core Ck and the orthogonal tensor core Cn to obtain a calculation result D of the data X and the data Y.

9. A processing system, characterized in that: The processing system includes a user terminal a, a user terminal b, a cloud service c1 and a cloud service c2, and is used to execute the method according to any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores a plurality of instructions, and the instructions are suitable for being loaded by a processor to execute the method according to any one of claims 1 to 7.

Images