X-Git-Url: http://plrg.eecs.uci.edu/git/?p=repair.git;a=blobdiff_plain;f=Repair%2FRepairCompiler%2FMCC%2FIR%2FTermination.java;h=5d25732106884d1a26f81fce5a483f974d3559be;hp=2dccba3de978c8fce64bba9c4ed774d08bda1169;hb=726db8dc825fb7f33f64f0aca6a4f63b0ba43313;hpb=ca628f50b6dedc5c650dea4c6862260efba76136

diff --git a/Repair/RepairCompiler/MCC/IR/Termination.java b/Repair/RepairCompiler/MCC/IR/Termination.java
index 2dccba3..5d25732 100755
--- a/Repair/RepairCompiler/MCC/IR/Termination.java
+++ b/Repair/RepairCompiler/MCC/IR/Termination.java
@@ -9,6 +9,8 @@ public class Termination {
     Hashtable conjunctionmap;
 
     HashSet abstractrepair;
+    HashSet abstractrepairadd;
+
     HashSet updatenodes;
     HashSet consequencenodes;
 
@@ -21,14 +23,27 @@ public class Termination {
     Hashtable conjtonodemap;
     Hashtable predtoabstractmap;
     Set removedset;
-
+    ComputeMaxSize maxsize;
     State state;
+    AbstractInterferes abstractinterferes;
+    ConcreteInterferes concreteinterferes;
+    ConstraintDependence constraintdependence;
+    ExactSize exactsize;
+    ArrayAnalysis arrayanalysis;
+    Sources sources;
+    static String conjoption="style=bold";
+    static String absrepoption="shape=box,color=blue,style=bold";
+    static String updateoption="shape=box,color=red,style=bold";
+    static String scopeoption="color=brown";
+    static String conseqoption="style=bold,color=green";
+    static String compoption="shape=box,color=purple,style=bold";
 
     public Termination(State state) {
 	this.state=state;
 	conjunctions=new HashSet();
 	conjunctionmap=new Hashtable();
 	abstractrepair=new HashSet();
+	abstractrepairadd=new HashSet();
 	scopenodes=new HashSet();
 	scopesatisfy=new Hashtable();
 	scopefalsify=new Hashtable();
@@ -42,24 +57,43 @@ public class Termination {
 	if (!Compiler.REPAIR)
 	    return;
 
+
+	for(int i=0;i<state.vRules.size();i++)
+	    System.out.println(state.vRules.get(i));
+	for(int i=0;i<state.vConstraints.size();i++)
+	    System.out.println(state.vConstraints.get(i));
+
+	sources=new Sources(state);
+	maxsize=new ComputeMaxSize(state);
+	exactsize=new ExactSize(state);
+	arrayanalysis=new ArrayAnalysis(state,this);
+
+	abstractinterferes=new AbstractInterferes(this);
+	concreteinterferes=new ConcreteInterferes(this);
 	generateconjunctionnodes();
+	constraintdependence=new ConstraintDependence(state,this);
+
+        debugmsg("Generating scope nodes");
 	generatescopenodes();
+        debugmsg("Generating repair nodes");
 	generaterepairnodes();
+        debugmsg("Generating data structure nodes");
 	generatedatastructureupdatenodes();
-	generatecompensationnodes();
-
+        debugmsg("Generating compensation nodes");
+	if (!Compiler.OMITCOMP)
+	    generatecompensationnodes();
+        debugmsg("Generating abstract edges");
 	generateabstractedges();
+        debugmsg("Generating scope edges");
 	generatescopeedges();
+        debugmsg("Generating update edges");
 	generateupdateedges();
 
+
 	HashSet superset=new HashSet();
 	superset.addAll(conjunctions);
 	HashSet closureset=new HashSet();
-	//	closureset.addAll(updatenodes);
-	//superset.addAll(abstractrepair);
-	//superset.addAll(updatenodes);
-	//superset.addAll(scopenodes);
-	//superset.addAll(consequencenodes);
+        debugmsg("Computing closure");
 	GraphNode.computeclosure(superset,closureset);
 	try {
 	    GraphNode.DOTVisitor.visit(new FileOutputStream("graph.dot"),superset);
@@ -67,6 +101,9 @@ public class Termination {
 	    e.printStackTrace();
 	    System.exit(-1);
 	}
+
+	generatedebuggraphs();
+
 	for(Iterator it=updatenodes.iterator();it.hasNext();) {
 	    GraphNode gn=(GraphNode)it.next();
 	    TermNode tn=(TermNode)gn.getOwner();
@@ -80,6 +117,7 @@ public class Termination {
 	    System.out.println("Can't generate terminating repair algorithm!");
 	    System.exit(-1);
 	}
+
 	System.out.println("Removing:");
 	for(Iterator it=removedset.iterator();it.hasNext();) {
 	    GraphNode gn=(GraphNode)it.next();
@@ -96,11 +134,41 @@ public class Termination {
 	    e.printStackTrace();
 	    System.exit(-1);
 	}
+	constraintdependence.traversedependences(this);
+    }
+
+    void generatedebuggraphs() {
+	for (int i=0;i<Compiler.debuggraphs.size();i++) {
+	    DebugItem di=(DebugItem) Compiler.debuggraphs.get(i);
+	    HashSet superset=new HashSet();
+	    Constraint constr=(Constraint)state.vConstraints.get(di.constraintnum);
+
+	    if (di.conjunctionnum==-1) {
+		superset.addAll((Set)conjunctionmap.get(constr));
+	    } else {
+		DNFConstraint dnf=constr.dnfconstraint;
+		superset.add(conjtonodemap.get(dnf.get(di.conjunctionnum)));
+	    }
 
+	    GraphNode.boundedcomputeclosure(superset,null,di.depth);
+	    try {
+		GraphNode.DOTVisitor.visit(new FileOutputStream("graph"+di.constraintnum+"-"+di.depth+(di.conjunctionnum==-1?"":"-"+di.conjunctionnum)+".dot"),superset);
+	    } catch (Exception e) {
+		e.printStackTrace();
+		System.exit(-1);
+	    }
+	}
     }
-    
+
+
+    /** This method generates a node for each conjunction in the DNF
+     * form of each constraint.  It also converts the quantifiers into
+     * conjunctions also - constraints can be satisfied by removing
+     * items from the sets and relations they are quantified over */
+
     void generateconjunctionnodes() {
 	Vector constraints=state.vConstraints;
+	// Constructs conjunction nodes
 	for(int i=0;i<constraints.size();i++) {
 	    Constraint c=(Constraint)constraints.get(i);
 	    DNFConstraint dnf=c.dnfconstraint;
@@ -109,12 +177,14 @@ public class Termination {
 		GraphNode gn=new GraphNode("Conj"+i+"A"+j,
 					   "Conj ("+i+","+j+") "+dnf.get(j).name()
 					   ,tn);
+		gn.setOption(conjoption);
 		conjunctions.add(gn);
 		if (!conjunctionmap.containsKey(c))
 		    conjunctionmap.put(c,new HashSet());
 		((Set)conjunctionmap.get(c)).add(gn);
 		conjtonodemap.put(dnf.get(j),gn);
 	    }
+	    // Construct quantifier "conjunction" nodes
 	    for(int j=0;j<c.numQuantifiers();j++) {
 		Quantifier q=c.getQuantifier(j);
 		if (q instanceof SetQuantifier) {
@@ -124,14 +194,17 @@ public class Termination {
 		    DNFConstraint dconst=new DNFConstraint(ip);
 		    dconst=dconst.not();
 		    TermNode tn=new TermNode(c,dconst.get(0));
+		    tn.setquantifiernode();
 		    GraphNode gn=new GraphNode("Conj"+i+"AQ"+j,
 					       "Conj ("+i+","+j+") "+dconst.get(0).name()
 					       ,tn);
+		    gn.setOption(conjoption);
 		    conjunctions.add(gn);
 		    if (!conjunctionmap.containsKey(c))
 			conjunctionmap.put(c,new HashSet());
 		    ((Set)conjunctionmap.get(c)).add(gn);
 		    conjtonodemap.put(dconst.get(0),gn);
+
 		} else if (q instanceof RelationQuantifier) {
 		    RelationQuantifier rq=(RelationQuantifier)q;
 		    VarExpr ve=new VarExpr(rq.y);
@@ -139,9 +212,11 @@ public class Termination {
 		    DNFConstraint dconst=new DNFConstraint(ip);
 		    dconst=dconst.not();
 		    TermNode tn=new TermNode(c,dconst.get(0));
+		    tn.setquantifiernode();
 		    GraphNode gn=new GraphNode("Conj"+i+"AQ"+j,
 					       "Conj ("+i+","+j+") "+dconst.get(0).name()
 					       ,tn);
+		    gn.setOption(conjoption);
 		    conjunctions.add(gn);
 		    if (!conjunctionmap.containsKey(c))
 			conjunctionmap.put(c,new HashSet());
@@ -157,15 +232,48 @@ public class Termination {
 	    GraphNode gn=(GraphNode)updateiterator.next();
 	    TermNode tn=(TermNode)gn.getOwner();
 	    MultUpdateNode mun=tn.getUpdate();
+	    for(int i=0;i<mun.numUpdates();i++) {
+		UpdateNode un=mun.getUpdate(i);
+		for(int j=0;j<un.numUpdates();j++) {
+		    Updates u=un.getUpdate(j);
+		    if (u.getType()==Updates.ABSTRACT) {
+			Expr e=u.getLeftExpr();
+			boolean negated=u.negate;
+			if (e instanceof TupleOfExpr) {
+			    TupleOfExpr toe=(TupleOfExpr)e;
+			    if (negated) {
+				GraphNode agn=(GraphNode)abstractremove.get(toe.relation);
+				GraphNode.Edge edge=new GraphNode.Edge("requires",agn);
+				gn.addEdge(edge);
+			    } else {
+				GraphNode agn=(GraphNode)abstractadd.get(toe.relation);
+				GraphNode.Edge edge=new GraphNode.Edge("requires",agn);
+				gn.addEdge(edge);
+			    }
+			} else if (e instanceof ElementOfExpr) {
+			    ElementOfExpr eoe=(ElementOfExpr)e;
+			    if (negated) {
+				GraphNode agn=(GraphNode)abstractremove.get(eoe.set);
+				GraphNode.Edge edge=new GraphNode.Edge("requires",agn);
+				gn.addEdge(edge);
+			    } else {
+				GraphNode agn=(GraphNode)abstractadd.get(eoe.set);
+				GraphNode.Edge edge=new GraphNode.Edge("requires",agn);
+				gn.addEdge(edge);
+			    }
+			} else throw new Error("Unrecognized Abstract Update");
+		    }
+		}
+	    }
 	    /* Cycle through the rules to look for possible conflicts */
 	    for(int i=0;i<state.vRules.size();i++) {
-		Rule r=(Rule) state.vRules.get(i);  
-		if (ConcreteInterferes.interferes(mun,r,true)) {
+		Rule r=(Rule) state.vRules.get(i);
+		if (concreteinterferes.interferes(mun,r,true)) {
 		    GraphNode scopenode=(GraphNode)scopesatisfy.get(r);
 		    GraphNode.Edge e=new GraphNode.Edge("interferes",scopenode);
 		    gn.addEdge(e);
 		}
-		if (ConcreteInterferes.interferes(mun,r,false)) {
+		if (concreteinterferes.interferes(mun,r,false)) {
 		    GraphNode scopenode=(GraphNode)scopefalsify.get(r);
 		    GraphNode.Edge e=new GraphNode.Edge("interferes",scopenode);
 		    gn.addEdge(e);
@@ -179,42 +287,101 @@ public class Termination {
 	    GraphNode gn=(GraphNode)absiterator.next();
 	    TermNode tn=(TermNode)gn.getOwner();
 	    AbstractRepair ar=(AbstractRepair)tn.getAbstract();
-	
+
 	    for(Iterator conjiterator=conjunctions.iterator();conjiterator.hasNext();) {
 		GraphNode gn2=(GraphNode)conjiterator.next();
 		TermNode tn2=(TermNode)gn2.getOwner();
 		Conjunction conj=tn2.getConjunction();
 		Constraint cons=tn2.getConstraint();
+		/* See if this is a relation wellformedness constraint
+                   that is trivially satisfied. */
+		if (abstractinterferes.checkrelationconstraint(ar, cons))
+		    continue;
+                if (AbstractInterferes.interferesquantifier(ar,cons)) {
+                    GraphNode.Edge e=new GraphNode.Edge("interferes",gn2);
+                    gn.addEdge(e);
+                } else {
+                    for(int i=0;i<conj.size();i++) {
+                        DNFPredicate dp=conj.get(i);
 
-		for(int i=0;i<conj.size();i++) {
-		    DNFPredicate dp=conj.get(i);
-		    if (AbstractInterferes.interferes(ar,cons)||
-			AbstractInterferes.interferes(ar,dp)) {
-			GraphNode.Edge e=new GraphNode.Edge("interferes",gn2);
-			gn.addEdge(e);
-			break;
-		    }
-		}
+                        if (!abstractinterferes.interfereswithpredicate(ar,dp))
+                            continue;
+                        if (getConstraint(gn)==null||
+                            !abstractinterferes.interferemodifies(ar,getConstraint(gn),dp,cons)) {
+                            GraphNode.Edge e=new GraphNode.Edge("interferes",gn2);
+                            gn.addEdge(e);
+                            break;
+                        }
+                    }
+                }
 	    }
-
 	    for(Iterator scopeiterator=scopenodes.iterator();scopeiterator.hasNext();) {
 		GraphNode gn2=(GraphNode)scopeiterator.next();
 		TermNode tn2=(TermNode)gn2.getOwner();
 		ScopeNode sn2=tn2.getScope();
-		if (AbstractInterferes.interferes(ar,sn2.getRule(),sn2.getSatisfy())) {
+		if (AbstractInterferes.interfereswithrule(ar,sn2.getRule(),sn2.getSatisfy())) {
 		    GraphNode.Edge e=new GraphNode.Edge("interferes",gn2);
 		    gn.addEdge(e);
 		}
 	    }
 	}
     }
-    
+
+    Constraint getConstraint(GraphNode gn) {
+        for(Iterator it=gn.inedges();it.hasNext();) {
+            GraphNode.Edge e=(GraphNode.Edge)it.next();
+            GraphNode gnsource=e.getSource();
+            TermNode tnsource=(TermNode)gnsource.getOwner();
+            if (tnsource.getType()==TermNode.CONJUNCTION) {
+                return tnsource.getConstraint();
+            }
+        }
+        return null;
+    }
+
+    void generatescopenodes() {
+	for(int i=0;i<state.vRules.size();i++) {
+	    Rule r=(Rule) state.vRules.get(i);
+	    ScopeNode satisfy=new ScopeNode(r,true);
+	    TermNode tnsatisfy=new TermNode(satisfy);
+	    GraphNode gnsatisfy=new GraphNode("SatisfyRule"+i,tnsatisfy);
+	    gnsatisfy.setOption(scopeoption);
+	    gnsatisfy.setMerge();
+	    ConsequenceNode cnsatisfy=new ConsequenceNode();
+	    TermNode ctnsatisfy=new TermNode(cnsatisfy);
+	    GraphNode cgnsatisfy=new GraphNode("ConseqSatisfyRule"+i,ctnsatisfy);
+	    cgnsatisfy.setOption(conseqoption);
+	    consequence.put(satisfy,cgnsatisfy);
+	    GraphNode.Edge esat=new GraphNode.Edge("consequencesatisfy"+i,cgnsatisfy);
+	    gnsatisfy.addEdge(esat);
+	    consequencenodes.add(cgnsatisfy);
+	    scopesatisfy.put(r,gnsatisfy);
+	    scopenodes.add(gnsatisfy);
+
+	    ScopeNode falsify=new ScopeNode(r,false);
+	    TermNode tnfalsify=new TermNode(falsify);
+	    GraphNode gnfalsify=new GraphNode("FalsifyRule"+i,tnfalsify);
+	    gnfalsify.setOption(scopeoption);
+	    gnfalsify.setMerge();
+	    ConsequenceNode cnfalsify=new ConsequenceNode();
+	    TermNode ctnfalsify=new TermNode(cnfalsify);
+	    GraphNode cgnfalsify=new GraphNode("ConseqFalsifyRule"+i,ctnfalsify);
+	    cgnfalsify.setOption(conseqoption);
+	    consequence.put(falsify,cgnfalsify);
+	    GraphNode.Edge efals=new GraphNode.Edge("consequencefalsify"+i,cgnfalsify);
+	    gnfalsify.addEdge(efals);
+	    consequencenodes.add(cgnfalsify);
+	    scopefalsify.put(r,gnfalsify);
+	    scopenodes.add(gnfalsify);
+	}
+    }
+
     void generatescopeedges() {
 	for(Iterator scopeiterator=scopenodes.iterator();scopeiterator.hasNext();) {
 	    GraphNode gn=(GraphNode)scopeiterator.next();
 	    TermNode tn=(TermNode)gn.getOwner();
 	    ScopeNode sn=tn.getScope();
-	    
+
 	    /* Interference edges with conjunctions */
 	    for(Iterator conjiterator=conjunctions.iterator();conjiterator.hasNext();) {
 		GraphNode gn2=(GraphNode)conjiterator.next();
@@ -223,8 +390,8 @@ public class Termination {
 		Constraint constr=tn2.getConstraint();
 		for(int i=0;i<conj.size();i++) {
 		    DNFPredicate dp=conj.get(i);
-		    if (AbstractInterferes.interferes(sn,dp)||
-			AbstractInterferes.interferes(sn.getDescriptor(),sn.getSatisfy(),constr)) {
+		    if (abstractinterferes.scopeinterfereswithpredicate(sn,dp)||
+			AbstractInterferes.interfereswithquantifier(sn.getDescriptor(),sn.getSatisfy(),constr)) {
 			GraphNode.Edge e=new GraphNode.Edge("interferes",gn2);
 			GraphNode gnconseq=(GraphNode)consequence.get(sn);
 			gnconseq.addEdge(e);
@@ -236,13 +403,13 @@ public class Termination {
 	    /* Now see if this could effect other model defintion rules */
 	    for(int i=0;i<state.vRules.size();i++) {
 		Rule r=(Rule) state.vRules.get(i);
-		if (AbstractInterferes.interferes(sn.getDescriptor(),sn.getSatisfy(),r,true)) {
+		if (AbstractInterferes.interfereswithrule(sn.getDescriptor(),sn.getSatisfy(),r,true)) {
 		    GraphNode scopenode=(GraphNode)scopesatisfy.get(r);
 		    GraphNode.Edge e=new GraphNode.Edge("interferes",scopenode);
 		    GraphNode gnconseq=(GraphNode)consequence.get(sn);
 		    gnconseq.addEdge(e);
 		}
-		if (AbstractInterferes.interferes(sn.getDescriptor(),sn.getSatisfy(),r,false)) {
+		if (AbstractInterferes.interfereswithrule(sn.getDescriptor(),sn.getSatisfy(),r,false)) {
 		    GraphNode scopenode=(GraphNode)scopefalsify.get(r);
 		    GraphNode.Edge e=new GraphNode.Edge("interferes",scopenode);
 		    GraphNode gnconseq=(GraphNode)consequence.get(sn);
@@ -252,21 +419,48 @@ public class Termination {
 	}
     }
 
-    /* Generates the abstract repair nodes */
+    /** This method generates the abstract repair nodes. */
     void generaterepairnodes() {
 	/* Generate repairs of conjunctions */
 	for(Iterator conjiterator=conjunctions.iterator();conjiterator.hasNext();) {
 	    GraphNode gn=(GraphNode)conjiterator.next();
 	    TermNode tn=(TermNode)gn.getOwner();
 	    Conjunction conj=tn.getConjunction();
+	loop:
 	    for(int i=0;i<conj.size();i++) {
 		DNFPredicate dp=conj.get(i);
-		int[] array=dp.getPredicate().getRepairs(dp.isNegated());
+		int[] array=dp.getPredicate().getRepairs(dp.isNegated(),this);
 		Descriptor d=dp.getPredicate().getDescriptor();
+		if ((dp.getPredicate() instanceof ExprPredicate)&&
+		    (((ExprPredicate)dp.getPredicate()).getType()==ExprPredicate.SIZE)) {
+		    boolean neg=dp.isNegated();
+		    Opcode op=((ExprPredicate)dp.getPredicate()).getOp();
+		    int size=((ExprPredicate)dp.getPredicate()).rightSize();
+		    op=Opcode.translateOpcode(neg,op);
+		    if (((size==1)&&(op==Opcode.EQ))||
+			((size!=1)&&(op==Opcode.NE))||
+			((size<=1)&&(op==Opcode.GE))||
+			((size<1)&&(op==Opcode.GT))||
+			((size>1)&&(op==Opcode.LT))||
+			((size>=1)&&(op==Opcode.LE))) {
+			for(int i2=0;i2<conj.size();i2++) {
+			    DNFPredicate dp2=conj.get(i2);
+			    if ((dp2.getPredicate() instanceof ExprPredicate)&&
+				(((ExprPredicate)dp2.getPredicate()).getType()==ExprPredicate.COMPARISON)) {
+				if (equivalent(((SizeofExpr)((OpExpr)((ExprPredicate)dp.getPredicate()).expr).left).setexpr,
+					       (RelationExpr)((OpExpr)((ExprPredicate)dp2.getPredicate()).expr).left))
+				    continue loop; // comparison predicate ensure that size expr is true - no need to generate abstract repairs...
+			    }
+			}
+		    }
+		}
+
 		for(int j=0;j<array.length;j++) {
-		    AbstractRepair ar=new AbstractRepair(dp,array[j],d);
+		    AbstractRepair ar=new AbstractRepair(dp,array[j],d,sources);
 		    TermNode tn2=new TermNode(ar);
-		    GraphNode gn2=new GraphNode(gn.getLabel()+"A"+i+"B"+ar.type(),gn.getTextLabel()+" #"+i+" "+ar.type(),tn2);
+		    //		    GraphNode gn2=new GraphNode(gn.getLabel()+"A"+i+"B"+ar.type(),gn.getTextLabel()+" #"+i+" "+ar.type(),tn2);
+		    GraphNode gn2=new GraphNode(gn.getLabel()+"A"+i+"B"+ar.type(),dp.name()+" "+ar.type(),tn2);
+		    gn2.setOption(absrepoption);
 		    GraphNode.Edge e=new GraphNode.Edge("abstract",gn2);
 		    gn.addEdge(e);
 		    if (!predtoabstractmap.containsKey(dp))
@@ -281,62 +475,65 @@ public class Termination {
 	for(int i=0;i<setdescriptors.size();i++) {
 	    SetDescriptor sd=(SetDescriptor)setdescriptors.get(i);
 
-	    /* XXXXXXX: Not sure what to do here */
 	    VarExpr ve=new VarExpr("DUMMY");
 	    InclusionPredicate ip=new InclusionPredicate(ve,new SetExpr(sd));
-	    
 	    DNFPredicate tp=new DNFPredicate(false,ip);
-	    AbstractRepair ar=new AbstractRepair(tp, AbstractRepair.ADDTOSET, sd);
+	    AbstractRepair ar=new AbstractRepair(tp, AbstractRepair.ADDTOSET, sd,sources);
 	    TermNode tn=new TermNode(ar);
 	    GraphNode gn=new GraphNode("AbstractAddSetRule"+i,tn);
+	    gn.setOption(absrepoption);
 	    if (!predtoabstractmap.containsKey(tp))
 		predtoabstractmap.put(tp,new HashSet());
 	    ((Set)predtoabstractmap.get(tp)).add(gn);
 	    abstractrepair.add(gn);
+	    abstractrepairadd.add(gn);
 	    abstractadd.put(sd,gn);
-	    
+
 	    DNFPredicate tp2=new DNFPredicate(true,ip);
-	    AbstractRepair ar2=new AbstractRepair(tp2, AbstractRepair.REMOVEFROMSET, sd);
+	    AbstractRepair ar2=new AbstractRepair(tp2, AbstractRepair.REMOVEFROMSET, sd,sources);
 	    TermNode tn2=new TermNode(ar2);
 	    GraphNode gn2=new GraphNode("AbstractRemSetRule"+i,tn2);
+	    gn2.setOption(absrepoption);
 	    if (!predtoabstractmap.containsKey(tp2))
 		predtoabstractmap.put(tp2,new HashSet());
 	    ((Set)predtoabstractmap.get(tp2)).add(gn2);
 	    abstractrepair.add(gn2);
+	    abstractrepairadd.add(gn2);
 	    abstractremove.put(sd,gn2);
 	}
 
 	Vector relationdescriptors=state.stRelations.getAllDescriptors();
 	for(int i=0;i<relationdescriptors.size();i++) {
 	    RelationDescriptor rd=(RelationDescriptor)relationdescriptors.get(i);
-
-	    /* XXXXXXX: Not sure what to do here */
 	    VarDescriptor vd1=new VarDescriptor("DUMMY1");
 	    VarExpr ve2=new VarExpr("DUMMY2");
 
 	    InclusionPredicate ip=new InclusionPredicate(ve2,new ImageSetExpr(vd1, rd));
-	    
+
 	    DNFPredicate tp=new DNFPredicate(false,ip);
-	    AbstractRepair ar=new AbstractRepair(tp, AbstractRepair.ADDTORELATION, rd);
+	    AbstractRepair ar=new AbstractRepair(tp, AbstractRepair.ADDTORELATION, rd,sources);
 	    TermNode tn=new TermNode(ar);
 	    GraphNode gn=new GraphNode("AbstractAddRelRule"+i,tn);
+	    gn.setOption(absrepoption);
 	    if (!predtoabstractmap.containsKey(tp))
 		predtoabstractmap.put(tp,new HashSet());
 	    ((Set)predtoabstractmap.get(tp)).add(gn);
 	    abstractrepair.add(gn);
+	    abstractrepairadd.add(gn);
 	    abstractadd.put(rd,gn);
-	    
+
 	    DNFPredicate tp2=new DNFPredicate(true,ip);
-	    AbstractRepair ar2=new AbstractRepair(tp2, AbstractRepair.REMOVEFROMRELATION, rd);
+	    AbstractRepair ar2=new AbstractRepair(tp2, AbstractRepair.REMOVEFROMRELATION, rd,sources);
 	    TermNode tn2=new TermNode(ar2);
 	    GraphNode gn2=new GraphNode("AbstractRemRelRule"+i,tn2);
+	    gn2.setOption(absrepoption);
 	    if (!predtoabstractmap.containsKey(tp2))
 		predtoabstractmap.put(tp2,new HashSet());
 	    ((Set)predtoabstractmap.get(tp2)).add(gn2);
 	    abstractrepair.add(gn2);
+	    abstractrepairadd.add(gn2);
 	    abstractremove.put(rd,gn2);
 	}
-	
     }
 
     int compensationcount=0;
@@ -344,11 +541,7 @@ public class Termination {
 	for(int i=0;i<state.vRules.size();i++) {
 	    Rule r=(Rule) state.vRules.get(i);
 	    Vector possiblerules=new Vector();
-	    /* Construct bindings */
-	    /* No need to construct bindings on remove
-	       Vector bindings=new Vector();
-	       constructbindings(bindings, r,true);
-	    */
+
 	    for(int j=0;j<(r.numQuantifiers()+r.getDNFNegGuardExpr().size());j++) {
 		GraphNode gn=(GraphNode)scopesatisfy.get(r);
 		TermNode tn=(TermNode) gn.getOwner();
@@ -356,9 +549,9 @@ public class Termination {
 		MultUpdateNode mun=new MultUpdateNode(sn);
 		TermNode tn2=new TermNode(mun);
 		GraphNode gn2=new GraphNode("CompRem"+compensationcount,tn2);
+		gn2.setOption(compoption);
 		UpdateNode un=new UpdateNode(r);
-		//		un.addBindings(bindings);
-		// Not necessary
+
 		if (j<r.numQuantifiers()) {
 		    /* Remove quantifier */
 		    Quantifier q=r.getQuantifier(j);
@@ -392,16 +585,16 @@ public class Termination {
 			continue;
 		    }
 		} else {
+		    /* Negate conjunction */
 		    int c=j-r.numQuantifiers();
-		    if (!processconjunction(un,r.getDNFNegGuardExpr().get(c))) {
+		    if (!processconjunction(un,r.getDNFNegGuardExpr().get(c),null)) {
 			continue;
 		    }
 		}
 		if (!un.checkupdates()) /* Make sure we have a good update */
 		    continue;
-		
-		mun.addUpdate(un);
 
+		mun.addUpdate(un);
 		GraphNode.Edge e=new GraphNode.Edge("abstract"+compensationcount,gn2);
 		compensationcount++;
 		gn.addEdge(e);
@@ -413,6 +606,7 @@ public class Termination {
     void generatedatastructureupdatenodes() {
 	for(Iterator absiterator=abstractrepair.iterator();absiterator.hasNext();) {
 	    GraphNode gn=(GraphNode)absiterator.next();
+	    System.out.println("Analysing: "+gn.getTextLabel());
 	    TermNode tn=(TermNode) gn.getOwner();
 	    AbstractRepair ar=tn.getAbstract();
 	    if (ar.getType()==AbstractRepair.ADDTOSET) {
@@ -425,7 +619,8 @@ public class Termination {
 		generateremovefromsetrelation(gn,ar);
 	    } else if (ar.getType()==AbstractRepair.MODIFYRELATION) {
 		/* Generate remove/add pairs */
-		generateremovefromsetrelation(gn,ar);
+		if (ar.needsRemoves(state))
+		    generateremovefromsetrelation(gn,ar);
 		generateaddtosetrelation(gn,ar);
 		/* Generate atomic modify */
 		generatemodifyrelation(gn,ar);
@@ -433,8 +628,14 @@ public class Termination {
 	}
     }
 
+
+    /** This method generates concrete data structure updates which
+     * remove an object (or tuple) from a set (or relation).*/
+
     int removefromcount=0;
     void generateremovefromsetrelation(GraphNode gn,AbstractRepair ar) {
+	/* Construct the set of all rules which could add something to the given set or relation */
+
 	Vector possiblerules=new Vector();
 	for(int i=0;i<state.vRules.size();i++) {
 	    Rule r=(Rule) state.vRules.get(i);
@@ -447,21 +648,20 @@ public class Termination {
 	}
 	if (possiblerules.size()==0)
 	    return;
+
+	/* Loop through different ways of falsifying each of these rules */
 	int[] count=new int[possiblerules.size()];
 	while(remains(count,possiblerules,true)) {
 	    MultUpdateNode mun=new MultUpdateNode(ar,MultUpdateNode.REMOVE);
 	    TermNode tn=new TermNode(mun);
 	    GraphNode gn2=new GraphNode("UpdateRem"+removefromcount,tn);
+	    gn2.setOption(updateoption);
 
 	    boolean goodflag=true;
 	    for(int i=0;i<possiblerules.size();i++) {
 		Rule r=(Rule)possiblerules.get(i);
 		UpdateNode un=new UpdateNode(r);
-		/* Construct bindings */
-		/* No Need to construct bindings on remove
-		   Vector bindings=new Vector();
-		   constructbindings(bindings, r,true);
-		  un.addBindings(bindings);*/
+
 		if (count[i]<r.numQuantifiers()) {
 		    /* Remove quantifier */
 		    Quantifier q=r.getQuantifier(count[i]);
@@ -494,7 +694,7 @@ public class Termination {
 		    } else {goodflag=false;break;}
 		} else {
 		    int c=count[i]-r.numQuantifiers();
-		    if (!processconjunction(un,r.getDNFNegGuardExpr().get(c))) {
+		    if (!processconjunction(un,r.getDNFNegGuardExpr().get(c),null)) {
 			goodflag=false;break;
 		    }
 		}
@@ -505,8 +705,7 @@ public class Termination {
 		mun.addUpdate(un);
 	    }
 	    if (goodflag) {
-		GraphNode.Edge e=new GraphNode.Edge("abstract"+removefromcount,gn2);
-		removefromcount++;
+		GraphNode.Edge e=new GraphNode.Edge("abstract"+(removefromcount++),gn2);
 		gn.addEdge(e);
 		updatenodes.add(gn2);
 	    }
@@ -514,7 +713,9 @@ public class Termination {
 	}
     }
 
-    static void increment(int count[], Vector rules,boolean isremove) {
+    /** This method increments to the next possibility. */
+
+    static private void increment(int count[], Vector rules,boolean isremove) {
 	count[0]++;
 	for(int i=0;i<(rules.size()-1);i++) {
 	    int num=isremove?(((Rule)rules.get(i)).numQuantifiers()+(((Rule)rules.get(i)).getDNFNegGuardExpr().size())):((Rule)rules.get(i)).getDNFGuardExpr().size();
@@ -525,7 +726,10 @@ public class Termination {
 	}
     }
 
-    static boolean remains(int count[], Vector rules, boolean isremove) {
+
+    /** This method test if there remain any possibilities to loop
+     * through. */
+    static private boolean remains(int count[], Vector rules, boolean isremove) {
 	for(int i=0;i<rules.size();i++) {
 	    int num=isremove?(((Rule)rules.get(i)).numQuantifiers()+(((Rule)rules.get(i)).getDNFNegGuardExpr().size())):((Rule)rules.get(i)).getDNFGuardExpr().size();
 	    if (count[i]>=num) {
@@ -537,6 +741,7 @@ public class Termination {
 
     /** This method generates data structure updates to implement the
      * 	abstract atomic modification specified by ar. */
+
     int modifycount=0;
     void generatemodifyrelation(GraphNode gn, AbstractRepair ar) {
 	RelationDescriptor rd=(RelationDescriptor)ar.getDescriptor();
@@ -546,10 +751,10 @@ public class Termination {
 	int rightindex=1;
 	if (inverted)
 	    leftindex=2;
-	else 
+	else
 	    rightindex=2;
 
-
+	// construct set of possible rules
 	Vector possiblerules=new Vector();
 	for(int i=0;i<state.vRules.size();i++) {
 	    Rule r=(Rule) state.vRules.get(i);
@@ -559,46 +764,61 @@ public class Termination {
 	}
 	if (possiblerules.size()==0)
 	    return;
+
+	// increment through this set
 	int[] count=new int[possiblerules.size()];
 	while(remains(count,possiblerules,false)) {
 	    MultUpdateNode mun=new MultUpdateNode(ar,MultUpdateNode.MODIFY);
 	    TermNode tn=new TermNode(mun);
-	    GraphNode gn2=new GraphNode("UpdateMod"+removefromcount,tn);
+	    GraphNode gn2=new GraphNode("UpdateMod"+modifycount,tn);
+	    gn2.setOption(updateoption);
 
 	    boolean goodflag=true;
 	    for(int i=0;i<possiblerules.size();i++) {
 		Rule r=(Rule)possiblerules.get(i);
 		UpdateNode un=new UpdateNode(r);
-		/* No Need to construct bindings on modify */
-		
+
 		int c=count[i];
-		if (!processconjunction(un,r.getDNFGuardExpr().get(c))) {
+		if (!processconjunction(un,r.getDNFGuardExpr().get(c),null)) {
 		    goodflag=false;break;
 		}
 		RelationInclusion ri=(RelationInclusion)r.getInclusion();
 		if (!(ri.getLeftExpr() instanceof VarExpr)) {
-		    Updates up=new Updates(ri.getLeftExpr(),leftindex);
-		    un.addUpdate(up);
+		    if (ri.getLeftExpr().isValue(ri.getRelation().getDomain().getType())) {
+			Updates up=new Updates(ri.getLeftExpr(),leftindex,ri.getRelation().getDomain().getType());
+			un.addUpdate(up);
+		    } else {
+			if (inverted)
+			    goodflag=false;
+			else un.addInvariant(ri.getLeftExpr());
+		    }
 		} else {
 		    VarDescriptor vd=((VarExpr)ri.getLeftExpr()).getVar();
 		    if (vd.isGlobal()) {
-			Updates up=new Updates(ri.getLeftExpr(),leftindex);
+			Updates up=new Updates(ri.getLeftExpr(),leftindex,null);
 			un.addUpdate(up);
 		    } else if (inverted)
 			goodflag=false;
 		}
 		if (!(ri.getRightExpr() instanceof VarExpr)) {
-		    Updates up=new Updates(ri.getRightExpr(),rightindex);
-		    un.addUpdate(up);
+		    if (ri.getRightExpr().isValue(ri.getRelation().getRange().getType())) {
+			Updates up=new Updates(ri.getRightExpr(),rightindex,ri.getRelation().getRange().getType());
+			un.addUpdate(up);
+		    } else {
+			if (!inverted)
+			    goodflag=false;
+			else
+			    un.addInvariant(ri.getLeftExpr());
+		    }
 		} else {
 		    VarDescriptor vd=((VarExpr)ri.getRightExpr()).getVar();
 		    if (vd.isGlobal()) {
-			Updates up=new Updates(ri.getRightExpr(),rightindex);
+			Updates up=new Updates(ri.getRightExpr(),rightindex,null);
 			un.addUpdate(up);
-		    } else if (!inverted) 
+		    } else if (!inverted)
 			goodflag=false;
 		}
-				
+
 		if (!un.checkupdates()) {
 		    goodflag=false;
 		    break;
@@ -615,10 +835,233 @@ public class Termination {
 	}
     }
 
+    /** Generate concrete data structure update to add an object(or
+     * tuple) to a set (or relation). */
+
+    static int addtocount=0;
+    void generateaddtosetrelation(GraphNode gn, AbstractRepair ar) {
+	for(int i=0;i<state.vRules.size();i++) {
+	    Rule r=(Rule) state.vRules.get(i);
+
+
+	    /* See if this is a good rule*/
+	    if ((r.getInclusion() instanceof SetInclusion&&
+		 ar.getDescriptor()==((SetInclusion)r.getInclusion()).getSet())||
+		(r.getInclusion() instanceof RelationInclusion&&
+		 ar.getDescriptor()==((RelationInclusion)r.getInclusion()).getRelation())) {
+
+		/* First solve for quantifiers */
+		Vector bindings=new Vector();
+		/* Construct bindings */
+
+		Hashtable setmapping=new Hashtable();
+		System.out.println("Attempting to construct bindings");
 
-    boolean constructbindings(Vector bindings, Rule r, boolean isremoval) {
+		if (!constructbindings(bindings,r,ar,setmapping,false))
+		    continue;
+		System.out.println("Bindings constructed");
+		//Generate add instruction
+		DNFRule dnfrule=r.getDNFGuardExpr();
+		 endloop:
+		for(int j=0;j<dnfrule.size();j++) {
+		    Inclusion inc=r.getInclusion();
+		    UpdateNode un=new UpdateNode(r);
+		    un.addBindings(bindings);
+		    /* Now build update for tuple/set inclusion condition */
+		    if(inc instanceof SetInclusion) {
+			SetInclusion si=(SetInclusion)inc;
+			Expr e=si.elementexpr;
+
+			while(e instanceof CastExpr) {
+			    CastExpr ce=(CastExpr)e;
+			    if (ce.getType()!=si.getSet().getType())
+				continue endloop;
+			    e=ce.getExpr();
+			}
+
+			if (!(e instanceof VarExpr)) {
+			    if (e.isValue(si.getSet().getType())) {
+				Updates up=new Updates(e,0,si.getSet().getType());
+				un.addUpdate(up);
+			    } else {
+				/* We're an add to set*/
+				ArrayAnalysis.AccessPath rap=arrayanalysis.analyzeExpr(r,e);
+				SetDescriptor set=sources.setSource(si.getSet())?
+				    sources.getSourceSet(si.getSet()):null;
+				if (set==null)
+				    continue;
+				ArrayAnalysis.AccessPath ap=arrayanalysis.getSet(set);
+				if (rap==ArrayAnalysis.AccessPath.NONE)
+				    continue;
+				if (!rap.equal(ap))
+				    continue;
+				if (!constructarrayupdate(un, e, rap, 0))
+				    continue;
+			    }
+			} else {
+			    VarDescriptor vd=((VarExpr)e).getVar();
+			    if (vd.isGlobal()) {
+				Updates up=new Updates(e,0,null);
+				un.addUpdate(up);
+			    }
+			}
+		    } else if (inc instanceof RelationInclusion) {
+			RelationInclusion ri=(RelationInclusion)inc;
+
+			Expr e=ri.getLeftExpr();
+
+			while(e instanceof CastExpr) {
+			    CastExpr ce=(CastExpr)e;
+			    if (ce.getType()!=ri.getRelation().getDomain().getType())
+				continue endloop;
+			    e=ce.getExpr();
+			}
+			if (!(e instanceof VarExpr)) {
+			    if (e.isValue(ri.getRelation().getDomain().getType())) {
+				Updates up=new Updates(e,0,ri.getRelation().getDomain().getType());
+				if (ar.getDomainSet()!=null)
+				    setmapping.put(e,ar.getDomainSet());
+				un.addUpdate(up);
+			    } else {
+				/* We don't handly relation modifies */
+				if (ar.getType()==AbstractRepair.MODIFYRELATION)
+				    continue;
+				/* We're an add to relation*/
+				ArrayAnalysis.AccessPath rap=arrayanalysis.analyzeExpr(r,e);
+				SetDescriptor set=sources.relsetSource(ri.getRelation(),true /* Domain*/)?
+				    sources.relgetSourceSet(ri.getRelation(),true):null;
+				if (set==null)
+				    continue;
+				ArrayAnalysis.AccessPath ap=arrayanalysis.getSet(set);
+				if (rap==ArrayAnalysis.AccessPath.NONE||
+				    !rap.equal(ap)||
+				    !constructarrayupdate(un, e, rap, 0))
+				    continue;
+				if (ar.getDomainSet()!=null)
+				    setmapping.put(e,ar.getDomainSet());
+
+			    }
+			} else {
+			    VarDescriptor vd=((VarExpr)e).getVar();
+			    if (vd.isGlobal()) {
+				Updates up=new Updates(e,0,null);
+				if (ar.getDomainSet()!=null)
+				    setmapping.put(e,ar.getDomainSet());
+				un.addUpdate(up);
+			    }
+     			}
+
+			e=ri.getRightExpr();
+
+			while(e instanceof CastExpr) {
+			    CastExpr ce=(CastExpr)e;
+			    if (ce.getType()!=ri.getRelation().getRange().getType())
+				continue endloop;
+			    e=ce.getExpr();
+			}
+			if (!(e instanceof VarExpr)) {
+			    if (e.isValue(ri.getRelation().getRange().getType())) {
+				Updates up=new Updates(e,1,ri.getRelation().getRange().getType());
+				un.addUpdate(up);
+			    } else {
+				/* We don't handly relation modifies */
+				if (ar.getType()==AbstractRepair.MODIFYRELATION)
+				    continue;
+				/* We're an add to relation*/
+				ArrayAnalysis.AccessPath rap=arrayanalysis.analyzeExpr(r,e);
+				SetDescriptor set=sources.relsetSource(ri.getRelation(),false /* Range*/)?
+				    sources.relgetSourceSet(ri.getRelation(),false):null;
+				if (set==null)
+				    continue;
+				ArrayAnalysis.AccessPath ap=arrayanalysis.getSet(set);
+
+				if (rap==ArrayAnalysis.AccessPath.NONE||
+				    !rap.equal(ap)||
+				    !constructarrayupdate(un, e, rap, 1))
+				    continue;
+				if (ar.getRangeSet()!=null)
+				    setmapping.put(e,ar.getRangeSet());
+			    }
+			} else {
+			    VarDescriptor vd=((VarExpr)e).getVar();
+			    if (vd.isGlobal()) {
+				Updates up=new Updates(e,1,null);
+				if (ar.getRangeSet()!=null)
+				    setmapping.put(e,ar.getRangeSet());
+				un.addUpdate(up);
+			    }
+			}
+		    }
+		    System.out.println("Built inclusion condition updates.");
+		    //Finally build necessary updates to satisfy conjunction
+		    RuleConjunction ruleconj=dnfrule.get(j);
+
+		    /* Add in updates for quantifiers */
+		    MultUpdateNode mun=new MultUpdateNode(ar,MultUpdateNode.ADD);
+		    TermNode tn=new TermNode(mun);
+		    GraphNode gn2=new GraphNode("UpdateAdd"+addtocount,tn);
+		    gn2.setOption(updateoption);
+
+		    if (debugmsg("Start processing quantifiers")&&
+			processquantifiers(gn2,un, r,setmapping)&&
+			debugmsg("Finished processing quantifiers")&&
+			processconjunction(un,ruleconj,setmapping)&&
+			debugmsg("Finished processing conjunction")&&
+			un.checkupdates()&&
+			debugmsg("Updates checked")) {
+			mun.addUpdate(un);
+			GraphNode.Edge e=new GraphNode.Edge("abstract"+addtocount,gn2);
+			addtocount++;
+			gn.addEdge(e);
+			updatenodes.add(gn2);
+		    }
+		}
+	    }
+	}
+    }
+
+    boolean debugmsg(String st) {
+	System.out.println(st);
+	return true;
+    }
+
+    boolean constructarrayupdate(UpdateNode un, Expr lexpr, ArrayAnalysis.AccessPath ap, int slotnumber) {
+	System.out.println("Constructing array update");
+	Expr e=null;
+	for (int i=ap.numFields()-1;i>=0;i--) {
+	    if (e==null)
+		e=lexpr;
+	    else
+		e=((DotExpr)e).getExpr();
+
+	    while (e instanceof CastExpr)
+		e=((CastExpr)e).getExpr();
+
+	    DotExpr de=(DotExpr)e;
+	    FieldDescriptor fd=ap.getField(i);
+	    if (fd instanceof ArrayDescriptor) {
+		// We have an ArrayDescriptor!
+		Expr index=de.getIndex();
+		if (!index.isValue(null)) {/* Not assignable */
+		    System.out.println("ERROR:Index isn't assignable");
+		    return false;
+		}
+		Updates updates=new Updates(index,i,ap,lexpr,slotnumber);
+		un.addUpdate(updates);
+	    }
+	}
+	return true;
+    }
+
+    /** This method constructs bindings for an update using rule
+     * r. The boolean flag isremoval indicates that the update
+     * performs a removal.  The function returns true if it is able to
+     * generate a valid set of bindings and false otherwise. */
+
+    boolean constructbindings(Vector bindings, Rule r, AbstractRepair ar, Hashtable setmapping, boolean isremoval) {
 	boolean goodupdate=true;
 	Inclusion inc=r.getInclusion();
+
 	for(Iterator iterator=r.quantifiers();iterator.hasNext();) {
 	    Quantifier q=(Quantifier)iterator.next();
 	    if ((q instanceof SetQuantifier)||(q instanceof ForQuantifier)) {
@@ -626,31 +1069,75 @@ public class Termination {
 		SetDescriptor set=null;
 		if (q instanceof SetQuantifier) {
 		    vd=((SetQuantifier)q).getVar();
-		} else
+		    set=((SetQuantifier)q).getSet();
+		} else {
 		    vd=((ForQuantifier)q).getVar();
+		}
 		if(inc instanceof SetInclusion) {
 		    SetInclusion si=(SetInclusion)inc;
-		    if ((si.elementexpr instanceof VarExpr)&&
-			(((VarExpr)si.elementexpr).getVar()==vd)) {
+		    Expr tmpe=si.elementexpr;
+		    Expr e=si.elementexpr;
+
+		    while(e instanceof CastExpr) {
+			CastExpr ce=(CastExpr)e;
+			if (ce.getType()!=si.getSet().getType())
+			    return false;
+			e=ce.getExpr();
+		    }
+
+		    if ((e instanceof VarExpr)&&
+			(((VarExpr)e).getVar()==vd)) {
 			/* Can solve for v */
+			if (set==null||!si.getSet().getType().isSubtypeOf(set.getType()))
+			    return false;
 			Binding binding=new Binding(vd,0);
 			bindings.add(binding);
-		    } else
+		    } else {
 			goodupdate=false;
+		    }
 		} else if (inc instanceof RelationInclusion) {
 		    RelationInclusion ri=(RelationInclusion)inc;
 		    boolean f1=true;
 		    boolean f2=true;
-		    if ((ri.getLeftExpr() instanceof VarExpr)&&
-			(((VarExpr)ri.getLeftExpr()).getVar()==vd)) {
+
+		    Expr e=ri.getLeftExpr();
+
+		    while(e instanceof CastExpr) {
+			CastExpr ce=(CastExpr)e;
+			if (ce.getType()!=ri.getRelation().getDomain().getType())
+			    return false;
+			e=ce.getExpr();
+		    }
+
+		    if ((e instanceof VarExpr)&&
+			(((VarExpr)e).getVar()==vd)) {
 				/* Can solve for v */
 			Binding binding=new Binding(vd,0);
+			if (!ri.getRelation().getDomain().getType().isSubtypeOf(set.getType()))
+			    return false;
+			if (ar.getDomainSet()!=null)
+			    setmapping.put(ri.getLeftExpr(),ar.getDomainSet());
 			bindings.add(binding);
 		    } else f1=false;
-		    if ((ri.getRightExpr() instanceof VarExpr)&&
-			(((VarExpr)ri.getRightExpr()).getVar()==vd)) {
+
+
+		    e=ri.getRightExpr();
+
+		    while(e instanceof CastExpr) {
+			CastExpr ce=(CastExpr)e;
+			if (ce.getType()!=ri.getRelation().getRange().getType())
+			    return false;
+			e=ce.getExpr();
+		    }
+
+		    if ((e instanceof VarExpr)&&
+			(((VarExpr)e).getVar()==vd)) {
 				/* Can solve for v */
-			Binding binding=new Binding(vd,0);
+			Binding binding=new Binding(vd,1);
+			if (!ri.getRelation().getRange().getType().isSubtypeOf(set.getType()))
+			    return false;
+			if (ar.getRangeSet()!=null)
+			    setmapping.put(ri.getRightExpr(),ar.getRangeSet());
 			bindings.add(binding);
 		    } else f2=false;
 		    if (!(f1||f2))
@@ -658,21 +1145,43 @@ public class Termination {
 		} else throw new Error("Inclusion not recognized");
 		if (!goodupdate)
 		    if (isremoval) {
-			Binding binding=new Binding(vd);
+			/* Removals don't need bindings anymore
+			   Binding binding=new Binding(vd);
+			   bindings.add(binding);*/
+			goodupdate=true;
+		    } else if (q instanceof SetQuantifier) {
+			/* Create new element to bind to */
+			// search if the set 'set' has a size
+			Binding binding=new Binding(vd,set,exactsize.getsize(set)==1);
 			bindings.add(binding);
 			goodupdate=true;
+
 		    } else
-			break;
+			goodupdate=false;
 	    } else if (q instanceof RelationQuantifier) {
 		RelationQuantifier rq=(RelationQuantifier)q;
 		for(int k=0;k<2;k++) {
 		    VarDescriptor vd=(k==0)?rq.x:rq.y;
+		    TypeDescriptor td=(k==0)?rq.getRelation().getDomain().getType():rq.getRelation().getRange().getType();
 		    if(inc instanceof SetInclusion) {
 			SetInclusion si=(SetInclusion)inc;
-			if ((si.elementexpr instanceof VarExpr)&&
-			    (((VarExpr)si.elementexpr).getVar()==vd)) {
+
+			Expr e=si.elementexpr;
+
+			while(e instanceof CastExpr) {
+			    CastExpr ce=(CastExpr)e;
+			    if (ce.getType()!=td)
+				return false;
+			    e=ce.getExpr();
+			}
+
+			if ((e instanceof VarExpr)&&
+			    (((VarExpr)e).getVar()==vd)) {
 			    /* Can solve for v */
 			    Binding binding=new Binding(vd,0);
+
+			    if (!si.getSet().getType().isSubtypeOf(td))
+				return false;
 			    bindings.add(binding);
 			} else
 			    goodupdate=false;
@@ -680,16 +1189,44 @@ public class Termination {
 			RelationInclusion ri=(RelationInclusion)inc;
 			boolean f1=true;
 			boolean f2=true;
+
+
+			Expr e=ri.getLeftExpr();
+
+			while(e instanceof CastExpr) {
+			    CastExpr ce=(CastExpr)e;
+			    if (ce.getType()!=ri.getRelation().getDomain().getType())
+				return false;
+			    e=ce.getExpr();
+			}
 			if ((ri.getLeftExpr() instanceof VarExpr)&&
 			    (((VarExpr)ri.getLeftExpr()).getVar()==vd)) {
 			    /* Can solve for v */
 			    Binding binding=new Binding(vd,0);
+			    if (!ri.getRelation().getDomain().getType().isSubtypeOf(td))
+				return false;
+			    if (ar.getDomainSet()!=null)
+				setmapping.put(ri.getLeftExpr(),ar.getDomainSet());
 			    bindings.add(binding);
 			} else f1=false;
+
+
+			e=ri.getRightExpr();
+
+			while(e instanceof CastExpr) {
+			    CastExpr ce=(CastExpr)e;
+			    if (ce.getType()!=ri.getRelation().getRange().getType())
+				return false;
+			    e=ce.getExpr();
+			}
 			if ((ri.getRightExpr() instanceof VarExpr)&&
 			    (((VarExpr)ri.getRightExpr()).getVar()==vd)) {
 			    /* Can solve for v */
-			    Binding binding=new Binding(vd,0);
+			    Binding binding=new Binding(vd,1);
+			    if (!ri.getRelation().getRange().getType().isSubtypeOf(td))
+				return false;
+			    if (ar.getRangeSet()!=null)
+				setmapping.put(ri.getRightExpr(),ar.getRangeSet());
 			    bindings.add(binding);
 			} else f2=false;
 			if (!(f1||f2))
@@ -697,8 +1234,9 @@ public class Termination {
 		    } else throw new Error("Inclusion not recognized");
 		    if (!goodupdate)
 			if (isremoval) {
-			    Binding binding=new Binding(vd);
-			    bindings.add(binding);
+			    /* Removals don't need bindings anymore
+			       Binding binding=new Binding(vd);
+			       bindings.add(binding);*/
 			    goodupdate=true;
 			} else
 			    break;
@@ -710,123 +1248,45 @@ public class Termination {
 	return goodupdate;
     }
 
-    static int addtocount=0;
-    void generateaddtosetrelation(GraphNode gn, AbstractRepair ar) {
-	//	System.out.println("Attempting to generate add to set");
-	//System.out.println(ar.getPredicate().getPredicate().name());
-	//System.out.println(ar.getPredicate().isNegated());
-	for(int i=0;i<state.vRules.size();i++) {
-	    Rule r=(Rule) state.vRules.get(i);
-	    /* See if this is a good rule*/
-	    //System.out.println(r.getGuardExpr().name());
-	    if ((r.getInclusion() instanceof SetInclusion&&
-		ar.getDescriptor()==((SetInclusion)r.getInclusion()).getSet())||
-		(r.getInclusion() instanceof RelationInclusion&&
-		 ar.getDescriptor()==((RelationInclusion)r.getInclusion()).getRelation())) {
-
-		/* First solve for quantifiers */
-		Vector bindings=new Vector();
-		/* Construct bindings */
-		//System.out.println("Attempting to generate add to set: #2");
-		if (!constructbindings(bindings,r,false))
-		    continue;
-		//System.out.println("Attempting to generate add to set: #3");
-		//Generate add instruction
-		DNFRule dnfrule=r.getDNFGuardExpr();
-		for(int j=0;j<dnfrule.size();j++) {
-		    Inclusion inc=r.getInclusion();
-		    UpdateNode un=new UpdateNode(r);
-		    un.addBindings(bindings);
-		    /* Now build update for tuple/set inclusion condition */
-		    if(inc instanceof SetInclusion) {
-			SetInclusion si=(SetInclusion)inc;
-			if (!(si.elementexpr instanceof VarExpr)) {
-			    Updates up=new Updates(si.elementexpr,0);
-			    un.addUpdate(up);
-			} else {
-			    VarDescriptor vd=((VarExpr)si.elementexpr).getVar();
-			    if (un.getBinding(vd)==null) {
-				Updates up=new Updates(si.elementexpr,0);
-				un.addUpdate(up);
-			    }
-			}
-		    } else if (inc instanceof RelationInclusion) {
-			RelationInclusion ri=(RelationInclusion)inc;
-			if (!(ri.getLeftExpr() instanceof VarExpr)) {
-			    Updates up=new Updates(ri.getLeftExpr(),0);
-			    un.addUpdate(up);
-			} else {
-			    VarDescriptor vd=((VarExpr)ri.getLeftExpr()).getVar();
-			    if (un.getBinding(vd)==null) {
-				Updates up=new Updates(ri.getLeftExpr(),0);
-				un.addUpdate(up);
-			    }
-     			}
-			if (!(ri.getRightExpr() instanceof VarExpr)) {
-			    Updates up=new Updates(ri.getRightExpr(),1);
-			    un.addUpdate(up);
-			} else {
-			    VarDescriptor vd=((VarExpr)ri.getRightExpr()).getVar();
-			    if (un.getBinding(vd)==null) {
-				Updates up=new Updates(ri.getRightExpr(),1);
-				un.addUpdate(up);
-			    }
-			}
-		    }
-		    //Finally build necessary updates to satisfy conjunction
-		    RuleConjunction ruleconj=dnfrule.get(j);
-		    /* Add in updates for quantifiers */
-		    //System.out.println("Attempting to generate add to set #4");
-		    MultUpdateNode mun=new MultUpdateNode(ar,MultUpdateNode.ADD);
-		    TermNode tn=new TermNode(mun);
-		    GraphNode gn2=new GraphNode("UpdateAdd"+addtocount,tn);
-
-		    if (processquantifers(gn2,un, r)&&debugdd()&&
-			processconjunction(un,ruleconj)&&
-			un.checkupdates()) {
-			//System.out.println("Attempting to generate add to set #5");
-			mun.addUpdate(un);
-			GraphNode.Edge e=new GraphNode.Edge("abstract"+addtocount,gn2);
-			addtocount++;
-			gn.addEdge(e);
-			updatenodes.add(gn2);}
-		}
-	    }
-	}
-    }
-
-    boolean debugdd() {
-	//System.out.println("Attempting to generate add to set DD");
-	return true;
-    }
+    /** Adds updates that add an item to the appropriate set or
+     * relation quantified over by the model definition rule.. */
 
-    boolean processquantifers(GraphNode gn,UpdateNode un, Rule r) {
+    boolean processquantifiers(GraphNode gn,UpdateNode un, Rule r,Hashtable setmapping) {
 	Inclusion inc=r.getInclusion();
 	for(Iterator iterator=r.quantifiers();iterator.hasNext();) {
 	    Quantifier q=(Quantifier)iterator.next();
 	    /* Add quantifier */
-	    /* FIXME: Analysis to determine when this update is necessary */
 	    if (q instanceof RelationQuantifier) {
 		RelationQuantifier rq=(RelationQuantifier)q;
 		TupleOfExpr toe=new TupleOfExpr(new VarExpr(rq.x),new VarExpr(rq.y),rq.relation);
 		toe.td=ReservedTypeDescriptor.INT;
 		Updates u=new Updates(toe,false);
 		un.addUpdate(u);
-		if (abstractremove.containsKey(rq.relation)) {
+		if (abstractadd.containsKey(rq.relation)) {
 		    GraphNode agn=(GraphNode)abstractadd.get(rq.relation);
 		    GraphNode.Edge e=new GraphNode.Edge("requires",agn);
 		    gn.addEdge(e);
 		} else {
 		    return false;
 		}
-
 	    } else if (q instanceof SetQuantifier) {
 		SetQuantifier sq=(SetQuantifier)q;
-		ElementOfExpr eoe=new ElementOfExpr(new VarExpr(sq.var),sq.set);
+		if (un.getBinding(sq.var).getType()==Binding.SEARCH) {
+		    Binding b=un.getBinding(sq.var);
+		    Constraint reqc=exactsize.getConstraint(b.getSet());
+		    constraintdependence.requiresConstraint(gn,reqc);
+		    continue; /* Don't need to ensure addition for search */
+		}
+		VarExpr ve=new VarExpr(sq.var);
+		SetDescriptor sd=findExpr(setmapping, ve);
+		if (sd!=null&&sd.isSubset(sq.set))
+		    continue; /* this update is trivially true */
+
+		ElementOfExpr eoe=new ElementOfExpr(ve,sq.set);
 		eoe.td=ReservedTypeDescriptor.INT;
 		Updates u=new Updates(eoe,false);
 		un.addUpdate(u);
-		if (abstractremove.containsKey(sq.set)) {
+		if (abstractadd.containsKey(sq.set)) {
 		    GraphNode agn=(GraphNode)abstractadd.get(sq.set);
 		    GraphNode.Edge e=new GraphNode.Edge("requires",agn);
 		    gn.addEdge(e);
@@ -838,7 +1298,23 @@ public class Termination {
 	return true;
     }
 
-    boolean  processconjunction(UpdateNode un,RuleConjunction ruleconj){
+    static SetDescriptor findExpr(Hashtable setmapping, Expr e) {
+	if (setmapping==null)
+	    return null;
+	Set kset=setmapping.keySet();
+	for(Iterator it=kset.iterator();it.hasNext();) {
+	    Expr expr=(Expr)it.next();
+	    if (expr.equals(null,e)) {
+		return (SetDescriptor)setmapping.get(expr);
+	    }
+	}
+	return null;
+    }
+
+    /** This method generates the necessary updates to satisfy the
+     * conjunction ruleconj. */
+
+    boolean  processconjunction(UpdateNode un,RuleConjunction ruleconj,Hashtable setmapping) {
 	boolean okay=true;
 	for(int k=0;k<ruleconj.size();k++) {
 	    DNFExpr de=ruleconj.get(k);
@@ -849,12 +1325,15 @@ public class Termination {
 		Updates up=new Updates(ex.left,ex.right,op, de.getNegation());
 		un.addUpdate(up);
 	    } else if (e instanceof ElementOfExpr) {
+		SetDescriptor sd=findExpr(setmapping, ((ElementOfExpr)e).element);
+		if (sd!=null&&sd.isSubset(((ElementOfExpr)e).set))
+		    continue; /* this update is trivially true */
 		Updates up=new Updates(e,de.getNegation());
 		un.addUpdate(up);
 	    } else if (e instanceof TupleOfExpr) {
 		Updates up=new Updates(e,de.getNegation());
 		un.addUpdate(up);
-	    } else if (e instanceof BooleanLiteralExpr) { 
+	    } else if (e instanceof BooleanLiteralExpr) {
 		boolean truth=((BooleanLiteralExpr)e).getValue();
 		if (de.getNegation())
 		    truth=!truth;
@@ -870,34 +1349,90 @@ public class Termination {
 	return okay;
     }
 
-    void generatescopenodes() {
-	for(int i=0;i<state.vRules.size();i++) {
-	    Rule r=(Rule) state.vRules.get(i);
-	    ScopeNode satisfy=new ScopeNode(r,true);
-	    TermNode tnsatisfy=new TermNode(satisfy);
-	    GraphNode gnsatisfy=new GraphNode("SatisfyRule"+i,tnsatisfy);
-	    ConsequenceNode cnsatisfy=new ConsequenceNode();
-	    TermNode ctnsatisfy=new TermNode(cnsatisfy);
-	    GraphNode cgnsatisfy=new GraphNode("ConseqSatisfyRule"+i,ctnsatisfy);
-	    consequence.put(satisfy,cgnsatisfy);
-	    GraphNode.Edge esat=new GraphNode.Edge("consequencesatisfy"+i,cgnsatisfy);
-	    gnsatisfy.addEdge(esat);
-	    consequencenodes.add(cgnsatisfy);
-	    scopesatisfy.put(r,gnsatisfy);
-	    scopenodes.add(gnsatisfy);
+    /** This method sees if when the quantifiers listed in set are
+     *  fixed, whether there can be more than one unique binding for
+     *  the constraint or model definition rule qs.*/
+    public boolean analyzeQuantifiers(Quantifiers qs,Set set) {
+	for(int i=0;i<qs.numQuantifiers();i++) {
+	    Quantifier q=qs.getQuantifier(i);
+	    if (set.contains(q))
+		continue;
+	    if (q instanceof SetQuantifier) {
+		SetDescriptor sd=((SetQuantifier)q).getSet();
+		if (maxsize.getsize(sd)<=1&&
+		    maxsize.getsize(sd)>=0)
+		    continue;
+	    } else if (q instanceof RelationQuantifier) {
+		RelationDescriptor rd=((RelationQuantifier)q).getRelation();
+		if (maxsize.getsize(rd)<=1&&
+		    maxsize.getsize(rd)>=0)
+		    continue;
+	    }
+	    return false;
+	}
+	return true;
+    }
 
-	    ScopeNode falsify=new ScopeNode(r,false);
-	    TermNode tnfalsify=new TermNode(falsify);
-	    GraphNode gnfalsify=new GraphNode("FalsifyRule"+i,tnfalsify);
-	    ConsequenceNode cnfalsify=new ConsequenceNode();
-	    TermNode ctnfalsify=new TermNode(cnfalsify);
-	    GraphNode cgnfalsify=new GraphNode("ConseqFalsifyRule"+i,ctnfalsify);
-	    consequence.put(falsify,cgnfalsify);
-	    GraphNode.Edge efals=new GraphNode.Edge("consequencefalsify"+i,cgnfalsify);
-	    gnfalsify.addEdge(efals);
-	    consequencenodes.add(cgnfalsify);
-	    scopefalsify.put(r,gnfalsify);
-	    scopenodes.add(gnfalsify);
+    public boolean mutuallyexclusive(SetDescriptor sd1, SetDescriptor sd2) {
+	if (mutualexclusive(sd1,sd2)||
+	    mutualexclusive(sd2,sd1))
+	    return true;
+	else
+	    return false;
+    }
+
+    private boolean mutualexclusive(SetDescriptor sd1, SetDescriptor sd2) {
+	Vector rules=state.vRules;
+	for(int i=0;i<rules.size();i++) {
+	    Rule r=(Rule)rules.get(i);
+	    if (r.getInclusion().getTargetDescriptors().contains(sd1)) {
+		/* Rule may add items to sd1 */
+		SetInclusion si=(SetInclusion)r.getInclusion();
+		Expr ve=si.getExpr();
+		DNFRule drule=r.getDNFGuardExpr();
+		for(int j=0;j<drule.size();j++) {
+		    RuleConjunction rconj=drule.get(j);
+		    boolean containsexclusion=false;
+		    for (int k=0;k<rconj.size();k++) {
+			DNFExpr dexpr=rconj.get(k);
+			if (dexpr.getNegation()&&
+			    dexpr.getExpr() instanceof ElementOfExpr&&
+			    ((ElementOfExpr)dexpr.getExpr()).element.equals(null,ve)) {
+			    SetDescriptor sd=((ElementOfExpr)dexpr.getExpr()).set;
+			    if (sd.isSubset(sd2))
+				containsexclusion=true;
+			}
+		    }
+		    if (!containsexclusion)
+			return false;
+		}
+	    }
+	}
+	return true;
+    }
+
+    boolean equivalent(SetExpr se, RelationExpr re) {
+	if (!(se instanceof ImageSetExpr))
+	    return false;
+	ImageSetExpr ise=(ImageSetExpr)se;
+	while(re!=null&&ise!=null) {
+	    if (re.getRelation()!=ise.getRelation())
+		return false;
+	    if (re.inverted()!=ise.inverted())
+		return false;
+	    if (ise.isimageset) {
+		ise=ise.getImageSetExpr();
+		if (!(re.getExpr() instanceof RelationExpr))
+		    return false;
+		re=(RelationExpr)re.getExpr();
+	    } else {
+		if (!(re.getExpr() instanceof VarExpr))
+		    return false;
+		if (((VarExpr)re.getExpr()).getVar()==ise.getVar())
+		    return true; //everything matches
+		return false;
+	    }
 	}
+	return false;
     }
 }