1
Secure and Parallel Determinant Computation for Large-Scale Matrices in Edge Environments
arXiv:2605.22039v1 [cs.DC] 21 May 2026
Prajwal Panth, Student Member, IEEE
Abstract—The advent of edge computing has enabled resourceconstrained clients to delegate intensive computational tasks to distributed edge servers, especially within Internet of Things (IoT) environments. Among such tasks, Matrix Determinant Computation (MDC) remains critical for applications in control systems, cryptography, and machine learning. However, the cubic complexity of traditional determinant algorithms makes them unsuitable for real-time processing in constrained edge scenarios. We propose a Secure Parallel Determinant Computation (SPDC) framework, which provides strong security guaranties, including privacy-preserving MDC, across N distributed edge servers. The framework achieves privacy through Composite Element Distortion (CED)—a lightweight encryption method that combines Element-wise Obfuscation (EWO) and the Panth Rotation Theorem (PRT) to conceal both structural and numerical matrix content while preserving determinant properties. Parallel LU decomposition is used to distribute encrypted matrix blocks across an arbitrary number of untrusted edge servers, enabling efficient and scalable determinant computation. A one-way communication model further reduces coordination overhead by eliminating interserver interactions. To ensure result integrity with minimal client burden, we further introduce two verification algorithms: Q2 , a probabilistic scalar method, and Q3 , a deterministic and lowcomplexity alternative. Mathematical analysis demonstrates that the proposed framework provides strong privacy and security guaranties, low computational overhead, and deployment flexibility—making it well-suited for secure, scalable, and real-time MDC in distributed edgeassisted systems. Index Terms—Edge Computing, Matrix Determinant, Panth Rotation Theorem (PRT), Parallel Outsourcing, Privacy Preservation, Secure Computation, Secure Parallel Determinant Computation (SPDC)
I. INTRODUCTION
T
HE Rapid adoption of the Internet of Things (IoT) has led to a surge in data generation and inter-device communication, necessitating scalable and energy-efficient computational frameworks. Edge computing has emerged as a viable solution, reducing latency, optimizing bandwidth, and improving response times by processing data closer to its source [1], [2]. However, its decentralized nature introduces challenges in ensuring data privacy and computational security. Matrix determinant computation (MDC) is a fundamental operation in cryptography, machine learning, and artificial intelligence. Despite its significance, computing the determinant of large matrices remains computationally intensive. Methods such as LU decomposition incur a computational complexity of O(n3 ), making determinant calculation of large matrices Corresponding author: Prajwal Panth (email: [email protected]). School of Computer Engineering, KIIT Deemed to be University, Bhubaneswar, India.
impractical in resource-constrained edge environments [2], [3]. Secure outsourcing techniques, such as homomorphic encryption and secure multiparty computation (SMPC), face significant computational overhead that limits their real-time applicability [4], [5]. Existing parallel MDC solutions, such as the two-server model [6], also face scalability and efficiency challenges in large-scale distributed networks. To address these limitations, this paper introduces the Secure Parallel Determinant Computation (SPDC) framework, comprising three protocols: (i) the Privacy-Preserving Matrix Obfuscation Protocol (PMOP), (ii) the Secure Parallel Computation Protocol (SPCP), and (iii) the Result Recovery and Verification Protocol (RRVP). At its core, SPDC employs the Composite Element Distortion (CED) mechanism, designed to enable efficient parallel computation of matrix determinants over an arbitrary number of untrusted edge servers. CED integrates Element-wise Obfuscation (EWO) and Panth Rotation Theorem (PRT)-based obfuscation to jointly achieve computational efficiency and strong privacy protection. Specifically, EWO secures individual matrix entries through either Element-wise Division (EWD) or Element-wise Multiplication (EWM). In contrast, PRT-based obfuscation applies a geometric rotation that alters the structural representation of the matrix without affecting its determinant, thereby introducing an additional layer of security. Additionally, an N -server parallel LU decomposition model is introduced, overcoming the scalability limitations of twoserver approaches and reducing computational complexity from O(n3 ) to approximately O(n2 ). The proposed model optimizes computational resource utilization, minimizes latency, and integrates a matrix augmentation technique to handle nondivisible matrix sizes while preserving determinant accuracy. Mathematical evaluations using 3-server and 4-server configurations demonstrate its scalability and efficiency. To ensure result integrity, novel authentication algorithms (Q2 and Q3 ) are introduced, enabling the client to verify the correctness of results returned by edge servers with minimal computational overhead. By combining efficiency, scalability, and robust privacy mechanisms, this framework addresses critical challenges in privacy-preserving and secure MDC, making it a practical solution for real-time secure computations in distributed edge environments. II. CORE CONCEPTS AND TECHNIQUES EMPLOYED IN THE FRAMEWORK This section provides a comprehensive discussion of the mathematical techniques and computational methods used within the
2
Fig. 1. Visual abstract of the framework.
Fig. 3. System architecture.
Fig. 2. Algorithm flow and execution placement across client and edge servers in the proposed determinant computation framework.
proposed SPDC framework. These methods are fundamental to ensuring both the efficiency of parallel processing and the confidentiality of the data during computation.
A. PANTH ROTATION THEOREM (PRT) The PRT is a novel contribution to matrix theory, designed to facilitate privacy-preserving and secure matrix transformations by ensuring that the absolute value of the determinant remains invariant under specific geometric transformations. This theorem plays a pivotal role in obfuscating matrix elements without affecting the accuracy of the determinant calculation.
3
1) Theorem Let n be a natural number representing the size of a square matrix. The determinant of the matrix exhibits distinct behavior under rotations of 90◦ , 180◦ , 270◦ , and 360◦ , depending on the congruence class of n modulo 4: 1.1 For matrices of size n ≡ 2 (mod 4) or n ≡ 3 (mod 4): Rotations by 90° and 270° invert the sign of the determinant. • Rotations by 180° and 360° preserve the sign of the determinant. •
1.2 For matrices of size n ≡ 0 (mod 4) or n ≡ 1 (mod 4): •
Rotations by any angle (90°, 180°, 270°, and 360° do not alter the sign of the determinant.
To illustrate these transformations, consider the following 4 × 4 matrix X: X11 X12 X13 X14 X21 X22 X23 X24 X= X31 X32 X33 X34 X41 X42 X43 X44 The transformations of matrix X under various rotations are as follows: X41 X31 X21 X11 X42 X32 X22 X12 R90° (X) = X43 X33 X23 X13 , X44 X34 X24 X14 X44 X43 X42 X41 X34 X33 X32 X31 R180° (X) = X24 X23 X22 X21 , X14 X13 X12 X11 X14 X24 X34 X44 X13 X23 X33 X43 R270° (X) = X12 X22 X32 X42 . X11 X21 X31 X41 2) Proof The proof of the PRT involves analyzing the determinant behavior under different degrees of rotation. Each case examines how column and row operations affect the determinant. C ASE 1: 90° Rotation Consider an n × n matrix X. A 90° clockwise rotation of X, denoted as R90° (X), can be achieved by transposing X followed by reversing the order of the columns. The reversal of n columns can be performed through n2 swaps, where each swap inverts the determinant’s sign. Therefore, n det R90° (X) = (−1)[ 2 ] det(X) •
If nn = 4k or n = 4k + 1 for some positive integer k, then 2 = 2k, which is even, leading to det R90° (X) = det(X).
•
n If n = 4k + 2 or n = 4k + 3, then 2 = 2k + 1, which is odd, leading to det R90° (X) = − det(X).
C ASE 2: 180° Rotation A 180° rotation reverses the order of both rows and columns. Since the operation involves n2 swaps for rows and n2 swaps for columns, the total number of swaps is even, leaving the determinant unchanged regardless of the matrix size. Thus, n det R180° (X) = (−1)2[ 2 ] det(X) = det(X) C ASE 3: 270° Rotation A 270° rotation is equivalent to performing a 90° counterclockwise rotation, which is the same as three 90° clockwise rotations. Therefore, n n det R270° (X) = (−1)3[ 2 ] det(X) = (−1)[ 2 ] det(X) If nn = 4k or n = 4k + 1 for some positive integer k, then 2 = 2k, which is even, leading to det R270° (X) = det(X). n • If n = 4k + 2 or n = 4k + 3, then 2 = 2k + 1, which is odd, leading to det R270° (X) = − det(X). •
C ASE 4: 360° Rotation A 360° rotation returns the matrix to its original configuration: n det R360° (X) = (−1)4[ 2 ] det(X) = det(X) Thus for any n, det R360◦ (X) does not invert the sign. 3) Implications The PRT plays a pivotal role in enabling privacy-preserving matrix transformations. It guarantees that the absolute value of a determinant remains invariant under specific rotations, thereby safeguarding sensitive matrix data during outsourced computations. By bridging geometric transformations with algebraic properties, PRT contributes simultaneously to applied cryptography and theoretical linear algebra. In image processing, where matrices represent pixel data, PRT enables fast and secure rotations (90°, 180°, 270°) without altering fundamental image characteristics, thus supporting image encryption. Overall, PRT prevents information leakage during computation, ensures accurate determinant recovery after decryption, and strengthens the design of secure data outsourcing protocols. B. MATRIX AUGMENTATION In distributed systems, matrix augmentation ensures efficient parallel processing when the matrix size is not divisible by the number of servers. It allows balanced load distribution while preserving the determinant. 1) Definition and Statement Let A be an n × n square matrix. Consider an augmented (n + 1) × (n + 1) matrix B, where: • The upper-left n × n submatrix of B is identical to A, • The element at position (n + 1, n + 1) is set to 1,
4
Either the remaining elements of the (n + 1)-th row or the (n + 1)-th column are filled with zeros, and • The remaining n elements (in either the row or column not filled with zeros) may contain any real numbers. Under these conditions, det(B) = det(A). •
2) Relation to Block Triangular Matrices The augmentation process in this framework can be viewed as a specific instance of block matrices, where additional rows and columns are introduced without altering the determinant. The augmented matrix B can be expressed as: A 0 B= , R C where A is the original n × n matrix, R is a row vector of size 1 × n containing real numbers, and C is a scalar set to one. The addition of R and a zero-filled column ensures that the determinant of the augmented matrix remains unchanged from the original matrix. 3) Implication • Facilitates parallel computation by ensuring equally sized submatrices for all servers. • Allows even-sized partitioning, making it compatible with scalable parallel LU decomposition. • Improves computational efficiency in distributed systems by optimizing task distribution while maintaining determinant accuracy. C. LU FACTORIZATION LU factorization decomposes a nonsingular n × n matrix A into a lower triangular matrix L and an upper triangular matrix U , expressed as A = L × U [3]. This simplifies determinant computation since the determinant of a triangular matrix is the product of its diagonal elements. In distributed systems, parallelizing LU factorization improves efficiency by distributing workloads for faster computation. III. DEFINITIONS In this section, we introduce the SPDC framework and define its associated security guarantees.
1) Seed Generation Algorithm: SeedGen(λ1 , M) → (Ψ, µ, Mmax ). Given the input matrix M and security parameter λ1 , the client generates a secure pseudo-random number, referred to as Seed(Ψ), based on the matrix’s statistical characteristics (mean µ and maximum value Mmax ) along with λ1 . This seed is used for subsequent key generation and encryption. 2) Key Generation Algorithm: KeyGen(λ2 , Ψ, µ, Mmax ) → K. With the seed Ψ, matrix properties µ and Mmax , and an additional security parameter λ2 , the client generates a secret key K, which includes a blinding vector v to obfuscate the matrix during encryption. 3) Data Protection Algorithm: Cipher(K, M) → X. The client uses the secret key K to encrypt the matrix M, resulting in the ciphertext matrix X. The encryption process involves EWD by the blinding vector v and the application of the PRT to maintain the matrix’s determinant properties while obfuscating its structure. 4) Parallel Computation Algorithm: Parallelize(X) → (L, U ). For the ciphertext matrix X, edge servers compute the LU decomposition in parallel. The matrix is divided into submatrices and distributed to an arbitrary number of untrusted servers for efficient computation of the matrix determinant. 5) Result Authentication Algorithm: Authenticate(L, U, X) → {1, 0}. After receiving the LU decomposition results from the servers, the client verifies their correctness. If the results are valid, the output is 1; otherwise, it is 0. Authentication is performed using lightweight authentication formulas Q2 and Q3 , which reduce computational load. 6) Result Decryption Algorithm: Decipher(Ψ, L, U ) → det(M). The client uses the seed Ψ and the verified LU decomposition results to compute the determinant of the original matrix M, ensuring correctness and privacy of the outsourced computation. B. SECURITY DEFINITION A SPDC framework must ensure the security of both the matrix and its determinant, even when outsourced to untrusted edge servers. This guarantees data confidentiality, computational integrity, and protection against adversarial attacks.
Fig. 4. Process workflow.
A. FRAMEWORK Our SPDC framework consists of three protocols (PMOP, SPCP, and RRVP), each implemented using a set of algorithms. The framework is represented as a tuple of six core algorithms, (SeedGen, KeyGen, Cipher, Parallelize, Authenticate, Decipher), where each algorithm is formalized as follows:
Definition 1 (Blinding Vector and Rotational Obfuscation Security). The matrix encryption process employs a blinding vector derived from the matrix seed Ψ in combination with rotational obfuscation via the Panth Rotation Theorem (PRT), thereby concealing both the matrix structure and its determinant. Given an encrypted matrix X, an adversary’s probability Pr of inferring the original matrix M or its determinant is negligible, bounded by ϵ(λ), where λ is the security parameter. • Indistinguishability: For any adversary A attempting to infer the original matrix M or its determinant from
5
the encrypted matrix X, the probability Pr of success is negligible. Formally, Pr[A(X) → M or det(M)] ≤ ϵ(λ),
stage is carefully designed to maintain privacy, optimize efficiency, and ensure an accurate recovery of the matrix determinant.
where ϵ(λ) is a negligible function in λ. As the security parameter λ increases, the probability of a successful attack approaches zero. • Determinant Preservation: The determinant of the encrypted matrix differs from that of the original matrix but can be fully restored upon decryption with the seed Ψ, following the relationship:
A. SEED GENERATION ALGORITHM (SEEDGEN) SeedGen(λ1 , M) → (Ψ, µ, Mmax ). The SeedGen algorithm generates a secure seed Ψ based on the input matrix M = (mij ) and cryptographic security parameter λ1 . To generate Ψ, the algorithm first computes the statistical properties of the matrix, specifically the mean µ and the maximum value Mmax , defined as:
det(M) = det(A) × Correction Factor
1 XX µ= 2 mij n i=1 j=1
Definition 2 (Correctness of Outsourced Computation). After parallel LU decomposition is performed on the encrypted matrix X, the client must verify the correctness of the results [7]. This is done through lightweight authentication algorithms that confirm the validity of the reconstructed matrix X ′ = L × U , where L and U are the LU components returned by edge servers. ′ • Consistency: The reconstructed matrix X approximates the original encrypted matrix X within a small threshold ϵ, ensuring that deviations are only due to numerical inconsistencies, not malicious tampering: | det(X ′ ) − det(X)| < ϵ •
Efficient Authenticity: The authentication process relies on lightweight computations, ensuring that the client, even with limited computational resources, can efficiently verify the correctness of the LU decomposition computation.
Definition 3 (Resilience to Collusion). This security property of the framework ensures resilience to collusion between multiple edge servers. Even if a subset of servers colludes to share intermediate results, they cannot reconstruct the original matrix or its determinant. This is achieved through the distribution of encrypted submatrices and the sequential one-way communication pattern between servers. The probability Pr that a subset of servers S ′ can successfully reconstruct the matrix M or its determinant from the encrypted data X is negligible, expressed mathematically as: Pr[S ′ (X) → M or det(M)] < ϵ(λ) This definition ensures resilience against potential collusion among servers, thereby preserving the confidentiality of the matrix across distributed environments. By preventing any individual or group of servers from gaining insights into the data, this framework maintains data confidentiality and robustness in multi-server architectures. IV. PROTOCOL CONSTRUCTION We construct a SPDC framework for MDC, consisting of six key stages: SeedGen, KeyGen, Cipher, Parallelize, Authenticate, and Decipher. This framework enables secure outsourcing of MDC tasks to an arbitrary number of untrusted edge servers, ensuring both data confidentiality and computational integrity through advanced cryptographic and algebraic methods. Each
n
n
Mmax = max(mij ),
∀i, j
These statistical properties provide matrix-specific randomness, ensuring that the seed reflects the internal structure of the matrix. The security parameter λ1 , combined with these statistical properties, contributes to the cryptographic strength of the seed. The seed Ψ is computed as: Ψ = H(λ1 , µ, Mmax ) where H is a cryptographic hash function, ensuring that Ψ is unpredictable and resistant to adversarial attacks. The computed seed Ψ, along with the matrix’s mean µ and maximum Mmax , will be used in the key generation process to ensure secure randomization and matrix obfuscation. B. KEY GENERATION ALGORITHM (KEYGEN) KeyGen(λ2 , Ψ, µ, Mmax ) → K. The KeyGen algorithm generates the secret key K used for encryption. It relies on the seed Ψ, matrix properties µ and Mmax , and the cryptographic parameter λ2 . Given the seed Ψ, the matrix properties, the key generation algorithm constructs a blinding vector v = [v1 , v2 , . . . , vn ], which is used to obfuscate the matrix elements during encryption. The elements of the blinding vector v are selected to satisfy the condition: n Y vi = Ψ, vi ̸= 1 ∀i ∈ [1, n] i=1
The blinding vector v is generated using a cryptographically secure pseudorandom number generator (CSPRNG or any), which guarantees the security and unpredictability of the vector elements. This ensures that even if an adversary obtains the ciphertext matrix X, they will be unable to reconstruct the original matrix M without access to the complete blinding vector. The secret key K = {v} is securely stored by the client and is used to cipher the matrix M into its encrypted form X. C. DATA PROTECTION ALGORITHM (CIPHER) Cipher(K, M) → X. The Cipher algorithm applies CED, a dual-layer encryption method combining EWO and PRTbased Obfuscation to secure both matrix values and structure efficiently. These obfuscation techniques run simultaneously, not only to enhance security but also to reduce the time complexity of ciphering.
6
1) Element-wise Obfuscation (EWO): It obfuscates each element of matrix M through one of two distinct transformations: 1.1 Element-wise Division (EWD): Each element mij of the original matrix is divided by the corresponding element of the blinding vector: mij m′ij = vi 1.2 Element-wise Multiplication (EWM): Alternatively, the matrix can be transformed by multiplying each element mij of M by the corresponding element of the blinding vector: m′ij = mij × vi These transformations conceal individual values, preventing unauthorized access. 2) PRT-based Obfuscation: In addition to EWO, the matrix simultaneously undergoes PRTbased Obfuscation, a rotational obfuscation technique based on PRT. This obfuscation preserves the matrix determinant while altering its spatial arrangement by rotating the matrix by a fixed angle (90◦ , 180◦ , or 270◦ ), depending on the seed value Ψ. The degree of rotation is determined by the Rotate(Ψ) function: ◦ 1 if 90 rotation is required Rotate(Ψ) = 2 if 180◦ rotation is required 3 if 270◦ rotation is required Given a seed value Ψ, the Rotate(Ψ) function determines the appropriate rotation, returning a value in the set {1, 2, 3} that corresponds to the rotation angles. The seed value Ψ may initially be a floating-point number. To convert Ψ into a Quantized Seed (Ψ′ ) for rotation selection, one of the following methods is employed: ′ • Floor Function: Ψ = ⌊Ψ⌋ ′ • Ceiling Function: Ψ = ⌈Ψ⌉ ′ • Round Function: Ψ = round(Ψ) ′ • Truncation: Ψ = int(Ψ) Once Ψ′ is derived, it is mapped to the rotation set {1, 2, 3} using various methods, one of which is illustrated below: Rotation Degree = (Ψ′ mod 3) + 1 This ensures a pseudo-random yet deterministic rotation based on the seed value, making it infeasible for an adversary to reconstruct the original matrix even if some element values are known.
Unlike recent work such as [6], which implements parallel determinant outsourcing using a fixed 2-server architecture (N = 2), our protocol introduces a generalized formulation that supports any number of servers N ≥ 2. The underlying structure is formally parameterized, enabling deployment across diverse edge environments with varying numbers of computational nodes. When instantiated with N = 2, our formulation reduces to the approach in [6], thereby preserving compatibility while extending parallelism to arbitrary configurations. Additionally, for input matrices whose dimensions are not evenly divisible by N , a determinant-preserving augmentation technique is applied. This ensures uniform partitioning across all servers without compromising correctness, thereby maintaining computational balance and accuracy under varied input scenarios. 1) Matrix Partitioning and Augmentation The client C partitions the encrypted input matrix X into smaller submatrices and distributes them among edge servers for parallel processing. If the input matrix of size n × n is not evenly divisible by the number of servers N such that the resulting submatrix size is greater than 1, the matrix is augmented. Specifically, the matrix is augmented to a size of (n + p) × (n + p), where p is the minimum positive integer that ensures both: n+p • N is an integer, and n+p • N > 1. After augmentation, the matrix is partitioned into N 2 subma n+p trices, each of size n+p × . N N 1.1 Examples Example 1: 3-Server Setup with a 4 × 4 Input Matrix For N = 3 and an input matrix of size 4 × 4, we require 4+p 4+p > 1 and ∈ Z. 3 3 The smallest p that satisfies these conditions is p = 2, so the augmented matrix becomes (4 + 2) × (4 + 2) = 6 × 6. This matrix is then partitioned into 32 = 9 submatrices, each of size (3/2) × (3/2) = 2 × 2. Example 2: 2-Server Setup with a 6 × 6 Input Matrix For N = 2 and an input matrix of size 6 × 6, we compute 6+p . 2 Since 6 is already divisible by 2 (with 62 = 3 > 1), we set p = 0. The matrix is partitioned into 22 = 4 submatrices, each of size 3 × 3. In this configuration, each server is assigned two submatrices. 1.2 Assignment of Submatrices
D. PARALLEL COMPUTATION ALGORITHM (PARALLELIZE) Parallelize(X) → (L, U ). The Parallelize algorithm enhances the efficiency of MDC by distributing workloads across an arbitrary number of untrusted edge servers, overcoming the scalability limits of traditional 2-server MDC frameworks.
In all configurations, the N 2 submatrices are allocated among the N servers according to a row-wise scheme. For example, in the generalized N -server setup, if the submatrices are labeled Xij (where i, j = 1, 2, . . . , N ), then: •
Server S1 : Handles submatrices X11 , X12 , X13 , . . . , X1N
7
Server S2 : Handles submatrices X21 , X22 , X23 , . . . , X2N • Server S3 : Handles submatrices X31 , X32 , X33 , . . . , X3N .. . •
•
Server SN : Handles submatrices XN 1 , XN 2 , XN 3 , . . . , XN N
Following the initial LU decomposition on their respective submatrices, servers exchange the necessary intermediate results to the next server to ensure the overall computational integrity. 2) The Algorithm The parallel LU decomposition model for two servers has been previously established in the literature [6]. We extend this by implementing a scalable model across multiple edge servers, including 3-server, 4-server, and generalized N server configurations. Starting with the 3-server setup, we demonstrate improved efficiency over the 2-server model. This foundation extends to 4 servers, illustrating scalability for complex computations, and ultimately generalizes to N -servers for efficiently handling larger datasets and utilizing greater computational resources.
1: S1 performs LU factorization on X11 s.t. X11 = L11 × U11 and sends U11 to S2 . First Computation & Communication Phase: 2: S1 computes U12 = L−1 11 X12 , then sends U12 to S2 . −1 3: S2 activates and computes L21 = X21 U11 . Second Computation & Communication Phase: 4: S1 computes U13 = L−1 11 X13 and sends U13 to S2 . 5: S2 updates X22 = X22 − (L21 U12 ). 6: S2 sends {U11 , U12 } to S3 . Third Computation & Communication Phase: 7: S1 returns result res1 = {L11 , U11 , U12 , U13 } to C. 8: S2 performs X22 = L22 × U22 . 9: S2 sends {U13 , U22 } to S3 . −1 10: S3 activates and computes L31 = X31 U11 . Fourth Computation & Communication Phase: 11: S2 computes U23 = L−1 22 (X23 − L21 U13 ). 12: S2 sends U23 to S3 . −1 13: S3 computes L32 = U22 (X32 − L31 U12 ). Final Computation Phase: 14: S2 returns result res2 = {L21 , L22 , U22 , U23 } to C. 15: S3 computes X33 = X33 − (L31 U13 + L32 U23 ), then X33 = L33 × U33 . 16: S3 returns result res3 = {L31 , L32 , L33 , U33 } to C. Final Output Integration: 17: C integrates res1 , res2 , and res3 into L and U . 2.2 Four-Server LU Decomposition Algorithm Algorithm 2: 4-Server Parallel Computing. Input: The ciphertext blocks Xij (1 ≤ i, j ≤ 4). Output: The computation results L and U . Initial Phase: 1: S1 performs LU factorization on X11 s.t. X11 = L11 × U11 and sends U11 to S2 . First Computation & Communication Phase: 2: S1 computes U12 = L−1 11 X12 , then sends U12 to S2 . −1 3: S2 activates and computes L21 = X21 U11 . Second Computation & Communication Phase: 4: S1 computes U13 = L−1 11 X13 and sends U13 to S2 . 5: S2 updates X22 = X22 − (L21 U12 ). 6: S2 sends {U11 , U12 } to S3 .
Fig. 5. Three-server parallel LU decomposition process.
2.1 Three-Server LU Decomposition Algorithm Algorithm 1: 3-Server Parallel Computing. Input: The ciphertext blocks Xij (1 ≤ i, j ≤ 3). Output: The computation results L and U . Initial Phase:
Third Computation & Communication Phase: 7: S1 computes U14 = L−1 11 X14 . 8: S1 sends U14 to S2 . 9: S2 performs X22 = L22 × U22 . 10: S2 sends {U13 , U22 } to S3 . −1 11: S3 activates and computes L31 = X31 U11 . Fourth Computation & Communication Phase: 12: S1 returns result res1 = {L11 , U11 , U12 , U13 , U14 } to C. 13: S2 computes U23 = (X23 − L21 U13 )L−1 22 . 14: S2 sends {U14 , U23 } to S3 .
8
−1 15: S3 computes L32 = (X32 − L31 U12 )U22 . 16: S3 sends {U11 , U12 , U13 , U22 } to S4 .
8: Updates Xii :
Fifth Computation & Communication Phase: 17: S2 computes U24 = (X24 − L21 U14 )L−1 22 . 18: S2 sends U24 to S3 . 19: S3 updates X33 = X33 − (L31 U13 + L32 U23 ). −1 20: S4 activates and computes L41 = X41 U11 . Sixth Computation & Communication Phase: 21: S2 returns result res2 = {L21 , L22 , U22 , U23 , U24 } to C. 22: S3 performs X33 = L33 × U33 . 23: S3 sends {U24 , U33 } to S4 . −1 24: S4 computes L42 = (X42 − L41 U12 )U22 . Seventh Computation & Communication Phase: 25: S3 computes U34 = (X34 − (L31 U14 + L32 U24 ))L−1 33 . 26: S3 sends U34 to S4 . −1 27: S4 computes L43 = (X43 − (L41 U13 + L42 U23 ))U33 . Eighth Computation & Communication Phase: 28: S3 returns result res3 = {L31 , L32 , L33 , U33 , U34 } to C. 29: S4 updates X44 = X44 − (L41 U14 + L42 U24 + L43 U34 ). 30: S4 performs X44 = L44 × U44 . 31: S4 returns result res4 = {L41 , L42 , L43 , L44 , U44 } to C. Final Output Integration: 32: Client C integrates res1 , res2 , res3 , res4 into L and U . 2.3 N-Server LU Decomposition Algorithm
Input: The ciphertext blocks Xij (1 ≤ i, j ≤ N ). Output: The computation results L and U . S1 Computation: 1: Performs LU factorization on X11 s.t. X11 = L11 × U11 . 2: Computes U1j = L−1 11 X1j (for j = 2, . . . , N ). • Sends U1j (for j = 1, . . . , N ) to S2 . • Returns result res1 = {L11 , U1j } (j = 1, . . . , N ) to C. S2 Computation: −1 3: Computes L21 = X21 U11 . 4: Updates X22 = X22 − (L21 U12 ). 5: Performs X22 = L22 × U22 . 6: Computes U2j = (X2j − L21 U1j )L−1 22 for j = 3 to N . • Forwards the received results from the previous server to S3 . • Sends the computed values U2j (for j = 2 to N ) to S3 . • Returns result res2 = {L21 , L22 , U2j } (for j = 2 to N ) to C. Si Computation: 7: Computes Li1 , Li2 , . . . , Li(i−1) : −1 Lik = Ukk
Xik −
! Lim Umk
m=1
∀k = 1, . . . , i − 1.
i−1 X
Lik Uik .
k=1
9: Performs Xii = Lii × Uii . 10: Computes Uij for j = i + 1 to N : Uij = L−1 ii
Xij −
i−1 X
! Lik Ukj
.
k=1
Forwards the received results from the previous server along with the computed Uij to Si+1 . • Returns result resi , resi = {Li1 , . . . , Lii , Uii , Ui(i+1) , . . . , UiN } to C. •
SN Computation: 11: Computes LN 1 , LN 2 , . . . , LN (N −1) : −1 LN k = Ukk
XN k −
k−1 X
! LN m Umk
,
m=1
∀k = 1, . . . , N − 1. 12: Updates XN N : XN N = XN N −
N −1 X
LN k UkN .
k=1
13: Performs XN N = LN N × UN N . • Returns result resN = {LN 1 , LN 2 , . . . , LN N , UN N } to C. Final Output Integration: 14: Client C integrates res1 , . . . , resN into L and U .
Algorithm 3: N-Server Parallel Computing.
k−1 X
Xii = Xii −
,
The integrated representation of the results res1 , . . . , resN is given by: L11 0 ··· 0 L21 L22 · · · 0 L= . .. .. .. .. . . . LN 1 and
U11 0 U= . .. 0
LN 2
···
· · · U1(N −1) · · · U2(N −1) .. .. . . ··· 0
LN N U1N U2N .. . . UN N
3) Inter-Server Communication Pattern The proposed parallel LU decomposition algorithm is designed to minimize idle time and reduce communication overhead between servers. In all configurations, in earlier multi-server models, communication follows a one-way result transfer pattern, in which each server transmits its computed results (i.e., Uij ) to the immediate downstream server. In earlier multi-server models, each server was required to broadcast its results to all downstream servers, causing significant delays as downstream servers had to wait for data from multiple upstream servers before initiating their computations.
9
In contrast, our proposed multi-server model improves efficiency by ensuring that each server activates its immediate successor after completing its first task in the case of S1 to S2 , and after completing its first two tasks in all other cases (e.g., Si to Si+1 , where i > 1). Once these initial tasks are completed, the server sends the necessary results to the next downstream server, allowing it to smoothly begin its computations while the current server continues to compute and send further results in parallel. This staggered communication pattern reduces waiting time for downstream servers, ensuring that computations proceed in a parallelized manner, thereby maintaining full utilization of resources. E. RESULT AUTHENTICATION ALGORITHM (AUTHENTICATE) Authenticate(L, U, X) → {1, 0}. The Authenticate algorithm ensures the correctness of the LU decomposition while maintaining computational efficiency. During the LU decomposition of the submatrices of X, the corresponding blocks Lij and Uij are combined to form the full L and U matrices of size n × n. When reconstructing X ′ as L × U, the reconstructed matrix X ′ may match X exactly on an element-wise basis, but the determinant of X remains equal to or approximately equal. This discrepancy arises from both floating-point inconsistencies and the design of the parallel computing algorithm. While determinant comparisons could theoretically serve as a correctness check, computing the determinant of large matrices is computationally expensive, particularly on resourceconstrained edge devices, making this method impractical in these scenarios. To overcome this, we use lightweight authentication to avoid matrix-matrix multiplications. Gao et al. [6] proposed an authentication formula, which we denote as Q1 , that reduces matrix-matrix operations to matrix-vector operations using a random vector r. We introduce Q2 and Q3 for greater efficiency in parallel computing: Q2 uses a random vector, while Q3 works directly on diagonal elements, eliminating the need for randomization. Unlike Q1 , both Q2 and Q3 return scalar values rather than vector output, making authentication more efficient. 1) Existing Formula: Q1 Q1 = L × (U × r) − Xr Produces a vector output of size 1 × n. In an ideal scenario, if Q1 = (0, 0, . . . , 0)T , the authentication succeeds (i.e., decomposition is correct). Otherwise, the result is rejected. 2) Our Contributions: Q2 and Q3 We introduce two new authentication formulas that return scalar outputs, making them computationally lighter and easier to handle than the vector output of Q1 . Q2 – Scalar-Based Random Vector Authentication: Q2 = (LT r)T × (U r) − (rT × X)r Relies on a random vector r ∈ Rn , but it returns a scalar result.
Q3 – Deterministic Scalar-Based Authentication: Q3 =
n X i X
(Lij Uji ) − xii
i=1 j=1
Relies solely on the deterministic values of the diagonal elements in L, U , and X. It offers a quick and effective verification without requiring randomization. For both Q2 and Q3 , in 2-server implementations, they return zero when the decomposition is correct. In multi-server cases, achieving zero is challenging, so a threshold ϵ is introduced to account for these deviations. 3) Introduction of Threshold ϵ A threshold ϵ(N ) is introduced to account for numerical deviations that arise due to design limitations of the parallel computing algorithm and floating-point precision limitations. As N increases, ϵ(N ) adapts to compensate for discrepancies between X and X ′ , ensuring reliable authentication. The decomposition is validated if |Q| < ϵ(N ), returning Authenticate = 1; otherwise, it is rejected with Authenticate = 0. F. RESULT DECRYPTION ALGORITHM (DECIPHER) Decipher(Ψ, L, U ) → det(M). Upon successful authentication, the client decrypts the determinant of the original matrix M without relying on the secret key K, reducing security risks of K being exposed. Instead, a seed-based correction factor Ψ is used. 1) Determinant Computation of Ciphertext Matrix X: The determinant of the matrix X is computed from the diagonal elements of the matrices L and U : n Y det(X) = (Lii × Uii ) i=1
2) Determinant Recovery for Original Matrix M : Depending on the obfuscation method used during encryption, M’s determinant is retrieved as follows: 2.1 For EWD + PRT: res = det(X) × (−1)Rotate(Ψ) × Seed(Ψ) 2.2 For EWM + PRT: det(X) × (−1)Rotate(Ψ) Seed(Ψ) The final result res denotes the determinant of the plaintext matrix M. By employing the seed-based correction factor during the deciphering process, this approach ensures determinant integrity while mitigating risks associated with key exposure. res =
V. THEORETICAL ANALYSIS This section establishes the theoretical foundations of the proposed SPDC framework, covering Integrity, Privacy, and Authenticity through mathematical proofs and practical considerations. This demonstrates the reliability, scalability, and security of the framework.
10
Fig. 6. Four-server parallel LU decomposition process.
A. INTEGRITY The protocol ensures the client obtains the correct determinant of the original matrix M, despite computations being performed on its encrypted counterpart X. This integrity is maintained through secure partitioning, parallel LU decomposition, and result authentication. 1) Parallel LU Decomposition After encryption, the matrix M is transformed into the matrix X, which is divided into submatrices and distributed across N edge servers for parallel LU decomposition. Each server Si begins the computation on its assigned submatrices and incrementally incorporates intermediate results received from upstream servers S1 , . . . , Si−1 , thereby ensuring both consistency and integrity throughout the computation.
Xii ← Xii −
i−1 X
Lij Uji
j=1
Only after receiving these updates, server Si can proceed with its own LU decomposition:
Xii = Lii Uii
This ensures that all computations integrate previous results, maintaining the correctness of LU factorization.
11
2) Determinant Computation After receiving L and U , the client reconstructs X and computes the determinant: det(X) =
n Y
Lii ×
i=1
n Y i=1
Uii =
n Y
(Lii × Uii )
i=1
The determinant of M is then recovered based on the applied EWO transformation: • For EWD: det(M) = det(X) × (−1)Rotate(Ψ) × Seed(Ψ) •
For EWM: det(M) =
det(X) × (−1)Rotate(Ψ) Seed(Ψ)
Thus, if all servers adhere to the protocol, the determinant remains correct and tamper-resistant.
MR = Rθ (M) det(MR ) = det(M) × (−1)Rotate(Ψ) where θ ∈ {90◦ , 180◦ , 270◦ } is determined by the seed Ψ. This prevents pattern leakage and guarantees confidentiality, since even with access to X, L, or U , an adversary cannot reconstruct M without knowledge of Ψ. 2) Output Privacy Output privacy guarantees that the adversary cannot compute the true determinant det(M) from the outsourced computation results, even if they gain access to intermediate values (i.e., Lij and Uij ) or the fully encrypted matrix X. It is preserved by the dependency of the determinant recovery formula on the seed Ψ and the obfuscation method applied: •
det(M) = det(X) × (−1)Rotate(Ψ) × Seed(Ψ)
B. PRIVACY The framework ensures input and output privacy through CED to protect both matrix elements and determinants. 1) Input Privacy Input privacy is preserved through the combined use of two key techniques: EWO and the PRT-based obfuscation. Together, these transformations obfuscate both the values and structural arrangement of M, resulting in X, which is computationally indistinguishable from a random matrix. 1.1 Element-wise Obfuscation (EWO) via Blinding Vector: Each element mij of M is obfuscated as: mij ′ • EWD: mij = vi ′ • EWM: mij = mij × vi Here, v = [v1 , v2 , . . . , vn ] is a secret blinding vector derived from Ψ, ensuring that X remains computationally indistinguishable from random noise. Even if an adversary obtains full access to X, they cannot reconstruct M without knowing vi for each element, as reversing EWD or EWM operations requires exact knowledge of vi in each transformation. Since v is derived from the cryptographic seed Ψ, which is kept private, the probability of successfully guessing v (and thereby reversing the transformations) is negligible.
If EWD was applied:
•
If EWM was applied: det(M) =
det(X) × (−1)Rotate(Ψ) Seed(Ψ)
Seed(Ψ) is derived from the security parameter and mathematical properties of M. It is generated from a cryptographic source, ensuring that any attempt to infer det(M) remains infeasible under standard cryptographic assumptions. To further ensure privacy, the one-way inter-server communication pattern, where an upstream server passes intermediate Uij results only to its adjacent downstream server, restricts each server to partial computations. This prevents any single entity from reconstructing X or computing det(M). Even in the event of collusion and access to X, servers lack access to the blinding vector and Ψ, making it impossible to recover M or det(M). This resilience to collusion is mathematically characterized by the information-theoretic guarantees provided by the protocol. For a probabilistic polynomial-time (PPT) adversary A with access to X, L, and U , the probability of successfully computing det(M) remains negligible:
1.2 Structural Obfuscation via Panth Rotation Theorem (PRT): To further protect matrix structure, elements of matrix M are simultaneously rotated by a fixed rotation angle based on the quantized seed Ψ′ . The rotation angle is computed based on the function Rotate(Ψ), defined as: ◦ if (Ψ′ mod 3) + 1 = 1 90 ◦ Rotate(Ψ) = 180 if (Ψ′ mod 3) + 1 = 2 ◦ 270 if (Ψ′ mod 3) + 1 = 3
where λ is the security parameter tied to seed(Ψ). This guarantees that cryptographic obfuscation and structured scrambling effectively safeguard both input and output privacy under adversarial conditions.
The rotated matrix, denoted as MR , scrambles the spatial arrangement of the matrix elements without altering the matrix’s determinant. Mathematically, for matrix M, we represent this rotation as:
To ensure the correctness of LU decomposition in a multiserver environment, we analyze the mathematical foundations of the proposed Q2 and Q3 authentication methods, proving their reliability in verifying computational integrity.
Pr[A(det(X), L, U ) = det(M)] ≤ negl(λ)
C. AUTHENTICITY
12
TABLE I C OMPARISON OF THE C OMPUTATIONAL OVERHEAD Protocols [Reference]
SeedGen (biops)
KeyGen (biops)
Cipher (flops)
Authenticate (biops + flops)
Decipher (flops)
Lei et al. [1] Fu et al. [8] Liu et al. [9] Gao et al. [6] Our protocol
N/A N/A N/A N/A 2n
(nm′ + 2n + 3m′ )s (2nm′ + n + 2m′2 )s 2ns ns ns
2(n + m′ )2 m′ (n + m′ )2 + n2 4n2 2n2 n2
l(n + m′ )s + 2l(n + m′ )2 l(n + m′ )s + 2l(n + m′ )2 lns + 2ln2 ns + 2n2 0 + 2n(n + 1) (Q3 )
4n + 5m′ 3n + 2m′3 + 2m′ 3n 3n 2n
1) Proof of Correctness for Q2 The Q2 authentication formula uses a random vector r ∈ Rn to validate LU decomposition: Q2 = (L⊤ r)⊤ (U r) − (r⊤ X)r For an accurate LU decomposition, X = L × U . Substituting this into Q2 : Q2 = ((Lr)⊤ (U r)) − (r⊤ (LU )r)
VI. PERFORMANCE EVALUATION This section presents a detailed performance evaluation of the proposed privacy-preserving and secure determinant computation protocol. Focusing on theoretical analysis rather than experimental testing, we assess computational complexity, communication cost, verification overhead, and deployment suitability. The results are benchmarked against state-of-the-art protocols [1], [6], [8], [9] to demonstrate comparative efficiency, scalability, and practicality.
Expanding both terms: ((Lr)⊤ (U r)) = r⊤ LU r,
and
(r⊤ (LU )r) = r⊤ LU r
Since both expressions are equal, we obtain: Q2 = 0 Thus, Q2 = 0 confirms the correctness of LU decomposition. If Q2 ̸= 0, it indicates computational errors or potential tampering, thereby signaling a failure in the decomposition. 2) Proof of Correctness for Q3 The Q3 authentication formula relies on diagonal consistency within L, U , and X: Q3 =
n X i X (Lij Uji ) − xii i=1 j=1
For a correctly decomposed matrix, each diagonal element xii of X is given by: xii = Lii × Uii Substituting into Q3 : Q3 =
n X
|Lii Uii − xii | = 0
A. COMPUTATIONAL OVERHEAD Table I compares the computational costs of the algorithms used in each protocol. Our proposed protocol demonstrates the lowest overall complexity across all stages. Its streamlined encryption, authentication, and decryption processes significantly reduce the computational burden on both client and server. Unlike prior methods, it avoids redundant operations and multiple verification rounds under normal conditions, with additional computations required only when the server returns incorrect results. The parallel structure further enhances performance in large-scale, edge-oriented environments. For fairness and consistency, comparative metrics for existing protocols are referenced from Gao and Yu [6]. The overhead values, measured in floating-point operations (flops) and bitwise operations (biops), directly reflect actual resource consumption in high-performance computing contexts. Overall, our proposed framework emerges as the most scalable and practical solution for secure and privacy-preserving determinant computation, enabling secure outsourcing without imposing excessive load on clients or edge devices.
i=1
Thus, Q3 = 0 guarantees correct LU decomposition, while deviations indicate computational inconsistencies. 3) Numerical Discrepancies in Multi-Server Implementations According to Section IV-E-3, when the protocol is implemented across more than 2 servers, slight numerical discrepancies arise primarily due to design limitations of the parallel computing algorithm and floating-point precision limitations. To accommodate this, authentication incorporates a threshold ϵ(N ): |Q| ≤ ϵ(N ) where Q ∈ {Q2 , Q3 } Here, ϵ(N ) increases as the number of servers N grows, ensuring robust authentication without unnecessary rejection.
B. PROTOCOL CHARACTERISTICS Table II presents a comparative view of fundamental protocol characteristics, including privacy preservation, parallel outsourcing capability, and supported threat models. Early approaches such as [1] lack both privacy protection and parallelism, while others like [8], [9] offer privacy guarantees but rely on serial computation or assume weaker adversaries. The recent work in [6] advances toward parallel outsourcing under a malicious model, yet remains constrained to two servers and even-sized matrices. In contrast, the proposed protocol uniquely integrates all three properties: privacy preservation, parallel outsourcing, and malicious adversary resistance, within a lightweight and
13
TABLE II P ROTOCOL C HARACTERISTICS C OMPARISON Protocols [Reference]
Privacy Preserving
Parallel Outsourcing
Threat Model
Lei et al. [1] Fu et al. [8] Liu et al. [9] Gao et al. [6] Our protocol
No Yes Yes Yes Yes
No No No Yes Yes
Malicious Honest-but-curious Malicious Malicious Malicious
TABLE IV C OMPARISON OF P ROTOCOLS BY D IMENSION E XTENSION M ECHANISM Protocols
Dimension Extension Mechanism
Lei et al. [1]
Always extends to (n + m′ ) × (n + m′ ) via block augmentation Always extends to (n + m′ ) × (n + m′ ) via block augmentation Works directly on original n × n matrix Only partitions even-sized matrices into blocks for parallel processing Pads odd n to next even; can optionally pad even n as per server requirements
Fu et al. [8] Liu et al. [9] Gao et al. [6] Our protocol
scalable architecture. This is achieved through a combination of formal parameterization, modular algorithm design, and parallel execution strategies. The use of a sequential oneway communication pattern between servers helps reduce coordination overhead and simplifies parallel computation. Moreover, the protocol supports flexible deployment across any number of servers, including resource-constrained edge nodes. As a result, it enables efficient and secure determinant outsourcing for all square matrices, without the structural or trust limitations observed in prior work.
servers to accelerate determinant evaluation, the protocol pads even-sized matrices if the input is too small to be evenly partitioned across all N servers, ensuring balanced encrypted block distribution. This design achieves a balance between computational efficiency and correctness, ensuring result fidelity across diverse matrix types and deployment scenarios. D. DEPLOYMENT AND CLIENT COMPATIBILITY
C. MATRIX TYPE SUPPORT AND DIMENSION EXTENSION In MDC, handling both even- and odd-sized square matrices is critical. While determinants are defined for all square matrices, privacy-preserving protocols impose constraints that either disallow odd dimensions or require large padding to convert them into suitable even-sized matrices. Such differences directly impact computational efficiency and numerical accuracy. TABLE III C OMPARISON OF P ROTOCOLS BY M ATRIX S UPPORT AND E XTENSION Protocols [Reference]
Supported Matrix Types
Requires Dimension Extension?
Lei et al. [1] Fu et al. [8] Liu et al. [9] Gao et al. [6] Our protocol
Even & Odd Even & Odd Even & Odd Even only Even & Odd
Yes (always force-padded) Yes (always force-padded) No (padding not required) No (odd sizes not supported) Yes (only when needed)
Table III compares representative protocols in terms of their ability to process even- and odd-sized square matrices and whether dimension extension is required. For instance, Lei et al. [1] and Fu et al. [8] enforce padding for all input sizes, while Gao et al. [6] entirely exclude odd-sized matrices from consideration. Liu et al. [9] avoid padding, directly supporting both cases. Our protocol, in contrast, supports both even and odd dimensions, applying minimal padding only when strictly necessary. Table IV details the mechanisms by which protocols extend matrix dimensions when required. Most prior methods rely on block augmentation, which inflates matrix size and may introduce redundant computation. Our protocol applies padding only when necessary and follows a determinant-preserving augmentation scheme. It applies padding in two distinct scenarios. First, it uses nearest-even padding to minimally extend odd-sized matrices to the next even order. Second, when the user opts for parallel computation across many
As detailed in Table V, earlier protocols were primarily designed for cloud-centric environments, where resource limitations on participating devices are typically not a primary concern. While the recent work in [6] introduces an edgeoriented approach, it remains restricted to a fixed 2-server model and offers only limited support for deployment on heterogeneous or resource-constrained platforms. In contrast, our protocol is explicitly developed to operate efficiently across an arbitrary number of untrusted servers and is fully compatible with edge devices that have limited computational capacity, making it more suitable for practical real-world deployments. To improve efficiency and security, the protocol avoids conventional designs that depend on multi-round probabilistic verification and key-based result extraction. It instead uses a single round of verification, which may be either deterministic (Q3 ) or probabilistic (Q2 ), and adopts a seed-based result extraction mechanism. This design not only significantly reduces computational and communication overhead, but also lowers the associated security risks by minimizing sensitive key usage on the client side. Together, these features enable scalable, lightweight, and secure determinant outsourcing in diverse edge computing environments. VII. EXTENSIONS AND APPLICATIONS The proposed framework is designed for scalability and adaptability, allowing it to be applied across diverse computational environments. This section explores its current applications and potential future advancements in various domains, emphasizing its versatility and effectiveness. A. SCALABILITY AND SECURE COMPUTATION IN DISTRIBUTED ENVIRONMENTS Our SPDC framework supports multi-server scalability and decentralized computation, making it adaptable to cloud computing, edge computing, and IoT networks.
14
TABLE V D EPLOYMENT-O RIENTED P ROPERTIES OF D ETERMINANT O UTSOURCING P ROTOCOLS Protocols [Reference]
Deployment Environment
Server Scalability
Verification Method
Result Extraction Mechanism
Resource-Constrained Support
Lei et al. [1] Fu et al. [8] Liu et al. [9] Gao et al. [6] Our protocol
Cloud Cloud Cloud Edge Edge
1 (single cloud server) 1 (single cloud server) 1 (single cloud server) 2 (fixed block partition) N (flexible, arbitrary)
Multi-round Monte Carlo Multi-round Monte Carlo Multi-round Monte Carlo Q1 : Single-round prob. (vector) Single-round (scalar): Q2 prob., Q3 deterministic
Key-based Key-based Key-based Key-based Seed-based
No No Partial Partial Yes
Our protocol is designed for edge environments, supporting flexible parallelism with arbitrary N . It can adapt to federated or cloud clusters, though such deployment is not the primary focus of our analysis.
Parallel Computation Efficiency: The SPCP protocol reduces computational complexity as N increases, ensuring scalability for large-scale matrix determinant computations. • Client-Controlled Multi-Server Deployment: Unlike fixed 2-server models, the privacy-preserving computation (PPC) protocol allows clients to allocate and manage any number of servers, dynamically partitioning matrices for parallel execution. • Secure IoT and Ad Hoc Computing: The protocol enables distributed determinant computation in resourceconstrained environments, such as IoT and ad hoc networks, where computational tasks are shared across multiple devices while preserving data privacy. •
Privacy-Preserving Matrix Inversion & Eigenvalue Computation: Extending the protocol to support secure matrix inversion and eigenvalue computation would open applications in machine learning, optimization, and secure data analysis. • Automated Fault Tolerance: Future implementations could incorporate real-time failure detection, redundancy strategies, and dynamic task redistribution, ensuring uninterrupted computation in cloud, edge, and MANET environments. This framework provides a scalable, lightweight, and reliable N -server determinant computation protocol with applications in distributed computing, IoT security, and real-time analytics. Future advancements in blockchain authentication, expanded matrix operations, and automated fault tolerance will further enhance its impact across scientific, industrial, and AI-driven domains. •
VIII. CONCLUSION
Fig. 7. Ad hoc network model.
B. FUTURE ENHANCEMENTS AND EXTENSIONS While the SPDC framework effectively supports secure N server determinant computation, it has the potential to support broader privacy-preserving and secure matrix operations and integrated authentication mechanisms. •
Blockchain-Integrated Secure Computing: Integrating blockchain into the PPC protocol can enhance authenticity by providing immutable audit trails and consensus mechanisms. This ensures transparent, verifiable computations across untrusted servers, strengthening security against adversarial attacks [10].
This paper presented the Secure Parallel Determinant Computation (SPDC) framework, a privacy-preserving and secure approach to parallel matrix determinant computation tailored for resource-constrained and distributed edge environments. The framework employs Composite Element Distortion (CED), which integrates Element-wise Obfuscation (EWO) with Panth Rotation Theorem (PRT)-based Obfuscation. Through this mechanism, SPDC enables scalable N -server parallel LU decomposition over untrusted edge servers while ensuring strong data confidentiality, computational integrity, and high efficiency. Performance evaluations show that the proposed method significantly reduces computational overhead on both client and server sides, eliminates unnecessary dimension extension, and supports both even and odd-sized square matrices via minimal, determinant-preserving augmentation. The use of lightweight, single-round, scalar-based authentication mechanisms enables rapid and robust verification without burdening edge devices. The framework’s adaptable design enables secure and parallel outsourcing across heterogeneous infrastructures, thereby overcoming the scalability, privacy, and deployment limitations of prior solutions. Collectively, these contributions establish a new benchmark for practical, efficient, and secure determinant outsourcing in real-world Internet of Things (IoT) and largescale distributed computing scenarios.
15
R EFERENCES [1] X. Lei, X. Liao, T. Huang, and H. Li, “Cloud computing service: The caseof large matrix determinant computation,” IEEE Transactions on Services Computing, vol. 8, no. 5, p. 688–700, Sep. 2015. [Online]. Available: http://dx.doi.org/10.1109/tsc.2014.2331694 [2] Y. Xiao, Y. Jia, C. Liu, X. Cheng, J. Yu, and W. Lv, “Edge computing security: State of the art and challenges,” Proceedings of the IEEE, vol. 107, no. 8, p. 1608–1631, Aug. 2019. [Online]. Available: http://dx.doi.org/10.1109/jproc.2019.2918437 [3] G. Strang, Linear Algebra and Its Applications, 4th ed. Belmont, CA, USA: Brooks/Cole, 2006. [4] S. Hohenberger and A. Lysyanskaya, “How to securely outsource cryptographic computations,” in Theory of Cryptography, J. Kilian, Ed. Berlin, Heidelberg: Springer Berlin Heidelberg, 2005, pp. 264–282. [5] Z. Shan, K. Ren, M. Blanton, and C. Wang, “Practical secure computation outsourcing: A survey,” ACM Comput. Surv., vol. 51, no. 2, Feb. 2018. [Online]. Available: https://doi.org/10.1145/3158363 [6] W. Gao and J. Yu, “Privacy-preserving parallel computation of matrix determinant with edge computing,” IEEE Transactions on Services Computing, vol. 16, no. 5, pp. 3578–3589, 2023. [7] X. Gao, J. Yu, Y. Chang, H. Wang, and J. Fan, “Checking only when it is necessary: Enabling integrity auditing based on the keyword with sensitive information privacy for encrypted cloud data,” IEEE Transactions on Dependable and Secure Computing, vol. 19, no. 6, p. 3774–3789, Nov. 2022. [Online]. Available: http://dx.doi.org/10.1109/tdsc.2021.3106780 [8] S. Fu, Y. Yu, and M. Xu, “Practical privacy-preserving outsourcing of large-scale matrix determinant computation in the cloud,” in Cloud Computing and Security, X. Sun, H.-C. Chao, X. You, and E. Bertino, Eds. Cham: Springer International Publishing, 2017, pp. 3–15. [9] J. Liu, J. Bi, and M. Li, “Secure outsourcing of large matrix determinant computation,” Frontiers of Computer Science, vol. 14, no. 6, Mar. 2020. [Online]. Available: http://dx.doi.org/10.1007/s11704-019-9189-7 [10] S. Nakamoto, “Bitcoin: A peer-to-peer electronic cash system,” 2008, [Online]. Available: https://bitcoin.org/bitcoin.pdf. [Accessed: Aug. 12, 2025].
Prajwal Panth (Member, IEEE) is currently pursuing a B.Tech. (Honours with Research) in Computer Science and Engineering, with a minor in Applied Machine Learning, at the Kalinga Institute of Industrial Technology (KIIT), India. His research interests include machine learning, secure computation, secure outsourced computation, and natural language processing. He received the Scientific Innovation Award from the Government of Nepal in recognition of his contributions to research and science outreach.