Journals and conferences run on layered rules. An editor-in-chief sets global policy, such as "no paper with an undeclared conflict of interest is accepted" or "human-subjects work needs ethics approval unless exempted." Area chairs and associate editors then write their own track rules on top of it, such as fast desk-reject criteria or "skip the meta-review when all reviewers agree." Reviewers and sub-committees fill in whatever those rules leave open. Nobody checks whether the lower tiers' rules, combined with anything the tier below might do, can still produce a decision that breaks the global policy. The rules also carry defaults and exceptions ("reject unless the rebuttal resolves the concern"), so their interactions are hard to see by reading them.
This note proposes to treat that question as a logical entailment problem and hand it to an off-the-shelf SAT solver, a program that decides whether a Boolean formula has a satisfying assignment. When the answer is "no, compliance can fail," the solver's satisfying assignment is a concrete counterexample: a submission profile together with a lower-tier rule set under which the global policy is violated. The contribution is not "encode a policy in logic." It is a delegation-robust compliance check that quantifies over everything a lower tier is allowed to do. It adapts the reduction behind strong-equivalence checking of logic programs to hierarchical governance.
Core Claim
Model each tier's policy as a small logic program with defaults. Here a logic program is a set of if-then rules over atoms describing submission attributes, reviewer reports and decisions, read under answer-set semantics, which lets a rule fire "unless" something is known. Let $G$ be the global constraints, $T$ a track policy, and $\mathcal{R}$ the class of lower-tier rule sets the track delegates to, restricted to a declared vocabulary of report atoms. The property we want is
$$\forall R \in \mathcal{R}:\ \text{every answer set of } T \cup R \text{ satisfies } G,$$
that is, the track is compliant no matter how its delegated tier behaves.
When $\mathcal{R}$ contains only sets of facts (reviewers report, they do not legislate), a violation is a single NP-style search. Program completion plus loop formulas, the translation of Loop Formulas for Circumscription that turns default reasoning into plain propositional clauses, reduces the check to one SAT call.
When $\mathcal{R}$ contains rules (sub-committees write their own), the quantifier ranges over programs. This is exactly the shape of strong equivalence, "$P_1 \cup P \equiv P_2 \cup P$ for any $P$," which SELP reduces to classical SAT and answers with an explicit witness program. We adapt that reduction from "equivalent under any extension" to "compliant under any extension over a restricted vocabulary."
The same machinery answers the latency question the file raises about hierarchies. It can check whether a streamlined workflow, for example one that skips meta-review on unanimous reports, is interchangeable with the full workflow in every delegated context, as far as $G$ is concerned.
Research Program
The first component is an encoding language. Tier policies are written as rules with explicit exception atoms. Tiers are connected in the style of the multi-context systems of Complexity of Contextual Reasoning, which models local "microtheories" linked by bridge rules and proves a bounded model property. That property keeps the flattened SAT instance's size growing with the number of contexts plus bridge rules, not with the product of tiers. Here the contexts are the editor-in-chief, track and reviewer tiers, and the bridge rules are the delegation interfaces. The tier structure itself follows the three-level arrangement documented in IEEE Transactions on Information Theory publication information and IEEE Transactions on Cybernetics publication information.
The second component is the reduction. For the fact-only case we use completion plus loop formulas, and for the rule-delegating case a SELP-style characterization. We will prove that each translation is sound and complete. We will also state the complexity of each case: we expect the fact case to be coNP for compliance and the rule case to stay coNP for the vocabularies we restrict to, mirroring the known result that strong equivalence reduces to SAT. We will say exactly where adding nested delegation (a sub-committee that re-delegates) breaks this.
For purely conditional obligations without answer-set defaults, we reuse the embedding of Streamlining Input/Output Logics with Sequent Calculi, which shows entailment in eight input/output logics (logics of conditional obligations) is co-NP-complete and embeds into shallow modal logic, and so reduces to SAT. That paper leaves nonmonotonic input/output logic open, and the answer-set route is our way around that gap for the rules governance actually uses.
The third component is witness replay. Every counterexample is turned into a concrete submission profile plus lower-tier behavior and replayed in an LLM-driven review simulation built on ResearchTown. ResearchTown simulates reviewing as unconstrained message passing among agent and paper nodes. Replay confirms the violation is reachable, not an artifact of the encoding.
Scope matters because of a tension in the file. PeerRead shows acceptance tracks "substance" and "clarity" far more than "soundness," so reviewing judgments are noisy. We do not verify judgments. Reviewer scores and flags enter as free atoms, and we verify only the procedural rules that consume them. This is also why the check is useful: it must hold for every possible, arbitrarily noisy, report.
Baselines
The naive reference point is reading the policies and trusting them. Operationally, this is scenario testing: sample submission and report profiles whose attribute and score marginals are fit to PeerRead's annotated aspect scores, run them through the tier rules, and flag any global violation. It will be given the same wall-clock budget as the solver, and seeded both uniformly and adversarially. We beat it if we detect injected violations it misses at equal compute, especially those that need a specific lower-tier rule to appear.
The strongest practical competitor is an LLM auditor, with and without VERIMAP-style verification. Verification-Aware Planning for Multi-Agent Systems has a planner emit subtasks with Python and natural-language verification functions. It reports gains of 4.05% on BigCodeBench-Hard and 9.8% on Olympiads over ReAct agents, but on coding and math, not policy compliance. We will give the LLM auditor the identical policy texts, a comparable token and time budget, and the same hand-tuned prompt budget as our encoding effort. The auditor is asked for a yes/no compliance verdict and a counterexample, and its counterexamples are replayed exactly like ours. Beating it means higher recall on injected violations at comparable false-alarm rates, with every reported witness confirmed on replay.
The ablation that isolates the key ingredient is a flat encoding. It uses the same SAT back end but checks $T$ plus a fixed set of lower-tier rules, typically the ones actually in force, without the quantifier over $\mathcal{R}$. If the flat check catches nearly everything the quantified check does, the delegation-robust semantics buys nothing.
A second ablation replaces the SELP-style reduction with brute-force enumeration of lower-tier rule sets. SELP itself needed 119,877,472 cases and about 10 hours for rules over 6 atoms, which calibrates how fast enumeration explodes.
For the policy-compliance task itself there is no reported result on Lacuna, so every baseline number will be produced here.
Why not just…?
Why not just ask an LLM to check the policies? This is the most natural alternative, and it is a baseline above rather than a straw man. The file's evidence against relying on it alone is indirect. From Complexity to Clarity surveys compliance auditing across multi-tier "consistency chains" and notes the lack of faithful, rule-citing verification. VERIMAP documents silent failures that look plausible but violate global constraints. The decisive test is whether the LLM finds violations that exist only under a particular delegated rule, which requires reasoning over all lower-tier behaviors. If it matches the solver there, the formal route is unjustified except for the guarantee of "no violation."
Why not just write the rules directly in an answer-set solver or satisfiability-modulo-theories tool and search? This is a real threat for the fact-only case. There, our reduction is essentially that direct encoding, and we claim no advantage beyond the witness and the soundness proof. The difference appears only when lower tiers can write rules. A direct encoding then either fixes those rules, which is the flat ablation, or enumerates them, which is the brute-force ablation. The experiments report the two cases separately so the reader can see whether the rule-delegation case exists in real policies at all. If real policies almost never delegate rule-making, the honest conclusion is that a standard solver encoding suffices.
Why not just test with realistic simulated submissions? Random or simulated testing through PeerRead-fitted profiles or ResearchTown agents is cheap. It also exercises the realistic regime, not the worst case. It cannot certify absence of violations, and it samples reports from the realistic distribution rather than the adversarial corners where strategic behavior lives. Impartial Peer Review shows that ordinary averaging invites strategic downgrading of competitors, so those corners matter. The equal-compute comparison measures how often the corners matter in practice.
Proposed Experiments
No benchmark in the file covers editorial policy consistency, so we build one. We transcribe tiered policies from public journal and conference guidelines, covering conflict of interest, desk rejection, ethics review, meta-review and rebuttal handling. Two annotators encode each policy independently, and we report their agreement. We then inject known drift at known locations: dropped exceptions, inverted priorities between rules, new defaults at a track, and delegation vocabularies that are too permissive. About half of these violations are designed to require a specific lower-tier rule to trigger. The primary metrics are detection recall and false-alarm rate per drift class, the fraction of witnesses confirmed on ResearchTown replay, and solver time as tracks and bridge rules grow.
Solver time is the scaling check. If the bounded model property carries over, time should grow with contexts plus bridge rules rather than with tier depth multiplicatively. We use the 21-million-constraint Glucose instance of Strategyproofness and Proportionality in Party-Approval Multiwinner Elections as a reference for what current solvers handle comfortably.
A separate experiment measures the natural-language bottleneck honestly. An LLM translates policy text into rules, and we count how many detection failures trace to translation rather than to reasoning. This bounds how much of the guarantee survives in an end-to-end tool.
The streamlining question gets its own test. We take candidate low-latency workflows, such as skipping meta-review on unanimous reports or allowing an area chair to desk-reject alone, and check whether each is interchangeable with the full workflow relative to $G$ in every delegated context. Witnesses of non-interchangeability go to replay.
The decisive checks are three. First, the quantified check must find a class of real or injected violations that the flat encoding and equal-compute scenario testing both miss. Second, those witnesses must reproduce in simulation. Third, the solver must remain fast at the scale of a real multi-track venue. If the first check fails, the project reduces to a useful but ordinary solver encoding of editorial rules, and we would report exactly that.
References
- Loop Formulas for Circumscription
- SELP - A System for Studying Strong Equivalence between Logic Programs
- Complexity of Contextual Reasoning
- IEEE Transactions on Information Theory publication information
- IEEE Transactions on Cybernetics publication information
- Streamlining Input/Output Logics with Sequent Calculi (Extended Abstract)
- ResearchTown: Simulator of Human Research Community
- A Dataset of Peer Reviews (PeerRead): Collection, Insights and NLP Applications
- Verification-Aware Planning for Multi-Agent Systems
- From Complexity to Clarity: AI/NLP's Role in Regulatory Compliance
- Impartial Peer Review
- Strategyproofness and Proportionality in Party-Approval Multiwinner Elections