Enhanced distributed zero knowledge proof generation

Abstract

Zero knowledge proof (ZKP) generation may be managed and performed in an enhanced manner. An attestation manager may decompose a directed acyclic graph (DAG) representing a data analysis workflow into respective sub-DAGs representing respective workflow portions. Based on the respective sub-DAG, the attestation manager may determine a respective sub-ZKP associated with the respective workflow portion and the sub-DAG. Respective servers may be used to simultaneously determine respective sub-ZKPs. The attestation manager may hash the respective input and output values of the respective sub-DAGs and include the respective hashed values in the respective sub-ZKPs. Based on linking the respective sub-ZKPs having the respective hash values satisfying the prescribed matching criteria, the attestation manager may determine and generate ZKPs related to the workflow that include calculation results. The attestation manager may communicate the ZKP to a verifier in order to verify correctness of the ZKP including the calculation results. The attestation manager may store the sub-ZKP and reuse the stored sub-ZKP related to the computation of the sub-DAG of another workflow.

Description

[0001] Cross-references to related applications

[0002] This patent application claims priority to U.S. Provisional Patent Application No. 63 / 714,884, filed November 1, 2024, entitled “A New Approach for Distributed Zero-Knowledge Proof Generation for DataAnalytics Workflow,” the entire contents of which are incorporated herein by reference. Background Technology

[0003] Various cryptographic tools can be used to protect data. For example, zero-knowledge proofs can be a cryptographic tool that allows a prover to convince a verifier of the correctness of a computation without revealing the underlying data used in performing the computation and generating the zero-knowledge proof.

[0004] The above description is intended to provide a contextual overview of cryptographic tools and proofs only, and is not intended to be exhaustive. Summary of the Invention

[0005] The following is a simplified summary of the invention to provide a basic understanding of some of the aspects described herein. This summary is not an exhaustive overview of the disclosed subject matter. It is not intended to identify key or essential elements of this disclosure, nor is it intended to describe its scope. Its sole purpose is to present some concepts in a simplified form as an introduction to the more detailed description that follows.

[0006] In some embodiments, the disclosed subject matter may include a method that may include: decomposing a graph representing a workflow into corresponding subgraphs representing corresponding parts of the workflow by a system including at least one processor. The method may further include: determining, based on the corresponding subgraphs, corresponding subproofs relating to the corresponding parts of the workflow and the corresponding subgraphs. The method may further include: generating proofs relating to the workflow based on the corresponding subproofs.

[0007] In some embodiments, the disclosed subject matter may include a system that may include at least one memory for storing computer-executable components and at least one processor for executing the computer-executable components stored in the at least one memory. The computer-executable components may include a decomposer that can decompose a graph representing a workflow into corresponding subgraphs associated with corresponding parts of the workflow. The computer-executable components may also include a proof generator that can determine corresponding sub-proofs associated with corresponding parts of the workflow and corresponding subgraphs based on the corresponding subgraphs, in order to generate proofs related to the workflow.

[0008] In other embodiments, the disclosed subject matter may include a non-transitory machine-readable medium comprising executable instructions that, when executed by at least one processor, facilitate the execution of operations. The operations may include: segmenting a directed acyclic graph representing a workflow into corresponding directed acyclic subgraphs relating to corresponding portions of the workflow. The operations may further include: generating corresponding sub-proofs relating to the corresponding portions of the workflow and the corresponding directed acyclic subgraphs based on the corresponding directed acyclic subgraphs. The operations may further include: generating proofs relating to the workflow based on the corresponding sub-proofs.

[0009] The following description and accompanying drawings illustrate certain illustrative aspects of this disclosure in detail. However, these aspects merely indicate a few of the various ways in which the principles of the disclosed aspects may be employed, and this disclosure is intended to include all such aspects and their equivalents. Other advantages and features will become apparent from the following detailed description when considered in conjunction with the accompanying drawings. Attached Figure Description

[0010] Figure 1 A block diagram of a non-limiting example system is shown, which is generated from proofs of the expected execution and management of datasets based on various aspects and embodiments of the disclosed subject matter.

[0011] Figure 2 A block diagram of a non-limiting exemplary proof manager component is shown, which is intended to perform and manage proof generation (including proof generation for large-scale datasets and distributed proof generation) according to various aspects and embodiments of the disclosed subject matter.

[0012] Figure 3 A schematic diagram of a non-limiting exemplary proof generation process according to various aspects and embodiments of the disclosed subject matter is shown, which may include: decomposing a workflow-related graph into subgraphs, generating subproofs at least in part based on the subgraphs, and generating a workflow-related proof at least in part based on the subproofs.

[0013] Figure 4 A block diagram is shown illustrating a non-limiting example of two sub-proofs linked to each other based on various aspects and embodiments of the disclosed subject matter.

[0014] Figure 5 A block diagram of a non-limiting example validator manager component is shown, which is intended to validate proofs associated with a dataset received from a proof manager component (e.g., a proof manager component) according to various aspects and embodiments of the disclosed subject matter.

[0015] Figure 6A block diagram of a non-limiting example system based on various aspects and embodiments of the disclosed subject matter is shown, which is expected to perform and manage proof generation of a dataset, including performing and managing distributed sub-proof generation to facilitate proof generation.

[0016] Figure 7 A block diagram of a non-limiting example subproof reuse flow based on various aspects and embodiments of the disclosed subject matter is shown, which can be executed to reuse previously generated subproofs with respect to subsequent subgraphs of subsequent datasets.

[0017] Figure 8 A flowchart illustrating an example method for generating proofs of the expected execution and management of workflows based on various aspects and embodiments of the disclosed subject matter is shown.

[0018] Figure 9 A flowchart is shown of another example method based on various aspects and embodiments of the disclosed subject matter, which is expected to perform and manage the proof generation of a workflow.

[0019] Figure 10 A flowchart is shown of an example method based on various aspects and embodiments of the disclosed subject matter, which desirably reuses previously generated sub-proofs associated with previously processed workflows in place of generating new sub-proofs related to processing subsequent workflows.

[0020] Figure 11 An example block diagram is shown that illustrates an example computing environment that can implement the various embodiments described herein. Detailed Implementation

[0021] Various aspects of the disclosed subject matter will now be described with reference to the accompanying drawings, wherein the same reference numerals are consistently used to refer to the same elements. In the following description, numerous specific details are set forth for illustrative purposes to provide a thorough understanding of one or more aspects. However, it will be apparent that these aspects(s) can be practiced without these specific details. In other instances, well-known structures and apparatuses are shown in block diagram form to describe one or more aspects.

[0022] This disclosure generally relates to systems, mechanisms, methods, and techniques for managing and generating zero-knowledge proofs (ZKPs), including ZKPs for data analysis workflows, in a desired (e.g., appropriate, accurate, rapid, efficient, reliable, enhanced, or optimal) manner. Various cryptographic tools can be used to protect the data. For example, a ZKP can be a cryptographic tool that allows the prover to assure the verifier of the correctness of the computation without revealing the underlying data used in performing the computation and generating the ZKP.

[0023] There are existing ZKP systems that can involve creating a single ZKP that can contain an entire computation. For example, such an existing ZKP system can focus on performing general computation to create a single ZKP that can contain an entire computation, which can be a monolithic computation.

[0024] However, this approach of creating a single ZKP encompassing the entire computation from existing ZKP systems can often be flawed, infeasible, inefficient, and / or undesirable for data analytics workflows, especially given the significant computational resources available for processing large datasets to generate ZKPs. For example, data analytics workflows can often be modeled as directed acyclic graphs (DAGs), where nodes represent individual computational steps and edges represent data dependencies between these steps. Generating a single ZKP for complex data analytics workflows (such as complex DAG-based workflows) using existing ZKP techniques is often computationally prohibitive, particularly for large-scale data analytics tasks.

[0025] It is expected (e.g., appropriate, beneficial, advantageous, desirable, useful, improved, or optimal) that ZKP generation systems, methods, and techniques can address the challenges of generating ZKPs for data analysis workflows and can generate ZKPs for data analysis workflows quickly, efficiently, and accurately. To this end, a system, method, and technique are proposed that can expectably (e.g., automatically, dynamically, appropriately, reliably, efficiently, enhanced, and / or optimally) address the challenges of generating ZKPs for data analysis workflows and can generate ZKPs for data analysis workflows quickly, efficiently, and accurately. According to various embodiments, the system may include a proof manager component that can expectably manage and execute the generation of proofs (e.g., ZKPs) for workflows (e.g., data analysis workflows, other types of workflows, or other types of datasets).

[0026] In some embodiments, based at least in part on the analysis results of a graph (e.g., a DAG), including computational tasks or operations associated with the graph, the proof manager component can decompose a graph representing a workflow (e.g., a data analysis workflow, other types of workflows, or other types of datasets) into corresponding subgraphs representing the respective parts of the workflow. In some embodiments, based at least in part on the corresponding subgraphs, the proof manager component can determine corresponding subproofs associated with the corresponding workflow parts and the corresponding subgraphs (e.g., and the corresponding computational tasks). In some embodiments, corresponding servers (e.g., in a distributed manner) can be used to simultaneously determine and generate the corresponding subproofs, which can allow for parallel processing and efficient utilization of computational resources. In some embodiments, the proof manager component can hash the corresponding input and output values ​​of the corresponding subgraphs to generate corresponding hashed input and output values ​​for the corresponding subgraphs, and can include the corresponding hashed input and output values ​​in the corresponding subproofs associated with the corresponding subgraphs. The corresponding hash input and output values ​​in the corresponding sub-proof can be used to guarantee the integrity of the data flow between the corresponding subgraphs (and corresponding sub-proofs).

[0027] In some embodiments, the proof manager component may link specific corresponding subproofs to each other, at least in part, based on determining that the corresponding hash input values ​​or corresponding hash output values ​​of specific corresponding subproofs satisfy a prescribed matching criterion. For example, the proof manager component may determine that the hash output value of a first subproof and the hash input value of a second subproof satisfy a prescribed matching criterion (e.g., it may determine that the hash output value of the first subproof and the hash input value of the second subproof match each other, or at least substantially or sufficiently match each other). Based at least in part on determining that the hash output value of the first subproof and the hash input value of the second subproof satisfy the prescribed matching criterion, the proof manager component may determine that the output of the first subproof can be linked to the input of the second subproof. For example, the proof manager component may link specific corresponding subproofs to each other by ensuring that matching the hash input values ​​and hash output values ​​of the respective subproofs is consistent across the entire graph (e.g., a computed DAG).

[0028] Based at least in part on the linking of specific corresponding sub-proofs having corresponding hash input or hash output values ​​that satisfy specified matching criteria, a proof manager component can aggregate corresponding sub-proofs to generate a workflow-related proof (e.g., ZKP), where the proof may include computation results that can be derived from or obtained from the aggregation of corresponding computational results of the corresponding sub-proofs. For example, based at least in part on the linking, the proof manager component can aggregate corresponding sub-proofs to generate a proof that can represent the correctness of the entire workflow, where the proof manager component can perform the aggregation of corresponding sub-proofs by verifying the consistency of hash commitments between the corresponding sub-proofs.

[0029] In some embodiments, the proof manager component may pass proofs to a verifier (e.g., a verifier component or verifier device) so that the verifier can verify the correctness of the proofs, including verifying the computational results of the proofs. For example, the proof may enable the proof manager component to assure the verifier of the correctness (e.g., accuracy) of the computations of proofs (and graphs) related to the workflow without revealing the underlying data of the workflow used to perform the computations, determine, and generate the proofs.

[0030] In some embodiments, the proof manager component may store corresponding sub-proofs in a data store (e.g., a cache memory or other data store) and reuse corresponding stored sub-proofs that may be associated with corresponding computations of corresponding subgraphs of a corresponding subgraph of another workflow(s). For example, when another (e.g., a new) workflow is initiated, the proof manager component may analyze the computational tasks of the graph representing the other workflow (e.g., corresponding computational tasks of corresponding subgraphs of the graph derived by decomposing the graph) and may analyze (e.g., examine) the corresponding computational tasks associated with the corresponding stored sub-proofs stored in the data store. If the proof manager component determines that the computational tasks associated with the stored sub-proofs satisfy a similarity criterion (e.g., identical or substantially similar) with respect to the computational tasks of a subgraph representing a part of another workflow, the proof manager component may determine that the stored sub-proofs can be reused as sub-proofs with respect to the subgraph associated with the other workflow (e.g., instead of utilizing computational resources to determine and generate new sub-proofs for the subgraph). By employing such a proof reuse mechanism, the proof manager component can thus allow the system to fully utilize previously generated sub-proofs from the data store when encountering the same or similar computational tasks in subsequent workflows (e.g., data analysis workflows or other types of workflows or datasets). By storing sub-proofs in the data store and reusing them when desired, the proof manager component can significantly reduce the amount of time spent generating new proofs, especially for recurring computations common in large-scale data analysis. The reuse (e.g., direct reuse) of stored sub-proofs associated with computational tasks that are identical (e.g., matching) to the computational tasks of newly initiated workflows can hopefully avoid redundant computations and improve the overall efficiency of proof generation for newly initiated workflows and the overall efficiency of the system.

[0031] Compared to existing systems, methods, and techniques for proof generation, the disclosed subject matter, by employing the proof manager components and enhancement techniques (e.g., enhanced proof generation techniques) described herein, can desirably (e.g., automatically, dynamically, appropriately, reliably, efficiently, enhancedly, and / or optimally) distribute multiple parts of the workflow for processing across multiple servers, reducing the amount of time spent processing datasets, reducing and / or avoiding redundant computations during the determination and generation of sub-proofs and proofs, improving the efficiency of determining and generating proofs, and improving the overall performance of the proof generation system. The disclosed subject matter, by employing the proof manager components and enhancement techniques (e.g., enhanced proof generation techniques) described herein (including enhancements for decomposing a graph representing the workflow (e.g., a computational DAG) into smaller corresponding subgraphs to facilitate the generation of corresponding sub-proofs), can desirably (e.g., automatically, dynamically, appropriately, reliably, efficiently, enhancedly, and / or optimally) make the entire proof generation process significantly more scalable because each sub-proof can be generated independently, thereby reducing the computational load on individual servers.

[0032] The disclosed subject matter can be parallelized by employing the proof manager components and enhancement techniques (e.g., enhanced proof generation techniques) described herein, because decomposing the graph into subgraphs enables parallel proof generation (e.g., sub-proof generation) across multiple servers, which allows for efficient utilization of distributed computing resources. This can be particularly beneficial for large-scale data analytics workflows, where different parts of the graph (e.g., subgraphs) can be processed in parallel (e.g., concurrently or simultaneously).

[0033] The disclosed subject matter, by employing the proof manager components and enhancement techniques (e.g., enhanced proof generation techniques) described herein, enables the desired modularity in the proof generation process. This is because the proof manager components and enhancement techniques provide a modular framework for proof generation, allowing for efficient updates (e.g., incremental or other updates) and modifications to individual sub-proofs without having to regenerate the entire proof or sub-proof. This modularity also facilitates enhanced (e.g., improved, better, or optimal) error handling and debugging regarding proof generation.

[0034] These and other aspects and embodiments of the disclosed subject matter will now be described with reference to the accompanying drawings.

[0035] Now refer to the attached diagram, Figure 1A block diagram of a non-limiting example system 100, based on various aspects and embodiments of the disclosed subject matter, is shown. This system is expected to (e.g., automatically, dynamically, appropriately, efficiently, reliably, enhancedly, and / or optimally) perform and manage proof generation for datasets (e.g., data analysis workflows or other types of workflows or datasets). In some embodiments, system 100 may include a proof manager component 102, which is expected to perform and manage proof (e.g., ZKP) generation, including proof generation for larger datasets (e.g., data analysis workflows) and distributed proof generation.

[0036] According to various embodiments, the proof manager component 102 may be part of or associated with one or more devices (e.g., one or more servers) as described herein (e.g., communicatively connected to the one or more devices). In some embodiments, the proof manager component 102 may be derived from one or more devices ( Figure 1 (Not shown) receives data for processing (e.g., data analysis workflows or other types of workflows or datasets). In some embodiments, the proof manager component 102 may be associated with (e.g., communicatively connected to) a device 104 (e.g., a verifier device), which may receive one or more proofs generated by the proof manager component 102 for verification and to obtain computational results, as described herein. In some embodiments, the device 104 may include a verifier manager component 106 capable of verifying proofs, including computational results, relating to datasets that may be received from the proof manager component 102. It should be understood and appreciated that, for the sake of brevity and clarity, Figure 1 Only one device 104 (e.g., a validator device) is shown; however, at various times, the proof manager component 102 can actually be associated with any desired number of validator devices that can receive proofs from the proof manager component 102 for verification and to obtain computation results. It should also be understood and appreciated that while the various embodiments of the disclosed subject matter described herein relate to data analysis workflows, the techniques and embodiments of the disclosed subject matter related to proof generation can be utilized or applied to virtually any type of dataset or workflow, including relatively large or relatively small datasets or workflows.

[0037] According to various embodiments, the device (e.g., one or more devices including or associated with the proof manager component 102, device 104, or other devices) may be a computer, laptop computer, server, wireless, mobile, or smartphone, tablet or VA device, electronic glasses, electronic watch or other electronic clothing, video game device, Internet of Things (IoT) device (e.g., health monitoring device, toaster, coffee maker, blind, music player, speaker, telemetry device, smart meter, machine-to-machine (M2M) device, or other type of IoT device), connected vehicle device (e.g., car, airplane, train, rocket, and / or other at least partially automated vehicle (e.g., drone)), personal digital assistant (PDA), radar detector (e.g., Universal Serial Bus (USB) or other type of radar detector), communication device, or other type of device. In some embodiments, the non-limiting term "user equipment (UE)" may be used to describe the device.

[0038] refer to Figure 2 (together) Figure 1 ), Figure 2 A block diagram of a non-limiting example proof manager component 102, according to various aspects and embodiments of the disclosed subject matter, is shown. This component is intended to perform and manage proof (e.g., ZKP) generation, including proof generation for large-scale datasets (e.g., data analytics workflows) and distributed proof generation, in a manner that is desirously (e.g., automatically, dynamically, appropriately, reliably, efficiently, enhancedly, and / or optimally). According to various embodiments, proof manager component 102 may include a proof key component 202, a graph generator component 204, a decomposer component 206, a proof generator component 208, a hasher component 210, a linker and aggregator component 212, and a sub-proof manager component 214. In some embodiments, proof manager component 102 may include (as shown) a processor component 216 and a data storage unit 218, or be associated with (e.g., communicatively connected to) the processor component 216 and the data storage unit 218. In some embodiments, the proof manager component 102 may store proofs 220 and sub-proofs 222 related to the dataset, as well as other necessary data, in a data storage unit 218, as described herein. According to various embodiments, the proof manager component 102 may include or be associated with an artificial intelligence (AI) component 224, which may include a trainer component 226 and one or more models 228 (e.g., AI-based models).

[0039] In some embodiments, the proof manager component 102 may receive a dataset from another device or retrieve a dataset (e.g., a previously received and stored dataset) from the data storage unit 218. The dataset may be a data analysis workflow or other types of workflows or datasets. In some embodiments, the graph generator component 204 may determine and generate a graph (e.g., a DAG or other desired type of graph) that can represent the dataset, at least in part, based on the results of analyzing data in the dataset. In some embodiments, the graph may include groups of nodes, where corresponding nodes may be associated (e.g., connected to) corresponding other nodes in the node group via corresponding edges (e.g., connectors), where the corresponding edges may have corresponding data dependencies, in part depending on the dataset. For example, a first node may have an edge associated with its output, and the other end of the edge may be associated with the input of a second node, where data output from the first node may be transmitted to the input of the second node via the edge. Each node in the node group can represent or be associated with a computational task or operation, wherein the aforementioned computational tasks or operations can be performed (e.g., by the proof manager component 102) on various portions of the dataset and / or on data generated by other nodes in the node group within the graph, to determine and generate a proof including the computational results based at least in part on the results of analyzing the dataset.

[0040] refer to Figure 3 (together) Figure 1 and Figure 2 ), Figure 3A schematic diagram of a non-limiting exemplary proof generation process 300 according to various aspects and embodiments of the disclosed subject matter is shown. This process may include: decomposing a workflow-related graph into subgraphs, generating subproofs at least partially based on the subgraphs, and generating a workflow-related proof at least partially based on the subproofs. According to various embodiments, a graph generator component 204 may determine and generate a graph 302 (e.g., a DAG or other desired type of graph) that may represent a workflow (e.g., a data analysis workflow or other types of workflows) or be related to a workflow, at least partially based on the analysis results of workflow data. Graph 302 may include a node group 304 and an edge group 306, wherein corresponding edges in edge group 306 may connect a corresponding output of a corresponding node in node group 304 to a corresponding input of another corresponding node in node group 304. Partly depending on the workflow, the corresponding edges may have corresponding data dependencies between the corresponding node and the corresponding computational task associated with the corresponding node. For example, data expected or desired at the input of a second node may depend in part on data output from a first node, wherein the edge between the output of the first node and the input of the second node may include such a data dependency. Each node in node group 304 may represent or be associated with a computational task or operation, wherein the aforementioned computational tasks or operations may be performed (e.g., by the proof manager component 102) on various parts of the workflow and / or on data generated by other nodes in node group 304 within FIG302, to determine and generate proofs (e.g., ZKP) related to the data flow, including the computational results, based at least in part on the analysis results of the workflow.

[0041] In some embodiments, the decomposer component 206 may perform a graph decomposition process 308 to decompose (e.g., segment, divide, partition, or separate) graph 302 into a group of subgraphs 310 comprising subgraphs 312, 314, and 316, at least in part based on the analysis results of graph 302 and / or workflow. The decomposer component 206 may decompose graph 302 into corresponding subgraphs (e.g., 312, 314, 316) within the group of subgraphs 310, such that each of the corresponding subgraphs (e.g., 312, 314, 316) may include, relate to, or represent one or more corresponding portions of a workflow, including one or more corresponding computational tasks relating to the workflow. In some embodiments, each of the corresponding subgraphs (e.g., 312, 314, 316) in subgraph group 310 may include a corresponding subgroup of nodes (SGN), which may include subgroup of nodes 318 of subgraph 312, subgroup of nodes 320 of subgraph 314, and subgroup of nodes 322 of subgraph 316, wherein each of the corresponding subgroup of nodes (e.g., 318, 320, 322) may include one or more corresponding nodes, which may be associated with or represent one or more corresponding computational tasks at least in part based on (e.g., according to) a workflow. In some embodiments, there may be edges including edges 324, 326, and 328, which may be associated (e.g., connected to the corresponding subgraph) and located between the corresponding subgraphs (e.g., 312, 314, 316), and thus may be associated with the corresponding node subgroups (e.g., 318, 320, 322), wherein the corresponding edges (e.g., 324, 326, 328) may have corresponding data dependencies, as described herein. It should be understood and appreciated that the number of subgraphs generated from the decomposition of the workflow-related graph, the number of edges between subgraphs, the arrangement of the subgraphs, and the arrangement of edges relative to the subgraphs may vary depending on the graph and / or workflow, and may be at least partially based on the graph and / or workflow. It should also be understood and appreciated that the edges (e.g., 324, 326, 328) shown with respect to subgraph group 310 are merely non-limiting examples of edges, and the arrangement of edges may vary. Figure 3 The differences shown here depend in part on the workflow. For example, depending in part on the workflow, instead of an edge 324 between the output of subgraph 312 and the input of subgraph 314, there may be an edge between the output of subgraph 312 and another input of another subgraph in subgraph group 310, in addition to an edge 324 between the output of subgraph 312 and the input of subgraph 314.

[0042] In some embodiments, the proof generator component 208 may perform a sub-proof generation process 330, wherein the proof generator component 208 may determine and generate, or may facilitate the determination and generation of, corresponding sub-proofs (e.g., corresponding zero-knowledge sub-proofs) based at least in part on corresponding subgraphs (e.g., 312, 314, 316) in subgraph group 310, which include sub-proofs 332, 334, and 336. For example, the proof generator component 208 may determine and generate, or may facilitate the determination and generation of a sub-proof 332 including a sub-result 338 (e.g., computational sub-result) based at least in part on subgraph 312 and / or cryptographic keys (e.g., private and / or secure encryption keys) of proof key component 202, wherein the proof generator component 208 may use a portion of the data associated with the workflow (e.g., by analyzing and performing computational operations on a portion of the data associated with the workflow) to perform one or more computational tasks within subgraph 312 to determine and generate sub-result 338. In some embodiments, the cryptographic key of the proof key component 202 may be used to cryptographically protect sub-result 338 (e.g., encrypt sub-result 338). In other embodiments, after the proof generator component 208 has determined and generated a proof at least in part based on the corresponding sub-proofs (e.g., 332, 334, 336), the proof manager component 102 may use the cryptographic key of the proof key component 202 to cryptographically protect (e.g., encrypt) the final computation result of the proof. In some embodiments, the proof key component 202 may determine, generate, utilize, and / or provide different cryptographic keys for determining and generating different proofs for different datasets (e.g., data analysis workflows or other datasets). In some embodiments, similar to the determination and generation of sub-proof 332, proof generator component 208 may determine and generate, or facilitate the determination and generation of, other corresponding sub-proofs (e.g., 334, 336) including other corresponding sub-results (e.g., 340, 342) based at least in part on other corresponding subgraphs (e.g., 314, 316) and / or cryptographic keys. Proof generator component 208 (or one or more other proof generator components associated with another server) may use other corresponding portions of the data associated with the workflow (e.g., by analyzing and performing corresponding computational operations on other corresponding portions of the data associated with the workflow) to perform one or more corresponding computational tasks within other corresponding sub-proofs (e.g., 314, 316) to determine and generate other corresponding sub-results (e.g., 340, 342). The corresponding sub-proofs (e.g., 332, 334, 336) capture and / or represent the correctness (e.g., accuracy) of the corresponding computations performed by the proof generator component 208 within the corresponding subgraphs (e.g., 312, 314, 316) of the subgraph group 310.

[0043] According to various embodiments, one or more servers (e.g., employing one or more corresponding proof manager components) may determine and generate corresponding sub-proofs (e.g., 332, 334, 336) including corresponding sub-results (e.g., 338, 340, 342) based at least in part on corresponding subgraphs (e.g., 312, 314, 316), workflow data or workflow-related data (e.g., data derived from, calculated or obtained from, or connected to the workflow), and / or cryptographic keys. For example, a first server (e.g., employing proof manager component 102) may determine and generate subproof 332 based at least in part on a first portion of the data of subgraph 312 and the workflow, or a first portion of the data associated with the workflow; a second server (e.g., employing another proof manager component) may determine and generate subproof 334 based at least in part on a second portion of the data of subgraph 314 and the workflow, or a second portion of the data associated with the workflow; and / or another server (e.g., employing yet another proof manager component) may determine and generate subproof 336 in parallel (e.g., concurrently, simultaneously, or substantially simultaneously, in a distributed manner) based at least in part on another portion of the data of subgraph 316 and the workflow, or another portion of the data associated with the workflow, as described herein.

[0044] Based at least in part (e.g., according to) the corresponding data dependencies and corresponding sub-results (e.g., 338, 340, 342) associated with the corresponding sub-proofs (e.g., 332, 334, 336), the corresponding sub-proofs (e.g., 332, 334, 336) may have corresponding input values ​​and corresponding output values. In some embodiments, the hasher component 210 may hash the corresponding input values ​​and corresponding output values ​​of the corresponding sub-proofs (e.g., 332, 334, 336) based at least in part (e.g., using and according to) a desired hashing algorithm or technique and / or the cryptographic key (e.g., a private encryption key) of the proof key component 202, to determine and generate the corresponding hash input values ​​and corresponding hash output values ​​of the corresponding sub-proofs (e.g., 332, 334, 336). For example, hasher component 210 may, at least in part, hash one or more first input values ​​and one or more first output values ​​of a first sub-proof (e.g., 332) to determine and generate one or more first hash input values ​​and one or more first hash output values ​​of the first sub-proof, based on a desired hashing algorithm or technique and / or cryptographic key; hash one or more second input values ​​and one or more second output values ​​of a second sub-proof (e.g., 334) to determine and generate one or more second hash input values ​​and one or more second hash output values ​​of the second sub-proof; and / or hash one or more other input values ​​and one or more other output values ​​of another sub-proof (e.g., 336) to determine and generate one or more other hash input values ​​and one or more other hash output values ​​of the other sub-proof.

[0045] In some embodiments, the proof manager component 102 may use the corresponding hash input and output values ​​of the corresponding sub-proofs (e.g., 332, 334, 336) to commit to the integrity of the data flow between the corresponding subgraphs (e.g., 312, 314, 316) associated with the corresponding sub-proofs (e.g., 332, 334, 336) in order to ensure and / or maintain the integrity of the entire workflow. For example, the integrity of the entire workflow can be ensured and maintained by committing to the corresponding hash input and output values ​​of the corresponding sub-proofs (e.g., 332, 334, 336) associated with the workflow. Committing the hash input and output values ​​of the sub-proofs may mean: cryptographically binding these hash values ​​to ensure the integrity and verifiability of the data flow between the sub-proofs within the workflow. For example, consider a series of workloads w1, w2, w3, etc., and corresponding sub-proofs p1, p2, p3, etc. in the workflow. In some embodiments, instead of generating full proofs for workloads (e.g., w1, w2, w3, etc.) to ensure the integrity of the entire workflow, the proof manager component 102 can generate corresponding sub-proofs (e.g., p1, p2, p3, etc.) for corresponding parts (e.g., corresponding steps) of the workflow, wherein the overall integrity of the workflow is ensured by binding the hash output value of the output of sub-proof p1 to the hash input value of the input of sub-proof p2 (e.g., linking, joining, or constraining), binding the hash output value of the output of sub-proof p2 to the hash input value of the input of sub-proof p3, etc.

[0046] According to various embodiments, the proof manager component 102 can execute a proof generation process 344 to determine and generate a proof 346 that includes result 348 (e.g., calculation result) based at least in part on corresponding sub-proofs (e.g., 332, 334, 336) that include corresponding sub-results (e.g., 338, 340, 342). In some embodiments, the linker and aggregator component 212 (e.g., in conjunction with the proof generator component 208) may link corresponding sub-proofs (e.g., corresponding sub-proofs 332, 334, and / or 336) to other sub-proofs within the corresponding sub-proofs (e.g., other sub-proofs in corresponding sub-proofs 332, 334, and / or 336), and may aggregate the linked sub-proofs at least in part based on the corresponding hash input and corresponding hash output values ​​of the corresponding sub-proofs (e.g., 332, 334, 336) in relation to the workflow and on a prescribed matching criterion related to the matching of hash values, to determine and generate a proof 346 including a result 348 (e.g., an overall or final computation result). For example, the linker and aggregator component 212 can analyze the corresponding hash input and output values ​​of the respective sub-proofs (e.g., 332, 334, 336), and can, at least in part, determine the corresponding hash output values ​​of certain corresponding sub-proofs (e.g., sub-proof 332) based on the analysis results, which satisfy (e.g., conform to) a matching criterion given the corresponding hash input values ​​of certain other corresponding sub-proofs (e.g., sub-proof 334). In some embodiments of the described system 100, the proof manager component 102 can link the various sub-proofs through a process that may involve matching the hash output value of one sub-proof with the hash input value of another sub-proof relative to the sub-proofs associated with the workflow. This matching mechanism employed by the proof manager component 102 ensures the integrity of the workflow by strengthening the cryptographic binding between successive computation steps (e.g., successive computation operations) of the workflow. In some embodiments, each sub-proof associated with the workflow may correspond to a specific computation or transformation applied to data. When a sub-proof produces output, proof manager component 102 (e.g., employing hasher component 210) hashes the result (e.g., hashes the output value or sub-result) to create a unique, verifiable "fingerprint" (e.g., a unique, verifiable identifier or characteristic) that can be used to identify the result of the sub-proof. If another sub-proof associated with the workflow expects (e.g., wants or requires; and / or wants to utilize) this output data as its input data, that other sub-proof can reference the same hash value. Matching these corresponding hashed output values ​​and hashed input values ​​confirms that the expected and desired data flow is preserved, thereby allowing those sub-proofs to be securely linked.

[0047] As a non-limiting example of using and linking sub-proofs in a data analytics pipeline, consider a data analytics workflow where raw data can first be filtered based on specific conditions to generate a filtered dataset, and the filtered dataset can be used as input to train a machine learning model. This process may include, for example, the following operations or steps:

[0048] Step 1: Data Filtering (Sub-proof 1 (p1))

[0049] a) The dataset containing customer transactions can be filtered to include only purchases of $100 or more, generating a filtered dataset; and

[0050] b) The obtained filtered dataset (D′) can be hashed (e.g., by hasher component 212) to produce a hash (output p1).

[0051] Step 2: Machine learning model training (sub-proof 2(p2))

[0052] a) The filtered dataset (D′) can be used as input to train a customer segmentation model (e.g., a machine learning model related to customer segmentation);

[0053] b) Before using the filtered dataset (D′) as input, the proof manager component 102 can verify that the hash of sub-proof p1 (output p1) matches the expected hash input of sub-proof p2, i.e., the hash (input p2) matches (e.g., satisfies the prescribed matching criteria); and

[0054] c) If (e.g., by the proof manager component 102) it is determined that the hash output (e.g., the filtered dataset), i.e., the hash (output p1) matches the expected hash input of the sub-proof p2, i.e., the hash (input p2), then the proof manager component 102 can confirm that the correct data (e.g., the filtered dataset) is being used to train the client segmentation model, and the output of the sub-proof p1 can be linked to the input of the sub-proof p2.

[0055] In some embodiments, at least in part based on (e.g., because or in response to) the linker and aggregator component 212 determining that the corresponding hash output values ​​of certain corresponding sub-proofs satisfy a specified matching criterion regarding the corresponding hash input values ​​of certain other corresponding sub-proofs, the linker and aggregator component 212 may link the corresponding outputs of certain corresponding sub-proofs to the corresponding inputs of certain other corresponding sub-proofs via corresponding links to aggregate the corresponding sub-proofs (e.g., 332, 334, 336) to generate proof 346, which includes the respective linked and aggregated sub-proofs. For example, by ensuring that the hash input values ​​and hash output values ​​of the corresponding sub-proofs are matched consistently on FIG302 (e.g., the computed DAG), the linker and aggregator component 212 may link the corresponding outputs of certain corresponding sub-proofs to the corresponding inputs of certain other corresponding sub-proofs. In some embodiments, as part of linking and aggregating certain corresponding sub-proofs to certain other corresponding sub-proofs, the linker and aggregator component 212 may check (e.g., evaluate) the consistency of the corresponding hash commitments between certain corresponding sub-proofs and certain other corresponding sub-proofs. In some embodiments, corresponding links between the corresponding outputs of certain corresponding sub-proofs and the corresponding inputs of certain other corresponding sub-proofs enable the corresponding output data (e.g., corresponding computational sub-results) of certain corresponding sub-proofs to flow to (e.g., be passed to) the corresponding inputs of certain other corresponding sub-proofs, so as to generate a proof at least in part based on the corresponding sub-proofs (e.g., 332, 334, 336). Proof 346 may include result 348 (e.g., computational result) and may represent the correctness (e.g., accuracy) of the entire workflow (e.g., as illustrated by FIG. 302).

[0056] Brief reference Figure 4 (together) Figures 1 to 3 ), Figure 4A block diagram illustrating a non-limiting example of two sub-proofs linked together 400 according to various aspects and embodiments of the disclosed subject matter is shown. In some embodiments, sub-proof 332 may have a hash input value (HI / PV) 402 and a hash output value (HO / PV) 404, and sub-proof 334 may have a hash input value 406 and a hash output value 408, wherein the hash output value 404 of sub-proof 332 may match the hash input value 406 of sub-proof 334 (e.g., may be the same as the hash input value 406 of sub-proof 334). In some embodiments (e.g., in the exemplary case), at least in part based on the analysis results of the corresponding hash input values ​​and corresponding hash output values ​​of the respective sub-proofs (e.g., 332, 334, 336), the linker and aggregator component 212 may determine that the hash output value 404 of sub-proof 332 satisfies a specified matching criterion regarding the hash input value 406 of sub-proof 334 (e.g., the hash output value 404 of sub-proof 332 matches the hash input value 406 of sub-proof 334). At least in part based on (e.g., because or in response to) determining that the hash output value 404 of sub-proof 332 satisfies the specified matching criterion regarding the hash input value 406 of sub-proof 334, the linker and aggregator component 212 may link the output (O / P) 410 of sub-proof 332 to the input (I / P) 412 of sub-proof 334 via link 414.

[0057] In some embodiments, the proof manager component 102 may transmit a proof 346 (e.g., a ZKP) including result 348 to device 104 (e.g., a verifier device) for verification and obtain and / or exploit (e.g., further process or otherwise exploit) result 348. Figure 5 (together) Figures 1 to 3 ), Figure 5 A block diagram of a non-limiting example verifier manager component 106, based on various aspects and embodiments of the disclosed subject matter, is shown. This verifier manager component is designed to (e.g., automatically, dynamically, appropriately, efficiently, reliably, enhancedly, and / or optimally) verify proofs relating to datasets (e.g., workflows, such as data analysis workflows) received from a proof manager component (such as proof manager component 102). In some embodiments, verifier manager component 106 may include verifier key component 502 and verifier component 504. In some embodiments, verifier manager component 106 may include processor component 506 and data storage 508, or be associated with processor component 506 and data storage 508.

[0058] In some embodiments, verifier component 504 may verify the correctness of a received proof (e.g., proof 346) at least in part based on the results of the analysis (e.g., evaluation) of the proof, including verifying the result of the proof (e.g., calculation result) (e.g., result 348). In some embodiments, proof 346 including result 348 may be protected (e.g., encrypted using a cryptographic key of proof key component 202 of proof manager component 102). According to such embodiments, verifier component 504 may utilize the cryptographic key of verifier key component 502 (e.g., a decryption key, which may be a public decryption key) to decrypt information (e.g., encrypted information) of proof 346 and facilitate verification of proof 346 including result 348. In some embodiments, the decryption key may correspond to, be consistent with, and / or be determined and generated at least in part based on the encryption key used to determine and generate proof 346 (e.g., the proof key component 202 of proof manager component 102). Based at least in part on the analysis results of proof 346 and / or the decryption of proof 346, verifier component 504 can verify the correctness of proof 346, including verifying the result 348 of proof 346. For example, proof 346 can enable proof manager component 102 to allow verifier component 504 to believe in the correctness (e.g., accuracy) of computation (e.g., underlying computation) and the result 348 of proof 346 in relation to the workflow (e.g., a result accessible to verifier component 504), without disclosing (e.g., by preventing, prohibiting, and / or disallowing disclosure) the underlying data of the workflow (e.g., private, secure, and / or proprietary data) used by proof manager component 102 to perform computations and determine and generate proof 346. That is, by successfully verifying the proof 346 including the result 348, the verifier component 504 can be certain that the proof 346 including the result 348 and the underlying computation are correct, even if the verifier component 504 may not be able to access the underlying data of the workflow to independently verify the proof 346 including the result 348 and the underlying computation using the underlying data of the workflow.

[0059] refer to Figure 6 (together) Figures 1 to 3 ), Figure 6A block diagram of a non-limiting example system 600 according to various aspects and embodiments of the disclosed subject matter is shown, which is expected to (e.g., automatically, dynamically, appropriately, efficiently, reliably, enhancedly, and / or optimally) perform and manage proof generation of datasets (e.g., data analysis workflows or other types of workflows or datasets), including performing and managing distributed sub-proof generation to facilitate proof generation. In some embodiments, system 600 may include a desired number of servers, including server 602, server 604, and / or server 606, which may be associated with each other (e.g., communicatively connected or networked to each other). In some embodiments, each server (e.g., 602, 604, and / or 606) may include a corresponding proof manager component, such as proof manager component 102, proof manager component 608, and / or proof manager component 610, wherein the corresponding proof manager component (e.g., 608 and / or 610) may include the same or similar components as proof manager component 102, and / or may have the same or similar functionality as proof manager component 102, as described herein.

[0060] In some embodiments, the proof manager component 102 (e.g., employing graph generator component 204) may determine and generate a graph 612 (e.g., a DAG or other desired type of graph) representing the dataset, as described herein, based at least in part on the analysis results of data in the dataset (e.g., a data analysis stream or other dataset). In some embodiments, the proof manager component 102 (e.g., employing decomposer component 206) may perform a graph decomposition process (e.g., 308) to decompose graph 612 into a set of subgraphs, which may include subgraphs (SUBG) 614, 616, and / or 618, as described herein. For example, decomposer component 206 may decompose graph 612 into corresponding subgraphs (e.g., 614, 616, and / or 618) in the subgraph set, such that each of the corresponding subgraphs (e.g., 614, 616, and / or 618) may include, relate to, or represent one or more corresponding portions of the dataset, which include one or more corresponding computational tasks related to the dataset.

[0061] In some embodiments, proof manager component 102 (e.g., employing sub-proof manager component 214) may distribute and transmit corresponding subgraphs representing portions of a dataset to other servers for appropriate processing (e.g., parallel, concurrent, or simultaneous processing) of those corresponding subgraphs. For example, proof manager component 102 (e.g., employing sub-proof manager component 214) may distribute and transmit subgraph 616 to server 604, and subgraph 618 to server 606 for appropriate processing.

[0062] In some embodiments, server 602 employs proof manager component 102 (e.g., proof generator component 208) which can perform a subproof generation process (e.g., 330) to determine and generate at least in part based on subgraph 614, or can facilitate the determination and generation of subproofs (SUBP) 620 (e.g., zero-knowledge subproofs) that include sub-results (e.g., computed sub-results), as described herein. In some embodiments, similarly and in parallel (e.g., concurrently), server 604 employs proof manager component 608 (e.g., employing its proof generator component) to perform a sub-proof generation process to determine and generate proofs at least in part based on subgraph 616, or to facilitate the determination and generation of sub-proofs 622 including sub-results (e.g., zero-knowledge sub-proofs), and / or server 606 employs proof manager component 610 (e.g., employing its proof generator component) to perform a sub-proof generation process to determine and generate proofs at least in part based on subgraph 618, or to facilitate the determination and generation of sub-proofs 624 including sub-results (e.g., zero-knowledge sub-proofs), as described herein.

[0063] According to various embodiments (e.g., in parallel, concurrently, or simultaneously), server 602 employs proof manager component 102 (e.g., employing hasher component 210) to hash the input and output values ​​of sub-proof 620, at least in part, based on the sub-results of sub-proof 620 and a desired hashing algorithm or technique, to determine and generate the hashed input and hashed output values ​​of sub-proof 620; server 604 employs proof manager component 608 (e.g., employing its hasher component) to hash the input and output values ​​of sub-proof 620, at least in part, based on the sub-proof 620. The sub-result of 624 and the expected hashing algorithm or technique are used to hash the input and output values ​​of sub-proof 622 to determine and generate the hashed input and hashed output values ​​of sub-proof 622; and / or the server 606 employs proof manager component 610 (e.g., employing its hasher component) to hash the input and output values ​​of sub-proof 624, at least in part, based on the sub-result of sub-proof 624 and the expected hashing algorithm or technique, to determine and generate the hashed input and hashed output values ​​of sub-proof 624, as described herein.

[0064] In some embodiments, server 604 (e.g., employing proof manager component 608) may transmit a subproof 622, including sub-results and / or hash input and hash output values, to server 602; server 606 (e.g., employing proof manager component 610) may transmit a subproof 624, including sub-results and / or hash input and hash output values, to server 602; and / or another server may transmit another subproof, including sub-results and / or hash input and hash output values ​​generated by another server, to server 602. Proof manager component 102 (e.g., employing proof generator component 208 and / or linker and aggregator component 212) may link and aggregate individual subproofs (e.g., 620, 622, 624) to determine and generate a proof 626, including results (e.g., computation results), as described herein, at least in part based on the respective sub-results and respective hash input and output values ​​of the respective subproofs (e.g., 620, 622, 624). Server 602 may transmit proof 626 (e.g., ZKP) including the result to device 104 (e.g., verifier device) for verification and obtain and / or utilize (e.g., further process or otherwise utilize) the result as described herein.

[0065] Further reference Figure 1 and Figure 2 According to various embodiments, the proof manager component 102 employs a subproof manager component 214, which can reuse one or more previously generated subproofs 222 (e.g., previously generated subproofs may be matching or similar subproofs) instead of generating one or more subproofs related to the dataset, in order to facilitate the generation (e.g., efficiently and / or optimally determine and generate) of proofs related to the dataset. In some embodiments, the subproof manager component 214 may include a subproof reuse mechanism that allows the proof manager component 102 to fully utilize previously generated subproofs 222 in a subproof cache from the data storage unit 218 when the computational task of a subgraph of a subsequent dataset (e.g., a subsequent data analysis workflow being processed) is determined to be the same as or similar to the computational task performed in association with the generation of the previously generated subproof 222.

[0066] For example, if it can be assumed that input data can generally remain unchanged across different workflows, this allows and / or enables the proof manager component 102 to decompose workflows and reuse sub-workflows that have the same operations (e.g., the same or identical operational steps) from previous workflows. For example, consider two workflows w1 and w2, where workflow w1 may include sub-proofs p1, p2, and p3:

[0067] w1 = p3(p2(p1(data)))

[0068] w2 = p4(p2(p1(data))).

[0069] When a proof of workflow w2 is generated (which may include sub-proof p4), proof manager component 102 (e.g., employing sub-proof manager component 214) can reuse sub-proofs p1(data) and p2(p1(data)) from workflow w1. In some embodiments, and more generally, proof manager component 102 can represent the workflow as a DAG and can eagerly match shared prefixes to enhance (e.g., maximize or optimize) sub-proof reuse.

[0070] refer to Figure 7 (together) Figure 1 and Figure 2 ), Figure 7 A block diagram of a non-limiting example subproof reuse process 700, based on various aspects and embodiments of the disclosed subject matter, is shown. This process can be executed to reuse previously generated subproofs for subsequent subgraphs of subsequent datasets. In some embodiments, as described herein, proof manager component 102 (e.g., employing subproof manager component 214) may store corresponding previously generated subproofs (e.g., 222) associated with one or more previously generated proofs (e.g., 220), wherein the one or more previously generated proofs (e.g., 220) are associated with one or more previously processed datasets to facilitate the reuse of one or more corresponding previously generated subproofs for subsequent datasets (e.g., subsequent data analysis workflows or other subsequent datasets). The previously generated subproof (e.g., 222) may include, for example, a first subproof 750, which may relate to a first computational task (FIRST COMPTASK) 752 performed within a first subgraph associated with a previous workflow, wherein the first subgraph may represent a portion of the previous workflow (and a portion of the first graph representing the previous workflow).

[0071] In some embodiments, regarding subsequent workflows, proof manager component 102 (e.g., employing sub-proof manager component 214) may determine whether to reuse previously generated and stored sub-proofs instead (e.g., substitute or replace) utilize time and computational resources to perform a second computation task 754 associated with a second subgraph 756, which is associated with a second graph that may represent subsequent workflows (e.g., according to example sub-proof reuse flow 700). The second graph can be obtained by decomposing it into a group of subgraphs that include the second subgraph 756 (e.g., by proof manager component 102), as described herein. In some embodiments, as indicated by reference numeral 702 in the exemplary subproof reuse process 700, in conjunction with processing subsequent workflows, proof manager component 102 (e.g., employing subproof manager component 214) may evaluate (e.g., analyze or examine) the corresponding computational task associated with a corresponding previously generated subproof (e.g., 222) stored in data storage unit 218 and the second computational task 754 associated with a second subgraph 756 associated with a subsequent workflow (e.g., representing a portion of a subsequent workflow) to facilitate determining whether any of the corresponding computational tasks associated with the corresponding previously generated subproof meets the specified similarity criteria for the second computational task 754. For example, subproof manager component 214 may evaluate the relative similarity (if any) between the corresponding computational task associated with the corresponding previously generated subproof (e.g., 222) and the second computational task 754 associated with the second subgraph 756 associated with a subsequent workflow. It should be understood and appreciated that, while in some instances the second computation task 754 may include a single computation task, in other instances the second computation task 754 may include more than one computation task (e.g., a group of computation tasks).

[0072] In some embodiments, as indicated by reference numeral 704 in the exemplary subproof reuse process 700, the proof manager component 102 (e.g., employing subproof manager component 214) may determine, at least in part, based on the results of such evaluation, whether any of the corresponding computational tasks associated with the corresponding previously generated subproof (e.g., 222) meets the similarity criteria (e.g., for reuse) specified with respect to the second computational task 754 associated with the subsequent workflow.

[0073] As indicated by reference numeral 706 in the exemplary subproof reuse process 700, in some embodiments, if, at least in part based on the evaluation results, proof manager component 102 (e.g., employing subproof manager component 214) determines that none of the corresponding computational tasks associated with a corresponding previously generated subproof (e.g., 222) satisfies (e.g., conforms to or complies with) the similarity criteria given regarding a second computational task 754 associated with a second subgraph 756 in a subsequent workflow, then proof manager component 102 may determine that, for the second computational task 754, none of the corresponding previously generated subproofs (e.g., 222) can be reused, instead of generating a second (e.g., a new) subproof as part of processing the subsequent workflow. Therefore, as indicated by reference numeral 708 in the exemplary subproof reuse process 700, proof manager component 102 may generate a second subproof 758 at least in part based on the second subgraph 756, wherein, as part of generating the second subproof 758, proof manager component 102 may perform the second computational task 754 within the second subgraph 756, as described herein.

[0074] As indicated by reference numeral 710 in the exemplary subproof reuse process 700, in some embodiments, instead of performing the second computation task 752 relative to the first subproof 750 of the corresponding previously generated subproof (e.g., 222) based at least in part on the evaluation results, the proof manager component 102 (e.g., employing subproof manager component 214) determines that the first computation task 752 is reused relative to the second computation task 754, which is at least partially based on the evaluation results. (e.g., the first computation task 752 is determined to be the same as or substantially the same as the second computation task 754). The proof manager component 102 may determine that the first subproof 750, which includes the first computation sub-result, can be reused instead of performing the second computation task 754 and generating the second subproof 758 as part of the processing of a subsequent workflow. Therefore, as indicated by reference numeral 712 in the exemplary sub-proof reuse process 700, instead of generating a second sub-proof 758, the proof manager component 102 can reuse a first sub-proof 750, which includes a first computational sub-result from performing a first computational task 752, instead of undesirably utilizing time and computational resources to perform a second computational task 754 within a second subgraph 756 related to subsequent workflows and to generate a second sub-proof 758. The first computational sub-result may be the same as or substantially the same as the second computational sub-result, which the proof manager component 102 obtains when performing the second computational task 754 and generating the second sub-proof 758 within the second subgraph 756. In some embodiments, the proof manager component 102 may update and / or modify the first sub-proof 750 as needed (e.g., as needed, appropriate, suitable, or required) to address any specific and / or minor differences between the first computational task 752 and the second computational task 754.

[0075] The disclosed subject matter (e.g., the proof manager component and enhancement techniques described herein) can expect and significantly reduce the amount of time spent processing datasets (e.g., by avoiding the amount of time spent determining and generating new subproofs and associated proofs when the computational tasks of those subproofs 222 are determined to be matching or similar to subsequent computational tasks associated with subsequent subgraphs and related datasets) by storing subproofs 222 in a subproof cache of data storage unit 218 and reusing those subproofs 222 when the computational tasks of those subproofs 222 are determined to be matching or similar to subsequent computational tasks associated with subsequent subgraphs and related datasets, instead of re-executing those subsequent computational tasks to generate subsequent (e.g., new and / or redundant) subproofs. This can reduce and / or avoid redundant computations during the determination and generation of subproofs and proofs, improve the efficiency of proof determination and generation, and improve the overall performance of the proof generation system. This reuse of subproofs 222 can be particularly useful and efficient for repetitive computations, which can be common in large-scale data analysis.

[0076] Further concerning AI component 224, according to various embodiments, AI component 224 and / or model 228 can perform AI-based analysis on data such as information and / or feedback information (e.g., feedback information from a user, device, or another data source) relating to datasets (e.g., data analysis streams or other datasets), graphs, subgraphs, proofs, subproofs, computational tasks, sub-results, hash values, applications, services, attributes, operations, functions, parameters, events, and / or other types of data. In some embodiments, regarding model 228, AI component 224 can input such information into (trained) model 228 for analysis by model 228 (e.g., AI-based analysis) to update model 228 or generate output results (e.g., AI-related data relating to graphs, subgraphs, proofs, subproofs, computational tasks, sub-results, and / or other output results) based at least in part on the analysis of the input information.

[0077] In conjunction with or as part of such AI-based analytics, AI component 224 may employ, construct (e.g., build or create) and / or import AI-based technologies and algorithms, AI-based models 228 (e.g., untrained or trained models), neural networks (e.g., untrained or trained neural networks), decision trees, Markov chains (e.g., trained Markov chains), and / or graph mining to present and / or generate predictions, inferences, operations, oracles, estimates, derivations, forecasts, detections, and / or computations that can facilitate the identification or learning of data patterns in the data, and the identification or learning of one or more data... Based on the correlation, relationship, or causal relationship between an event and another event (e.g., the occurrence of another event), determine or learn the correlation, relationship, or causal relationship between an event and another event (e.g., the occurrence of another event), determine or learn patterns related to the decomposition of a graph into subgraphs, determine or learn patterns related to the determination and generation of subproofs associated with a graph that can represent a dataset, determine or learn patterns related to computational tasks associated with subgraphs and subproofs, perform other desired functions or operations, and / or automate one or more functions or features of the disclosed subject matter, as described more fully herein.

[0078] AI component 224 may employ various AI-based schemes to perform the various embodiments / examples disclosed herein. To provide or assist in the numerous determinations (e.g., determination, ascertainment, inference, computation, prediction, oracle, estimation, derivation, forecasting, detection, and / or computation) described herein with respect to the disclosed subject matter, AI component 224 may examine all or a subset of its granted access data (e.g., training data; operational data relating to the operation of the proof manager component 102 and / or one or more servers or other devices; feedback information; and / or other information, such as that described herein), and may provide reasoning or determination of the state of the system and / or environment based on a set of observations captured via events and / or data. For example, determination may be employed to identify specific contexts or actions, or a probability distribution of states may be generated. This determination may be probabilistic; that is, calculating the probability distribution of states of interest based on considerations of data and events. Determination may also refer to techniques used to construct higher-level events based on a set of events and / or data.

[0079] In some embodiments, regarding probabilities, AI component 224 and / or (one or more) trained models 228 may employ one or more threshold probabilities (e.g., threshold probability values) to facilitate determination. For example, when making a determination (e.g., determining whether a first subproof can be linked to a second subproof, determining whether a previously generated subproof can be reused relative to a subgraph in a subsequent workflow, or other determinations), as part of performing AI-based analysis of the information, AI component 224 and / or (one or more) trained models 228 may determine probabilities (e.g., the probability that it is expected (e.g., appropriate, acceptable, desired, or optimal) to link the first subproof to the second subproof to maintain the integrity of the data flow between these subgraphs, the probability that the computational task associated with the previously generated subproof is the same as or sufficiently similar to the computational task associated with a subgraph in a subsequent workflow so that the previously generated subproof can be reused relative to the subgraph, or other probabilities), and may determine whether the probabilities (e.g., probability values) satisfy (e.g., satisfy or exceed; or are greater than or equal to) a specified and applicable threshold probability. AI component 224 and / or (one or more) trained models 228 may make determinations (or predictions or inferences) at least in part based on the results of analysis (e.g., comparison) of probabilities with prescribed and applicable threshold probabilities (e.g., minimum threshold probability values). (e.g., determining (or predicting or inferring) whether a first subproof is linkable or to be linked to a second subproof, determining (or predicting or inferring) whether a previously generated subproof is reusable or will be reused relative to a subgraph in a subsequent workflow, or making other determinations (or predictions or inferences)). As a non-limiting example, AI component 224 and / or (one or more) trained models 228 may determine (or predict or infer) whether a previously generated subproof can be reused or will be reused relative to a subgraph in a subsequent workflow, at least in part, based on the probability that the probability of a previously generated subproof being reused or will be reused relative to a subgraph in a subsequent workflow (or the probability that the computational task associated with the previously generated subproof satisfies the similarity criterion specified regarding the computational task associated with the subgraph) meets a specified and applicable threshold probability (e.g., relative to other probabilities related to whether a previously generated subproof can be reused or will be reused relative to a subgraph in a subsequent workflow, which is the highest probability and meets the specified and applicable threshold probability). In other embodiments, AI component 224 and / or (one or more) trained models 228 may determine (or predict or infer) whether a previously generated sub-proof can be reused or will be reused in a subsequent workflow (or determine (or predict or infer) whether the computational task associated with the previously generated sub-proof satisfies the similarity criteria specified regarding the computational task associated with the subgraph) based at least in part on the probability that the previously generated sub-proof can be reused or will be reused relative to the subgraph of a subsequent workflow based on the probability that the previously generated sub-proof has the highest probability relative to other probabilities, without using and / or considering threshold probabilities.

[0080] Such determination can lead to the construction of new events or actions based on a set of observed events and / or stored event data, regardless of whether the events are closely related in time or whether the events and data come from one or more event and data sources. The components disclosed herein can employ various classification schemes (explicit training (e.g., via training data) and implicit training (e.g., via observed behavior, preferences, historical information, received external information, etc.)) and / or systems (e.g., support vector machines, neural networks, expert systems, Bayesian belief networks, fuzzy logic, data fusion engines, etc.) that involve performing automated and / or deterministic actions related to the claimed subject matter. Therefore, classification schemes and / or systems can be used to automatically learn and perform multiple functions, actions, and / or determinations.

[0081] In some embodiments, AI component 224 may employ a classifier capable of performing AI-based analysis on the data. The classifier can map an input attribute vector z = (z1, z2, z3, z4, ..., zn) to a confidence level that the input belongs to a class, as denoted by f(z) = confidence(class). This classification can employ probability- and / or statistical analysis (e.g., taking into account analytical utility and cost) to determine the action to be automatically performed. Support Vector Machines (SVMs) are an example of a classifier that can be employed. SVMs operate by searching for a hypersurface in the space of possible inputs, where the hypersurface attempts to separate triggering criteria from non-triggering events. Intuitively, this makes the classification correct for data that is close to but not equivalent to the training data. Other directed and non-directed model classification approaches include, for example, Naive Bayes, Bayesian networks, decision trees, neural networks, fuzzy logic models, and / or probabilistic classification models that provide different independent patterns, any of which may be employed. Classification as used herein also includes statistical regression for developing priority models.

[0082] In some embodiments, AI component 224 (e.g., employing trainer component 226) may include, generate, and / or train (e.g., iteratively train) an AI-based model 228, which may be trained to learn, determine, predict, or infer data patterns in data; correlations, relationships, or causal relationships between (one or more) data items and (one or more) other data items (e.g., the occurrence of (one or more) other data items or events associated with them); correlations, relationships, or causal relationships between events and other events (e.g., the occurrence of another event); relationships between subgraphs of a graph representing a dataset; relationships between corresponding (e.g., different) subgraphs representing corresponding (e.g., different) datasets; and / or perform other desired functions or operations, and / or automate one or more functions or features of the disclosed subject matter, as described herein.

[0083] Further concerning the processor component 216 and data storage unit 218 of the proof manager component 102, or the processor component 216 and data storage unit 218 associated with the proof manager component 102, the processor component 216 may be associated with (e.g., communicatively connected to) other components of the proof manager component 102 and / or the system 100, and may operate in conjunction with other components of the proof manager component 102 and / or the system 100, including the proof key component 202, the graph generator component 204, the decomposer component 206, the proof generator component 208, the hasher component 210, the linker and aggregator component 212, the sub-proof manager component 214, the data storage unit 218, the AI ​​component 224, and / or other components of the proof manager component 102 and / or the system 100, in order to perform various functions and operations of the proof manager component 102 and / or the system 100. Processor component 216 may employ one or more processors (e.g., one or more central processing units (CPUs), accelerators, graph processing units (GPUs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), microprocessors, controllers, and / or microcontrollers) capable of processing data, instructions, files, datasets (e.g., data analysis streams or other datasets), graphs (e.g., DAGs or other graphs), subgraphs, computational tasks, cryptographic keys, proofs (e.g., 220), sub-proofs (e.g., 222), computation results, computational sub-results, services, applications, AI / ML-based models, AI-related data, training data, feedback information, updates, predictions, inferences, thresholds (e.g., maximum, minimum, or other thresholds), weight values, data processing operations, messages, notifications, alerts, warnings, preferences (e.g., user or client preferences), hash values, metadata, hyperparameters, parameters, tables, etc. Information regarding mappings, strategies, prescribed proof management criteria, algorithms (e.g., enhanced proof generation management algorithms, enhanced sub-proof reuse algorithms, AI algorithms, hashing algorithms, data compression algorithms, data decompression algorithms, and / or other algorithms), interfaces, protocols, tools, and / or other information, to facilitate the operation of the proof manager component 102 and / or system 100, and to control the data flow between the proof manager component 102 and / or other components associated with the proof manager component 102 and / or system 100 (e.g., proof key component 202, graph generator component 204, decomposer component 206, proof generator component 208, hasher component 210, linker and aggregator component 212, sub-proof manager component 214, data storage unit 218, AI component 224, network devices or components, communication networks, device 104 or other devices, servers, nodes, applications, services, users, or other entities).

[0084] Data storage unit 218 can store data structures (e.g., user data, metadata), one or more code structures (e.g., modules, objects, hashes, categories, procedures) or instructions, data, instructions, files, datasets (e.g., data analysis streams or other datasets), graphs (e.g., DAGs or other graphs), subgraphs, computation tasks, cryptographic keys, proofs (e.g., 220), sub-proofs (e.g., 222), computation results, computation sub-results, services, applications, AI / ML-based models, AI-related data, training data, feedback information, updates, predictions, inferences, and thresholds. Values ​​(e.g., maximum, minimum, or other thresholds), weight values, data processing operations, messages, notifications, alerts, warnings, preferences (e.g., user or customer preferences), hash values, metadata, hyperparameters, parameters, tables, mappings, policies, prescribed proof management guidelines, algorithms (e.g., enhanced proof generation management algorithms, enhanced subproof reuse algorithms, AI algorithms, hash algorithms, data compression algorithms, data decompression algorithms, and / or other algorithms), interfaces, protocols, tool-related information, and / or other information, to facilitate the control or execution of operations associated with the proof manager component 102 and / or system 100. The data storage unit 218 may include volatile and / or non-volatile memory, such as that described herein. In one aspect, processor component 216 may be functionally coupled (e.g., via a memory bus) to data storage unit 218 to store and retrieve information for desired operations and / or at least partially enable functionality to the proof key component 202, graph generator component 204, decomposer component 206, proof generator component 208, hasher component 210, linker and aggregator component 212, sub-proof manager component 214, processor component 216, data storage unit 218, AI component 224 and / or proof manager component 102 and / or other components of system 100, and / or substantially any other operational aspect of proof manager component 102 and / or system 100.

[0085] Data storage unit 218 may include volatile memory and / or non-volatile memory. By way of example, and not limitation, non-volatile memory may include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable ROM (EEPROM), flash memory, non-volatile memory Express (NVMe), NVMe over fabric (NVMe-oF), persistent memory (PMEM), or PMEM-oF. Volatile memory may include random access memory (RAM), which can act as an external cache. By way of example, and not limitation, RAM may be available in many forms, such as synchronous RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), dual data rate SDRAM (DDR SDRAM), enhanced SDRAM (ESDRAM), synchronous linked DRAM (SLDRAM), and direct Rambus RAM (DRRAM). The memory disclosed in this document is intended to include, but is not limited to, these and other suitable types of memory.

[0086] Further regarding the processor component 506 and data storage unit 508 of the validator manager component 106, or the processor component 506 and data storage unit 508 associated with the validator manager component 106, the processor component 506 may be associated with (e.g., communicatively connected to) the validator manager component 106 and / or other components of the system 100, and may operate in conjunction with the validator manager component 106 and / or other components of the system 100, including the validator key component 502, the validator component 504, the data storage unit 508 and / or other components of the validator manager component 106 and / or the system 100, in order to perform various functions and operations of the validator manager component 106 and / or the system 100. Processor component 506 may employ one or more processors (e.g., one or more CPUs, accelerators, GPUs, ASICs, FPGAs, microprocessors, controllers, and / or microcontrollers that can process information related to data, instructions, files, services, applications, cryptographic keys, proofs, computation results, thresholds (e.g., maximum, minimum, or other thresholds), weight values, data processing operations, messages, notifications, alarms, warnings, preferences (e.g., user or client preferences), hash values, metadata, hyperparameters, parameters, tables, mappings, policies, prescribed proof management criteria, algorithms (e.g., proof verification and management algorithms, hash algorithms, data compression algorithms, data decompression algorithms, and / or other algorithms), interfaces, protocols, tools, and / or other information to facilitate the operation of verifier manager component 106 and / or system 100, and to control data flow between verifier manager component 106 and / or other components associated with verifier manager component 106 and / or system 100 (e.g., proof manager component 102, network devices or components, communication networks, devices, servers, nodes, applications, services, users, or other entities).

[0087] Data storage unit 508 may store data structures (e.g., user data, metadata), one or more code structures (e.g., modules, objects, hashes, categories, procedures) or instructions, and information related to data, instructions, files, services, applications, cryptographic keys, proofs, calculation results, thresholds (e.g., maximum, minimum, or other thresholds), weight values, data processing operations, messages, notifications, alarms, warnings, preferences (e.g., user or client preferences), hash values, metadata, hyperparameters, parameters, tables, mappings, policies, prescribed proof management criteria, algorithms (e.g., proof verification and management algorithms, hash algorithms, data compression algorithms, data decompression algorithms, and / or other algorithms), interfaces, protocols, tools, and / or other information to control or execute operations associated with verifier manager component 106 and / or system 100. Data storage unit 508 may include volatile and / or non-volatile memory, such as that described herein. On one hand, processor component 506 may be functionally coupled to data storage unit 508 (e.g., via memory bus) to store and retrieve information for desired operation and / or at least partially enable functionality to validator key component 502, validator component 504, processor component 506, data storage unit 508 and / or validator manager component 106 and / or other components of system 100, and / or validator manager component 106 and / or substantially any other operational aspect of system 100.

[0088] It should be understood and comprehended that one or more components of the system (e.g., system 100, system 600, or other systems) or method described herein (e.g., proof manager component 102, device 104, verifier manager component 106, one or more servers (e.g., server 602, server 604, and / or server 606) or other components) may include or be associated with various other types of components such as displays (e.g., touchscreen displays or non-touchscreen displays), audio functions (e.g., amplifiers, speakers, or audio interfaces), or other interfaces to present information to users, entities, or other components (e.g., other devices or other servers), and / or perform other desired functions or operations.

[0089] The systems and / or devices described above have already been described in relation to the interactions between several components. It should be understood that such systems and components may include those components or sub-components specified herein, some of the specified components or sub-components, and / or additional components. Sub-components may also be implemented as components communicatively coupled to other components, rather than being included within a parent component. Furthermore, one or more components and / or sub-components may be combined into a single component that provides aggregate functionality. These components may also interact with one or more other components, which are not specifically described herein for the sake of brevity, but are known to those skilled in the art.

[0090] Given the example systems and / or devices described herein, reference may be made to Figures 8 to 10 The flowcharts in the document are provided to further understand the example methods that can be implemented according to the disclosed subject matter. For simplicity of explanation, the example methods disclosed herein are presented and described as a series of actions; however, it should be understood and appreciated that the disclosed subject matter is not limited by the order of actions, as some actions may occur in a different order and / or simultaneously with other actions shown and described herein. For example, alternatively, the methods disclosed herein may be represented as a series of interrelated states or events, such as in a state diagram. Furthermore, one or more interaction diagrams may represent the methods according to the disclosed subject matter when different entities implement different parts of the methods. Moreover, not all actions shown are necessary to implement the methods according to this specification. It should also be understood that the methods disclosed in this specification can be stored on an article of art for transmission and delivery to a computer for execution by a processor or stored in memory.

[0091] Figure 8 A flowchart of an example method 800 according to various aspects and embodiments of the disclosed subject matter is shown. This method is intended to perform and manage the generation of proofs (e.g., ZKPs) for workflows (e.g., data analysis workflows or other types of workflows or datasets) in a manner that is desirable (e.g., automatically, dynamically, appropriately, efficiently, reliably, enhanced, and / or optimally). Method 800 may be employed by a system that may include, for example, a proof manager component, which may include or be associated with a processor component, a data store, and / or other components.

[0092] In 802, a graph representing a workflow is decomposed into corresponding subgraphs representing corresponding parts of the workflow, at least in part based on the results of graph analysis. For example, a proof manager component may decompose (e.g., split, partition, or separate) a graph (e.g., a DAG) into corresponding subgraphs (e.g., corresponding sub-DAGs) at least in part based on the results of graph analysis, where the graph may represent a workflow (e.g., a data analysis workflow or other types of workflows or datasets), and where the corresponding subgraphs may represent corresponding parts of the workflow. The corresponding parts of the workflow may involve (e.g., through or using the proof manager component and one or more servers) corresponding computational tasks or operations that can be performed on the corresponding data items of the workflow.

[0093] In 804, based at least in part on the corresponding subgraph, corresponding subproofs that can be associated with the corresponding parts and corresponding subgraphs of the workflow can be determined. For example, based at least in part on the corresponding subgraph, the proof manager component can determine and generate corresponding subproofs that can be associated with the corresponding parts and corresponding subgraphs of the workflow, as described herein.

[0094] In 806, workflow-related proofs can be generated at least in part based on the corresponding sub-proofs. For example, a proof manager component can determine and generate workflow-related proofs at least in part based on the corresponding sub-proofs, as described herein.

[0095] Figure 9 A flowchart of another example method 900 according to various aspects and embodiments of the disclosed subject matter is shown, which is intended to (e.g., automatically, dynamically, appropriately, efficiently, reliably, enhancedly, and / or optimally) execute and manage the generation of proofs (e.g., ZKP) for workflows (e.g., data analysis workflows or other types of workflows or datasets). Method 900 may be employed by a system that may include, for example, a proof manager component, which may include a processor component, a data store, and / or other components or associated therewith.

[0096] At 902, a workflow can be initiated. At 904, a graph representing the workflow can be generated, at least in part, based on the analysis results of the workflow. The proof manager component can receive and / or initiate workflows (e.g., data analysis workflows or other types of workflows or datasets). In some embodiments, the proof manager component can generate a graph representing the workflow, at least in part, based on the analysis results of the workflow.

[0097] In 906, a graph can be decomposed into corresponding subgraphs representing corresponding parts of a workflow, at least in part, based on the results of graph analysis. For example, a proof manager component can decompose a graph (e.g., a DAG) into corresponding subgraphs (e.g., corresponding sub-DAGs), where the corresponding subgraphs can represent corresponding parts of a workflow, at least in part, based on the results of graph analysis. The corresponding parts of the workflow may involve (e.g., through or using the proof manager component and one or more servers) corresponding computational tasks or operations that can be performed on the corresponding data items of the workflow.

[0098] In 908, based at least in part on the corresponding subgraph, a corresponding subproof that can be associated with a corresponding part of the workflow and the corresponding subgraph can be determined, wherein the corresponding subproof can include corresponding input values ​​and corresponding output values. For example, a proof manager component can determine and generate corresponding subproofs at least in part on the corresponding subgraph, wherein the corresponding subproof can be associated with a corresponding part of the workflow and the corresponding subgraph, as described herein. As part of determining and generating the corresponding subproof, the proof manager component can perform or facilitate the performance of corresponding computational tasks and operations in the corresponding subgraph to generate corresponding computational sub-results, wherein corresponding input values ​​and corresponding output values ​​can be determined and can be included in the corresponding subproof based at least in part on the performance of the corresponding computational tasks and operations in the corresponding subgraph. According to various embodiments, the proof manager component can utilize a server to determine and generate corresponding subproofs at least in part on the corresponding subgraph, or it can utilize two or more servers in a distributed manner to determine and generate corresponding subproofs at least in part on the corresponding subgraph (e.g., in parallel).

[0099] In 910, the corresponding input and output values ​​of a corresponding subgraph can be hashed to generate corresponding hashed input and output values ​​for the corresponding subgraph, which can be included in a corresponding sub-proof associated with the corresponding subgraph. In the corresponding sub-proof, the corresponding hashed input and output values ​​can be submitted as corresponding hash commitments to ensure the integrity of the workflow, including the integrity of data flow between the corresponding subgraphs. For example, corresponding edges between corresponding subgraphs can represent corresponding data dependencies. Accordingly, corresponding sub-proofs (and corresponding subgraphs) can include or be associated with corresponding input and output values. The proof manager component can hash the corresponding input and output values ​​of a corresponding subgraph to generate corresponding hashed input and output values ​​for the corresponding subgraph, and those corresponding hashed input and output values ​​can be included in the corresponding sub-proof.

[0100] In 912, based at least in part on a matching criterion that determines the corresponding hash input and / or corresponding hash output values ​​of a corresponding sub-proof satisfies other values ​​among the corresponding hash input and / or corresponding hash output values ​​of other corresponding sub-proofs, a corresponding sub-proof may be linked to other sub-proofs within the corresponding sub-proof and aggregated to generate a workflow-related proof, wherein the proof may include workflow-related computation results. For example, as described herein, based at least in part on a matching criterion that determines the corresponding hash input and / or corresponding hash output values ​​of a corresponding sub-proof satisfies other values ​​among the corresponding hash input and / or corresponding hash output values ​​of other corresponding sub-proofs, a proof manager component may link a corresponding sub-proof to other sub-proofs within the corresponding sub-proof and aggregate the linked sub-proofs to generate a workflow-related proof. The proof manager component may determine workflow-related computation results based at least in part on the corresponding computational sub-results of the corresponding sub-proofs.

[0101] In 914, proofs including computation results can be transmitted to the validator device. The proof manager component can transmit proofs to the validator device to present the computation results to the validator device and verify that the proof including the computation results is correct, without disclosing the underlying data of the workflow used to determine and generate proofs to the validator device.

[0102] Figure 10 A flowchart of an exemplary method 1000 according to various aspects and embodiments of the disclosed subject matter is shown. This method desirably (e.g., automatically, dynamically, appropriately, reliably, efficiently, enhancedly, and / or optimally) reuses previously generated sub-proofs associated with previously processed workflows in lieu of generating new sub-proofs related to processing subsequent workflows. Method 1000 may be employed by a system, for example, that may include a proof manager component, which may include or be associated with a processor component, a data store, and / or other components.

[0103] At 1002, corresponding sub-proofs associated with one or more proofs relating to one or more previous workflows can be stored in a data store, including corresponding sub-proofs of a first sub-proof that can be associated with a corresponding computational task including a first computational task performed within a corresponding subgraph relating to one or more previous workflows. The proof manager component can store corresponding sub-proofs associated with one or more proofs in the data store to facilitate reuse in one or more corresponding sub-proofs relating to subsequent workflows, as described herein. The first sub-proof may relate to a first computational task performed within a first subgraph relating to a previous workflow, wherein the first subgraph may represent a portion of the previous workflow.

[0104] In step 1004, in conjunction with subsequent workflows, the corresponding computational tasks associated with the corresponding sub-proof and the second computational tasks associated with the second subgraph of the subsequent workflow can be evaluated to determine whether any of the corresponding computational tasks meets the similarity criteria specified for the second computational task. For example, a proof manager component (e.g., employing a sub-proof manager component) can evaluate (e.g., analyze or examine) the corresponding and second computational tasks to determine whether any of the corresponding computational tasks meets the similarity criteria specified for the second computational task.

[0105] In 1006, based at least in part on the evaluation results, it can be determined whether any computational task in the corresponding computational task associated with the corresponding sub-proof satisfies the similarity criterion specified regarding the second computational task associated with the second subgraph of the subsequent workflow. For example, a proof manager component (e.g., employing a sub-proof manager component) can determine, at least in part on the evaluation results, whether any of the corresponding computational tasks associated with the corresponding sub-proof satisfies the similarity criterion specified regarding the second computational task.

[0106] If, based at least in part on the evaluation results, it is determined that none of the corresponding computational tasks associated with the corresponding sub-proof satisfy the similarity criteria specified regarding the second computational task associated with the second subgraph of the subsequent workflow, then at 1008, it can be determined that none of the corresponding sub-proofs can be reused with respect to the second computational task. For example, if, based at least in part on the evaluation results, the proof manager component determines that none of the corresponding computational tasks associated with the corresponding sub-proof satisfy the similarity criteria specified regarding the second computational task, then the proof manager component can determine that none of the corresponding sub-proofs can be reused with respect to the second computational task. Therefore, the proof manager component can generate the second sub-proof at least in part based on the second subgraph, wherein, as part of generating the second sub-proof, the proof manager component can perform the second computational task within the second subgraph, as described herein.

[0107] Referring again to reference numeral 1006, if at 1006, based at least in part on the evaluation results, it is determined that the first computational task associated with the first sub-proof satisfies a prescribed similarity criterion for reuse relative to the second computational task, then at 1010, it can be determined that the first sub-proof can be reused instead of performing the second computational task and generating the second sub-proof as part of processing in a subsequent workflow. In some embodiments, if, at least in part on the evaluation results, the proof manager component determines that the first computational task associated with the first sub-proof satisfies a prescribed similarity criterion for reuse relative to the second computational task (e.g., the first computational task is the same as or substantially the same as the second computational task), it can be determined that the first sub-proof can be reused instead of performing the second computational task and generating the second sub-proof as part of processing in a subsequent workflow. Instead of generating the second sub-proof, the proof manager component can reuse the first sub-proof, which includes the first computational sub-result from performing the first computational task, instead of undesirably utilizing time and computational resources to perform the second computational task within the second subgraph related to the subsequent workflow and generate the second sub-proof. The first computational sub-result may be the same as or substantially the same as the second computational sub-result, wherein the second computational sub-result will be obtained if the proof manager component performs the second computational task within the second subgraph and generates the second sub-proof. In some embodiments, the proof manager component may update and / or modify the first sub-proof as needed (e.g., as needed, appropriate, suitable, or required) to address any specific and / or minor differences between the first and second computational tasks.

[0108] To provide additional context for the various embodiments described herein, Figure 11 The following discussion is intended to provide a brief, general description of a suitable computing environment 1100 in which various embodiments of the embodiments described herein may be implemented. Although the various embodiments have been described above in the general context of computer-executable instructions that can run on one or more computers, those skilled in the art will recognize that the embodiments may also be implemented in combination with other program modules and / or as a combination of hardware and software.

[0109] Typically, program modules include routines, programs, components, data structures, etc., that perform specific tasks or implement specific abstract data types. Furthermore, those skilled in the art will understand that these methods can be implemented using other computer system configurations, including single-processor or multi-processor computer systems, minicomputers, mainframes, IoT devices, distributed computing systems, and personal computers, handheld computing devices, microprocessor-based or programmable consumer electronics, each operatively coupled to one or more associated devices.

[0110] The embodiments illustrated in this document can also be practiced in a distributed computing environment, where some tasks are performed by remote processing devices linked via a communication network. In a distributed computing environment, program modules can reside in both local and remote memory storage devices.

[0111] Computing devices typically include various media, which may include computer-readable storage media, machine-readable storage media, and / or communication media, these two terms being used differently from each other, as described below. A computer-readable storage medium or a machine-readable storage medium can be any available storage medium that is accessible by a computer and includes volatile and non-volatile media, removable and non-removable media. By way of example and not limitation, a computer-readable storage medium or a machine-readable storage medium can be implemented in conjunction with any method or technique for storing information such as computer-readable or machine-readable instructions, program modules, structured data, or unstructured data.

[0112] Computer-readable storage media may include, but are not limited to, random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, optical disc read-only memory (CDROM), digital versatile disc (DVD), Blu-ray disc (BD) or other optical disc storage, magnetic tape cassettes, magnetic tape, disk storage or other magnetic storage devices, solid-state drives or other solid-state storage devices, or other tangible and / or non-transitory media that can be used to store desired information. In this regard, the terms “tangible” or “non-transitory” as used herein with respect to storage devices, memories, or computer-readable media shall be understood to exclude only the propagation of transient signals themselves as a modifier, and shall not waive the rights to all standard storage devices, memories, or computer-readable media that do not only propagate transient signals themselves.

[0113] Computer-readable storage media can be accessed by one or more local or remote computing devices, for example via access requests, queries or other data retrieval protocols, in order to perform various operations on the information stored on the media.

[0114] Communication media typically embody computer-readable instructions, data structures, program modules, or other structured or unstructured data in the form of data signals (such as modulated data signals, for example, carrier waves or other transmission mechanisms), and include any information transmission or delivery medium. The term "modulated data signal" or multiple signals refers to a signal whose one or more characteristics are set or altered to encode information in one or more signals. By way of example and not limitation, communication media include wired media, such as wired networks or direct-wire connections, and wireless media, such as acoustic, RF, infrared, and other wireless media.

[0115] Refer again Figure 11An example environment 1100 for implementing various embodiments of the aspects described herein includes a computer 1102, which includes a processing unit 1104, system memory 1106, and a system bus 1108. The system bus 1108 couples system components, including but not limited to system memory 1106, to the processing unit 1104. The processing unit 1104 can be any of a variety of commercially available processors. Dual-microprocessor and other multiprocessor architectures may also be used as the processing unit 1104.

[0116] System bus 1108 can be any of several types of bus architectures, which can also interconnect to memory buses (with or without memory controllers), peripheral buses, and local buses using any of the various commercially available bus architectures. System memory 1106 includes ROM 1110 and RAM 1112. The Basic Input / Output System (BIOS) can be stored in non-volatile memory such as ROM, erasable programmable read-only memory (EPROM), or EEPROM, where the BIOS contains basic routines that help, for example, pass information between various components within computer 1102 during startup. RAM 1112 may also include high-speed RAM (such as static RAM) for caching data.

[0117] Computer 1102 also includes an internal hard disk drive (HDD) 1114 (e.g., EIDE, SATA), one or more external storage devices 1116 (e.g., floppy disk drive (FDD) 1116, memory stick or flash drive reader, memory card reader, etc.), and an optical disc drive 1120 (e.g., capable of reading from or writing to CD-ROMs, DVDs, BDs, etc.). While the internal HDD 1114 is shown as being located within computer 1102, it can also be configured for use outside a suitable chassis (not shown). Additionally, although not shown in environment 1100, a solid-state drive (SSD) may be used in addition to or in place of HDD 1114. HDD 1114, one or more external storage devices 1116, and optical disc drive 1120 can be connected to system bus 1108 via HDD interface 1124, external storage interface 1126, and optical disc drive interface 1128, respectively. The interface 1124 for the external driver implementation may include at least one or both of Universal Serial Bus (USB) and Institute of Electrical and Electronics Engineers (IEEE) 1394 interface technologies. Other external driver connectivity technologies are within the scope of the embodiments described herein.

[0118] The drive and its associated computer-readable storage medium provide non-volatile storage of data, data structures, computer-executable instructions, etc. For computer 1102, the drive and storage medium accommodate storage of any data in a suitable digital format. Although the above description of computer-readable storage media refers to corresponding types of storage devices, those skilled in the art will understand that other types of computer-readable storage media, whether currently existing or developed in the future, may also be used in the example operating environment, and furthermore, any such storage medium may contain computer-executable instructions for performing the methods described herein.

[0119] Multiple program modules may be stored in the driver and RAM 1112, including an operating system 1130, one or more applications 1132, other program modules 1134, and program data 1136. All or part of the operating system, applications, modules, and / or data may also be cached in RAM 1112. The systems and methods described herein can be implemented using various commercially available operating systems or combinations of operating systems.

[0120] Computer 1102 may optionally include emulation technology. For example, a super manager (not shown) or other intermediary may emulate a hardware environment for operating system 1130, and the emulated hardware may optionally be different from the hardware used in the emulation. Figure 11 The hardware is shown. In such an embodiment, the operating system 1130 may include one of a plurality of virtual machines (VMs) hosted at the computer 1102. Furthermore, the operating system 1130 may provide a runtime environment for the application 1132, such as the Java Runtime Environment or the .NET Framework. A runtime environment is a consistent execution environment that allows the application 1132 to run on any operating system that includes a runtime environment. Similarly, the operating system 1130 may support containers, and the application 1132 may be in the form of a container, which is a lightweight, stand-alone, executable software package that includes, for example, code, runtime, system tools, system libraries, and setup for the application.

[0121] Furthermore, computer 1102 can be enabled using a security module (e.g., a Trusted Processing Module (TPM)). For example, using a TPM, the boot component hashes the next boot component in time and waits for the result to match a security value before loading the next boot component. This process can occur at any layer of the computer 1102's code execution stack, for example, at the application execution level or at the operating system (OS) kernel level, thus achieving security at any code execution level.

[0122] Users can input commands and information into computer 1102 through one or more wired / wireless input devices, such as keyboard 1138, touchscreen 1140, and pointing devices such as mouse 1142. Other input devices (not shown) may include microphones, infrared (IR) remote controls, radio frequency (RF) remote controls or other remote controls, joysticks, virtual reality controllers and / or virtual reality headsets, gaming pads, styluses, image input devices (e.g., one or more cameras), gesture sensor input devices, visual motion sensor input devices, emotion or face detection devices, biometric input devices (e.g., fingerprint or iris scanners), etc. These and other input devices are typically connected to processing unit 1104 via input device interface 1144, which is coupled to system bus 1108, but may also be connected via other interfaces (e.g., parallel ports, IEEE 1394 serial ports, gaming ports, USB ports, IR interfaces, Bluetooth interfaces, etc.).

[0123] Monitor 1146 or other types of display devices may also be connected to system bus 1108 via an interface such as video adapter 1148. In addition to monitor 1146, computers typically include other peripheral output devices (not shown), such as speakers, printers, etc.

[0124] Computer 1102 can operate in a networked environment via wired and / or wireless communication to one or more remote computers (e.g., one or more remote computers 1150), using logical connections. The remote computers 1150 can be workstations, server computers, routers, personal computers, portable computers, microprocessor-based entertainment devices, peer-to-peer devices, or other common network nodes, and typically include many or all of the elements described relative to computer 1102; however, for simplicity, only the memory / storage unit 1152 is shown. The described logical connections include wired / wireless connections to a local area network (LAN) 1154 and / or a larger network (e.g., a wide area network (WAN) 1156). Such LAN and WAN networking environments are common in offices and companies and facilitate enterprise-wide computer networks such as intranets, all of which can be connected to global communication networks such as the Internet.

[0125] When used in a LAN network environment, computer 1102 can connect to local area network 1154 via a wired and / or wireless communication network interface or adapter 1158. Adapter 1158 facilitates wired or wireless communication with LAN 1154, which may also include a wireless access point (AP) configured thereon for communicating with adapter 1158 wirelessly.

[0126] When used in a WAN networking environment, computer 1102 may include modem 1160, or may be connected to a communication server on WAN 1156 via other means (e.g., via the Internet) to establish communication on WAN 1156. Modem 1160 may be built-in or external, and may be a wired or wireless device, and may be connected to system bus 1108 via input device interface 1144. In a networked environment, program modules or portions thereof described relative to computer 1102 may be stored in remote memory / storage unit 1152. It is understood that the network connection shown is an example, and other means for establishing communication links between computers may be used.

[0127] When used in a LAN or WAN networking environment, in addition to the external storage device 1116 or an alternative external storage device 1116 as described above, computer 1102 can access cloud storage systems or other network-based storage systems. Typically, a connection between computer 1102 and the cloud storage system can be established on LAN 1154 or WAN 1156, for example, via adapter 1158 or modem 1160, respectively. When computer 1102 is connected to an associated cloud storage system, external storage interface 1126 can manage the storage provided by the cloud storage system with the help of adapter 1158 and / or modem 1160, just as it would manage other types of external storage. For example, external storage interface 1126 can be configured to provide access to cloud storage sources as if these sources were physically connected to computer 1102.

[0128] Computer 1102 is operable to communicate with any wireless device or entity operatively located in wireless communication (e.g., printer, scanner, desktop and / or portable computer, portable data assistant, communication satellite, any device or location associated with a wirelessly detectable tag (e.g., public telephone booth, newsstand, shelf, etc.), and telephone). This can include Wi-Fi and Bluetooth wireless technologies. Therefore, communication can be a predefined structure like a conventional network, or simply self-organizing communication between at least two devices.

[0129] Wi-Fi, or Wireless Fidelity, allows internet access from the sofa in your home, hotel room, or work conference room without the need for wires. Similar to the wireless technology used in cellular phones, Wi-Fi enables devices such as computers to send and receive data indoors and outdoors, anywhere within range of a base station. Wi-Fi networks use radio technology known as IEEE 802.11 (a, b, g, etc.) to provide secure, reliable, and fast wireless connectivity. Wi-Fi networks can be used to connect computers to each other, connect to the internet, and connect to wired networks (which use IEEE 802.3 or Ethernet). Wi-Fi networks operate in the unlicensed 2.4 GHz and 5 GHz radio bands, for example, at data rates of 11 Mbps (802.11a) or 54 Mbps (802.11b), or have products that include two bands (dual-band), thus providing real-world performance similar to basic 10BaseT wired Ethernet used in many offices.

[0130] The various aspects or features described herein can be implemented as methods, apparatus, systems, or articles of art using standard programming or engineering techniques. Additionally, the various aspects or features disclosed herein can also be implemented by program modules that implement at least one or more methods disclosed herein, the program modules being stored in memory and executed at least by a processor. Other combinations of hardware and software, or hardware and firmware, can implement or carry out the aspects described herein, including the disclosed methods(s). As used herein, the term “article of art” is intended to cover a computer program accessible from any computer-readable device, carrier, or storage medium. For example, a computer-readable storage medium may include, but is not limited to, magnetic storage devices (e.g., hard disks, floppy disks, magnetic stripes, etc.), optical disks (e.g., compact discs (CDs), digital versatile discs (DVDs), Blu-ray discs (BDs), etc.), smart cards, and memory devices that include volatile and / or non-volatile memory (e.g., flash memory devices, such as, for example, cards, sticks, key drives, etc.). According to various embodiments, a computer-readable storage medium may be a non-transitory computer-readable storage medium and / or a computer-readable storage device may include a computer-readable storage medium.

[0131] As used herein, the term "processor" can refer to substantially any computing processing unit or device, including but not limited to: a single-core processor; a single-core processor with software multithreading capabilities; a multi-core processor; a multi-core processor with software multithreading capabilities; a multi-core processor with hardware multithreading technology; a parallel platform; and a parallel platform with distributed shared memory. A processor can be or can include, for example, multiple processors, which can include distributed or parallel processors in a single machine or multiple machines. Additionally, a processor can include or refer to an integrated circuit, application-specific integrated circuit (ASIC), digital signal processor (DSP), programmable gate array (PGA), field-programmable gate array (FPGA), programmable logic controller (PLC), complex programmable logic device (CPLD), state machine, discrete gate or transistor logic, discrete hardware components, or any combination thereof, designed to perform the functions described herein. Furthermore, processors can employ nanoscale architectures, such as, but not limited to, molecular and quantum dot-based transistors, switches, and gates, to optimize space utilization or enhance the performance of user equipment. Processors can also be implemented as a combination of computing processing units.

[0132] A processor can facilitate the performance of various types of operations, for example, by executing computer-executable instructions. When a processor executes instructions to perform an operation, this can include the processor performing (e.g., directly executing) the operation, and / or performing the operation indirectly, such as by facilitating (e.g., facilitating its operation), directing, controlling one or more other devices or components to perform the operation, or cooperating with one or more other devices or components. In some embodiments, memory can store computer-executable instructions, and the processor can be communicatively coupled to the memory, wherein the processor can access or retrieve the computer-executable instructions from the memory and can facilitate the execution of the computer-executable instructions to perform an operation.

[0133] In some implementations, the processor may be, or may include, one or more processors that can be used to support a virtualized computing environment or a virtualized processing environment. A virtualized computing environment may support one or more virtual machines representing computers, servers, or other computing devices. In such virtualized virtual machines, components such as processors and storage devices may be virtualized or logically represented.

[0134] In this specification, terms such as “storage,” “storage device,” “data storage,” “data storage apparatus,” “database,” and virtually any other information storage component related to the operation and function of the component are used to refer to a “memory component,” an entity embodied in “memory,” or a component that includes memory. It should be understood that the memory and / or memory components described herein may be volatile memory or non-volatile memory, or may include both volatile and non-volatile memory.

[0135] By way of illustration and not limitation, non-volatile memory may include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable ROM (EEPROM), or flash memory. Volatile memory may include random access memory (RAM), which acts as an external cache memory. By way of illustration and not limitation, RAM may be available in many forms, such as synchronous RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), dual data rate SDRAM (DDR SDRAM), enhanced SDRAM (ESDRAM), synchronous link DRAM (SLDRAM), and direct Rambus RAM (DRRAM). Furthermore, the memory components disclosed in the systems or methods herein are intended to include, but are not limited to, these and any other suitable types of memory.

[0136] As used herein, the terms “component,” “system,” “platform,” “framework,” “layer,” “interface,” “agent,” etc., may refer to and / or include computer-related entities or entities related to an operating machine having one or more specific functions. Entities disclosed herein may be hardware, a combination of hardware and software, software, or software in execution. For example, a component may be, but is not limited to, a process running on a processor, a processor, an object, an executable file, a thread of execution, computer-executable instructions, a program, and / or a computer. For illustration, an application running on a server and the server itself may both be components. One or more components may reside within a process and / or a thread of execution, and components may reside on one computer and / or be distributed across two or more computers.

[0137] In another example, the components may be executed from various computer-readable media on which various data structures are stored. Components may communicate via local and / or remote processes, for example, based on signals having one or more data packets (e.g., data from a component that interacts with another component in a local system, a distributed system, and / or via signals to other systems through a network such as the Internet). As another example, a component may be a device having specific functions provided by mechanical parts operated by electrical or electronic circuitry, which is operated by software or firmware applications executed by a processor. In this case, the processor may be internal or external to the device and may execute at least a portion of the software or firmware application. As yet another example, a component may be a device that provides specific functions through electronic components rather than mechanical parts, wherein the electronic components may include a processor or other means to execute software or firmware that at least partially endows the electronic components with the functions. In one aspect, a component may be emulated via a virtual machine, for example, within a cloud computing system.

[0138] The communication devices described herein may be, or may include, for example, computers, laptops, servers, telephones (e.g., smartphones), electronic tablets or tablets, video game devices, electronic headwear or clothing (e.g., electronic glasses, smartwatches, augmented reality (AR) / virtual reality (VR) headsets, or other types of electronic headwear or clothing), set-top boxes, Internet Protocol (IP) television (IPTV), IoT devices (e.g., medical devices, electronic speakers with voice controllers, camera devices, security devices, tracking devices, appliances, or other IoT devices), or other desired types of communication devices.

[0139] Furthermore, the term "or" is intended to mean an inclusive "or" rather than an exclusive "or". That is, unless otherwise specified or apparent from the context, "X adopts A or B" is intended to mean any natural inclusive permutation. That is, if X adopts A; X adopts B; or X adopts both A and B, then "X adopts A or B" is satisfied in any of the foregoing instances. Furthermore, unless otherwise specified or apparent from the context, the articles "a (and an)" as used in this specification and the accompanying drawings should generally be interpreted as meaning "one or more".

[0140] As used herein, the terms “example,” “exemplary,” and / or “illustrative” are used to indicate that something is used as an example, instance, or illustration. To avoid ambiguity, the subject matter disclosed herein is not limited to these examples. Furthermore, any aspect or design described herein as “example,” “exemplary,” and / or “illustrative” is not necessarily to be construed as preferred or advantageous over other aspects or designs, nor does it exclude equivalent exemplary structures and techniques known to those skilled in the art. Moreover, with respect to the use of the terms “comprising,” “having,” “including,” and other similar words in the detailed description or claims, these terms are intended to be inclusive in a manner similar to the term “comprising” as an open transition word, without excluding any additional or other elements.

[0141] It should be understood and appreciated that components described with respect to a particular system or method (e.g., proof manager component, verifier manager component, AI component, device, server, processor component, data storage or other component) may include the same or similar functionality as corresponding components described with respect to other systems or methods disclosed herein (e.g., separately named components or similarly named components).

[0142] The foregoing description includes examples of systems and methods that provide advantages to the disclosed subject matter. It is certainly impossible to describe every conceivable combination of components or methods in order to describe the disclosed subject matter, but those skilled in the art will recognize that many further combinations and arrangements of the disclosed subject matter are possible. Furthermore, with regard to the use of the terms “comprising,” “having,” “possessing,” etc., in the detailed description, claims, appendices, and drawings, these terms are intended to be inclusive in a manner similar to the term “comprising,” as “comprising” is interpreted as a transitional word in the claims.

Claims

1. A method comprising: A system including at least one processor decomposes a graph representing a workflow into corresponding subgraphs representing corresponding parts of the workflow; Based on the corresponding subgraph, the system determines the corresponding subproof related to the corresponding part of the workflow and the corresponding subgraph; as well as Based on the corresponding sub-proof, the system generates proofs related to the workflow.

2. The method according to claim 1, wherein, The proof is a zero-knowledge proof, and the corresponding sub-proof is a corresponding zero-knowledge sub-proof.

3. The method according to claim 1, wherein, The workflow is a data analysis workflow, wherein the graph is a directed acyclic graph, and wherein the corresponding subgraph is a corresponding directed acyclic subgraph.

4. The method according to claim 1, further comprising: Based on the corresponding computational operations performed within the corresponding subgraph, the system determines corresponding sub-result data items related to the workflow, wherein the corresponding sub-proof includes the corresponding sub-result data items; and Based on the corresponding sub-proof, the system determines the proof, including result data, related to the workflow, wherein the result data is determined based on the corresponding sub-result data item.

5. The method according to claim 4, further comprising: The system transmits the proof to a verifier device, wherein the proof facilitates the verification that the proof, including the result data, is correct without disclosing to the verifier device the underlying data of the workflow used to determine and generate the proof.

6. The method according to claim 4, wherein, The corresponding edges between the corresponding subgraphs represent corresponding data dependencies, wherein the corresponding subgraphs include corresponding input values ​​and corresponding output values, and wherein the method further includes: The system hashes the corresponding input and output values ​​of the corresponding subgraphs to generate corresponding hash input and output values ​​for the corresponding subgraphs. These hash input and output values ​​are included in the corresponding sub-proof, and are committed as hash commitments in the sub-proof to ensure the integrity of the workflow, including the integrity of data flows between the corresponding subgraphs. The system links the corresponding sub-proofs to generate the proof based on the corresponding hash input value and the corresponding hash output value of the corresponding sub-proof.

7. The method according to claim 6, wherein, The corresponding sub-proof includes a first sub-proof and a second sub-proof, wherein the first sub-proof includes a first hash input value and a first hash output value, wherein the second sub-proof includes a second hash input value and a second hash output value, and wherein the method further includes: Based on the determination that the first hash output value of the first sub-proof satisfies a matching criterion specified with respect to the second hash input value of the second sub-proof, the system determines that the output of the first sub-proof should be linked to the input of the second sub-proof, wherein the linking includes: linking the output of the first sub-proof to the input of the second sub-proof based on the determination that the output of the first sub-proof should be linked to the input of the second sub-proof.

8. The method according to claim 1, wherein, The workflow is a first workflow, wherein the proof is a first proof, and wherein the method further includes: The system stores the corresponding sub-proof in a data storage unit, wherein the corresponding sub-proof is associated with a corresponding computation task, and the corresponding sub-proof includes a first sub-proof associated with a first computation task executed within a first subgraph of the corresponding subgraph; Based on the analysis of the second computation task associated with the second workflow and the first computation task associated with the first sub-proof, the system combines the second workflow to determine whether the second computation task satisfies the similarity criteria specified with respect to the first computation task, wherein the second computation task is associated with a second subgraph representing a part of the second workflow; Based on the determination that the second computational task associated with the second workflow satisfies the similarity criterion regarding the first computational task associated with the first sub-proof, the system retrieves the first sub-proof from the data storage unit; and The system utilizes the first sub-proof as a second sub-proof regarding the second subgraph to generate a second proof relating to the second workflow, wherein the second subgraph represents the portion of the second workflow.

9. The method according to claim 1, wherein, The corresponding subgraph includes a first subgraph representing a first part of the workflow and a second subgraph representing a second part of the workflow, wherein the corresponding subproof includes a first subproof related to the first subgraph and a second subproof related to the second subgraph, and wherein determining the corresponding subproof includes: The first sub-proof is determined based on the first subgraph; and In parallel with determining the first sub-proof, the second sub-proof is determined based on the second subgraph.

10. A system comprising: At least one memory that stores computer-executable components; as well as At least one processor that executes a computer-executable component stored in the at least one memory, wherein the computer-executable component includes: A decomposer that decomposes a graph representing a workflow into corresponding subgraphs related to the corresponding parts of the workflow; and A proof generator determines corresponding sub-proofs related to the corresponding parts of the workflow and the corresponding sub-graph based on the corresponding subgraph, in order to generate proofs related to the workflow.

11. The system according to claim 10, wherein, The workflow is a data analysis workflow, wherein the proof is a zero-knowledge proof, and the corresponding sub-proof includes a corresponding zero-knowledge sub-proof, and wherein the graph is a directed acyclic graph, and the corresponding sub-graph includes a corresponding directed acyclic sub-graph.

12. The system according to claim 10, wherein, The proof generator determines corresponding sub-result information items related to the workflow based on corresponding computational tasks performed within the corresponding subgraph, and determines and generates the proof related to the workflow, including result information, based on the corresponding sub-proof, wherein the corresponding sub-proof includes the corresponding sub-result information data item.

13. The system according to claim 12, wherein, The proof generator transmits or facilitates the transmission of the proof to the verifier device, wherein the proof facilitates the verification that the proof, including the result information, is correct, without disclosing to the verifier device the underlying information of the workflow used to determine and generate the proof.

14. The system according to claim 13, wherein, The corresponding edges between the corresponding subgraphs represent corresponding data dependencies, wherein the corresponding subgraphs include corresponding input values ​​and corresponding output values, and wherein the computer-executable component further includes: A hasher that hashes the corresponding input and output values ​​of the corresponding subgraph to generate corresponding hash input and output values ​​of the corresponding subgraph as part of the corresponding subproof, wherein the corresponding hash input and output values ​​are submitted as corresponding hash commitments in the corresponding subproof to ensure the integrity of the workflow and the integrity of the data flow between the corresponding subgraphs; and A linker that links the corresponding sub-proofs based on the corresponding hash input value and the corresponding hash output value of the corresponding sub-proof in order to generate the proof.

15. The system according to claim 14, wherein, The corresponding sub-proof includes a first sub-proof and a second sub-proof, wherein the first sub-proof includes a first hash input value and a first hash output value, wherein the second sub-proof includes a second hash input value and a second hash output value, wherein the linker determines that the output of the first sub-proof should be linked to the input of the second sub-proof based on determining that the first hash output value of the first sub-proof satisfies a specified matching criterion with respect to the second hash input value of the second sub-proof, and wherein, in response to determining that the output of the first sub-proof should be linked to the input of the second sub-proof, the linker links the output of the first sub-proof to the input of the second sub-proof.

16. The system according to claim 10, wherein, The workflow is a first workflow, wherein the corresponding sub-proof is associated with a corresponding computation task, the corresponding sub-proof includes a first sub-proof associated with a first computation task executed within a first subgraph of the corresponding subgraph, wherein the proof is a first proof, and wherein the proof generator stores or facilitates the storage of the corresponding sub-proof in a data storage unit; In this context, in conjunction with the second workflow, the proof generator determines, based on the analysis results of the second computational task associated with the second workflow and the first computational task associated with the first sub-proof, that the second computational task satisfies the similarity criteria specified for the first computational task, wherein the second computational task is associated with a second subgraph representing a part of the second workflow; Wherein, based on determining that the second computing task satisfies the similarity criterion specified regarding the first computing task, the proof generator obtains the first sub-proof from the data storage unit; and The proof generator utilizes the first sub-proof as a second sub-proof regarding the second subgraph to generate a second proof relating to the second workflow, wherein the second subgraph represents the portion of the second workflow; or the proof generator modifies the first sub-proof to generate a modified sub-proof and utilizes the modified sub-proof as a second sub-proof regarding the second subgraph to generate the second proof.

17. The system according to claim 10, wherein, The corresponding subgraph includes a first subgraph representing a first part of the workflow and a second subgraph representing a second part of the workflow, wherein the corresponding subproof includes a first subproof related to the first subgraph and a second subproof related to the second subgraph, and wherein a first server is used to facilitate the determination of the first subproof based on the first subgraph, while a second server is used to facilitate the determination of the second subproof based on the second subgraph.

18. The system according to claim 10, wherein, The decomposer or the proof generator includes or utilizes an accelerator unit, a graph processing unit, a field-programmable gate array, or an application-specific integrated circuit.

19. A non-transitory machine-readable medium comprising executable instructions that, when executed by at least one processor, facilitate the execution of operations, said operations including: The directed acyclic graph representing the workflow is divided into corresponding directed acyclic subgraphs related to the corresponding parts of the workflow; Based on the corresponding directed acyclic subgraph, generate corresponding subproofs related to the corresponding parts of the workflow and the corresponding directed acyclic subgraph; as well as Based on the corresponding sub-proof, a proof related to the workflow is generated.

20. The non-transitory machine-readable medium according to claim 19, wherein, The workflow is a data analysis workflow, wherein the proof is a zero-knowledge proof, and the corresponding sub-proof includes a corresponding zero-knowledge sub-proof, and wherein the operation further includes: The corresponding sub-result data items related to the data analysis workflow are determined based on the corresponding computational tasks performed within the corresponding directed acyclic subgraph, wherein the corresponding zero-knowledge sub-proof includes the corresponding sub-result data items; The zero-knowledge proof relating to the data analysis workflow, including result data, is determined based on the corresponding zero-knowledge sub-proof, wherein the result data is determined based on the corresponding sub-result data item; and The zero-knowledge proof is transmitted to a validator device, wherein the zero-knowledge proof facilitates the verification that the zero-knowledge proof, including the result data, is correct, without disclosing to the validator device the underlying data of the data analysis workflow used to determine and generate the zero-knowledge proof.

Images