package expansion
- Alphabetic
- By Inheritance
- expansion
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
trait
BinaryExpansionTree
extends ExpansionTree
An expansion tree with two subtrees.
-
case class
ETAnd
(child1: ExpansionTree, child2: ExpansionTree) extends BinaryExpansionTree with Product with Serializable
A tree representing A ∧ B.
A tree representing A ∧ B.
- child1
A tree representing A.
- child2
A tree representing B.
-
case class
ETAtom
(atom: HOLAtom, polarity: Polarity) extends ExpansionTree with Product with Serializable
A tree representing an atomic formula.
A tree representing an atomic formula.
- atom
The represented atom.
-
case class
ETBottom
(polarity: Polarity) extends ExpansionTree with Product with Serializable
A tree representing ⊥.
-
case class
ETDefinedAtom
(atom: HOLAtom, polarity: Polarity, definedExpr: LambdaExpression) extends ExpansionTree with Product with Serializable
A tree whose deep formula is an atom, and whose shallow formula is the definitional expansion of the atom.
A tree whose deep formula is an atom, and whose shallow formula is the definitional expansion of the atom.
This tree is used as an intermediate data structure during proof import from clausal provers. During clausification, it is often advantageous to abbreviate subformulas by fresh atoms. (This is necessary for polynomial-time clausification.) These subformula abbreviations are then translated into expansion trees using defined atoms and extra axioms. If we replace a subformula φ(x,y) by the atom D(x,y), then we have an ETDefinedAtom(D(x,y), ..., λxλy φ(x,y)) as an expansion of the subformula, as well as expansions of the extra axiom ∀x∀y(D(x,y) <-> φ(x,y)).
Another way to view defined atoms is the extracted expansions of non-atomic logical axioms in LK. Consider a proof in LK of φ:-φ that consists of just LogicalAxiom(φ). Instead of first performing an atomic expansion, we could directly extract an expansion proof with defined atoms: ETDefinedAtom(D, InAnt, φ) :- ETDefinedAtom(D, InSuc, φ) This expansion proof has the deep sequent D:-D and the shallow sequent φ:-φ. (NB: this extraction is not implemented.)
- atom
The atom (whose predicate symbol is defined)
- polarity
Polarity of the atom.
- definedExpr
Definitional expansion of the predicate symbol.
-
case class
ETDefinition
(shallow: HOLAtom, definedExpr: LambdaExpression, child: ExpansionTree) extends UnaryExpansionTree with Product with Serializable
Expansion tree node for definitions.
Expansion tree node for definitions.
- shallow
An atom P(x1,..., xn) where P stands for a more complex formula.
- definedExpr
The expression that P abbreviates. Must have the same type as P.
- child
An expansion tree of definedExpr(x1,...,xn).
-
case class
ETImp
(child1: ExpansionTree, child2: ExpansionTree) extends BinaryExpansionTree with Product with Serializable
A tree representing A ⊃ B.
A tree representing A ⊃ B.
- child1
A tree representing A.
- child2
A tree representing B.
-
case class
ETMerge
(child1: ExpansionTree, child2: ExpansionTree) extends BinaryExpansionTree with Product with Serializable
A node signifying that two trees need to be merged.
A node signifying that two trees need to be merged.
The two trees must have the same shallow formula.
- child1
The left subtree.
- child2
The right subtree.
-
case class
ETNeg
(child: ExpansionTree) extends UnaryExpansionTree with Product with Serializable
A tree representing ¬A.
A tree representing ¬A.
- child
A tree representing A.
-
case class
ETOr
(child1: ExpansionTree, child2: ExpansionTree) extends BinaryExpansionTree with Product with Serializable
A tree representing A ∨ B.
A tree representing A ∨ B.
- child1
A tree representing A.
- child2
A tree representing B.
-
trait
ETQuantifier
extends ExpansionTree
A general trait for trees representing quantified formulas.
-
case class
ETSkolemQuantifier
(shallow: HOLFormula, skolemTerm: LambdaExpression, skolemDef: LambdaExpression, child: ExpansionTree) extends ETQuantifier with UnaryExpansionTree with Product with Serializable
A tree representing a formula beginning with a strong quantifier, i.e., a positive universal or a negative existential.
A tree representing a formula beginning with a strong quantifier, i.e., a positive universal or a negative existential.
As an example let us consider an expansion proof of ∀z P(c,z) :- ∃x ∀y P(x,y). For Skolemization we introduce the Skolem function
s_1
(for the single strong quantifier), this function has the Skolem definitionλx ∀y P(x,y)
(see at.logic.gapt.expr.hol.SkolemFunctions for details). The natural expansion proof has the deep formulaP(c,s_1(c)) :- P(c,s_1(c))
, so we need a Skolem node with the shallow formula∀y P(c,y)
, and deep formulaP(c,s_1(c))
. This Skolem node is constructed asETSkolemQuantifier(∀y P(c,y), s_1(c), λx ∀y P(x,y), ETAtom(P(c,s_1(c)), InSuc))
.- shallow
Shallow formula of the expansion tree.
- skolemTerm
Skolem term that instantiates the strong quantifier, e.g. s_3(c)
- skolemDef
Skolem definition for the Skolem symbol, see at.logic.gapt.expr.hol.SkolemFunctions
- child
Expansion tree of the instantiated formula.
-
case class
ETStrongQuantifier
(shallow: HOLFormula, eigenVariable: Var, child: ExpansionTree) extends ETQuantifier with UnaryExpansionTree with Product with Serializable
A tree representing a formula beginning with a strong quantifier, i.e., a positive universal or a negative existential.
A tree representing a formula beginning with a strong quantifier, i.e., a positive universal or a negative existential.
It has the form Qx.A +α E, where α is a variable (called the eigenvariable) and E is an expansion tree of A[x\α].
Its deep formula is the deep formula of E.
- shallow
The formula A.
- eigenVariable
The variable α.
- child
The subtree E.
-
case class
ETTop
(polarity: Polarity) extends ExpansionTree with Product with Serializable
A tree representing ⊤.
-
case class
ETWeakQuantifier
(shallow: HOLFormula, instances: Map[LambdaExpression, ExpansionTree]) extends ETQuantifier with Product with Serializable
A tree representing a formula beginning with a weak quantifier, i.e., a positive existential or negative universal.
A tree representing a formula beginning with a weak quantifier, i.e., a positive existential or negative universal.
It has the form Qx.A +t1 E1 + … +tn En, where t1,…,tn are lambda terms of the same type as x and Ei is an expansion tree of A[x\ti].
Its deep formula is E1.deep ∨ … ∨ En.deep (in the case of an existential) or E1.deep ∧ … ∧ En.deep (in the case of a universal).
- shallow
The formula Qx.A.
- instances
A map containing the pairs t1 → E1,…,tn → En.
-
case class
ETWeakening
(formula: HOLFormula, polarity: Polarity) extends ExpansionTree with Product with Serializable
A tree representing a formula that originates from a weakening.
A tree representing a formula that originates from a weakening.
- formula
The represented formula.
- case class ExpansionProof (expansionSequent: Sequent[ExpansionTree]) extends Product with Serializable
- class ExpansionProofToLK extends SolveUtils
- case class ExpansionProofWithCut (expansionWithCutAxiom: ExpansionProof) extends Product with Serializable
- type ExpansionSequent = Sequent[ExpansionTree]
-
trait
ExpansionTree
extends DagProof[ExpansionTree]
A tree collecting instances of a formula.
A tree collecting instances of a formula. See, e.g., M. Baaz, S. Hetzl, D. Weller: On the complexity of proof deskolemization, Journal of Symbolic Logic, 77(2), 2012 for a formulation close to the one implemented here.
- class ExpansionTreePrettyPrinter extends BabelExporter
-
class
InstanceTermEncoding
extends AnyRef
Encodes instances of an end-sequent as terms.
Encodes instances of an end-sequent as terms.
Only instances of weak quantifiers are recorded, instances of strong quantifiers or free variables are ignored.
The end-sequent will be internally transformed into one which is in variable normal form.
In the case of cut-introduction, the end-sequent has no free variables and no strong quantifiers and we're encoding a Herbrand sequent as a set of terms. A term r_i(t_1,...,t_n) encodes an instance of the formula "forall x_1 ... x_n, phi(x_1,...,x_n)" using the instances (t_1,...,t_n).
In the case of inductive proofs, the end-sequent contains strong quantifiers variable (alpha). Here, we consider proofs of instance sequents, which are obtained by e.g. substituting a numeral for alpha. Hence the formulas occurring in the end-sequents of instance proofs are substitution instances of endSequent; the encoded terms still only capture the instances used in the instance proofs--i.e. not alpha.
-
implicit
class
RichExpansionSequent
extends AnyRef
Extension class that allows calling shallow and deep on sequents.
-
trait
UnaryExpansionTree
extends ExpansionTree
An expansion tree with one subtree.
Value Members
- val ExpansionSequent: Sequent.type
- implicit val expansionProofsAreClosedUnderSubstitution: ClosedUnderSub[ExpansionProof]
- implicit val expansionProofsWithCutAreClosedUnderSubstitution: ClosedUnderSub[ExpansionProofWithCut]
- implicit val expansionTreesAreClosedUnderAdmissibleSubstitutions: ClosedUnderSub[ExpansionTree]
- object ETMerge extends Serializable
- object ETQuantifier
- object ETStrongQuantifierBlock
- object ETWeakQuantifier extends Serializable
-
object
ETWeakQuantifierBlock
Creates or matches a block of weak quantifiers.
- object ExpansionProofToLK extends ExpansionProofToLK
- object ExpansionProofWithCut extends Serializable
- object InstanceTermEncoding
- object PropositionalExpansionProofToLK extends ExpansionProofToLK
-
object
addSymmetry
Given an expansion sequent S which is a tautology modulo symmetry of equality, returns an expansion sequent S' which is S extended by the symmetry instances needed to make it a tautology.
-
object
cleanStructureET
Cleans up an expansion tree by introducing weakenings as late as possible.
-
object
eigenVariablesET
Returns the eigenvariables in an expansion tree or expansion sequent.
- object eliminateCutsET
- object eliminateDefsET
- object eliminateMerges
- implicit object expansionProofsAreReplaceable extends ClosedUnderReplacement[ExpansionProof]
- implicit object expansionProofsWithCutAreReplaceable extends ClosedUnderReplacement[ExpansionProofWithCut]
- implicit object expansionTreesAreReplaceable extends ClosedUnderReplacement[ExpansionTree]
-
object
extractInstances
Extracts the instances used in a prenex FOL Pi_1 expansion tree / Sigma_1 expansion sequent.
Extracts the instances used in a prenex FOL Pi_1 expansion tree / Sigma_1 expansion sequent.
Each expansion tree is transformed into a list of instances of its shallow formula.
In contrast to ExpansionProof.deep, this function doesn't produce conjunctions of instances, but instead increases the number of formulas in the antecedent/succedent.
- object formulaToExpansionTree
- object freeVariablesET
- object generalizeET
- object groundTerms
-
object
minimalExpansionSequent
Given an expansion sequent S, this algorithm computes a single expansion sequents below S that is valid and minimal.
Given an expansion sequent S, this algorithm computes a single expansion sequents below S that is valid and minimal. This algorithm is considerably faster than the one implemented in minimalExpansionSequents.
-
object
minimalExpansionSequents
Given an expansion sequent S, this algorithm computes the list of expansion sequents below S that are valid and minimal.
- object numberOfInstancesET
- object prenexifyET
- object replaceAtHOLPosition
-
object
replaceWithContext
Replaces terms in an expansion tree according to a replacement context.
-
object
unifyInstancesET
Decreases the number of instances in an expansion proof by unifying the instance terms.