方法

1. 将F右侧全部分解为只有一个属性；

2. 去掉冗余项：从第一个函数依赖X->Y开始，假设将其从F中去掉，在剩下的函数依赖中求X的闭包，看Y是属于X的闭包中。如果属于，则去掉X->Y；如果不属于，则保留。依次扫描......

3. 去掉冗余属性：选取左边属性个数>1的所有依赖，假设XY->A。先将XY->A换成Y->A，判断A是否还属于Y的闭包。如果属于，则删掉此X，否则保留。依次测试每个依赖的每个左边属性......

　（如果3中改变了函数依赖F，则需要重新来一次2）

例题

R={A, B, C, D, E, F}，F={ABD->AC, C->BE, AD->BF, B->E}，求最小函数依赖集

1. 化简右侧。F={ABD->A, ABD->C, C->B, C->E, AD->B, AD->F, B->E}。

2. 去掉冗余项。

　　如果删去ABD->A，F={ ABD->C, C->B, C->E, AD->B, AD->F, B->E}。ABD+={ABDCEF}，A包含在其中，因此删掉。

　　如果删去ABD->C，F={C->B, C->E, AD->B, AD->F, B->E}。ABD+={ABDEF}，C不包含在其中，不能删除。

　　如果删掉C->B，F={ ABD->C, C->E, AD->B, AD->F, B->E}。C+={C, E}，B不包含在其中，不能删除。

　　如果删掉C->E，F={ ABD->C, C->B, AD->B, AD->F, B->E}。C+={C, B, E}，E包含在其中，因此删掉。

　　如果删掉AD->B，F={ ABD->C, C->B, AD->F, B->E}。AD+={A, D, F}，B不包含在其中，不能删除。

　　如果删掉AD->F，F={ ABD->C, C->B, AD->B, B->E}。AD+={A, D, B, E, C}，F不包含在其中，不能删除。

　　如果删掉B->E, F={ ABD->C, C->B, AD->B, AD->F}。B+={B}，E不包含在其中，不能删除。

　　综上：F={ ABD->C, C->B, AD->B, AD->F, B->E}

3. 去掉冗余属性。

　　将ABD->C去掉A，变成BD->C，BD+={B, D, E}，C不包含在其中，不能删掉

　　将ABD->C去掉B，变成AD->C，AD+={A, D, B, E, F, C}，C包含在其中，可以删掉B

　　将ABD->C去掉D，变成AB->C，AC+={A, B, E}，C不包含在其中，不能删掉

　　因此ABD->C化简为AD->C

　　将AD->C去掉A，变成D->C，D+={D}，C不包含在其中，不能删掉

　　将AD->C去掉D，变成A->C，A+={A}，C不包含在其中，不能删掉

　　因此AD->C不变

　　将AD->B去掉A，变成D->B，D+={D}，B不包含在其中，不能删除

　　将AD->B去掉D，变成A->B，A+={A}，B不包含在其中，不能删除

　　因此AD->B不变

　　将AD->F去掉A，变成D->F，D+={D}，F不包含在其中，不能删除

　　将AD->F去掉D，变成A->F，A+={A}，F不包含在其中，不能删除

　　因此AD->F不变

　　此时F={ AD->C, C->B, AD->B, AD->F, B->E}

4. 重复2

　　将AD->C删掉，F={C->B, AD->B, AD->F, B->E}，AD+={A,D,B,E,F}，C不包含在其中，不能删

　　将C->B删掉，F={ AD->C, AD->B, AD->F, B->E}，C+={C}，B不包含在其中，不能删

　　将AD->B删掉，F={ AD->C, C->B, AD->F, B->E}，AD+={ADCBEF}，C包含在其中，删AD->B

　　将AD->F删掉，F={ AD->C, C->B, B->E}，AD+={A, D, C, B, E}，F不包含其中，不能删

　　将B->E删掉，F={ AD->C, C->B, AD->F}，B+={B}，E不包含在其中，不能删除

综上：F_m={ AD->C, C->B, AD->F, B->E}