Examples with Sentence nars.entity.Sentence used on opensource projects

Example 31 with Sentence

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);
    }
}

Example 32 with Sentence

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;
}

Example 33 with Sentence

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;
}

Example 34 with Sentence

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;
}

Example 35 with Sentence

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;
    }
}