Normative design using inductive learning

In this paper we propose a use-case-driven iterative design methodology for normative frameworks, also called virtual institutions, which are used to govern open systems. Our computational model represents the normative framework as a logic program under answer set semantics (ASP). By means of an inductive logic programming approach, implemented using ASP, it is possible to synthesise new rules and revise the existing ones. The learning mechanism is guided by the designer who describes the desired properties of the framework through use cases, comprising (i) event traces that capture possible scenarios, and (ii) a state that describes the desired outcome. The learning process then proposes additional rules, or changes to current rules, to satisfy the constraints expressed in the use cases. Thus, the contribution of this paper is a process for the elaboration and revision of a normative framework by means of a semi-automatic and iterative process driven from specifications of (un)desirable behaviour. The process integrates a novel and general methodology for theory revision based on ASP.

💡 Research Summary

The paper presents a novel, use‑case‑driven iterative methodology for designing and revising normative frameworks—also called virtual institutions—that govern open systems. The authors model a normative framework as a logic program under answer set semantics (ASP). The model distinguishes between events (E) and fluents (F). Events are split into exogenous events (E_ex) and normative events (E_norm); the latter are further divided into normative actions (E_act) and violation events (E_viol). Fluents capture normative properties such as permissions (P), powers (W), obligations (O) and domain‑specific facts (D). Two central relations drive the dynamics: the generation relation G, which implements “counts‑as” mappings from observed events to generated normative events subject to empowerment and state conditions; and the consequence relation C, which initiates or terminates fluents when events occur.

The formal model is translated into an ASP program using the AnsProlog language. Time is represented by discrete instances with a “next” ordering, and predicates such as observed(e,i), occurred(e,i), holdsat(p,i), initiated(p,i), and terminated(p,i) capture the evolution of the normative state. A complete trace yields a single answer set, and its computation is linear in the number of time steps; incomplete traces require NP‑complete search over possible missing exogenous events.

The core contribution lies in coupling this ASP representation with Inductive Logic Programming (ILP). Designers specify use cases consisting of (i) an event trace and (ii) a desired final state (a set of fluents). If the current ASP program fails to produce an answer set that satisfies the desired state, the failing trace together with the existing rule base is fed to an ILP system. The ILP task is constrained by a language bias expressed through mode declarations (modeh, modeb), which limit the shape of admissible hypotheses. The ILP engine searches for hypotheses—new rules, added facts, or modified conditions—that, when combined with the background theory, make all use‑case properties true in every answer set.

Because ASP is non‑monotonic, ordinary ILP cannot directly perform theory revision. The authors therefore introduce a Theory Revision (TR) framework that defines a “revision distance” between two logic programs as the minimal number of elementary transformations (rule deletion, fact addition, condition addition or removal). A minimal‑revision solution is one that achieves the required properties with the smallest possible distance from the original theory. This approach yields a set of candidate revisions that are close to the designer’s original intent, facilitating human validation.

The methodology is demonstrated on a reciprocal file‑sharing normative system. An initial set of rules encodes basic permissions for uploading and downloading files. Several use cases are introduced, e.g., a user attempts to download a file without proper permission, or a file owner grants access to another user. The ILP‑driven revision process first proposes a missing rule that grants owners the right to delegate access, then suggests a sanction rule for unauthorized downloads. After each iteration, the designer can accept, modify, or reject the suggested changes, and the ASP model is re‑executed to verify compliance with all use cases.

The paper discusses the generality of the approach: the same ILP‑based revision mechanism can be applied to any domain modeled in ASP, not only normative frameworks. Limitations include the current focus on single, static traces and the reliance on manually crafted mode declarations. Future work aims at handling multiple concurrent traces, integrating dynamic feedback from users, and exploring richer bias specifications to reduce the search space.

In summary, the authors provide a semi‑automatic, iterative design loop that combines ASP’s expressive power for modeling normative institutions with ILP’s ability to synthesize and revise logical rules from concrete examples. This loop enables designers to incrementally construct consistent, behavior‑aligned normative frameworks while retaining control over the resulting rule set.