Examples with Interval nars.language.Interval used on opensource projects

Example 6 with Interval

use of nars.language.Interval in project opennars by opennars.

the class StructuralRules method transformSubjectPI.

/**
 * Equivalent transformation between products and images when the subject is
 * a compound {<(*, S, M) --> P>, S@(*, S, M)} |- <S --> (/, P, _, M)> {<S
 * --> (/, P, _, M)>, P@(/, P, _, M)} |- <(*, S, M) --> P> {<S --> (/, P, _,
 * M)>, M@(/, P, _, M)} |- <M --> (/, P, S, _)>
 *
 * @param subject The subject term
 * @param predicate The predicate term
 * @param nal Reference to the memory
 */
private static void transformSubjectPI(short index, CompoundTerm subject, Term predicate, DerivationContext nal) {
    TruthValue truth = nal.getCurrentTask().sentence.truth;
    BudgetValue budget;
    Inheritance inheritance;
    Term newSubj, newPred;
    if (subject instanceof Product) {
        Product product = (Product) subject;
        short i = index;
        /*for (short i = 0; i < product.size(); i++)*/
        {
            newSubj = product.term[i];
            newPred = ImageExt.make(product, predicate, i);
            if (!(newSubj instanceof Interval)) {
                // no intervals as subjects
                inheritance = Inheritance.make(newSubj, newPred);
                if (inheritance != null) {
                    if (truth == null) {
                        budget = BudgetFunctions.compoundBackward(inheritance, nal);
                    } else {
                        budget = BudgetFunctions.compoundForward(truth, inheritance, nal);
                    }
                    nal.singlePremiseTask(inheritance, truth, budget);
                }
            }
        }
    } else if (subject instanceof ImageInt) {
        ImageInt image = (ImageInt) subject;
        int relationIndex = image.relationIndex;
        for (short i = 0; i < image.size(); i++) {
            if (i == relationIndex) {
                newSubj = image.term[relationIndex];
                newPred = Product.make(image, predicate, relationIndex);
            } else {
                newSubj = ImageInt.make(image, predicate, i);
                newPred = image.term[i];
            }
            inheritance = Inheritance.make(newSubj, newPred);
            if (inheritance != null) {
                if (truth == null) {
                    budget = BudgetFunctions.compoundBackward(inheritance, nal);
                } else {
                    budget = BudgetFunctions.compoundForward(truth, inheritance, nal);
                }
                nal.singlePremiseTask(inheritance, truth, budget);
            }
        }
    }
}

Example 7 with Interval

use of nars.language.Interval in project opennars by opennars.

the class SyllogisticRules method conditionalDedInd.

/**
 * {<(&&, S1, S2, S3) ==> P>, S1} |- <(&&, S2, S3) ==> P> {<(&&, S2, S3) ==>
 * P>, <S1 ==> S2>} |- <(&&, S1, S3) ==> P> {<(&&, S1, S3) ==> P>, <S1 ==>
 * S2>} |- <(&&, S2, S3) ==> P>
 *
 * @param premise1 The conditional premise
 * @param index The location of the shared term in the condition of premise1
 * @param premise2 The premise which, or part of which, appears in the
 * condition of premise1
 * @param side The location of the shared term in premise2: 0 for subject, 1
 * for predicate, -1 for the whole term
 * @param nal Reference to the memory
 */
static void conditionalDedInd(Sentence premise1Sentence, Implication premise1, short index, Term premise2, int side, DerivationContext nal) {
    Task task = nal.getCurrentTask();
    Sentence taskSentence = task.sentence;
    Sentence belief = nal.getCurrentBelief();
    boolean deduction = (side != 0);
    boolean conditionalTask = Variables.hasSubstitute(Symbols.VAR_INDEPENDENT, premise2, belief.term);
    Term commonComponent;
    Term newComponent = null;
    if (side == 0) {
        commonComponent = ((Statement) premise2).getSubject();
        newComponent = ((Statement) premise2).getPredicate();
    } else if (side == 1) {
        commonComponent = ((Statement) premise2).getPredicate();
        newComponent = ((Statement) premise2).getSubject();
    } else {
        commonComponent = premise2;
    }
    Term subj = premise1.getSubject();
    if (!(subj instanceof Conjunction)) {
        return;
    }
    Conjunction oldCondition = (Conjunction) subj;
    int index2 = Terms.indexOf(oldCondition.term, commonComponent);
    if (index2 >= 0) {
        index = (short) index2;
    } else {
        Term[] u = new Term[] { premise1, premise2 };
        boolean match = Variables.unify(Symbols.VAR_INDEPENDENT, oldCondition.term[index], commonComponent, u);
        premise1 = (Implication) u[0];
        premise2 = u[1];
        if (!match && (commonComponent.getClass() == oldCondition.getClass())) {
            CompoundTerm compoundCommonComponent = ((CompoundTerm) commonComponent);
            if ((oldCondition.term.length > index) && (compoundCommonComponent.term.length > index)) {
                // assumption: { was missing
                u = new Term[] { premise1, premise2 };
                match = Variables.unify(Symbols.VAR_INDEPENDENT, oldCondition.term[index], compoundCommonComponent.term[index], u);
                premise1 = (Implication) u[0];
                premise2 = u[1];
            }
        }
        if (!match) {
            return;
        }
    }
    int conjunctionOrder = subj.getTemporalOrder();
    if (conjunctionOrder == ORDER_FORWARD) {
        if (index > 0) {
            return;
        }
        if ((side == 0) && (premise2.getTemporalOrder() == ORDER_FORWARD)) {
            return;
        }
        if ((side == 1) && (premise2.getTemporalOrder() == ORDER_BACKWARD)) {
            return;
        }
    }
    Term newCondition;
    if (oldCondition.equals(commonComponent)) {
        newCondition = null;
    } else {
        newCondition = oldCondition.setComponent(index, newComponent, nal.mem());
    }
    Term content;
    long delta = 0;
    long mintime = 0;
    long maxtime = 0;
    boolean predictedEvent = false;
    if (newCondition != null) {
        if (newCondition instanceof Interval) {
            content = premise1.getPredicate();
            delta = ((Interval) newCondition).time;
            if (taskSentence.getOccurenceTime() != Stamp.ETERNAL) {
                mintime = taskSentence.getOccurenceTime() + ((Interval) newCondition).time - 1;
                maxtime = taskSentence.getOccurenceTime() + ((Interval) newCondition).time + 2;
                predictedEvent = true;
            }
        } else {
            while ((newCondition instanceof Conjunction) && (((CompoundTerm) newCondition).term[0] instanceof Interval)) {
                Interval interval = (Interval) ((CompoundTerm) newCondition).term[0];
                delta += interval.time;
                newCondition = ((CompoundTerm) newCondition).setComponent(0, null, nal.mem());
            }
            content = Statement.make(premise1, newCondition, premise1.getPredicate(), premise1.getTemporalOrder());
        }
    } else {
        content = premise1.getPredicate();
    }
    if (content == null)
        return;
    long occurrence_time = nal.getTheNewStamp().getOccurrenceTime();
    if (delta != 0) {
        long baseTime = taskSentence.getOccurenceTime();
        if (baseTime != Stamp.ETERNAL) {
            baseTime += delta;
            occurrence_time = baseTime;
        }
    }
    TruthValue truth1 = taskSentence.truth;
    TruthValue truth2 = belief.truth;
    TruthValue truth = null;
    BudgetValue budget;
    if (taskSentence.isQuestion() || taskSentence.isQuest()) {
        budget = BudgetFunctions.backwardWeak(truth2, nal);
    } else {
        if (taskSentence.isGoal()) {
            if (conditionalTask) {
                truth = TruthFunctions.desireWeak(truth1, truth2);
            } else if (deduction) {
                truth = TruthFunctions.desireInd(truth1, truth2);
            } else {
                truth = TruthFunctions.desireDed(truth1, truth2);
            }
        } else {
            if (deduction) {
                truth = TruthFunctions.deduction(truth1, truth2);
            } else if (conditionalTask) {
                truth = TruthFunctions.induction(truth2, truth1);
            } else {
                truth = TruthFunctions.induction(truth1, truth2);
            }
        }
        budget = BudgetFunctions.forward(truth, nal);
    }
    nal.getTheNewStamp().setOccurrenceTime(occurrence_time);
    // (allow overlap) when deduction on judgment
    List<Task> ret = nal.doublePremiseTask(content, truth, budget, false, taskSentence.isJudgment() && deduction);
    if (!nal.evidentalOverlap && ret != null && ret.size() > 0) {
        if (predictedEvent && taskSentence.isJudgment() && truth != null && truth.getExpectation() > Parameters.DEFAULT_CONFIRMATION_EXPECTATION && !premise1Sentence.stamp.alreadyAnticipatedNegConfirmation) {
            premise1Sentence.stamp.alreadyAnticipatedNegConfirmation = true;
            ConceptProcessing.generatePotentialNegConfirmation(nal, premise1Sentence, budget, mintime, maxtime, 1);
        }
    }
}

Example 8 with Interval

use of nars.language.Interval 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 9 with Interval

use of nars.language.Interval 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 10 with Interval

use of nars.language.Interval 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;
}