package G4ip;+ −
+ − + − import pizza.util.Hashtable;+ −
import java.util.Vector;+ −
import G4ip.Form.*;+ −
import G4ip.ProofDisplay.*;+ −
import G4ip.Sequent.*;+ −
+ − + − /** The Gi4p prover.<p>+ −
* The prover is a thread in order to suspend the proof search+ −
* after one proof is found and to let the user make a choice + −
* of whether to stop or to continue with the proof search.+ −
* @author Christian Urban+ −
*/+ −
public class Prover extends Thread+ −
{ ProverApplet parent; // the parent of the prover;+ −
boolean once; // if true then at least one proof was found+ −
Sequent sequ; // the root sequent to be proved+ −
Vector frames; // to record all frames which have been opened+ −
int index ;+ −
Hashtable<int,Sequent> proof; // keeps a record of the proof+ −
+ −
+ −
/** The constructor creates a prover which proves a specific sequent.<p>+ −
* The parameter parent is for access to the applet buttons.+ −
*/+ −
public Prover(Sequent init_sequ, ProverApplet init_parent) {+ −
super("Prover");+ −
parent = init_parent;+ −
once = false;+ −
sequ = new Sequent(init_sequ);+ −
frames = new Vector();+ −
index = 1;+ −
proof = new Hashtable();+ −
}+ −
+ −
/** Starts the thread; calls prove and stops the thread when + −
* the proof search is finished.+ −
*/+ −
public void run()+ −
{ prove(1,sequ,initial_sc); + −
if (once == true) { + −
parent.messages.setText("No more proofs.");+ −
parent.messages.repaint();+ −
parent.repaint();+ −
}+ −
else { + −
parent.messages.setText("Not provable.");+ −
parent.messages.repaint();+ −
parent.repaint(); + −
}+ −
parent.switch_into_input_mode();+ −
this.stop(); // everything is done, stop the thread+ −
} + −
+ − /** Closes all frames which have been opened.+ −
*/+ −
public void finalize() { + −
for (int i=0; i<frames.size();i++) { + −
if (frames.elementAt != null) + −
{ ((ProofDisplay)frames.elementAt(i)).dispose(); }+ −
}+ −
}+ −
+ − /** The tactic of the proof search.<p>+ −
* Method prove first enumerates all formulae on the LHS + −
* as being the principal formula and attempts to apply left-rules, + −
* subsequently it analyses the goal formula. + −
*/ + −
public void prove(int index, Sequent is,(() -> void) sc) {+ −
Form principal;+ −
proof.put(index,new Sequent(is)); // add sequence to proof+ −
rightrules(index,is,sc);+ −
for (int i=0;i<is.Gamma.size();i++) {+ −
principal = (Form)is.Gamma.elementAt(i);+ −
is.Gamma.removeElement(principal); // Gamma minus principal formula+ −
leftrules(index,principal,is,sc);+ −
is.Gamma.insertElementAt(principal,i); // put principal formula+ −
} // back into Gamma + −
//rightrules(index,is,sc);+ −
proof.remove(index); // remove sequence from proof+ −
}+ −
+ − /** Analyses the goal formula. + −
*/+ −
public void rightrules(int index, Sequent sequ,(() -> void) sc) {+ −
Context Gamma = sequ.Gamma;+ −
switch(sequ.G) { + −
/** And-R+ −
* Gamma => A Gamma => B + −
* -------------------------- + −
* Gamma => A and B + −
*/+ −
case And(Form A,Form B): + −
prove(2*index,new Sequent(Gamma,A),+ −
fun() -> void { prove(2*index+1,new Sequent(Gamma,B),sc); } ); + −
break;+ −
+ − /** Imp-R + −
* Gamma,A => B + −
* ----------------- + −
* Gamma => A imp B + −
*/ + −
case Imp(Form A,Form B):+ −
prove(2*index,new Sequent(Gamma.add(A),B),sc); break;+ −
+ −
/** Or-R + −
* Gamma => A Gamma => B + −
* ----------------- or ----------------- + −
* Gamma => A or B Gamma => A or B + −
*/+ −
case Or(Form A,Form B):+ −
prove(2*index,new Sequent(Gamma,A),sc);+ −
prove(2*index,new Sequent(Gamma,B),sc); break;+ −
+ −
/** Equ-R+ −
* Gamma => A -> B Gamma => B -> A + −
* -------------------------------- + −
* Gamma => A <-> B + −
*/ + −
}+ −
}+ −
+ − /** Analyses the principal formula on the LHS. + −
*/+ −
public void leftrules(int index,Form principal,Sequent sequ,(() -> void) sc){+ −
Context Gamma = sequ.Gamma;+ −
Form G = sequ.G;+ −
switch(principal) {+ −
/** false-L+ −
* -------------------- + −
* false, Gamma => G + −
*/+ −
case False(): sc(); break;+ −
+ − /** Axiom+ −
* --------------- + −
* Gamma, G => G G being atomic + −
*/+ −
case Atm(String c):+ −
if (G instanceof Atm) {+ −
if (((Atm)G).c.compareTo(c) == 0) { sc(); }+ −
}+ −
break;+ −
+ − /** And-L+ −
* Gamma, A, B => G + −
* -------------------- + −
* Gamma, A and B => G + −
*/+ −
+ −
case And(Form A, Form B): + −
prove(2*index,new Sequent(Gamma.add(A,B),G),sc); break;+ −
+ − /** Or-R+ −
* Gamma, A => G Gamma, B => G + −
* ------------------------------- + −
* Gamma, A or B => G + −
*/ + −
case Or(Form A, Form B):+ −
prove(2*index,new Sequent(Gamma.add(A),G),+ −
fun() -> void {prove(2*index+1,new Sequent(Gamma.add(B),G),sc);});+ −
break;+ −
+ − /** Imp-L 2 + −
* Gamma, A imp (B imp C) => G + −
* ------------------------------+ −
* Gamma, (A and B) imp C => G + −
*/+ −
case Imp(And(Form A, Form B), Form C):+ −
prove(2*index,new Sequent(Gamma.add(Imp(A,Imp(B,C))),G),sc); break; + −
+ − + − /** Imp-L 3 + −
* Gamma, (A imp C), (B imp C) => G + −
* ----------------------------------+ −
* Gamma, (A or B) imp C => G + −
*/+ −
case Imp(Or(Form A, Form B), Form C): + −
prove(2*index,new Sequent(Gamma.add(Imp(A,C),Imp(B,C)),G),sc); break; + −
+ − /** Imp-L 4 + −
* Gamma, (B imp C) => (A imp B) Gamma, C => G + −
* ------------------------------------------------+ −
* Gamma, (A imp B) imp C => G + −
*/+ −
case Imp(Imp(Form A, Form B), Form C): + −
prove(2*index,new Sequent(Gamma.add(Imp(B,C)),Imp(A,B)),+ −
fun() -> void { prove(2*index+1,new Sequent(Gamma.add(C),G),sc);});+ −
break; + −
/** Imp-L 1 + −
* Gamma(A), B => G A being atomic + −
* ------------------------ Gamma(A) means:+ −
* Gamma(A), A imp B => G Gamma contains A+ −
*/ + −
case Imp(Form A, Form B):+ −
if (A instanceof Atm) { + −
if (Gamma.includes(A)) {+ −
{ prove(2*index,new Sequent(Gamma.add(B),G),sc); }+ −
}+ −
}+ −
break; + −
}+ −
+ − }+ −
+ − + − /** The initial success continuation. + −
* Suspends the thread when a proof is found. + −
*/+ −
public void initial_sc() { + −
once = true;+ −
ProofDisplay p = new ProofDisplay(proof);+ −
frames.addElement(p); // keep a record for later disposal+ −
try { // suspend the proof search, + −
suspend(); } // it might be resumed later on by the user+ −
catch(SecurityException sec_exc)+ −
{ /* this catch is neccessary for Netscape 3.0 (Linux) */ }+ −
} + −
+ −
}+ −