[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This is a catch-all section for documented functions, methods and relations that haven’t been categorized yet into any of the previous sections. They are in random order and many of them will never be part of the official PowerLoom interface. So beware!
Return the element of array at position [row, column].
Return the element of array at position [row, column].
Set the element of array at position [row, column] to value and return the result.
Set the element of array at position [row, column] to value and return the result.
Add a query and score pair to the master list of testing examples
Add a query and score pair to the master list of training examples
Return a set of all of the types that are asserted to be satisfied by self.
Return a set of instances that belong to the class type.
Return a list of lists of descriptions that are provably co-extensional.
Return a set of relations that immediately specialize relation. If removeEquivalents? (recommended), don’t include any relations equivalent to relation.
Return a set of relations that immediately subsume relation. If removeEquivalents? (recommended), don’t include any relations equivalent to relation.
Return a set of most specific types that are satisfied by self.
Return a list of all relations equivalent to relation. If reflexive?, include relation in the list.
Return a list of all definite (TRUE or FALSE) propositions attached to self.
This is a generalization of all-facts-of
(which see). With n = 0
and only one instance this command behaves just like all-facts-of
.
Otherwise, returns a cons list of all definite (TRUE or FALSE) propositions
that reference any of the instances listed in instanceRefs, plus if n >= 1
all propositions that reference any instances that are arguments of
propositions collected in the previous step, plus if n >= 2... and so on.
That is, if we only consider binary propositions, this can be viewed as
growing a graph with instances as its nodes and predicates as its arcs
starting from the set of seed instanceRefs to depth n-1.
Caution: with a fully connected KB and large enough n this could return
the whole knowledge base.
The returned propositions include those asserted to be true or false by
default, but it does not include propositions that are found to be
true only by running the query engine. Facts inferred to be true by
the forward chainer will be included. Hence, the returned list of
facts may be longer in a context where the forward chainer has been
run then in one where it has not (see run-forward-rules
).
Iterate over all conceived propositions visible from module that have an inconsistent truth value. If local?, only return inconsistent propositions conceived locally in module.
Iterate over all instances (or individuals) visible from module. Only instances that haven’t been deleted will be considered. If local?, only return instances created locally in module.
Iterate over all conceived propositions visible from module that had their truth value locally modified (initialized, asserted, retracted). Note, that this will always include all locally conceived propositions.
Iterate over all named descriptions visible from module. If local?, return only named descriptions interned in module. If module is null, return all named descriptions interned everywhere.
Iterate over all named instances (or individuals) visible from module. Only instances that haven’t been deleted will be considered. If local?, only return instances created locally in module.
Iterate over all named terms visible from module. A term can be an instance (or individual) as well as a description. Only terms that haven’t been deleted will be considered. If local?, only return terms created locally in module.
Iterate over all conceived propositions visible from module. Only propositions that haven’t been deleted will be considered. If local?, only return propositions conceived locally in module.
Return a set of values that satisfy the relation relation (a surrogate) applied to nMinusOneArguments plus that last value.
Return a list of sentences describing facts about instanceRef.
Return a set of the most specific types for fillers of the slot relation applied to self.
Return a set of values for the slot relation (a surrogate) applied to self (an object).
Return a set of all (named) relations that specialize relation.
Return a set of all relations that subsume relation.
Return a set of all of the types that are satisfied by self, using only assertions and upward taxonomic reasoning.
Return a list of all terms visible from module. A term can be an instance (or individual) as well as a description. Only terms that haven’t been deleted will be considered. If local?, only return terms created locally in module.
Return a set of all of the types that are satisfied by self.
Iterate over all unnamed terms visible from module. A term can be an instance (or individual) as well as a description. Only terms that haven’t been deleted will be considered. If local?, only return terms created locally in module.
Similar to allocate-transitive-closure-iterator
(which see),
but return a SUPPORTED-CLOSURE-ITERATOR instead.
Return an iterator that generates the transitive closure of applying iterators generated by allocateAdjacencyIterator to startNode. If filterFunction is non-null, that function is applied as a filter to each node generated (nodes filtered out still generate descendants, but they don’t get returned).
Execute a yes/no query composed of input-variables
inputVariables
and body queryBody
. Before executing, bind variables
to inputBindings
(in sequence).
(apply-ask inputVariables queryBody inputBindings)
Apply (inherit) the description description
to members of the vector vector. Return TRUE if no clash was detected.
Constraint propagation happens only if it is enabled prior to calling
apply-kappa?
.
Execute a query composed of io-variables variables
and body queryBody
. Before executing, bind variables to inputBindings
(in sequence). If one variable is left unbound, returns a cons list of
bindings of that variable. If two or more are unbound, returns
a cons list of cons lists of bindings. Setting the option :singletons?
to FALSE always returns a list of lists. Example call:
(apply-retrieve variables queryBody inputBindings)
Similar to ask
(which see), but return the highest partial match score
for the supplied proposition instead of a truth value. If the option
:MAXIMIZE-SCORE? is set to FALSE, return after the first partial match score
has been generated.
Return TRUE if self is the undefined individual BOTTOM.
Return a list of all definite (TRUE or FALSE) propositions that reference the instance instanceRef.
Callable version of ask
(which see). Accepts queries
specified by a query iterator, or specified as a CONS-list of arguments as they
would be supplied to ask
. Raises LOGIC-EXCEPTIONs in case of illegal
queries and logical expressions.
Callable version of the defconcept
command (which see).
Expects the same arguments as defconcept
but supplied as a list.
Callable version of the deffunction
command (which see).
Expects the same arguments as deffunction
but supplied as a list.
Callable version of the defobject
command (which see).
Expects the same arguments as defobject
but supplied as a list.
Callable version of the defproposition
command (which see).
Expects the same arguments as defproposition
but supplied as a list.
Callable version of the defrelation
command (which see).
Expects the same arguments as defrelation
but supplied as a list.
Callable version of list-undefined-relations
(which see).
Trigger constraint propagation over all propositions in the module or world context.
Callable version of retrieve
(which see). Accepts queries
specified by a query iterator, or specified as a CONS-list of arguments as they
would be supplied to retrieve
. Raises LOGIC-EXCEPTIONs in case of illegal
queries and logical expressions.
Callable version of retrieve-partial
(which see). Accepts queries
specified by a query iterator, or specified as a CONS-list of arguments as they
would be supplied to retrieve-partial
. Raises LOGIC-EXCEPTIONs in case of
illegal queries and logical expressions.
Run forward inference rules in module module. If module is NULL, the current module will be used. If forward inferencing is already up-to-date in the designated module, no additional inferencing will occur, unless force? is set to TRUE, in which case all forward rules are run or rerun.
Set the inference level of module to the level specified by levelKeyword. If module is NULL and we are inside a query, set the level of the current query iterator. Otherwise, set the level globally.
Return TRUE if objectRef denotes a class.
Return the logic instance referred to by self.
Return the logic instance referred to by self, or self if it is a literal (e.g., string or number) that can’t be coerced.
Return a vector containing the elements in self. Coerce each element of self to be a logic object or literal.
Return TRUE if objectRef denotes a relation or a class.
Return the simplest inversion of prop, trying to reuse existing negations or negated arguments of prop if possible.
tree is a term expression (a string or an s-expression), or is a class reference (a symbol or surrogate). Return a (possibly newly-conceived) term representing the internalized representation of that term.
Return the logical conjunction of truth values tv1 and tv2.
Return a CONS tree representation of the proof self. Each proof step is represented as a CONS tree of the form (<proposition> (<key> <value>...) <antecedent>...) where each <antecedent> is a CONS tree representing a subproof. The consification follows the original proof structure literally, i.e., no uninteresting nodes such as patterns or AND-introductions are suppressed.
Generate all solutions for the query self, and collect them into a cons list
of result tuples. If :SINGLETONS? TRUE
, collect a list of atoms rather than a
list of lists for tuples of arity=1.
Collect all solutions of self into a cons list and return the result.
Collect the current solutions of self into a cons list
of result tuples. If :SINGLETONS? TRUE
, collect a list of atoms rather than a
list of lists for tuples of arity=1.
Return a CONS tree representation of the proof self. Each proof step is represented as a CONS tree of the form (<proposition> (<key> <value>...) <antecedent>...) where each <antecedent> is a CONS tree representing a subproof. style indicates what nodes in the proof tree should be suppressed. :RAW preserves the original structure literally, :VERBOSE keeps AND- introductions but suppresses all auxiliary (non-logical) nodes such as pattern nodes, and :BRIEF additionally suppresses AND-introduction nodes.
Return true if self is a constant such as TRUE or FALSE.
Return TRUE if objectRef denotes a literal or scalar.
Return a copy of the proof starting at self. Allocates all new justification objects, but structure-shares other information such as propositions and substitutions.
Create a logic object with name name and return it. If type is also supplied, assert that the object belongs to that type.
Create a two-dimensional array with nof-rows rows and nof-columns columns, and initialize it in row-major-order from values. Missing values will be padded with NULL, extraneous values will be ignored.
Create a two-dimensional array with nof-rows rows and nof-columns columns, and initialize it in row-major-order from values. Missing values will be padded with NULL, extraneous values will be ignored.
Return a vector containing values, in order.
Return a new marker storage object, used to
remember with objects have been marked
. If supportRecall?
is set, then the iterator recall-marked-objects
can be invoked
on the new marker storage object.
Return a vector containing values, in order.
Return the current inference level that is active in the current query, the current module, or, otherwise, globally.
Set the debug ID of self to id. If id is NULL, simply use the current ID counter and increment it appropriately.
Return true if self is default false.
Return true if self is default true.
Return TRUE if self is a default truth value.
Defines name as an arithmetic comparision operation using the
test test-name
. It will take two wrapped number parameters and
return a wrapped number. The code will use the appropriate test
for the specific subtype of wrapped number actually passed in,
and return the appropriate subtype of wrapped number based on the
normal arithmetic contagion rules.
For example, if both input parameters are wrapped integers then the output will be a wrapped integer. If the inputs are a wrapped integer and a wrapped float then the output will be a wrapped float, etc.
Defines name as an arithmetic comparision operation using the
test test-name. It will take two wrapped number parameters and
return a boolean
. The code will use the appropriate test for
the specific subtype of wrapped number actually passed in.
Defines name to be a constraint computation which uses
constraint-test to determine if a fully bound set of variables
satisfies the constraint. The forms in position-computations
are used to compute the value for each of the positions. All such
computations must set the variable value
to be the result
computed for the missing position. Setting value
to null
for
any such computation means that that particular argument cannot
be computed from the others. The input variables in var-list
will be bound to the N arguments to the constraint.
The generated function will return a Stella Object and take as
inputs the values of the N arguments to the constraint. A value
of null
means that the value is not available. If all
arguments are not null
, then the return value will be a Stella
wrapped boolean indicating whether the constraint is satisified
or not.
If more than one input value is null
, then this constraint
code will not be called.
Return a copy of self where all logic objects are
replaced by their generated
parse-tree version. This is useful to
convert the result of a retrieval query into a regular parse tree.
Prints a description of self to stream stream. mode
can be :terse, :verbose, or :source. Used by describe
.
Return the name of the description self.
Return the name of the description self, if it has one.
Return TRUE if self is a description.
Destroy all propositions that reference self,
and mark it as deleted?
, thereby making it invisible within class
extensions.
Destroy self which can be a term or a proposition. Destroy all
propositions that reference self and mark it as deleted?
(thereby
making it invisible within class extensions).
Retract and destroy the proposition proposition. Recursively destroy all propositions that reference proposition. Also, destroy all satellite propositions of proposition.
Destroy all propositions that reference self,
and mark it as deleted?
, thereby making it invisible within class
extensions. Unlink descriptions from native relations.
Return direct super classes/slots of self.
Return true if the STELLA feature is currently disabled.
Return the logical disjunction of truth values tv1 and tv2.
Return TRUE if d1 and d2 belong to disjoint partitions.
Function version of clear-instances
that evaluates its argument.
Save module to the persistent store store which can either be an output stream or a persistent OBJECT-STORE.
Return TRUE if self has zero entries.
Return TRUE if self has length 0.
Return true if the STELLA feature is currently enabled.
Return the estimated length of the sequences in self, which could be too large if some of the members have been deleted.
Evaluate self against its arguments, possibly resulting in the setting or changing of its truth value.
Return :POSTED if proposition is on the evaluation queue for *context*, :EVALUATED if has been evaluated, or NULL if it has never been evaluated.
Record the evaluation state of proposition.
Print an explanation for prop if there is one. This will only happen for forward-chained propositions.
Programmer’s interface to WHY function.
Programmer’s interface to the WHYNOT function.
Return TRUE if self represents some form of falsehood.
Return true if self is false (or default-false if we are considering default assertions).
Fetch a duplicate of prop if defined by store. EXPERIMENTAL! The exact semantics of this still needs to be worked out. This needs to be appropriately specialized on actual OBJECT-STORE implementations.
Fetch the instance identified by name (a string or symbol) from store and return it as an appropriate logic object. This needs to be appropriately specialized on actual OBJECT-STORE implementations.
Fetch the relation identified by name (a string or symbol) from store and return it as a named description. This needs to be appropriately specialized on actual OBJECT-STORE implementations.
Fill the two-dimensional array self in row-major-order from values. Missing values will retain their old values, extraneous values will be ignored.
Fill the two-dimensional array self in row-major-order from values. Missing values will retain their old values, extraneous values will be ignored.
Finalize all currently unfinalized objects.
The user-level entry point for this is (process-definitions)
.
Classify self and return three values, its direct
supers, direct subs, and a list of equivalent descriptions.
Setting supersOnly?
may speed up the computation (perhaps by a lot).
If description
is nameless and has no dependent propositions, then
it is automatically removed from the hierarchy after classification.
Classify self and return a list of most specific named descriptions among all descriptions that it satisfies.
Return the nearest instance with name instanceRef visible from the current module. instanceRef can be a string, symbol, or surrogate. If instanceRef is a surrogate, the search originates in the module the surrogate was interned in.
Search for a rule named ruleName. Like get-rule
,
but find-rule
implicity quotes its input argument.
Return TRUE if relationRef references a function.
Return an s-expression representing the source expression for self.
Method to generate a specialized term for self. This is designed to allow for extension of the term generation code to cover other types of objects for the logic. This particular method will signal an error unless there is a surrogate-value-inverse link set.
Return the nearest class with name instanceRef visible from the current module. instanceRef can be a string, symbol, or surrogate. If instanceRef is a surrogate, the search originates in the module the surrogate was interned in.
Return propositions forward justifications.
Return the nearest instance with name instanceRef visible from the current module. instanceRef can be a string, symbol, or surrogate. If instanceRef is a surrogate, the search originates in the module the surrogate was interned in.
Return a module named moduleRef.
Return the nearest relation with name instanceRef visible from the current module. instanceRef can be a string, symbol, or surrogate. If instanceRef is a surrogate, the search originates in the module the surrogate was interned in.
Used to convert a computation to reference so-called
template
slots rather than own
slots: If instanceRef denotes a class,
return a prototype of that class. Otherwise, return instanceRef.
Return a maximum value for the number of fillers of relation relation (a surrogate) applied to the instance self (an object).
Return a minimum value for the number of fillers of relation relation (a surrogate) applied to the instance self (an object).
Return a single value for the slot relation (a surrogate) applied to self (an object).
Return a most specific type for fillers of the slot relation (a surrogate) applied to self. If there is more than one, pick one.
Return the set of clash exceptions for incoherentProp that are visible from the current context. These are recorded most-recent first in order of occurrance.
Returns the current WHY justification. May also throw one of the following subtypes of EXPLAIN-EXCEPTION: EXPLAIN-NO-QUERY-EXCEPTION EXPLAIN-NO-SOLUTION-EXCEPTION EXPLAIN-NO-MORE-SOLUTIONS-EXCEPTION EXPLAIN-NOT-ENABLED-EXCEPTION EXPLAIN-NO-SUCH-LABEL-EXCEPTION EXPLAIN-QUERY-TRUE-EXCEPTION
Programmer’s interface to WHYNOT function. Derive justifications why query failed, or, if label was supplied as non-NULL, lookup its justification relative to mapping and return the result.
Return TRUE if proposition has any forward justifications.
Return TRUE if we have at least one object store opened/linked into PowerLoom, which changes some index access routines to be considerate of that.
Helper function for print-concept-outline
Helper function for print-concept-outline
Change the current logic dialect to dialect.
Currently supported dialects are KIF
, STELLA
, and PREFIX-STELLA
.
The STELLA dialects are not recommended for the construction of knowledge
bases, they are mainly used internally by PowerLoom.
Return TRUE if self represents INCONSISTENT.
Return true if self is inconsistent (true and false).
Insert value identified by key into self. If a solution with that key already exists, destructively modify it with the slot values of value. This is necessary to preserve the order of solutions in self.
Return the logical negation of self.
Return TRUE if self is a known truth value, that is either TRUE or FALSE, but not UNKNOWN, INCONSISTENT, etc.
Return the number of entries in self.
Return a list containing two lists, a list of currently enabled PowerLoom features, and a list of all available PowerLoom features.
Just like QUERY-ITERATOR.consify
but return a LIST instead.
Loads all PowerLoom files specified on the command line.
If directories are listed, all PowerLoom files in those directories are loaded.
Since when this is called we might still have unprocessed command line args,
this only looks at files which are to the right of the last argument that
starts with a -
character.
Load all PowerLoom files (*.plm) in directory in alphabetic sort order.
Read logic commands from stream and evaluate them.
Read logic commands from stream and evaluate them. If default-module
is not null
, then any commands will be read into that module unless
an in-module
declaration is encountered which will over-ride the default
value. If noe default-module is specified, and the input stream does
not have an in-module
form, an error is signaled.
Return true if proposition’s truth-value has been locally modified in module (initialized, asserted, retracted). This will always succeed for locally conceived propositions regardless of whether their truth value is defined or not.
Return TRUE if the class self or one of its supers supports indices that record extensions referenced by the logic system. Also return true for literal classes.
A sorting predicate for objects o1 and o2 that can appear in logical
forms. Performs a combined numeric and lexocographic sort that accounts
for lists, collections and propositions. Numbers precede all other values,
null
follows all other values.
Return TRUE if self is a logic module, implying
that relations defined within it define a knowledge base. A module
is a logic module iff it inherits the module PL-KERNEL
.
Lookup the solution identified by key in self and return its value, or NULL if no such solution exists.
Returns the native funtion code for native-name if it exists and the underlying programming languages supports such lookups. It is looked up using the signature of a computation function supported by the computation specialist.
Returns the native funtion code for native-name if it exists and the underlying programming languages supports such lookups. Uses the signature of a specialist function.
Merge two truth values that are describing the "same" logical proposition. This handles subordination of default to strict values, known over unknown and potential inconsistent values.
In particular, this can be used to check for negated values by asking for the truth of a proposition and its negation, inverting the negation and then using merge to come up with an answer.
Return TRUE if self is the description of a named class or relation.
True if normalization is governed by natural deduction semantics.
Return TRUE if self has at least 1 entry.
Return TRUE if self has length > 0.
Return the nth solution in self, or NULL if it is empty.
Return the name symbol for the logic object self.
Return the name string for the logic object self.
Return the surrogate naming the object self, which may be a Stella class that is used in PowerLoom as well as a more normal powerloom object.
Return the name of the logic object self to name.
Remove and return the first solution of self or NULL if the table is empty.
Push self onto the evaluation queue (unless it’s already there).
Run the PowerLoom listener. Read logic commands from the
standard input, evaluate them, and print their results. Exit if the user
entered bye
, exit
, halt
, quit
, or stop
.
Exit hook to stop the PowerLoom GUI if it is running.
Returns information about the current PowerLoom implementation. Useful when reporting problems.
Pretty-print the logical form form to stream according
to the current setting of *logic-dialect*
.
Print the array self to stream.
Print the array self to stream.
Print the extension sizes of concepts visible in module. If module is NULL the current module is used. Do not report extensions with size less than sizeCutoff (default is 10).
Like all-facts-of
, but sorts and prints each fact
on a separate line on the standard output stream.
Print stack of goals. Assumes that query has been interrupted with a full stack of control frames.
Print the logical form form to stream according to
the current setting of *logic-dialect*
. Pretty-printing is controlled
by the current setting of *prettyPrintLogicalForms?*
.
Produce a stringified version of a logical representation of self and write it to the stream stream. Use the dialect dialect, or use the current dialect if dialect is NULL.
Print the logical form form to stream according to
the current setting of *logic-dialect*
. Pretty-printing is explicitly
forced to be turned off.
Print a WHYNOT justification to stream according to maxDepth and style. Print a summary only if summary? is TRUE.
Generate a random integer in the interval [0..n-1]. n must be <= 2^15.
Return an iterator that generates all marked objects recorded in self.
Return TRUE if every query records justifications to enable the explanation of concluded results.
Creates a registration entry for name as a computation which executes code. Essentially just builds the Stella meta-information tructure needed to funcall name as a computation function by the computation specialist. The function definition in code needs to accept ARITY Stella OBJECTs as arguments and return a Stella OBJECT suitable for PowerLoom use. (These are generally LOGIC-OBJECTs and the literal wrappers FLOAT-WRAPPER, INTEGER-WRAPPER and STRING-WRAPPER.)
registers a computation function stella-name based on the native-name for the particular programming language in question. Use of this command makes the resulting code or knowledge bases non-portable to other target languages.
Register fn as a logic-object print function for dialect.
Each function should have the signature ((self OBJECT) (stream OUTPUT-STREAM))
.
Any return values will be ignored.
Register store as an active object store.
Creates a registration entry for name as a specialist which executes code. Essentially just builds the Stella meta-information tructure needed to funcall name as a specialist. The function definition in code needs to accept a CONTROL-FRAME and KEYWORD as arguments and return a KEYWORD. Side effects on elements of the proposition in the control frame can be used to bind and thus return values.
registers a specialist function stella-name based on the native-name for the particular programming language in question. Use of this command makes the resulting code or knowledge bases non-portable to other target languages.
Given a relation object, return it’s name.
Return TRUE if objectRef denotes a relation or a class.
Remove the solution identified by key from self. To preserve the solution ordering chain, the solution is marked as deleted and will be completely removed upon the next iteration through self.
Destructively remove all deleted members of self.
Resets the collection of clash exceptions
Zero out all caches managed by the query optimizer, so that it will reoptimize subgoal queries upon next invocation.
Retract all definite (TRUE or FALSE) propositions attached to self.
Partial-match version of retrieve
(which see) that generates scored
partial solutions based on the current partial match strategy. By supplying
BEST
instead of ALL
, or by adding the option :SORT-BY :SCORE
, the generated
solutions will be sorted so that solutions with higher scores come first.
Use the :MATCH-MODE
option to override the global default setting established
by set-partial-match-mode
, e.g., use :MATCH-MODE :NN
to use the neural
net partial match mode. The :MINIMUM-SCORE
option can be used to only
retrieve solutions that have at least the specified minimum match score.
By default, retrieve-partial
does not maximize the match scores of its returned
bindings. To only get maximal scores use :MAXIMIZE-SCORE? TRUE
(this is not
yet implemented - you can use ask-partial
to maximize scores for individual
solutions by hand).
Run forward inference rules in the module defined by the :module option (which defaults to the current module). If forward inferencing is already up-to-date in the designated module, no additional inferencing will occur, unless the :force? option is specified as TRUE, in which case all forward rules are run or rerun. For backwards compatibility, this command also supports the old <module> :force arguments specified with a non-standard keyword notation.
Calling run-forward-rules
temporarily puts the module into a mode where
future assertional (monotonic) updates will trigger additional forward
inference. Once a non-monotonic update is performed, i.e., a retraction
or clipping of relation value, all cached forward inferences will be discarded
and forward inferencing will be disabled until this function is called again.
Run the PowerLoom test suite. Currently this simply runs all demos and echos commands and their results to standard output. The output can then be diffed with previously validated runs to find deviations.
Try to prove whether instanceOrTuple satisfies the definition of the relation relationRef and return the result truth value of the query. instanceOrTuple can be a single object, the name or surrogate of an object, or a collection (a list or vector) of objects. relationRef can be a relation, description, surrogate or relation name.
Save all neural networks to file (if file is non-NULL).
If networks are saved periodically (see set-save-network-cycle
) this file
name will be used to perform periodic saves.
Helping function for specialists. Return the appropriate keyword indicating success or failure of a proof.
Helping function for specialists testing the validity of a
fully bound inference frame. Based on the test result success?
and reversePolarity?*
, set the truth value of frame and return
an appropriate keyword. The keyword will be either :final-success
:terminal-failure
if terminal? is true. Otherwise it will be
:final-success
or :failure
.
Set number of cycles between which error rates are saved to
the file established by the last call to save-all-neural-networks
appended
with extension .err
. A number <= 0 (or NULL) turns off periodic saving.
Set the inference level of module to the level specified
by levelKeyword
. If module is NULL, set the level globally.
Record membership of object in the marker storage object self.
Sets the number of nearest neighbors to predict from.
Sets the number of training examples for each case in the training set.
Enable the PowerLoom environment feature feature.
Set number of cycles between which networks are saved to the
file established by the last call to save-all-neural-networks
. A number <= 0
or a NULL number turns off periodic saving.
Similar to copy
but does not copy antecedent justifications.
Perform a stable, destructive sort of self according to
predicate, and return the result. If predicate has a <
semantics, the
result will be in ascending order.
Try to prove if the description associated with subObject specializes the description for superObject and return the result truth value of the query.
Start the PowerLoom HTTP server at :port (defaults to 9090). Loads the required support systems in Lisp and Java if necessary (C++ is not yet supported).
Start the PowerLoom server at :port (defaults to 9090) and launches
the GUI which will communicate with the server at that port. If :host is specified,
the GUI will try to communicate with a server at host:port
instead of the local
embedded server (note, you can always point the GUI manually to a different server
from its Connect to Server
menu item). Loads the required support systems if necessary.
Embedded calls to the GUI are currently only supported in Java; however, when the GUI is
run in standalone mode, it can communicate with any PowerLoom installation that supports
an HTTP server (currently Lisp and Java).
Start the PowerLoom HTTP server at :port (defaults to 9090). Loads the required support systems in Lisp and Java if necessary (C++ is not yet supported).
Stop the PowerLoom HTTP server and free up any bound ports. This is a no-op if no server is running or the server is not supported.
Closes the PowerLoom GUI application if it is currently visible. This is a no-op if the GUI is not running or if it is not supported.
Stop the PowerLoom HTTP server and free up any bound ports. This is a no-op if no server is running or the server is not supported.
If tv2 has greater strength than tv1, adapt the strength of tv1 (not its value!) and return the result. Otherwise, return tv1 unmodified.
Return TRUE if self is a strict truth value.
Compare the two truth values and return true
if tv1 is strictly
stronger than tv2. Stronger uses the following partial order:
INCONSISTENT > STRICT > DEFAULT > UNKNOWN.
Truth values at the same level are equal in strength.
Convert self into an equivalent PowerLoom object that can be passed as an argument wherever an instance is expected.
Return TRUE if relation (a surrogate) is asserted to be closed or if the current module closes all relations.
Return TRUE if relation (a surrogate) is a function.
Return TRUE if object is stored (marked) in self.
Return TRUE if relation (a surrogate) is TRUE when applied to arguments.
Return TRUE if the proposition (<relation> <self> <filler>)
is true.
Return TRUE if the object self is stored (marked)
in the table pointed at by the special variable *specialMarkerTable*.
Designed for use by remove-if
.
Return TRUE if subrelation specializes superrelation.
Return TRUE if self satisfies type.
Translate the Loom file input to PowerLoom and write the translation to the file output. Note that this will only work for fairly vanilla Loom files that do not contain any Lisp-isms. It might require to clean the Loom file manually before this translation will work.
Return TRUE if self represents some form of truth.
Return true if self is true (or default-true if we are considering default assertions).
Retract the truth, falsity or inconsistency of proposition. This is a
more general version of retract
that also handles falsity. For example, if
we assert the proposition "(not (sad Fred))", and then execute the statement
"(unassert (sad Fred))", the truth value of the proposition "(sad Fred)"
will be set to UNKNOWN. If we had called retract
in place of unassert
,
the proposition "(sad Fred)" would remain set to FALSE. Note that for this
unassertion to succeed, the logic constant Fred
and the relation sad
must
already be defined.
Retract the truth, falsity or inconsistency of the proposition self.
Return TRUE if self represents UNKNOWN.
Return true if the truth of self is unknown.
Return TRUE if self is an unnamed description.
Remove store from the list of active object stores.
Disable the PowerLoom environment feature feature.
Classify all named descriptions.
Classify all named instances.
Classify instances local to module and inherited by module. If local?, don’t classify inherited descriptions. If module is NULL, classify descriptions in all modules.
Classify named descriptions local to module and inherited by module. If local?, don’t classify inherited descriptions. If module is NULL, classify descriptions in all modules.
A module with store has had the truth value of proposition change according to update-mode. The default method does nothing.
Assert or retract a proposition that applies relation to arguments.
If tv2 has lesser strength than tv1, adapt the strength of tv1 (not its value!) and return the result. Otherwise, return tv1 unmodified.
Execute body within the module resulting from moduleForm.
*module*
is an acceptable moduleForm. It will locally rebind
*module*
and *context*
and shield the outer bindings from changes.
Used during classification. Execute body within the indicated classification session and inference world.
Execute body within the meta cache of the current module. Set appropriate special variables.
Returns the Stella keyword name, creating it if necessary. name is treated case-sensitively. This should generally not be necessary to do.
Returns the Stella symbol name visible in module, creating it if necessary. name is ALWAYS treated case-sensitively, even if module is case insensitive. This should generally not be necessary to do.
Return inconsistent propositions visible in module.
Returns the Stella KEYWORD name if it exists. Case sensitive.
Return the name, qualified as necessary, so that obj can be found from
module. If there is no name for the object return null
.
Return the short name of obj, if it has one. Otherwise return null
.
Returns the Stella SYMBOL name visible in module if it exists. name is ALWAYS treated case sensitively.
Return relations that have been referenced but not defined in module.
Tests whether tv is a known truth value (i.e., true or false).
Return TRUE if a proposition (relation
args
) has
been asserted (or inferred by forward chaining).
Read logic commands from the file named filename and evaluate them.
If the file does not have an in-module
declaration that specifies the module
within which all remaining commands are to be evaluated, it will be loaded
in the module specified. If no module is specified and the file does
not contain an in-module
declaration, an error will be signaled.
The remaining commands are evaluated one-by-one, applying the function
evaluate
to each of them.
Read logic commands from the native input stream stream and evaluate them.
Assumes stream is a line-buffered stream which is a safe compromise but does
not generate the best efficiency for block-buffered streams such as files.
If the stream does not supply an in-module
declaration that specifies the
module within which all remaining commands are to be evaluated, it will be
loaded in the module specified. If no module is specified and the file
does not supply an in-module
declaration, an error will be signaled.
The remaining commands are evaluated one-by-one, applying the function
evaluate
to each of them.
Read logic commands from the STELLA stream stream and evaluate them.
If the stream does not supply an in-module
declaration that specifies the
module within which all remaining commands are to be evaluated, it will be
loaded in the module specified. If no module is specified and the file
does not supply an in-module
declaration, an error will be signaled.
The remaining commands are evaluated one-by-one, applying the function
evaluate
to each of them.
Register name as a function name in module which will invoke the
native code procedure described by function-reference.
The name
is a fully-qualified name which will be interpreted by the normal
rules for reading names in PowerLoom. The function must conform
to the signature for computation functions used by the computation
specialist. Arity specifies the number of arguments the computation
accepts.
The exact form of function-reference depends on the underlying programming language. The following type mappings are used: C++: cpp_function_code (a pointer to the function code) Common Lisp: FUNCTION (result of #’ or (FUNCTION ...)) Java: java.lang.reflect.Method
Register name as a function name in module which will invoke the
native code procedure described by function-reference.
The name
is a fully-qualified name which will be interpreted by the normal
rules for reading names in PowerLoom. The function must conform
to the signature for specialist functions.
The exact form of function-reference depends on the underlying programming language. The following type mappings are used: C++: Common Lisp: FUNCTION (result of #’ or (FUNCTION ...)) Java: java.lang.reflect.Method
Register name as a function name in the module named module-name. This function will the native code named native-name. The name is a fully-qualified name which will be interpreted by the normal rules for reading names in PowerLoom. The native-name will be processed in a manner that depends on the underlying programming language. The following type mappings are used: C++: Not available. Error signaled. Common Lisp: The native-name is read by READ-FROM-STRING and then the SYMBOL-FUNCTION is taken. Java: A fully package-qualified name is required. It is looked up using the Reflection tools. The function found must conform to the signature for computation functions. Arity specifies the number of arguments the computation accepts.
Register name as a function name in the module named module-name. This function will the native code named native-name. The name is a fully-qualified name which will be interpreted by the normal rules for reading names in PowerLoom. The native-name will be processed in a manner that depends on the underlying programming language. The following type mappings are used: C++: Not available. Error signaled. Common Lisp: The native-name is read by READ-FROM-STRING and then the SYMBOL-FUNCTION is taken. Java: A fully package-qualified name is required. It is looked up using the Reflection tools. The function found must conform to the signature for specialist functions.
Test if env has level set to level
Convert self into a Stella CONS.
Convert self into a Stella LIST.
Bootstrap the PowerLoom built-in kernel KB.
[ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by Hans Chalupsky on May 1, 2014 using texi2html 1.82.