class RDF::N3::Algebra::Log::Includes

The subject formula includes the object formula.

Formula A includes formula B if there exists some substitution which when applied to B creates a formula B’ such that for every statement in B’ is also in A, every variable universally (or existentially) quantified in B’ is quantified in the same way in A.

Variable substitution is applied recursively to nested compound terms such as formulae, lists and sets.

(Understood natively by cwm when in in the antecedent of a rule. You can use this to peer inside nested formulae.)

Constants

NAME
URI

Public Instance Methods

apply(subject, object) click to toggle source

Creates a repository constructed by substituting variables and in that subject with known IRIs and queries object against that repository. Either retuns a single solution, or no solutions.

@note this does allow object to have variables not in the subject, if they could have been substituted away.

@param [RDF::N3::Algebra::Formula] subject

a formula

@param [RDF::N3::Algebra::Formula] object

a formula

@return [RDF::Literal::Boolean]

# File lib/rdf/n3/algebra/log/includes.rb, line 40
def apply(subject, object)
  subject_var_map = subject.variables.values.inject({}) {|memo, v| memo.merge(v => RDF::URI(v.name))}
  object_vars = object.variables.keys
  log_debug(NAME,  "subject var map") {SXP::Generator.string(subject_var_map.to_sxp_bin)}
  log_debug(NAME, "object vars") {SXP::Generator.string(object_vars.to_sxp_bin)}
  # create a queryable from subject, replacing variables with IRIs for thsoe variables.
  queryable = RDF::Repository.new do |r|
    log_depth do
      subject.each do |stmt|
        parts = stmt.to_quad.map do |part|
          part.is_a?(RDF::Query::Variable) ? subject_var_map.fetch(part) : part
        end
        r << RDF::Statement.from(parts)
      end
    end
  end

  # Query object against subject
  solns = log_depth {queryable.query(object, **@options)}
  log_info("(#{NAME} solutions)") {SXP::Generator.string solns.to_sxp_bin}

  if !solns.empty? && (object_vars - solns.variable_names).empty?
    # Return solution
    solns.first
  else
    # Return false,
    RDF::Literal::FALSE
  end
end
input_operand() click to toggle source

Both subject and object are inputs.

# File lib/rdf/n3/algebra/log/includes.rb, line 26
def input_operand
  RDF::N3::List.new(values: operands)
end
resolve(resource, position:) click to toggle source

Both subject and object must be formulae.

@param [RDF::Term] resource @param [:subject, :object] position @return [RDF::Term] @see RDF::N3::ResourceOperator#evaluate

# File lib/rdf/n3/algebra/log/includes.rb, line 21
def resolve(resource, position:)
  resource if resource.formula?
end