solve-problog/it.unibo.tuprolog.solve.problog.lib.knowledge/MutableProblogTheory

MutableProblogTheory

interface MutableProblogTheory : ProblogTheory, MutableTheory

Represents a logic Theory suitable for the representation of probabilistic logic clauses using Problog's notation, in which the probability is annotated on clauses and facts. Instances of this interface must be mutable.

This is the mutable counterpart of ProblogTheory: see that interface's documentation for how ProbLog's annotated clauses, facts and evidence are represented and rewritten internally. Every assertA/assertZ/ retract/retractAll/abolish operation here applies the same clause-mapping logic to newly-added or removed clauses.

Author

Jason Dellaluce

Types

object Companion

Properties

abstract val clauses: Iterable<Clause>

open val directives: Iterable<Directive>

abstract val isEmpty: Boolean

open override val isMutable: Boolean

abstract val isNonEmpty: Boolean

open val rules: Iterable<Rule>

abstract val size: Long

abstract val tags: Map<String, Any>

abstract val unificator: Unificator

Functions

abstract override fun abolish(indicator: Indicator): MutableProblogTheory

abstract override fun assertA(clause: Clause): MutableProblogTheory

open override fun assertA(struct: Struct): MutableProblogTheory

abstract override fun assertA(clauses: Iterable<Clause>): MutableProblogTheory

abstract override fun assertA(clauses: Sequence<Clause>): MutableProblogTheory

abstract override fun assertZ(clause: Clause): MutableProblogTheory

open override fun assertZ(struct: Struct): MutableProblogTheory

abstract override fun assertZ(clauses: Iterable<Clause>): MutableProblogTheory

abstract override fun assertZ(clauses: Sequence<Clause>): MutableProblogTheory

abstract fun clone(): MutableTheory

abstract operator fun contains(clause: Clause): Boolean

abstract operator fun contains(indicator: Indicator): Boolean

abstract operator fun contains(head: Struct): Boolean

open fun containsTag(name: String): Boolean

abstract fun equals(other: Theory, useVarCompleteName: Boolean): Boolean

abstract operator fun get(clause: Clause): Sequence<Clause>

abstract operator fun get(indicator: Indicator): Sequence<Rule>

abstract operator fun get(head: Struct): Sequence<Rule>

open fun <T : Any> getTag(name: String): T?

abstract operator fun iterator(): Iterator<Clause>

open operator override fun plus(clause: Clause): MutableProblogTheory

abstract operator override fun plus(theory: ProblogTheory): MutableProblogTheory

abstract operator override fun plus(theory: Theory): MutableProblogTheory

abstract fun replaceTags(tags: Map<String, Any>): MutableTheory

abstract override fun retract(clause: Clause): RetractResult<MutableProblogTheory>

open override fun retract(head: Struct): RetractResult<MutableProblogTheory>

abstract override fun retract(clauses: Iterable<Clause>): RetractResult<MutableProblogTheory>

abstract override fun retract(clauses: Sequence<Clause>): RetractResult<MutableProblogTheory>

abstract override fun retractAll(clause: Clause): RetractResult<MutableProblogTheory>

open override fun retractAll(head: Struct): RetractResult<MutableProblogTheory>

abstract fun setUnificator(unificator: Unificator): MutableTheory

toImmutableTheory

open override fun toImmutableTheory(): ProblogTheory

toMutableTheory

open override fun toMutableTheory(): MutableProblogTheory

abstract fun toString(asPrologText: Boolean): String