Enhanced zero knowledge analysis

Abstract

Zero knowledge (ZK) analysis, including causal analysis and ZK attestation (ZKP) generation, may be managed and performed in an enhanced manner. The graph processor may perform a first analysis of graph data of a graph related to a cause, effect, or event based on the one or more ZK primitives. One or more ZK primitives may be customized for causal analysis in a ZK application. The attestation manager may determine and generate a ZKP related to the cause, effect, or event, including calculation results, based on a second result of a second analysis of result data of a first result of the first analysis, where the result data may include primitive data representing or related to at least one ZK primitive. The attestation manager may transmit the ZKP to a verifier to facilitate verification of correctness of the ZKP including the calculation results.

Description

[0001] Cross-references to related applications

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

[0003] For various applications and services, and in various situations, it may be desirable to protect personal and / or sensitive data. A variety of cryptographic tools can be used to protect this 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 a prelude to the detailed embodiments presented later.

[0006] In some embodiments, the disclosed subject matter may include a method that may include: performing a first analysis of graph data, which may represent a graph relating to a cause, effect, or event, by a system including at least one processor, based on at least one zero-knowledge (ZK) primitive. The method may further include: determining, by the system, a ZK proof (ZKP) relating to the cause, effect, or event, based on a second result of a second analysis of result data of a first result of the first analysis, wherein the result data may include graph data that may represent the at least one ZK primitive.

[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 graph processor capable of performing a first analysis of graph information that may represent a graph relating to a cause, effect, or event, based on at least one ZK primitive. The computer-executable components may further include a proof generator capable of determining a ZKP relating to the cause, effect, or event based on a second result of a second analysis of result information from a first result of the first analysis, wherein the result information may include primitive information that may represent the at least one ZK primitive.

[0008] In other embodiments, the disclosed subject matter may include a non-transitory machine-readable medium including executable instructions that, when executed by at least one processor, facilitate the execution of operations. The operations may include: performing a first analysis of graph data relating to a cause, effect, or event based on at least one ZK primitive. The operations may further include: generating a ZKP relating to the cause, effect, or event based on a second result of a second analysis of result data from a first result of the first analysis.

[0009] The result data may include metadata of the at least one ZK primitive.

[0010] 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

[0011] Figure 1 A block diagram of a non-limiting example system based on various aspects and embodiments of the disclosed subject matter is shown, which can desirously perform and manage data analysis and the generation of proofs related to such data analysis using graph primitives.

[0012] Figure 2 A block diagram of a non-limiting exemplary proof manager component is shown, which is intended to perform and manage data analysis and the generation of proofs related to such data analysis using primitives, according to various aspects and embodiments of the disclosed subject matter.

[0013] Figure 3A schematic diagram is shown that can represent a non-restricted example directed acyclic graph (DAG) of a non-restricted example dataset according to various aspects and embodiments of the disclosed subject matter.

[0014] Figure 4 A block diagram of a non-limiting example validator manager component is shown, which is intended to verify proofs, which may involve analysis performed on a dataset or information associated with a dataset received from a proof manager component (such as a proof manager component).

[0015] Figure 5 A flowchart is shown of an exemplary method according to various aspects and embodiments of the disclosed subject matter, which can desirously perform and manage data analysis and the generation of proofs related to such data analysis using one or more primitives.

[0016] Figure 6 A flowchart of an example method according to various aspects and embodiments of the disclosed subject matter is shown, which can desirously perform and manage data analysis and the generation of proofs related to such data analysis using primitives, wherein the primitives can facilitate the identification of descendant nodes and ancestor nodes of nodes in the graph.

[0017] Figure 7 A flowchart of an exemplary method according to various aspects and embodiments of the disclosed subject matter is shown, which can desirously perform and manage data analysis and the generation of proofs related to such data analysis using primitives, wherein the primitives can facilitate the determination of whether a graph is acyclic, and the performance of acyclic or cyclic graph processing.

[0018] Figure 8 A flowchart of an exemplary method according to various aspects and embodiments of the disclosed subject matter is shown, which can desirously perform and manage data analysis and the generation of proofs related to such data analysis using primitives, wherein the primitives can facilitate the evaluation of whether a first node subgroup and a second node subgroup of a node group of a graph are d-separated.

[0019] Figure 9 A flowchart illustrating an example method based on various aspects and embodiments of the disclosed subject matter is provided. This method can desirably perform and manage data analysis and the generation of proofs related to such data analysis using primitives, wherein the primitives can facilitate the generation of an interventional graph of the target node of the graph, in order to eliminate or mitigate the impact of other nodes of the graph on the graph.

[0020] The impact of the target node.

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

[0022] 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.

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

[0024] Causal analysis can play a vital and useful role in understanding the relationships and dependencies between variables across a wide range of fields, including, for example, epidemiology, economics, and machine learning. For instance, causal analysis can be a systematic approach aimed at elucidating causal relationships between random variables. At the heart of this analysis can be causal primitives, including graphical and numerical operators. These primitives can facilitate desired (e.g., important, fundamental, or basic) operations, such as, for example, regulation, intervention, and counterfactual reasoning, which can form the basis of advanced causal analysis algorithms. By leveraging causal analysis, researchers and practitioners can gain a comprehensive understanding of complex relationships, leading to more informed decision-making across a wide range of fields, including healthcare, economics, and social sciences.

[0025] However, the expectation (e.g., desire or need) for privacy protection is likely paramount in these analyses, especially when sensitive or personal data is involved, and the increasing emphasis on data privacy can pose significant challenges to causal analysis. In many real-world situations, the data involved, such as patient records or financial information, may be sensitive and subject to stringent privacy regulations. Some existing causal analysis methods may unintentionally and undesirably expose this sensitive or personal data to unauthorized access or breaches, potentially increasing privacy concerns. Even when the raw data is not directly disclosed, intermediate results may still potentially reveal sensitive information about the underlying data, which could pose significant risks.

[0026] In cloud-based environments, users often request service providers to perform causal analysis on private data or causal graphs, which presents an increased need for transparency. Because this information can be stored in the cloud, users frequently demand transparency, insisting that service providers disclose the data or causal graphs. However, service providers may be reluctant to release this information due to concerns about data privacy and trade secrets. For service providers, since such data and causal graphs can represent trade secrets and sensitive information, a scheme is expected that can convincingly demonstrate that the correct data or causal graph is being used for causal analysis while ensuring privacy.

[0027] In response to these challenges, ZKP offers a promising and robust solution because it allows parties to verify the correctness of calculations without revealing the underlying data involved. This can be achieved using ZK circuits, which enable individuals to prove knowledge of certain information without disclosing the information itself. By integrating ZKP into causal analysis frameworks, valuable insights can be extracted from data and causal graphs without compromising sensitive information or trade secrets, thereby fostering trust and compliance in data-driven decision-making. However, existing ZK tools may be imperfect and inefficient when used for causal analysis and certain other types of analysis, and when applying existing general-purpose ZK frameworks to these tasks.

[0028] There is a need for a ZKP generation system, method, and technique (e.g., suitable, beneficial, advantageous, desirable, useful, improved, or optimal) that can address the challenges of performing causal analysis and other types of analysis under ZK conditions, and identifying and generating ZKPs associated with causal analysis and other types of analysis. To this end, a system, method, and technique are proposed to address the challenges of performing causal analysis and other types of analysis under ZK conditions and identifying and generating ZKPs associated with causal analysis and other types of analysis. According to various embodiments, the system may include a proof manager component that can desirably (e.g., automatically, dynamically, appropriately, reliably, efficiently, enhancedly, and / or optimally) manage and perform causal analysis and other types of analysis under ZK conditions, and generate proofs (e.g., ZKPs) associated with causal analysis and other types of analysis. In some embodiments, the proof manager component may include a graph processor component that can perform a first analysis (e.g., causal analysis or other type of analysis) on graph data based at least in part on one or more graph primitives (e.g., one or more ZK primitives), wherein the graph data may represent a graph relating to one or more causes, one or more effects and / or one or more events, wherein the graph may represent a dataset relating to a desired one or more topics or subjects.

[0029] In some embodiments, one or more primitives can be customized (e.g., customized or adapted) to perform causal analysis and / or other desired types of analysis under ZK conditions and in ZK applications. As described herein, one or more primitives may include, for example, a first primitive, a second primitive, a third primitive, a fourth primitive, and / or another desired primitive, wherein the first primitive can be used to identify descendant and ancestor nodes of nodes in a graph (e.g., for each node), the second primitive can determine whether the graph is acyclic and can perform acyclic or cyclic graph processing (e.g., depending in part on whether the graph is acyclic), the third primitive can evaluate whether two subgroups of a node group in a graph (e.g., a DAG) are d-separated, and the fourth primitive can generate an intervention graph for a target node of the graph to eliminate or mitigate (e.g., reduce or minimize) the influence of other nodes in the graph on the target node.

[0030] In some embodiments, the proof manager component may further include a proof generator component that can determine and generate a proof (e.g., ZKP) based at least in part on a second result of a second analysis of the result data of a first analysis (e.g., causal analysis or other types of analysis) and a cryptographic key (e.g., a private encryption key). The proof may include the results of analysis and / or computation relating to one or more causes, one or more results, and / or one or more events, wherein the result data may include graph data that may represent or be associated with one or more graphs used during the analysis and proof generation.

[0031] In some embodiments, the proof manager component may pass a proof (e.g., a ZKP) to a verifier (e.g., a verifier component or device) so that the verifier can verify the correctness of the proof, including verifying the analysis and / or computation results of the proof. For example, the proof may enable the proof manager component to assure the verifier of the correctness (e.g., accuracy) of the computation of the proof (and graph) without revealing the underlying data used to perform the computation, determine, and generate the proof.

[0032] By employing the proof manager components and enhancement techniques described herein (e.g., enhanced analysis (e.g., causal analysis) techniques, enhanced proof generation techniques), the disclosed subject matter can, desirably (e.g., automatically, dynamically, appropriately, reliably, efficiently, enhancedly, and / or optimally), perform analyses (e.g., causal analysis and / or other analyses under ZK conditions) on data (e.g., graphs and / or datasets (e.g., datasets used to generate graphs)) and determine and generate proofs related to the data analysis. By employing the proof manager components and enhancement techniques described herein (e.g., enhanced analysis (e.g., causal analysis) techniques, enhanced proof generation techniques), the disclosed subject matter can also, desirably (e.g., automatically, dynamically, appropriately, reliably, efficiently, enhancedly, and / or optimally) protect personal information, sensitive information, proprietary information (e.g., trade secrets) and / or confidential information from unintended disclosure to other entities, while generating proofs including the results of analyses and calculations relating to such personal information, sensitive information, proprietary information, and / or confidential information, which can be used by another entity or device to verify and trust the correctness of the analysis and calculation results. This enables and facilitates more informed decision-making, which can be based on robust, privacy-focused insights. By employing the proof manager components and enhancement techniques described herein (e.g., enhanced analysis (e.g., causal analysis) techniques, enhanced proof generation techniques), the disclosed subject matter can also be expected (e.g., automatically, dynamically, appropriately, reliably, efficiently, enhancedly, and / or optimally) to result in more efficient implementations of primitives in ZK circuits, which can enhance both the performance and scalability of the systems and processes used for analysis (e.g., causal analysis and / or other analyses) and proof generation.

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

[0034] Now refer to the attached diagram, Figure 1A block diagram of a non-limiting example system 100 according to various aspects and embodiments of the disclosed subject matter is shown, which can desirably (e.g., automatically, dynamically, appropriately, efficiently, reliably, enhancedly, and / or optimally) perform and manage data analysis (e.g., causal analysis, correlation analysis, and / or other types of analysis) and the generation of proofs (e.g., ZKPs) related to such data analysis using primitives (e.g., custom or customized primitives). In some embodiments, system 100 may include a proof manager component 102, which desirably performs and manages data analysis and the generation of proofs (e.g., ZKPs) related to the data analysis. According to various embodiments, proof manager component 102 may be part of or associated with one or more devices (e.g., one or more servers) such as those described herein (e.g., communicatively connected to one or more devices (e.g., one or more servers)). In some embodiments, proof manager component 102 may be derived from one or more devices (e.g., one or more servers). Figure 1 (Not shown in the image) Receives data for processing and analysis.

[0035] According to various embodiments, the proof manager component 102 may include a graph processor component 104 and a proof generator component 106, wherein the graph processor component 104 may include an analysis component 108 and a primitive component 110. In some embodiments, the graph processor component 104, employing the analysis component 108 and the primitive component 110 (e.g., one or more primitives of the primitive component 110), may utilize one or more desired primitives (e.g., one or more custom or customized primitives) to perform analysis (e.g., causal analysis or other analysis) on graph data of one or more graphs that may represent one or more datasets (e.g., one or more data groups) to generate analysis results (e.g., causal analysis results or other results) related to the datasets (one or more datasets), wherein the analysis results relate to generating proofs (e.g., ZKP) related to such analysis and the datasets (one or more datasets) according to established proof management standards as described herein. In some embodiments, the proof generator component 106 may generate proofs (e.g., ZKPs) relating to such analyses and datasets(s) and(s) thereof, wherein the proofs enable a prover (e.g., the proof manager component 102 or an entity associated therewith) to convince a verifier (e.g., a verifier device or an entity associated therewith) of the correctness of the analysis and computation performed when the proof is generated, without revealing the underlying data used in performing the analysis and computation and generating the proof in accordance with established proof management standards such as those described herein.

[0036] According to various embodiments, one or more primitives (e.g., causal primitives) can be used in conjunction with such data analysis (e.g., causal analysis) and the generation of associated proofs, and can be customized and / or designed for causal analysis in applications such as ZK applications, according to established proof management standards. Primitives can include graph operators and numerical operators. Primitives can facilitate desired (e.g., wanted, useful, or important) operations, such as, for example, regulation, intervention, and counterfactual reasoning, which can form the basis of advanced causal analysis algorithms. By leveraging causal analysis, users (e.g., researchers, practitioners, and / or other users) can gain a comprehensive understanding of complex relationships, which can lead to more informed decision-making across a wide range of fields, including healthcare, medicine, science, economics, social sciences, climate, marketing, engineering, manufacturing, and / or another desired field.

[0037] As described herein, one or more primitives may include: for example, a first primitive (e.g., a first ZK primitive and / or an ancestor / descendant identifier primitive) that can be used to identify descendant and ancestor nodes of nodes in a graph (e.g., for each node); a second primitive (e.g., a second ZK primitive and / or an acyclic graph identifier primitive) that can determine whether the graph is acyclic and can perform acyclic or cyclic graph processing (e.g., depending on whether the graph is acyclic); a third primitive (e.g., a third ZK primitive and / or a d-separation identifier primitive) that can evaluate whether two subgroups in a group of nodes in a graph (e.g., a DAG) are d-separated; a fourth primitive (e.g., a fourth ZK primitive and / or an intervention graph that generates primitives) that can generate an intervention graph for a target node in the graph to eliminate or mitigate (e.g., reduce or minimize) the influence of other nodes in the graph on the target node; and / or another desired primitive. In some embodiments, these primitives can be developed by transforming graph operators into matrix algorithms, enhancing computational complexity by leveraging the unique properties of adjacency matrices associated with or otherwise related to causal graphs, as described herein. These primitives (e.g., custom or custom primitives) and the disclosed techniques can lead to computations that are less complex as desired, reduce the verification complexity of matrix computations, result in or yield more efficient implementations of primitives in ZK circuits, enhance the performance and scalability of systems and processes used for analysis (e.g., causal analysis and / or other analyses) and proof generation, and improve the efficiency and applicability of proofs (such as ZKP) in causal analysis and other analyses.

[0038] 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 (e.g., causal analysis results or other analytical results), as described herein. In some embodiments, the device 112 may include a verifier manager component 114 capable of verifying proofs that include computational results (e.g., causal analysis results or other results), said proof relating to a dataset 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 112 (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 causal analysis of data, the techniques and embodiments of the disclosed subject matter related to proof generation can be used or applied to virtually any type of dataset or workflow, which may include relatively large or relatively small datasets or workflows.

[0039] According to various embodiments, the device (e.g., one or more devices including or associated with the proof manager component 102, device 112, or other devices) may be a computer, laptop computer, server, cordless phone, mobile phone 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), device for connected vehicles (e.g., car, airplane, train, rocket, and / or other at least partially automated vehicles (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.

[0040] refer to Figure 2 (together) Figure 1 ), Figure 2A 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 proof manager component 102 can desirously (e.g., automatically, dynamically, appropriately, reliably, efficiently, enhancedly, and / or optimally) perform and manage data analysis (e.g., causal analysis, correlation analysis, and / or other types of analysis) and the generation of primitive-based proofs (e.g., ZKP) associated with such data analysis. According to various embodiments, the proof manager component 102 may include a graph processor component 104, a proof generator component 106, an analysis component 108, a primitive component 110, a proof key component 202, and / or the graph generator component 204. In some embodiments, the proof manager component 102 may include (as shown) a processor component 206 and a data storage 208, or the proof manager component 102 may be associated with (e.g., communicatively connected to) the processor component 206 and the data storage 208. In some embodiments, the proof manager component 102 may store proofs 210 related to the dataset, as well as other required data, in a data storage 208, as described herein. According to various embodiments, the proof manager component 102 may include or be associated with an artificial intelligence (AI) component 212, which may include a trainer component 214 and one or more models 216 (e.g., AI-based models).

[0041] In some embodiments, the proof manager component 102 may receive one or more datasets from another device or retrieve one or more datasets (e.g., previously received and stored datasets) from data storage 208. The datasets may be or may relate to healthcare and / or medicine, science, economics, social sciences, climate (e.g., climate change), marketing, engineering, manufacturing, and / or another desired topic or issue, or may be another type of dataset. 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 datasets (one or more) based at least in part on the results of analysis of the data in the datasets (one or more). In some embodiments, the graph may be a causal graph (e.g., a causal DAG or other causal graph) that can be used in an analysis (e.g., causal analysis or other analysis). In some embodiments, the graph may include groups of nodes, where corresponding nodes may be associated (e.g., connected to corresponding other nodes) with corresponding edges (e.g., connectors), where corresponding edges may have corresponding data dependencies that depend in part on the datasets (one or more). For example, a first node may have an edge associated with its output, and the other end of that edge may be associated with the input of a second node, wherein data output from the first node can be transmitted to the input of the second node via that edge. Each node in a node group may represent or be associated with a specific computational task or operation, wherein the computational task or operation may be performed within the graph (e.g., by the proof manager component 102) on portions of one or more datasets and / or on data generated by other nodes in the node group to determine and generate a proof, including the computational results, at least in part based on the analysis results of one or more datasets.

[0042] Brief reference Figure 3 (together) Figure 1 and Figure 2 ), Figure 3A schematic diagram of a non-limiting example DAG 300 representing a non-limiting example dataset is shown, according to various aspects and embodiments of the disclosed subject matter. In some embodiments, the example DAG 300 may include a group of nodes, which may include nodes 302, 304, 306, 308, and 310. In some embodiments, the example DAG 300 may also include a set of edges, which may include edges 312, 314, 316, 318, and 320, wherein each edge may be associated with a corresponding output of some corresponding node (e.g., connected to a corresponding output) and may be associated with a corresponding input of some other corresponding node, and wherein the arrangement of nodes and edges may be at least partially based on the dataset. It should be understood and appreciated that the number of nodes, the number of edges, the arrangement of nodes, and the arrangement of edges relative to nodes in the example DAG 300 are merely a non-limiting example and depend in part on the corresponding data of the corresponding dataset. A corresponding DAG representing a corresponding dataset may have a corresponding (e.g., different or unique) number of nodes, a corresponding number of edges, a corresponding arrangement of nodes, and a corresponding arrangement of edges relative to nodes.

[0043] Further reference Figure 1 and Figure 2 In some embodiments, the graph processor component 104, employing analysis component 108 and primitive component 110, can perform analysis (e.g., causal analysis or other desired type of analysis) on the graph to generate analysis results (e.g., causal analysis results or other results), wherein the analysis results are related to proof generation (e.g., by proof generator component 106) in accordance with established proof management standards. In some embodiments, primitives, associated proof-related circuitry (e.g., ZK circuitry), and associated operations can be customized to facilitate the desired and efficient performance of causal analysis on data (e.g., graph data of the graph and / or other data) without merging or performing unwanted, irrelevant, and / or inefficient operations. It should be understood and appreciated that, according to various embodiments, the analysis performed by the graph processor component 104 may involve one or more graphs related to or representing one or more datasets, and / or involve utilizing one or more primitives as part of the analysis.

[0044] In some embodiments, a first primitive (e.g., a first ZK and / or ancestor / descendant identifier primitive) may be used to identify descendant and ancestor nodes of each node in a graph (e.g., a causal DAG or other graph). Processing for this first primitive may include graph preprocessing, circuit (e.g., ZK circuit) constraints, matrix inversion, and descendant and ancestor identification. In some embodiments, as part of analysis and preprocessing, with respect to a graph A (e.g., a causal DAG A) representing one or more datasets, graph processor component 104 may determine (e.g., compute) a transformation matrix P outside the circuit such that B = P. -1 AP can lead to an upper triangular matrix B with zero values ​​on its diagonal, where P satisfies the condition: ∑ j p ij =1 and ∑ i p ij =1. In some embodiments, within the circuit, the graph processor component 104 may implement a set of constraints, wherein the set of constraints may include the following constraints: matrix B is an upper triangular matrix with zero values ​​on its diagonal, and matrices P and P -1 The following property can be satisfied: each row and column of the matrix can be summed to a value of 1. Additionally, in some embodiments, the graph processor component 104 can ensure (e.g., in a constraint group) another constraint, namely, that P·P can be satisfied. -1 =I (e.g., using the Freivalds algorithm or other desired techniques or algorithms), where I can be the identity matrix.

[0045] In some embodiments, as part of the analysis, graph processor component 104 (e.g., employing analysis component 108 and primitive component 110) can perform matrix inversion, wherein the graph processor component can determine (e.g., compute) the external (IB) components of the circuit. -1 Furthermore, the Freivalds algorithm can be used to verify constraints within the circuit, i.e., (IB). -1 (IB) = I. In some embodiments, as part of the analysis, the graph processor component 104 can perform descendant and ancestor identification of the nodes in the graph, wherein, in the resulting matrix (IB) -1 If the graph processor component 104 determines that the entry in the i-th row and j-th column is 1, then the graph processor component 104 can determine that node j can be a descendant of node i, which can make node i an ancestor node of node j.

[0046] In some embodiments, for a second primitive (e.g., a second ZK and / or acyclic graph identifier primitive) that can be used to determine whether graph A (e.g., causal graph A) is acyclic and for which acyclic or cyclic graph processing (e.g., depending on whether the graph is acyclic) can be performed, graph processor component 104 (e.g., using analysis component 108 and primitive component 110) can perform processing for the second primitive, which may include cycle detection, acyclic graph processing, and / or cyclic graph processing. In some embodiments, as part of the analysis of graph A, graph processor component 104 may check (e.g., examine or evaluate) whether cycles exist in graph A outside of a circuit.

[0047] In some embodiments, as part of the analysis of the second primitive, if the graph processor component 104 determines that graph A is acyclic, then the graph processor component 104 may determine (e.g., compute) a transformation matrix P such that B = P -1 AP, where B can be an upper triangular matrix with zero values ​​on its diagonal, and the transformation matrix P satisfies the condition ∑ j p ij =1 and ∑ i p ij =1. In some embodiments, within the circuit, the graph processor component 104 may implement a set of constraints (e.g., a set of constraints described with respect to the first primitive), wherein the set of constraints may include the following constraints: matrix B is an upper triangular matrix with zero values ​​on its diagonal, and matrices P and P -1 It can satisfy the following properties: the sum of each row and column of the matrix can be equal to 1, and it can satisfy P·P -1 =I (e.g., using the Freivalds algorithm or other desired techniques or algorithms), where I can be the identity matrix.

[0048] In some embodiments, as part of the analysis of the second primitive, instead of graph processor component 104 determining that graph A is a cycle (e.g., if graph processor component 104 detects a cycle), graph processor component 104 can determine (e.g., calculate) a path that can correspond to one of the cycles outside the circuit, and can enforce the constraint that the path starts and ends at the same node within the circuit.

[0049] In some embodiments, for a given subgroup (e.g., subgroup A and subgroup B) of a node group S in a graph (e.g., a causal DAG) G that can be evaluated as a d-separated third primitive (e.g., a third ZK and / or d-separation identifier primitive), the graph processor component 104 (e.g., employing the analysis component 108 and the primitive component 110) can perform processing for that third primitive, which may include graph pruning, moralization, node removal, and / or path testing. In some embodiments, as part of the analysis, with respect to a graph G (e.g., a causal DAG) representing one or more datasets and node subgroups A, B, and S of the graph, the graph processor component 104 can perform graph pruning to remove all nodes that can be determined not to be in the ancestor group (e.g., ancestor set) A∪B∪S, to obtain (e.g., generate or realize) a subgraph G. ancestor (A∪B∪S)(For example, ancestor subgraph G) ancestor ).

[0050] In some embodiments, as part of the analysis, the graph processor component 104 may process the remaining graph (e.g., the ancestor subgraph G) ancestor Perform moralization to generate (e.g., produce) a moral subgraph (G). ancestor (A∪B∪S)) m In some embodiments, the graph processor component 104 and the third primitive can determine (e.g., calculate) GG T To obtain (e.g., generate) G′ to implement or perform the generation of the moral subgraph, and to verify the condition G′ = GG using, for example, the Freivalds algorithm. T G T This can be the transpose of matrix G (e.g., the transpose of a matrix (e.g., an adjacency matrix) representing graph G). In some embodiments, graph processor component 104 and the third primitive can set edges in graph G that correspond to non-zero positions in G′ to a value of 1 to form a moral graph while adding appropriate constraints. In some embodiments, regarding constraints, let It is an indicator function, when x = 0. It can be equal to 1 when x ≠ 0. It can be equal to 0, and the constraint can be expressed as:

[0051] In some embodiments, as part of the analysis, the graph processor component 104 can analyze the moral subgraph (G). ancestor (A∪B∪S)) m Remove all nodes from group S to generate subgraph G″ and the desired constraint group by setting the corresponding rows and columns to zero. The desired constraint group may include, for example, for i in group S, ((G ancesroe (A∪B∪S))m ) i,: =0 and ((G ancestor (A∪B∪S)) m ) :,i = 0. These constraints ensure that whenever i ∈ S, the entire i-th column and i-th row can be 0. In some embodiments, as part of the analysis, the graph processor component 104 can perform path testing, wherein G″′ = G″ + ... + G″ is determined (e.g., calculated). n Simultaneously, by using, for example, the Freivalds algorithm to add and enforce constraints for this operation, the graph processor component 104 can test (e.g., check, verify, or evaluate) whether there is a path between node subgroups A and B in subgraph G″, where n can be a desired value, and such constraints can include G″′ for i from 1 to n-1. (i+1) =G″ i ·G, and G″′=G″+...+G″ n In some embodiments, if the graph processor component 104 determines that any entry in the i-th row and j-th column of the subgraph (or corresponding matrix) G″′ is a non-zero value, this may indicate the existence of a path from node i to node j (e.g., a path may exist between node i and node j), and the graph processor component 104 may determine that there is no d-separation between node subgroup A and node subgroup B. Conversely, if the graph processor component 104 determines that there is no such path (e.g., no entry in the i-th row and j-th column of the subgraph (or corresponding matrix) G″′), this may indicate or confirm that a d-separation may exist between node subgroup A and node subgroup B, and the graph processor component 104 may determine that a d-separation may exist between node subgroup A and node subgroup B.

[0052] In some embodiments, a fourth primitive (e.g., a fourth ZK and / or intervention graph generation primitive) can be used to generate an intervention graph for target nodes s of the graph to facilitate the elimination or mitigation of the influence of other nodes on target nodes s. For example, as part of the analysis, the graph processor component 104 (e.g., employing the analysis component 108 and the primitive component 110) can modify the adjacency matrix associated with the graph (e.g., a causal DAG) by setting entries in the columns corresponding to the target nodes s in the adjacency matrix to zero values, where the modification of the adjacency matrix can facilitate the elimination or mitigation of the influence of other nodes in the graph on target nodes s. In some embodiments, the graph processor component 104 can add one or more constraints to ensure that the modification of the adjacency matrix can be implemented within the ZK circuit. Regarding the one or more constraints, let the adjacency matrix associated with the graph be G, then the one or more constraints may include, for example, G :,s =0.

[0053] In some embodiments, at least in part based on the results of analysis (e.g., causal analysis or other analysis) of one or more graphs representing one or more datasets, the proof generator component 106, utilizing one or more primitives and / or combining such analysis, can determine and generate proofs (e.g., ZKPs) according to established proof management standards. These proofs (e.g., ZKPs) include results (e.g., computational results) that are related to and / or represent the results of the analysis. For example, at least in part based on the analysis results and a cryptographic key (e.g., a private encryption key), the proof generator component 106 can determine and generate proofs that include results related to and / or represent the results of the analysis. The proofs can be used to convince a verifier (e.g., a verifier device (e.g., 112) or an associated entity) of the correctness of the analysis and computation performed when generating the proof, without revealing the underlying data used in performing the analysis and computation.

[0054] In some embodiments, the proof manager component 102 may transmit a proof including the result (e.g., a ZKP) to device 112 (e.g., a verifier device) for verification and obtain and / or utilize (e.g., further process or otherwise utilize) the result. Figure 4 (together) Figures 1 to 3 ), Figure 4 A block diagram of a non-limiting example validator manager component, based on various aspects and embodiments of the disclosed subject matter, is shown. This component is intended to (e.g., automatically, dynamically, appropriately, efficiently, reliably, enhancedly, and / or optimally) verify proofs received from a proof manager component (such as proof manager component 102), the proofs potentially involving analysis (e.g., causal analysis or other analysis) performed on a dataset or information associated with it (e.g., a graph representing the dataset). In some embodiments, validator manager component 114 may include a validator key component 402 and a validator component 404. In some embodiments, validator manager component 114 may include a processor component 406 and a data storage 408, or be associated with a processor component 406 and a data storage 408.

[0055] In some embodiments, verifier component 404 may verify the correctness of a received proof at least in part based on the results of analyzing (e.g., evaluating) the proof, including verifying the results of the proof (e.g., computational results). In some embodiments, the proof including the results may be protected (e.g., encrypted using a cryptographic key of the proof key component 202 of proof manager component 102). According to such embodiments, verifier component 404 may utilize the cryptographic key of verifier key component 402 (e.g., a decryption key, which may be a public decryption key) to decrypt the information of the proof (e.g., encrypted information) and facilitate the verification of the proof including the results. 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 the proof (e.g., the proof key component 202 of proof manager component 102). Verifier component 404 may verify the correctness of the proof, including verifying the results of the proof, at least in part based on the results of analyzing the proof and / or the decryption of the proof. For example, a proof could enable the proof manager component 102 to assure the verifier component of the correctness (e.g., accuracy) of the results of a proof relating to computation (e.g., underlying computation) and analysis of the underlying data (e.g., causal analysis or other analysis) (e.g., results accessible to the verifier component 404), without revealing (e.g., by preventing, prohibiting, and / or disallowing the disclosure) the underlying data (e.g., private, secure, and / or proprietary data) or intermediate analysis data of the dataset used to perform the computation and to determine and generate the proof. That is, by successfully verifying a proof including the results, the verifier component 404 can have a confidence that the proof including the results and the underlying computation is correct, even if the verifier component 404 may not have access to the underlying data to independently verify the proof including the results and the underlying computation using the underlying data.

[0056] Further information Figure 2According to various embodiments, AI component 212 and / or model 216 can perform AI-based analysis on data such as information and / or feedback information (e.g., feedback from a user, device, or another data source) relating to datasets (e.g., data analysis streams or other datasets), graphs, subgraphs, matrices, circuits (e.g., ZK circuits), proofs, computational tasks, computation results, hash values, applications, services, attributes, operations, functions, parameters, events, and / or other types of data. In some embodiments, with respect to model 216, AI component 212 can input such information into (trained) model 216 for analysis by model 216 (e.g., AI-based analysis) to update model 216 or generate output results (e.g., AI-related data relating to graphs, subgraphs, matrices, circuits, proofs, computational tasks, computation results, and / or other output results) based at least in part on the analysis of the input information.

[0057] In conjunction with or as part of such AI-based analytics, AI component 212 can employ, construct (e.g., build or create) and / or import AI-based technologies and algorithms, AI-based models 216 (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 correlations, relationships, or causal relationships (e.g., (a) ...) between one or more data items and another data item. The following functions are employed: determining or learning the correlation, relationship, or causal relationship between an event and another event (e.g., the occurrence of another event); determining or learning patterns related to performing graph analyses (e.g., causal analysis, correlation analysis, and / or other analyses) that may represent a dataset; determining or learning patterns related to the use of graph primitives that may represent a dataset; determining or learning patterns related to determining and generating proofs that may represent a dataset; determining or learning patterns related to computational tasks associated with graphs, subgraphs, and / or matrices; performing other desired functions or operations; and / or automating one or more functions or features of the disclosed subject matter, as described more fully herein.

[0058] AI component 212 can employ various AI-based approaches 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 212 can examine all or a subset of data granted access (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 can 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 can be employed to identify specific contexts or actions, or a probability distribution of states can be generated. This determination can be probabilistic; that is, calculating the probability distribution of states of interest based on considerations of data and events. Determination can also refer to techniques used to construct higher-level events based on a set of events and / or data.

[0059] In some embodiments, regarding probabilities, AI component 212 and / or (one or more) trained models 216 may employ one or more threshold probabilities (e.g., threshold probability values) to facilitate determination. For example, when making determinations (e.g., determinations related to causal analysis (e.g., determination of (one or more) causes and (one or more) effects), determination of which primitive to use in conjunction with causal analysis or other types of analysis, or other determinations), as part of AI-based information analysis, AI component 212 and / or (one or more) trained models 216 may determine probabilities (e.g., the probability that a first event, state, or variable is a cause of the occurrence of a second event, state, or variable, the probability that using (one or more) specific primitives is more useful or advantageous than (one or more) other primitives, or other probabilities), and may determine whether that probability (e.g., probability value) satisfies (e.g., conforms to or exceeds; or is equal to or greater than) a defined and applicable threshold probability. AI component 212 and / or (one or more) trained models 216 may make determinations (or predictions or inferences) at least in part based on the results of analyzing (e.g., comparing) probabilities with defined and applicable threshold probabilities (e.g., a minimum threshold probability value). This determination (or prediction or inference) may include whether a first event, state, or variable is the cause of a second event, state, or variable, whether the utilization of (one or more) particular primitives is more useful or advantageous than that of other primitives, or other determinations (or predictions or inferences)). As a non-limiting example, AI component 212 and / or (one or more) trained models 216 may make a determination (or prediction or inference) that a first event, state, or variable is the cause of a second event, state, or variable based at least in part on the probability that the first event, state, or variable is the cause of the second event, state, or variable satisfying a defined and applicable threshold probability (e.g., the highest probability relative to other probabilities concerning whether another event, state, or variable is the cause of the second event, state, or variable). In other embodiments, the AI ​​component 212 and / or one or more trained models 216 may make a determination (or prediction or inference) that the first event, state, or variable is the cause of the second event, state, or variable based at least in part on the probability that the first event, state, or variable is the cause of the second event, state, or variable being ...

[0060] 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 actions and / or determining 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.

[0061] In some embodiments, AI component 212 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 certain class, such as by f(z) = confidence(class). This classification can employ probability-based and / or statistical-based 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.

[0062] In some embodiments, AI component 212 (e.g., employing trainer component 214) may include, generate, and / or train (e.g., iteratively train) an AI-based model 216, which may be trained to learn, identify, predict, or infer data patterns in data; correlations, relationships, or causal relationships between (one or more) data items (or events associated with them) and (one or more) other data items (e.g., the occurrence of (one or more) other data items or other events associated with them); correlations, relationships, or causal relationships between an event and another event (e.g., the occurrence of another event); relationships between (one or more) first variables and (one or more) second variables (e.g., causal relationships or other relationships); relationships between the use of (one or more) specific primitives during data analysis (e.g., causal analysis of (one or more) graphs) and the results of the data analysis (e.g., the accuracy of the results); 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.

[0063] Further regarding the processor component 206 and data storage 208 of the proof manager component 102, or the processor component 206 and data storage 208 associated with the proof manager component 102, the processor component 206 may be associated with (e.g., communicatively connected to) other components of the proof manager component 102 and / or system 100 and may operate in conjunction with other components of the proof manager component 102 and / or system 100 to perform various functions and operations of the proof manager component 102 and / or system 100, wherein said other components include graph processor component 104, proof generator component 106, proof key component 202, graph generator component 204, data storage 208, AI component 224, and / or other components of the proof manager component 102 and / or system 100. Processor component 206 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, matrices, circuits (e.g., ZK circuits or other proof circuits), computational tasks, cryptographic keys, proofs (e.g., 210), computation results, services, applications, AI-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, and messages. Information such as notifications, alerts, warnings, preferences (e.g., user or client preferences), hash values, metadata, hyperparameters, parameters, tables, mappings, policies, established proof management standards, algorithms (e.g., enhanced graph processing algorithms, enhanced primitive algorithms, enhanced proof generation management 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., device 112 or other devices, network devices or components, communication networks, servers, nodes, applications, services, users, or other entities).

[0064] Data storage 208 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, matrices, circuits (e.g., ZK circuits or other proof circuits), computational tasks, cryptographic keys, proofs (e.g., 210), computation results, services, applications, AI-based models, AI-related data, training data, feedback information, updates, predictions, inferences, thresholds (e.g., maximum...). Information related to the proof manager component 102 and / or system 100, including: maximum value, minimum value, 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; established proof management standards; algorithms (e.g., enhanced graph processing algorithms, enhanced primitive algorithms, enhanced proof generation management 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 control or execution of operations associated with the proof manager component 102 and / or system 100. Data storage 208 may include volatile and / or non-volatile memory, such as that described herein. In one aspect, processor component 206 may (e.g., via a memory bus) be functionally coupled to data storage 208 to store and retrieve information for desired operations and / or at least partially enable functionality to graph processor component 104, proof generator component 106, proof key component 202, graph generator component 204, processor component 206, data storage 208, AI component 212 and / or proof manager component 102 and / or other components of system 100, and / or any other substantially any operational aspect of proof manager component 102 and / or system 100.

[0065] Data storage 208 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 may act as an external cache memory. 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.

[0066] Further regarding the processor component 406 and data storage 408 of the validator manager component 114, or the processor component 406 and data storage 408 associated with the validator manager component 114, the processor component 406 may be associated with (e.g., communicatively connected to) the validator manager component 114 and / or other components of the system 100 and may operate in conjunction with the validator manager component 114 and / or other components of the system 100 to perform various functions and operations of the validator manager component 114 and / or the system 100, wherein said other components include the validator key component 402, the validator component 404, the data storage 408 and / or other components of the validator manager component 114 and / or the system 100. Processor component 406 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, established proof management standards, 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 114 and / or system 100, and to control data flow between verifier manager component 114 and / or other components associated with verifier manager component 114 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).

[0067] Data storage 408 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, computation results, 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, mappings, policies, established proof management standards, algorithms (e.g., proof verification and management algorithms, hashing algorithms, data compression algorithms, data decompression algorithms, and / or other algorithms), interfaces, protocols, tools, and / or other information to control or perform operations associated with verifier manager component 114 and / or system 100. Data storage 408 may include volatile and / or non-volatile memory, such as that described herein. On one hand, processor component 406 may be functionally coupled to data storage 408 (e.g., via a memory bus) to store and retrieve information for desired operation and / or at least partially enable functionality to validator key component 402, validator component 404, processor component 406, data storage 408 and / or validator manager component 114 and / or other components of system 100, and / or validator manager component 114 and / or substantially any other operational aspect of system 100.

[0068] It should be understood and complied with that one or more components of the system (e.g., system 100 or other systems) or method described herein (e.g., proof manager component 102, device 112, verifier manager component 114, (one or more) servers) 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 facilitate the presentation of information to users, entities, or other components (e.g., other devices or other servers), and / or the performance of other desired functions or operations.

[0069] The aforementioned systems and / or devices have already been described with respect 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.

[0070] Given the example systems and / or devices described herein, reference may be made to Figures 5 to 9 The flowcharts in the document are provided to further understand the example methods that can be implemented according to the disclosed subject matter. For the purpose of 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, the methods disclosed herein may alternatively 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. In addition, 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 to facilitate the transfer and transmission of these methods to a computer for execution by a processor or storage in memory.

[0071] Figure 5 A flowchart of an example method 500 according to various aspects and embodiments of the disclosed subject matter is shown. This method can desirously (e.g., automatically, dynamically, appropriately, efficiently, reliably, enhancedly, and / or optimally) perform and manage data analysis (e.g., causal analysis, correlation analysis, and / or other types of analysis) and the generation of proofs (e.g., ZKPs) related to such data analysis using one or more primitives (e.g., custom or tailored primitives). Method 500 can be adopted by a system that may include a proof manager component, which may include a processor component, a data store, and / or other components or associated therewith, wherein the proof manager component may include a graph processor component and a proof generator component.

[0072] At 502, a first analysis of graph data, wherein the graph data represents a graph relating to one or more causes, one or more effects, and / or one or more events, can be performed, at least in part, based on at least one ZK primitive. In some embodiments, the graph processor component can perform a first analysis (e.g., causal analysis) of graph data representing a graph (e.g., a causal graph or a causal DAG) relating to one or more causes, one or more effects, and / or one or more events, at least in part, based on at least one ZK primitive. The at least one ZK primitive may include: a first ZK primitive that can identify descendant and ancestor nodes of nodes in the graph; a second ZK primitive that can determine that the graph is acyclic and perform acyclic or cyclic graph processing; a third ZK primitive that can evaluate whether two subgroups in a group of nodes in the graph are d-separated; a fourth ZK primitive that can generate an intervention graph for a target node of the graph; and / or another desired ZK primitive, such as those described herein.

[0073] At 504, a ZKP related to one or more causes, effects, and / or events can be determined based at least in part on a second result of a second analysis of the result data of a first result of a first analysis, wherein the result data may include graph data representing at least one ZK primitive or related to at least one ZK primitive. For example, a proof generator component can determine and generate a ZKP related to one or more causes, effects, and / or events based at least in part on a second result of a second analysis of the result data of a first result of a first analysis. The result data may include graph data representing at least one ZK primitive or relating to at least one ZK primitive and / or other result data obtained from the first analysis.

[0074] Figure 6 A flowchart of an example method 600 according to various aspects and embodiments of the disclosed subject matter is shown. This method can desirably (e.g., automatically, dynamically, appropriately, efficiently, reliably, enhancedly, and / or optimally) perform and manage data analysis (e.g., causal analysis, correlation analysis, and / or other types of analysis) and the generation of proofs (e.g., ZKP) related to such data analysis using primitives, wherein the primitives can facilitate the identification of descendant and ancestor nodes of nodes in the graph. Method 600 can be employed by, for example, a system that may include a proof manager component, which may include a processor component, a data store, and / or other components or associated therewith, wherein the proof manager component may include a graph processor component and a proof generator component.

[0075] At 602, a first analysis of graph data representing a graph relating to one or more causes, one or more effects, and / or one or more events can be performed, at least in part, based on graph primitives (e.g., ZK primitives) that can identify descendant and ancestor nodes of nodes in the graph. In some embodiments, the graph processor component can perform a first analysis (e.g., causal analysis) of graph data representing a graph (e.g., a causal graph or a causal DAG) relating to one or more causes, one or more effects, and / or one or more events, at least in part, based on ZK primitives that can identify descendant and ancestor nodes of nodes in the graph.

[0076] In 604, as part of a first analysis utilizing primitives, matrix transformations can be applied to convert a graph (e.g., a causal DAG) into an upper triangular matrix outside a ZK circuit, wherein the correctness of matrix transformations within the ZK circuit can be ensured at least in part based on a set of circuit constraints, as described herein. A graph processor component can apply matrix transformations to a graph (e.g., graph data representing a graph) to convert a graph (e.g., a causal DAG) into an upper triangular matrix outside a ZK circuit, wherein the correctness of matrix transformations within the ZK circuit can be ensured at least in part based on a set of circuit constraints, as described herein.

[0077] At 606, as part of a first analysis utilizing primitives, the inverse of the difference between the identity matrix and the upper triangular matrix outside the ZK circuit can be determined, wherein the correctness of the constraints relating to this determination of the interior of the ZK circuit can be verified. For example, the graph processor component can determine (e.g., compute) the inverse of the difference between the identity matrix and the upper triangular matrix outside the ZK circuit, at least in part, based on the results of analyzing the upper triangular matrix and the identity matrix. In some embodiments, the graph processor component can verify the correctness of the constraints relating to such a determination by utilizing (e.g., applying) an algorithm such as the Freivalds algorithm described herein.

[0078] At 608, as part of a first analysis utilizing graph primitives, and in the resulting matrix related to the matrix inversion of the identity matrix and the upper triangular matrix, the corresponding descendant nodes and corresponding ancestor nodes associated with the corresponding nodes of the graph can be identified. In some embodiments, in or based on the resulting matrix, the graph processor component can identify (e.g., determine) the corresponding descendant nodes and corresponding ancestor nodes associated with the corresponding nodes of the graph (e.g., a causal DAG), as described herein.

[0079] At 610, a proof (e.g., ZKP) relating to one or more causes, effects, and / or events can be determined at least in part based on a cryptographic key and a second result of a second analysis of the result data of the first result of the first analysis, wherein the result data may include graph data representing or relating to a primitive, the graph data including information relating to the corresponding descendant nodes and ancestor nodes associated with the corresponding nodes of the graph. For example, the proof generator component may determine and generate a ZKP relating to one or more causes, effects, and / or events based at least in part on a cryptographic key (e.g., a private encryption key) and a second result of a second analysis of the result data of the first result of the first analysis. The result data may include graph data representing or relating to a primitive and / or other result data obtained from the first analysis, wherein the graph data may at least in part relate to the corresponding descendant nodes and ancestor nodes associated with the corresponding nodes of the graph.

[0080] Figure 7 A flowchart of an example method 700 according to various aspects and embodiments of the disclosed subject matter is shown. This method can desirably (e.g., automatically, dynamically, appropriately, efficiently, reliably, enhancedly, and / or optimally) perform and manage data analysis (e.g., causal analysis, correlation analysis, and / or other types of analysis) and the generation of proofs (e.g., ZKP) related to such data analysis using primitives, wherein the primitives can facilitate the determination of whether a graph is acyclic and the performance of acyclic or cyclic graph processing. Method 700 can be employed by, for example, a system that may include a proof manager component, which may include a processor component, a data store, and / or other components or associated therewith, wherein the proof manager component may include a graph processor component and a proof generator component.

[0081] At 702, a first analysis of graph data representing a graph relating to one or more causes, one or more effects, and / or one or more events can be performed at least partially based on primitives (e.g., ZK primitives), wherein the primitives can determine whether the graph is acyclic and perform acyclic or cyclic graph processing. In some embodiments, the graph processor component can perform a first analysis (e.g., causal analysis) of graph data representing a graph (e.g., a causal graph or causal DAG) relating to one or more causes, one or more effects, and / or one or more events, wherein the primitives can determine whether the graph is acyclic and perform acyclic or cyclic graph processing.

[0082] At 704, as part of a first analysis utilizing primitives, cycle detection can be performed on the graph outside the ZK circuit. In some embodiments, the graph processor component can perform cycle detection on the graph outside the ZK circuit. For example, the graph processor component can check for the presence of cycles in the graph outside the ZK circuit.

[0083] At 706, as part of a first analysis utilizing primitives, the determination of whether a graph is acyclic or cyclic can be based at least in part on the execution of cycle detection. In some embodiments, the graph processor component can determine whether a graph is acyclic or cyclic based at least in part on the results of performing cycle detection on the graph outside the ZK circuitry.

[0084] As part of a first analysis utilizing primitives, if it is determined that the graph is acyclic, then at 708, a matrix transformation can be applied to convert the graph into an upper triangular matrix outside a ZK circuit, wherein the correctness of the matrix transformation within the ZK circuit can be ensured at least in part based on a set of circuit constraints. In some embodiments, the graph processor component can apply a matrix transformation to a graph (e.g., graph data representing the graph) to convert the graph (e.g., a causal DAG) into an upper triangular matrix outside a ZK circuit, wherein the correctness of the matrix transformation within the ZK circuit can be ensured at least in part based on a set of circuit constraints, as described herein. In some embodiments, at this point, method 700 can proceed to reference numeral 714 and can continue from that point.

[0085] Referring again to reference 706, as part of a first analysis using the primitives, conversely, if it is determined at 706 that the graph is cyclic, then at 710, a path corresponding to a cycle outside the ZK circuit can be determined. If the graph processor component determines that the graph is cyclic (e.g., a causal cyclic graph), then the graph processor component can determine (e.g., compute) a path corresponding to a cycle outside the ZK circuit.

[0086] At 712, as part of a first analysis utilizing primitives, a constraint can be implemented that the path begins and ends at the same node within the ZK circuit. In some embodiments, the graph processor component can implement the constraint that the path begins and ends at the same node within the ZK circuit. In some embodiments, at this point, method 700 can proceed to reference numeral 714 and can continue from that point.

[0087] At 714, a proof (e.g., ZKP) relating to one or more causes, effects, and / or events can be determined at least in part based on a cryptographic key and a second result of a second analysis of the result data of the first result of the first analysis, wherein the result data may include graph data representing or relating to primitives, which may include information relating to acyclic or cyclic graph processing, such as that described herein (e.g., as described herein with respect to reference numerals 708, 710, and 712, and / or as described herein). For example, a proof generator component may determine and generate a ZKP relating to one or more causes, effects, and / or events based at least in part on a cryptographic key (e.g., a private encryption key) and a second result of a second analysis of the result data of the first result of the first analysis. The result data may include graph data representing or relating to primitives and / or other result data obtained according to the first analysis, wherein the graph data may at least in part relate to acyclic or cyclic graph processing.

[0088] Figure 8A flowchart of an example method 800 according to various aspects and embodiments of the disclosed subject matter is shown. This method can desirably (e.g., automatically, dynamically, appropriately, efficiently, reliably, enhancedly, and / or optimally) perform and manage data analysis (e.g., causal analysis, correlation analysis, and / or other types of analysis) and the generation of proofs (e.g., ZKP) related to such data analysis using primitives, wherein the primitives can facilitate the evaluation of whether a first and second subgroup of nodes in a graph's node group are d-separated. Method 800 can be employed by, for example, a system that may include a proof manager component, which may include a processor component, a data store, and / or other components or associated therewith, wherein the proof manager component may include a graph processor component and a proof generator component.

[0089] At 802, a first analysis of graph data representing a graph relating to one or more causes, one or more effects, and / or one or more events can be performed at least partially based on primitives (e.g., ZK primitives), wherein the primitives can evaluate whether a first subgroup and a second subgroup of nodes in the graph are d-separated. In some embodiments, the graph processor component can perform a first analysis (e.g., causal analysis) of graph data representing a graph (e.g., a causal DAG) relating to one or more causes, one or more effects, and / or one or more events, at least partially based on primitives, wherein the primitives can evaluate whether a first subgroup and a second subgroup of nodes in the graph are d-separated.

[0090] At 804, as part of a first analysis utilizing graph primitives, certain nodes identified as not being in the ancestor groups of nodes can be removed to obtain an ancestor subgraph, wherein the ancestor groups of nodes can be determined at least in part based on union operations on the first subgroup of nodes, the second subgroup of nodes, and the node group. In some embodiments, the graph processor component can determine the ancestor groups of nodes at least in part based on the results of performing union operations on the first subgroup of nodes, the second subgroup of nodes, and the node group. Based at least in part on the results of analyzing the ancestor groups of nodes, the first subgroup of nodes, the second subgroup of nodes, and / or the node group, the graph processor component can determine certain nodes not in the ancestor groups of nodes. The graph processor component can remove these specific nodes to generate an ancestor subgraph, which may include the ancestor groups of nodes.

[0091] At 806, as part of a first analysis utilizing primitives, moralization can be applied to the ancestor subgraph to generate a moralized ancestor subgraph. In some embodiments, the graph processor component can apply moralization to the ancestor subgraph to generate a moralized ancestor subgraph, as described herein. In some embodiments, the graph processor component can verify the moralized ancestor subgraph by leveraging (e.g., applying) an algorithm such as the Freivalds algorithm described herein. In some embodiments, the graph processor component can add and / or implement certain constraints for the moralized ancestor subgraph, as described herein.

[0092] At 808, as part of a first analysis utilizing primitives, the moralized ancestor subgraph can be transformed into a matrix, wherein the correctness of the moralized ancestor subgraph can be verified within a ZK circuit, at least in part, based on a first set of constraints. In some embodiments, the graph processor component can transform the moralized ancestor subgraph into a matrix and can verify the correctness of the moralized ancestor subgraph within a ZK circuit, as described herein, at least in part, based on a first set of constraints.

[0093] At 810, as part of a first analysis utilizing primitives, the existence of d-separation between the first and second node subgroups can be determined, at least in part, based on the result of determining, using matrix operations, whether any path exists between the corresponding nodes of interest in the first and second node subgroups. A second set of constraints can be implemented within the ZK circuit to verify the correctness of the matrix operations. In some embodiments, the graph processor component can determine, at least in part, the existence of d-separation between the first and second node subgroups, based on the result of determining, using matrix operations, whether any path exists between the corresponding nodes of interest in the first and second node subgroups. In some embodiments, the graph processor component (e.g., employing the Freivalds algorithm) can implement a second set of constraints within the ZK circuit to verify the correctness of the matrix operations.

[0094] At 812, as part of a first analysis utilizing graph primitives, if it is determined that no path exists between the corresponding nodes of interest, a d-separation can be determined between the first node subgroup and the second node subgroup. For example, if the graph processor component determines that no path exists between the corresponding nodes of interest, the graph processor component can determine that a d-separation exists between the first node subgroup and the second node subgroup. In some embodiments, at this point, method 800 may proceed to reference numeral 816 and may continue from that point.

[0095] Referring again to reference numeral 810, as part of a first analysis utilizing primitives, conversely, if it is determined at 810 that at least one path exists between the respective nodes of interest, then at 814, it can be determined that there is no d-separation between the first node subgroup and the second node subgroup. For example, if the graph processor component determines that at least one path exists between the respective nodes of interest, the graph processor component can determine that there is no d-separation between the first node subgroup and the second node subgroup. In some embodiments, at this point, method 800 may proceed to reference numeral 816 and may continue from that point.

[0096] In 816, a proof (e.g., ZKP) relating to one or more causes, effects, and / or events can be determined at least in part based on a cryptographic key and a second result of a second analysis of the result data of a first analysis of a first analysis, wherein the result data may include graph data representing or relating to primitives, which may include information relating to the existence of d-separation between a first node subgroup and a second node subgroup, as described herein. For example, a proof generator component may determine and generate a ZKP relating to one or more causes, effects, and / or events based at least in part on a cryptographic key (e.g., a private encryption key) and a second result of a second analysis of the result data of a first analysis of a first analysis of a first analysis of a first analysis. The result data may include graph data representing or relating to primitives and / or other result data obtained from the first analysis, wherein the graph data may at least in part relate to and / or indicate the existence of d-separation between a first node subgroup and a second node subgroup.

[0097] Figure 9 A flowchart of an example method 900 according to various aspects and embodiments of the disclosed subject matter is shown. This method can desirably (e.g., automatically, dynamically, appropriately, efficiently, reliably, augmentingly, and / or optimally) perform and manage data analysis (e.g., causal analysis, correlation analysis, and / or other types of analysis) and the generation of proofs (e.g., ZKPs) related to such data analysis using primitives, wherein the primitives can facilitate the generation of intervention graphs of target nodes in order to eliminate or mitigate the influence of other nodes in the graph on the target nodes. Method 900 can be employed by, for example, a system that may include a proof manager component, which may include a processor component, a data store, and / or other components or associated therewith.

[0098] At 902, a first analysis of graph data representing a graph relating to one or more causes, effects, and / or events can be performed by generating intervention graph primitives (e.g., ZK primitives) at least in part based on the target nodes of the graph. In some embodiments, the graph processor component can generate intervention graph primitives at least in part based on the target nodes of the graph to perform a first analysis (e.g., causal analysis) of graph data representing a graph relating to one or more causes, effects, and / or events (e.g., a causal DAG).

[0099] At 904, as part of a first analysis utilizing graph primitives, the adjacency matrix associated with the graph can be modified to eliminate or mitigate the influence of other nodes in the graph on the target node. In some embodiments, the graph processor component can modify the adjacency matrix associated with the graph (e.g., to generate an intervention graph for the target node) to eliminate or mitigate the influence of other nodes in the graph on the target node. For example, the graph processor component can modify the adjacency matrix by setting the entries in the column corresponding to the target node in the adjacency matrix to zero.

[0100] In 906, as part of the first analysis utilizing primitives, one or more constraints can be added to ensure that modifications to the adjacency matrix can be implemented within a ZK circuit. For example, a graph processor component can add one or more constraints to ensure that modifications to the adjacency matrix can be implemented within a ZK circuit.

[0101] At 908, a proof (e.g., ZKP) relating to one or more causes, effects, and / or events can be determined at least in part based on a cryptographic key and a second result of a second analysis of the result data of the first result of the first analysis. The result data may include graph metadata representing or relating to graph elements, which may include information relating to modifications to the adjacency matrix associated with the graph to eliminate or mitigate the influence of other nodes in the graph on the target node. In some embodiments, the proof generator component may determine and generate a ZKP relating to one or more causes, effects, and / or events based at least in part on a cryptographic key (e.g., a private encryption key) and a second result of a second analysis of the result data of the first result of the first analysis. The result data may include graph metadata representing or relating to graph elements and / or other result data obtained from the first analysis, where the graph metadata may at least in part relate to modifications to the adjacency matrix associated with the graph (e.g., to generate an intervention graph for the target node) to eliminate or mitigate the influence of other nodes in the graph on the target node.

[0102] To provide additional context for the various embodiments described herein, Figure 10The following discussion is intended to provide a brief, general description of a suitable computing environment 1000 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.

[0103] 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.

[0104] 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.

[0105] 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 both 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 may 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.

[0106] 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.

[0107] 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.

[0108] 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 signals whose one or more characteristics are set or altered in a manner that encodes 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.

[0109] Refer again Figure 10 An example environment 1000 for implementing various embodiments of the aspects described herein includes a computer 1002, which includes a processing unit 1004, a system memory 1006, and a system bus 1008. The system bus 1008 couples system components, including but not limited to the system memory 1006, to the processing unit 1004. The processing unit 1004 can be any of a variety of commercially available processors. Dual-microprocessor and other multiprocessor architectures may also be used as the processing unit 1004.

[0110] System bus 1008 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 1006 includes ROM 1010 and RAM 1012. 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 such as those that help pass information between components within computer 1002 during startup. RAM 1012 may also include high-speed RAM (such as static RAM) for caching data.

[0111] Computer 1002 also includes an internal hard disk drive (HDD) 1014 (e.g., EIDE, SATA), one or more external storage devices 1016 (e.g., floppy disk drive (FDD) 1016, memory stick or flash drive reader, memory card reader, etc.), and an optical disc drive 1020 (e.g., capable of reading from or writing to CD-ROMs, DVDs, BDs, etc.). Although the internal HDD 1014 is shown as being located within computer 1002, the internal HDD 1014 can also be configured for use outside a suitable chassis (not shown). Additionally, although not shown in environment 1000, a solid-state drive (SSD) may be used in addition to or in place of HDD 1014. HDD 1014, one or more external storage devices 1016, and optical disc drive 1020 can be connected to system bus 1008 via HDD interface 1024, external storage interface 1026, and optical disc drive interface 1028, respectively. The interface 1024 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.

[0112] The drive and its associated computer-readable storage medium provide non-volatile storage of data, data structures, computer-executable instructions, etc. For computer 1002, the drive and storage medium accommodate any data stored in a suitable digital format. Although the above description of computer-readable storage media refers to a corresponding type of storage device, 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.

[0113] Multiple program modules may be stored in the driver and RAM 1012, including an operating system 1030, one or more applications 1032, other program modules 1034, and program data 1036. All or part of the operating system, applications, modules, and / or data may also be cached in RAM 1012. The systems and methods described herein can be implemented using various commercially available operating systems or combinations of operating systems.

[0114] Computer 1002 may optionally include emulation technology. For example, a super manager (not shown) or other intermediary may emulate a hardware environment for operating system 1030, and the emulated hardware may optionally be different from the hardware used in the emulation. Figure 10 The hardware is shown. In such an embodiment, the operating system 1030 may include one of a plurality of virtual machines (VMs) hosted at the computer 1002. Furthermore, the operating system 1030 may provide a runtime environment for the application 1032, such as the Java Runtime Environment or the .NET Framework. A runtime environment is a consistent execution environment that allows the application 1032 to run on any operating system that includes a runtime environment. Similarly, the operating system 1030 may support containers, and the application 1032 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.

[0115] Furthermore, a security module (such as a Trusted Processing Module (TPM)) can be used to enable computer 1002. 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 code execution stack of computer 1002, for example, at the application execution level or at the operating system (OS) kernel level, thus achieving security at any code execution level.

[0116] Users can input commands and information into computer 1002 through one or more wired / wireless input devices, such as keyboard 1038, touchscreen 1040, and pointing devices such as mouse 1042. 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 1004 via input device interface 1044, which is coupled to system bus 1008, 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.).

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

[0118] Computer 1002 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 1050), using logical connections. The remote computers 1050 can be workstations, server computers, routers, personal computers, laptops, 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 1002; however, for simplicity, only memory / storage device 1052 is shown. The described logical connections include wired / wireless connections to a local area network (LAN) 1054 and / or a larger network (e.g., a wide area network (WAN) 1056). 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.

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

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

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

[0122] Computer 1002 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.

[0123] 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.

[0124] 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 implementing at least one or more program modules of the 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 enable or implement 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 including 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.

[0125] 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.

[0126] 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 the processor performing the operation indirectly, such as by facilitating (e.g., facilitating its operation), directing, controlling, 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.

[0127] 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 can be virtualized or logically represented.

[0128] 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.

[0129] 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.

[0130] 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.

[0131] 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 a local system, another component in a distributed system, and / or other systems via 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.

[0132] 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.

[0133] 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".

[0134] 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.

[0135] It should be understood and appreciated that components described with respect to a particular system or method (e.g., proof manager component, graph processor component, proof generator component, verifier manager component, AI component, model, 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).

[0136] 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 performs a first analysis of graph data representing graphs related to causes, effects, or events, based on at least one zero-knowledge graph primitive; as well as The system determines a zero-knowledge proof related to the cause, the effect, or the event based on a second result of a second analysis of the result data of the first result of the first analysis, wherein the result data includes graph data representing the at least one zero-knowledge graph element.

2. The method according to claim 1, wherein, The graph is a causal directed acyclic graph or a causal cyclic graph, wherein at least one zero-knowledge graph primitive is customized for causal analysis of data in zero-knowledge applications, and wherein the data includes the graph metadata or the graph data.

3. The method according to claim 1, wherein, The at least one zero-knowledge primitive includes a zero-knowledge primitive comprising a group of nodes and a set of edges associated with the group of nodes, the zero-knowledge primitive having primitive features such that removing any edge from the set of edges from the zero-knowledge primitive results in the zero-knowledge primitive being disconnected.

4. The method according to claim 1, wherein, The at least one zero-knowledge primitive includes: a first zero-knowledge primitive for identifying descendant and ancestor nodes of nodes in the graph; a second zero-knowledge primitive for determining whether the graph is acyclic and performing acyclic or cyclic graph processing; a third zero-knowledge primitive for evaluating whether two subgroups in a node group of the graph are d-separated; or a fourth zero-knowledge primitive for generating an intervention graph for a target node of the graph.

5. The method according to claim 1, wherein, The first result includes a causal result, wherein performing the first analysis includes: by the system, based on the at least one zero-knowledge graph, performing a causal analysis on data related to the cause, the effect, or the event, and wherein determining the zero-knowledge proof includes: determining the zero-knowledge proof related to the cause, the effect, or the event based on the causal result of the causal analysis and a cryptographic key.

6. The method according to claim 1, further comprising: The system transmits the zero-knowledge proof to a verifier device, wherein the zero-knowledge proof facilitates the verification that the zero-knowledge proof, including the analysis or computation result data, is correct, without revealing to the verifier device the underlying data used to determine and generate the zero-knowledge proof, and wherein the underlying data includes at least one of the graph data, data for generating the graph data representing the graph, or the graph data.

7. The method according to claim 1, wherein, The graph is a causal directed acyclic graph, wherein the at least one zero-knowledge primitive includes zero-knowledge primitives for identifying descendant nodes and ancestor nodes of nodes in the graph, and wherein the method further includes: The system applies matrix transformations to convert the causal directed acyclic graph into an upper triangular matrix outside the zero-knowledge circuit, wherein the correctness of the matrix transformation within the zero-knowledge circuit is ensured based on circuit constraint sets. The system determines the inverse of the difference between the identity matrix and the upper triangular matrix outside the zero-knowledge circuit; The system verifies the correctness of the inverse of the difference between the identity matrix and the upper triangular matrix within the zero-knowledge circuit; and In the resulting matrix associated with the identity matrix and the upper triangular matrix, the system identifies the corresponding descendant nodes and corresponding ancestor nodes associated with the corresponding nodes in the causal directed acyclic graph.

8. The method according to claim 1, wherein, The graph is a causal graph, wherein the at least one zero-knowledge primitive includes a zero-knowledge primitive, the zero-knowledge primitive being partially involved in determining whether the causal graph is acyclic, and wherein the method further includes: The system performs cyclic detection on the causal graph outside of the zero-knowledge circuit. Based on the execution of the loop detection, the system determines whether the cause-effect graph is cyclic or acyclic; and In response to determining that the causal graph is acyclic: The system applies matrix transformations to convert the causal graph into an upper triangular matrix outside the zero-knowledge circuit, wherein the correctness of the matrix transformation within the zero-knowledge circuit is ensured based on circuit constraint sets; or In response to determining that the causal graph is cyclic, including the individual cycles: The system determines paths corresponding to loops in the various loops outside the zero-knowledge circuit; and The system enforces the constraint that the path begins and ends at the same node within the zero-knowledge circuit.

9. The method according to claim 1, wherein, The graph is a causal directed acyclic graph, wherein the at least one zero-knowledge primitive includes a zero-knowledge primitive that evaluates whether a first node subgroup and a second node subgroup of a node group in the causal directed acyclic graph are d-separated, and wherein the method further includes: The system removes nodes that are determined not to be in the ancestor group of a node to obtain an ancestor subgraph, wherein the ancestor group of the node is determined based on a merge operation of the first node subgroup, the second node subgroup, and the node group. The system applies moralization to the ancestor subgraph to generate a moralized ancestor subgraph. The system transforms the moralized ancestor subgraph into a matrix, wherein the correctness of the moralized ancestor subgraph is verified within a zero-knowledge circuit based on a first set of constraints; and The system determines whether d-separation exists between the first node subgroup and the second node subgroup based on a third result obtained by using matrix operations to determine whether any path exists between the corresponding nodes of interest in the first node subgroup and the second node subgroup, wherein a second set of constraints is implemented within the zero-knowledge circuit to verify the correctness of the matrix operations.

10. The method of claim 9, further comprising: The system determines, based on the third result indicating that no path exists between the corresponding nodes of interest, that there is a d-separation between the first node subgroup and the second node subgroup; or The system determines, based on a third result indicating the existence of the path between the corresponding nodes of interest, that there is no d-separation between the first node subgroup and the second node subgroup.

11. The method according to claim 1, wherein, The graph is a causal directed acyclic graph, wherein the at least one zero-knowledge primitive includes zero-knowledge primitives that generate an intervention graph for the target node of the causal directed acyclic graph, and wherein the method further includes: The system modifies the adjacency matrix associated with the causal directed acyclic graph by setting the entries in the columns corresponding to the target node in the adjacency matrix to zero. This modification helps eliminate the influence of other nodes in the causal directed acyclic graph on the target node. The system adds one or more constraints to ensure that modifications to the adjacency matrix are implemented within a zero-knowledge circuit.

12. 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 graph processor that performs a first analysis of graph information representing a graph relating to cause, effect, or event, based on at least one zero-knowledge graph primitive; and A proof generator that determines a zero-knowledge proof relating to the cause, the effect, or the event based on a second result of a second analysis of result information of a first result of the first analysis, wherein the result information includes primitive information representing the at least one zero-knowledge primitive.

13. The system according to claim 12, wherein, The graph is a causal directed acyclic graph or a causal cyclic graph, wherein the at least one zero-knowledge primitive is custom-defined to facilitate causal analysis of information in zero-knowledge applications, and wherein the information includes the primitive information or the graph information.

14. The system according to claim 12, wherein, The at least one zero-knowledge primitive includes: a first zero-knowledge primitive for identifying descendant and ancestor nodes of nodes in the graph; a second zero-knowledge primitive for determining whether the graph is acyclic and performing acyclic or cyclic graph processing; a third zero-knowledge primitive for evaluating whether two subgroups in a node group of the graph are d-separated; or a fourth zero-knowledge primitive for generating an intervention graph for a target node of the graph.

15. The system according to claim 12, wherein, The first analysis includes causal analysis, wherein the first result includes causal results, and wherein the proof generator performs causal analysis on information related to the cause, the effect, or the event based on the at least one zero-knowledge primitive; and determines the zero-knowledge proof related to the cause, the effect, or the event based on the causal results of the causal analysis and the cryptographic key.

16. The system according to claim 12, wherein, The proof generator sends or facilitates the sending of the zero-knowledge proof to the verifier device, wherein the zero-knowledge proof facilitates the verification that the zero-knowledge proof, including the analysis or computation result information, is accurate, without disclosing to the verifier device the underlying information used to determine and generate the zero-knowledge proof, and wherein the underlying data includes at least one of the graph information, information used to generate the graph information, or the primitive information.

17. The system according to claim 12, wherein, The graph processor 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.

18. A non-transitory machine-readable medium comprising executable instructions that, when executed by at least one processor, facilitate the execution of operations, the operations including: Based on at least one zero-knowledge graph element, perform a first analysis of the graph data relating to cause, effect, or event; as well as Based on the second result of the second analysis of the result data of the first result of the first analysis, a zero-knowledge proof related to the cause, the effect, or the event is generated, wherein the result data includes graph data of the at least one zero-knowledge graph element.

19. The non-transitory machine-readable medium according to claim 18, wherein, The graph is a causal directed acyclic graph or a causal cyclic graph, wherein at least one zero-knowledge graph primitive is customized for causal analysis of data in zero-knowledge applications, and wherein the data includes the graph data primitive or the graph data, and Wherein, the at least one zero-knowledge primitive includes: a first zero-knowledge primitive for identifying descendant nodes and ancestor nodes of nodes in the graph; a second zero-knowledge primitive for determining whether the graph is acyclic and performing acyclic or cyclic graph processing; a third zero-knowledge primitive for evaluating whether two subgroups in a node group of the graph are d-separated; or a fourth zero-knowledge primitive for generating an intervention graph for the target node of the graph.

20. The non-transitory machine-readable medium according to claim 18, wherein, The operation also includes: 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 analysis or computation result data, is correct, without exposing to the validator device the underlying data used to determine and generate the zero-knowledge proof, and wherein the underlying data includes at least one of the graph data, data for generating the graph data representing the graph, or the graph data.

Images