Here only list some important one.

Then–>Than

Lower Bound Algorithm condition 3. Condition should be stronged as the one and the only one to fuarantee the conclusion.

Example2 for the  Lower Bound Algorithm. It should stop in the previous step. There is a contradiction in the final step.

 For other errors please contact licody202 at yahoo. com. cn. These errors are as of 12/01/2007 from Dr. Gelfond lecture notes for CS5368 Intelligent System.

Any comments are welcome! 

SCC1:(A,B) (B,C)(C,D)(D,A)
SCC2:(G,E)(E,F)(F,G)(E,H)(H,E)
NonScc:(C,E)
Suppose  A  is the base point(choose randomly),  the time of composition is at least 3.
However, if we choose C as the base point , we only need 2 compositions around SCC1.  The similar situation happen to SCC2.
we delete B(composition (A,C)), and then C(composition (A,D);composition (A,E)): —> we have 2 choice
1. continute composition with A as the base point. In this case, we continue to composition (A,H)composition (A,F) composition (A,G) ? Is this the different method to do the composition? The idea is that before we want to delete one vertex in the graph, we have to finish all the composition between the base point and another point that is reachable from  the current vertex to guarantee that we can remove the current vertex safely, namely, we reserve the same resolution (space).
2. move to SCC2 select E as base point to minimize the times of composition…

Which is the one we should select? 

Linear Elimination(inout(N,D,C)) // What does inout mean?
{
  Found_Strongly_connected(GF); // the function is try to find all the SCC of GF of                                     //   (N,D,C)
  for(m=1;m<number_SCC;m++)   // in each SCC?
  {
   SCC(m);
   substitution=i;            //choose any var i belong to SCC
   L=all_reachable(i); // directly, all_reachable(i) return a set that is     
     //  directly reachable from i.
   While(!empty(L))
     { j=reachable(i);
       delete(j);
       for(p=1;p<n_constraint(j)&&C!=C(j,i);p++)   //hoe to express except C(j,i)    
       {
         compose(i,j,k) ;
         update(C);
         modify(L);
        
       }
     }
 
  }
  for(n=1;n<n_eliminated;n++)
  {
   delete(eliminated);
   delete(edges);
  }
  o=topsort(left); // functional ??
  while(!empty(o))
  {
    i=first(o);
    delete(i);
    L=all_reachable(i);
    while(!empty(L))
      {
         j=reachable(i);
         delete(j);
         for(p=1;p<n_constraint(j)&&C!=C(j,i);p++)   //hoe to express except C(j,i)    
           {
             compose(i,j,k) ;
             update(GF);
             modify(L);
        
           }
      }
   
  }

}

objective:  Empirical study of functional constraints-encode the elimination algorithm and run the program associate it to some constraint solver like YL’s solver to solve the all the constraints, including functional constraints. Specifically, we will control the proportion of functional constraint from 0%, 20%,40%,60%, 80%,100% in the experiment to illustrate how efficient the elimination algorithm is when compared to using solvers to solve these constraints directly.  

1. Generate the CSP(N,D,C), including both functional constraints and non-functional constraints (with the FC proportion of 0%, 20%,40%,60%, 80%,100% )and store them in  file 1.
2. Encode LE Algorithm and give the file 1 to LE, the output is stored in file 2.
3. Learn to use YL’s Solver to solve the constraints stored in file 2.  The output is file 3.
4. Use other traditional CSP solvers to deal with the same generated problem and store the output in file 4.
5. Compare file 3 and file 4. Analyze and write, refine  the  experiment into a document.