JS闭包的概念

因为R有传递性,所以R的传递闭包就是R本身,{,}

设A={1,2,3},R={,,}是A上的传递关系(实际上是普通的小于关系).s(R)={,,,,,},s(R)不传递,如,在s(R)中,但,不在s(R)中,由定义s(R)不传递.

我有一个可以用的.怎么给你?百度hi我吧.
算了,我贴上来吧,由电脑编程网整理：
#include
#include
#define smax 45
typedef int datatype;
typedef struct lnode //结构体和共用体的定义
{
int i,j;
struct lnode *cptr,*rptr;
union
{
struct lnode *next;
datatype v;
}uval;
}link;
int flag=0;
//建立稀疏矩阵的函数,返回十字链表头指针
link *creatlinkmat()
{
link *p,*q,*head,*cp[smax];
int i,j,k,m,n,t,s;
datatype v;
printf("输入行、列,非零元素个数(m,n,t数字间用逗号分隔)");
scanf("%d,%d,%d",&m,&n,&t);//输入行、列,非零元素个数
if(m>n)s=m; else s=n;
head=(link *)malloc(sizeof(link)); //建立十字链表头结点
head->i=m;head->j=n;
cp[0]=head; //cp[]是指针数组,分别指向头结点和行、列表头结点
for(i=1;i<=s;i++) //建立头结点循环链表
{
p=(link *)malloc(sizeof(link));
p->i=0;p->j=0;
p->rptr=p;p->cptr=p;
cp[i]=p; cp[i-1]->uval.next=p;
}
cp[s]->uval.next=head;
for(k=1;k<=t;k++)
{
printf("t 第%d个元素(行号i 列号j 值v,数字间用空格分隔):",k);
scanf("%d%d%d",&i,&j,&v);
p=(link *)malloc(sizeof(link));
p->i=i;p->j=j;p->uval.v=v;
q=cp[i];
while((q->rptr!=cp[i])&&(q->rptr->j q=q->rptr;
p->rptr=q->rptr;
q->rptr=p;
q=cp[j];
while((q->cptr!=cp[j])&&(q->cptr->i q=q->cptr;
p->cptr=q->cptr;
q->cptr=p;
}
return head;
}
//插入结点函数
void insert(int i,int j,int v,link *cp[])
{
link *p,*q;
p=(link *)malloc(sizeof(link));
p->i=i;p->j=j;p->uval.v=v;
//以下是经*p结点插入第i行链表中
q=cp[i];
while((q->rptr!=cp[i])&&(q->rptr->j q=q->rptr;//在第i行中找第一个列号大于j的结点*(q->rptr)
//找不到时,*q是该行表上的尾结点
p->rptr=q->rptr;
q->rptr=p;//*p插入在*q之后
//以下是将结点插入第j列链表中
q=cp[j];//取第j列表头结点
while((q->cptr!=cp[j])&&(q->cptr->i q=q->cptr ;//在第j行中找第一个列号大于i的结点*(q->cptr)
//找不到时,*q是该行表上的尾结点
p->cptr=q->cptr;
q->cptr=p;//*p插入在*q之后
}
//输出十字链表的函数
void print(link *a)
{
link *p,*q,*r;//p是控制行q是控制列r是控制输出的格式
int k,col,t,row;
col=a->j;//矩阵a的列数
printf("矩阵为：n");
p=a->uval.next;//p指向第一个结点（不是头结点）
while(p!=a)
{
q=p->rptr;//p指向这以一行的一个值
if(q==a->cptr)break;//如果行或列处理完了,跳出
r=p;//r指向这一行的头结点
while(q!=p)
{
for(k=1;kj-(r->j);k++)//输出同一行上两非零数据间的零
printf(" 0");
printf("%3d",q->uval.v);//输出那个非零值
q=q->rptr;//q指向这一行的下一个元素
r=r->rptr;//r指向q前面的一个非零元素
}
k=r->j;//k的值是某一行的最后一个非零元的列数
for(t=k;t printf(" 0");
printf("n");
p=p->uval.next;//p指向下一行
}
}
link *add(link *a,link *b)
{
link *p,*q,*u,*v,*r,*cp[smax],*c;//p,q控制十字链a的行列,u,v控制十字链b的行列
int s,i;
if(a->i!=b->i||a->j!=b->j)

//建立c的表头环链
c=(link *)malloc(sizeof(link));
c->i=a->i;c->j=a->j;
if(c->i>c->j)s=c->i; else s=c->j;
cp[0]=c;
for(i=1;i<=s;i++)
{
r=(link *)malloc(sizeof(link));
r->i=0;r->j=0;
r->rptr=r;r->cptr=r;
cp[i]=r;
cp[i-1]->uval.next=r;
}
cp[s]->uval.next =c;
//矩阵相加
p=a->uval.next;u=b->uval.next;
while(p!=a&&u!=b)
{
q=p->rptr;v=u->rptr;
if(q==p&&v!=u)//矩阵a中第p行为空,矩阵b的第u行不为空
while(v!=u)//将b的行的都复制到和矩阵中

else if(v==u&&q!=p)//矩阵a中第p行不为空,矩阵b的第u行为空
while(q!=p)

else if(q!=p&&v!=u)//矩阵b的第u行和矩阵a的第p行都不为空
{
while(q!=p&&v!=u)
{
if(q->jj)//如果a中有元素的列数小于b的,将a中的所有小于b的值都插到c中

else if(q->j>v->j)//如果b中有元素的列数小于a的,将a中的所有小于b的值都插到c中

else//a、b当前是在同一个位置,判断加的和是否为零,不为零才做加法运算
{if(q->uval.v+v->uval.v!=0)insert(q->i,q->j,(q->uval.v+v->uval.v),cp);
q=q->rptr;v=v->rptr;
}
}
if(q==p&&v!=u)//如果b未处理完,将b中未处理的值都插入到和矩阵中
while(v!=u)

else if(v==u&&q!=p)//如果a未处理完,将a中未处理的值都插入到和矩阵中
while(q!=p)

else; //都处理完了,什么都不做
}
else ; //矩阵b的第u行和矩阵a的第p行都为空,什么都不做

p=p->uval.next;u=u->uval.next;//a、b都指向下一行
}
return c;
}
//
void main()
{
link *a,*b,*c;
a=creatlinkmat();print(a);
b=creatlinkmat();print(b);
c=add(a,b);
if(flag==1)printf("矩阵a、b不能相加!");
else printf("和矩阵c为：n");print(c);
}
测试用例：
输入行、列,非零元素个数(m,n,t数字间用逗号分隔)2,2,4
第1个元素(行号i 列号j 值v,数字间用空格分隔):1 1 1
第2个元素(行号i 列号j 值v,数字间用空格分隔):1 2 1
第3个元素(行号i 列号j 值v,数字间用空格分隔):2 1 1
第4个元素(行号i 列号j 值v,数字间用空格分隔):2 2 1
矩阵为：
1 1
1 1
输入行、列,非零元素个数(m,n,t数字间用逗号分隔)2,2,3
第1个元素(行号i 列号j 值v,数字间用空格分隔):1 1 5
第2个元素(行号i 列号j 值v,数字间用空格分隔):1 2 5
第3个元素(行号i 列号j 值v,数字间用空格分隔):2 1 5
矩阵为：
5 5
5 0
和矩阵c为：
矩阵为：
6 6
6 1
请按任意键继续. . .

（CD)+闭包 就是ABCDEG
ACD的闭包也是ABCDEG 因为CD的闭包都是ABCDEEG了,ACD肯定也是.
(AD)+的闭包为 ADBG

1：A+首先包括自己
2：找A的依赖 把它能依赖的属性的闭包加入A+ 比如A->D 把D+加到A+
所以A+={A,D}
E+={E,C}
AE+={A,C,D,E}
再CD->I
AE+={A,C,D,E,I}

先求自反闭包r(R),再求r(R)的对称闭包s(r(R)),最后求s(r(R))的传递闭包t(s(r(R))),按次序求就好

设A是一个开集,以d(A)表示A的导集,cl(A)表示A的闭包.显然d(A)包含于cl(A).

因为内点必是聚点,而A里面的任意元素都是A的内点,所以A包含于d(A),
而cl(A)=A∪d(A),所以cl(A)包含于d(A).


综上两方面,d(A)=cl(A).

准紧集的任何子列都有收敛子列,但是其收敛的聚点未必属于自身.
而由闭包的定义可知,闭包一定包含了自身的所有聚点.从而上述聚点也都包含在闭包之内.
由于准紧集的闭包相对于原准紧集新加入的点都是原准紧集的聚点,因此这些点的任何序列也都必定有收敛子列.否则假如存在一个聚点的序列无收敛子列.则由聚点的定义可知,对此序列中的每一点,都可以找到原准紧集中的一点,使得两者之间的距离足够小.那么由此条序列可以得到对应的原准紧集中的一条序列,该序列也无收敛子列,这与准紧集定义矛盾.
因此准紧集的闭包的任何子列都有收敛子列,且收敛到自身.
这正是紧集的定义.
因此准紧集的闭包是紧集.
证毕.

先理解闭包的概念,x∈A的闭包,就是对于任意的x的开领域G与A交集不为空,那么对于任意的x∈（A的闭包+B的闭包）那么x∈A的闭包或者x∈B的闭包,不妨设x∈A的闭包,那么对于任意的x的开领域G与A交集不为空,所以x的开领域G与A+B的交集也不为空,所以x∈A+B的闭包.由于x的任意性,则（A的闭包+B的闭包）包含于（A+B）的闭包

①A -> BC, B -> D所以A -> D所以A -> DC -> E
所以呢A -> ABCDE
②E -> A, A -> ABCDE, 所以E -> ABCDE
③CD -> E, 所以呢CD -> ABCDE
④B -> D, BC -> CD,所以呢BC -> ABCDE
能推出abcde而又不包含多余成分的就是候选键 所以上面仨是候选键 A+的话是求闭包吧

集合的闭包的内部是包含于集合的闭包的最大开集,从而该集合的导集中不可能有点属于该最大开集（否则该点成了集合的内点了）,从而该最大开集包含于该集合中,两边同时再取内部,得到该最大开集包含于该集合的内部.
明白了没?

考虑B的补集C,任取一点c
c有个邻域E交A为空集
如果这个领域交B不空,则有一点a属于E交B
a的领域交B都非空,得到c的邻域和A交,矛盾
所以C是开集
B就是闭集

即如果R1是R的自反闭包,则一定具有下面3个条件:
1.R1包含R(即R是R1的子集)
2.R1具有自反性质
3.对任意具有自反性质且包含R的关系Q,Q必也包含R1(即R1的最小性)

closure relation应该翻译成封闭关系,就是只力学量的正交基是完备的.

A-29 完全没有什么所谓的变量代换,只是内插了恒等式


其中的r'只是哑标而已.

A.非充分非必要.非必要:F(x) = x²连续.取A = (-1,1),A的内部 = A.但F(A) = [0,1) ≠ (0,1) = F(A)的内部.非充分:不知道是不是我想复杂了,这个例子构造的相当麻烦.从解题的角度只需要上面非必要的例子就够了,不...

(R)＝{,,,,},所有的放进去
t(R)＝{,,,,},交换两个元素的有序对都放进去
s(R)＝{,,,},这个稍麻烦,画关系图,从每一个顶点出发找它经过不超过3步的边所能到达的顶点,有,则有序对放进去

只需在一维空间中找例子.
取An=(1/(n+1),1/n)是开区间,n=1,2,3,.
则An的闭包是[1/(n+1),1/n],An的闭包的并是
[1/2,1]并[1/3,1/2]并.=(0,1].注意：这里不包含0.
因为0不位于任意一个Bn=An的闭包中,所以并集后不含0.
而先取并后取闭包就是[0,1]了,这里包含0了.

一个关系不具有自反,对称,传递这3种基本性质之一,但均可以通过对该关系的扩充(在关系中增添序偶),使扩充后的关系具有这种性质,这种包含该关系的最小扩充称为该关系关于这种性质的闭包.下面给出闭包的定义.
设R是X上的关系,R的自反(对称,传递)闭包R1是这样的包含R(或R包含于R1)的自反(对称,传递)关系,对任意的自反(对称,传递) 关系S,如果R包含于S,则必有R1包含于S.
关系闭包在数学中,在日常生活中均有广泛的应用,比如在数学中,小于()关系均没有自反性,但它们的的自反闭包是小于等于(≤)或大于等于((≥),却有自反性,在数学中经常要用到小于关系表示量之间的关系,但是有时感到用小于关系不方便,而用小于等于关系,实际上是将量之间的关系进行扩大,不自觉地用了小于的自反闭包,日常生活中我们按同龄或同班或同乡关系将人分组,一般来说同龄,同班,同乡关系指两个不同的人之间的一种关系,这种关系就不具有自反性,如果我们约定了自已与自已同龄,同班,同乡,此时它们就有了自反性,如果仅有一个人和其他人年龄均不同,此时他自已就可构成一组.
小于关系是不对称,它的逆关系大于关系也是不对称,但将两者关系并起来(将关系看成集合),得不等关系却是的对称的,不等关系是小于或大于关系的对称闭包,夫对妻的关系是不对称的,妻对夫的关系也是不对称的,但对称闭包婚姻关系却是对称的(考虑到男女平等,即对称性).大于1的关系是不传递的,大于2的关系也是不传递的,…将大于1,大于2,大于3,…全部并起来得到大于关系却是传递的,大于关系是大于1的关系的传递闭包,父子关系是不传递的,但它的传递闭包是长辈对后辈关系却是传递的.
总而言之,我们经常不自觉的用到了关系闭包的概念,在数学中随着人们的对关系的深入认识,自觉地使用闭包的概念,比如在数学中严格偏序关系的自反闭包是偏序关系,偏序集利用所谓盖住关系的关系图(哈斯图),来描述该偏序集十分简单明了,盖住关系的自反传递闭包就是偏序集上的偏序关系.

设A的闭包是B,A的闭包的闭包是C.用反证法,如果命题不成立,则B的某一个内点或聚点不是A的内点或聚点.显然,B的每个元素都在A的闭包里.所以只要证B的每个聚点都在A的闭包里.假设B的某个聚点P不在A的闭包里,则P是A的外点.所以P的某个邻域U与A的交集是空集.而U内必定有B的元素.设Q为U与B的交集的某个元素.在Q的某个邻域内没有A的元素,即Q是A的外点.但既然Q是B的元素,则Q必定是A的内点或聚点.所以矛盾.原命题成立.

闭包点
对欧几里德空间的子集 S,x 是 S 的闭包点,若所有以 x 为中心的开球都包含 S 的点（这个点也可以是 x）.
这个定义可以推广到度量空间 X 的任意子集 S.具体地说,对具有度量 d 的度量空间 X,x 是 S 的闭包点,若对所有 r > 0,存在 y 属于 S,使得距离 d(x,y) < r（同样的,可以是 x = y）.另一种说法可以是,x 是 S 的闭包点,若距离 d(x,S) := inf{d(x,s) :s 属于 S} = 0（这里 inf 表示下确界）.
这个定义也可以推广到拓扑空间,只需要用邻域替代“开球”.设 S 是拓扑空间 X 的子集,则 x 是 S 的闭包点,若所有 x 邻域都包含 S 的点.注意,这个定义并不要求邻域是开的.
极限点
闭包点的定义非常接近极限点的定义.这两个定义之间的差别非常微小但很重要——在极限点的定义中,点 x 的邻域必须包含和 x 不同的集合的点.
因此,所有极限点都是闭包点,但不是所有的闭包点都是极限点.不是极限点的闭包点就是孤点.也就是说,点 x 是孤点,若它是 S 的元素,且存在 x 的邻域,该邻域中除了 x 没有其他的点属于 S.
对给定的集合 S 和点 x,x 是 S 的闭包点,当且仅当 x 属于 S,或 x 是 S 的极限点.
集合的闭包
集合 S 的闭包是所有 S 的闭包点组成的集合.S 的闭包写作 cl(S),Cl(S) 或 S−.集合的闭包具有如下性质：
cl(S) 是 S 的闭父集.
cl(S) 是所有包含 S 的闭集的交集.
cl(S) 是包含 S 的最小的闭集.
集合 S 是闭集,当且仅当 S = cl(S).
若 S 是 T 的子集,则 cl(S) 是 cl(T) 的子集.
若 A 是闭集,则 A 包含 S 当且仅当 A 包含 cl(S).
有时候,上述第二或第三条性质会被作为拓扑闭包的定义.
在第一可数空间（如度量空间）中,cl(S) 是所有点的收敛数列的所有极限.
注意,若将“闭包”,“交集”,“包含”,“最小”,“闭”等词汇相应替换成“内部”,“并集”,“饱含于”,“最大”,“开”,上述性质仍然成立.更多信息请参看下面的“闭包运算”.
闭包的本质
集合 S 是闭集当且仅当 Cl(S)=S.特别的,空集的闭包是空集,X 的闭包是 X.集合的交集的闭包总是集合的闭包的交集的子集（不一定是真子集）.有限多个集合的并集的闭包和这些集合的闭包的并集相等；零个集合的并集为空集,所以这个命题包含了前面的空集的闭包的特殊情况.无限多个集合的并集的闭包不一定等于这些集合的闭包的并集,但前者一定是后者的父集
若 A 为包含 S 的 X 的子空间,则 S 在 A 中计算得到的闭包等于 A 和 S 在 X 中计算得到的闭包（Cl_A(S) = Acap Cl_X(S)）的交集.特别的,S 在 A 中是稠密的,当且仅当 A 是 Cl_X(S) 的子集.

用延拓定理,如果不属于,则根据x和span（xn：n＞=1）的闭包做个泛函f,这个泛函在span（xn：n＞=1）的闭包上取0,在x处取x到闭包的距离,这样f(xn)不收敛到f(x).

1:如果集合A是闭集,那么A=他的闭包,显然有相同的极限点
2；如果A是一开集,它可以表示为可数个开区间（互不相交的构成区间）的并,
那么对于其中任意一个区间An=（an,bn),只要证明an,bn是极限点,其他的点都是极限点,故它极限点的集合就是An的闭.而对于An的闭[an,bn]显然极限点的集合也是An的闭,证明这是很容易的,严格的语言表达你自己动手做一下.
对于2还有1个特别的情况就是出现（bn-1,an),(an,bn),那么an为A的1个极限点,而它的闭包为[bn-1,bn],极限点包含an.
3：对于一任意集合A,不外呼1,2,1并2的情况.
证明完备.

闭包上包含所给集合的最小闭集,函数在闭集上有许多性质,我们可以通过研究函数在闭包上的性质来(近似)推测函数在原来集合上的性质.

自反闭包，是将矩阵主对角线上元素全变成1
对称闭包，是将矩阵非主对角线上的1元素，转置后的元素（行列交换,，即位置与主对角线对称）也变成1，0元素不要管，即根据矩阵的情况来定