The arguments of the context branch context, with the arguments supporting them (Argument.supports), identified as A0, A1, ... in order of their number of supporters, rules, conclusion and top rule

arithEq

open infix fun Any.arithEq(right: Any): Struct

arithNeq

open infix fun Any.arithNeq(right: Any): Struct

assert

open fun assert(clause: Any): Struct

assertA

abstract fun assertA(clause: Clause)

abstract fun assertA(fact: Struct)

asserta

open fun asserta(clause: Any): Struct

assertZ

abstract fun assertZ(clause: Clause)

abstract fun assertZ(fact: Struct)

assertz

open fun assertz(clause: Any): Struct

at_end_of_stream

open fun at_end_of_stream(alias: Any): Struct

atom

open fun atom(atom: Any): Struct

atom_chars

open fun atom_chars(atom: Any, chars: Any): Struct

atom_codes

open fun atom_codes(atom: Any, codes: Any): Struct

atom_concat

open fun atom_concat(first: Any, second: Any, result: Any): Struct

atom_length

open fun atom_length(atom: Any, length: Any): Struct

atomic

open fun atomic(atomic: Any): Struct

atomOf

abstract fun atomOf(value: Char): Atom

abstract fun atomOf(value: String): Atom

attacks

fun Solver.attacks(context: Int, arguments: List<Argument>): List<Attack>

The attacks between arguments in the context branch context

bagof

open fun bagof(template: Any, goal: Any, bag: Any): Struct

between

open fun between(min: Any, max: Any, number: Any): Struct

blockOf

abstract fun blockOf(terms: Iterable<Term>): Block

abstract fun blockOf(terms: Sequence<Term>): Block

abstract fun blockOf(vararg terms: Term): Block

open fun blockOf(vararg terms: Any): Block

call

open infix fun Any.call(other: Any): Struct

open fun call(goal: Any): Struct

callable

open fun callable(goal: Any): Struct

catch

open fun catch(goal: Any, error: Any, continuation: Any): Struct

char_code

open fun char_code(char: Any, code: Any): Struct

clause

open fun clause(head: Any, body: Any): Struct

open fun clause(function: LogicProgrammingScope.() -> Any): Clause

clauseOf

abstract fun clauseOf(head: Struct?, vararg body: Term): Clause

clone

abstract override fun clone(): MutableSolver

compound

open fun compound(struct: Any): Struct

consOf

abstract fun consOf(head: Term, tail: Term): Cons

open fun consOf(head: Any, tail: Any): Cons

consult

open fun consult(url: Any): Struct

contains

abstract operator fun contains(variable: Var): Boolean

abstract operator fun contains(variable: String): Boolean

open operator fun Substitution.contains(term: Any): Boolean

containsKey

open fun Substitution.containsKey(term: Any): Boolean

containsValue

open fun Substitution.containsValue(term: Any): Boolean

copy

abstract override fun copy(scope: Scope): LogicProgrammingScope

abstract fun copy(unificator: Unificator): LogicProgrammingScope

abstract override fun copy(unificator: Unificator, libraries: Runtime, flags: FlagStore, staticKb: Theory, dynamicKb: Theory, stdIn: InputChannel<String>, stdOut: OutputChannel<String>, stdErr: OutputChannel<String>, warnings: OutputChannel<Warning>): MutableSolver

copy_term

open fun copy_term(term: Any, copy: Any): Struct

current_flag

open fun current_flag(name: Any, value: Any): Struct

current_op

open fun current_op(precedence: Any, specifier: Any, functor: Any): Struct

current_prolog_flag

open fun ~~current_prolog_flag~~(name: Any, value: Any): Struct

directive

open fun directive(function: LogicProgrammingScope.() -> Any): Directive

directiveOf

abstract fun directiveOf(body1: Term, vararg body: Term): Directive

open fun directiveOf(term: Any, vararg terms: Any): Directive

div

open operator fun Term.div(other: Any): Indicator

open operator fun Boolean.div(other: Any): Struct

open operator fun Char.div(other: Any): Struct

open operator fun Number.div(other: Any): Struct

open operator fun String.div(other: Any): Struct

dynamic

open fun dynamic(indicator: Any): Struct

dynamicKb

open fun dynamicKb(theory: Theory)

open fun dynamicKb(clauses: Iterable<Clause>)

open fun dynamicKb(clauses: Sequence<Clause>)

open fun dynamicKb(vararg clauses: Clause)

emptyMutableTheory

open fun emptyMutableTheory(): MutableTheory

abstract fun emptyMutableTheory(unificator: Unificator): MutableTheory

emptyTheory

open fun emptyTheory(): Theory

abstract fun emptyTheory(unificator: Unificator): Theory

open infix fun Any.eq(right: Any): Struct

equalsTo

open infix fun Any.equalsTo(other: Any): Struct

fact

open fun fact(function: LogicProgrammingScope.() -> Any): Fact

factOf

abstract fun factOf(head: Struct): Fact

open fun factOf(term: Any): Fact

findall

open fun findall(template: Any, goal: Any, bag: Any): Struct

float

open fun float(number: Any): Struct

functor

open fun functor(struct: Any, functor: Any, arity: Any): Struct

get

abstract operator fun get(variable: String): Var?

open operator fun Substitution.get(term: Any): Term?

getValue

abstract operator fun getValue(thisRef: Any?, property: KProperty<*>): Var

graph

fun Solver.graph(): Graph

The graph of the active context branch

fun Solver.graph(context: Int): Graph

The graph of the context branch context: its arguments, labelled, their attacks and supports

greaterThan

open infix fun Any.greaterThan(other: Any): Struct

greaterThanOrEqualsTo

open infix fun Any.greaterThanOrEqualsTo(other: Any): Struct

ground

open fun ground(term: Any): Struct

open infix fun Any.id(right: Any): Struct

open infix fun Any.if(other: Any): Rule

open fun Any.if(vararg other: Any): Rule

impliedBy

open infix fun Any.impliedBy(other: Any): Rule

open fun Any.impliedBy(vararg other: Any): Rule

include

open fun include(url: Any): Struct

indicatorOf

abstract fun indicatorOf(name: Term, arity: Term): Indicator

abstract fun indicatorOf(name: String, arity: Int): Indicator

initialization

open fun initialization(goal: Any): Struct

intDiv

open infix fun Any.intDiv(other: Any): Struct

integer

open fun integer(number: Any): Struct

intOf

abstract fun intOf(value: Byte): Integer

abstract fun intOf(value: Int): Integer

abstract fun intOf(value: Long): Integer

abstract fun intOf(value: Short): Integer

abstract fun intOf(value: String): Integer

abstract fun intOf(value: BigInteger): Integer

abstract fun intOf(value: String, radix: Int): Integer

invoke

open operator fun String.invoke(term: Any, vararg terms: Any): Struct

open infix fun Any.is(other: Any): Struct

labels

fun Solver.labels(context: Int, arguments: List<Argument>): List<LabelledArgument>

arguments with their labels in the context branch context (na, when an argument has none)

load

open fun load(url: Any): Struct

loadDynamicClauses

open fun loadDynamicClauses(clauses: Iterable<Clause>)

open fun loadDynamicClauses(clauses: Sequence<Clause>)

open fun loadDynamicClauses(vararg clauses: Clause)

loadDynamicKb

abstract fun loadDynamicKb(theory: Theory)

loadLibrary

abstract fun loadLibrary(library: Library)

loadStaticClauses

open fun loadStaticClauses(clauses: Iterable<Clause>)

open fun loadStaticClauses(clauses: Sequence<Clause>)

open fun loadStaticClauses(vararg clauses: Clause)

loadStaticKb

abstract fun loadStaticKb(theory: Theory)

logicList

open fun logicList(vararg items: Any, tail: Any?): List

logicListFrom

abstract fun logicListFrom(terms: Iterable<Term>, last: Term?): List

abstract fun logicListFrom(terms: Sequence<Term>, last: Term?): List

abstract fun logicListFrom(vararg terms: Term, last: Term?): List

logicListOf

abstract fun logicListOf(terms: Iterable<Term>): List

abstract fun logicListOf(terms: Sequence<Term>): List

abstract fun logicListOf(vararg terms: Term): List

open fun logicListOf(vararg terms: Any): List

lowerThan

open infix fun Any.lowerThan(other: Any): Struct

lowerThanOrEqualsTo

open infix fun Any.lowerThanOrEqualsTo(other: Any): Struct

match

open fun match(term1: Any, term2: Any, occurCheckEnabled: Boolean): Boolean

open fun match(term1: Term, term2: Term): Boolean

open fun match(term1: Term, term2: Term, occurCheckEnabled: Boolean): Boolean

matches

open infix fun Any.matches(other: Any): Boolean

member

open fun member(item: Any, list: Any): Struct

merge

open fun merge(substitution1: Substitution, substitution2: Substitution): Substitution

abstract fun merge(substitution1: Substitution, substitution2: Substitution, occurCheckEnabled: Boolean): Substitution

mgu

open fun mgu(term1: Any, term2: Any, occurCheckEnabled: Boolean): Substitution

open fun mgu(term1: Term, term2: Term): Substitution

abstract fun mgu(term1: Term, term2: Term, occurCheckEnabled: Boolean): Substitution

mguWith

open infix fun Any.mguWith(other: Any): Substitution

minus

open operator fun Term.minus(other: Any): Struct

open operator fun Boolean.minus(other: Any): Struct

open operator fun Char.minus(other: Any): Struct

open operator fun Number.minus(other: Any): Struct

open operator fun String.minus(other: Any): Struct

mutableTheory

open fun mutableTheory(vararg clauseFunctions: LogicProgrammingScope.() -> Any): MutableTheory

mutableTheoryOf

open fun mutableTheoryOf(clauses: Iterable<Clause>, vararg otherClauses: Iterable<Clause>): MutableTheory

open fun mutableTheoryOf(clauses: Sequence<Clause>, vararg otherClauses: Sequence<Clause>): MutableTheory

open fun mutableTheoryOf(clauses: Iterable<Clause>): MutableTheory

open fun mutableTheoryOf(clauses: Sequence<Clause>): MutableTheory

open fun mutableTheoryOf(vararg clauses: Clause): MutableTheory

abstract fun mutableTheoryOf(unificator: Unificator, vararg clauses: Clause): MutableTheory

abstract fun mutableTheoryOf(clauses: Iterable<Clause>, unificator: Unificator): MutableTheory

abstract fun mutableTheoryOf(clauses: Sequence<Clause>, unificator: Unificator): MutableTheory

naf

open fun naf(goal: Any): Struct

natural

open fun natural(number: Any): Struct

neq

open infix fun Any.neq(right: Any): Struct

newScope

abstract fun newScope(): LogicProgrammingScope

nid

open infix fun Any.nid(right: Any): Struct

nonGreaterThan

open infix fun Any.nonGreaterThan(other: Any): Struct

nonLowerThan

open infix fun Any.nonLowerThan(other: Any): Struct

nonvar

open fun nonvar(number: Any): Struct

not

open fun not(goal: Any): Struct

notEqualsTo

open infix fun Any.notEqualsTo(other: Any): Struct

number

open fun number(number: Any): Struct

number_chars

open fun number_chars(first: Any, second: Any): Struct

number_codes

open fun number_codes(first: Any, second: Any): Struct

numOf

abstract fun numOf(value: Byte): Integer

abstract fun numOf(value: Double): Real

abstract fun numOf(value: Float): Real

abstract fun numOf(value: Int): Integer

abstract fun numOf(value: Long): Integer

abstract fun numOf(value: Number): Numeric

abstract fun numOf(value: Short): Integer

abstract fun numOf(value: String): Numeric

abstract fun numOf(value: BigDecimal): Real

abstract fun numOf(value: BigInteger): Integer

open fun op(precedence: Any, specifier: Any, functor: Any): Struct

open infix fun Any.or(other: Any): Struct

plus

open operator fun Term.plus(other: Any): Struct

open operator fun Boolean.plus(other: Any): Struct

open operator fun Char.plus(other: Any): Struct

open operator fun Number.plus(other: Any): Struct

pow

open infix fun Any.pow(other: Any): Struct

realOf

abstract fun realOf(value: Double): Real

abstract fun realOf(value: Float): Real

abstract fun realOf(value: String): Real

abstract fun realOf(value: BigDecimal): Real

rem

open infix operator fun Term.rem(other: Any): Struct

open infix operator fun Boolean.rem(other: Any): Struct

open infix operator fun Char.rem(other: Any): Struct

open infix operator fun Number.rem(other: Any): Struct

open infix operator fun String.rem(other: Any): Struct

resetDynamicKb

abstract fun resetDynamicKb()

resetStaticKb

abstract fun resetStaticKb()

retract

open fun retract(clause: Any): Struct

abstract fun retract(clause: Clause): RetractResult<Theory>

abstract fun retract(fact: Struct): RetractResult<Theory>

retractAll

abstract fun retractAll(clause: Clause): RetractResult<Theory>

abstract fun retractAll(fact: Struct): RetractResult<Theory>

retractall

open fun retractall(clause: Any): Struct

rule

open fun rule(function: LogicProgrammingScope.() -> Any): Rule

ruleOf

abstract fun ruleOf(head: Struct, body1: Term, vararg body: Term): Rule

scope

open fun <R> scope(function: LogicProgrammingScope.() -> R): R

set_flag

open fun set_flag(name: Any, value: Any): Struct

set_prolog_flag

open fun ~~set_prolog_flag~~(name: Any, value: Any): Struct

setFlag

abstract fun setFlag(flag: NotableFlag)

abstract fun setFlag(flag: Pair<String, Term>)

abstract fun setFlag(name: String, value: Term)

setof

open fun setof(template: Any, goal: Any, bag: Any): Struct

setRuntime

abstract fun setRuntime(libraries: Runtime)

setStandardError

abstract fun setStandardError(stdErr: OutputChannel<String>)

setStandardInput

abstract fun setStandardInput(stdIn: InputChannel<String>)

setStandardOutput

abstract fun setStandardOutput(stdOut: OutputChannel<String>)

setWarnings

abstract fun setWarnings(warnings: OutputChannel<Warning>)

solve

open fun solve(goal: Any): Struct

open fun solve(goal: Struct): Sequence<Solution>

abstract fun solve(goal: Struct, options: SolveOptions): Sequence<Solution>

open fun solve(goal: Struct, timeout: TimeDuration): Sequence<Solution>

solveForCaller

fun Solver.solveForCaller(goal: Struct, options: SolveOptions): Sequence<Solution>

Solves goal on behalf of a primitive, whose caller needs the bindings of all the variables of the goal.

solveList

open fun solveList(goal: Struct): List<Solution>

open fun solveList(goal: Struct, options: SolveOptions): List<Solution>

open fun solveList(goal: Struct, timeout: TimeDuration): List<Solution>

solveOnce

open fun solveOnce(goal: Struct): Solution

open fun solveOnce(goal: Struct, options: SolveOptions): Solution

open fun solveOnce(goal: Struct, timeout: TimeDuration): Solution

solverOf

open fun solverOf(unificator: Unificator, otherLibraries: Runtime, flags: FlagStore, staticKb: Theory, dynamicKb: Theory, stdIn: InputChannel<String>, stdOut: OutputChannel<String>, stdErr: OutputChannel<String>, warnings: OutputChannel<Warning>): MutableSolver

static