{"id":"d7544e4b-c24e-47c5-ad5c-19d0a683eb6e","arxiv_id":"2509.05552","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"Crypto-Lp is a two-party secure computation framework that provides optimized L1, L2, and L-infinity norm protocols and introduces L1-based (AdderNet) layers for secure neural network inference.","lead":"This paper presents Crypto-Lp, a set of two-party cryptographic protocols for computing L1, L2, and L-infinity distances without revealing the inputs. It reports large speedups over earlier secure-computation systems and shows that L1-based neural network layers can cut communication in secure inference.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Crypto-L1 and Crypto-L2 accumulate norms in a ring that can overflow for the paper's own 32-bit, n=2^16 benchmarks, so the core protocols may not compute the claimed norms.","rationale":"The reader's weakest assumption was comparability of emulated and re-implemented baselines; that is a valid performance concern. But the overflow issue is more fundamental: if it lands, the headline 'secure L1/L2 norm' is not simply slower or faster than prior work, it computes a different function. The ABS MUX algebra in Appendix B1 is correct and the tree maximum is standard, so the cryptographic core is plausible; this is a range-arithmetic gap rather than a protocol-level flaw. The public code makes the check easy. I keep the verdict CONDITIONAL rather than REJECT because the framework can be repaired by choosing a wider ring or documenting explicit bounds, and the paper does not currently make a falsifiable claim that would be impossible to satisfy. The condition should be extended: prove or test exactness on the stated domain, and report communication for the larger ring if that is what the benchmark requires.","tokens_in":23935,"tokens_out":15795,"duration_ms":139912,"concrete_test":"Use the public artifact (or a minimal standalone implementation of Alg. 5) to compute the secure L1 distance for n=2^16 with x_i=2^17−1 and y_i=0 for all i, using 32-bit arithmetic, and compare the reconstructed output with the exact integer norm 2^33−2^16. If the output is 2^32−2^16 instead, F_MD does not realize the L1 norm on its stated domain and the benchmarked ring size is too small. If the code already accumulates in a ring of at least ℓ+⌈log n⌉ bits, the test passes and the concern is resolved.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The most load-bearing problem is not the speedup ratios but whether the protocols compute the norms they claim for the stated input domain. The paper defines inputs over Z_{2^ℓ} (§II-A), and F_MD (Alg. 5) computes the L1 norm by summing n ℓ-bit absolute differences in that ring. The true norm can be as large as n(2^ℓ−1), which exceeds the modulus as soon as n>1. Table III shows ℓ=32 and n=2^16; with valid inputs such as x_i=2^17−1 and y_i=0, the exact L1 norm is 2^33−2^16, whereas the protocol's modular sum is 2^32−2^16. F_ED (Alg. 6) has the analogous issue: a squared difference needs 2ℓ bits, and the sum over n components needs 2ℓ+⌈log n⌉ bits. No range condition, wider accumulator, or saturation is stated, and no end-to-end correctness check against plaintext norms is reported. If the released implementation uses the same 32-bit ring that Table III implies, the central 'secure Lp-norm' functionality is not correct for the advertised domain; if it uses a wider ring, the paper should say so and report the corresponding communication costs.","agreement_with_reader":"disagree"},"referee_report":{"model":"deepseek-v4-flash","summary":"Crypto-Lp is a suite of semi-honest two-party protocols for computing the L1 (Manhattan), L2 (Euclidean), and L∞ (Chebyshev) distances between n-dimensional ℓ-bit vectors held as arithmetic secret shares over Z_{2^ℓ}. The framework is assembled from a small set of building blocks — an optimized absolute-value multiplexer (F_ABS_MUX), a base multiplexer (F_Base_MUX), an MSB protocol, and a tree-based secure maximum (F_Max) — and the paper reports communication complexities for each, measured runtime and communication for n=2^16 vectors on a LAN, comparisons against seven prior systems, and a new application to secure AdderNet-style L1-based neural network inference. The abstract claims the first comprehensive secure Lp-norm framework, speedups of 82×, 271×, and 42× over prior work for p=1, 2, and ∞, respectively, and a 3× communication reduction for secure inference with comparable runtime and accuracy.","tokens_in":24167,"tokens_out":13649,"duration_ms":109512,"significance":"If the correctness and evaluation issues were resolved, this would be a useful contribution. The F_ABS_MUX construction is a genuine and checkable improvement: the correctness algebra in Appendix B1 verifies, and the construction halves the COT cost relative to the naive composition. The tree-based maximum reduces round complexity from O(n) to O(log n), an improvement that the authors demonstrate experimentally in Figure 3. The L1-based Adder operation for secure 2PC inference is an interesting design point backed by external plaintext results [21]–[23], and the paper is unusually concrete: a public code repository is promised, protocols are specified as numbered algorithms with explicit communication bounds, and evaluations span multiple real datasets (AT&T faces, Lsun, SIFT, Deep1B, Amazon, CIFAR-10, Twitter spatial crowdsourcing). These strengths are substantially offset by the fact that the L1 and L2 protocols, as specified in Algorithms 5 and 6, do not compute their advertised functions over the 32-bit, n=2^16 domain used in the headline benchmarks, and by the L2/squared-L2 ambiguity in the reported speedups.","major_comments":[{"comment":"The protocols F_MD and F_ED do not compute the advertised norms over the domain stated in the paper. Section II-C fixes all arithmetic in the ring Z_{2^ℓ}, and Table III evaluates on ℓ=32 with n=2^16. For F_MD (Alg. 5), the true norm Σ|x_i−y_i| can be as large as n(2^ℓ−1); for the valid inputs x_i=2^17−1 and y_i=0, the exact L1 norm is 2^33−2^16, whereas the modular sum returned by the protocol is 2^32−2^16. No input-range condition, wider accumulator, or saturation is stated in Section IV, so the protocol computes the wrong value for the paper's own benchmark parameters. F_ED (Alg. 6) has the analogous problem already at the level of a single component: (x_i−y_i)^2 needs 2ℓ bits, and the sum over n components needs 2ℓ+⌈log n⌉ bits. The authors must either state explicit range conditions under which all partial sums fit in Z_{2^ℓ}, or switch to a wider ring (e.g., 64-bit arithmetic) and re-report the runtime and communication numbers in Tables III, IV, and V accordingly. An end-to-end correctness check of the released implementation against plaintext norms should also be reported.","section":"§IV-A (Alg. 5), §IV-B (Alg. 6), §II-C, Table III"},{"comment":"The paper computes two different objects but reports them as one. Algorithm 6 defines F_ED as the square root of the sum of squared differences, while Section VI.B states that 'for the remainder of this section, L2-norm or Euclidean distance will specifically refer to the squared L2-norm,' and Table III reports both an 'L2' row that includes the SQRT cost and a 'Squared L2' row without it. The head-to-head speedup claims in Table V (e.g., 271× against Mohassel et al. [7]) are made with the squared version, so the abstract's 271× improvement for p=2 compares a squared-norm functionality against baselines that may compute the true Euclidean distance. The paper must state unambiguously which functionality each comparison uses, and any comparison of squared against unsquared distances should be removed or explicitly labeled as such.","section":"§IV-B (Alg. 6), §VI.B, Table V"},{"comment":"The headline speedups rest on baseline comparability that is not established. Han et al. [10] is not executed in the same setting: it is a multi-party HE-based protocol relying on a trusted third party, and its performance is emulated from published complexity tables under the authors' chosen parameters. PILOT [38] is re-implemented within ABY rather than run from its original code, and Cong et al. [45] reports no communication cost at all ('-' in Table V). Comparisons across different trust models, protocol types, and implementations can be informative, but the 82×, 271×, and 42× ratios in the abstract are presented as if they were direct measurements. The paper should either run the baselines in a common setting or use the original code, or it should clearly report each baseline's provenance (original code, re-implementation, or emulated complexity) in the tables and soften the abstract claims accordingly.","section":"§VI.C, §VI.D, Tables IV and V"},{"comment":"The paper asserts security in the semi-honest hybrid model but provides no simulation-based proof for any of the main norm protocols. The only proof-like material is the correctness algebra for F_ABS_MUX in Appendix B1; the security statements for F_MD, F_ED, F_CD, and F_Max are one-line appeals (e.g., 'Security follows directly from that of F_Mill' in Section III-A and 'Security follows from that of F_MSB and F_Base MUX' after Algorithm 4). Since the central contribution is a secure framework, the authors should add formal theorem statements with simulation arguments, or at least a complete hybrid composition argument, for F_MD, F_ED, F_CD, and F_Max, including the handling of the tree-structured F_Max.","section":"§II-B, §III-A, §IV"},{"comment":"The secure inference claim of 'maintaining comparable runtime and accuracy' is only partially supported. Table VII reports plaintext accuracy of MiniONN and ResNet32 with CNN versus Adder layers, and Tables VIII–IX report runtime and communication for the secure Adder and Conv operations, but no end-to-end secure 2PC inference accuracy is measured. The transfer from plaintext to fixed-point 2PC is assumed rather than tested, and given the truncated modular arithmetic in F_MD (see the first major comment), the accuracy of the secure model is not automatically the plaintext accuracy. The authors should run the secure inference end-to-end on CIFAR-10 and report accuracy, or explicitly state that no secure accuracy evaluation was performed and remove the accuracy claim from the abstract.","section":"§V-C, §VII, Table VII"}],"minor_comments":[{"comment":"Algorithm 4 contains several presentation errors that impede verification: line 2 reads 'while width<1 do', which is never true for n>1 and should read 'while width>1 do'; the comments on lines 4 and 11 ('if #nodes is even') contradict the condition 'width=2^0', which only isolates the single-node level; and line 9's comment 'Note that s_i = msb_i' is inconsistent with the assignments, which implement s_i = msb_i ⊕ 1 (i.e., s_i = 1{d_i ≥ 0}). These should be corrected and the pseudocode aligned with the surrounding text.","section":"Alg. 4, lines 2, 4, 9"},{"comment":"The baseline name is given inconsistently as 'SAANS' in the text of Section VI.D and as 'SANNS' in Table II and the reference list; the correct name (SANNS [46]) should be used throughout.","section":"§VI.D and Table II"},{"comment":"The phrase 'syntheti data' contains a typo, and the pointer 'Table VIII (Appendix VIII)' is incorrect because Table VIII appears in Section VII rather than in an appendix. In the same section, the sentence claiming AdderNet 'can serve as a practical substitute' should indicate which architecture the subsequent secure comparison (Tables VIII–IX) actually uses, since MiniONN and ResNet32 have different layer counts.","section":"§VII"},{"comment":"The 'first comprehensive framework' claim should be scoped more carefully. The paper's own Table II shows that Mohassel et al. [7] and Han et al. [10] already cover all three Lp norms in specific applications; the novelty lies in the general-purpose, application-agnostic protocol design, and the claim should be phrased in those terms rather than as the first secure Lp-norm computation of any kind. Minor wording issues include 'To our best knowledge' (three occurrences) and 'ubiquituosly' in Section I.","section":"Abstract, §I-A, §I-B"},{"comment":"Table I's entry for the maximum functionality gives total communication as '<(n−1)(λ+16)(ℓ+1)−30(n−1)', and the accompanying text in Section III.B separately counts the cost of the F_MSB calls; the two figures are consistent, but for clarity the table should also list the round complexity, since reducing the round complexity from O(n) to O(log n) is one of the paper's stated contributions and the basis of Figure 3.","section":"Table I and §III-B"}],"recommendation":"major_revision","confidential_remarks":"The manuscript's headline claims ('first comprehensive framework', 'first L1-norm-based 2PC neural network') are aggressive, and the evaluation compares against emulated baselines under different trust models, so the editor may want the authors to verify that the released repository matches the described protocols and to re-run the L1 and L2 benchmarks with a wider ring before acceptance. In my assessment, the modular-accumulation error in F_MD and F_ED is a genuine correctness bug in the core protocols rather than an artifact of the benchmark design, and it should be treated as a priority issue despite the otherwise sound and well-structured approach. I would also note that comparing a 2PC OT-based protocol with an HE-based protocol that assumes a trusted third party may be of limited scientific value unless the comparison is framed as a cross-model cost illustration."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Here's my read on the Crypto-Lp paper.\n\nWhat's actually new: the optimized ABS multiplexer (F_ABS_MUX = x - 2*F_Base_MUX) is a clean trick that halves COT cost vs. naive composition, and the binary-tree max reduces rounds to O(log n). The AdderNet-in-2PC application is a reasonable idea, and the reported communication savings for the Adder layer over secure Conv are plausible. The code is public, which is good. These are real contributions, incremental but not trivial.\n\nWhere it gets shaky: the protocols as written compute norms in Z_{2^ℓ}. F_MD (Alg 5) sums n absolute differences modulo 2^ℓ. With ℓ=32 and n=2^16 (their own Table III), a valid input like x_i = 2^17-1, y_i = 0 gives true L1 = 2^33 - 2^16, but the protocol outputs 2^32 - 2^16. Same issue for L2: squared differences need 2ℓ bits, and the sum needs 2ℓ + log n. The paper never states a range condition, wider accumulator, or saturation. So as written, the core 'norm' functionality is not correct for the advertised domain. If the released code uses a wider ring, the paper should say so and report the communication cost. This is not a nit—it's load-bearing.\n\nThe evaluation also has comparability gaps. Han et al. [10] is emulated from reported complexity under a different threat model; PILOT [38] is re-implemented in ABY rather than run from original code; and Section VI.B redefines 'L2-norm' as squared L2 after describing SQRT, so the '271x' and '4x' numbers might compare squared vs unsquared distance. The plaintext accuracy in Table VII is transferred to 2PC without measuring secure end-to-end accuracy. Headline speedups should be treated with caution until baselines are checked.\n\nOther soft spots: Algorithm 4 has a pseudocode error (while width<1 instead of while width>1), and the security analysis is informal—no full simulation proof, just hybrid-style appeals. These are fixable.\n\nWho this is for: systems/MPC people who want a drop-in norm module and are willing to verify the code. The ABS MUX and tree max are worth borrowing. But because of the overflow issue, I would not cite the L1/L2 protocols as correct without seeing the implementation or a corrected version.\n\nRecommendation: send to peer review, but with a clear request to address the ring-overflow correctness question and to redo the benchmarks with equivalent baselines. The core ideas deserve referee time; the current version needs a major revision.","headline":"A genuinely useful building-block paper with a real correctness gap: the L1/L2 protocols sum in a ring that can overflow for the paper's own parameters, and the headline speedups rest on emulated baselines.","tokens_in":24750,"tokens_out":3181,"would_cite":false,"duration_ms":27247,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"This paper presents Crypto-Lp, a unified two-party protocol suite for L1, L2, and L-infinity norms, reporting large gains in runtime and communication over prior secure norm computation.","keywords":["secure two-party computation","Lp-norm","Euclidean distance","Chebyshev distance","oblivious transfer","AdderNet","secure machine learning inference","privacy-preserving location-based services"],"falsifier":"Run the main baselines in the same implementation environment, on the same machine, with the same vector size and security parameter, and measure both the squared $L^2$-norm and the true Euclidean distance with secure square root; if the emulated baselines close most of the reported gap, the headline ratios are not a fair measure of improvement. Separately, measure the secure fixed-point AdderNet accuracy on CIFAR-10 and compare it with the plaintext accuracy reported in the paper.","tokens_in":23693,"feed_emoji":"🔐","tokens_out":9354,"duration_ms":76913,"temperature":0.7,"pith_summary":"Crypto-$L^p$ is a proposed framework for securely computing the $L^1$, $L^2$, and $L^\\infty$ norms of vectors held by two parties, using tailored two-party computation protocols rather than generic circuits. The paper claims it is the first such general framework and that it outperforms earlier secure norm constructions, with up to $82\\times$, $271\\times$, and $42\\times$ faster runtime and $36\\times$, $4\\times$, and $21\\times$ lower communication for $p=1,2,\\infty$ respectively. The same toolkit also implements the first $L^1$-norm-based two-party neural network layer, replacing convolution with the Adder operation $-|x-y|$, cutting secure inference communication by roughly $3\\times$ at comparable runtime and accuracy. If these results hold, distance-based applications such as clustering, biometric matching, location-based services, and private machine learning gain a reusable building block that makes privacy-preserving versions substantially cheaper.","feed_headline":"Unified secure Lp-norm toolkit claims up to 271x speedups","feed_subtitle":"A unified two-party toolbox for L1, L2, and L-infinity norms could make private clustering and inference much cheaper.","key_machinery":"The load-bearing object is a compact set of oblivious-transfer-based primitives: an absolute-value multiplexer that selects between $x$ and $-x$ using two correlated-OT calls, a most-significant-bit protocol that detects the sign of a shared integer, a generalized multiplexer for arbitrary private selection, and a binary-tree maximum that computes the max of $n$ shared values in $O(\\log n)$ rounds. These are composed into distance protocols: the $L^1$ norm sums per-coordinate absolute values, the $L^2$ norm squares differences and invokes a secure square root (or omits it for the squared variant), and the $L^\\infty$ norm applies the tree maximum to per-coordinate absolute values. For machine learning, the same $L^1$ machinery realizes the Adder operation $-|x-y|$, the multiplication-free similarity function that carries the paper's inference claim.","core_discovery":"The paper's central claim is that a small set of optimized two-party building blocks—most-significant-bit extraction, an absolute-value multiplexer, a binary-tree maximum, and a secure square root—can be composed into norm protocols that are far cheaper than earlier constructions. The absolute-value multiplexer is the main economy: computing $|x|$ as $x - 2 \\cdot \\mathrm{BaseMUX}(x,s)$ halves the cost of the naive approach, and the tree-based maximum reduces the round complexity of the $L^\\infty$ norm from $O(n)$ to $O(\\log n)$. The paper reports that its $L^1$, $L^2$, and $L^\\infty$ protocols beat the compared baselines by $82\\times$, $271\\times$, and $42\\times$ in runtime and $36\\times$, $4\\times$, and $21\\times$ in communication, with the stated caveat that the $L^2$ evaluation uses the squared $L^2$-norm (genuine Euclidean distance would add a secure square-root call). For inference, the framework substitutes the Adder operation $-|x-y|$ for convolution, achieving up to $3\\times$ lower communication on CIFAR-10 models while keeping runtime and accuracy close to the baseline.","pith_inferences":["The $L^2$ headline runtime figure of $271\\times$ is computed for the squared $L^2$-norm, so applications that need true Euclidean distance will pay an additional secure square-root call; treating $271\\times$ as the cost of genuine $L^2$ overstates the practical gain.","The accuracy comparison for the $L^1$-based inference is made in plaintext, not through the fixed-point secure pipeline; measuring the exact secure inference accuracy would be a direct test of the $3\\times$ communication substitution.","The emulated baselines—especially the trusted-third-party homomorphic protocol of Han et al.—are the most fragile points of the benchmark; porting that protocol into the same OT-based two-party setting would clarify whether the reported speedups are inherent or an artifact of the comparison."],"forward_implications":["If the claimed speedups hold, secure clustering, biometric matching, and location-based services can adopt these norm protocols directly, reducing the cost of common distance-based algorithms.","For high-dimensional inputs, the $L^1$-based Adder layer offers a communication-favourable substitute for secure convolution, at the price of slightly slower runtime in the reported measurements.","The absolute-value and maximum primitives are general two-party tools, so any computation needing sign, abs, or max can reuse them rather than build them from scratch.","The framework's per-building-block cost table lets practitioners estimate end-to-end norm cost before committing to a full implementation."],"supporting_citations":[{"why":"Provides the three-norm secure clustering baseline that anchors the main L1, L2, and Linfinity speedup comparisons.","marker":"[7]"},{"why":"Supplies the underlying two-party mixed-protocol framework and OT-based multiplication triples used by the construction, and serves as a comparison baseline.","marker":"[8]"},{"why":"Provides the MSB, Millionaires, and base multiplexer building blocks that Crypto-Lp optimizes.","marker":"[12]"},{"why":"Provides the multiplication and secure square-root protocols used in the L2-norm construction.","marker":"[6]"},{"why":"Is the location-based-services baseline using all three norms, emulated from its reported complexity.","marker":"[10]"},{"why":"Is the indoor-localization baseline whose protocols are re-implemented in the same two-party setting for comparison.","marker":"[38]"},{"why":"Supplies the plaintext accuracy evidence that L1 similarity can substitute for convolution in neural networks.","marker":"[21]"},{"why":"Is the convolution comparison target for the secure Adder layer and the Linfinity max comparison.","marker":"[13]"}],"fun_headline_variants":["Two-party Lp-norm toolbox: up to 271x faster, 36x less comm","Secure Lp-norm protocols beat baselines by up to 271x","Unified secure Lp-norm framework: 271x speedup, 3x less ML comm","Private Lp-norm toolbox: 82x to 271x faster, 36x less data","Novel Lp-norm protocols: 271x faster, 21x less L∞ comm"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The headline speedups rest on the assumption that the baselines were emulated faithfully enough for the comparisons to be fair, and that the accuracy measured in plaintext still holds when the same model runs through the secure two-party pipeline.","fun_headline_variants_meta":{"raw":{"variants":["Two-party Lp-norm toolbox: up to 271x faster, 36x less comm","Secure Lp-norm protocols beat baselines by up to 271x","Unified secure Lp-norm framework: 271x speedup, 3x less ML comm","Private Lp-norm toolbox: 82x to 271x faster, 36x less data","Novel Lp-norm protocols: 271x faster, 21x less L∞ comm"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000801,"raw_usage":{"total_tokens":3617,"prompt_tokens":1133,"completion_tokens":2484,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":749,"completion_tokens_details":{"reasoning_tokens":2361}},"tokens_in":749,"tokens_out":2484,"duration_ms":15902,"temperature":1.0,"reasoning_tokens":2361,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-15T16:23:54.993974+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run the main baselines in the same implementation environment, on the same machine, with the same vector size and security parameter, and measure both the squared $L^2$-norm and the true Euclidean distance with secure square root; if the emulated baselines close most of the reported gap, the headline ratios are not a fair measure of improvement. Separately, measure the secure fixed-point AdderNet accuracy on CIFAR-10 and compare it with the plaintext accuracy reported in the paper.","supporting_citations":[{"cited_title":"Practical privacy-preserving k-means clustering,","cited_arxiv_id":null,"evidence_quote":"Provides the three-norm secure clustering baseline that anchors the main L1, L2, and Linfinity speedup comparisons."},{"cited_title":"ABY - A framework for efficient mixed-protocol secure two-party computation,","cited_arxiv_id":null,"evidence_quote":"Supplies the underlying two-party mixed-protocol framework and OT-based multiplication triples used by the construction, and serves as a comparison baseline."},{"cited_title":"Cryptflow2: Practical 2-party secure inference,","cited_arxiv_id":null,"evidence_quote":"Provides the MSB, Millionaires, and base multiplexer building blocks that Crypto-Lp optimizes."},{"cited_title":"Sirnn: A math library for secure RNN inference,","cited_arxiv_id":null,"evidence_quote":"Provides the multiplication and secure square-root protocols used in the L2-norm construction."},{"cited_title":"Location privacy-preserving distance computation for spatial crowdsourcing,","cited_arxiv_id":null,"evidence_quote":"Is the location-based-services baseline using all three norms, emulated from its reported complexity."},{"cited_title":"PILOT: practical privacy-preserving indoor localization using outsourcing,","cited_arxiv_id":null,"evidence_quote":"Is the indoor-localization baseline whose protocols are re-implemented in the same two-party setting for comparison."},{"cited_title":"Addernet: Do we really need multiplications in deep learning?","cited_arxiv_id":null,"evidence_quote":"Supplies the plaintext accuracy evidence that L1 similarity can substitute for convolution in neural networks."},{"cited_title":"Cheetah: Lean and fast secure two-party deep neural network inference,","cited_arxiv_id":null,"evidence_quote":"Is the convolution comparison target for the secure Adder layer and the Linfinity max comparison."}],"review_version":2}