已知F=｛A→D，B→D，BD→CA，CD→B｝，求Fmin。数据库系统概论习题解答

要求F的最小函数依赖集，需要先进行以下步骤：

1. 求出F的闭包集合F+；
2. 对于F中的每一个函数依赖X→Y，判断X是否是候选键，如果不是，则将其移除；
3. 对于F中的每一个函数依赖X→Y，判断是否可以从其他函数依赖推导出来，如果可以，则将其移除。

具体步骤如下：

1. 求F的闭包集合F+：
A+ = ADBCA
B+ = BDCAB
BD+ = BDCAB
CD+ = CDBA
AC+ = ADBCA
AD+ = ADBCA
BC+ = BDCAB
BD+ = BDCAB
CA+ = CDBA
CB+ = CDBA
CD+ = CDBA

2. 判断候选键：
由于AC可以推导出BD，因此AC不是候选键，而BD是候选键。

3. 判断可以从其他函数依赖推导出来的函数依赖：
A→D和B→D都不能从其他函数依赖推导出来，因此它们保留。
BD→CA可以从CD→B和B→D推导出来，因此将其移除。
CD→B可以从BD→CA和CA→B推导出来，因此将其移除。
因此，Fmin={A→D，B→D，CA→B}。

相关问题

习题2：已知F={ A→D，B→D，BD→CA，CD→B }，求 Fmin。

首先，我们需要使用 Armstrong's Axioms 将 F 转化为其等效的无冗余函数依赖集合。具体过程如下：

1. 消除冗余依赖

- 从 F 中删除可以由其他依赖推导出的依赖。在这个例子中，我们可以删除 BD→CA，因为它可以由 A→D 和 B→D 推导出来。

所以现在 F 为 { A→D，B→D，CD→B }。

2. 消除传递依赖

- 对于每个依赖 X→Y，在 F 中寻找可以推导出 X 的超键 K。
- 如果 K 中除了 X 还有其他属性，则将它们加入到 F 中，形成新的依赖 K-X→Y。
- 重复这个过程，直到不存在可以推导出 X 的超键为止。

在这个例子中，我们有：

- A→D，无需消除传递依赖，因为 A 是一个超键。
- B→D，无需消除传递依赖，因为 B 是一个超键。
- CD→B，找到一个超键 ABCD，将它分解为 BC→D 和 CD→B，然后删除 CD→B。

现在 F 为 { A→D，B→D，BC→D，CD→B }。

最后，我们需要找到 F 的最小等效依赖集合 Fmin。我们可以使用以下步骤：

1. 对于 F 中的每个依赖 X→Y，尝试删除 X 中的每个属性。
2. 如果删除后的集合能够推导出 Y，则删除 X 中的属性。
3. 重复这个过程，直到不能再删除属性为止。

在这个例子中，我们有：

- A→D，无法删除任何属性。
- B→D，无法删除任何属性。
- BC→D，尝试删除 B 和 C，但是都无法推导出 D。所以 BC→D 是 Fmin 的一部分。
- CD→B，尝试删除 C 和 D，但是都无法推导出 B。所以 CD→B 是 Fmin 的一部分。

因此，F 的最小等效依赖集合 Fmin 为 { A→D，B→D，BC→D，CD→B }。

已知F={ A→D，B→D，BD→CA，CD→B }，求 Fmin。

首先，我们可以使用 Armstrong Axioms 来推导出 F 的闭包，即所有能够推导出的函数依赖关系，包括直接依赖和传递依赖。

1. 自反律：如果 X 是任何一个属性集，那么 X → X 属于闭包。
所以，我们可以得到 AD → AD 和 BC → BC。

2. 扩展律：如果 X → Y，那么对于任何属性集 Z，有 XZ → YZ。
根据这个规则，我们可以推导出 BD → CD 和 BD → CA。

3. 传递律：如果 X → Y，Y → Z，那么 X → Z。
根据这个规则，我们可以推导出 BD → B 和 BD → C。

通过以上三个规则，我们可以得到 F 的闭包如下：

- A → AD
- B → BD
- C → AC
- D → D
- AD → ABCD
- BC → ABCD

接下来我们需要使用 F+ 算法，将 F 进行最小化。F+ 算法的基本思想是：将所有函数依赖关系划分到等价类中，每个等价类代表一个最小的超码。

首先，我们将 F 的所有左部属性集划分到不同的等价类中：

A B C D
---------
A B C D

然后，根据 F 的右部属性集，将等价类进一步划分：

A B C D
---------
D D D

A B C D
---------
D D C D

A B C D
---------
D B C D

A B C D
---------
D B C

A B C
---------
D B C

现在我们可以得到 Fmin，它包含以下函数依赖关系：

- A → D
- B → D
- CD → B

这就是 F 的最小化结果。