I must discover the canonical cover or minimum quantity of functional dependencies inside a database.

For instance:

For those who have: Table = (A,B,C) <-- they are posts: A,B,C

And dependencies:

A → BC

B → C

A → B

AB → C

The canonical cover (or minimum quantity of dependencies) is:

A → B

B → C

It is possible to program that may make this happen? Otherwise, any code/pseudocode that helped me to write you might be appreciated. Prefer in Python or Java.

Searching at the dependencies, it appears like you will see them like a partial order on A, B, C. What you would like sounds nearly the same as (although not entirely) a topological sort (an incomplete order sort on the directed acyclic graph).

Looks in my experience as if you can refactor any rules from the form:

   A ->  BC

into

 A -> B

and

  A -> C

and then any rules from the form:

  AB -> C

into

  A -> C

and

  B -> C

Following this refactoring, you ought to have some rules from the singleton pairs:

  X -> Y

(Likely with a lot of redundant copies you are able to immediately remove). This forms the partial order that rlotun appeared to mentioning to.

For that example to date, you finish track of:

 A -> B
 B -> C
 A -> C

Should you then minimize the partial order (e.g., remove any redundant links, data structure books on partial should let you know how to achieve that), you'll possess a minimal partial order, and i believe this is the answer you would like. Reducing the partial order within the example, you'd remove A -> C from the partial order, ending together with your answer.