dymokomi/luce-prism
Source of release 0.6.0
0.6.0 / tests / compatibility / logic.lucb
from luce_prism import prism
import interop
import memory
pub func atom(predicate: str, args: const str[], negative: bool = false, variables: bool = false) -> interop.Reference[prism.Atom]!:
let result = try interop.Reference[prism.Atom].adopt(try new prism.Atom(predicate, negative) in memory.heap, prism.atom_type, memory.heap)
errdefer result.release()
for arg in args:
if variables:
try result.value().variable(arg)
else:
try result.value().constant(arg)
return result
pub func policy() -> interop.Reference[prism.Document]!:
let doc = try prism.Document.parse("#prisma 4.0\n")
errdefer doc.release()
let statements: str[9] = ["employee(alice)", "contractor(bob)", "document(q3plan)", "confidential(q3plan)", "employee(U), document(D) => can_view(U, D)", "contractor(U), document(D) => -can_view(U, D)", "confidential(D), document(D) => -can_view(U, D)", "owns(U, D) -> can_view(U, D)", "p3 > p1"]
let names: str[9] = ["f1", "f2", "f3", "f4", "p1", "p2", "p3", "p4", "sup_conf"]
for i in 0..<(usize)9:
try doc.value().compile_logic(names[i], statements[i])
return doc
pub func clearance() -> interop.Reference[prism.Document]!:
return try prism.parse_surface("logic \"f5\" { cleared(alice) } logic \"p5\" { cleared(U), confidential(D), document(D) => can_view(U, D) } logic \"sup_clear\" { p5 > p3 }")
pub func view(doc: interop.Reference[prism.Document], person: str, negative: bool = false) -> prism.ProofTag!:
let args: str[2] = [person, "q3plan"]
let query = try atom("can_view", args, negative)
defer query.release()
return try prism.conclude(doc, query)
func structured_rule_round_trips_to_the_canonical_form() -> !:
let doc = try prism.Document.parse("#prisma 4.0\n")
defer doc.release()
let head_args: str[2] = ["U", "D"]
let head = try atom("can_view", head_args, variables = true)
defer head.release()
let first_args: str[1] = ["U"]
let second_args: str[1] = ["D"]
let first = try atom("employee", first_args, variables = true)
defer first.release()
let second = try atom("document", second_args, variables = true)
defer second.release()
let body = try interop.Reference[prism.Atoms].adopt(try new prism.Atoms() in memory.heap, prism.atoms_type, memory.heap)
defer body.release()
try body.value().append(first)
try body.value().append(second)
try doc.value().add_rule("p1", prism.RuleKind.defeasible, head, body)
assert(try doc.value().type_at("/p1") == "defeasible")
assert(try doc.value().type_at("/p1/head") == "atom")
assert(try doc.value().type_at("/p1/head/[0]") == "var")
assert(doc.value().child_count("/p1") == 3)
let bytes = try doc.value().encode()
defer bytes.release()
let decoded = try prism.Document.decode(bytes.value().bytes())
defer decoded.release()
assert(try decoded.value().equals(doc))
func base_policy_blocks_employee_on_confidential_doc() -> !:
let doc = try policy()
defer doc.release()
assert(try view(doc, "alice") == prism.ProofTag.defeasible_refute)
assert(try view(doc, "bob") == prism.ProofTag.defeasible_refute)
assert(try view(doc, "alice", true) == prism.ProofTag.defeasible_proof)
func a_clearance_layer_defeats_the_confidentiality_block() -> !:
let base = try policy()
defer base.release()
let layer = try clearance()
defer layer.release()
let doc = try base.value().overlay(layer)
defer doc.release()
assert(try view(doc, "alice") == prism.ProofTag.defeasible_proof)
assert(try view(doc, "bob") == prism.ProofTag.defeasible_refute)
let args: str[2] = ["alice", "q3plan"]
let query = try atom("can_view", args)
defer query.release()
let why = try prism.why(doc, query)
defer why.release()
var fired = false
var defeated = false
for i in 0..<why.value().fired_count():
fired = fired or try why.value().fired_at(i) == "p5"
for i in 0..<why.value().defeated_count():
defeated = defeated or try why.value().defeated_at(i) == "p3"
assert(fired and defeated)
func retracting_the_clearance_rule_reverts_the_conclusion() -> !:
let base = try policy()
defer base.release()
let layer = try clearance()
defer layer.release()
let doc = try base.value().overlay(layer)
defer doc.release()
let revoke = try prism.Document.parse("#prisma 4.0\ndelete \"/p5\"")
defer revoke.release()
let reverted = try doc.value().overlay(revoke)
defer reverted.release()
assert(try view(reverted, "alice") == prism.ProofTag.defeasible_refute)
func strict_rule_yields_a_definite_conclusion() -> !:
let doc = try prism.parse_surface("logic \"f\" { owns(alice, q3plan) } logic \"r\" { owns(U, D) -> can_view(U, D) }")
defer doc.release()
assert(try view(doc, "alice") == prism.ProofTag.definite_proof)
assert(try view(doc, "alice", true) == prism.ProofTag.definite_refute)
func derive_materializes_provable_conclusions() -> !:
let base = try policy()
defer base.release()
let doc = try prism.derive(base)
defer doc.release()
var denial = false
for i in 0..<doc.value().child_count("/derived"):
let child = doc.value().child_at("/derived", i) else error(prism.invalid, "missing derived child")
let pred = try doc.value().get(child, "pred")
defer pred.release()
assert(try pred.value().text_at() != "employee")
if try pred.value().text_at() == "can_view":
let args = doc.value().child_at(child, 0) else error(prism.invalid, "missing derived argument")
let arg = try doc.value().get(args, "name")
defer arg.release()
if try arg.value().text_at() == "alice":
let neg = try doc.value().get(child, "neg")
defer neg.release()
denial = try neg.value().number_at() != 0.0
assert(denial)
func cycles_defeaters_and_empty_universe() -> !:
let doc = try prism.parse_surface("logic \"a\" { p => q } logic \"b\" { q => p } logic \"c\" { => allowed } logic \"d\" { ~> -allowed } logic \"e\" { seen(X) => known(X) }")
defer doc.release()
let unused: str[1] = [""]
let args = unused[..<0]
let p = try atom("p", args)
defer p.release()
let allowed = try atom("allowed", args)
defer allowed.release()
let denial = try atom("allowed", args, true)
defer denial.release()
assert(try prism.conclude(doc, p) == prism.ProofTag.defeasible_refute)
assert(try prism.conclude(doc, allowed) == prism.ProofTag.defeasible_refute)
assert(try prism.conclude(doc, denial) == prism.ProofTag.defeasible_refute)
let solved = try interop.Reference[prism.Logic].adopt(try new prism.Logic(doc) in memory.heap, prism.logic_type, memory.heap)
defer solved.release()
try doc.value().compile_logic("priority", "c > d")
assert(try prism.conclude(doc, allowed) == prism.ProofTag.defeasible_proof)
assert(try solved.value().conclude(allowed) == prism.ProofTag.defeasible_refute)
pub func run() -> !:
try structured_rule_round_trips_to_the_canonical_form()
try base_policy_blocks_employee_on_confidential_doc()
try a_clearance_layer_defeats_the_confidentiality_block()
try retracting_the_clearance_rule_reverts_the_conclusion()
try strict_rule_yields_a_definite_conclusion()
try derive_materializes_provable_conclusions()
try cycles_defeaters_and_empty_universe()
print("PASS 6 legacy logic cases, cycles, defeaters, and owned theory snapshots")