wytp.proof.rules.quantifier

Class ExistentialElimination

java.lang.Object

wytp.proof.util.AbstractProofRule

wytp.proof.rules.quantifier.ExistentialElimination

All Implemented Interfaces:

Proof.LinearRule, Proof.Rule

public class ExistentialElimination
extends AbstractProofRule
implements Proof.LinearRule

Responsible for eliminating an existential quantifier through skolemisation. For example, if we encounter exists(int i).(i >= 0) then we replace this with the ground term i >= 0, where i is now a skolem (that is, an unknown constant).

NOTE: This rule current exploits the underlying structure of a syntactic heap for ensuring that a given variable remains a skolem. This is problematic in the case of existentials nested within universal quantifiers and could be improved somewhat.

Author:

David J. Pearce

Field Summary

Fields inherited from class wytp.proof.util.AbstractProofRule

simp, types

Constructor Summary

Constructors

Constructor and Description
ExistentialElimination(Simplification simplify, TypeSystem types)

Method Summary

Modifier and Type	Method and Description
Proof.State	apply(Proof.State head, Formula truth)
protected Formula	expandTypeInvariants(wybs.util.AbstractCompilationUnit.Tuple<WyalFile.VariableDeclaration> declarations, TypeSystem types) For a given sequence of variable declarations expand their type invariants as appropriate.
String	getName() Get the name of this rule

Methods inherited from class wytp.proof.util.AbstractProofRule

apply, extractDefinedTerms, findAllInstances, substitute

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface wytp.proof.Proof.LinearRule

apply

Constructor Detail

ExistentialElimination

public ExistentialElimination(Simplification simplify,
                              TypeSystem types)

Method Detail

getName

public String getName()

Description copied from interface: Proof.Rule

Get the name of this rule

Specified by:

getName in interface Proof.Rule

Returns:

apply

public Proof.State apply(Proof.State head,
                         Formula truth)
                  throws wybs.lang.NameResolver.ResolutionError

Specified by:

apply in class AbstractProofRule

Throws:

wybs.lang.NameResolver.ResolutionError

expandTypeInvariants

protected Formula expandTypeInvariants(wybs.util.AbstractCompilationUnit.Tuple<WyalFile.VariableDeclaration> declarations,
                                       TypeSystem types)
                                throws wybs.lang.NameResolver.ResolutionError

For a given sequence of variable declarations expand their type invariants as appropriate. This expansion is done lazily, in that it produces invocations to the type invariants themselves. Such invocations must then be separately expanded (like macros) later on. As an example, consider this:

 type nat is (int x) where x >= 0

 assert:
     forall(nat x):
         x >= 0
 

The type invariant given for x in the quantifier will be expanded, to give then body nat(x) ==> x >= 0. The call nat(x) will later be expanded during theorem proving to x >= 0. The reason this is done lazily is to properly support recursive types and their invariants.

Parameters:

declarations -

types -

Returns:

Throws:

wybs.lang.NameResolver.ResolutionError