In relational database theory, Inference Rules are formal rules that allow us to derive new functional dependencies from a given set. These rules are used to:

• Prove whether a particular functional dependency logically follows from a given set.

• Compute attribute closure.

• Verify dependency preservation and key candidates.

The most important inference rules are the three Armstrong’s Axioms and several derived rules built on top of them.

Basic Inference Rules

1. Reflexivity Rule

If $Y \subseteq X$, then $X \to Y$.

• Any set of attributes functionally determines its subsets.

• These are trivial dependencies.

Example:
If $X = \{A, B, C\}$ and $Y = \{A, B\}$, then $\{A, B, C\} \to \{A, B\}$.

2. Augmentation Rule

If $X \to Y$, then $XZ \to YZ$ for any attribute set $Z$.

• Adding the same attributes to both sides of an FD does not change its validity.

Example:
If $A \to B$, then $\{A, C\} \to \{B, C\}$.

3. Transitivity Rule

If $X \to Y$ and $Y \to Z$, then $X \to Z$.

• Dependencies can be chained.

Example:
If $A \to B$ and $B \to C$, then $A \to C$.

Derived Inference Rules

Using the three basic rules, several useful derived rules can be obtained:

4. Union Rule

If $X \to Y$ and $X \to Z$, then $X \to YZ$.

Example:
If $A \to B$ and $A \to C$, then $A \to BC$.

5. Decomposition Rule

If $X \to YZ$, then $X \to Y$ and $X \to Z$.

Example:
If $A \to BC$, then $A \to B$ and $A \to C$.

6. Pseudotransitivity Rule

If $X \to Y$ and $YZ \to W$, then $XZ \to W$.

This rule extends transitivity to cases where an extra attribute appears in the determinant of the second FD.

How Inference Rules Help in Design

• They allow systematic derivation of implied functional dependencies from a given set.

• They support attribute closure computation and key discovery.

• They provide a formal framework for checking whether a dependency holds and for building minimal covers.

Summary

Inference Rules in DBMS are formal rules (like Reflexivity, Augmentation, Transitivity, Union, Decomposition, and Pseudotransitivity) that allow us to derive new functional dependencies from a given set. These rules form the logical foundation for dependency analysis, closure computation, and normalization in relational database design.