Package | Description |
---|---|
at.jku.risc.stout.nau.algo |
This package contains the classes of the rule based system
(
AntiUnifySystem ) to solve the nominal
anti-unification problem and an algorithm to solve the nominal
equivariance problem (EquivarianceSystem )
which is needed by the anti-unification algorithm. |
at.jku.risc.stout.nau.data |
This package contains the nominal parser and some container classes like
equation systems, freshness context and a container for nominal pairs.
|
at.jku.risc.stout.nau.data.atom |
This package contains the classes which are needed to build up the term tree
(E.g.: Atom,
Abstraction,
FunctionApplication,
Suspension,
SortAtom,
SortData,
NodeFactory,...).
|
Modifier and Type | Method and Description |
---|---|
NominalTerm |
Substitution.get(Variable var)
Returns the associated NominalTerm for a given
Variable or null if no mapping exists.
|
Modifier and Type | Method and Description |
---|---|
Equation<NominalTerm> |
EquivarianceProblem.deepCopy() |
Equation<NominalTerm> |
AntiUnifyProblem.deepCopy() |
Map<Variable,NominalTerm> |
Substitution.getMapping() |
Modifier and Type | Method and Description |
---|---|
AntiUnifyProblem |
AntiUnifySystem.addEquation(NominalTerm left,
NominalTerm right,
boolean deepCopy)
Adds an anti-unification problem to the set of problems.
|
void |
EquivarianceSystem.addEquation(NominalTerm eq1Left,
NominalTerm eq2Left,
boolean deepCopy)
Adds a matching problem to the problem set.
|
void |
Substitution.composeInRange(Variable fromVar,
NominalTerm toTerm)
Substitution composition which does not add new variables to the mapping.
|
static void |
EquivarianceProblem.printString(Writer toPrint,
NominalTerm left,
NominalTerm right) |
static void |
AntiUnifyProblem.printString(Writer toPrint,
NominalTerm left,
NominalTerm right,
Variable genVar) |
void |
Substitution.put(Variable fromVar,
NominalTerm toTerm)
Add a new mapping of the form: Variable -> Term.
|
Constructor and Description |
---|
AntiUnifyProblem(NominalTerm left,
NominalTerm right,
NodeFactory factory)
A constructor who takes two nominal terms and a factory to instantiate a
fresh generalization variable.
|
EquivarianceProblem(NominalTerm left,
NominalTerm right) |
Modifier and Type | Method and Description |
---|---|
<T extends Equation<NominalTerm>> |
InputParser.parseEquation(Reader in1,
Reader in2,
EquationSystem<T> eqSys) |
<T extends Equation<NominalTerm>> |
InputParser.parseEquationSystem(Reader in,
EquationSystem<T> eqSys)
Pull characters from the given Reader and parse the input.
|
Modifier and Type | Method and Description |
---|---|
NominalTerm |
NominalPair.getTerm()
Returns the nominal term (NominalTerm) of this nominal pair.
|
NominalTerm |
InputParser.parseTerm(Reader in,
boolean reset)
Pull characters from the given Reader and parse the input.
|
Modifier and Type | Method and Description |
---|---|
void |
FreshnessCtx.addFreshConstraint(Atom atom,
NominalTerm... nomTerms)
Add freshness constraints as needed, such that the given atom is fresh in
all the given nominal terms.
|
abstract T |
EquationSystem.newEquation(NominalTerm left,
NominalTerm right)
You have to implement this method, so that an algorithm is able to
instantiate new Equations of arbitrary types.
|
static void |
NominalPair.printPair(Writer toPrint,
FreshnessCtx freshEnv,
NominalTerm term) |
void |
NominalPair.setTerm(NominalTerm term)
Changes the nominal term (NominalTerm) of this nominal pair.
|
void |
NominalPair.substitute(Variable fromVar,
NominalTerm toTerm)
Applies a substitution to the nominal pair.
|
void |
FreshnessCtx.substitute(Variable fromVar,
NominalTerm toTerm) |
Constructor and Description |
---|
NominalPair(FreshnessCtx freshEnv,
NominalTerm term)
Instantiates a nominal pair with then given freshness context and
nominal term.
|
NominalPair(NominalTerm term)
Instantiates a nominal pair with an empty freshness context.
|
Modifier and Type | Class and Description |
---|---|
class |
Abstraction
An abstraction is a NominalTerm which consists of a bound atom
and a subterm.
|
class |
Atom
An Atom is a NominalTerm, consisting of the atom
name and an optional origin name.
|
class |
FunctionApplication
A FunctionApplication is a NominalTerm consisting
of a unique FunctionSymbol and an array of arguments.
|
class |
Suspension
|
Modifier and Type | Field and Description |
---|---|
static NominalTerm[] |
FunctionApplication.emptyArgs |
Modifier and Type | Method and Description |
---|---|
NominalTerm |
Atom.deepCopy() |
NominalTerm[] |
FunctionApplication.getArgs() |
NominalTerm |
Abstraction.getSubTerm() |
NominalTerm |
FunctionApplication.permute(Permutation perm) |
NominalTerm |
Suspension.permute(Permutation perm) |
abstract NominalTerm |
NominalTerm.permute(Permutation perm) |
NominalTerm |
Atom.substitute(Variable fromVar,
NominalTerm toTerm) |
NominalTerm |
FunctionApplication.substitute(Variable fromVar,
NominalTerm toTerm) |
NominalTerm |
Suspension.substitute(Variable fromVar,
NominalTerm toTerm) |
NominalTerm |
Abstraction.substitute(Variable fromVar,
NominalTerm toTerm) |
abstract NominalTerm |
NominalTerm.substitute(Variable fromVar,
NominalTerm toTerm) |
NominalTerm |
FunctionApplication.swap(Atom a1,
Atom a2) |
NominalTerm |
Suspension.swap(Atom a1,
Atom a2) |
NominalTerm |
Abstraction.swap(Atom a1,
Atom a2) |
abstract NominalTerm |
NominalTerm.swap(Atom a1,
Atom a2) |
Modifier and Type | Method and Description |
---|---|
boolean |
NominalTerm.equivalent(NominalTerm otherTerm,
FreshnessCtx nabla)
Alpha-equivalence test of two nominal terms respecting nabla.
|
void |
Abstraction.setSubTerm(NominalTerm subTerm) |
NominalTerm |
Atom.substitute(Variable fromVar,
NominalTerm toTerm) |
NominalTerm |
FunctionApplication.substitute(Variable fromVar,
NominalTerm toTerm) |
NominalTerm |
Suspension.substitute(Variable fromVar,
NominalTerm toTerm) |
NominalTerm |
Abstraction.substitute(Variable fromVar,
NominalTerm toTerm) |
abstract NominalTerm |
NominalTerm.substitute(Variable fromVar,
NominalTerm toTerm) |
Modifier and Type | Method and Description |
---|---|
boolean |
NominalTerm.traverse(Traversable.TraverseCallBack<NominalTerm> callBack)
Traverses the term tree and executes the callback function at every
subterm.
|
Constructor and Description |
---|
Abstraction(Atom boundAtom,
NominalTerm subTerm) |
FunctionApplication(FunctionSymbol fncSymb,
NominalTerm[] args)
Instantiates a function application with the given arguments.
|
Constructor and Description |
---|
FunctionApplication(FunctionSymbol fncSymb,
List<NominalTerm> args)
Instantiates a function application with the given arguments.
|