A system to dynamically calculate a root hash value from a plurality of leaf hash values includes a flat associative memory and a hash parser. The flat associative memory stores a plurality of leaf hash values. The hash parser extracts a compressed number of branch nodes from the plurality of leaf hash values, determines branch node relationships from the plurality of leaf hash values, and saves the compressed number of branch nodes, and the branch node relationships.
Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
2. The system of claim 1 wherein said plurality of leaf hash values is stored in columns of said flat associative memory.
A system for data storage and retrieval uses a flat associative memory to store and process data efficiently. The system addresses the challenge of managing large datasets by organizing data in a way that allows for fast and flexible access. The flat associative memory is structured to store multiple leaf hash values in columns, enabling parallel processing and quick lookups. These leaf hash values are derived from hierarchical hash structures, such as Merkle trees, where each leaf represents a data block or record. By storing the leaf hash values in columns, the system optimizes memory access patterns, reducing latency and improving throughput. The flat associative memory can be implemented using hardware or software, depending on the application requirements. The system may also include mechanisms for updating and verifying the integrity of the stored data, ensuring reliability and consistency. This approach is particularly useful in applications requiring high-speed data retrieval, such as blockchain systems, distributed databases, or real-time analytics platforms. The columnar storage of leaf hash values allows for efficient parallel processing, making the system scalable and adaptable to various use cases.
3. The system of claim 1 wherein said hash parser to extract said compressed number of branch nodes, and said branch node relationships are determined from a top root node down to a set of leaves.
The invention relates to a system for parsing and analyzing hierarchical data structures, particularly in the context of compressed data representations. The system addresses the challenge of efficiently extracting and interpreting compressed hierarchical data, such as decision trees or branching structures, where the data is stored in a compact form to save memory and processing resources. The system includes a hash parser that decompresses the data to reconstruct the original hierarchical structure, including the number of branch nodes and their relationships. The parsing process begins at a top root node and proceeds downward through the hierarchy to identify all branch nodes and their connections, ultimately reaching the leaf nodes at the bottom of the structure. This approach ensures accurate reconstruction of the original data while minimizing computational overhead. The system is particularly useful in applications requiring fast access to hierarchical data, such as machine learning models, database indexing, or network routing, where compressed representations are common but efficient decompression is critical for performance. The invention improves upon prior methods by providing a structured and systematic way to parse compressed hierarchical data, ensuring both accuracy and efficiency in the reconstruction process.
4. The system of claim 1 wherein said hash parser to parse said plurality of leaf hash values from a most significant byte to a least significant byte of said plurality of leaf hash values.
The invention relates to a system for processing hash values in a hierarchical data structure, such as a Merkle tree, to improve efficiency and accuracy in data verification. The system addresses the challenge of efficiently parsing and processing hash values, particularly in distributed or decentralized systems where data integrity is critical. The system includes a hash parser that extracts leaf hash values from a data structure, such as a Merkle tree, and processes them in a specific order. The hash parser parses the leaf hash values from the most significant byte to the least significant byte, ensuring consistent and systematic processing. This ordered parsing method enhances computational efficiency and reduces errors in hash value extraction, which is essential for applications like blockchain verification, digital signatures, and secure data storage. The system may also include a data structure generator that constructs the hierarchical data structure, such as a Merkle tree, from input data, and a verification module that uses the parsed hash values to verify data integrity. The ordered parsing approach ensures that the system can reliably and efficiently validate data across distributed networks, improving security and performance in applications requiring cryptographic proof.
5. The system of claim 1 wherein said hash parser to find common prefixes between said plurality of leaf hash values.
A system for optimizing data storage and retrieval in a distributed ledger or blockchain environment addresses the inefficiency of storing and verifying large volumes of hash values. The system includes a hash parser that processes a plurality of leaf hash values, which are typically generated from transactions or data blocks in the ledger. The hash parser identifies common prefixes among these leaf hash values, enabling compression and efficient storage. By detecting shared prefix patterns, the system reduces the storage footprint and speeds up verification processes, as only the unique suffixes of the hash values need to be stored or transmitted. This is particularly useful in blockchain networks where hash values are frequently compared to validate transactions or blocks. The system may also include a data structure, such as a Merkle tree, where the leaf hash values are derived from lower-level nodes, and the common prefix detection further optimizes the tree's traversal and verification. The hash parser may employ algorithms like prefix trees or hash-based indexing to efficiently locate and manage these common prefixes, improving overall system performance.
6. The system of claim 1 and also comprising a node calculator to calculate branch node hash values, and said root hash value according to said branch node relationships.
A system for cryptographic data verification calculates hash values for a hierarchical data structure. The system includes a data structure generator that creates a hierarchical data structure with branch nodes and a root node, where each branch node is linked to one or more child nodes. A node calculator computes hash values for each branch node based on the data stored in the child nodes and their relationships. The node calculator also calculates a root hash value that represents the entire hierarchical data structure by aggregating the hash values of the branch nodes according to their hierarchical relationships. This system enables efficient verification of data integrity by allowing a verifier to check the root hash value against a trusted reference, ensuring that the underlying data has not been altered. The hierarchical structure allows for selective verification of subsets of the data by examining intermediate branch node hash values. This approach is particularly useful in blockchain and distributed ledger technologies, where maintaining data integrity across a network of nodes is critical. The system ensures that any modification to the data would result in a change to the root hash value, making tampering detectable.
7. The system of claim 6 and also comprising at least one flat node table to save said compressed number of branch nodes, and said branch node relationships.
A system for optimizing data storage and retrieval in hierarchical or tree-like data structures, such as those used in databases or file systems, addresses inefficiencies in storing and accessing nested or branching data. Traditional methods often require significant memory and computational overhead to manage parent-child relationships and traversal paths, leading to slower performance and higher resource consumption. The system improves upon this by compressing the number of branch nodes in the hierarchy, reducing the overall storage footprint and simplifying traversal operations. Additionally, the system includes at least one flat node table to store the compressed branch nodes and their relationships. This table provides a structured, linear representation of the hierarchical data, enabling faster lookups and updates while maintaining the integrity of the original branching structure. The flat node table may include identifiers for each node, references to parent or child nodes, and metadata such as depth or position within the hierarchy. By combining compression techniques with a flat storage format, the system enhances scalability and performance for applications requiring frequent hierarchical data access.
8. The system of claim 7 wherein said at least one flat node table to record said branch node hash values, and said root hash value.
A system for managing hierarchical data structures, such as Merkle trees, includes a method for efficiently storing and retrieving hash values associated with branch nodes and root nodes. The system addresses the challenge of optimizing storage and computational efficiency in distributed ledger technologies, blockchain systems, or other applications requiring cryptographic verification of data integrity. The system uses at least one flat node table to record branch node hash values and a root hash value, enabling fast lookups and reducing the overhead of traversing hierarchical structures. The flat node table simplifies the storage and retrieval process by eliminating the need for nested or recursive data structures, improving performance in environments where rapid verification is critical. The system may also include mechanisms for updating the flat node table when new branch nodes are added or modified, ensuring consistency between the stored hash values and the underlying data. This approach enhances scalability and reliability in applications requiring frequent cryptographic proofs, such as blockchain consensus algorithms or distributed databases. The system may further integrate with other components, such as validation modules or consensus protocols, to ensure that the recorded hash values are accurately reflected in the overall data structure. By using a flat node table, the system reduces complexity while maintaining the integrity and verifiability of the hierarchical data structure.
9. The system of claim 8 wherein said node calculator to recalculate a new root hash value using at least one newly calculated branch node hash value and said branch node hash values stored in said at least one flat node table.
A system for managing and updating a data structure, such as a Merkle tree, is designed to efficiently recalculate a root hash value when changes occur in the underlying data. The system addresses the computational inefficiency of recalculating the entire tree structure from scratch whenever a single data element is modified. Instead, it leverages a flat node table that stores precomputed branch node hash values, allowing for selective recalculation of only the affected portions of the tree. The system includes a node calculator that recalculates a new root hash value by combining at least one newly calculated branch node hash value with the existing branch node hash values stored in the flat node table. This approach minimizes computational overhead by avoiding redundant hash calculations and ensures data integrity by maintaining an up-to-date root hash that reflects all changes in the underlying data. The system is particularly useful in applications requiring frequent updates to large datasets, such as blockchain systems, distributed ledgers, or any environment where efficient hash tree maintenance is critical. The flat node table serves as a cache of intermediate hash values, enabling faster updates and reducing the time required to verify the integrity of the entire data structure.
10. The system of claim 1 wherein said hash parser is implemented in an associative processing unit.
The system relates to data processing, specifically to a system for parsing hash values using an associative processing unit. The problem addressed is the need for efficient and scalable hash parsing in data processing systems, particularly in applications requiring high-speed lookups or comparisons of hash values. Traditional hash parsing methods may suffer from bottlenecks in performance or scalability, especially when dealing with large datasets or real-time processing requirements. The system includes a hash parser implemented in an associative processing unit. The associative processing unit is designed to perform parallel comparisons of input data against stored data, leveraging associative memory techniques to accelerate the parsing process. This implementation allows for rapid identification and extraction of relevant hash values from input data streams, improving processing efficiency and reducing latency. The associative processing unit may include specialized hardware or firmware optimized for associative operations, such as content-addressable memory (CAM) or other associative storage mechanisms. The system may also include input interfaces for receiving data streams, preprocessing modules for preparing the data for parsing, and output interfaces for delivering parsed results. The associative processing unit's parallel processing capabilities enable high-throughput hash parsing, making the system suitable for applications like network security, data indexing, or real-time analytics. The overall design aims to enhance the speed and scalability of hash-based operations in data processing environments.
11. The system of claim 8 wherein said at least one flat node table is implemented in CPU memory.
A system for managing and querying hierarchical data structures, such as organizational charts or file systems, addresses inefficiencies in traditional relational database approaches. These systems often struggle with complex hierarchical queries, leading to slow performance and high computational overhead. The invention introduces a flat node table stored in CPU memory to optimize hierarchical data access. This table contains entries for each node in the hierarchy, with each entry including a unique identifier, a parent identifier, and other relevant attributes. By storing the table in CPU memory, the system reduces latency and improves query performance compared to disk-based storage. The system also includes a query processor that translates hierarchical queries into efficient operations on the flat node table, enabling fast traversal and retrieval of hierarchical relationships. Additional features may include indexing mechanisms to further accelerate lookups and support for dynamic updates to the hierarchy. The invention is particularly useful in applications requiring real-time hierarchical data analysis, such as enterprise resource planning or network topology management.
12. The system of claim 6 wherein said node calculator is implemented on a CPU.
A system for distributed computing involves a network of nodes that perform computational tasks. Each node includes a node calculator that processes data and communicates with other nodes to coordinate computations. The system addresses inefficiencies in distributed computing by optimizing task allocation and reducing communication overhead. The node calculator, implemented on a central processing unit (CPU), executes algorithms to manage workload distribution, monitor performance, and ensure data consistency across the network. It handles task scheduling, resource allocation, and error detection to improve computational efficiency. The system may also include a network interface for inter-node communication and a memory module for storing intermediate results. The CPU-based implementation ensures high-speed processing and compatibility with existing hardware infrastructure. This approach enhances scalability and reliability in distributed computing environments, making it suitable for applications requiring parallel processing, such as scientific simulations, big data analytics, and machine learning. The system dynamically adjusts task priorities and resource usage based on real-time performance metrics, further optimizing computational performance.
14. The method of claim 13 wherein said storing comprises storing said plurality of leaf hash values in columns of said flat associative memory.
This invention relates to data storage and retrieval systems, specifically addressing the challenge of efficiently storing and accessing large datasets in a flat associative memory structure. The method involves storing a plurality of leaf hash values in columns of a flat associative memory. The flat associative memory is a high-speed, content-addressable memory that allows for rapid data retrieval based on content rather than location. The leaf hash values are derived from a hierarchical hash structure, where data is broken down into smaller, more manageable components, each associated with a unique hash value. By storing these leaf hash values in columns of the flat associative memory, the system enables fast and parallel access to the data, improving retrieval efficiency. The method ensures that the associative memory can handle large datasets by distributing the hash values across multiple columns, optimizing memory usage and access speed. This approach is particularly useful in applications requiring real-time data processing, such as database systems, network security, and machine learning, where quick access to stored data is critical. The invention enhances the performance of associative memory systems by leveraging hierarchical hashing and efficient column-based storage.
15. The method of claim 13 wherein said extracting and said determining comprise extracting and determining from a top root node down to a set of leaves.
A method for processing hierarchical data structures, such as trees or graphs, addresses the challenge of efficiently analyzing and extracting information from nested or interconnected data. The method involves traversing a hierarchical structure from a top root node downward to a set of leaf nodes, systematically extracting relevant data at each level. This traversal ensures comprehensive coverage of the structure, allowing for accurate determination of relationships, properties, or values within the data. The extraction and determination steps are performed in a top-down manner, starting from the root and proceeding through intermediate nodes until reaching the leaves. This approach is particularly useful in applications requiring structured data analysis, such as parsing syntax trees in programming, analyzing organizational hierarchies, or processing decision trees in machine learning. By systematically processing the hierarchy from the top down, the method ensures that all relevant data is captured and analyzed in a consistent and efficient manner.
16. The method of claim 13 wherein said extracting comprises extracting from a most significant byte to a least significant byte of said plurality of leaf hash values.
A method for processing data in a cryptographic system involves extracting hash values from a data structure, such as a Merkle tree, where the extraction is performed sequentially from the most significant byte to the least significant byte of each leaf hash value. This approach ensures that the extraction process follows a consistent and predictable order, which is critical for maintaining data integrity and security in cryptographic operations. The method may be part of a broader system for verifying or validating data by comparing extracted hash values against expected values. By processing the bytes in a fixed order, the method reduces the risk of errors and ensures compatibility with standard cryptographic protocols. The extraction process may be applied in various applications, including blockchain transactions, digital signatures, and secure data storage, where accurate and reliable hash value retrieval is essential. The method improves efficiency and reliability in cryptographic operations by standardizing the extraction sequence, making it suitable for high-security environments where data integrity is paramount.
17. The method of claim 13 wherein said extracting comprises finding common prefixes between said plurality of leaf hash values.
A method for optimizing data storage and retrieval in a distributed system, particularly in blockchain or distributed ledger technologies, addresses the inefficiency of storing and verifying large datasets by leveraging hash-based indexing. The method involves generating a plurality of leaf hash values from data entries, where each leaf hash value corresponds to a unique data entry. To reduce storage overhead and improve retrieval efficiency, the method extracts common prefixes from these leaf hash values. By identifying and storing only the unique portions of the hash values, the system minimizes redundant data storage while maintaining the ability to reconstruct the full hash values when needed. This approach is particularly useful in environments where data integrity and quick verification are critical, such as in cryptographic proof systems or distributed consensus mechanisms. The method ensures that the original data can be accurately verified without storing the entire hash values, thus optimizing both storage space and computational resources. The extraction of common prefixes is performed through a systematic comparison of the hash values, allowing the system to dynamically adapt to changes in the dataset while maintaining efficiency. This technique is applicable in various distributed systems where hash-based indexing is employed for data management and verification.
18. The method of claim 13 and also comprising calculating branch node hash values, and said root hash value according to said branch node relationships.
A system and method for generating and verifying a hierarchical data structure, such as a Merkle tree, to ensure data integrity and authenticity. The invention addresses the need for efficient and secure verification of large datasets by organizing data into a tree-like structure where each non-leaf node is a hash of its child nodes. The method involves calculating hash values for branch nodes based on their child nodes and computing a root hash value that represents the entire dataset. This root hash can be used to verify the integrity of any subset of the data by comparing derived hashes against the root hash. The system may also include mechanisms for updating the tree structure when new data is added or modified, ensuring the root hash remains consistent with the current state of the data. The invention is particularly useful in applications requiring tamper-proof data verification, such as blockchain systems, distributed ledgers, and secure data storage. The method ensures that any alteration in the data will result in a different root hash, making unauthorized modifications detectable. The system may also include optimizations for performance, such as parallel hash calculations or incremental updates, to handle large-scale datasets efficiently.
19. The method of claim 18 wherein said saving comprises saving to at least one flat node table.
A system and method for data storage and retrieval involves organizing data into a hierarchical structure of nodes, where each node can contain child nodes, forming a tree-like arrangement. The method addresses the challenge of efficiently storing and querying hierarchical data, particularly in database systems, by optimizing the way relationships between nodes are managed. The hierarchical structure allows for efficient traversal and retrieval of nested data, which is common in applications like organizational charts, file systems, or taxonomies. The method includes steps for creating, modifying, and querying nodes within this hierarchy. When saving data, the system stores the hierarchical relationships in a flat node table, which simplifies database operations by avoiding complex joins or recursive queries. This approach improves performance by reducing the computational overhead associated with traversing deeply nested structures. The flat node table may include fields such as node identifiers, parent-child relationships, and metadata, allowing for efficient indexing and querying. The method also supports operations like adding new nodes, updating existing nodes, and deleting nodes while maintaining the integrity of the hierarchical structure. Querying the data involves traversing the hierarchy based on the relationships stored in the flat node table, enabling fast access to specific nodes or subtrees. This approach is particularly useful in scenarios where hierarchical data must be frequently accessed or modified, such as in content management systems or database-driven applications. The use of a flat node table ensures that the system remains scalable and performant even as the hierarchy grows in size and complexity.
20. The method of claim 19 and also comprising recording said branch node hash values, and said root hash value to said at least one flat node table.
A method for managing data in a distributed ledger system, particularly for optimizing storage and retrieval of blockchain data, addresses the challenge of efficiently tracking and verifying the integrity of blockchain transactions. The method involves generating a Merkle tree structure from transaction data, where each leaf node represents a transaction hash, and intermediate nodes are computed as hash values of their child nodes. The root hash of the Merkle tree serves as a compact representation of all transactions in a block. The method further includes recording branch node hash values and the root hash in at least one flat node table, which is a simplified data structure that stores these values in a non-hierarchical format. This allows for efficient querying and verification of transaction integrity without requiring the full Merkle tree structure. The flat node table enables faster access to transaction data and reduces computational overhead when verifying transactions, as it eliminates the need to reconstruct the entire Merkle tree. The method ensures data consistency and integrity by maintaining a verifiable link between transactions and their corresponding hash values in the flat node table. This approach is particularly useful in blockchain systems where scalability and performance are critical, as it reduces storage requirements and speeds up transaction verification processes.
21. The method of claim 20 and also comprising recalculating a new root hash value using at least one newly calculated branch node hash value and said branch node hash values stored in said at least one flat node table.
A method for updating a data structure, such as a Merkle tree, involves recalculating a root hash value after changes to the tree. The method includes storing branch node hash values in at least one flat node table, which allows efficient access and modification. When a new branch node hash value is calculated, the method recalculates the root hash value by incorporating the newly calculated hash value along with the existing branch node hash values stored in the flat node table. This approach ensures data integrity and consistency in distributed systems or blockchain applications where hash-based verification is critical. The recalculation process optimizes performance by leveraging precomputed hash values stored in the flat node table, reducing redundant computations. The method is particularly useful in scenarios requiring frequent updates to the data structure while maintaining cryptographic security. The flat node table structure simplifies the management of intermediate hash values, enabling efficient traversal and verification of the tree's integrity. This technique is applicable in various domains, including blockchain, distributed ledgers, and secure data storage systems.
Cooperative Patent Classification codes for this invention. Click any code to explore related patents in that topic.
February 7, 2022
May 21, 2024
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.