ai.grakn.graql.internal.reasoner.atom

Class Atom

java.lang.Object

ai.grakn.graql.internal.reasoner.atom.AtomicBase

ai.grakn.graql.internal.reasoner.atom.Atom

All Implemented Interfaces:

Atomic

Direct Known Subclasses:

Binary

public abstract class Atom
extends AtomicBase

AtomicBase extension defining specialised functionalities.

Author:

Kasper Piskorski

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	Atom(Atom a)
protected	Atom(VarPatternAdmin pattern, ReasonerQuery par)

Method Summary

Modifier and Type	Method and Description
Atom	addType(SchemaConcept type)
List<Atom>	atomOptions(Answer sub)
int	baseResolutionPriority()
int	computePriority(Set<Var> subbedVars) compute resolution priority based on provided substitution variables
java.util.stream.Stream<InferenceRule>	getApplicableRules()
IdPredicate	getIdPredicate(Var var)
abstract java.util.stream.Stream<Predicate>	getInnerPredicates()
<T extends Predicate> java.util.stream.Stream<T>	getInnerPredicates(Class<T> type)
MultiUnifier	getMultiUnifier(Atom parentAtom, boolean exact) find the (multi) unifier with parent atom
<T extends Atomic> java.util.stream.Stream<T>	getNeighbours(Class<T> type)
java.util.stream.Stream<Atomic>	getNonSelectableConstraints()
protected java.util.stream.Stream<IdPredicate>	getPartialSubstitutions()
<T extends Predicate> T	getPredicate(Var var, Class<T> type)
java.util.stream.Stream<Predicate>	getPredicates()
<T extends Predicate> java.util.stream.Stream<T>	getPredicates(Class<T> type)
abstract Var	getPredicateVariable()
Set<Var>	getRoleExpansionVariables()
abstract SchemaConcept	getSchemaConcept()
Set<TypeAtom>	getSpecificTypeConstraints()
java.util.stream.Stream<TypeAtom>	getTypeConstraints()
abstract ConceptId	getTypeId()
abstract Unifier	getUnifier(Atom parentAtom)
Set<VarProperty>	getVarProperties()
Atom	inferTypes()
boolean	isAtom()
boolean	isRecursive()
protected abstract boolean	isRuleApplicableViaAtom(Atom headAtom)
boolean	isRuleResolvable()
boolean	requiresMaterialisation()
boolean	requiresRoleExpansion()
Atom	rewriteToUserDefined(Atom parentAtom) rewrites the atom to one with user defined name
RelationshipAtom	toRelationshipAtom()

Methods inherited from class ai.grakn.graql.internal.reasoner.atom.AtomicBase

containsVar, copy, getCombinedPattern, getParentQuery, getPattern, getVarName, getVarNames, isUserDefined, setParentQuery, toString, tx

Methods inherited from class java.lang.Object

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

Methods inherited from interface ai.grakn.graql.admin.Atomic

equivalenceHashCode, isAllowedToFormRuleHead, isEquivalent, isPredicate, isRelation, isResource, isSelectable, isType, validateOntologically

Constructor Detail

Atom

protected Atom(VarPatternAdmin pattern,
               ReasonerQuery par)

Atom

protected Atom(Atom a)

Method Detail

toRelationshipAtom

public RelationshipAtom toRelationshipAtom()

isAtom

public boolean isAtom()

isRuleResolvable

public boolean isRuleResolvable()

isRecursive

public boolean isRecursive()

getVarProperties

public Set<VarProperty> getVarProperties()

Returns:

var properties this atom (its pattern) contains

getPartialSubstitutions

protected java.util.stream.Stream<IdPredicate> getPartialSubstitutions()

Returns:

partial substitutions for this atom (NB: instances)

getRoleExpansionVariables

public Set<Var> getRoleExpansionVariables()

Returns:

set of variables that need to be have their roles expanded

computePriority

public int computePriority(Set<Var> subbedVars)

compute resolution priority based on provided substitution variables

Parameters:

subbedVars - variables having a substitution

Returns:

resolution priority value

baseResolutionPriority

public int baseResolutionPriority()

Returns:

measure of priority with which this atom should be resolved

isRuleApplicableViaAtom

protected abstract boolean isRuleApplicableViaAtom(Atom headAtom)

getApplicableRules

public java.util.stream.Stream<InferenceRule> getApplicableRules()

Returns:

set of applicable rules - does detailed (slow) check for applicability

requiresMaterialisation

public boolean requiresMaterialisation()

Returns:

true if the atom requires materialisation in order to be referenced

requiresRoleExpansion

public boolean requiresRoleExpansion()

Returns:

true if the atom requires role expansion

getSchemaConcept

public abstract SchemaConcept getSchemaConcept()

Returns:

corresponding type if any

getTypeId

public abstract ConceptId getTypeId()

Returns:

type id of the corresponding type if any

getPredicateVariable

public abstract Var getPredicateVariable()

Returns:

value variable name

getPredicates

public java.util.stream.Stream<Predicate> getPredicates()

Returns:

set of predicates relevant to this atom

getPredicates

public <T extends Predicate> java.util.stream.Stream<T> getPredicates(Class<T> type)

Type Parameters:

T - the type of Predicate to return

Parameters:

type - the class of Predicate to return

Returns:

stream of predicates relevant to this atom

getIdPredicate

@Nullable
public IdPredicate getIdPredicate(Var var)

Parameters:

var - variable of interest

Returns:

id predicate referring to prescribed variable

getPredicate

@Nullable
public <T extends Predicate> T getPredicate(Var var,
                                                      Class<T> type)

Type Parameters:

T - predicate type generic

Parameters:

var - variable the predicate refers to

type - predicate type

Returns:

specific predicate referring to provided variable

getInnerPredicates

public abstract java.util.stream.Stream<Predicate> getInnerPredicates()

getInnerPredicates

public <T extends Predicate> java.util.stream.Stream<T> getInnerPredicates(Class<T> type)

Type Parameters:

T - the type of Predicate to return

Parameters:

type - the class of Predicate to return

Returns:

stream of predicates relevant to this atom

getTypeConstraints

public java.util.stream.Stream<TypeAtom> getTypeConstraints()

Returns:

set of types relevant to this atom

getNeighbours

public <T extends Atomic> java.util.stream.Stream<T> getNeighbours(Class<T> type)

Type Parameters:

T - the type of neighbour Atomic to return

Parameters:

type - the class of Predicate to return

Returns:

neighbours of this atoms, i.e. atoms connected to this atom via shared variable

getNonSelectableConstraints

public java.util.stream.Stream<Atomic> getNonSelectableConstraints()

Returns:

set of constraints of this atom (predicates + types) that are not selectable

getSpecificTypeConstraints

public Set<TypeAtom> getSpecificTypeConstraints()

Returns:

set of type atoms that describe specific role players or resource owner

inferTypes

public Atom inferTypes()

Specified by:

inferTypes in interface Atomic

Overrides:

inferTypes in class AtomicBase

atomOptions

public List<Atom> atomOptions(Answer sub)

Parameters:

sub - partial substitution

Returns:

list of possible atoms obtained by applying type inference

addType

public Atom addType(SchemaConcept type)

Parameters:

type - to be added to this Atom

Returns:

new Atom with specified type

rewriteToUserDefined

public Atom rewriteToUserDefined(Atom parentAtom)

rewrites the atom to one with user defined name

Parameters:

parentAtom - parent atom that triggers rewrite

Returns:

pair of (rewritten atom, unifiers required to unify child with rewritten atom)

getUnifier

public abstract Unifier getUnifier(Atom parentAtom)

Parameters:

parentAtom - atom to be unified with

Returns:

corresponding unifier

getMultiUnifier

public MultiUnifier getMultiUnifier(Atom parentAtom,
                                    boolean exact)

find the (multi) unifier with parent atom

Parameters:

parentAtom - atom to be unified with

exact - flag indicating whether unification should be exact

Returns:

multiunifier