dymokomi/luce-prism
Source of release 0.6.0
0.6.0 / src / logic / api.lucb
## A solved, owned theory can answer many queries without grounding it again.
import interop
import memory
import logic.theory as grounding
import logic.solver
import logic.builders
import collections.sort as sorting
from logic.atoms import Atom, ProofTag
from document import Document, own_document, snapshot_document
from model import DocumentData
from authoring.paths import Paths, own_paths
from authoring.names import unique_path
from collections.index import Index
from storage import List
from path import joined
import strings
pub struct Justification:
var fired: Paths
var defeated: Paths
pub func init():
return
pub func fired_count() -> usize:
return self.fired.count()
pub func fired_at(index: usize) -> str!:
return try self.fired.at(index)
pub func defeated_count() -> usize:
return self.defeated.count()
pub func defeated_at(index: usize) -> str!:
return try self.defeated.at(index)
pub func close():
self.fired.close()
self.defeated.close()
pub let justification_type = interop.Type[Justification]("Prism logic justification", Justification.close, closeable = true)
func ordered_names(index: const Index*, result: Paths*) -> !:
var names: List[str]
defer names.close()
for bucket in index.buckets.span():
try names.push(bucket.key.view())
sorting.text(names.span())
for name in names.span():
try result.append(name)
pub struct Logic:
var theory: grounding.Theory
pub func init(document: interop.Reference[Document]) -> !:
var snap = try snapshot_document(try document.get())
defer snap.close()
self.theory = try grounding.build(&snap)
solver.solve(&self.theory)
pub func conclude(atom: interop.Reference[Atom]) -> ProofTag!:
var key = try (try atom.get()).view_data().key()
defer key.close()
let index = self.theory.find(key.view()) else return ProofTag.defeasible_refute
return solver.tag(&self.theory, index)
pub func why(atom: interop.Reference[Atom]) -> interop.Reference[Justification]!:
var result = Justification()
errdefer result.close()
var key = try (try atom.get()).view_data().key()
defer key.close()
if let index = self.theory.find(key.view()):
let literal = &self.theory.literals.items[index]
var fired: Index
defer fired.close()
var defeated: Index
defer defeated.close()
for id in literal.supporters.span():
let rule = &self.theory.rules.items[id]
if solver.applicable(&self.theory, rule):
_ = try fired.add(self.theory.names.buckets.items[rule.name].key.view(), rule.name)
for id in self.theory.literals.items[literal.complement].rules.span():
let rule = &self.theory.rules.items[id]
if solver.discarded(&self.theory, rule):
continue
for bucket in fired.buckets.span():
if self.theory.superior(bucket.rows.items[0], rule.name):
_ = try defeated.add(self.theory.names.buckets.items[rule.name].key.view(), rule.name)
break
try ordered_names(&fired, &result.fired)
try ordered_names(&defeated, &result.defeated)
let owned = try new Justification() in memory.heap
owned[0] = result
result = Justification()
return try interop.Reference[Justification].adopt(owned, justification_type, memory.heap)
pub func close():
self.theory.close()
pub let logic_type = interop.Type[Logic]("Prism logic theory", Logic.close, closeable = true)
pub func conclude(document: interop.Reference[Document], atom: interop.Reference[Atom]) -> ProofTag!:
var logic = try Logic(document)
defer logic.close()
return try logic.conclude(atom)
pub func why(document: interop.Reference[Document], atom: interop.Reference[Atom]) -> interop.Reference[Justification]!:
var logic = try Logic(document)
defer logic.close()
return try logic.why(atom)
pub func derive(document: interop.Reference[Document]) -> interop.Reference[Document]!:
var logic = try Logic(document)
defer logic.close()
var result = try snapshot_document(try document.get())
errdefer result.close()
var root = try unique_path(&result, "/derived")
defer root.close()
try result.insert(root.view(), "group")
var count: usize = 0
for id in logic.theory.order.span():
let literal = &logic.theory.literals.items[id]
if not literal.proof or literal.fact:
continue
var scratch: u8[32]
var path = try joined(root.view(), try strings.format(scratch, f"[{count}]"))
defer path.close()
try builders.build_atom(&result, path.view(), &literal.atom, "derived", "+∂")
count += 1
let owned = result
result = DocumentData()
return try own_document(owned)