Rule

java.lang.Object
- amie.rules.Rule

```
public class Rule
extends java.lang.Object
```
A class that represents Horn rules of the form A => B where A is a conjunction of binary atoms of the form r(x, y). Each atom is represented as a triple [x, r, y] (subject, relation, object).

Author:

lgalarra

Constructor Summary

Constructors
Constructor and Description
`Rule()` Instantiates an empty rule.
`Rule(javatools.datatypes.ByteString[] headAtom, double cardinality)` Instantiates a rule of the form [] => r(?a, ?b) with empty body and the given pattern as rule.
`Rule(javatools.datatypes.ByteString[] head, java.util.List<javatools.datatypes.ByteString[]> body, double cardinality)`
`Rule(Rule otherQuery, double support)` Creates a new query as a clone of the query sent as argument with the given support.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`_containsQuasiBindings()`
`boolean`	`_isBelowMinimumSupport()`
`void`	`_setBelowMinimumSupport(boolean belowMinimumSupport)`
`void`	`_setContainsQuasibinding(boolean containsQuasiBindings)`
`Rule`	`addAtom(javatools.datatypes.ByteString[] newAtom, double cardinality)`
`Rule`	`addAtom(javatools.datatypes.ByteString[] newAtom, int cardinality, javatools.datatypes.ByteString joinedVariable, javatools.datatypes.ByteString danglingVariable)` Returns a new rule that contains all the atoms of the current rule plus the atom provided as argument.
`Rule`	`addEdges(javatools.datatypes.ByteString[] newEdge1, javatools.datatypes.ByteString[] newEdge2)` Returns a new rule that is a copy of the current rules plus the two edges sent as arguments.
`int`	`alternativeParentHashCode()` The alternative hash code for the parents of the rule.
`static boolean`	`areEquivalent(javatools.datatypes.ByteString[] pattern, javatools.datatypes.ByteString[] newAtom)`
`static void`	`bind(javatools.datatypes.ByteString oldVal, javatools.datatypes.ByteString newVal, java.util.List<javatools.datatypes.ByteString[]> query)` Replaces all occurrences of oldVal with newVal in the subject and object positions of the input query.
`static void`	`bind(java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.ByteString> mappings, java.util.List<javatools.datatypes.ByteString[]> inputTriples)` Applies the mappings provided as first argument to the subject and object positions of the query included in the second argument.
`int`	`cardinalityForRelation(javatools.datatypes.ByteString relation)` Returns the number of times the relation occurs in the atoms of the query
`static Rule`	`combineRules(java.util.List<Rule> rules)` Given a list of rules A1 => X1, ...
`boolean`	`containsDisallowedDiamond()`
`boolean`	`containsLevel2RedundantSubgraphs()` For rules with an even number of atoms (n > 2), it checks if it contains level 2 redundant subgraphs, that is, each relation occurs exactly twice in the rule.
`boolean`	`containsRelation(javatools.datatypes.ByteString relation)`
`int`	`containsRelationTimes(javatools.datatypes.ByteString relation)`
`boolean`	`containsRepeatedVariablesInLastPattern()` Determines if a pattern contains repeated components, which are considered hard to satisfy (i.e., ?x somePredicate ?x)
`boolean`	`containsSinglePath()` It determines whether the rule contains a single path that connects the head variables in the body.
`boolean`	`containsUnifiablePatterns()` Determines whether the last atom of the query.
`static boolean`	`equal(javatools.datatypes.ByteString[] pattern1, javatools.datatypes.ByteString[] pattern2)`
`static boolean`	`equals(javatools.datatypes.ByteString[] atom1, javatools.datatypes.ByteString[] atom2)`
`boolean`	`equals(java.lang.Object obj)`
`static int`	`findFunctionalVariable(Rule q, KB d)`
`javatools.datatypes.ByteString[]`	`fullyUnboundTriplePattern()` It creates a new unbound atom with fresh variables for the subject and object and an undefined property, i.e., ?s[n] ?p ?o[n].
`static javatools.datatypes.ByteString[]`	`fullyUnboundTriplePattern1()` It creates a new unbound atom with fresh variables for the subject and object and an undefined property, i.e., ?s[n] ?p ?o[n].
`java.util.List<Rule>`	`getAllAncestors()`
`java.util.List<Rule>`	`getAncestors()`
`java.util.List<javatools.datatypes.ByteString[]>`	`getAntecedent()` Returns the list of triples in the body of the rule.
`java.util.List<javatools.datatypes.ByteString[]>`	`getAntecedentClone()` Returns a list with copies of the triples of the rule.
`java.lang.String`	`getBasicRuleString()`
`java.util.List<javatools.datatypes.ByteString[]>`	`getBody()` Returns the list of triples in the body of the rule.
`long`	`getBodyMinusHeadSize()`
`java.util.List<javatools.datatypes.ByteString>`	`getBodyRelations()`
`long`	`getBodySize()` The support of the body of the rule.
`java.util.Set<javatools.datatypes.ByteString>`	`getBodyVariables()` Returns an array with the variables that occur in the body but not in the head.
`java.util.List<javatools.datatypes.ByteString[]>`	`getCanonicalPath()` Given a rule that contains a single variables path for the head variables in the body (the method containsSinglePath returns true), it returns the atoms sorted so that the path can be reproduced.
`double`	`getConfidenceRunningTime()`
`java.lang.String`	`getDatalogString()`
`int[]`	`getEvaluationResult()`
`java.lang.String`	`getFullRuleString()`
`javatools.datatypes.ByteString`	`getFunctionalVariable()`
`int`	`getFunctionalVariablePosition()`
`long`	`getHashCardinality()` The cardinality number used to hash the rule.
`javatools.datatypes.ByteString[]`	`getHead()` Returns the head of a query B => r(a, b) as a triple [?a, r, ?b].
`double`	`getHeadCoverage()`
`java.lang.String`	`getHeadKey()` Return a key for the rule based on the constant arguments of the head atom.
`java.lang.String`	`getHeadRelation()` Returns the rule's head relation as a String
`javatools.datatypes.ByteString`	`getHeadRelationBS()` Returns the rule's head relation as ByteString.
`java.util.List<javatools.datatypes.ByteString>`	`getHeadVariables()` Returns the head variables of the rule.
`int`	`getId()`
`javatools.datatypes.ByteString[]`	`getLastRealTriplePattern()` Return the last triple pattern which is not the a pseudo-atom.
`int`	`getLastRealTriplePatternIndex()` Return the index of the last triple pattern which is not the a pseudo-atom.
`javatools.datatypes.ByteString[]`	`getLastTriplePattern()` Returns the last triple pattern added to this rule.
`int`	`getLength()` Returns the number of atoms of the rule.
`int`	`getLengthWithoutTypes(javatools.datatypes.ByteString typeString)` Returns the number of atoms of the rule that are not type constraints of the form rdf:type(?x, C) where C is a class, i.e., Person.
`int`	`getLengthWithoutTypesAndLinksTo(javatools.datatypes.ByteString typeString, javatools.datatypes.ByteString linksString)` Returns the number of atoms of the rule that are neither type constraints of the form rdf:type(?x, C) or linksTo atoms.
`javatools.datatypes.ByteString`	`getNonFunctionalVariable()`
`int`	`getNonFunctionalVariablePosition()`
`java.util.List<javatools.datatypes.ByteString>`	`getOpenVariables()`
`static void`	`getParentsOfSize(java.util.List<javatools.datatypes.ByteString[]> antecedent, javatools.datatypes.ByteString[] head, int windowSize, java.util.List<java.util.List<javatools.datatypes.ByteString[]>> output)` Given the antecedent and the succedent of a rule as sets of atoms, it returns the combinations of atoms of size 'i' that are "parents" of the current rule, i.e., subsets of atoms of the original rule.
`double`	`getPcaBodySize()`
`double`	`getPcaConfidence()`
`double`	`getPcaConfidenceRunningTime()`
`double`	`getPcaEstimation()`
`java.util.List<javatools.datatypes.ByteString[]>`	`getPCAQuery()` It returns the query expression corresponding to the normalization value used to calculate the PCA confidence.
`int`	`getRealLength()` Returns the number of atoms of the rule that are not pseudo-atoms Pseudo-atoms contain the Database keywords "DIFFERENTFROM" and "EQUALS"
`int`	`getRealLengthWithoutTypes(javatools.datatypes.ByteString typeString)` Returns the number of atoms of the rule that are neither pseudo-atoms nor type constraints.
`java.util.List<javatools.datatypes.ByteString[]>`	`getRealTriples()` Returns the triples of a query except for those containing DIFFERENTFROM constraints.
`java.util.List<javatools.datatypes.ByteString[]>`	`getRedundantAtoms()` Checks whether the last atom in the query is redundant.
`java.util.List<javatools.datatypes.ByteString[]>`	`getRedundantAtoms(int withRespectToIdx)` Look for the redundant atoms with respect to a reference atom
`java.lang.String`	`getRuleString()`
`double`	`getStdConfidence()`
`javatools.datatypes.ByteString[]`	`getSuccedent()` Returns the head of a query B => r(a, b) as a triple [?a, r, ?b].
`double`	`getSupport()`
`double`	`getSupportRatio()`
`java.util.List<javatools.datatypes.ByteString[]>`	`getTriples()` Return the list of triples of the query.
`java.util.List<javatools.datatypes.ByteString>`	`getVariables()` Returns a list with all the different variables in the query.
`boolean`	`hasConfidenceGain()` Verifies if the given rule has higher confidence that its parent rules.
`int`	`hashCode()`
`Rule`	`instantiateConstant(int danglingPosition, javatools.datatypes.ByteString constant, double cardinality)` Returns a new query where the variable at the dangling position of the last atom has been unified to the provided constant.
`Rule`	`instantiateConstant(int triplePos, int danglingPosition, javatools.datatypes.ByteString constant, double cardinality)` Return a new query where the variable at position danglingPosition in triple at position triplePos is bound to constant.
`boolean`	`isClosed()`
`boolean`	`isEmpty()`
`static boolean`	`isGroundAtom(javatools.datatypes.ByteString[] pattern)` Returns true if the triple pattern contains constants in all its positions
`boolean`	`isPerfect()`
`boolean`	`isRedundantRecursive()` Returns true if the rule contains redundant recursive atoms, i.e., atoms with a relation that occurs more than once AND that do not have any effect on the query result.
`static boolean`	`isUnifiable(javatools.datatypes.ByteString[] pattern, javatools.datatypes.ByteString[] newAtom)` Determines if the second argument is unifiable to the first one.
`static int[]`	`joinPositions(javatools.datatypes.ByteString[] a1, javatools.datatypes.ByteString[] a2)` Given 2 atoms joining in at least one variable, it returns the first pairs of variable positions of each atom.
`static void`	`main(java.lang.String[] args)`
`static void`	`printRuleBasicHeaders()`
`static void`	`printRuleHeaders()`
`static java.util.List<javatools.datatypes.ByteString[]>`	`redundantAtoms(javatools.datatypes.ByteString[] test, java.util.List<javatools.datatypes.ByteString[]> query)` It returns a list with all the redundant atoms contained in the first list, i.e., atoms whose removal does not affect the results of the query defined in the second list.
`Rule`	`rewriteQuery(javatools.datatypes.ByteString[] remove, javatools.datatypes.ByteString[] target, javatools.datatypes.ByteString victimVar, javatools.datatypes.ByteString targetVar)`
`void`	`setBodyMinusHeadSize(int size)`
`void`	`setBodySize(long bodySize)`
`void`	`setConfidenceRunningTime(double confidenceRunningTime)`
`void`	`setConfidenceUpperBound(double stdConfUpperBound)`
`void`	`setEvaluationResult(int[] evaluationResult)`
`void`	`setFunctionalVariablePosition(int functionalVariablePosition)`
`void`	`setHeadCoverage(double headCoverage)`
`void`	`setId(int id)`
`void`	`setParent(Rule parent)` Sets the rule's parent rule.
`void`	`setPcaBodySize(double size)`
`void`	`setPcaConfidenceRunningTime(double pcaConfidenceRunningTime)`
`void`	`setPcaConfidenceUpperBound(double pcaConfUpperBound)`
`void`	`setPcaEstimation(double pcaEstimation)`
`void`	`setSupport(double cardinality)`
`void`	`setSupportRatio(double support)`
`protected void`	`setTriples(java.util.ArrayList<javatools.datatypes.ByteString[]> triples)`
`static java.lang.String`	`toDatalog(javatools.datatypes.ByteString[] atom)`
`java.lang.String`	`toString()` Simple string representation of the rule.
`static javatools.datatypes.ByteString[]`	`triple(javatools.datatypes.ByteString sub, javatools.datatypes.ByteString pred, javatools.datatypes.ByteString obj)` It puts the arguments in an array.
`static boolean`	`unifies(javatools.datatypes.ByteString[] test, java.util.List<javatools.datatypes.ByteString[]> query)`
`boolean`	`variableCanBeDeleted(int triplePos, int varPos)`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - Rule
```
public Rule()
```
    Instantiates an empty rule.
  - Rule
```
public Rule(javatools.datatypes.ByteString[] headAtom,
            double cardinality)
```
    Instantiates a rule of the form [] => r(?a, ?b) with empty body and the given pattern as rule.
    
    Parameters:
    
    headAtom - The head atom as an array of the form [?a, r, ?b].
    
    cardinality -
  - Rule
```
public Rule(Rule otherQuery,
            double support)
```
    Creates a new query as a clone of the query sent as argument with the given support.
    
    Parameters:
    
    otherQuery -
    
    support -
  - Rule
```
public Rule(javatools.datatypes.ByteString[] head,
            java.util.List<javatools.datatypes.ByteString[]> body,
            double cardinality)
```
- Method Detail
  - triple
```
public static javatools.datatypes.ByteString[] triple(javatools.datatypes.ByteString sub,
                                                      javatools.datatypes.ByteString pred,
                                                      javatools.datatypes.ByteString obj)
```
    It puts the arguments in an array.
    
    Parameters:
    
    sub -
    
    pred -
    
    obj -
    
    Returns:
  - equal
```
public static boolean equal(javatools.datatypes.ByteString[] pattern1,
                            javatools.datatypes.ByteString[] pattern2)
```
  - fullyUnboundTriplePattern
```
public javatools.datatypes.ByteString[] fullyUnboundTriplePattern()
```
    It creates a new unbound atom with fresh variables for the subject and object and an undefined property, i.e., ?s[n] ?p ?o[n]. n is optional and is always greater than 1.
    
    Returns:
  - fullyUnboundTriplePattern1
```
public static javatools.datatypes.ByteString[] fullyUnboundTriplePattern1()
```
    It creates a new unbound atom with fresh variables for the subject and object and an undefined property, i.e., ?s[n] ?p ?o[n]. n is optional and is always greater than 1.
  - equals
```
public static boolean equals(javatools.datatypes.ByteString[] atom1,
                             javatools.datatypes.ByteString[] atom2)
```
  - getTriples
```
public java.util.List<javatools.datatypes.ByteString[]> getTriples()
```
    Return the list of triples of the query. Modifications to this list alter the query.
    
    Returns:
  - getRealTriples
```
public java.util.List<javatools.datatypes.ByteString[]> getRealTriples()
```
    Returns the triples of a query except for those containing DIFFERENTFROM constraints. Modifications to this list do not alter the query. However, modifications to the atoms do alter the query.
    
    Returns:
  - getHead
```
public javatools.datatypes.ByteString[] getHead()
```
    Returns the head of a query B => r(a, b) as a triple [?a, r, ?b].
    
    Returns:
  - getSuccedent
```
public javatools.datatypes.ByteString[] getSuccedent()
```
    Returns the head of a query B => r(a, b) as a triple [?a, r, ?b]. Alias for the method getHead().
    
    Returns:
  - getBody
```
public java.util.List<javatools.datatypes.ByteString[]> getBody()
```
    Returns the list of triples in the body of the rule.
    
    Returns:
    
    Non-modifiable list of atoms.
  - getAntecedent
```
public java.util.List<javatools.datatypes.ByteString[]> getAntecedent()
```
    Returns the list of triples in the body of the rule. It is an alias for the method getBody()
    
    Returns:
    
    Non-modifiable list of atoms.
  - getAntecedentClone
```
public java.util.List<javatools.datatypes.ByteString[]> getAntecedentClone()
```
    Returns a list with copies of the triples of the rule. Modifications to either the list or the atoms do not alter the rule.
    
    Returns:
  - setTriples
```
protected void setTriples(java.util.ArrayList<javatools.datatypes.ByteString[]> triples)
```
  - getOpenVariables
```
public java.util.List<javatools.datatypes.ByteString> getOpenVariables()
```
    Returns:
    
    the mustBindVariables
  - getHeadCoverage
```
public double getHeadCoverage()
```
  - setHeadCoverage
```
public void setHeadCoverage(double headCoverage)
```
  - getSupportRatio
```
public double getSupportRatio()
```
    Returns:
    
    the support
  - setSupportRatio
```
public void setSupportRatio(double support)
```
    Parameters:
    
    support - the support to set
  - getSupport
```
public double getSupport()
```
    Returns:
    
    the headBodyCount
  - getHashCardinality
```
public long getHashCardinality()
```
    The cardinality number used to hash the rule.
    
    Returns:
  - setSupport
```
public void setSupport(double cardinality)
```
    Parameters:
    
    cardinality - the headBodyCount to set
  - getBodySize
```
public long getBodySize()
```
    The support of the body of the rule. If the rule has the form B => r(x,y) then the body size is support(B).
    
    Returns:
  - setBodySize
```
public void setBodySize(long bodySize)
```
    Parameters:
    
    bodySize -
  - getStdConfidence
```
public double getStdConfidence()
```
    Returns:
    
    the confidence
  - getEvaluationResult
```
public int[] getEvaluationResult()
```
    Returns:
    
    the evaluationResult
  - setEvaluationResult
```
public void setEvaluationResult(int[] evaluationResult)
```
    Parameters:
    
    evaluationResult - the evaluationResult to set
  - getPcaConfidence
```
public double getPcaConfidence()
```
    Returns:
    
    the pcaConfidence
  - getConfidenceRunningTime
```
public double getConfidenceRunningTime()
```
  - setConfidenceRunningTime
```
public void setConfidenceRunningTime(double confidenceRunningTime)
```
  - getPcaConfidenceRunningTime
```
public double getPcaConfidenceRunningTime()
```
  - setPcaConfidenceRunningTime
```
public void setPcaConfidenceRunningTime(double pcaConfidenceRunningTime)
```
  - getId
```
public int getId()
```
  - setId
```
public void setId(int id)
```
  - getLastTriplePattern
```
public javatools.datatypes.ByteString[] getLastTriplePattern()
```
    Returns the last triple pattern added to this rule.
    
    Returns:
  - getLastRealTriplePattern
```
public javatools.datatypes.ByteString[] getLastRealTriplePattern()
```
    Return the last triple pattern which is not the a pseudo-atom.
    
    Returns:
  - getLastRealTriplePatternIndex
```
public int getLastRealTriplePatternIndex()
```
    Return the index of the last triple pattern which is not the a pseudo-atom.
    
    Returns:
  - cardinalityForRelation
```
public int cardinalityForRelation(javatools.datatypes.ByteString relation)
```
    Returns the number of times the relation occurs in the atoms of the query
    
    Returns:
  - isGroundAtom
```
public static boolean isGroundAtom(javatools.datatypes.ByteString[] pattern)
```
    Returns true if the triple pattern contains constants in all its positions
    
    Parameters:
    
    pattern -
    
    Returns:
  - getRedundantAtoms
```
public java.util.List<javatools.datatypes.ByteString[]> getRedundantAtoms(int withRespectToIdx)
```
    Look for the redundant atoms with respect to a reference atom
    
    Parameters:
    
    withRespectToIdx - The index of the reference atom
    
    Returns:
  - getRedundantAtoms
```
public java.util.List<javatools.datatypes.ByteString[]> getRedundantAtoms()
```
    Checks whether the last atom in the query is redundant.
    
    Returns:
  - getFunctionalVariable
```
public javatools.datatypes.ByteString getFunctionalVariable()
```
  - getNonFunctionalVariable
```
public javatools.datatypes.ByteString getNonFunctionalVariable()
```
  - getFunctionalVariablePosition
```
public int getFunctionalVariablePosition()
```
  - setFunctionalVariablePosition
```
public void setFunctionalVariablePosition(int functionalVariablePosition)
```
  - getNonFunctionalVariablePosition
```
public int getNonFunctionalVariablePosition()
```
  - isUnifiable
```
public static boolean isUnifiable(javatools.datatypes.ByteString[] pattern,
                                  javatools.datatypes.ByteString[] newAtom)
```
    Determines if the second argument is unifiable to the first one. Unifiable means there is a valid unification mapping (variable -> variable, variable -> constant) between the components of the triple pattern
    
    Parameters:
    
    pattern -
    
    newAtom -
    
    Returns:
    
    boolean
  - areEquivalent
```
public static boolean areEquivalent(javatools.datatypes.ByteString[] pattern,
                                    javatools.datatypes.ByteString[] newAtom)
```
  - unifies
```
public static boolean unifies(javatools.datatypes.ByteString[] test,
                              java.util.List<javatools.datatypes.ByteString[]> query)
```
  - redundantAtoms
```
public static java.util.List<javatools.datatypes.ByteString[]> redundantAtoms(javatools.datatypes.ByteString[] test,
                                                                              java.util.List<javatools.datatypes.ByteString[]> query)
```
    It returns a list with all the redundant atoms contained in the first list, i.e., atoms whose removal does not affect the results of the query defined in the second list.
    
    Parameters:
    
    test -
    
    query -
    
    Returns:
  - containsUnifiablePatterns
```
public boolean containsUnifiablePatterns()
```
    Determines whether the last atom of the query.
    
    Returns:
    
    boolean
  - toString
```
public java.lang.String toString()
```
    Simple string representation of the rule. Check the methods getRuleString, getFullRuleString and getBasicRuleString.
    
    Overrides:
    
    toString in class java.lang.Object
  - getVariables
```
public java.util.List<javatools.datatypes.ByteString> getVariables()
```
    Returns a list with all the different variables in the query.
    
    Returns:
  - containsRepeatedVariablesInLastPattern
```
public boolean containsRepeatedVariablesInLastPattern()
```
    Determines if a pattern contains repeated components, which are considered hard to satisfy (i.e., ?x somePredicate ?x)
    
    Returns:
    
    boolean
  - isRedundantRecursive
```
public boolean isRedundantRecursive()
```
    Returns true if the rule contains redundant recursive atoms, i.e., atoms with a relation that occurs more than once AND that do not have any effect on the query result.
    
    Returns:
  - isEmpty
```
public boolean isEmpty()
```
    Returns:
    
    boolean True if the rule has atoms.
  - isClosed
```
public boolean isClosed()
```
    Returns:
    
    boolean True if the rule is closed, i.e., each variable in the rule occurs at least in two atoms.
  - isPerfect
```
public boolean isPerfect()
```
    Returns:
    
    boolean. True if the rule has PCA confidence 1.0
  - getHeadKey
```
public java.lang.String getHeadKey()
```
    Return a key for the rule based on the constant arguments of the head atom. It can be used as a hash key.
    
    Returns:
  - getHeadRelation
```
public java.lang.String getHeadRelation()
```
    Returns the rule's head relation as a String
    
    Returns:
  - getHeadRelationBS
```
public javatools.datatypes.ByteString getHeadRelationBS()
```
    Returns the rule's head relation as ByteString.
    
    Returns:
  - getLength
```
public int getLength()
```
    Returns the number of atoms of the rule.
    
    Returns:
  - getRealLength
```
public int getRealLength()
```
    Returns the number of atoms of the rule that are not pseudo-atoms Pseudo-atoms contain the Database keywords "DIFFERENTFROM" and "EQUALS"
    
    Returns:
  - getRealLengthWithoutTypes
```
public int getRealLengthWithoutTypes(javatools.datatypes.ByteString typeString)
```
    Returns the number of atoms of the rule that are neither pseudo-atoms nor type constraints. Pseudo-atoms contain the Database keywords "DIFFERENTFROM"
    
    Returns:
  - getLengthWithoutTypes
```
public int getLengthWithoutTypes(javatools.datatypes.ByteString typeString)
```
    Returns the number of atoms of the rule that are not type constraints of the form rdf:type(?x, C) where C is a class, i.e., Person.
    
    Parameters:
    
    typeString -
    
    Returns:
  - getLengthWithoutTypesAndLinksTo
```
public int getLengthWithoutTypesAndLinksTo(javatools.datatypes.ByteString typeString,
                                           javatools.datatypes.ByteString linksString)
```
    Returns the number of atoms of the rule that are neither type constraints of the form rdf:type(?x, C) or linksTo atoms.
    
    Parameters:
    
    typeString -
    
    Returns:
  - setParent
```
public void setParent(Rule parent)
```
    Sets the rule's parent rule.
    
    Parameters:
    
    parent -
  - addAtom
```
public Rule addAtom(javatools.datatypes.ByteString[] newAtom,
                    int cardinality,
                    javatools.datatypes.ByteString joinedVariable,
                    javatools.datatypes.ByteString danglingVariable)
```
    Returns a new rule that contains all the atoms of the current rule plus the atom provided as argument.
    
    Parameters:
    
    newAtom - The new atom.
    
    cardinality - The support of the new rule.
    
    joinedVariable - The position of the common variable w.r.t to the rule in the new atom, i.e., 0 if the new atoms joins on the subject or 2 if it joins on the object.
    
    danglingVariable - The position of the fresh variable in the new atom.
    
    Returns:
  - addAtom
```
public Rule addAtom(javatools.datatypes.ByteString[] newAtom,
                    double cardinality)
```
  - alternativeParentHashCode
```
public int alternativeParentHashCode()
```
    The alternative hash code for the parents of the rule. The alternative hash code if a small variant of the hashCode method that does not use the support of the rule.
    
    Returns:
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object
  - printRuleBasicHeaders
```
public static void printRuleBasicHeaders()
```
  - printRuleHeaders
```
public static void printRuleHeaders()
```
  - getRuleString
```
public java.lang.String getRuleString()
```
  - getFullRuleString
```
public java.lang.String getFullRuleString()
```
  - getBasicRuleString
```
public java.lang.String getBasicRuleString()
```
  - toDatalog
```
public static java.lang.String toDatalog(javatools.datatypes.ByteString[] atom)
```
  - getDatalogString
```
public java.lang.String getDatalogString()
```
  - instantiateConstant
```
public Rule instantiateConstant(int danglingPosition,
                                javatools.datatypes.ByteString constant,
                                double cardinality)
```
    Returns a new query where the variable at the dangling position of the last atom has been unified to the provided constant.
    
    Parameters:
    
    danglingPosition -
    
    constant -
    
    cardinality -
    
    Returns:
  - instantiateConstant
```
public Rule instantiateConstant(int triplePos,
                                int danglingPosition,
                                javatools.datatypes.ByteString constant,
                                double cardinality)
```
    Return a new query where the variable at position danglingPosition in triple at position triplePos is bound to constant.
    
    Parameters:
    
    triplePos -
    
    danglingPosition -
    
    constant -
    
    cardinality -
    
    Returns:
  - getAncestors
```
public java.util.List<Rule> getAncestors()
```
  - getAllAncestors
```
public java.util.List<Rule> getAllAncestors()
```
  - setBodyMinusHeadSize
```
public void setBodyMinusHeadSize(int size)
```
  - getBodyMinusHeadSize
```
public long getBodyMinusHeadSize()
```
  - setPcaBodySize
```
public void setPcaBodySize(double size)
```
  - getPcaBodySize
```
public double getPcaBodySize()
```
  - _isBelowMinimumSupport
```
public boolean _isBelowMinimumSupport()
```
  - _setBelowMinimumSupport
```
public void _setBelowMinimumSupport(boolean belowMinimumSupport)
```
  - _containsQuasiBindings
```
public boolean _containsQuasiBindings()
```
  - _setContainsQuasibinding
```
public void _setContainsQuasibinding(boolean containsQuasiBindings)
```
  - rewriteQuery
```
public Rule rewriteQuery(javatools.datatypes.ByteString[] remove,
                         javatools.datatypes.ByteString[] target,
                         javatools.datatypes.ByteString victimVar,
                         javatools.datatypes.ByteString targetVar)
```
  - variableCanBeDeleted
```
public boolean variableCanBeDeleted(int triplePos,
                                    int varPos)
```
  - findFunctionalVariable
```
public static int findFunctionalVariable(Rule q,
                                         KB d)
```
  - setConfidenceUpperBound
```
public void setConfidenceUpperBound(double stdConfUpperBound)
```
  - setPcaConfidenceUpperBound
```
public void setPcaConfidenceUpperBound(double pcaConfUpperBound)
```
  - getPcaEstimation
```
public double getPcaEstimation()
```
    Returns:
    
    the pcaEstimation
  - setPcaEstimation
```
public void setPcaEstimation(double pcaEstimation)
```
    Parameters:
    
    pcaEstimation - the pcaEstimation to set
  - containsLevel2RedundantSubgraphs
```
public boolean containsLevel2RedundantSubgraphs()
```
    For rules with an even number of atoms (n > 2), it checks if it contains level 2 redundant subgraphs, that is, each relation occurs exactly twice in the rule.
    
    Returns:
  - containsDisallowedDiamond
```
public boolean containsDisallowedDiamond()
```
  - bind
```
public static void bind(java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.ByteString> mappings,
                        java.util.List<javatools.datatypes.ByteString[]> inputTriples)
```
    Applies the mappings provided as first argument to the subject and object positions of the query included in the second argument.
    
    Parameters:
    
    mappings -
    
    inputTriples -
  - bind
```
public static void bind(javatools.datatypes.ByteString oldVal,
                        javatools.datatypes.ByteString newVal,
                        java.util.List<javatools.datatypes.ByteString[]> query)
```
    Replaces all occurrences of oldVal with newVal in the subject and object positions of the input query.
    
    Parameters:
    
    oldVal -
    
    newVal -
    
    query -
  - hasConfidenceGain
```
public boolean hasConfidenceGain()
```
    Verifies if the given rule has higher confidence that its parent rules. The parent rules are those rules that were refined in previous stages of the AMIE algorithm and led to the construction of the current rule.
    
    Returns:
    
    true if the rule has better confidence that its parent rules.
  - getPCAQuery
```
public java.util.List<javatools.datatypes.ByteString[]> getPCAQuery()
```
    It returns the query expression corresponding to the normalization value used to calculate the PCA confidence.
    
    Returns:
  - combineRules
```
public static Rule combineRules(java.util.List<Rule> rules)
```
    Given a list of rules A1 => X1, ... An => Xn, having the same head relation, it returns the combined rule A1,..., An => X', where X' is the most specific atom. For example given the rules A1 => livesIn(x, y) and A2 => livesIn(x, USA), the method returns A1, A2 => livesIn(x, USA).
    
    Parameters:
    
    rules -
    
    Returns:
  - containsRelation
```
public boolean containsRelation(javatools.datatypes.ByteString relation)
```
  - containsRelationTimes
```
public int containsRelationTimes(javatools.datatypes.ByteString relation)
```
  - getParentsOfSize
```
public static void getParentsOfSize(java.util.List<javatools.datatypes.ByteString[]> antecedent,
                                    javatools.datatypes.ByteString[] head,
                                    int windowSize,
                                    java.util.List<java.util.List<javatools.datatypes.ByteString[]>> output)
```
    Given the antecedent and the succedent of a rule as sets of atoms, it returns the combinations of atoms of size 'i' that are "parents" of the current rule, i.e., subsets of atoms of the original rule.
    
    Parameters:
    
    antecedent -
    
    head -
  - containsSinglePath
```
public boolean containsSinglePath()
```
    It determines whether the rule contains a single path that connects the head variables in the body. For example, the rule: - worksAt(x, w), locatedInCity(w, z), locatedInCountry(z, y) => livesIn(x, y) meets such criteria because there is a single path of variables that connects the head variables in the body: x -> w -> z -> y.
    
    Returns:
  - getBodyVariables
```
public java.util.Set<javatools.datatypes.ByteString> getBodyVariables()
```
    Returns an array with the variables that occur in the body but not in the head.
    
    Returns:
  - getHeadVariables
```
public java.util.List<javatools.datatypes.ByteString> getHeadVariables()
```
    Returns the head variables of the rule.
    
    Returns:
  - getCanonicalPath
```
public java.util.List<javatools.datatypes.ByteString[]> getCanonicalPath()
```
    Given a rule that contains a single variables path for the head variables in the body (the method containsSinglePath returns true), it returns the atoms sorted so that the path can be reproduced.
    
    Returns:
  - joinPositions
```
public static int[] joinPositions(javatools.datatypes.ByteString[] a1,
                                  javatools.datatypes.ByteString[] a2)
```
    Given 2 atoms joining in at least one variable, it returns the first pairs of variable positions of each atom.
    
    Parameters:
    
    a1 -
    
    a2 -
    
    Returns:
  - addEdges
```
public Rule addEdges(javatools.datatypes.ByteString[] newEdge1,
                     javatools.datatypes.ByteString[] newEdge2)
```
    Returns a new rule that is a copy of the current rules plus the two edges sent as arguments.
    
    Parameters:
    
    newEdge1 -
    
    newEdge2 -
    
    Returns:
  - getBodyRelations
```
public java.util.List<javatools.datatypes.ByteString> getBodyRelations()
```
  - main
```
public static void main(java.lang.String[] args)
```

Class Rule

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Rule

Rule

Rule

Rule

Method Detail

triple

equal

fullyUnboundTriplePattern

fullyUnboundTriplePattern1

equals

getTriples

getRealTriples

getHead

getSuccedent

getBody

getAntecedent

getAntecedentClone

setTriples

getOpenVariables

getHeadCoverage

setHeadCoverage

getSupportRatio

setSupportRatio

getSupport

getHashCardinality

setSupport

getBodySize

setBodySize

getStdConfidence

getEvaluationResult

setEvaluationResult

getPcaConfidence

getConfidenceRunningTime

setConfidenceRunningTime

getPcaConfidenceRunningTime

setPcaConfidenceRunningTime

getId

setId

getLastTriplePattern

getLastRealTriplePattern

getLastRealTriplePatternIndex

cardinalityForRelation

isGroundAtom

getRedundantAtoms

getRedundantAtoms

getFunctionalVariable

getNonFunctionalVariable

getFunctionalVariablePosition

setFunctionalVariablePosition

getNonFunctionalVariablePosition

isUnifiable

areEquivalent

unifies

redundantAtoms

containsUnifiablePatterns

toString

getVariables

containsRepeatedVariablesInLastPattern

isRedundantRecursive

isEmpty

isClosed

isPerfect

getHeadKey

getHeadRelation

getHeadRelationBS

getLength

getRealLength

getRealLengthWithoutTypes

getLengthWithoutTypes

getLengthWithoutTypesAndLinksTo

setParent

addAtom

addAtom

alternativeParentHashCode

hashCode