Validation of GPU Computation in Decentralized, Trustless Networks

Alison Haire; Eric Boniardi; Stanley Bishop

REVIEW 5 major objections 5 minor 21 references

Validation of GPU Computation in Decentralized, Trustless Networks

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

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

Pith's one-line read This paper claims that semantic similarity between outputs can probabilistically verify correct GPU execution in decentralized networks, replacing bitwise comparison.

desk verdict Semantic verification is a real idea, but the paper tests it only against random text, not GPU failures, so the central claim is unsupported. read the letter →

arxiv 2501.05374 v1 pith:L54BVH7M submitted 2025-01-09 cs.ET cs.DC

Eric Boniardi , Stanley Bishop , Alison Haire This is my paper · ORCID

classification cs.ETcs.DC

keywords semanticsimilarityGPUnon-determinismdecentralizedverificationtrustlessnetworksLLMinferenceconsensusprotocolthresholdcomputationalintegrity

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

Because GPU execution is inherently non-deterministic, bitwise recomputation cannot verify decentralized GPU work, and the paper argues that cryptographic alternatives are impractical. It proposes to verify correctness by comparing the semantic similarity of outputs: an untrusted node's answer is accepted when its meaning is close to a trusted reference or to enough independent peer answers. Using a cosine-similarity threshold of 0.5 tuned on the Chatbot Arena dataset, the paper reports 76.5% held-out accuracy, precision 66.9%, recall 81.8%, and F1 0.736. The paper's ternary consensus variant claims to remove the need for a trusted node, replacing it with two independent verifiers and a two-tier consensus rule.

What carries the argument

The load-bearing mechanism is semantic-similarity thresholding on neural embeddings: each output is transformed into a vector by a sentence-transformer embedding model, and correctness is decided by whether the cosine similarity between two outputs reaches an offline-optimized threshold $t^* = 0.5$. The ternary protocol adds a two-tier rule: first both verifier nodes must agree on the pairwise similarity pattern, and then a response set is accepted only when at least two of the three responses are mutually similar. This machinery converts the intractable problem of checking bitwise equality into a tractable problem of checking meaning preservation.

What would settle it

Run the same prompt through the same LLM on two different GPU architectures and measure cosine similarity between their outputs across many prompts; if a sizable share of these correct-but-non-deterministic pairs falls below the 0.5 threshold, the semantic proxy cannot distinguish correct execution from error. Conversely, show that an adversarial node can pass verification by copying a valid response or by emitting text whose embedding lands above 0.5.

Watch

Extended reading notes

Core claim

The central discovery is that neural text embeddings can serve as a probabilistic substitute for bitwise comparison when verifying non-deterministic GPU workloads. The paper establishes that outputs from the same language model embed close together (intra-model cosine similarity around 0.55), while unrelated responses embed far apart (around 0.05), so a threshold of 0.5 can separate legitimate outputs from arbitrary ones. It packages this into two protocols: a binary reference model where a trusted node compares outputs against its own reference, and a ternary consensus model where three nodes produce responses and two verifier nodes judge pairwise similarities. The paper reports training accuracy of 76.1% and held-out accuracy of 76.5%, and it asserts that the ternary protocol eliminates the requirement of trust in the verification process.

Load-bearing premise

The load-bearing premise is that semantic similarity between text outputs is a reliable proxy for correct GPU computation, meaning a node that computes incorrectly will produce an output whose embedding is far from correct outputs, and a node that computes correctly will stay close regardless of hardware-induced non-determinism.

Editorial extensions

If this is right

A decentralized network can validate non-deterministic LLM inference without deterministic recomputation or specialized hardware, so long as semantic equivalence is accepted as the standard of correctness.
The semantic threshold is reusable across queries: once tuned offline, the same 0.5 threshold can be applied at inference time to new outputs.
The ternary protocol enables verification without a trusted reference node, provided the two verifier nodes are independent and non-colluding.
The reported 76.5% accuracy means the guarantee is explicitly probabilistic: some invalid outputs will pass and some valid outputs will be rejected.
GPU profiling is left for future work, so the verified class of computations in this paper is currently text-generating models rather than arbitrary GPU kernels.

Reading between the lines

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

Editorial extension: the experiments compare LLM outputs with random unrelated text, so the claim that this verifies GPU computation assumes that any real execution error will shift the output's embedding far enough to cross the 0.5 threshold; that remains unmeasured.
A natural test is to run the same model on different GPU architectures and measure the actual similarity distribution of correct-but-bitwise-different outputs; if that distribution dips below 0.5, the threshold would need recalibration by hardware class.
The ternary protocol's trustlessness depends on the two verifiers not colluding, so an adversarial deployment would likely need staking or sybil-resistance to make collusion costly.
The semantic approach could extend to other stochastic output domains where correctness is defined by meaning, such as image captions or summaries, but it would not suit numerical computations where correctness is exact.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Desk Editor's Note

read the letter

Colleague,

The punchline: this paper proposes semantic similarity as a cheap way to verify GPU computation in decentralized networks, but the experiments never touch GPU computation. The positive class is same-model LLM responses; the negative class is random text. So the 76.5% accuracy measures something real but narrow—discriminating coherent model output from noise—and not the claimed verification property.

What is genuinely useful: the survey of FHE and TEE limitations is solid, with a concrete per-token cost estimate. The fingerprinting pilot is honestly reported (15% exact, 25% partial match) and the authors correctly drop that direction. The binary and ternary protocol descriptions are clear enough to implement, and the threshold search is proper train/test split methodology.

The soft spots are load-bearing. First, the negative class is trivial. Random Arena text is semantically far away; the failure modes that matter—a node running a quantized or smaller model, a swapped model, or an adversarial topic-consistent answer—are absent. The paper's own numbers show same-model similarity around 0.55 and cross-model around 0.557, with threshold 0.5. The margin is thin and no distributional analysis is given. Second, no GPU experiments at all. No repeated runs, no non-determinism measurements, no profiling. The title and abstract claim GPU validation; the data are text embeddings. Third, the ternary consensus protocol just asserts that two verifier nodes eliminate trust, with no adversary model or collusion analysis.

The citations are appropriate and prior work is credited. No artifacts, which is a minor further weakness.

Verdict: the central claim is unsupported by the experiments. This could become a decent proof-of-concept for semantic verification of LLM outputs if reframed, with an adversary model and GPU-based tests. As written, it overclaims. I think it deserves a serious referee—the problem is real and the protocols are concrete—but I would expect a reject or major revision. It is a good reading-group example of verification claims outrunning test sets.

Recommendation: send to peer review, but brace for heavy revision.

Referee Report

5 major / 5 minor

Summary. The paper argues that existing methods for verifying GPU computations in decentralized networks (exact recomputation, TEEs, FHE) are impractical, and it explores three alternative approaches: model fingerprinting, semantic similarity analysis, and GPU profiling. The empirical section reports a fingerprinting match rate of 15% exact / 25% partial on LLaMA-2-7B, and a semantic-similarity experiment on Chatbot Arena data in which a cosine-similarity threshold of 0.5 distinguishes same-model and cross-model LLM responses from random unrelated Arena responses with 76.5% held-out accuracy. On this basis the paper proposes a binary reference-node protocol and a ternary consensus protocol for trustless verification. The abstract and title claim validation of GPU computation, but no GPU execution, GPU non-determinism, or adversarial execution is experimentally studied; the reported metrics only separate LLM-generated text from random text.

Significance. The paper identifies a real problem: bitwise verification is unsuitable for non-deterministic GPU workloads, and the FHE/TEE alternatives have severe practical limitations. The proposed binary and ternary semantic-verification protocols are clearly described, and the use of a held-out test split for threshold evaluation is a methodological strength over simple in-sample reporting. If the underlying premise were validated—that semantic-similarity distance reliably separates correct from incorrect GPU computations—the framework would be a useful practical contribution. However, the paper does not validate that premise: the experiments contain no GPU traces, no controlled non-determinism, no wrong-model or adversarial outputs, and no GPU profiling results, so the central claim of the title and abstract is currently unsupported. The contribution is best assessed as a preliminary proposal for semantic verification of LLM outputs, not a validated method for GPU computation verification.

major comments (5)

[Sections 5 and 7] The central claim that semantic similarity can validate GPU computation is untested. The experiments compare LLM text responses (same model, cross-model, and random Arena responses) using sentence embeddings; they never involve GPU execution, bitwise variation from non-determinism, driver or architecture differences, quantized or swapped models, or adversarial outputs. The reported 76.5% held-out accuracy therefore estimates separability of LLM text from random text, not the false-accept/false-reject rates relevant to verifying a GPU computation. This is a load-bearing gap for the title and abstract's claim of 'Validation of GPU Computation in Decentralized, Trustless Networks'.
[Section 6.0.1 and Section 5] The threshold t*=0.5 is calibrated using same-model and cross-model (8B vs 70B) responses as positive examples and random Arena responses as negatives. The verification protocol, however, must in practice separate correct execution of a specified model from incorrect execution (e.g., wrong model, wrong weights, or non-deterministic numerical differences). Section 5 reports intra-model similarities of 0.549 and 0.565 and inter-model similarity of 0.557, all only marginally above the chosen threshold of 0.5. This leaves essentially no margin and suggests that similarity distributions for correct versus incorrect execution could overlap substantially; the paper does not report those distributions for any actual verification scenario.
[Section 6.0.2] The ternary consensus protocol's claim that it 'eliminates the requirement of trust' is asserted without an adversary model. The protocol assumes two verifier nodes reach identical conclusions and that three response nodes behave independently, but no threat model specifies collusion, Byzantine verifiers, duplicated responses, or an attacker controlling multiple nodes. In particular, if an adversarial node simply copies a valid response from another node, pairwise similarity will be high and the invalid response can pass; the paper does not address this attack, nor does it define what happens if all three responses are semantically similar but all are wrong. Without these details, the trustless property is not established.
[Section 5 and Section 3.1] The fingerprinting results reported in Section 5 (15% exact match, 25% partial match out of 60 samples) are low for a verification mechanism, and the paper explicitly notes that reliable detection often requires multiple queries, impacting economic viability. Despite this, Section 3.1 describes fingerprint verification through exact and inside match comparisons as a viable approach, and the abstract lists model fingerprinting as one of three explored methodologies. The paper should either present fingerprinting as a preliminary negative result or provide the query-count and cost analysis needed to assess its feasibility; as written, the treatment is internally inconsistent regarding whether fingerprinting is a supported contribution.
[Section 3.3 and Section 5] GPU profiling is listed as a third verification methodology in the abstract and Section 3.3, but Section 5 explicitly states that 'its implementation requires extensive data collection and will be explored in future work,' and no profiling experiments or validation appear anywhere in the paper. The abstract's claim that the paper 'explores three verification methodologies' is therefore overstated; only semantic similarity receives empirical validation, and even that is only for LLM text, not GPU execution.

minor comments (5)

[Section 7] The description of the random baseline is under-specified: 'sampling three unrelated responses from the Arena dataset' should clarify whether these are responses to the same prompt, responses to different prompts, or arbitrary text, because the resulting similarity distribution depends critically on this choice.
[Figure 6] Figure 6 lacks axis labels and a legend, making it difficult to determine which curves correspond to training versus testing and what quantity is plotted; the caption should describe the reported metric and class balance.
[Section 5] The phrase 'semantic similarity distance' is imprecise, since cosine similarity is a similarity measure rather than a distance; the paper should use consistent terminology (e.g., 'cosine similarity' or 'semantic dissimilarity').
[General] The manuscript contains multiple typographical and formatting errors, including 'o ffering', 'e fficiency', a duplicated affiliation '2Lilypad Network', and inconsistent author footnotes; these should be corrected before resubmission.
[Section 2.2.1] The FHE cost estimate is computed for CPU-based execution ('on a modern CPU... $5,000 per token'), but the paper's focus is GPU workloads; the authors should either provide GPU-relevant cost estimates or clarify that the estimate is only indicative of orders of magnitude.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the threshold is fitted on a training split and validated on a held-out split, so the reported accuracy is an honest out-of-sample measurement rather than a self-referential reduction.

full rationale

The paper's central quantitative claim is a standard supervised threshold-selection result. In Section 6.0.1 the threshold t* is selected on the LMSYS Chatbot Arena training data, and Section 7 reports that the same threshold reaches 76.5% accuracy on a held-out test set. This is an empirical fit with genuine out-of-sample evaluation, not a parameter that is defined in terms of the quantity it predicts. The protocol's validity rule ('if the similarity equals or exceeds t*, the response is deemed valid') is an operational definition, but the reported accuracy is not forced to be high by construction; it is a measured agreement with external labels (same-question model responses vs. random arena responses). No self-citations are load-bearing; reference [12] (Xu et al.) is tested and abandoned, and [16] (SemScore) provides the metric. The principal weakness is construct validity: the experiments compare LLM text outputs to random text, never GPU non-determinism, swapped models, or adversarial outputs, so semantic similarity is not shown to track computational correctness. That is a correctness/validity risk, not circularity, and it does not make the derivation equivalent to its inputs.

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

The central protocol rests on one fitted threshold, a pretrained embedding model, and several unvalidated domain assumptions about GPU nondeterminism and accuracy semantics. No new physical entities are introduced.

free parameters (1)

semantic similarity threshold t* = 0.5
Selected by sweeping 0.0 to 0.9 in increments of 0.1 on a training subset of Chatbot Arena questions to maximize classification accuracy (Sections 6.0.1 and 7).

assumptions (4)

domain assumption GPU nondeterminism produces semantically equivalent but bitwise different outputs, so semantic similarity is the right correctness criterion.
Stated in Sections 1 and 2 and used throughout; no GPU experiment verifies this mapping.
ad hoc to paper LLM text generation is representative of GPU workloads in decentralized networks.
All experiments use LLM outputs; results are generalized to GPU computation in the abstract and conclusion without a bridging experiment.
ad hoc to paper Incorrect computation can be modeled by random unrelated responses.
The negative class in Section 7 is three unrelated Arena responses; adversarial or subtly wrong outputs are not tested.
domain assumption Verifier nodes in the ternary protocol are independent and non-colluding.
The two-tier consensus in Section 6.0.2 requires both verifiers to reach identical conclusions; the paper provides no adversary or collusion model.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Validation of GPU Computation in Decentralized, Trustless Networks." pith.science (2026). https://pith.science/paper/L54BVH7M

@misc{pith2026250105374,
  author       = {Pith},
  title        = {Pith review of: Validation of GPU Computation in Decentralized, Trustless Networks},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/L54BVH7M}},
  note         = {Machine review of arXiv:2501.05374}
}

read the original abstract

Verifying computational processes in decentralized networks poses a fundamental challenge, particularly for Graphics Processing Unit (GPU) computations. Our investigation reveals significant limitations in existing approaches: exact recomputation fails due to computational non-determinism across GPU nodes, Trusted Execution Environments (TEEs) require specialized hardware, and Fully Homomorphic Encryption (FHE) faces prohibitive computational costs. To address these challenges, we explore three verification methodologies adapted from adjacent technical domains: model fingerprinting techniques, semantic similarity analysis, and GPU profiling. Through systematic exploration of these approaches, we develop novel probabilistic verification frameworks, including a binary reference model with trusted node verification and a ternary consensus framework that eliminates trust requirements. These methodologies establish a foundation for ensuring computational integrity across untrusted networks while addressing the inherent challenges of non-deterministic execution in GPU-accelerated workloads.

Figures

Figures reproduced from arXiv: 2501.05374 by the authors.

**Figure 1.** Model Fingerprinting Process frameworks, structured representations of knowledge that define concepts and their relationships. This measurement approach evaluates the distance between two concepts through their relative positioning within a hierarchical knowledge structure, providing a numerical representation of their conceptual closeness.[14] The computational framework operates by examining the positions of c… view at source ↗

**Figure 3.** GPU Profiling 3 Implementation of Cross-Domain Techniques for Computational Verification The subsequent sections detail alternative methodological approaches for adapting model fingerprinting, semantic similarity analysis, and GPU profiling to computational verification. These techniques, while originating from distinct domains, provide complementary mechanisms for establishing computational integrity. 3.1 From F… view at source ↗

**Figure 2.** Semantic Similarity of Input Embeddings 2.3.3 GPU Performance Profiling GPU profiling constitutes a systematic approach to monitoring graphics processing unit resource utilization during computational task execution. To illustrate the technical mechanisms of GPU profiling, we examine the implementation methodology of gpu_tracker.[17] The foundation of GPU profiling lies in its sampling architecture: a dedicated bac… view at source ↗

Figures from the paper (3 more)

**Figure 4.** Figure 4: Fingerprinting Preliminary Results [PITH_FULL_IMAGE:figures/full_fig_p005_4.png]

**Figure 5.** Figure 5: Semantic Preliminary Results 6 A Novel Verification Framework for Decentralized Computation via Semantic Analysis Based on our empirical evaluation, the adapter-based fingerprinting methodology exhibited substantial operational constraints, primarily stemming from the…

**Figure 6.** Figure 6: Empirical Analysis Results [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

21 extracted references · 16 canonical work pages

[1]

Mechanisms for outsourcing computation via a decentralized market

Scott Eisele, Taha Eghtesad, Nicholas Troutman, Aron Laszka, and Abhishek Dubey. Mechanisms for outsourcing computation via a decentralized market. In Proceedings of the 14th ACM International Conference on Distributed and Event-based Systems, pages 61–72, 2020

work page 2020
[2]

Determinism in deep learning

NVIDIA. Determinism in deep learning. https://developer.download.nvidia.com/ video/gputechconf/gtc/2019/presentation/ s9911-determinism-in-deep-learning.pdf , 2019. GTC 2019 Presentation S9911

work page 2019
[3]

Deep learning determinism

Duncan Riach. Deep learning determinism. https: //www.youtube.com/watch?v=TB07_mUMt0U, March

work page
[4]

A guide to fully homomorphic encryption

Frederik Armknecht, Colin Boyd, Christopher Carr, Kris- tian Gjøsteen, Angela Jäschke, Christian A Reuter, and Martin Strand. A guide to fully homomorphic encryption. Cryptology ePrint Archive, 2015

work page 2015
[5]

Peev: Parse encrypt execute verify-a verifiable fhe framework

Omar Ahmed, Charles Gouert, and Nektarios Georgios Tsoutsos. Peev: Parse encrypt execute verify-a verifiable fhe framework. IEEE Access, 2024

work page 2024
[6]

Towards encrypted large language models with FHE, August 2023

Jordan Frery. Towards encrypted large language models with FHE, August 2023. URL https://huggingface. co/blog/encrypted-llm. Blog post. Preprint – Validation of GPU Computation in Decentralized, Trustless Networks 8

work page 2023
[7]

Zama AI: Open source FHE solutions, 2024

Zama AI. Zama AI: Open source FHE solutions, 2024. URL https://github.com/zama-ai. Open source cryptography company developing Fully Homomorphic Encryption (FHE) solutions

work page 2024
[8]

Un- locking the potential of fully homomorphic encryption

Shruthi Gorantala, Rob Springer, and Bryant Gipson. Un- locking the potential of fully homomorphic encryption. Communications of the ACM, 66(5):72–81, May 2023. doi: 10.1145/3572832

work page doi:10.1145/3572832 2023

Show all 21 references

[9]

Making ChatGPT encrypted end-to-end, April 2023

Rand Hindi. Making ChatGPT encrypted end-to-end, April 2023. URL https://www.zama.ai/post/ chatgpt-privacy-with-homomorphic-encryption . Blog post

2023
[10]

Trusted execution environment: What it is, and what it is not

Mohamed Sabt, Mohammed Achemlal, and Abdelmadjid Bouabdallah. Trusted execution environment: What it is, and what it is not. In 2015 IEEE Trustcom/BigDataSE/Ispa, volume 1, pages 57–64. IEEE, 2015

2015
[11]

Teamwork makes tee work: Open and resilient remote attestation on decentralized trust

Xiaolin Zhang, Kailun Qin, Shipei Qu, Tengfei Wang, Chi Zhang, and Dawu Gu. Teamwork makes tee work: Open and resilient remote attestation on decentralized trust. arXiv preprint arXiv:2402.08908, 2024

2024 arXiv
[12]

Instructional fingerprinting of large language models

Jiashu Xu, Fei Wang, Mingyu Derek Ma, Pang Wei Koh, Chaowei Xiao, and Muhao Chen. Instructional fingerprinting of large language models. arXiv preprint arXiv:2401.12255, 2024

2024 arXiv
[13]

Proflingo: A fingerprinting-based copyright protection scheme for large language models

Heng Jin, Chaoyu Zhang, Shanghao Shi, Wenjing Lou, and Y Thomas Hou. Proflingo: A fingerprinting-based copyright protection scheme for large language models. arXiv preprint arXiv:2405.02466, 2024

2024 arXiv
[14]

Description and evaluation of se- mantic similarity measures approaches

Thabet Slimani. Description and evaluation of se- mantic similarity measures approaches. arXiv preprint arXiv:1310.8059, 2013

2013 arXiv
[15]

Evaluating large language models: A compre- hensive survey

Zishan Guo, Renren Jin, Chuang Liu, Yufei Huang, Dan Shi, Linhao Yu, Yan Liu, Jiaxuan Li, Bojian Xiong, Deyi Xiong, et al. Evaluating large language models: A compre- hensive survey. arXiv preprint arXiv:2310.19736, 2023

2023 arXiv
[16]

Semscore: Automated evaluation of instruction-tuned llms based on semantic textual similarity

Ansar Aynetdinov and Alan Akbik. Semscore: Automated evaluation of instruction-tuned llms based on semantic textual similarity. arXiv preprint arXiv:2401.17072, 2024

2024 arXiv
[17]

gpu_tracker: Context man- ager and CLI that tracks the computational-resource-usage of a code block or shell command, particularly the GPU usage, September 2024

MoseleyBioinformaticsLab. gpu_tracker: Context man- ager and CLI that tracks the computational-resource-usage of a code block or shell command, particularly the GPU usage, September 2024. URL https://github.com/ MoseleyBioinformaticsLab/gpu_tracker. GitHub repository

2024
[18]

gpu_tracker: Python package for tracking and profiling gpu utilization in both desktop and high-performance computing environ- ments

Erik D Huckvale and Hunter NB Moseley. gpu_tracker: Python package for tracking and profiling gpu utilization in both desktop and high-performance computing environ- ments. arXiv preprint arXiv:2404.01473, 2024

2024 arXiv
[19]

A normalized levenshtein distance metric

Li Yujian and Liu Bo. A normalized levenshtein distance metric. IEEE transactions on pattern analysis and machine intelligence, 29(6):1091–1095, 2007

2007
[20]

Chatbot Arena conversation dataset re- lease, July 2023

LMSYS Org. Chatbot Arena conversation dataset re- lease, July 2023. URL https://lmsys.org/blog/ 2023-07-20-dataset/ . Dataset

2023
[2019]

Presented at GTC 2019, San Jose McEnery Conven- tion Center, March 20, 2019

2019

Pith tools

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

[1] [1]

Mechanisms for outsourcing computation via a decentralized market

Scott Eisele, Taha Eghtesad, Nicholas Troutman, Aron Laszka, and Abhishek Dubey. Mechanisms for outsourcing computation via a decentralized market. In Proceedings of the 14th ACM International Conference on Distributed and Event-based Systems, pages 61–72, 2020

work page 2020

[2] [2]

Determinism in deep learning

NVIDIA. Determinism in deep learning. https://developer.download.nvidia.com/ video/gputechconf/gtc/2019/presentation/ s9911-determinism-in-deep-learning.pdf , 2019. GTC 2019 Presentation S9911

work page 2019

[3] [3]

Deep learning determinism

Duncan Riach. Deep learning determinism. https: //www.youtube.com/watch?v=TB07_mUMt0U, March

work page

[4] [4]

A guide to fully homomorphic encryption

Frederik Armknecht, Colin Boyd, Christopher Carr, Kris- tian Gjøsteen, Angela Jäschke, Christian A Reuter, and Martin Strand. A guide to fully homomorphic encryption. Cryptology ePrint Archive, 2015

work page 2015

[5] [5]

Peev: Parse encrypt execute verify-a verifiable fhe framework

Omar Ahmed, Charles Gouert, and Nektarios Georgios Tsoutsos. Peev: Parse encrypt execute verify-a verifiable fhe framework. IEEE Access, 2024

work page 2024

[6] [6]

Towards encrypted large language models with FHE, August 2023

Jordan Frery. Towards encrypted large language models with FHE, August 2023. URL https://huggingface. co/blog/encrypted-llm. Blog post. Preprint – Validation of GPU Computation in Decentralized, Trustless Networks 8

work page 2023

[7] [7]

Zama AI: Open source FHE solutions, 2024

Zama AI. Zama AI: Open source FHE solutions, 2024. URL https://github.com/zama-ai. Open source cryptography company developing Fully Homomorphic Encryption (FHE) solutions

work page 2024

[8] [8]

Un- locking the potential of fully homomorphic encryption

Shruthi Gorantala, Rob Springer, and Bryant Gipson. Un- locking the potential of fully homomorphic encryption. Communications of the ACM, 66(5):72–81, May 2023. doi: 10.1145/3572832

work page doi:10.1145/3572832 2023