Entity Dependency Graph (EDG)

• Entity Dependency Graph (EDG) is a formal graph-based abstraction that represents interdependent entities as nodes and their relationships as edges with domain-specific attributes.
• EDGs are constructed using methods such as DFS-based minimal cover search in property graphs, AST parsing in code repositories, and embedding-based inference in event streams.
• EDGs facilitate schema management, automated type inference, and system event analysis, driving scalable analysis and improved accuracy in heterogeneous data domains.

An Entity Dependency Graph (EDG) is a formal graph-based abstraction modeling interdependent entities and their attribute, type, or operational relationships across heterogeneous data domains, including property graphs, software codebases, and complex system event streams. EDGs serve as foundational structures for reasoning about dependencies in applications such as rule discovery, repository-scale type inference, and system event analysis. The specific semantics and construction of EDGs are domain-dependent, yet all share the core principle of representing entities as nodes and dependencies as edges, often enriched by attributes reflecting relationship strength, type, or provenance.

1. Formal Definitions Across Domains

Property Graphs and Rule Dependencies

In the context of property graphs, an EDG arises from the discovery of Graph Entity Dependencies (GEDs). Here, a dependency is expressed as a rule $X \rightarrow Y$ over a pattern $Q[\underline{u}]$, encoding dependencies among attribute-value pairs, variable equalities, or identity constraints over node and edge sets. Each minimal GED is mapped to a set of directed hyper-edges in the EDG, with edge weights reflecting confidence via a semantically meaningful error measure $e_3$ (Zhou et al., 2023).

Program Analysis and Type Inference

In code repositories, an EDG explicitly encodes object and type dependencies between Variable Entities (variables, attributes), Function Entities (functions/methods), and Class Entities (user-defined classes). The edge set is partitioned as $$E = E_{\text{Call}} \cup E_{\text{Access}} \cup E_{\text{Inherit}} \cup E_{\text{Def}}$$, corresponding to call, variable access, inheritance, and definition relationships. This structure drives iterative, large-scale type inference and annotation (Sun et al., 25 Dec 2025).

System Event Streams

For event-driven systems, EDGs generalize to heterogeneous, undirected, weighted graphs, with vertices corresponding to typed entities (processes, files, sockets, users) and edges encoding the intensity of dependency—either causal or correlational—learned from raw streams of categorical system events. Edge weights are determined via embedding- and statistical-based techniques (Luo et al., 2017).

2. Construction Methodologies

Approximate Rule Extraction (Property Graphs)

FASTAGEDS algorithm discovers minimal GEDs by:

• Mining $\tau$-frequent graph patterns as pattern scopes.
• For each pattern, constructing Items corresponding to potential literal constraints.
• Using depth-first search (DFS) to enumerate minimal covers over necessary sets, characterizing when $X \rightarrow Y$ is (approximately) satisfied.
• Assigning as edge-weights the relative error $e_3$ for each dependency. The final EDG is constructed by representing items as nodes and drawing directed hyper-edges from item-sets $X$ to $Y$ where $X \rightarrow Y$ is supported under (approximate) satisfaction (Zhou et al., 2023).

Program Entity Parsing and Dependency Extraction (Code Repositories)

EDG construction in program analysis proceeds as follows:

• Parse the Abstract Syntax Tree (AST) across the entire repository.
• Identify Variable Entities, Function Entities, and Class Entities.
• For each entity, analyze statements to extract:
  • Call dependencies for every function invocation,
  • Access dependencies for variable reads/writes,
  • Inheritance dependencies for class hierarchies,
  • Definition dependencies for assignments within functions.
• Aggregate all discovered entities and edges into the graph $(V, E)$. A (partial) mapping $\tau: V \rightarrow \mathcal{T} \cup \{\perp\}$ is maintained to store actual or inferred types (Sun et al., 25 Dec 2025).

Knowledge Transfer and Embedding-Based Learning (Event Streams)

In ACRET, EDG construction couples knowledge transfer and direct estimation:

• An Entity Estimation Model embeds entities from a mature source EDG, using meta-path-based similarity and manifold learning, and filters for relevance via statistical hypothesis testing.
• Selected source entities are merged with the immature target EDG.
• A Dependency Construction Model infers missing edges by optimizing for smoothness to observed target dependencies and consistency relative to the source domain, balancing via a hyperparameter $\mu$. Optimization is performed via alternating closed-form solutions and gradient steps, with statistical hypothesis testing to finalize edge presence (Luo et al., 2017).

3. Semantic Variants and Characterization

EDG variants differ fundamentally by domain and application:

Domain/Context	Node Types	Edge Semantics	Edge Attributes
Property Graphs	Attribute-derived Items	Minimal GEDs (rules)	$e_3$ (error)
Program Analysis	Variables, Functions/Classes	Inter-procedural deps	None (struct.)
Event Streams	System Entities (hetero.)	Causal/influence rels	Intensity

In property graphs, the EDG is a directed (hyper-)graph where each node corresponds to a literal constraint and edges encode implication (dependency) relationships, with strength annotated by satisfaction error. In software analysis, the EDG models program-wide type and dataflow dependencies. For system events, it functions as a relational blueprint abstracting operational system structure and causality.

4. Applications and Utility

Schema and Data Management (Property Graphs)

EDGs enable schema relaxation, evolution, and data cleaning:

• Suggesting new or relaxed schema constraints through analysis of approximate dependencies.
• Detecting schema drift and violations by identifying rule exceptions.
• Facilitating efficient query-planning via dependency-driven pruning and optimization (Zhou et al., 2023).

Automated Program Understanding and Type Inference

EDGs are central to scalable, repository-level type inference:

• Driving type propagation across interdependent entities,
• Supporting iterative, context-sensitive LLM and static analysis integration,
• Empirically yielding state-of-the-art accuracy in TypeSim and TypeExact metrics, while maintaining global consistency and reducing propagated type errors by over 92% (Sun et al., 25 Dec 2025).

System Diagnosis and Transfer Learning (Event Streams)

EDGs support:

• Accelerated construction of causal graphs for root-cause diagnosis,
• Rapid configuration-aware risk assessment and network/cyber forensics,
• Efficient adaptation across domains via entity and dependency transfer, achieving up to 70% accuracy improvement over no-transfer baselines, and delivering comparable detection precision and recall with one-tenth the training data (Luo et al., 2017).

5. Computational and Theoretical Properties

Complexity

• Property graph EDG extraction (FASTAGEDS): DFS-based minimal cover search is NP-hard in the worst case but effective pruning achieves near-polynomial runtime empirically for real data. Space and time complexity for building binary disagree relations is $O(|H|\cdot n)$ (matches $\times$ items) (Zhou et al., 2023).
• Program analysis: Each iteration for inference and graph restructuring is $O(|V| + |E|)$. The process converges in at most $|V|$ iterations, but typically $\approx 30$ suffice to annotate $>80\%$ of entities. Cost is dominated by LLM query latency and static type checks (Sun et al., 25 Dec 2025).
• Event streams: Optimization in ACRET (EEM and DCM) converges in $<10$ iterations per step via closed-form updates and SGD. Total runtime is dominated by embedding and matrix factorization (Luo et al., 2017).

Formal Guarantees

• Repository-scale inference with EDGs converges to a conflict-free full annotation, guaranteed by the monotonically increasing assignment of inferred types (Sun et al., 25 Dec 2025).
• Knowledge transfer in ACRET preserves domain distinction and avoids negative transfer by enforcing a consistency constraint on edge distributions (Luo et al., 2017).

6. Limitations and Research Directions

• Pattern and candidate explosion in rule mining (property graphs) results in combinatorial growth of items; integration of pattern-growth with dependency search and early pruning is required for scalability to large scopes (Zhou et al., 2023).
• The hypergraph representation in EDGs for expressive dependencies introduces significant NP-hardness; heuristics and parallelization (MapReduce, multi-threading) are indicated to achieve efficient enumeration in large datasets (Zhou et al., 2023).
• Richer dependency families, such as approximate joins with path- or distance-based semantics, demand new algorithmic innovations (Zhou et al., 2023).
• In event stream EDG learning, ongoing challenges include handling concept drift and rapid domain adaptation. Balancing smoothness (fit to target) and consistency (fit to transferred source) remains finely parameter-sensitive (Luo et al., 2017).

A plausible implication is that further advances in scalable, hybrid EDG construction will catalyze progress in graph database management, automated software understanding, and real-time system analytics across rapidly evolving or heterogeneous domains.