Committed Program Verification Using Succinct Hash Delegation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing technologies face challenges in achieving non-interactive, publicly verifiable, and succinct delegation of computations for committed programs without relying on SNARGs, particularly in scenarios where the verifier does not know the program, and current solutions are inefficient or require standard assumptions.
Innovation Solution
A protocol using the Learning with Errors (LWE) problem to enable non-interactive public verification of computations by allowing a trusted party to generate a succinct hash of the program, which is then used for public verification, ensuring zero-knowledge guarantees and efficient communication.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If SNARGs for NP are used to achieve non-interactive publicly verifiable delegation, then verification can be performed without knowing the program, but the solution requires non-standard knowledge assumptions or Random Oracle Model
Solution Approach 1:
The patent introduces a trusted setup phase that generates a common reference string (CRS) containing a trapdoor. This intermediary structure allows the verifier to verify computations without knowing the program, while the trapdoor enables the prover to generate valid proofs. The CRS acts as a mediator between the prover and verifier, eliminating the need for direct knowledge of the program while maintaining verification soundness based on standard LWE assumptions.
2Ease of manufacture
If the verifier knows the program P, then delegation can be achieved with standard assumptions, but the verification becomes trivial and does not provide meaningful delegation for large programs
Solution Approach 1:
The patent extracts only the necessary verification information from the program by using a succinct hash representation and trapdoor mechanism. Instead of requiring the verifier to know the entire program P, the system extracts a compressed verification credential (CRS with trapdoor) that contains all necessary information to verify computations. This extraction enables meaningful delegation for large programs while maintaining ease of construction through standard cryptographic assumptions.
3Reliability
If pre-processing algorithm is required before delegation, then public verification can be achieved, but the input provider cannot delegate without running the program first
Solution Approach 1:
The patent performs the preliminary action of generating the common reference string (CRS) with trapdoor during a setup phase before any actual delegation occurs. This pre-computed CRS is then reused for all subsequent verification operations, eliminating the need for repeated pre-processing. The trapdoor in the CRS enables the input provider to delegate computations immediately without needing to run the program again, thus reducing time loss while maintaining public verification reliability.
4Ease of operation
If non-interactive setting is implemented, then verification can be performed without interaction, but achieving succinct delegation for committed programs remains elusive
Solution Approach 1:
The patent uses a copying mechanism where the prover creates a copy of the computation trace and proofs, then verifies this copy against the CRS and challenge values. The verifier receives a condensed copy of the computation results and verification credentials, allowing non-interactive verification without requiring the full original computation data. This copying approach enables succinct non-interactive delegation while managing protocol complexity through efficient data representation.
Data Source
AI summary
Embodiments include a fully non-interactive publicly-verifiable delegation scheme for committed programs, specifically, a setting where Alice is a trusted author who delegates to an untrusted worker the task of hosting a program P, represented as a Boolean circuit. Alice also commits to a succinct value based on P. Disclosed methods allow an arbitrary user/verifier without knowledge of P to be convinced that they are receiving from the worker an actual computation of Alice's program on a given input x.