函数依赖属性集闭包的算法

F 的闭包:

在关系模式 R<U ， F> 中为 F 所逻辑蕴含的函数依赖的全体叫作 F 的闭包，记为 F + 。
属性集 X 关于函数依赖集 F 的闭包:

设 F 为属性集 U 上的一组函数依赖， X Í U ， XF + ={ A|X → A 能由 F 根据 Armstrong 公理导出 } ， XF + 称为属性集 X 关于函数依赖集 F 的闭包.

算法  求属性集 X （ X Í U ）关于 U 上的函数依赖集 F 的闭包 XF +

输入： X ， F         输出： XF +

步骤：

（ 1 ）令 X （ 0 ） =X ， i =0

（ 2 ）求 B ，这里 B = { A |( $ V)( $ W )(V → W Î F ∧ V Í X （ i ）∧ A Î W) } ；

（ 3 ） X （ i+1 ） =B ∪ X （ i ）

（ 4 ）判断 X （ i+1 ） = X （ i ）吗 ?

（ 5 ）若相等或 X （ i ） =U , 则 X （ i ）就是 XF + , 算法终止。

（ 6 ）若否，则 i =i +l ，返回第（ 2 ）步。

python 代码实现

U=input("请输入U\n")
U_list=U.split(",")
L_F=input("请输入函数依赖的左边\n")
L_F_list=L_F.split(",")
R_F=input("请输入函数依赖的右边\n")
R_F_list=R_F.split(",")
t=input("初始值\n")
res=list(t)
a=[1]*len(L_F_list)
count=len(L_F_list)
while count>0:
    for i in range(len(L_F_list)):
        _tmp = L_F_list[i]
        tmp = list(_tmp)
        res1 = list()
        inter = list(set(res).intersection(set(tmp)))   #两个集合的交集
        inter=list(set(inter).difference(set(tmp)))#在前者之中不在后者里面
        if len(inter)==0:  # 判断是否包含
            _tmp = R_F_list[i]
            tmp = list(_tmp)
            res1 = list(set(res).union(set(tmp)))
            if(a[i]==0):
                continue
            a[i]=0
            diff1=list(set(U).difference(set(res)))
            diff2=list(set(res1).difference(set(res)))
            if (len(diff1)==0|len(diff2)==0):
                break
            res = res1
    count=count-1;
print(res)