*Reasoning About Multivalued Dependencies*

There are a many rules about MVD's that are similar to the rules we learned for FD's in "Rules About Functional Dependencies". For instance, MVD's obey

● The trivial dependencies rule, which says that if MVD

A_{1}A_{2} . . . .A_{n} B_{1}B_{2} . . . B_{m}

holds for some relation, then so does A_{1}A_{2} . . . A_{n} C_{1}C_{2} . . . C_{k}, where the C's are the B's plus one or more of the A's. On the other hand, we can also remove attributes from the B's if they are among the A's and infer the MVD A_{1}A_{2} . . . A_{n} D_{1}D_{2} . . . D_{r}, if the D's are those B's that are not among the A's.

● The transitive rule, which says that if A_{1}A_{2} . . . A_{n} B_{1}B_{2} . . . B_{m} and B_{1}B_{2} . . . B_{m} C_{1}C_{2} . . . C_{k} hold for some relation, then so does

A_{1}A_{2} . . . A_{n} C_{1}C_{2} . . . C_{k}

However, any C's that are also B's must be deleted from the right side.

On the other hand, MVD's do not obey the splitting part of the splitting/combining rule, as the following example shows.**Example (a) :** Consider again the "Multivalued Dependencies" figure, where we observed the MVD:

name street city

If the splitting rule applied to MVD's, we would expect

name street

also to be true. This MVD says that each star's street addresses are independent of the other attributes, including city. However, that statement is false. Consider, for instance, the first two tuples of above figure. The hypothetical MVD would allow us to infer that the tuples with the streets interchanged:

were in the relation. But these are not true tuples, because, for example, the home on 5 Locust Ln. is in Malibu, not Hollywood.

However, there are many new rules dealing with MVD's that we can learn. First,

● Every FD is a MVD. That is, if A

_{1}A

_{2}. . . A

_{n}B

_{1}B

_{2}. . . B

_{m}, then

A

_{1}A

_{2}. . . A

_{n}B

_{1}B

_{2}. . . B

_{m}.

To See why, suppose R is some relation for which the FD

A

_{1}A

_{2}. . . A

_{n}B

_{1}B

_{2}. . . B

_{m}

holds, and suppose t and u are tuples of R that agree on the A's. To show that the MVD A

_{1}A

_{2}. . . A

_{n}B

_{1}B

_{2}. . . B

_{m}holds, we have to show that R also contains a tuple v that agrees with t and u on the A's, with t on the B's, and with u on all other attributes. But v can be u. Surely u agrees with t and u on the A's, because we started by assuming that these two tuples agree on the A's. The FD A

_{1}A

_{2}. . . A

_{n}B

_{1}B

_{2}. . . B

_{m}assures us that u agrees with t on the B's. And of course u agrees with itself on the other attributes. Therefore, whenever a FD holds, the corresponding MVD holds.

Another rule that has no counterpart in the world of FD's is the complementation rule:

● If A

_{1}A

_{2}. . . A

_{n}B

_{1}B

_{2}. . . B

_{m}is a MVD for relation R, then R also satisfies A

_{1}A

_{2}. . . A

_{n}C

_{1}C

_{2}. . . C

_{k}, where the C's are all attributes of R not among the A's and B's.

**Example (b) :**Again consider the relation of "Multivalued Dependencies" figure, for which we asserted the MVD:

name street city

The complementation rule says that

name title year

must also hold in this relation, because title and year are the attributes not mentioned in the first MVD. The second MVD intuitively means that each star has a set of movies starred in, which are independent of the star's addresses.

### Tags

- attributes
- tuples
- functional dependencies
- Scrolling Cursors
- Protecting Against Concurrent Updates
- Modifications by Cursor
- Cursors
- Instead-Of Triggers
- Triggers in SQL
- Schema-Level Constraints and Triggers
- Tuple-Based CHECK Constraints
- Constraints on Attributes and Tuples
- Declaring Foreign-Key Constraints
- Keys Declared With UNIQUE
- Constraints and Triggers
- Modifying Views
- View Definitions
- Introduction to Selection of Indexes
- Default Values / Indexes
- Simple Table Declarations
- Defining a Relation Schema in SQL
- Deletion / Updates
- Database Modifications
- Grouping / HAVING Clauses
- Full-Relation Operations
- Natural Joins / Outerjoins
- Subqueries in FROM Clauses
- Conditions Involving Tuples
- Subqueries
- Union, Intersection, and Difference of Queries
- Interpreting Multirelation Queries
- Tuple Variables
- Disambiguating Attributes
- Queries Involving More Than One Relation
- Null Values and Comparisons Involving NULL
- Selection in SQL
- Projection in SQL
- The Database Language SQL
- Additional Constraint Examples
- Constraints on Relations
- Extending the Projection Operator
- Grouping
- Extended Operators of Relational Algebra
- Selection on Bags / Product of Bags / Joins of Bags
- Union, Intersection, and Difference of Bags
- Relational Operations on Bags
- A Linear Notation for Algebraic Expressions
- Dependent and Independent Operations
- Renaming
- Combining Operations to Form Queries
- Selection / Cartesian Product
- Set Operations on Relations
- An Algebra of Relational Operations
- Relational Algebra
- Attribute Lists
- Information Integration Via Semistructured Data
- Semistructured Data Representation
- Object-Oriented Versus Object-Relational
- Nested Relations
- The Object-Relational Model
- What If There Is No Key
- Representing ODL Relationships
- Representing Other Type Constructors
- Representing Set-Valued Attributes
- Nonatomic Attributes in Classes
- Declaring Keys in ODL
- Subclasses in ODL / Multiple Inheritance in ODL
- Types in ODL
- Methods in ODL
- Multiplicity of Relationships
- Relationships in ODL / Inverse Relationships
- Attributes in ODL
- Introduction to ODL
- The Type System
- Decomposition into Fourth Normal Form
- Definition of Multivalued Dependencies
- Multivalued Dependencies
- Third Normal Form
- Boyce-Codd Normal Form
- Decomposing Relations
- Projecting Functional Dependencies
- Closing Sets of Functional Dependencies
- The Transitive Rule
- Why the Closure Algorithm Works
- Computing the Closure of Attributes
- Trivial Functional Dependencies
- The Splitting/Combining Rule
- Rules About Functional Dependencies
- Keys of Relations
- Using Null Values to Combine Relations - Comparison of Approaches
- An Object-Oriented Approach
- Converting Subclass Structures to Relations
- Handling Weak Entity Sets
- Combining Relations
- From E/R Relationships to Relations
- From Entity Sets to Relations
- From E/R Diagrams to Relational Designs
- Relation Instances
- Equivalent Representations of a Relation
- Tuples / Domains
- Attributes / Schemas
- The Relational Data Model
- Summary of The Entity-Relationship Data Model
- Weak Entity Set Notation
- Requirements for Weak Entity Sets
- Representing Keys in the E/R Model
- Keys in the E/R Model
- The Modeling of Constraints
- Picking the Right Kind of Element
- Design Principles
- Subclasses in the E/R Model
- Converting Multiway Relationships to Binary
- Attributes on Relationships
- Roles in Relationships
- Multiway Relationships
- Elements of the E/R Model
- Database System Implementation
- Database Design
- Multimedia Data
- Relational Database Systems