A collective duty as a whole

Intention

I want to create one duty of a collective without multiplying it onto members.

Correct formFrozen execution sceneBoundary

Incorrect form and why it stays silent

Incorrect form

// Члены коллектива автоматически получают отдельные обязанности.

The collective remains a single bearer. All three allocation/discharge/violation fields are dropped at lowering with warning LDC-E1305; the policy algorithm is not wired in; activity of the catalogue fields is not claimed.

Correct form

Arxo Law

language "law.core" version "0.2";
package recipes.a.r08 version "0.1.0";
namespace "urn:recipe:a-positions:08";

entity Team;
entity Person;
relation formed(g: Team);
relation member(g: Team, p: Person);
relation delivered(g: Team);
const Discharge: Text = "policy-defined-by-author";
const Violation: Text = "policy-defined-by-author";
rule R strict { for g: Team; when formed(g);
    then duty Joint { bearer g; allocation_policy joint;
        discharge_policy Discharge; violation_policy Violation;
        achieve delivered(g) during [@2026-09-01, @2026-09-10]; };
}

Frozen execution scene

Facts and snapshot	Question	Answer
two members, one duty; 2026-09-05	positions()	position_count(Joint, ACTIVE, 1); / COMPUTED
performed by the collective; 2026-09-05	positions()	position_count(Joint, SATISFIED, 1); / COMPUTED
policy references removed; 2026-09-05	positions()	position_count(Joint, SATISFIED, 1); / COMPUTED

two members share one duty

Arxo Law

test "two members share one duty" {
    given {
        context {
            legal_time @2026-09-05;
            decision_time @2026-09-05T09:00:00+05:00;
            knowledge_time @2026-09-30T09:00:00+05:00;
            timezone "Asia/Almaty";
        }
        assert formed(entity_ref("urn:recipe:a-positions:08:g")); assert member(entity_ref("urn:recipe:a-positions:08:g"), entity_ref("urn:recipe:a-positions:08:p")); assert member(entity_ref("urn:recipe:a-positions:08:g"), entity_ref("urn:recipe:a-positions:08:q"));
    }
    evaluate positions();
    expect position_count(Joint, ACTIVE, 1);
    expect evaluation_status == COMPUTED;

}

collective performance satisfies

Arxo Law

test "collective performance satisfies" {
    given {
        context {
            legal_time @2026-09-05;
            decision_time @2026-09-05T09:00:00+05:00;
            knowledge_time @2026-09-30T09:00:00+05:00;
            timezone "Asia/Almaty";
        }
        assert formed(entity_ref("urn:recipe:a-positions:08:g")); assert member(entity_ref("urn:recipe:a-positions:08:g"), entity_ref("urn:recipe:a-positions:08:p")); assert member(entity_ref("urn:recipe:a-positions:08:g"), entity_ref("urn:recipe:a-positions:08:q")); assert delivered(entity_ref("urn:recipe:a-positions:08:g"));
    }
    evaluate positions();
    expect position_count(Joint, SATISFIED, 1);
    expect evaluation_status == COMPUTED;

}

removed policy references still satisfy

Arxo Law

test "removed policy references still satisfy" {
    given {
        context {
            legal_time @2026-09-05;
            decision_time @2026-09-05T09:00:00+05:00;
            knowledge_time @2026-09-30T09:00:00+05:00;
            timezone "Asia/Almaty";
        }
        assert formed(entity_ref("urn:recipe:a-positions:08:g")); assert member(entity_ref("urn:recipe:a-positions:08:g"), entity_ref("urn:recipe:a-positions:08:p")); assert member(entity_ref("urn:recipe:a-positions:08:g"), entity_ref("urn:recipe:a-positions:08:q")); assert delivered(entity_ref("urn:recipe:a-positions:08:g"));
    }
    evaluate positions();
    expect position_count(Joint, SATISFIED, 1);
    expect evaluation_status == COMPUTED;

}

Python

>>> import runpy
>>> check = runpy.run_path("docs/recipes/a-positions/resources/check.py")
>>> check["check_boundary"](https://github.com/arxohq/law/blob/master/docs/recipes/a-positions/8)
'А8: граница проверена'

Counterfactual

Mutation: bearer g; → “; rejection LDC-E1305. Additional counterfactuals are shown as separate scenes.

Boundary

The constants name teaching references; they do not implement an allocation algorithm. Individual and joint consequences cannot be derived from these labels.