Sparse N-Ary Tree for Privacy-Preserving Liability Proofs
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current cryptographic proof of liability (PoL) systems in decentralized ecosystems face challenges with privacy preservation and efficiency, as they often result in long proofs and may leak user information, especially when using binary trees or other data structures that are not fully privacy-preserving.
Innovation Solution
The implementation of a sparse n-ary tree data structure, specifically a sparse summation Verkle tree, which maps liabilities to leaf nodes and uses vector commitments to ensure that only the inclusion of liabilities is revealed, maintaining privacy through zero-knowledge proofs and minimizing the size of authentication paths, thereby reducing storage and communication costs.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of manufacture
If binary trees are used in cryptographic proof of liability schemes, then the structure is simple and easy to implement, but the proof length becomes impractically long and processing time increases
Solution Approach 1:
The patent segments the binary tree structure into k-ary trees where each node has k children instead of 2. This segmentation changes the branching factor to reduce the height of the tree from O(log2 N) to O(logk N), where k > 2. The segmentation principle is applied by dividing the liability set into k branches at each level, thereby reducing the number of levels and shortening proof length while maintaining the hierarchical structure for efficient verification.
Solution Approach 2:
The patent transitions from a two-ary (binary) structure to a multi-ary (k-ary) structure by adding more dimensions to the branching factor. This dimensional change in the tree structure allows for shorter authentication paths while preserving the cryptographic properties needed for proof of liability schemes.
2Productivity
If shorter proofs are provided to reduce processing time, then efficiency improves, but user information such as the number of users may be leaked
Solution Approach 1:
The patent introduces cryptographic intermediaries including commitment schemes, zero-knowledge proofs, and authenticated data structures that act as mediators between the prover and verifier. These intermediaries enable the verification of liability inclusion without revealing underlying user information. The commitments hide the actual liability values while allowing verification of their inclusion in the total, and zero-knowledge proofs verify properties without disclosing sensitive data.
Solution Approach 2:
The patent applies different cryptographic properties to different parts of the data structure. Leaf nodes contain committed liability values with specific privacy properties, internal nodes contain aggregation information for verification efficiency, and the root contains the total liability commitment. Each part has locally optimized properties that collectively achieve both efficiency and privacy preservation.
3Reliability
If traditional data structures are used to prove liability inclusion, then completeness is achieved, but privacy preservation is insufficient and proof size becomes large
Solution Approach 1:
The patent combines multiple cryptographic primitives to create a composite proof structure. This includes combining commitment schemes (for hiding values), zero-knowledge proofs (for verifying properties without disclosure), and authenticated data structures (for efficient inclusion verification). The composite structure achieves both completeness and privacy preservation by leveraging the strengths of each component while mitigating their individual weaknesses.
Data Source
AI summary
A tree data structure having a root node, internal nodes and leaf nodes can be generated. A liability to a user can be mapped to a leaf node of the tree data structure, where each internal node of the tree data structure contains vector commitments to its child nodes and the root node contains a commitment to a sum of all leaf nodes in the tree. Responsive to receiving a query, an authentication path along the tree data structure and a plurality of proofs that prove that sums of terms in vectors along the authentication path are correct, that each entry in the vectors along the authentication path is positive, and that a sum associated with a vector in each node along the authentication path is an entry in a parent node's vector, can be generated.