Advanced cheat sheet

The constructs beyond the cheat sheet: decision tables, presumptions and legal fictions, constraints, liberties and immunities, questions only a person can decide, competing readings of a text, procedures, stages, precedents, templates and units. As on the first page, every law block belongs to one package that compiles, and every section has a scenario that runs. At the end — an index of every construct of the language.

Open this package in the playground → — edit the rules and the scenarios of this page and run them in your browser.

Package header

Arxo Law

language "law.core" version "0.2";
package demo.parking.advanced version "0.1.0";
namespace "urn:law:demo:parking-advanced";

entity Applicant;
entity Office;

Decision tables

Arxo Law

decision LongTermDiscount(months: Integer) -> Decimal {
    table hit unique {
        when months >= 12 => 20 percent;
        otherwise => 0 percent;
    }
}

A decision maps inputs to an output by rows. hit unique means at most one row may match; otherwise is the row for everything else. The answer names the row that fired.

Presumptions and fictions

Arxo Law

relation applied_for_permit(a: Applicant) kind empirical;
relation good_standing(a: Applicant) kind institutional;
relation unpaid_fine_recorded(a: Applicant) kind institutional;

presumption GoodStanding(a: Applicant) {
    when applied_for_permit(a);
    presume good_standing(a);
    unless unpaid_fine_recorded(a);
}

relation notice_posted(a: Applicant) kind empirical;
relation notice_received(a: Applicant) kind institutional;

fiction DeemedReceipt strict {
    for a: Applicant;
    when notice_posted(a);
    deem notice_received(a);
}

Form	Use it when the norm says
presumption … { presume …; unless …; }	“is presumed … until …”: holds by default, evidence rebuts it
fiction … { deem …; }	“is deemed …”: treated as true whatever the facts are

Constraints

Arxo Law

relation permit_issued(a: Applicant) kind empirical;
relation fee_paid(a: Applicant) kind empirical;

constraint IssuedNeedsFee(a: Applicant) {
    when permit_issued(a);
    require fee_paid(a);
    severity error;
    message "a permit is issued only after the fee is paid";
}

A constraint derives nothing. It checks that decided facts fit together and reports a finding when they do not; a legal consequence of the breach needs its own rule.

Liberties and immunities

Arxo Law

relation permit_refused(a: Applicant, o: Office) kind empirical;
relation objects(a: Applicant, o: Office) kind empirical;
relation permit_displayed(a: Applicant, o: Office) kind empirical;
relation vehicle_towed(o: Office, a: Applicant) kind institutional;

rule ObjectionRight strict {
    for a: Applicant;
    for o: Office;
    when permit_refused(a, o);
    then liberty MayObject {
        holder a;
        against o;
        action objects(a, o);
        window [@2026-03-01, @2026-03-31];
    };
}

rule NoTowing strict {
    for a: Applicant;
    for o: Office;
    when permit_displayed(a, o);
    then immunity NoTowingWithPermit {
        holder a;
        against o;
        protected_effect vehicle_towed(o, a);
        window [@2026-01-01, @2026-12-31];
    };
}

Position	Says
liberty	the holder may do something; nobody can demand otherwise
immunity	the holder is shielded: the other side cannot bring this effect about

Together with duty, prohibition and power from the first page these are the five positions a norm can give.

Questions only a person can decide

Arxo Law

external judgment relation hardship(a: Applicant) {
    authority HearingOfficer;
}

relation hardship_waiver(a: Applicant) kind institutional;

rule HardshipWaiver strict {
    for a: Applicant;
    when applied_for_permit(a) and hardship(a);
    then hardship_waiver(a);
}

Some criteria (“undue hardship”, “reasonable”, “proportionate”) are decided by a named authority, not computed. Until the decision is supplied the answer is REQUIRES_JUDGMENT; once it is given as a fact with origin adjudicated, the rule fires.

Competing readings

Arxo Law

relation second_vehicle(a: Applicant) kind empirical;
relation second_permit(a: Applicant) kind institutional;

interpretation Narrow {
    status reviewed;
    rule NarrowReading strict {
        for a: Applicant;
        when second_vehicle(a);
        then not second_permit(a);
    }
}

interpretation Broad {
    status reviewed;
    rule BroadReading strict {
        for a: Applicant;
        when second_vehicle(a);
        then second_permit(a);
    }
}

interpretation_group SecondVehicle {
    alternatives Narrow, Broad;
    selection exactly_one;
}

When a text can be read two ways, each reading is an interpretation, and the group says how many may be in force. The case chooses one in its context (interpretation Broad;); the answer records which reading it rests on. Until a reading is chosen, every answer of the package carries the issue INTERPRETATION_REQUIRED — the open question is never hidden.

Procedures

Arxo Law

event PermitApplied {
    applicant: Applicant;
}

relation application_complete(a: Applicant) kind empirical;

procedure PermitProcess(a: Applicant) {
    state Draft initial;
    state Filed;
    state Issued terminal;
    transition File {
        from Draft;
        to Filed;
        on PermitApplied;
        when application_complete(a);
    }
    transition Issue {
        from Filed;
        to Issued;
    }
}

A procedure is a state machine for one case: states, and transitions triggered by events and guarded by conditions. The question current_state(case, State) says where the case stands now and which attempts moved it.

Stages

Output

stage Reminders {
    index round: Integer from 1 to 3;
    bind reminder index 1;
}

Arxo Law

relation overdue() kind empirical;
relation reminder(i: Integer) kind institutional;
relation final_notice() kind institutional;

rule FirstReminder strict {
    when overdue();
    then reminder(1);
}

rule NextReminder(i: Integer) strict {
    when supported(reminder(i)) and i < 3;
    then reminder(i + 1);
}

rule FinalNotice strict {
    when supported(reminder(3));
    then final_notice();
}

A stage evaluates rounds in order: each round is closed before the next one reads it. Use it for anything that counts steps — reminders, rounds of a vote, an elimination tournament. A package with a stage cannot also hold a procedure (LDC-E4126), so the stage declaration above is shown, not compiled into this page’s package; the rules it orders are.

Precedents

Arxo Law

relation lives_in_city(a: Applicant) kind empirical;
relation second_home(a: Applicant) kind empirical;
relation resident_for_permit(a: Applicant) kind institutional;

factors ResidencyLine {
    for a: Applicant;
    domain lives_in_city(a);
    plaintiff lives_in_city;
    defendant second_home;
    courts HIGH; LOW;
}

rule SecondHomeNotResident strict {
    for a: Applicant;
    when second_home(a);
    then not resident_for_permit(a);
}

precedent P1 of ResidencyLine {
    court HIGH;
    decided @2020-06-01;
    plaintiff lives_in_city;
    outcome resident_for_permit(a);
}

factors names the considerations a line of cases weighs for each side; a precedent records which factors a court found and what it held. A new case with the same factors follows the holding; a case with a factor the precedent did not have is distinguished, and the general rule answers.

Templates

Arxo Law

relation employed_in_city(a: Applicant) kind institutional;
relation worker_permit(a: Applicant) kind institutional;

expansion pair {
    params { subject: binder; ground: relation(subject); result: relation(subject); }
    exports { ok = self/ok; }
    emit rule self/ok strict {
        for subject; when ground(subject); then result(subject);
        scope from self; effective from self; labels from self; source from self;
    }
}

expand pair WorkerPermit {
    label en unofficial "Workers in the city get a worker permit";
    bind subject = a: Applicant;
    ground = employed_in_city;
    result = worker_permit;
}

An expansion is a rule template with parameters; expand fills it in. Use it when an act repeats one pattern for many subjects — the expanded rule is an ordinary rule with its own name in the answer.

Units and quantities

Arxo Law

relation distance_to_zone(a: Applicant, d: Quantity) kind empirical { key(a); }
relation far_from_zone(a: Applicant) kind institutional;

rule FarFromZone strict {
    for a: Applicant;
    for d: Quantity;
    when distance_to_zone(a, d) and d >= 2 km;
    then far_from_zone(a);
}

Quantities carry their unit tag (3 km). Values in different units are never mixed silently: comparing 2500 m with 2 km reports DIMENSION_MISMATCH and the answer’s status is TYPE_ERROR; conversion is always explicit — convert(value, num, den, unit) with an exact factor. New units are declared with unit and derived unit.

Scenarios

Each section has a scenario; here is the first one. A scenario is written the same way as on the first page.

Arxo Law

test "a decision table" {
    given {
        context { legal_time @2026-03-01; decision_time @2026-03-01T09:00:00Z; knowledge_time @2026-03-01T09:00:00Z; timezone "UTC"; }
    }
    evaluate LongTermDiscount(12);
    expect value == 0.2;
}

Run it

Terminal

law engine check advanced.law
law engine test tests/advanced.lawtest --program advanced.law

Expected output:

Output

check OK: advanced.law

Output

test PASS: a decision table
test PASS: a presumption holds by default
test PASS: evidence rebuts the presumption
test PASS: a fiction
test PASS: a constraint reports a breach
test PASS: liberty and immunity
test PASS: a judgment not yet given
test PASS: a judgment given
test PASS: the broad reading
test PASS: the narrow reading
test PASS: no reading chosen
test PASS: a procedure step
test PASS: rules that count steps
test PASS: the precedent is followed
test PASS: the precedent is distinguished
test PASS: an expanded template
test PASS: quantities in one unit compare
test PASS: different units are not mixed

All constructs

Every construct of the language with a one-line description, the same text the editor shows on hover.

Word	Construct	What it does
action	Action with actor	Declares an event with a designated actor: an action someone performs, with typed fields.
align	Fragment alignment	States that two fragments in different languages correspond, with review status.
and	Conjunction	Conjoins formulas: every conjunct must hold for the whole to hold.
as	Premise alias	Names the unwrapped value of an if some premise: the binder the when-line reads.
assert	Assertion	Asserts one proposition as fact, with id, origin, validity window and evidence links.
calendar	Calendar dataset	Declares a versioned calendar dataset binding: timezone, period and a content-addressed resource.
case	Case file	Pins one matter to decide: its evaluation context, named individuals and asserted facts with evidence.
classification	Classification	Supports a class by rule-like conditions: strict or defeasible strength.
closure	Closed-world scope	Bounds explicit negation: only inside predicate, domain and snapshot may absence become false.
collect	Comprehension	Builds a set or list by filtering: collect bindings of a type where a formula holds.
const	Named constant	Binds an immutable snapshot value to a name: numbers, money, or an individual via entity_ref.
constraint	Non-derivational check	States a mandatory relation between decided facts: when the antecedent holds, the requirement must hold too.
context	Named context profile	Pins reusable evaluation axes under one versioned name: jurisdiction, time, resolvers and policies.
counterfactual	What-if analysis	Asks what minimal case change would flip a target: mutable and immutable inputs plus cost.
deadline	Deadline policy	Pins how calendar deadlines count: start day, end inclusion, rolling and cutoff.
decision	Named pure decision	Names a pure query over evaluated legal state: one table or let* plus return, no norms or effects.
defeasible	Defeasible strength	A candidate consequence that a stronger opposite can defeat.
defeat	Defeater head	Heads a defeater rule: removes support for the named conclusion without asserting anything.
defeater	Defeater rule	Blocks a conclusion without supporting its complement.
definition	Exact definition	Defines a concept by exact condition: the head holds exactly when the body holds.
derived	Derived unit	Declares a derived unit as a product and quotient of simple ones: it has no scale of its own.
edition	Source edition	Pins one content-language-revision Expression of a source: language, officiality and lifecycle.
effective	Effective window	Bounds the rule to a legal-time interval: outside it the rule does not apply.
entity	Nominal entity type	Declares a nominal type: identity is the pair (type, stable id); equal ids in two types never mix.
entrenchment	Entrenchment	Shields one source passage over a time window: a locator plus its validity interval.
enum	Enumeration	Declares a closed set of named members: the total vocabulary of one choice.
event	Event declaration	Desugars to an immutable nominal entity with id and typed fields; executable use wants one canonical time interval.
Event	Domain event	Declares an immutable nominal event subtype with typed intrinsic fields; identity is the stable id.
evidence	Evidence document	Declares a case document: a stable id over a typed schema with provenance fields.
expand	Expansion instance	Instantiates a named expansion: binds its parameters to local relations and values.
expansion	Expansion definition	A closed generation profile: params plus emit rules that generate nodes with stable ids, labels and anchors.
exports	Export map	Names what an expansion publishes: local names for generated nodes.
factors	Factor dictionary	Declares the closed factor vocabulary of one precedent line: signature, domain, sides and courts.
facts	Exported fact group	Named unit for exporting facts across the package border; the body holds asserts only.
fiction	Legal fiction	Deems an institutional fact true when its conditions hold: the law treats it as decided.
fragment	Source fragment	Pins one addressable passage inside an edition: kind, locator and fixed text.
function	Pure function	Returns a data value, never a proposition; pure means no assertions, no norms, no ambient reads.
governs	Temporal scope	Scopes a rule to regulated-fact time on a named axis: support outside the window is not support.
if	Conditional term	Chooses between two data terms on a boolean: if the condition holds, the first, else the second.
import	Dependency import	Declares a dependency once per package; only its pub symbols become reachable as pkg::Symbol.
integer	Integer parameter	An expansion parameter holding a whole number: the threshold of an aggregate premise.
interpretation	Named reading	Groups rules, priorities and definitions as one reading of a named document, with status and authority.
interpretation_group	Reading alternatives	Groups rival readings of one document with a selection policy: exactly one, any, or composed.
jurisdiction	Source jurisdiction	The legal order a source belongs to, written as an institution identifier.
key	Expansion case key	Names the generated node after the case: key(c) is the case name.
key	Key declaration	Names the arguments that identify a tuple or a generated node.
key	Relation key	Declares the candidate key: one key projection identifies one tuple.
language	Language header	Opens every file: the language name and the exact version the file is written against.
list	List aggregate	Collects the outputs of all matching rows of a decision table into a list.
list	List parameter	An expansion parameter holding a finite list of relation references.
map	Total enum map	Declares a closed total mapping from one enum to another: sugar over a pure function.
namespace	Namespace declaration	URI from which declaration StableIds are built ({namespace}#{Name}); one package forms one tree.
option	Optional premise parameter	An expansion parameter for a premise that may be absent.
package	Package declaration	Names the package and pins the language version; every file belongs to exactly one package.
params	Expansion params	Declares what an expansion instance must bind: binders, relations and value slots.
precedent	Precedent case	Records one decided case as factor sets and an outcome under a named vocabulary.
presumption	Presumption	Holds a conclusion defeasibly until an exception fires: a rule, a defeater and a priority in one form.
priority	Rule priority	Orders conflicting rules: prefer the winning application over the losing one, with an explicit reason.
procedure	Procedure automaton	Declares a state automaton over one instance: named states plus the transitions between them.
property	Property check	States what must hold over generated inputs: a forall domain plus a pure expectation.
publication	Published file	Pins one published file of an edition: media type, retrieval address and content hash.
quantity	Duration parameter	An expansion parameter holding the duration of a term, used in the date term of a deontic window.
query	Query declaration	A named computation over legal state that adds no support: local lets, then one return.
record	Value record	Bundles typed fields under one name: the plain value object of the language.
reference	Dynamic reference	Declares a reference resolved at evaluation: source, locator, resolution axis and policy.
region	Parallel region	Declares one token-holding area of a parallel state: its own states and transitions.
relation	Relation	Declares a named predicate: rules derive which of its tuples hold.
revision	Revision link	Links editions into an immutable graph: what came before, what comes next, and why.
role	Legal role	Introduces one LegalRole constant for an actor type, read through the has_role relation.
rule	Inference rule	Derives a conclusion when its conditions hold.
scope	Rule scope	Restricts when a rule applies: a formula kept separate for indexing and explanations.
set	Set literal (reserved)	Reserved word of the set literal; a set is built by a collect comprehension.
snapshot	Snapshot function	Declares an external function deterministic only against an exact snapshot hash, under a named capability.
some	Present option	Passes a present optional argument at an instance: some names the value the option carries.
source	Source work	Declares the abstract Work behind an act: its kind, jurisdiction, authority and number.
stage	Reserved tour boundary	Reserves a named node for round-based stratification: an empty body stays a loud boundary.
state	Automaton state	Names one state of a procedure automaton: entry states are initial, sinks are terminal.
strict	Strict strength	An indefeasible consequence inside the chosen theory.
support	Support edge	Links one document to one proposition with a fixed relation: supports, refutes, authenticates, measures, reports or establishes.
temporal_resolution_policy	Day-resolution policy	Pins how a Date becomes an Instant interval: one fixed offset and a day boundary.
term	Legal term with cases	Writes one legal deadline with a general rule and named special cases.
test	Executable test	Pins one executable check: given holds the case, evaluate asks the question, expect states the verdict.
text	Amendment text	The new text an amendment operation puts at a locator.
text	Fragment text	The pinned official text of a fragment, in a named language and status.
then	Rule head	States what the rule concludes: a literal or a norm template.
timezone	Calendar time zone	The time zone of a calendar snapshot.
transition	Automaton transition	Moves one procedure automaton from one state to another on an event, under a guard.
type	Type alias	Names an existing type without nominal separation; transparency holds on both compiler stages.
unit	Unit declaration	Declares a measurement unit: a simple atom carries exact scale and dimension, a derived unit multiplies simple ones.
Unit	Unit tag surface	The declared name for measurement-unit tags: tags resolve in the unit registry, conversions stay explicit.
unless	Rule exception	Adds a defeasible exception to a rule: when it fires, the rule does not.
uri	Publication address	The canonical address of a publication of an edition.
use	Explicit selection	Selects records explicitly: in a case, use names a snapshot alias and the records taken from it.
verification	Verification record	Pins one external authenticity check of a case document: evidence, hash, verifier and outcome.
when	Body clause	Conjoins the conditions a rule needs: literals, comparisons, calls.
where	Filter clause	Filters a comprehension or aggregate: only bindings satisfying the formula are collected.
within	Aggregate window	Bounds an event day to the instance window inside a count premise: day within window.