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

Example 21 with CompoundTerm

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

the class SyllogisticRules method analogy.

/**
 * {<S ==> P>, <M <=> P>} |- <S ==> P>
 *
 * @param subj Subject of the new task
 * @param pred Predicate of the new task
 * @param asym The asymmetric premise
 * @param sym The symmetric premise
 * @param figure Locations of the shared term in premises
 * @param nal Reference to the memory
 */
static void analogy(Term subj, Term pred, Sentence asym, Sentence sym, int figure, DerivationContext nal) {
    if (Statement.invalidStatement(subj, pred)) {
        return;
    }
    int order1 = asym.term.getTemporalOrder();
    int order2 = sym.term.getTemporalOrder();
    int order = analogyOrder(order1, order2, figure);
    if (order == ORDER_INVALID) {
        return;
    }
    Statement st = (Statement) asym.term;
    TruthValue truth = null;
    BudgetValue budget;
    Sentence sentence = nal.getCurrentTask().sentence;
    CompoundTerm taskTerm = (CompoundTerm) sentence.term;
    if (sentence.isQuestion() || sentence.isQuest()) {
        if (taskTerm.isCommutative()) {
            if (asym.truth == null) {
                // a question for example
                return;
            }
            budget = BudgetFunctions.backwardWeak(asym.truth, nal);
        } else {
            if (sym.truth == null) {
                // a question for example
                return;
            }
            budget = BudgetFunctions.backward(sym.truth, nal);
        }
    } else {
        if (sentence.isGoal()) {
            if (taskTerm.isCommutative()) {
                truth = TruthFunctions.desireWeak(asym.truth, sym.truth);
            } else {
                truth = TruthFunctions.desireStrong(asym.truth, sym.truth);
            }
        } else {
            truth = TruthFunctions.analogy(asym.truth, sym.truth);
        }
        budget = BudgetFunctions.forward(truth, nal);
    }
    // nal.mem().logic.ANALOGY.commit();
    // (allow overlap) but not needed here, isn't detachment
    nal.doublePremiseTask(Statement.make(st, subj, pred, order), truth, budget, false, false);
}

Example 22 with CompoundTerm

use of nars.language.CompoundTerm 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 23 with CompoundTerm

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

the class SyllogisticRules method conditionalAna.

/**
 * {<(&&, S1, S2, S3) <=> P>, S1} |- <(&&, S2, S3) <=> P> {<(&&, S2, S3) <=> P>,
 * <S1 ==> S2>} |- <(&&, S1, S3) <=> P> {<(&&, S1, S3) <=> P>, <S1 ==>
 *
 * @param premise1 The equivalence 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 conditionalAna(Equivalence premise1, short index, Term premise2, int side, DerivationContext nal) {
    Task task = nal.getCurrentTask();
    Sentence taskSentence = task.sentence;
    Sentence belief = nal.getCurrentBelief();
    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 tm = premise1.getSubject();
    if (!(tm instanceof Conjunction)) {
        return;
    }
    Conjunction oldCondition = (Conjunction) tm;
    Term[] u = new Term[] { premise1, premise2 };
    boolean match = Variables.unify(Symbols.VAR_DEPENDENT, oldCondition.term[index], commonComponent, u);
    premise1 = (Equivalence) u[0];
    premise2 = u[1];
    if (!match && (commonComponent.getClass() == oldCondition.getClass())) {
        u = new Term[] { premise1, premise2 };
        match = Variables.unify(Symbols.VAR_DEPENDENT, oldCondition.term[index], ((CompoundTerm) commonComponent).term[index], u);
        premise1 = (Equivalence) u[0];
        premise2 = u[1];
    }
    if (!match) {
        return;
    }
    int conjunctionOrder = oldCondition.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;
    if (newCondition != null) {
        content = Statement.make(premise1, newCondition, premise1.getPredicate(), premise1.getTemporalOrder());
    } else {
        content = premise1.getPredicate();
    }
    if (content == null)
        return;
    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 {
                truth = TruthFunctions.desireDed(truth1, truth2);
            }
        } else {
            if (conditionalTask) {
                truth = TruthFunctions.comparison(truth1, truth2);
            } else {
                truth = TruthFunctions.analogy(truth1, truth2);
            }
        }
        budget = BudgetFunctions.forward(truth, nal);
    }
    // (allow overlap) when !conditionalTask on judgment
    nal.doublePremiseTask(content, truth, budget, false, taskSentence.isJudgment() && !conditionalTask);
}

Example 24 with CompoundTerm

use of nars.language.CompoundTerm 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 25 with CompoundTerm

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

the class Concept method linkToTask.

/**
 * Link to a new task from all relevant concepts for continued processing in
 * the near future for unspecified time.
 * <p>
 * The only method that calls the TaskLink constructor.
 *
 * @param task The task to be linked
 * @param content The content of the task
 */
public void linkToTask(final Task task, DerivationContext cont) {
    final BudgetValue taskBudget = task.budget;
    insertTaskLink(new TaskLink(task, null, taskBudget, Parameters.TERM_LINK_RECORD_LENGTH), // link type: SELF
    cont);
    if (!(term instanceof CompoundTerm)) {
        return;
    }
    if (termLinkTemplates.isEmpty()) {
        return;
    }
    final BudgetValue subBudget = distributeAmongLinks(taskBudget, termLinkTemplates.size());
    if (subBudget.aboveThreshold()) {
        for (int t = 0; t < termLinkTemplates.size(); t++) {
            TermLink termLink = termLinkTemplates.get(t);
            if (termLink.type == TermLink.TEMPORAL)
                continue;
            Term componentTerm = termLink.target;
            Concept componentConcept = memory.conceptualize(subBudget, componentTerm);
            if (componentConcept != null) {
                componentConcept.insertTaskLink(new TaskLink(task, termLink, subBudget, Parameters.TERM_LINK_RECORD_LENGTH), cont);
            }
        }
        // recursively insert TermLink
        buildTermLinks(taskBudget);
    }
}