syncretism.java

人工智能经典问题之 最一般合一算法JAVA实现

import java.applet.Applet;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.xml.soap.Text;
/**
 * 该程序是关于最一般合一算法的实现
 * 本程序目前存在2个大问题：
 * 1、不能对个数超过2个的F谓词集合进行分析
 * 2、当谓词中存在超过1个自变量的函数时，还不能进行判断。
 * @author Administrator
 *
 */
 
public class Syncretism extends Applet implements ActionListener {
	
	TextField field1 ;
	TextField field2 ;
	Button b1 ;
	String test1;
	String test2;
	String mon[];
	String t[];
	String v[];
	public void init(){
		
		field1 = new TextField();
		field2 = new TextField();
		b1 = new Button("输入");
		b1.addActionListener(this);
		test1 = new String();
		test2 = new String();
	   	GridBagLayout gridbag = new GridBagLayout();
		GridBagConstraints cel = new GridBagConstraints();
	    setLayout(gridbag);
		cel.fill = GridBagConstraints.BOTH;
	    cel.gridheight = 1;
	    cel.gridwidth = 1;
	    cel.weightx = 1;
	    cel.weighty = 1;
	    gridbag.setConstraints(field1, cel);
	    add(field1);
		
	    cel.gridwidth = GridBagConstraints.REMAINDER ;
	    gridbag.setConstraints(b1, cel);
	    add(b1);
	    
	    cel.gridwidth = GridBagConstraints.REMAINDER ;
	    gridbag.setConstraints(field2, cel);
	    add(field2);
	    
	}
	
	public  void actionPerformed(ActionEvent event){
		
		if(event.getSource().equals(b1))
		{
			test1 = field1.getText(); 
		    mon =  Getmess(test1);
		    alogrithm(mon);
		
		} 
		
		 
	}
	
	public String[] Getmess(String source){
		  
		 String [] result;
		 String [] result1;
		 result = source.split("[A-Z]");
		 
		 for(int i = 1;i<result.length;i++)
		     result[i] = result[i].substring(result[i].indexOf('(')+1,result[i].lastIndexOf(')'));	 
		 		 		 
		return result;
	}
	 
	/**
	 * 要考虑到2个谓词公式的长短不一致的情况
	 * 程序暂时没有考虑,先无视
	 */
	public String[] Finddiff(String sour1,String sour2){
		String [] a1 = sour1.split(",");
		String [] a2 = sour2.split(",");
		String  d[]  = new String[2];
		
		for(int j=0;j<2;j++)
			d[j] =" ";
		int max = a1.length;
		if(a2.length>max)
		   max = a2.length;
		
	   	for(int i = 0;i<max;i++)
			if(a1[i].equals(a2[i]));
			else
			{ 
				d[0] = a1[i];
				d[1] = a2[i];
			    break;
			}
	    return d;
	}
	   
	public int alogrithm(String []f){
		String newresult[]= new String[f.length/2];
		String comeout = "this is:";
		t = new String[f.length];
		v = new String[f.length];
		 for(int j =0 ;j<t.length;j++)
		 { 
			 t[j] = " ";
		     v[j] = " ";
		 } 
		int p =0;
		if(f.length==1)
			return 1;
		 
		for(int i=1;i<f.length;i+=2)
		   {
			String mn = Execute(f[i],f[i+1],0);
			if(mn.equals("null"))
				{
				 field2.setText("不存在合一");
				 return 0;
				}
			else
			    {
				 for(int l = 0;l<f.length;l++)
					  if(t[l].equals(" "));
					  else
						  comeout = comeout+t[l]+"/"+v[l]+",";
				  field2.setText(comeout);
				  newresult[p++]=mn;
				}
		   }
		if(alogrithm(newresult)==0)
			return 0;
		else 
			
			return 1;//最后的结果是返回项集
		
	}
	
	public boolean Endcondition(String test){
	  
		for(int i=0;i<t.length;i++)
		   if(t[i].equals(test))
			   return true;
		   else
			   return false;
		
	   return true;
	}   
	  
	public String Execute(String a,String b,int ps){
		 
		 String diff [] ;
		 String ax = a;
		 String bx = b;
 		 String temp1,temp2;
 		 String object;
 		 String represent;
 		 String end;
 		 diff=Finddiff(a,b);
		  
 		 if(diff[0].length()!=1&&diff[1].length()!=1)
 		   if(parnumber(diff[0])>1&&parnumber(diff[1])>1)
		     {
		    	 ;
		     }
		     else if(parnumber(diff[0])==parnumber(diff[1]))
		         {
		    	   if(Isconstant(diff[0])||Isconstant(diff[1]));
		    	   else
		    	   {  
		    		 diff[0] = selfvariant(diff[0]);
		    	     diff[1] = selfvariant(diff[1]);
		    	   }
		    	 }
 		    
 		
 		 
 		 temp1 = whoreplace(diff[0],diff[1]);/*查看差异集合中一个元素里面由谁替换谁,
		                                             根据的是看谁是变元,谁是常量,以及函数
		                                      */
		 if(temp1.equals("null"))
			 return "null";                    /*测试是否因为集合中差异集中不存在项集和变元的组合
			                                        而导致无合一的算法结束
		                                      */ 
		 if(temp1.equals(diff[0]))
			  temp2 = diff[1];
		  else
			  temp2 = diff[0];
		                                   
		   t[ps] = temp1;
		   v[ps] = temp2; 
		   ps++;                               /*T中保存的是项集合,
		                                           用于在比较替换量时候的判断
		                                     */
		
		 object =  replaceExe(ax,temp2,temp1);  
		 represent = replaceExe(bx, temp2, temp1);
		 ax = "object:"+object+",represent:"+represent+'\n';
		 System.out.print(ax);
		 diff = Finddiff(represent,object); /*检查新替换后的字符串和原来的字符串
		                                            是否已经一样
		                                     */
		 if(diff[1].equals(" "))
			return  object; 
		 else
			end = Execute(represent,object,ps);
	     
		 if(end.equals(null)) return "null";
		 else 
			 return end;
		
	}
	
	
	public String replaceExe(String source,String object,String represent){
		
		source = source.replace(object, represent);
		
		return source;
	}
	
	/**
	 * 寻找谁替换谁的方法
	 * 但是这里在考虑的过程中,无视了函数常量
	 * 这里考虑了当2个都是单元素变量的时候,该如何判断.
	 * 此时,只要判断2者是否都是项集合T 中的元素,都是返回NULL,无解.
	 * 其中一个不是 就让不是的替换是的
	 */
	public String whoreplace(String s1,String s2 ){
		
		if(s1.length()==1&&s2.length()==1)
		{  if(Isconstant(s1))
		     {
			  if(Isconstant(s2))
			    return "null";
		      else if(Isvariant(s2))
			    {
		    	  if(Endcondition(s2))
			    	return "null";
			      else
			    	return s1;
			    } 
			 }
		   else  if(Isvariant(s2))
		    {
			 if(Endcondition(s1)&&Endcondition(s2)) 	
			     return "null";
			 else if(Endcondition(s1))
			     return s2;
			 else 
			    return s1;
		    }    
		   else 
			   return s2;
		}  
		else if(s1.length()==1)
			 {
			   if(Isvariant(s1))
				 if(Endcondition(s1))
					 return "null";
		         else
		    	     return s2;
			   else
			     return "null";
			 }
		else if(s2.length()==1)
		     {
			   
			    boolean mm = Isvariant(s2);
			    boolean gg = Endcondition(s2);
			    if(Isvariant(s2))
				   if(Endcondition(s2))
					   return "null";
				   else
					   return s1;
			   else
				   return "null";
		     }
		else if(Isconstant(s1)||Isconstant(s2))//要是含有函数常量，那么又是非变量的2个量则 无解
			      return "null";
		
	    return "fuck";
	} 
	
	
	public boolean samefunction(String s1,String s2){
		if(s1.charAt(0)==s2.charAt(0))
			return true;
		else 
			return false;
	 	
	}
	public int parnumber(String s1){
		int count = 0;
		String a1;
		String b1[];
		a1 = selfvariant(s1);
		if(a1.contains(","))
		{
			b1 = a1.split(",");
		    count = b1.length+1;
		
		}
		else
		count = 1;
		return count;
	}
	
	/**
	 * 剥去函数的函数名以及括号,只剩下参数组
	 * 函数的参数可能不只一个
	 */
	public String selfvariant(String function){
		String variant;
		variant =  function.substring(function.indexOf("(")+1, function.lastIndexOf(")"));
		return variant;
	} 
	 
	public boolean Isconstant(String s){
		String variant[];
		if(s.contains(","))//这个判断是判断多元参数的时候用的
		     {
			    variant = s.split(",");
			    for(int i=0;i<variant.length;i++)
			    	if(Isconstant(variant[i])!=true)
			    		return false;
		        return true;
		     }
		else if(s.length()!=1)//不能排除自变量是常量的函数
			    if(Isconstant(selfvariant(s)))
				   return true;
			    else
				   return false;
		
	   if(s.equals("a")||s.equals("b")||s.equals("c")||s.equals("d")||s.equals("e"))
		  return true;
	   else
		  return false;
	}
	
	public boolean Isvariant(String s){
	    if(s.length()!=1)
	    	return false;
		if(Isconstant(s))
	    	return false;
	    else
	    	return true;
	}
	
	public boolean Isfunction(String s){
		if(s.length()==1)
			return false;
		else
			return true;
	}
  
	 
}