Regular coverage

Regular coverage results are not unique.
One of the methods:

1. Partialize right to single attribute

2. Remove the redundant attributes of the left part,
   such as AB-> C

   1. Assuming that A is redundant, then see if B's ​​closure contains C
   2. Assuming that B is redundant, ...

3. Remove redundant functional dependencies

   • If A-> B is removed, then see if it can be changed by A

4. Merge functional dependencies

---

Simple example:
the functional dependency set F on the pattern (A, B, C):
A-> BC
B-> C
A-> B
AB-> C

1. After dividing the right part into a single attribute
   A-> B
   A-> C
   B-> C
   AB-> C
2. After removing the redundant attributes on the left,
   A-> B
   A-> C
   B-> C
3. After removing the redundant function dependency
   A-> B
   B-> C
4. Combine
   A-> B
   B-> C
   to get regular coverage

---

The functional dependency set F of the relational pattern r (A, B, C, D, E):
A-> BC
CD-> E
B-> D
E-> A

1. After the right part is converted into a single attribute,
   A-> B
   A-> C
   CD-> E
   B-> D
   E-> A
2. Remove the redundant attribute on the left
   A-> B
   A-> C
   CD-> E
   B-> D
   E-> A
3. Remove redundant function dependency
   A-> B
   A-> C
   CD-> E
   B-> D
   E-> A
4. The combined
   A-> the BC
   the B-> D
   CD-> E
   E-> A