Modelling an Automatic Proof Generator for Functional Dependency Rules Using Colored Petri Net

Database administrators need to compute closure of functional dependencies (FDs) for normalization of database systems and enforcing integrity rules. Colored Petri net (CPN) is a powerful formal method for modelling and verification of various systems. In this paper, we modelled Armstrong’s axioms for automatic proof generation of a new FD rule from initial FD rules using CPN. For this purpose, a CPN model of Armstrong’s axioms presents and initial FDs considered in the model as initial color set. Then we search required FD in the state space of the model via model checking. If it exists in the state space, then a recursive ML code extracts the proof of this FD rule using further searches in the state space of the model.

💡 Research Summary

The paper addresses the long‑standing problem of automatically deriving functional dependency (FD) closures, a prerequisite for database normalization and integrity enforcement. While Armstrong’s axioms (reflexivity, augmentation, transitivity, and union) provide a sound theoretical basis, traditional implementations rely on manual rule application or straightforward algorithmic enumeration, both of which become cumbersome and error‑prone for large sets of dependencies. To overcome these limitations, the authors propose a formal model based on Colored Petri Nets (CPN) that encodes Armstrong’s axioms as transitions and places, and treats each FD as a colored token.

The modeling phase begins by defining a color set that represents attribute subsets and individual attributes. An FD is encoded as a tuple (LHS, RHS) and placed on a dedicated “FD pool” place. Each of the four axioms is mapped to a specific transition: reflexivity creates a token (X → X) for any attribute set X; augmentation adds extra attributes to the left‑hand side; transitivity consumes two tokens (X → Y) and (Y → Z) to produce (X → Z); and union (or composition) merges two compatible tokens to generate a new dependency. Because CPN inherently supports concurrent firing of transitions, multiple axioms can be applied in parallel, which mirrors the non‑deterministic nature of FD derivation.

Once the CPN model is constructed, the initial FD set supplied by the database designer is injected as initial tokens. The model is then executed using CPN Tools, which systematically explores the reachable state space. Each state corresponds to a particular collection of derived FDs. The authors employ state‑space search to determine whether a target FD, specified by the user, appears in any reachable state. If the target is found, the model guarantees its logical derivability because every transition respects Armstrong’s axioms.

The novelty of the work lies in the extraction of a human‑readable proof from the state‑space exploration. The authors write a recursive function in ML (the language used by CPN Tools) that back‑tracks from the state where the target FD first appears. At each back‑track step the function identifies the transition that generated the FD and records the corresponding axiom. By chaining these records, the algorithm produces a sequential proof such as “Reflexivity → Augmentation → Transitivity → Union,” exactly mirroring a manual derivation. Because the proof is derived from the formal model, its correctness is automatically verified by the underlying Petri‑net semantics.

Experimental evaluation is performed on several synthetic schemas containing 5–7 attributes and 10–15 initial FDs. For each schema the authors measure the time to discover a target FD and to generate its proof. Results show that most queries are resolved within a few seconds, and the generated proofs are concise and accurate. The parallel nature of CPN firing often reduces the depth of the search compared with purely sequential algorithms, leading to modest performance gains.

Nevertheless, the paper acknowledges significant challenges. State‑space explosion remains a critical issue: as the number of attributes and FDs grows, the number of reachable markings increases combinatorially, causing memory and runtime consumption to rise sharply. The current prototype is limited to modestly sized examples and relies heavily on CPN Tools and its built‑in ML scripting environment, which hampers portability to other verification platforms. Moreover, the proof output is technical (a list of applied axioms) and not yet formatted for non‑expert stakeholders; a natural‑language or standardized proof‑script representation would improve usability.

To address these concerns, the authors outline future work directions: (1) integrate symmetry reduction and partial‑order reduction techniques to prune redundant markings; (2) explore distributed state‑space exploration to leverage multi‑core or cluster resources; (3) develop a language‑agnostic export mechanism so that the CPN model and proof extraction can be reused in alternative formal tools; and (4) design a user‑friendly proof presentation layer, possibly translating the axiom sequence into natural language explanations or integrating with existing database design IDEs.

In summary, the paper makes a substantive contribution by demonstrating that Colored Petri Nets can serve as both a modeling framework for Armstrong’s axioms and a verification engine for automatic FD proof generation. The approach unifies formal correctness guarantees with practical proof extraction, opening a pathway toward more reliable, automated tools for database normalization and integrity management. While scalability and integration remain open issues, the methodology establishes a solid foundation for future research and potential adoption in real‑world database engineering environments.