Pith. sign in

REVIEW 4 major objections 5 minor 45 references

Private and Secure Distributed Matrix Multiplication with Flexible Communication Load

T0 review · 4 major / 5 minor · reviewed 2026-08-14 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read A family of codes makes distributed matrix multiplication both private and flexible in cost.

desk verdict Useful achievable trade-off for secure coded matrix multiplication, but Theorem 3's privacy proof is under-powered; still deserves a serious referee. read the letter →

arxiv 1909.00407 v2 pith:GRXAMT7G submitted 2019-09-01 cs.IT math.IT

Malihe Aliasgari , Osvaldo Simeone , Joerg Kliewer This is my paper · ORCID
classification cs.ITmath.IT MSC 94A6268P3068W15
keywords securedistributedmatrixmultiplicationgeneralizedPolyDotcodesperfectsecrecyprivateinformationretrievalrecoverythresholdcommunicationloadcodedcomputationstragglermitigation
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper proposes coding schemes for distributed matrix multiplication where a master server wants the product C=AB from many workers without letting the workers learn the inputs. It claims two new code families achieve this: secure generalized PolyDot (SGPD) codes keep both matrices perfectly secret from up to P_C colluding workers, and private secure generalized PolyDot (PSGPD) codes keep one matrix secret while also hiding which public matrix from a library is being multiplied. Both families allow a flexible trade-off between recovery threshold, the number of workers that must finish, and communication load, the data downloaded, rather than optimizing one at the expense of the other. The paper also shows that the best code choice along this trade-off depends on whether the system bottleneck is communication rate or computation speed.

What carries the argument

The load-bearing object is the z-transform viewpoint of generalized PolyDot codes: matrices A and B are read as block sequences a and b, encoded by polynomial evaluation at worker-specific points, and the desired product blocks appear as the middle samples of the convolution a*b. The SGPD construction augments A and B with P_C random block matrices, arranged differently in the two cases s<t and s>=t so that the random terms in the product polynomial do not collide with the desired coefficient positions. The PSGPD construction attaches a private-information-retrieval query vector to each worker, so the desired public matrix is evaluated at a worker-specific random point while all undesired matrices are evaluated at common points, making the constant interference term that is later decoded away.

What would settle it

Compute, for the PSGPD encoding with s>1, the mutual information or total variation between ($q_p^{{(κ)}}$, $A_p^{{(κ)}}$, $C_p^{{(κ)}}$) for two different indices κ; if any pair of distributions differs for a fixed worker p, condition (9) fails, and the recovery threshold of Theorem 3 becomes a secure-computation result rather than a private one. For SGPD, a direct check of the entropy chain in (26) on a small finite-field instance with s<t and P_C=2 would expose whether the claimed perfect secrecy holds.

Watch

Extended reading notes

Core claim

The central discovery is that the generalized PolyDot z-transform construction can be extended with random padding blocks, chosen adaptively depending on whether s<t or s>=t, to satisfy information-theoretic secrecy without paying the full cost of a naive secure code. Theorem 1 states that for security level P_C<P, the SGPD code achieves the recovery threshold in (22) and communication load CL=P_R TD/(td) under the perfect secrecy condition I(A_P,B_P;A,B)=0. Theorem 2 covers s>=t with threshold (33). Theorem 3 states that by concatenating this idea with a private-information-retrieval query scheme, the PSGPD code achieves recovery threshold (40) with P_C=1 while satisfying both secrecy of A and index privacy of the selected public matrix. If correct, these are feasible operating points showing that security and privacy can be layered onto coded matrix multiplication at a tunable, not prohibitive, cost.

Load-bearing premise

The index-privacy guarantee of PSGPD codes depends on the whole tuple a worker sees, query, encoded A, and returned product, being identically distributed for every choice of public matrix, and the paper's proof verifies this only for the query vector while asserting the rest.

Editorial extensions

If this is right

  • For any fixed collusion threshold P_C, SGPD codes give a family of achievable (P_R, C_L) pairs parameterized by the block splitting (t,s,d), so system designers can choose the operating point that fits their network.
  • The recovery threshold expressions reduce to the known GPD thresholds when P_C=0, meaning the secure construction contains the non-secure state of the art as a special case.
  • The completion-time analysis shows the optimal code along the trade-off curve switches from low-communication-load codes at low communication rates to high-communication-load codes at high rates.
  • PSGPD codes achieve index privacy and secrecy of A with P_C=1, and their recovery threshold and communication load do not depend on the library size L.
  • The results imply that security and privacy constraints do not force a unique code choice; they enlarge the design space with explicitly quantified trade-offs.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The same z-transform padding technique could plausibly extend to multilinear products or tensor contractions by stacking more sequences and placing random padding to avoid interference in coefficient positions; the paper does not explore this.
  • If the omitted joint-distribution argument for index privacy can be supplied, a natural next target is the colluding-worker case P_C>1 with low per-worker complexity, which the paper leaves open and notes can currently be handled only by a costly concatenation.
  • The latency formula suggests a concrete rate-aware code selection rule: measure the ratio of communication rate to computation speed and choose t,s,d accordingly, but the paper stops short of giving an explicit optimization policy.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The paper studies distributed matrix multiplication with security and privacy constraints. In the first setting, both matrices A and B must be kept secret from up to PC colluding workers; the authors propose secure generalized PolyDot (SGPD) codes and claim recovery-threshold formulas in Theorems 1 and 2 together with the communication load (16). In the second setting, one matrix is public and only its index must be kept private, with A still secret; the authors propose private and secure GPD (PSGPD) codes and claim the recovery threshold in Theorem 3 under PC=1. The paper also provides a latency analysis based on shifted-exponential computation times and the PR-th order statistic. The constructions build on the z-transform interpretation of generalized PolyDot codes and on PIR-style query generation.

Significance. If the proofs are completed, the SGPD codes would provide a genuinely flexible achievable trade-off between recovery threshold, communication load, and collusion threshold, generalizing the non-secure GPD codes. The PSGPD codes would similarly provide an achievable point for the joint secrecy-and-index-privacy problem. The explicit polynomial-degree derivations, the z-transform viewpoint, and the latency comparison are useful strengths, and the paper benchmarks against GPD codes and the PIR-based scheme [38]. However, the manuscript currently has load-bearing gaps in the statements and proofs of Theorems 2 and 3; the central claims are defensible but need substantial revision before they can be accepted.

major comments (4)
  1. [Appendix A / Theorem 3, condition (9)] The privacy proof does not establish condition (9). The appendix proves only that the query vectors q_p^{(κ)} have the same marginal distribution, citing [38], and then asserts that the privacy condition follows. Condition (9) requires equality of the full joint distribution (q_p^{(κ)}, A_p^{(κ)}, C_p^{(κ)}, B) across κ. Since A_p^{(κ)} = F_A(z_{κ,p}) and C_p^{(κ)} = A_p^{(κ)} Σ_{r=1}^L F_{B(r)}(q_r), the joint law depends on which coordinate of q_p is the worker-specific point z_{κ,p}; the proof never analyzes this joint law. Coordinate exchangeability of the i.i.d. query entries alone does not imply equality of the joint distribution for arbitrary library matrices B(r), because the functions F_{B(r)} need not be permutation polynomials. In addition, the query entries are drawn from F without excluding 0; if z_{κ,p}=0, then F_A(0) contains no random key term, so the security condition (8) fails and the distributions in (9) can differ. The authors need to specify nonzero evaluation points and provide a complete indistinguishability argument for the tuple (q_p, A_p, C_p, B), or else Theorem 3 is unproven as stated.
  2. [Section IV-B, Theorem 2 and equations (29)-(30)] The zero-block count in the s≥t case is inconsistent with the dimensions of the random parts. In (29) the random part R has t Δ'_PC block entries, and in (30) the random part R′ has d Δ'_PC block entries. The text says that the last s Δ'_PC − P_C block matrices are set to zero. For parameters such as t=3, s=6, d=3, P_C=1, this gives 6·1−1=5 zero blocks while A* has only 3 random blocks, so all random keys would be zeroed and the secrecy condition (3) would fail. The zero count should presumably be t Δ'_PC − P_C for A* and d Δ'_PC − P_C for B*, or an equivalent corrected condition. This must be repaired for Theorem 2 to define a valid construction.
  3. [Appendix A, recovery step after equation (44)] The recovery proof ignores the constant term in B_p^{(κ)}. Equation (44) gives B_p^{(κ)} = F_{B(κ)}(z_{κ,p}) + C_0 with C_0 = Σ_{r≠κ} F_{B(r)}(z_r), so each worker returns F_A(z_{κ,p})(F_{B(κ)}(z_{κ,p}) + C_0), not F_A(z) F_{B(κ)}(z). To interpolate F_A(z)F_{B(κ)}(z), the master must first subtract F_A(z_{κ,p}) C_0 from each received product; this is possible because the master knows F_A(z_{κ,p}) = A_p^{(κ)} and C_0 from the query, but the step is not stated. As written, the degree count in Appendix A proves the recovery threshold for the wrong polynomial.
  4. [Section IV-A, proof of Theorem 1, equation (26)] Step (b) of the entropy chain in (26) is not rigorous as written. It says that from 'PR polynomial evaluations' one can recover 2P_C unknowns 'given that we have P_R ≥ 2P_C', but A_P and B_P in (26) denote only the P_C colluding workers' encoded matrices, and P_R is not the number of colluding workers. The correct statement is that P_C evaluations of F_{a*}(z) suffice to recover the P_C random block matrices in A*, and P_C evaluations of F_{b*}(z) suffice to recover the P_C random block matrices in B*, because those blocks appear with distinct nonzero powers and the evaluation points are distinct and nonzero. This argument needs to be stated cleanly; the current wording with P_R is misleading.
minor comments (5)
  1. [Section II-A] There is a typo: 'he function H(·)' should read 'The function H(·)'.
  2. [Section IV-B, Theorem 2] The proof of Theorem 2 is only one sentence and does not spell out the security argument or the zero-block placement for the s≥t case. Given that the construction differs structurally from the s<t case, the proof should be expanded.
  3. [Equation (25)] The notation 'dst∗' in the second line of (25) is easily misread; it should be written as 'd s t^*' or 'd·s·t^*'.
  4. [Example 2] In Example 2 the text writes 'T^comm_min = 1' but the model and equation (36) use the minimum computation time T^comp_min; this appears to be a typo.
  5. [Section V, Remark 3] The complexity discussion counts only download communication and omits the upload cost of the query and encoded A_p. Since the paper compares with PIR-based schemes where upload cost is a known concern, a brief remark on this modeling choice would be helpful.

Circularity Check

0 steps flagged · score 0.0 of 10

There is no circularity: the SGPD and PSGPD thresholds are obtained by polynomial-degree counting, and the only flagged weaknesses are proof-completeness gaps in Appendix A, not reductions of outputs to inputs.

full rationale

The paper's derivation chain is self-contained in the sense relevant to circularity. The SGPD recovery thresholds in Theorem 1, Eq. (22), and Theorem 2, Eq. (33), are computed as the degree of the product polynomial Fa*(z)Fb*(z) plus one after fixing the random-padding construction; the communication load in Eq. (16) is the number of required workers times the per-worker product size. Neither quantity is fitted to a target it is then claimed to predict, and no parameter is introduced by fitting a subset of data and later reported as a prediction. The security proof in Eq. (26) is a standard entropy chain using the random padding matrices, and the claimed privacy of the PSGPD scheme is attributed to the external result [38], not to a self-citation chain that assumes the theorem being proved. The manuscript-flagged weaknesses are real but non-circular: Appendix A asserts that condition (9) follows from the query-vector distribution 'as proved in [38]' without deriving the joint distribution of (A_p^{(kappa)}, C_p^{(kappa)}, q_p^{(kappa)}, B), and the recovery discussion does not explicitly state that the master must subtract the constant term in B_p^{(kappa)} before interpolation. These are omissions in proof detail, not equivalences by construction. The self-citations [1], [11], and [12] appear as provenance and latency-model references and are not load-bearing for the main code-construction claims.

Assumptions & free parameters 1 free parameters · 6 assumptions · 0 invented entities

The paper's claims rest on standard polynomial interpolation and on the domain assumptions of uniform random data over a large finite field and honest-but-curious workers with bounded collusion. The only external building block imported without proof is the PIR scheme of [38]. No fitted constants or ad hoc physical entities appear.

free parameters (1)
  • block partition parameters (t,s,d)
    Design degrees of freedom constrained by m=ts and n=sd; they parameterize the trade-off curve and are not fitted to data.
assumptions (6)
  • standard math Polynomial interpolation over a finite field F with |F|>P and distinct nonzero evaluation points reconstructs the product polynomial from PR evaluations.
    Used in Sections III and IV for decoding the convolution c* = a* * b* from sampled values.
  • standard math The z-transform converts convolution of block sequences into multiplication of polynomials, and the middle sample of the convolution of A-row blocks and B-column blocks gives the desired product blocks.
    Background in Section III; all theorem proofs use this equivalence.
  • domain assumption All data and random key entries are i.i.d. uniform over a sufficiently large finite field F.
    Stated in Section II-B and required for the entropy equalities in the secrecy proof and for the PIR indistinguishability argument.
  • domain assumption Workers are honest but curious and at most PC of them collude.
    Stated in Section II-C as the adversary model behind the secrecy constraint (3).
  • domain assumption For the private and secure setup, PC=1, meaning no colluding workers.
    Stated in Section II-D; the entirety of Theorem 3 and PSGPD relies on this simplification.
  • domain assumption The PIR scheme of [38] provides the required privacy for the query vectors and the resulting worker outputs.
    Appendix A invokes [38] to conclude condition (9); this is an external result imported without re-derivation.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Private and Secure Distributed Matrix Multiplication with Flexible Communication Load." pith.science (2026). https://pith.science/paper/GRXAMT7G

@misc{pith2026190900407,
  author       = {Pith},
  title        = {Pith review of: Private and Secure Distributed Matrix Multiplication with Flexible Communication Load},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/GRXAMT7G}},
  note         = {Machine review of arXiv:1909.00407}
}
read the original abstract

Large matrix multiplications are central to large-scale machine learning applications. These operations are often carried out on a distributed computing platform with a master server and multiple workers in the cloud operating in parallel. For such distributed platforms, it has been recently shown that coding over the input data matrices can reduce the computational delay, yielding a trade-off between recovery threshold, i.e., the number of workers required to recover the matrix product, and communication load, i.e., the total amount of data to be downloaded from the workers. In this paper, in addition to exact recovery requirements, we impose security and privacy constraints on the data matrices, and study the recovery threshold as a function of the communication load. We first assume that both matrices contain private information and that workers can collude to eavesdrop on the content of these data matrices. For this problem, we introduce a novel class of secure codes, referred to as secure generalized PolyDot (SGPD) codes, that generalize state-of-the-art non-secure codes for matrix multiplication. SGPD codes allow a flexible trade-off between recovery threshold and communication load for a fixed maximum number of colluding workers while providing perfect secrecy for the two data matrices. We then study a connection between secure matrix multiplication and private information retrieval. We specifically assume that one of the data matrices is taken from a public set known to all the workers. In this setup, the identity of the matrix of interest should be kept private from the workers. For this model, we present a variant of generalized PolyDot codes that can guarantee both secrecy of one matrix and privacy for the identity of the other matrix for the case of no colluding servers.

Figures

Figures reproduced from arXiv: 1909.00407 by the authors.

Figure 1
Figure 1. Secure matrix multiplication: the master server encodes both input matrices A and B, to be kept secure from the workers, and both random matrices R and R0 , respectively, to define the computational tasks of the slave servers or workers. The workers may fail or straggle, and they are honest but curious, with colluding subsets of workers of size at most PC . The master server must be able to decode the product C = AB… view at source ↗
Figure 2
Figure 2. Private and secure matrix multiplication: the master server encodes the input matrix A, to be kept secret from the workers, and generates the encoded matrix A (κ) p for each worker p. It also sends a query q (κ) p as a function of the index κ ∈ [1, L], to be kept private from workers, of the desired product C(κ) = AB(κ) , with matrices {B(r)} L r=1 available at all workers. The non-colluding workers may fail or stra… view at source ↗
Figure 3
Figure 3. Construction of the time sequences a and b used to define the generalized PolyDot (GPD) code. The zero dashed lines in b indicates all-zero block sequences. Each solid arrows in a and b shows a distinct row of A and a column of B, respectively. of index values κ 0 6= κ. Finally, the correct decoding requirement is defined as in (5), that is H(AB(κ) |{C(κ) p }p∈PR ) = 0. (10) A coding and decoding strategy that satis… view at source ↗
Figures from the paper (6 more)
Figure 4
Figure 4. Figure 4: Construction of the time block sequences a ∗ = [a, r] and b ∗ = [b, r 0 ] in (20) and (21) used to define the SGPD code for the case s < t. The zero dashed lines in b and r 0 indicate all-zero block sequences. server computes the inverse z-transform for the received pr…
Figure 5
Figure 5. Figure 5: Outcome of the communication Ci,j = ai ∗ bj for t = 3, s = 2, d = 2, and PC = 2. Dashed blue stems with filled markers represent the convolution c ∗. Individual convolutions ci,j are shown in different colors with square markers. Contributions from one or both random m…
Figure 6
Figure 6. Figure 6: Construction of the time block sequences a ∗ and b ∗ in (31) and (32) used to define the secure generalized PolyDot (SGPD) code for the case s ≥ t. The solid line and the zero dashed lines in b ∗ indicate columns of B and all-zero block sequences, respectively. needs t…
Figure 7
Figure 7. Figure 7: Communication load CL versus recovery threshold PR for both non￾secure generalized PolyDot (GPD) and secure generalized PolyDot (SGPD) codes (m = n = 36 and P = 3000 workers). point zp. This requires multiplying zp by (ts+PC ) and (sd+ PC ) submatrices, each of dimensi…
Figure 8
Figure 8. Figure 8: The figure shows that the optimal choice of the latency [PITH_FULL_IMAGE:figures/full_fig_p010_8.png]
Figure 9
Figure 9. Figure 9: Communication load CL versus recovery threshold PR for secure generalized PolyDot (SGPD) codes with PC = 1 and private and secure generalized PolyDot (PSGPD) codes (m = n = 36 and P = 3000 workers). Remark 4. As for SGPD codes, the overall average comple￾tion time of P…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

45 extracted references · 36 canonical work pages

  1. [38]

    Private secure coded computation,

    M. Kim and J. Lee, “Private secure coded computation,” arXiv preprint, arXiv:1902.00167, 2019

    arXiv 1902

  2. [1]

    Distributed and private coded matrix computation with flexible communication load,

    M. Aliasgari, O. Simeone, and J. Kliewer, “Distributed and private coded matrix computation with flexible communication load,” in Proc. IEEE Intern. Symp. Inform. Theory (ISIT) , Jul. 2019, pp. 1092–1096

    work page 2019

  3. [2]

    Beating the perils of non-convexity: Guaranteed training of neural networks using tensor methods,

    M. Janzamin, H. Sedghi, and A. Anandkumar, “Beating the perils of non-convexity: Guaranteed training of neural networks using tensor methods,” arXiv preprint, arXiv:1506.08473 , 2015

    arXiv 2015

  4. [3]

    Scaling distributed machine learning with the parameter server

    M. Li, D. G. Andersen, J. W. Park, A. J. Smola, A. Ahmed, V . Josifovski, J. Long, E. J. Shekita, and B.-Y . Su, “Scaling distributed machine learning with the parameter server.” in Proc. of the 11th USENIX Conference on Operating Systems Design and Implementation, OSDI , vol. 14, Oct. 2014, pp. 583–598

    work page 2014

  5. [4]

    The tail at scale,

    J. Dean and L. A. Barroso, “The tail at scale,” Communications of the ACM, vol. 56, no. 2, pp. 74–80, Feb. 2013

    work page 2013

  6. [5]

    Efficient redundancy techniques for latency reduction in cloud systems,

    G. Joshi, E. Soljanin, and G. Wornell, “Efficient redundancy techniques for latency reduction in cloud systems,” ACM Transactions on Modeling and Performance Evaluation of Computing Systems (TOMPECS), vol. 2, no. 2, pp. 12:1–12:30, Apr. 2017

    work page 2017

  7. [6]

    Using straggler replication to reduce latency in large-scale parallel computing,

    D. Wang, G. Joshi, and G. Wornell, “Using straggler replication to reduce latency in large-scale parallel computing,” ACM SIGMETRICS Performance Evaluation Review, vol. 43, no. 3, pp. 7–11, Dec. 2015

    work page 2015

  8. [7]

    Algorithm-based fault tolerance for matrix operations,

    K.-H. Huang and J. A. Abraham, “Algorithm-based fault tolerance for matrix operations,” IEEE Trans. on Computers, vol. 100, no. 6, pp. 518– 528, Jun. 1984

    work page 1984

Show all 45 references
  1. [8]

    Speeding up distributed machine learning using codes,

    K. Lee, M. Lam, R. Pedarsani, D. Papailiopoulos, and K. Ramchandran, “Speeding up distributed machine learning using codes,” IEEE Trans. on Inform. Theory , vol. 64, no. 3, pp. 1514–1529, Aug. 2017

    2017

  2. [9]

    Polynomial codes: an optimal design for high-dimensional coded matrix multiplication,

    Q. Yu, M. Maddah-Ali, and S. Avestimehr, “Polynomial codes: an optimal design for high-dimensional coded matrix multiplication,” in Proc. Advances in Neural Inform. Processing Systems , Dec. 2017, pp. 4403–4413

    2017

  3. [10]

    A fundamental tradeoff between computation and communication in distributed com- puting,

    S. Li, M. A. Maddah-Ali, Q. Yu, and A. S. Avestimehr, “A fundamental tradeoff between computation and communication in distributed com- puting,” IEEE Trans. on Inform. Theory , vol. 64, no. 1, pp. 109–128, Sep. 2017

    2017

  4. [11]

    Coded computation against processing delays for virtualized cloud-based channel decoding,

    M. Aliasgari, J. Kliewer, and O. Simeone, “Coded computation against processing delays for virtualized cloud-based channel decoding,” IEEE Trans. on Commun. , vol. 67, no. 1, pp. 28–38, Jan. 2019

    2019

  5. [12]

    Coded computation against straggling decoders for network function virtualization,

    ——, “Coded computation against straggling decoders for network function virtualization,” in Proc. IEEE Intern. Symp. Inform. Theory (ISIT), Jun. 2018, pp. 711–715

    2018

  6. [13]

    On the optimal recovery threshold of coded matrix mul- tiplication,

    S. Dutta, M. Fahim, F. Haddadpour, H. Jeong, V . Cadambe, and P. Grover, “On the optimal recovery threshold of coded matrix mul- tiplication,” arXiv preprint, arXiv:1801.10292 , 2018

    2018 arXiv

  7. [14]

    A unified coded deep neural network training strategy based on generalized polydot codes for matrix multiplication,

    S. Dutta, Z. Bai, H. Jeong, T. M. Low, and P. Grover, “A unified coded deep neural network training strategy based on generalized polydot codes for matrix multiplication,” arXiv preprint, arXiv:1811.10751 , 2018

    2018 arXiv

  8. [15]

    On the optimal recovery threshold of coded matrix mul- tiplication,

    M. Fahim, H. Jeong, F. Haddadpour, S. Dutta, V . Cadambe, and P. Grover, “On the optimal recovery threshold of coded matrix mul- tiplication,” in Proc. 55th Allerton Conf. Commun., Control, Comput., IL, USA, Oct. 2017, pp. 1264–1270

    2017

  9. [16]

    Numerically stable polynomially coded computing,

    M. Fahim and V . R. Cadambe, “Numerically stable polynomially coded computing,” arXiv preprint, arXiv:1903.08326 , 2019

    1903 arXiv

  10. [17]

    Random khatri-rao-product codes for numerically-stable distributed matrix mul- tiplication,

    A. M. Subramaniam, A. Heidarzadeh, and K. R. Narayanan, “Random khatri-rao-product codes for numerically-stable distributed matrix mul- tiplication,” arXiv preprint, arXiv:1907.05965 , 2019

    1907 arXiv

  11. [18]

    Limited-sharing multi-party computation for massive matrix operations,

    H. A. Nodehi and M. A. Maddah-Ali, “Limited-sharing multi-party computation for massive matrix operations,” inProc. IEEE Intern. Symp. on Inform. Theory (ISIT) , Jun. 2018, pp. 1231–1235

    2018

  12. [19]

    Lagrange coded computing: Optimal design for resiliency, security and privacy,

    Q. Yu, N. Raviv, J. So, and A. S. Avestimehr, “Lagrange coded computing: Optimal design for resiliency, security and privacy,” arXiv preprint, arXiv:1806.00939, 2018

    2018 arXiv

  13. [20]

    On the capacity of secure distributed matrix multiplication,

    W.-T. Chang and R. Tandon, “On the capacity of secure distributed matrix multiplication,” arXiv preprint, arXiv:1806.00469 , 2018

    2018 arXiv

  14. [21]

    On the capacity and straggler- robustness of distributed secure matrix multiplication,

    J. Kakar, S. Ebadifar, and A. Sezgin, “On the capacity and straggler- robustness of distributed secure matrix multiplication,” IEEE Access , vol. 7, pp. 45 783–45 799, Apr. 2019

    2019

  15. [22]

    Secure distributed computing with straggling servers using polynomial codes,

    H. Yang and J. Lee, “Secure distributed computing with straggling servers using polynomial codes,” IEEE Trans. on Inform. Forensics and Secur., vol. 14, no. 1, pp. 141–150, Jan. 2019

    2019

  16. [23]

    GASP codes for secure distributed matrix multiplication,

    R. G. D’Oliveira, S. E. Rouayheb, and D. Karpuk, “GASP codes for secure distributed matrix multiplication,” arXiv preprint, arXiv:1812.09962, 2018

    2018 arXiv

  17. [24]

    Random convolutional coding for robust and straggler resilient distributed matrix computation,

    A. B. Das, A. Ramamoorthy, and N. Vaswani, “Random convolutional coding for robust and straggler resilient distributed matrix computation,” arXiv preprint, arXiv:1907.08064 , 2019

    1907 arXiv

  18. [25]

    Secure coded multi-party compu- tation for massive matrix operations,

    H. A. Nodehi and M. A. Maddah-Ali, “Secure coded multi-party compu- tation for massive matrix operations,” arXiv preprint, arXiv:1908.04255, 2019

    1908 arXiv

  19. [26]

    Ricci, L

    F. Ricci, L. Rokach, and B. Shapira, Introduction to recommender systems handbook. Springer, 2011

    2011

  20. [27]

    High-dimensional coded matrix multiplication,

    K. Lee, C. Suh, and K. Ramchandran, “High-dimensional coded matrix multiplication,” in Proc. IEEE Intern. Symp. Inform. Theory (ISIT) , Jun. 2017, pp. 2418–2422

    2017

  21. [28]

    Straggler mitigation in distributed matrix multiplication: Fundamental limits and optimal coding,

    Q. Yu, M. A. Maddah-Ali, and A. S. Avestimehr, “Straggler mitigation in distributed matrix multiplication: Fundamental limits and optimal coding,” arXiv preprint, arXiv:1801.07487 , 2018

    2018 arXiv

  22. [29]

    On the capacity of secure distributed matrix multiplication,

    Z. Jia and S. A. Jafar, “On the capacity of secure distributed matrix multiplication,” arXiv preprint, arXiv:1908.06957 , 2019

    1908 arXiv

  23. [30]

    Private infor- mation retrieval,

    B. Chor, O. Goldreich, E. Kushilevitz, and M. Sudan, “Private infor- mation retrieval,” in Proceedings of IEEE 36th Annual Foundations of Computer Science. IEEE, 1995, pp. 41–50

    1995

  24. [31]

    A survey on private information retrieval,

    W. Gasarch, “A survey on private information retrieval,” Bulletin of the EATCS, vol. 82, no. 113, pp. 72–107, Feb. 2004

    2004

  25. [32]

    Private information retrieval,

    S. Yekhanin, “Private information retrieval,” Commun. ACM , vol. 53, no. 4, pp. 68–73, Apr. 2010

    2010

  26. [33]

    The capacity of private information retrieval,

    H. Sun and S. A. Jafar, “The capacity of private information retrieval,” IEEE Trans. on Inform. Theory, vol. 63, no. 7, pp. 4075–4088, Jul. 2017

    2017

  27. [34]

    The capacity of private information retrieval from coded databases,

    K. Banawan and S. Ulukus, “The capacity of private information retrieval from coded databases,” IEEE Trans. on Inform. Theory, vol. 64, no. 3, pp. 1945–1956, Mar. 2018

    1945

  28. [35]

    Private information retrieval from coded databases with colluding servers,

    R. Freij-Hollanti, O. W. Gnilke, C. Hollanti, and D. A. Karpuk, “Private information retrieval from coded databases with colluding servers,” SIAM J. Appl. Algebra Geom. , vol. 1, no. 1, pp. 647–664, Nov. 2017

    2017

  29. [36]

    Single- server single-message online private information retrieval with side information,

    F. Kazemi, E. Karimi, A. Heidarzadeh, and A. Sprintson, “Single- server single-message online private information retrieval with side information,” in Proc. IEEE Intern. Symp. Inform. Theory (ISIT) , Jul. 2019, pp. 350–354

    2019

  30. [37]

    Private information retrieval with private coded side information: The multi-server case,

    ——, “Private information retrieval with private coded side information: The multi-server case,” arXiv preprint, arXiv:1906.11278 , 2019

    1906 arXiv

  31. [39]

    On the upload versus download cost for secure and private matrix multiplication,

    W.-T. Chang and R. Tandon, “On the upload versus download cost for secure and private matrix multiplication,” arXiv preprint, arXiv:1906.10684, 2019

    1906 arXiv

  32. [40]

    Private sequential function computation,

    B. Tahmasebi and M. A. Maddah-Ali, “Private sequential function computation,” arXiv preprint, arXiv:1908.01204 , 2019

    1908 arXiv

  33. [41]

    How to share a secret,

    A. Shamir, “How to share a secret,” Communications of the ACM , vol. 22, no. 11, pp. 612–613, Nov. 1979

    1979

  34. [42]

    Kung, Fast evaluation and interpolation

    H.-T. Kung, Fast evaluation and interpolation . Carnegie Mellon University, Tech. Rep., 2009

    2009

  35. [43]

    Speeding up distributed machine learning using codes,

    K. Lee, M. Lam, R. Pedarsani, D. Papailiopoulos, and K. Ramchandran, “Speeding up distributed machine learning using codes,” IEEE Trans. on Inform. Theory , vol. 64, no. 3, pp. 1514–1529, Mar. 2017

    2017

  36. [44]

    S. M. Ross, Introduction to Probability Models. Academic Press, 2014

    2014

  37. [45]

    Coded federated computing in wireless networks with straggling devices and imperfect CSI,

    S. Ha, J. Zhang, O. Simeone, and J. Kang, “Coded federated computing in wireless networks with straggling devices and imperfect CSI,” inProc. IEEE Intern. Symp. Inform. Theory (ISIT) , Jul. 2019, pp. 2649–2653

    2019

Pith tools

Reviewed August 14, 2026 · model on record in the stance chip above.