Package org.opennars.inference

Class CompositionalRules

java.lang.Object

org.opennars.inference.CompositionalRules

public final class CompositionalRules
extends Object

Compound term composition and decomposition rules, with two premises.

New compound terms are introduced only in forward inference, while decompositional rules are also used in backward inference

Author:

Pei Wang, Patrick Hammer

Constructor Summary

Constructors

Constructor	Description
CompositionalRules()

Method Summary

Modifier and Type	Method	Description
static void	addVariableCandidates(Set<Term> candidates, Term side, boolean subject)	Add the variable candidates that appear as subjects and predicates
(package private) static void	composeCompound(Statement taskContent, Statement beliefContent, int index, DerivationContext nal)	{<S ==> M>, <P ==> M>} |- {<(S|P) ==> M>, <(S&P) ==> M>, <(S-P) ==> M>, <(P-S) ==> M>}
private static void	decomposeCompound(CompoundTerm compound, Term component, Term term1, int index, boolean compoundTask, int order, DerivationContext nal)	{<(S|P) ==> M>, <P ==> M>} |- <S ==> M>
(package private) static void	decomposeStatement(CompoundTerm compound, Term component, boolean compoundTask, int index, DerivationContext nal)	{(||, S, P), P} |- S {(&&, S, P), P} |- S
static void	eliminateVariableOfConditionAbductive(int figure, Sentence sentence, Sentence belief, DerivationContext nal)
private static void	eliminateVariableOfConditionAbductiveInner1(Sentence sentence, Sentence belief, DerivationContext nal, CompoundTerm s1, Map<Term,Term> res3, Term s12)
private static void	eliminateVariableOfConditionAbductiveTryCrossUnification(Sentence sentence, Sentence belief, DerivationContext nal, Term s1, Term p2, Map<Term,Term> res3, Map<Term,Term> res4)
private static void	eliminateVariableOfConditionAbductiveTryUnification1(Sentence sentence, Sentence belief, DerivationContext nal, Term p1, CompoundTerm p2, Map<Term,Term> res3, Map<Term,Term> res4)
static Set<org.apache.commons.lang3.tuple.Pair<Term,Float>>	introduceVariables(DerivationContext nal, Term implicationEquivalenceOrJunction, boolean subject)	Introduction of variables that appear either within subjects or within predicates and more than once
(package private) static boolean	introVarInner(Statement premise1, Statement premise2, CompoundTerm oldCompound, DerivationContext nal)	{<M --> S>, <C ==> <M --> P>>} |- <(&&, <#x --> S>, C) ==> <#x --> P>> {<M --> S>, (&&, C, <M --> P>)} |- (&&, C, <<#x --> S> ==> <#x --> P>>)
static void	introVarOuter(Statement taskContent, Statement beliefContent, int index, DerivationContext nal)	Introduce a dependent variable in an outer-layer conjunction {<S --> P1>, <S --> P2>} |- (&&, <#x --> P1>, <#x --> P2>)
(package private) static void	IntroVarSameSubjectOrPredicate(Sentence originalMainSentence, Sentence subSentence, Term component, Term content, int index, DerivationContext nal)
static <T> Set<Set<T>>	powerSet(Set<T> originalSet)	The power set, from João Silva, https://stackoverflow.com/questions/1670862/obtaining-a-powerset-of-a-set-in-java
private static void	processComposed(Statement statement, Term subject, Term predicate, int order, TruthValue truth, DerivationContext nal)	Finish composing implication term

Methods inherited from class java.lang.Object

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

Constructor Detail

CompositionalRules

public CompositionalRules()

Method Detail

composeCompound

static void composeCompound(Statement taskContent,
                            Statement beliefContent,
                            int index,
                            DerivationContext nal)

{<S ==> M>, <P ==> M>} |-
{<(S|P) ==> M>, <(S&P) ==> M>, <(S-P) ==> M>, <(P-S) ==> M>}

Parameters:

taskContent - The first premise

beliefContent - The second premise

index - The location of the shared term

nal - Reference to the memory

processComposed

private static void processComposed(Statement statement,
                                    Term subject,
                                    Term predicate,
                                    int order,
                                    TruthValue truth,
                                    DerivationContext nal)

Finish composing implication term

Parameters:

statement - Type of the contentInd

subject - Subject of contentInd

predicate - Predicate of contentInd

truth - TruthValue of the contentInd

nal - Reference to the memory

decomposeCompound

private static void decomposeCompound(CompoundTerm compound,
                                      Term component,
                                      Term term1,
                                      int index,
                                      boolean compoundTask,
                                      int order,
                                      DerivationContext nal)

{<(S|P) ==> M>, <P ==> M>} |- <S ==> M>

Parameters:

term1 - The other term in the contentInd

index - The location of the shared term: 0 for subject, 1 for predicate

compoundTask - Whether the implication comes from the task

nal - Reference to the memory

decomposeStatement

static void decomposeStatement(CompoundTerm compound,
                               Term component,
                               boolean compoundTask,
                               int index,
                               DerivationContext nal)

{(||, S, P), P} |- S {(&&, S, P), P} |- S

Parameters:

compoundTask - Whether the implication comes from the task

nal - Reference to the memory

introVarOuter

public static void introVarOuter(Statement taskContent,
                                 Statement beliefContent,
                                 int index,
                                 DerivationContext nal)

Introduce a dependent variable in an outer-layer conjunction
{<S --> P1>, <S --> P2>} |- (&&, <#x --> P1>, <#x --> P2>)

Parameters:

taskContent - The first premise <M --> S>

beliefContent - The second premise <M --> P>

index - The location of the shared term: 0 for subject, 1 for predicate

nal - Reference to the memory

introVarInner

static boolean introVarInner(Statement premise1,
                             Statement premise2,
                             CompoundTerm oldCompound,
                             DerivationContext nal)

{<M --> S>, <C ==> <M --> P>>} |- <(&&, <#x --> S>, C) ==> <#x --> P>>
{<M --> S>, (&&, C, <M --> P>)} |- (&&, C, <<#x --> S> ==> <#x --> P>>)

Parameters:

oldCompound - The whole contentInd of the first premise, Implication or Conjunction

nal - Reference to the memory

eliminateVariableOfConditionAbductive

public static void eliminateVariableOfConditionAbductive(int figure,
                                                         Sentence sentence,
                                                         Sentence belief,
                                                         DerivationContext nal)

eliminateVariableOfConditionAbductiveTryCrossUnification

private static void eliminateVariableOfConditionAbductiveTryCrossUnification(Sentence sentence,
                                                                             Sentence belief,
                                                                             DerivationContext nal,
                                                                             Term s1,
                                                                             Term p2,
                                                                             Map<Term,Term> res3,
                                                                             Map<Term,Term> res4)

eliminateVariableOfConditionAbductiveTryUnification1

private static void eliminateVariableOfConditionAbductiveTryUnification1(Sentence sentence,
                                                                         Sentence belief,
                                                                         DerivationContext nal,
                                                                         Term p1,
                                                                         CompoundTerm p2,
                                                                         Map<Term,Term> res3,
                                                                         Map<Term,Term> res4)

eliminateVariableOfConditionAbductiveInner1

private static void eliminateVariableOfConditionAbductiveInner1(Sentence sentence,
                                                                Sentence belief,
                                                                DerivationContext nal,
                                                                CompoundTerm s1,
                                                                Map<Term,Term> res3,
                                                                Term s12)

IntroVarSameSubjectOrPredicate

static void IntroVarSameSubjectOrPredicate(Sentence originalMainSentence,
                                           Sentence subSentence,
                                           Term component,
                                           Term content,
                                           int index,
                                           DerivationContext nal)

powerSet

public static <T> Set<Set<T>> powerSet(Set<T> originalSet)

The power set, from João Silva, https://stackoverflow.com/questions/1670862/obtaining-a-powerset-of-a-set-in-java

Type Parameters:

T -

Parameters:

originalSet -

Returns:

introduceVariables

public static Set<org.apache.commons.lang3.tuple.Pair<Term,Float>> introduceVariables(DerivationContext nal,
                                                                                      Term implicationEquivalenceOrJunction,
                                                                                      boolean subject)

Introduction of variables that appear either within subjects or within predicates and more than once

Parameters:

nal - The derivation context

implicationEquivalenceOrJunction -

subject -

Returns:

The terms of the variable introduction variants plus the penalty from the amount of vars introduced

addVariableCandidates

public static void addVariableCandidates(Set<Term> candidates,
                                         Term side,
                                         boolean subject)

Add the variable candidates that appear as subjects and predicates

Parameters:

candidates - manipulated set of candidates

side -

subject -