新建 文本文档.txt

Prolog开发的简单的几个人工智能方面的程序.含问题分析报告.

1.家族关系。以姐妹、父母儿子关系为基本关系。定义其他的家庭关系，如祖孙、舅甥等。请编写一个程序刻画《红楼梦》中的家族关系。
定义关系：
   male(string)：male(X)àX是男的
   female(string)：female(X)àX是女的
   parent_of(string,string)：parent_of(X,Y)àX是Y的父母
   sister_of(string,string)：sister_of(X,Y)àX是Y姐妹
   father(string,string)：father(X,Y)àX是Y的父亲
   mother(string,string)：mother(X,Y)àX是Y的母亲
   grandfather(string,string)：grandfather(X,Y)àX是Y的祖父
   offspring(string,string)：offspring(X,Y)àX是Y的祖先
   brother(string,string)：brother(X,Y)àX是Y的兄弟
   uncle(string,string)：uncle(X,Y)àX是Y的叔叔
   aunt(string,string): aunt(X,Y)àX是Y的姑姑
1.3源程序：
 predicates    /*1.家族关系*/
   male(string)
   female(string)
   parent_of(string,string)
   sister_of(string,string)
   father(string,string)
   mother(string,string)
   grandfather(string,string)
   offspring(string,string)
   brother(string,string)
   uncle(string,string)
   aunt(string,string)
   clauses
    male("jiayan").
	male("jiadaihua").
	male("jiadaishan").
	male("jiajing").
	male("jiazhen").
	male("jiayuan").
	male("jiadaison").
	male("jiashe").
	male("jiazhen").
	male("jialian").
	male("jiazhu").
    male("jiazong").
	male("jiabaoyu").
    male("jiahuan").
	
	female("youshi").
	female("jiarong").
	female("shitaijun").
	female("xingfuren").
	female("wangxifeng").
	female("wangfuren").
	female("liwan").
	female("baochai").
	female("daiyu").
	female("qiaojie").
	female("jiamin").
    female("jialan").
    parent_of("jiamin","daiyu").
	parent_of("jiayan","jiadaihua").
	parent_of("jiadaihua","jiajing").
	parent_of("jiajing","jiazhen").
	parent_of("jiazhen","jiarong").
	parent_of("youshi","jiarong").
	parent_of("jiashe","jialian").
	parent_of("jialian","qiaojie").
	parent_of("jiayuan","jiadaishan").
	parent_of("jiadaishan","jiashe").
	parent_of("jiadaishan","jiazhen").
	parent_of("jiadaishan","jiamin").
	parent_of("shitaijun","jiashe").
	parent_of("shitaijun","jiazhen").
	parent_of("shitaijun","jiamin").
	parent_of("jiazhen","jiazhu").
	parent_of("jiazhen","jiabaoyu").
	parent_of("wangfuren","jiazhu").
	parent_of("wangfuren","jiabaoyu").
        parent_of("jiashe","jiazong").
        parent_of("jiazhen","jiahuan").
        parent_of("jiazhu","jialan").
        sister_of("jiamin","jiashe").
	sister_of("jiamin","jiazhen").

   father(X,Y):-male(X),!,parent_of(X,Y).
   mother(X,Y):-parent_of(X,Y),female(X).   

   grandfather(X,Y):-
    father(X,Z),father(Z,Y).
   offspring(X,Y):-
    father(X,Y).
   offspring(X,Y):-
    father(X,Z),offspring(Z,Y).
   brother(X,Y):-
    father(Z,X),father(Z,Y),not(X=Y).
   uncle(X,Y):-
    brother(X,Z),father(Z,Y).  
   aunt(X,Z):-sister_of(X,Y),
         father(Y,Z).
2.定义集合上的关系
append(ilist,ilist,ilist):append(X,Y,Z)à将表X,Y合并为新表Z
  merge_set(ilist,ilist,ilist)：并集merge_set(x,y,z)=>x+y=z
  member(integer,ilist,integer)：member(x,ilist，y)=>ilist的第y个元素是x
  diff_set(ilist,ilist,ilist)：差集diff_set(x,y,z)=>z=x-y
  same_set(ilist,ilist,ilist)：交集same_set(x,y,z)=>x^y=z*/
  del_meb(integer,ilist,ilist)：删除ilist中的第integer个元素
2.3源程序：
domains 
  ilist=integer*
predicates
  append(ilist,ilist,ilist)
  merge_set(ilist,ilist,ilist)       /*并集merge_set(x,y,z)=>x+y=z*/
  member(integer,ilist,integer)      /*member(x,ilist，y)=>ilist的第y个元素是x*/
  diff_set(ilist,ilist,ilist)        /*差集diff_set(x,y,z)=>z=x-y*/
  same_set(ilist,ilist,ilist)        /*交集same_set(x,y,z)=>x^y=z*/
  del_meb(integer,ilist,ilist)       /*删除ilist中的第integer个元素*/
clauses
  append([],Ilist,Ilist).
  append([Head|Tail],List2,[Head|List3]):-
    append(Tail,List2,List3).

  merge_set([],X,X):-!.
  merge_set(X,[],X):-!.
  merge_set([Head|Tail],List2,[Head|List3]):-
    not(member(Head,List2,_)),
    merge_set(Tail,List2,List3).
  merge_set([X1|X],Y,Z):-
    member(X1,Y,_),merge_set(X,Y,Z).  
    
  member(_,[],_):-
     fail.
  member(X,[X|_],1):-!.
  member(X,[_|List],P):-
     !,member(X,List,N),P=N+1.

  diff_set([],_,[]).
  diff_set([X1|X],Y,[X1|Z]):-
    not(member(X1,Y,_)),diff_set(X,Y,Z).
  diff_set([X1|X],Y,Z):-
    member(X1,Y,_),diff_set(X,Y,Z).     

  same_set([],_,[]).
  same_set(_,[],[]).
  same_set([X1|X],Y,[X1|Z]):-
    member(X1,Y,_),same_set(X,Y,Z),!.
  same_set([_|X],Y,Z):-
    same_set(X,Y,Z).
  
  del_meb(1,[_|List],List).
  del_meb(I,[X|List],Result):-
      M=I-1,del_meb(M,List,Temp),
      append([X],Temp,Result).     
3。冒泡排序
3.1.2定义关系：
mp_sort(ilist,ilist)：冒泡排序，mp_order(X,Y)-〉将表X按冒泡排序为表Y.
        order(integer,integer):order(X,Y)àX<=Y.
append(ilist,ilist,ilist):表的合并，append(X,Y,Z)à将X,Y合并为表Z.
3.1.3源程序：
 domains
    ilist=integer*
 predicates
    mp_sort(ilist,ilist)
    order(integer,integer)
    append(ilist,ilist,ilist)
 clauses
    mp_sort([X],[X]):-!.
    mp_sort(L,S):-
      append(X,[A,B|Y],L),
      order(B,A),
      append(X,[B,A|Y],M),
      !,
      mp_sort(M,S).
    mp_sort(L,L).
    
    append([],L,L).
    append([H|T],L1,[H|L2]):-append(T,L1,L2).
    order(X,Y):-X<=Y.        
归并排序
3.2.2定义关系
sort(ilist,ilist):归并排序，sort(X,Y)à将X按照归并算法排序为Y
  split(ilist,ilist,ilist)：split(X,Y,Z)à将X按照长度大约相等分为表Y和Z，表Y的长度为X的长度的一半（或一半加一）
  split_on(integer,ilist,ilist,ilist)：split_on(A,X,Y,Z)à将X分为Y,Z，且Y的长度为A.
  merge(ilist,ilist,ilist):merge(X,Y,Z)à将两个有序表X、Y按大小合并为有序表Z。
  length(integer,ilist)：length(A,X)à表X的长度为A。
3.2.3源程序
domains
  ilist=integer*
predicates
  sort(ilist,ilist)
  split(ilist,ilist,ilist)
  split_on(integer,ilist,ilist,ilist)
  merge(ilist,ilist,ilist)
  length(integer,ilist)
clauses 
  sort([],[]):-!.
  sort([X],[X]):-!.
  sort([X1,X2|Y],Y):-
     split([X1,X2|_],Y1,Y2),
     sort(Y1,Z1),
     sort(Y2,Z2),!,
     merge(Z1,Z2,Y).
     
  merge([],X,X).
  merge(X,[],X).
  merge([B1|Y1],[B1|Y2],[B1,B1|Y]):-
     merge(Y1,Y2,Y).
  merge([B1|Y1],[B2|Y2],[B1|Y]):-
     B1<B2,
     merge(Y1,[B2|Y2],Y).
  merge([B1|Y1],[B2|Y2],[B2|Y]):-
     B2<B1,
     merge([B1|Y1],Y2,Y).      
     
  split(X,X1,X2):-
     length(N,X),    
     M=N/2,     
     split_on(M,X,X1,X2).
 split_on(0,X,[],X).
 split_on(Y,[X1|Z],[X1|Z1],Z2):-
     split_on(Y1,Z,Z1,Z2),
     Y=Y1+1.
 length(0,[]).
 length(M,[_|X]):-
    length(N,X),
    M=N+1.     
4。定义回文（Palin）关系
回文（Palin）:对于给定的一段文字，若其顺序与倒序完全相同，则称之为回文。包括："abcdefghijjihgfedcba"与"aba"两种形式。
4.2定义关系:
palin(sylist):回文关系,palin(X)àX是一回文.
    reverse(sylist,sylist):逆序关系,reverse(X,Y)à Y是X的逆序.
append(sylist,sylist,sylist):表的合并关系.append(X,Y,Z)à将X,Y合并为新表Z.
4.3源程序：
domains
  sylist=symbol*
predicates
  palin(sylist)
  reverse(sylist,sylist)
  append(sylist,sylist,sylist)
clauses
  palin([]).
  palin([X|[Y,X]]).
  palin([X|L]):-
    reverse(L,[X|M]),palin(M).
  
  reverse([],[]).
  reverse([Head|Tail],Result):-
    !,
    reverse(Tail,Temp),
    append(Temp,[Head],Result).
  append([],List,List).
  append([Head|List1],List2,[Head|Rest]):-
     append(List1,List2,Rest),!.
5。歌德巴赫猜想是指：对于任意的不小于6的偶数都可以写为两个素数之和。如：6=3+3，16=7+9，………
筛选法是判定一个数是否为素数的方法。具体为：若判定n是否为素数，则构造集合[2，3，4，……n],重复删除第一个元素以及它的所有倍数，直至给集合中只有最后一个元素n，则n为素数，否则，n不为素数。
5.2定义关系:
bahe(integer,ilist):bahe(X,[X1,X2])àX=X1+X2,且X1,X2都是素数.
  belong(integer,ilist):belog(X,Lst)à表示X是表LST中的元素.
  prisub(integer,ilist): prisub(X,Lst)àLst中的元素是从2到X的所有素数.
  int(integer,integer,ilist):int(A,B,LST)àLST中的元素是A,B之间的所有整数.
  shif(ilist,ilist):shif(LST1,LST2)à将表LST1中的非素数删去即可得到表LST2.
  del(integer,ilist,ilist):del(X,LST1,LST2)à从表LST1中删去所有的X的倍数即可得表LST2.
  modd(integer,integer,integer): modd(X,Y,Z)àZ=X mod Y.
  no(integer,ilist,integer):no(X,LST,Y)à表LST中的第X个元素是Y.
5.3源程序：
domains
  ilist=integer*
predicates
  bahe(integer,ilist)
  belong(integer,ilist)
  prisub(integer,ilist)
  int(integer,integer,ilist)
  shif(ilist,ilist)
  del(integer,ilist,ilist)
  modd(integer,integer,integer)
  no(integer,ilist,integer)
clauses
  bahe(X,[Y1,Y2]):-
    prisub(X,Y),no(I,Y,Y1),
    Y2=X-Y1,
    belong(Y2,Y).
    
 no(1,[X|_],X).
 no(I,[_|Y],Z):-no(M,Y,Z),I=M+1. 
    
 belong(_,[]):-fail.
 belong(X,[X|_]):-!.
 belong(X,[_|Y]):-belong(X,Y).   
      
  prisub(X,S1):-int(2,X,I1),shif(I1,S1).
  
  int(L,H,[L|Result]):-
     L<=H,
     N=L+1,
     int(N,H,Result).
  int(A,B,[]):-A>B.
     
  
  shif([],[]).
  shif([I|X],[I|Y]):-
      del(I,X,X1),
      shif(X1,Y).
         
  del(_,[],[]).
  del(N1,[I|X],[I|Y]):-
      not(modd(I,N1,0)),!,
      del(N1,X,Y).
  del(N1,[I|X],Y):-
      modd(I,N1,0),
      del(N1,X,Y).
          
  modd(X,Y,Z):-Z=X mod Y.