Atom (grakn-graql 1.4.2 API)

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

Field Summary

Fields
Modifier and Type Field and Description

protected Set<InferenceRule> applicableRules

Fields
Modifier and Type	Field and Description
`protected Set<InferenceRule>`	`applicableRules`

Constructor Summary

Constructors
Constructor and Description

Atom()

Constructors
Constructor and Description
`Atom()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`Atom`	`addType(SchemaConcept type)`
`List<Atom>`	`atomOptions(ConceptMap sub)`
`java.util.stream.Stream<InferenceRule>`	`getApplicableRules()`
`abstract java.util.stream.Stream<Predicate>`	`getInnerPredicates()`
`<T extends Predicate> java.util.stream.Stream<T>`	`getInnerPredicates(Class<T> type)`
`MultiUnifier`	`getMultiUnifier(Atom parentAtom, UnifierComparison unifierType)` 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()`
`java.util.stream.Stream<IdPredicate>`	`getPartialSubstitutions()`
`com.google.common.collect.ImmutableList<SchemaConcept>`	`getPossibleTypes()`
`java.util.stream.Stream<Rule>`	`getPotentialRules()`
`abstract Var`	`getPredicateVariable()`
`Set<Var>`	`getRoleExpansionVariables()`
`abstract SchemaConcept`	`getSchemaConcept()`
`java.util.stream.Stream<TypeAtom>`	`getTypeConstraints()`
`abstract ConceptId`	`getTypeId()`
`abstract Unifier`	`getUnifier(Atom parentAtom, UnifierComparison unifierType)` attempt to find a UNIQUE unifier with the parent atom
`java.util.stream.Stream<VarProperty>`	`getVarProperties()`
`abstract Class<? extends VarProperty>`	`getVarPropertyClass()`
`Atom`	`inferTypes()`
`Atom`	`inferTypes(ConceptMap sub)`
`boolean`	`isAtom()`
`boolean`	`isBounded()`
`boolean`	`isDisconnected()`
`boolean`	`isGround()`
`boolean`	`isRecursive()`
`protected abstract boolean`	`isRuleApplicableViaAtom(Atom headAtom)`
`boolean`	`isRuleResolvable()`
`abstract boolean`	`isUnifiableWith(Atom atom)`
`java.util.stream.Stream<ConceptMap>`	`materialise()`
`boolean`	`requiresDecomposition()`
`boolean`	`requiresMaterialisation()`
`boolean`	`requiresRoleExpansion()`
`boolean`	`requiresSchema()`
`Set<Atom>`	`rewriteToAtoms()`
`abstract Atom`	`rewriteToUserDefined(Atom parentAtom)` rewrites the atom to one with suitably user-defined names depending on provided parent
`Atom`	`rewriteWithRelationVariable()` rewrites the atom to one with user defined relation variable
`abstract Atom`	`rewriteWithTypeVariable()`
`Atom`	`rewriteWithTypeVariable(Atom parentAtom)` rewrites the atom to user-defined type variable
`IsaAtom`	`toIsaAtom()`
`RelationshipAtom`	`toRelationshipAtom()`
`Set<String>`	`validateAsRuleHead(Rule rule)`

Methods inherited from class ai.grakn.graql.internal.reasoner.atom.AtomicBase
checkValid, createCombinedPattern, getCombinedPattern, getIdPredicate, getPredicate, getPredicates, getPredicates, getVarNames, isUserDefined, 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
alphaEquivalenceHashCode, copy, getParentQuery, getPattern, getVarName, isAlphaEquivalent, isCompatibleWith, isRelation, isResource, isSelectable, isStructurallyEquivalent, isType, structuralEquivalenceHashCode, validateOntologically

- Field Detail
  - applicableRules
```
protected Set<InferenceRule> applicableRules
```
- Constructor Detail
  - Atom
```
public Atom()
```
- Method Detail
  - toRelationshipAtom
```
public RelationshipAtom toRelationshipAtom()
```
  - toIsaAtom
```
public IsaAtom toIsaAtom()
```
  - isUnifiableWith
```
public abstract boolean isUnifiableWith(Atom atom)
```
  - isAtom
```
public boolean isAtom()
```
  - isRuleResolvable
```
public boolean isRuleResolvable()
```
  - isRecursive
```
public boolean isRecursive()
```
  - isGround
```
public boolean isGround()
```
    Returns:
    
    true if the atom is ground (all variables are bound)
  - isBounded
```
public boolean isBounded()
```
    Returns:
    
    true if this atom is bounded - via substitution/specific resource or schema
  - isDisconnected
```
public boolean isDisconnected()
```
    Returns:
    
    true if this atom is disconnected (doesn't have neighbours)
  - requiresSchema
```
public boolean requiresSchema()
```
    Returns:
    
    true if this atom requires direct schema lookups
  - getVarPropertyClass
```
public abstract Class<? extends VarProperty> getVarPropertyClass()
```
  - validateAsRuleHead
```
public Set<String> validateAsRuleHead(Rule rule)
```
    Specified by:
    
    validateAsRuleHead in interface Atomic
    
    Overrides:
    
    validateAsRuleHead in class AtomicBase
  - getVarProperties
```
public java.util.stream.Stream<VarProperty> getVarProperties()
```
    Returns:
    
    var properties this atom (its pattern) contains
  - getPartialSubstitutions
```
public 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
  - isRuleApplicableViaAtom
```
protected abstract boolean isRuleApplicableViaAtom(Atom headAtom)
```
  - getPotentialRules
```
public java.util.stream.Stream<Rule> getPotentialRules()
```
    Returns:
    
    set of potentially applicable rules - does shallow (fast) check for applicability
  - 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
  - requiresDecomposition
```
public boolean requiresDecomposition()
```
    Returns:
    
    if this atom requires decomposition into a set of atoms
  - 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
  - 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
  - inferTypes
```
public Atom inferTypes()
```
    Specified by:
    
    inferTypes in interface Atomic
    
    Overrides:
    
    inferTypes in class AtomicBase
  - inferTypes
```
public Atom inferTypes(ConceptMap sub)
```
    Overrides:
    
    inferTypes in class AtomicBase
  - getPossibleTypes
```
public com.google.common.collect.ImmutableList<SchemaConcept> getPossibleTypes()
```
    Returns:
    
    list of types this atom can take
  - atomOptions
```
public List<Atom> atomOptions(ConceptMap 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
  - materialise
```
public java.util.stream.Stream<ConceptMap> materialise()
```
  - rewriteToAtoms
```
public Set<Atom> rewriteToAtoms()
```
    Returns:
    
    set of atoms this atom can be decomposed to
  - rewriteWithTypeVariable
```
public Atom rewriteWithTypeVariable(Atom parentAtom)
```
    rewrites the atom to user-defined type variable
    
    Parameters:
    
    parentAtom - parent atom that triggers rewrite
    
    Returns:
    
    rewritten atom
  - rewriteToUserDefined
```
public abstract Atom rewriteToUserDefined(Atom parentAtom)
```
    rewrites the atom to one with suitably user-defined names depending on provided parent
    
    Parameters:
    
    parentAtom - parent atom that triggers rewrite
    
    Returns:
    
    rewritten atom
  - rewriteWithTypeVariable
```
public abstract Atom rewriteWithTypeVariable()
```
  - rewriteWithRelationVariable
```
public Atom rewriteWithRelationVariable()
```
    rewrites the atom to one with user defined relation variable
    
    Returns:
    
    rewritten atom
  - getUnifier
```
@Nullable
public abstract Unifier getUnifier(Atom parentAtom,
                                             UnifierComparison unifierType)
```
    attempt to find a UNIQUE unifier with the parent atom
    
    Parameters:
    
    parentAtom - atom to be unified with
    
    unifierType - type of unifier to be computed
    
    Returns:
    
    corresponding unifier
  - getMultiUnifier
```
public MultiUnifier getMultiUnifier(Atom parentAtom,
                                    UnifierComparison unifierType)
```
    find the (multi) unifier with parent atom
    
    Parameters:
    
    parentAtom - atom to be unified with
    
    unifierType - type of unifier to be computed
    
    Returns:
    
    multiunifier

Class Atom

Field Summary

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

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

Field Detail

applicableRules

Constructor Detail

Atom

Method Detail

toRelationshipAtom

toIsaAtom

isUnifiableWith

isAtom

isRuleResolvable

isRecursive

isGround

isBounded

isDisconnected

requiresSchema

getVarPropertyClass

validateAsRuleHead

getVarProperties

getPartialSubstitutions

getRoleExpansionVariables

isRuleApplicableViaAtom

getPotentialRules

getApplicableRules

requiresMaterialisation

requiresRoleExpansion

requiresDecomposition

getSchemaConcept

getTypeId

getPredicateVariable

getInnerPredicates

getInnerPredicates

getTypeConstraints

getNeighbours

getNonSelectableConstraints

inferTypes

inferTypes

getPossibleTypes

atomOptions

addType

materialise

rewriteToAtoms

rewriteWithTypeVariable

rewriteToUserDefined

rewriteWithTypeVariable

rewriteWithRelationVariable

getUnifier

getMultiUnifier