Package | Description |
---|---|
org.opennars.inference |
The inference rules and control functions
|
org.opennars.io |
Input/output management
|
org.opennars.language |
Term hierarchy in Narsese
Open-NARS implements the following formal language, Narsese.
|
org.opennars.operator | |
org.opennars.operator.misc |
Modifier and Type | Method | Description |
---|---|---|
private static void |
TemporalRules.appendConclusion(DerivationContext nal,
TruthValue truth1,
BudgetValue budget1,
Statement statement1,
List<Task> success) |
|
private static void |
RuleTables.componentAndStatement(CompoundTerm compound,
short index,
Statement statement,
short side,
DerivationContext nal) |
Inference between a component term (of the current term) and a statement
|
(package private) static void |
CompositionalRules.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 |
RuleTables.compoundAndStatement(CompoundTerm compound,
short index,
Statement statement,
short side,
Term beliefTerm,
DerivationContext nal) |
Inference between a compound term and a statement
|
(package private) static boolean |
SyllogisticRules.conditionalAbd(Term cond1,
Term cond2,
Statement st1,
Statement st2,
DerivationContext nal) |
{<(&&, S2, S3) ==> P>, <(&&, S1, S3) ==> P>} |- <S1 ==> S2>
|
private static void |
RuleTables.conditionalDedIndWithVar(Sentence conditionalSentence,
Implication conditional,
short index,
Statement statement,
short side,
DerivationContext nal) |
Conditional deduction or induction, with variable unification
|
protected static boolean |
StructuralRules.contraposition(Statement statement,
Sentence sentence,
DerivationContext nal) |
{<A ==> B>, A@(--, A)} |- <(--, B) ==> (--, A)>
|
(package private) static boolean |
CompositionalRules.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 |
CompositionalRules.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>) |
private static void |
CompositionalRules.processComposed(Statement statement,
Term subject,
Term predicate,
int order,
TruthValue truth,
DerivationContext nal) |
Finish composing implication term
|
(package private) static void |
StructuralRules.structuralCompose1(CompoundTerm compound,
short index,
Statement statement,
DerivationContext nal) |
{<S --> P>, P@(P|Q)} |- <S --> (P|Q)>
|
(package private) static void |
StructuralRules.structuralCompose2(CompoundTerm compound,
short index,
Statement statement,
short side,
DerivationContext nal) |
{<S --> P>, S@(S&T)} |- <(S&T) --> (P&T)>
{<S --> P>, S@(M-S)} |- <(M-P) --> (M-S)> |
(package private) static void |
StructuralRules.structuralDecompose1(CompoundTerm compound,
short index,
Statement statement,
DerivationContext nal) |
{<(S|T) --> P>, S@(S|T)} |- <S --> P>
{<S --> (P&T)>, P@(P&T)} |- <S --> P> |
(package private) static void |
StructuralRules.structuralDecompose2(Statement statement,
int index,
DerivationContext nal) |
{<(S*T) --> (P*T)>, S@(S*T)} |- <S --> P>
|
(package private) static void |
StructuralRules.transformSetRelation(CompoundTerm compound,
Statement statement,
short side,
DerivationContext nal) |
{<S --> {P}>} |- <S <-> {P}>
|
Modifier and Type | Method | Description |
---|---|---|
private Statement |
Narsese.parseStatement(String s0) |
Parse a string to create a statement.
|
Modifier and Type | Class | Description |
---|---|---|
class |
Equivalence |
A Statement about an Equivalence relation as defined in the NARS-theory
|
class |
Implication |
A Statement about an Inheritance copula as defined in the NARS-theory
|
class |
Inheritance |
A Statement about an Inheritance relation as defined in the NARS-theory
|
class |
Similarity |
A Statement about a Similarity relation as defined in the NARS-theory
|
Modifier and Type | Method | Description |
---|---|---|
abstract Statement |
Statement.clone() |
|
static Statement |
Statement.make(Symbols.NativeOperator o,
Term subject,
Term predicate,
boolean customOrder,
int order) |
Make a Statement from String, called by StringParser
|
static Statement |
Statement.make(Symbols.NativeOperator op,
Term subj,
Term pred,
int order) |
Make a Statement from given term, called by the rules
|
static Statement |
Statement.make(Statement statement,
Term subj,
Term pred) |
Make a Statement from given components, called by the rules
|
static Statement |
Statement.make(Statement statement,
Term subj,
Term pred,
int order) |
|
static Statement |
Statement.makeSym(Statement statement,
Term subj,
Term pred,
int order) |
Make a symmetric Statement from given term and temporal
information, called by the rules
|
Modifier and Type | Method | Description |
---|---|---|
static Statement |
Statement.make(Statement statement,
Term subj,
Term pred) |
Make a Statement from given components, called by the rules
|
static Statement |
Statement.make(Statement statement,
Term subj,
Term pred,
int order) |
|
static Statement |
Statement.makeSym(Statement statement,
Term subj,
Term pred,
int order) |
Make a symmetric Statement from given term and temporal
information, called by the rules
|
Modifier and Type | Class | Description |
---|---|---|
class |
Operation |
An operation is interpreted as an Inheritance relation.
|
Modifier and Type | Method | Description |
---|---|---|
static String |
Operator.operationExecutionString(Statement operation) |
Modifier and Type | Method | Description |
---|---|---|
static Term |
Reflect.sop(Statement s,
String operatorName) |
|
static Term |
Reflect.sop(Statement s,
Term predicate) |
Copyright © 2020 OpenNARS. All rights reserved.