use of nars.entity.Sentence in project opennars by opennars.
the class SyllogisticRules method detachment.
static void detachment(Sentence mainSentence, Sentence subSentence, int side, boolean checkTermAgain, DerivationContext nal) {
Statement statement = (Statement) mainSentence.term;
if (!(statement instanceof Implication) && !(statement instanceof Equivalence)) {
return;
}
Term subject = statement.getSubject();
Term predicate = statement.getPredicate();
Term content;
Term term = subSentence.term;
if ((side == 0) && (!checkTermAgain || term.equals(subject))) {
content = predicate;
} else if ((side == 1) && (!checkTermAgain || term.equals(predicate))) {
content = subject;
} else {
return;
}
if ((content instanceof Statement) && ((Statement) content).invalid()) {
return;
}
Sentence taskSentence = nal.getCurrentTask().sentence;
Sentence beliefSentence = nal.getCurrentBelief();
if (beliefSentence == null)
return;
int order = statement.getTemporalOrder();
long occurrence_time = nal.getTheNewStamp().getOccurrenceTime();
if ((order != ORDER_NONE) && (order != ORDER_INVALID)) {
long baseTime = subSentence.getOccurenceTime();
if (baseTime == Stamp.ETERNAL) {
// =/> always should produce events
baseTime = nal.getTime();
}
long inc = order * Parameters.DURATION;
occurrence_time = (side == 0) ? baseTime + inc : baseTime - inc;
}
TruthValue beliefTruth = beliefSentence.truth;
TruthValue truth1 = mainSentence.truth;
TruthValue truth2 = subSentence.truth;
TruthValue truth = null;
boolean strong = false;
BudgetValue budget;
if (taskSentence.isQuestion()) {
if (statement instanceof Equivalence) {
budget = BudgetFunctions.backward(beliefTruth, nal);
} else if (side == 0) {
budget = BudgetFunctions.backwardWeak(beliefTruth, nal);
} else {
budget = BudgetFunctions.backward(beliefTruth, nal);
}
} else if (taskSentence.isQuest()) {
if (statement instanceof Equivalence) {
budget = BudgetFunctions.backwardWeak(beliefTruth, nal);
} else if (side == 0) {
budget = BudgetFunctions.backward(beliefTruth, nal);
} else {
budget = BudgetFunctions.backwardWeak(beliefTruth, nal);
}
} else {
if (taskSentence.isGoal()) {
if (statement instanceof Equivalence) {
truth = TruthFunctions.desireStrong(truth1, truth2);
// not for goals anymore
strong = true;
} else if (side == 0) {
truth = TruthFunctions.desireInd(truth1, truth2);
} else {
truth = TruthFunctions.desireDed(truth1, truth2);
// not for goals anymore
strong = true;
}
} else {
// isJudgment
if (statement instanceof Equivalence) {
truth = TruthFunctions.analogy(truth2, truth1);
strong = true;
} else if (side == 0) {
truth = TruthFunctions.deduction(truth1, truth2);
strong = true;
} else {
truth = TruthFunctions.abduction(truth2, truth1);
}
}
budget = BudgetFunctions.forward(truth, nal);
}
if (!Variables.indepVarUsedInvalid(content)) {
boolean allowOverlap = taskSentence.isJudgment() && strong;
nal.getTheNewStamp().setOccurrenceTime(occurrence_time);
// (strong) when strong on judgement
nal.doublePremiseTask(content, truth, budget, false, allowOverlap);
}
}
use of nars.entity.Sentence in project opennars by opennars.
the class TemporalRules method temporalInduction.
// TODO maybe split &/ case into own function
public static List<Task> temporalInduction(final Sentence s1, final Sentence s2, final nars.control.DerivationContext nal, boolean SucceedingEventsInduction, boolean addToMemory, boolean allowSequence) {
if ((s1.truth == null) || (s2.truth == null) || s1.punctuation != Symbols.JUDGMENT_MARK || s2.punctuation != Symbols.JUDGMENT_MARK || s1.isEternal() || s2.isEternal())
return Collections.EMPTY_LIST;
Term t1 = s1.term;
Term t2 = s2.term;
boolean deriveSequenceOnly = (!addToMemory) || Statement.invalidStatement(t1, t2, true);
if (Statement.invalidStatement(t1, t2, false))
return Collections.EMPTY_LIST;
Term t11 = null;
Term t22 = null;
if (!deriveSequenceOnly && termForTemporalInduction(t1) && termForTemporalInduction(t2)) {
Statement ss1 = (Statement) t1;
Statement ss2 = (Statement) t2;
Variable var1 = new Variable("$0");
Variable var2 = new Variable("$1");
if (ss2.containsTermRecursively(ss1.getSubject())) {
HashMap<Term, Term> subs = new HashMap();
subs.put(ss1.getSubject(), var1);
if (ss2.containsTermRecursively(ss1.getPredicate())) {
subs.put(ss1.getPredicate(), var2);
}
t11 = ss1.applySubstitute(subs);
t22 = ss2.applySubstitute(subs);
}
if (ss1.containsTermRecursively(ss2.getSubject())) {
HashMap<Term, Term> subs = new HashMap();
subs.put(ss2.getSubject(), var1);
if (ss1.containsTermRecursively(ss2.getPredicate())) {
subs.put(ss2.getPredicate(), var2);
}
t11 = ss1.applySubstitute(subs);
t22 = ss2.applySubstitute(subs);
}
// allow also temporal induction on operator arguments:
if (ss2 instanceof Operation ^ ss1 instanceof Operation) {
if (ss2 instanceof Operation && !(ss2.getSubject() instanceof Variable)) {
// it is an operation, let's look if one of the arguments is same as the subject of the other term
Term comp = ss1.getSubject();
Term ss2_term = ((Operation) ss2).getSubject();
boolean applicableVariableType = !(comp instanceof Variable && ((Variable) comp).hasVarIndep());
if (ss2_term instanceof Product) {
Product ss2_prod = (Product) ss2_term;
if (applicableVariableType && Terms.contains(ss2_prod.term, comp)) {
// only if there is one and it isnt a variable already
Term[] ars = ss2_prod.cloneTermsReplacing(comp, var1);
t11 = Statement.make(ss1, var1, ss1.getPredicate());
Operation op = (Operation) Operation.make(new Product(ars), ss2.getPredicate());
t22 = op;
}
}
}
if (ss1 instanceof Operation && !(ss1.getSubject() instanceof Variable)) {
// it is an operation, let's look if one of the arguments is same as the subject of the other term
Term comp = ss2.getSubject();
Term ss1_term = ((Operation) ss1).getSubject();
boolean applicableVariableType = !(comp instanceof Variable && ((Variable) comp).hasVarIndep());
if (ss1_term instanceof Product) {
Product ss1_prod = (Product) ss1_term;
if (applicableVariableType && Terms.contains(ss1_prod.term, comp)) {
// only if there is one and it isnt a variable already
Term[] ars = ss1_prod.cloneTermsReplacing(comp, var1);
t22 = Statement.make(ss2, var1, ss2.getPredicate());
Operation op = (Operation) Operation.make(new Product(ars), ss1.getPredicate());
t11 = op;
}
}
}
}
}
int durationCycles = Parameters.DURATION;
long time1 = s1.getOccurenceTime();
long time2 = s2.getOccurenceTime();
long timeDiff = time2 - time1;
Interval interval = null;
if (!concurrent(time1, time2, durationCycles)) {
interval = new Interval(Math.abs(timeDiff));
if (timeDiff > 0) {
t1 = Conjunction.make(t1, interval, ORDER_FORWARD);
if (t11 != null) {
t11 = Conjunction.make(t11, interval, ORDER_FORWARD);
}
} else {
t2 = Conjunction.make(t2, interval, ORDER_FORWARD);
if (t22 != null) {
t22 = Conjunction.make(t22, interval, ORDER_FORWARD);
}
}
}
int order = order(timeDiff, durationCycles);
TruthValue givenTruth1 = s1.truth;
TruthValue givenTruth2 = s2.truth;
// This code adds a penalty for large time distance (TODO probably revise)
Sentence s3 = s2.projection(s1.getOccurenceTime(), nal.memory.time());
givenTruth2 = s3.truth;
// Truth and priority calculations
TruthValue truth1 = TruthFunctions.induction(givenTruth1, givenTruth2);
TruthValue truth2 = TruthFunctions.induction(givenTruth2, givenTruth1);
TruthValue truth3 = TruthFunctions.comparison(givenTruth1, givenTruth2);
TruthValue truth4 = TruthFunctions.intersection(givenTruth1, givenTruth2);
BudgetValue budget1 = BudgetFunctions.forward(truth1, nal);
budget1.setPriority(budget1.getPriority() * Parameters.TEMPORAL_INDUCTION_PRIORITY_PENALTY);
BudgetValue budget2 = BudgetFunctions.forward(truth2, nal);
budget2.setPriority(budget2.getPriority() * Parameters.TEMPORAL_INDUCTION_PRIORITY_PENALTY);
BudgetValue budget3 = BudgetFunctions.forward(truth3, nal);
budget3.setPriority(budget3.getPriority() * Parameters.TEMPORAL_INDUCTION_PRIORITY_PENALTY);
// this one is sequence in sequenceBag, no need to reduce here
BudgetValue budget4 = BudgetFunctions.forward(truth4, nal);
Statement statement1 = Implication.make(t1, t2, order);
Statement statement2 = Implication.make(t2, t1, reverseOrder(order));
Statement statement3 = Equivalence.make(t1, t2, order);
Term statement4 = null;
switch(order) {
case TemporalRules.ORDER_FORWARD:
statement4 = Conjunction.make(t1, interval, s2.term, order);
break;
case TemporalRules.ORDER_BACKWARD:
statement4 = Conjunction.make(s2.term, interval, t1, reverseOrder(order));
break;
default:
statement4 = Conjunction.make(t1, s2.term, order);
break;
}
// "Perception Variable Introduction Rule" - https://groups.google.com/forum/#!topic/open-nars/uoJBa8j7ryE
if (!deriveSequenceOnly && statement2 != null) {
// there is no general form
// ok then it may be the (&/ =/> case which
// is discussed here: https://groups.google.com/forum/#!topic/open-nars/uoJBa8j7ryE
Statement st = statement2;
if (st.getPredicate() instanceof Inheritance && (st.getSubject() instanceof Conjunction || st.getSubject() instanceof Operation)) {
Term precon = (Term) st.getSubject();
Inheritance consequence = (Inheritance) st.getPredicate();
Term pred = consequence.getPredicate();
Term sub = consequence.getSubject();
// look if subject is contained in precon:
boolean SubsSub = precon.containsTermRecursively(sub);
boolean SubsPred = precon.containsTermRecursively(pred);
Variable v1 = new Variable("$91");
Variable v2 = new Variable("$92");
HashMap<Term, Term> app = new HashMap<Term, Term>();
if (SubsSub || SubsPred) {
if (SubsSub)
app.put(sub, v1);
if (SubsPred)
app.put(pred, v2);
Term res = ((CompoundTerm) statement2).applySubstitute(app);
if (res != null) {
// ok we applied it, all we have to do now is to use it
t22 = ((Statement) res).getSubject();
t11 = ((Statement) res).getPredicate();
}
}
}
}
List<Task> success = new ArrayList<Task>();
if (!deriveSequenceOnly && t11 != null && t22 != null) {
Statement statement11 = Implication.make(t11, t22, order);
Statement statement22 = Implication.make(t22, t11, reverseOrder(order));
Statement statement33 = Equivalence.make(t11, t22, order);
if (!tooMuchTemporalStatements(statement11)) {
List<Task> t = nal.doublePremiseTask(statement11, truth1, budget1, true, false);
if (t != null) {
success.addAll(t);
}
}
if (!tooMuchTemporalStatements(statement22)) {
List<Task> t = nal.doublePremiseTask(statement22, truth2, budget2, true, false);
if (t != null) {
success.addAll(t);
}
}
if (!tooMuchTemporalStatements(statement33)) {
List<Task> t = nal.doublePremiseTask(statement33, truth3, budget3, true, false);
if (t != null) {
success.addAll(t);
}
}
}
if (!deriveSequenceOnly && !tooMuchTemporalStatements(statement1)) {
List<Task> t = nal.doublePremiseTask(statement1, truth1, budget1, true, false);
if (t != null) {
success.addAll(t);
for (Task task : t) {
// we assume here that this function is used for observable events currently
task.setObservablePrediction(true);
}
}
}
if (!deriveSequenceOnly && !tooMuchTemporalStatements(statement2)) {
List<Task> t = nal.doublePremiseTask(statement2, truth2, budget2, true, false);
if (t != null) {
success.addAll(t);
for (Task task : t) {
// we assume here that this function is used for observable events currently
task.setObservablePrediction(true);
}
}
}
if (!deriveSequenceOnly && !tooMuchTemporalStatements(statement3)) {
List<Task> t = nal.doublePremiseTask(statement3, truth3, budget3, true, false);
if (t != null) {
for (Task task : t) {
// we assume here that this function is used for observable events currently
task.setObservablePrediction(true);
}
success.addAll(t);
}
}
if (!tooMuchTemporalStatements(statement4)) {
if (!allowSequence) {
return success;
}
List<Task> tl = nal.doublePremiseTask(statement4, truth4, budget4, true, false, addToMemory);
if (tl != null) {
for (Task t : tl) {
// fill sequenceTask buffer due to the new derived sequence
if (addToMemory && t.sentence.isJudgment() && !t.sentence.isEternal() && t.sentence.term instanceof Conjunction && ((Conjunction) t.sentence.term).getTemporalOrder() != TemporalRules.ORDER_NONE && ((Conjunction) t.sentence.term).getTemporalOrder() != TemporalRules.ORDER_INVALID) {
TemporalInferenceControl.addToSequenceTasks(nal, t);
}
success.add(t);
}
}
}
return success;
}
use of nars.entity.Sentence in project opennars by opennars.
the class DerivationContext method singlePremiseTask.
/**
* Shared final operations by all single-premise rules, called in
* StructuralRules
*
* @param newContent The content of the sentence in task
* @param punctuation The punctuation of the sentence in task
* @param newTruth The truth value of the sentence in task
* @param newBudget The budget value in task
*/
public boolean singlePremiseTask(final Term newContent, final char punctuation, final TruthValue newTruth, final BudgetValue newBudget) {
if (!newBudget.aboveThreshold())
return false;
Sentence taskSentence = getCurrentTask().sentence;
if (taskSentence.isGoal() || taskSentence.isJudgment() || getCurrentBelief() == null) {
setTheNewStamp(new Stamp(taskSentence.stamp, getTime()));
} else {
// to answer a question with negation in NAL-5 --- move to activated task?
setTheNewStamp(new Stamp(getCurrentBelief().stamp, getTime()));
}
if (newContent.subjectOrPredicateIsIndependentVar()) {
return false;
}
if (newContent instanceof Interval) {
return false;
}
Stamp derive_stamp = this.getTheNewStamp().clone();
// stamp was already obsorbed into task
this.resetOccurrenceTime();
Sentence newSentence = new Sentence(newContent, punctuation, newTruth, derive_stamp);
Task newTask = Task.make(newSentence, newBudget, getCurrentTask());
if (newTask != null) {
return derivedTask(newTask, false, true, false);
}
return false;
}
use of nars.entity.Sentence in project opennars by opennars.
the class DerivationContext method doublePremiseTask.
public List<Task> doublePremiseTask(final Term newContent, final TruthValue newTruth, final BudgetValue newBudget, boolean temporalInduction, boolean overlapAllowed, boolean addToMemory) {
List<Task> ret = new ArrayList<Task>();
if (newContent == null) {
return null;
}
if (!newBudget.aboveThreshold()) {
return null;
}
if ((newContent != null) && (!(newContent instanceof Interval)) && (!(newContent instanceof Variable))) {
if (newContent.subjectOrPredicateIsIndependentVar()) {
return null;
}
// because occurrence time will be reset:
Stamp derive_stamp = getTheNewStamp().clone();
// stamp was already obsorbed into task
this.resetOccurrenceTime();
try {
final Sentence newSentence = new Sentence(newContent, getCurrentTask().sentence.punctuation, newTruth, derive_stamp);
newSentence.producedByTemporalInduction = temporalInduction;
final Task newTask = Task.make(newSentence, newBudget, getCurrentTask(), getCurrentBelief());
if (newTask != null) {
boolean added = derivedTask(newTask, false, false, overlapAllowed, addToMemory);
if (added) {
ret.add(newTask);
}
}
} catch (CompoundTerm.UnableToCloneException e) {
return null;
}
// "Since in principle it is always valid to eternalize a tensed belief"
if (temporalInduction && Parameters.IMMEDIATE_ETERNALIZATION) {
try {
TruthValue truthEt = TruthFunctions.eternalize(newTruth);
Stamp st = derive_stamp.clone();
st.setEternal();
final Sentence newSentence = new Sentence(newContent, getCurrentTask().sentence.punctuation, truthEt, st);
newSentence.producedByTemporalInduction = temporalInduction;
final Task newTask = Task.make(newSentence, newBudget, getCurrentTask(), getCurrentBelief());
if (newTask != null) {
boolean added = derivedTask(newTask, false, false, overlapAllowed, addToMemory);
if (added) {
ret.add(newTask);
}
}
} catch (CompoundTerm.UnableToCloneException e) {
return null;
}
}
return ret;
}
return null;
}
use of nars.entity.Sentence in project opennars by opennars.
the class FunctionOperator method execute.
// abstract protected int getMinArity();
// abstract protected int getMaxArity();
@Override
protected ArrayList<Task> execute(Operation operation, Term[] args, Memory m) {
// TODO make memory access optional by constructor argument
// TODO allow access to NAR instance?
int numArgs = args.length - 1;
if (numArgs < 1) {
throw new RuntimeException("Requires at least 1 arguments");
}
if (numArgs < 2) /*&& !(this instanceof Javascript)*/
{
throw new RuntimeException("Requires at least 2 arguments");
}
// last argument a variable?
Term lastTerm = args[numArgs];
boolean variable = lastTerm instanceof Variable;
if (!variable) /*&& !(this instanceof Javascript)*/
{
throw new RuntimeException("output can not be specified");
}
int numParam = numArgs - 1;
/*if(this instanceof Javascript && !variable) {
numParam++;
}*/
Term[] x = new Term[numParam];
System.arraycopy(args, 1, x, 0, numParam);
Term y;
// try {
y = function(m, x);
if (y == null) {
return null;
}
/*if(!variable && this instanceof Javascript) {
return null;
}*/
// m.emit(SynchronousFunctionOperator.class, Arrays.toString(x) + " | " + y);
/*}
catch (Exception e) {
throw e;
}*/
Variable var = new Variable("$1");
// Term actual_part = Similarity.make(var, y);
// Variable vardep=new Variable("#1");
// Term actual_dep_part = Similarity.make(vardep, y);
operation = (Operation) operation.setComponent(0, ((CompoundTerm) operation.getSubject()).setComponent(numArgs, y, m), m);
float confidence = Parameters.DEFAULT_JUDGMENT_CONFIDENCE;
if (variable) {
Sentence s = new Sentence(operation, Symbols.JUDGMENT_MARK, new TruthValue(1.0f, Parameters.DEFAULT_JUDGMENT_CONFIDENCE), new Stamp(m));
return Lists.newArrayList(new Task(s, new BudgetValue(Parameters.DEFAULT_JUDGMENT_PRIORITY, Parameters.DEFAULT_FEEDBACK_DURABILITY, truthToQuality(s.getTruth())), true));
} else {
return null;
}
}
Aggregations