Strategy to tell prove procedure which rules to apply
Strategy to tell prove procedure which rules to apply
A strategy selects a next action to execute. An action is represented by a formula and the information whether this formula is in the antecedent or the succedent. The action is to apply a rule to this formula.
Strategy for proving propositional sequents.
Checks if two proof have the same branching structure.
Checks if two proof have the same branching structure.
does not work for LKsk proofs
Removes the redundant weakenings and contractions.
Removes the redundant weakenings and contractions. Traverses the proof top down, keeping track of the weakened formulas in ws. When processing each rule, checks whether the auxiliary formulas are in ws. If all were previously weakened, remove them from ws and adds the main formula.
I am aware the code is really really hard to read. I am sorry for that. In order to get it properly optimized, I had to use continuation-passing-style and the TailCall library from scala. This makes it particularly exotic. If you are going through the trouble of reading it (so brave of you ;), it's good to keep the following in mind: 1. Ignore tailcalls and everything associated with it 2. Treat the continuation call not as a function call but as if its arguments were the return value of the function.
The answer to the optimization was found here: http://stackoverflow.com/questions/20164061/how-to-acheive-tail-call-optimization-while-traversing-tree-like-structure-using
This macro rule simulates a series of contractions in the antecedent.
This macro rule simulates a series of contractions in both cedents.
This macro rule simulates a series of contractions in the succedent.
Macro rule that simulates several term replacements at once.
This macro rule unifies EquationLeft1Rule and EquationLeft2Rule by automatically choosing the appropriate rule.
Macro rule that simulates several term replacements at once.
This macro rule unifies EquationRight1Rule and EquationRight2Rule by automatically choosing the appropriate rule.
Binary induction rule:
Binary induction rule:
Γ |- Δ, A[0] A[x], Π |- Λ, A[s(x)] -----------------------------------------(ind) Γ, Π |- Δ, Λ, A[t]
This object implements a version of Gentzen's cut-elimination proof for our sequent calculus LK.
This object implements a version of Gentzen's cut-elimination proof for our sequent calculus LK. For details, please refer to the documentation of the apply methods.
This macro rule simulates multiple weakenings and contractions in both cedents.
This macro rule simulates a series of weakenings in the antecedent.
This macro rule simulates a series of weakenings in both cedents.
This macro rule simulates a series of weakenings in the succedent.
Condensation implements the redundancy optimization technique of the same name, see also Leitsch: The Resolution Calculus chapter 3.2
true iff this proof contains a reflexivity axiom or an equational inference
Extracts the cut-formulas from an LK proof.
An implementation of definition elmination which guesses the definitions.
An implementation of definition elmination which guesses the definitions. Alternatively, you can use at.logic.gapt.algorithms.rewriting.DefinitionElimination instead, which gets the definitions explicitly passed.
Extracts all auxiliary formulas in a proof.
Extracts the cut-ancestor formulas from a proof.
Extracts a list of suproofs which end in a cut rule.
An implementation of LK proof regularization.
An implementation of LK proof regularization. In a regular LK proof, an eigenvariable is globally unique to the proof. E.g. P(u) :- P(u) P(u) :- P(u) ----------------- fa:l ------------------- fa:l \A x:P(x) :- P(u) \A x:P(x) :- P(u) ----------------------- fa:r ------------------- fa:r \A x:P(x) :- \E x:P(x) \A x:P(x) :- \E x: P(x) --------------------------------------------------------- conj:r \A x:P(x), \A x:P(x) :- \E x:P(x) /\ \E x:P(x) --------------------------------------------------------- contr:l \A x:P(x) :- \E x:P(x) /\ \E x:P(x)
is not regular, but P(i) :- P(i) P(u) :- P(u) ----------------- fa:l ------------------- fa:l \A x:P(x) :- P(i) \A x:P(x) :- P(u) ----------------------- fa:r ------------------- fa:r \A x:P(x) :- \E x:P(x) \A x:P(x) :- \E x: P(x) --------------------------------------------------------- conj:r \A x:P(x), \A x:P(x) :- \E x:P(x) /\ \E x:P(x) --------------------------------------------------------- contr:l \A x:P(x) :- \E x:P(x) /\ \E x:P(x)
is.
Bottom-up construction of sequent calculus proofs.
Bottom-up construction of sequent calculus proofs.
Currently supports propositional logic as well as proof construction using expansion trees.