Implicator.cc

Go to the documentation of this file.

/*
 * Implicator.cc
 *
 * Copyright (C) 2009, 2014 Linas Vepstas
 *
 * Author: Linas Vepstas <linasvepstas@gmail.com>  January 2009
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License v3 as
 * published by the Free Software Foundation and including the exceptions
 * at http://opencog.org/wiki/Licenses
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program; if not, write to:
 * Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include <opencog/atomspace/AtomSpace.h>
#include <opencog/atomspace/SimpleTruthValue.h>
#include <opencog/atoms/bind/BindLink.h>

#include "BindLinkAPI.h"
#include "DefaultImplicator.h"
#include "PatternMatch.h"

using namespace opencog;

bool Implicator::grounding(const std::map<Handle, Handle> &var_soln,
                           const std::map<Handle, Handle> &term_soln)
{
    // PatternMatchEngine::print_solution(term_soln,var_soln);
    Handle h = inst.instantiate(implicand, var_soln);
    insert_result(h);

    // If we found as many as we want, then stop looking for more.
    if (_result_set.size() < max_results)
        return false;
    return true;
}

void Implicator::insert_result(const Handle& h)
{
    if (Handle::UNDEFINED != h)
    {
        if (_result_set.end() == _result_set.find(h))
        {
            _result_set.insert(h);
            _result_changed = true;
        }
    }
}

HandleSeq Implicator::get_result_list()
{
    if (_result_changed)
    {
        _result_list.clear();
        std::copy(_result_set.begin(), _result_set.end(),
                  std::back_inserter(_result_list));
        _result_changed = false;
    }
    return _result_list;
}


namespace opencog
{

static Handle do_imply(AtomSpace* as,
                       const Handle& hbindlink,
                       Implicator& impl,
                       bool do_conn_check=false)
{
    BindLinkPtr bl(BindLinkCast(hbindlink));
    if (NULL == bl)
        bl = createBindLink(*LinkCast(hbindlink));

    impl.implicand = bl->get_implicand();

    bl->imply(impl, do_conn_check);

    if (0 < impl.get_result_list().size())
    {
        // The result_list contains a list of the grounded expressions.
        // (The order of the list has no significance, so it's really a set.)
        // Put the set into a SetLink, and return that.
        Handle gl = as->add_link(SET_LINK, impl.get_result_list());
        return gl;
    }

    // There are certain useful queries, where the goal of the query
    // is to determine that some clause or set of clauses are absent
    // from the AtomSpace. If the clauses are jointly not found, after
    // a full and exhaustive search, then we want to run the implicator,
    // and perform some action. Easier said than done, this code is
    // currently a bit of a hack. It seems to work, per the AbsentUTest
    // but is perhaps a bit fragile in its assumptions.
    //
    // Theoretical background: the atomspace can be thought of as a
    // Kripke frame: it holds everything we know "right now". The
    // AbsentLink is a check for what we don't know, right now.
    const Pattern& pat = bl->get_pattern();
    DefaultPatternMatchCB* intu =
        dynamic_cast<DefaultPatternMatchCB*>(&impl);
    if (0 == pat.mandatory.size() and 0 < pat.optionals.size()
        and not intu->optionals_present())
    {
        std::map<Handle, Handle> empty_map;
        Handle h = impl.inst.instantiate(impl.implicand, empty_map);
        impl.insert_result(h);
    }

    return as->add_link(SET_LINK, impl.get_result_list());
}

Handle bindlink(AtomSpace* as, const Handle& hbindlink)
{
    // Now perform the search.
    DefaultImplicator impl(as);
    return do_imply(as, hbindlink, impl);
}

Handle single_bindlink (AtomSpace* as, const Handle& hbindlink)
{
    // Now perform the search.
    DefaultImplicator impl(as);
    impl.max_results = 1;
    return do_imply(as, hbindlink, impl);
}

Handle af_bindlink(AtomSpace* as, const Handle& hbindlink)
{
    // Now perform the search.
    AFImplicator impl(as);
    return do_imply(as, hbindlink, impl, false);
}

}

/* ===================== END OF FILE ===================== */