Which Editorial Policies Can Be Checked in Plain SQL?

Journals and conferences run on tiered boards: an editor-in-chief sets rules, associate or area editors apply them, and reviewers do the work. Many of these rules are short logical statements. "No reviewer may handle a paper by a coauthor of the last three years." "Every submission is handled by an associate editor or a guest editor." "Authority to waive a conflict passes down the chain of command." Venues enforce such rules today in three ways: hand-written database queries, ad hoc scripts, or, increasingly, a large language model given the policy as a prompt. The records these checks run on are incomplete and spread across sources. Affiliations go stale, coauthorship comes from DBLP or ORCID, and role assignments sit in a separate management system. A check that treats missing facts as false can quietly approve a conflicted assignment.

This note proposes to treat each governance rule as an ontology-mediated query. An ontology-mediated query is a question asked over data together with background rules, so the answer includes facts the rules imply as well as stored ones. The proposal then uses the theory of first-order rewritability to sort editorial policies into four groups. A rule is first-order rewritable when it can be compiled into one ordinary, non-recursive SQL query that gives the right "certain" answer even over incomplete records. Some rules instead need a recursive query, some need linear recursion, and some force reasoning over alternative possibilities, which is coNP-hard. Two features of a board's structure push rules out of plain SQL: chains of delegation, which cause unbounded recursion, and role coverings with unknown members, which cause disjunction. Each has a cheap structural fix: cap the delegation depth, declare roles disjoint, or add a key constraint. The deliverable is a policy linter that classifies each rule, explains which part of the board's structure causes any hardness, and proposes the smallest change that restores single-query checking. Experiments on real reviewer-assignment data will measure how often naive SQL actually gives wrong answers.

Core Claim

The claim is that the hard cases in the logic map one-to-one onto recognizable features of editorial governance, so complexity results can serve as a design tool for boards and not only as a classification of logics. Three results in the file make this concrete.

The first concerns covering axioms. A tetrachotomy of ontology-mediated queries with a covering axiom classifies path-shaped queries under a covering axiom (of the form "every A is either B or C") into four exact classes: plain SQL, linear recursion, general recursion, and coNP. A rule such as "every handling editor is either a regular or a guest editor," combined with a conflict query that walks along handler and coauthor edges, has exactly this shape.

The second concerns recursion. Deciding FO-Rewritability in EL shows that for the lightweight logic EL the decision problem is PSPACE-complete when the data may use any vocabulary. It becomes EXPTIME-complete when only some predicates can appear in the data. That restricted setting is exactly the multi-source case, where the role database exposes only some predicates. Deciding boundedness of monadic sirups shows that even a single recursive delegation rule can be 2EXPTIME-hard to analyze for boundedness, meaning whether its recursion always stops after a fixed number of steps. So an automatic decider is not enough by itself. Where the decision is hard, the linter must rely on the structural fixes.

The third concerns repair. First Order Rewritability in Ontology-Mediated Querying in Horn Description Logics shows that adding database integrity constraints, such as foreign keys, can make a rule rewritable that was not rewritable on its own. This is the formal basis for repair.

What is new is the direction of use. Prior work classifies queries given a fixed ontology. This proposal classifies institutional rules, attributes any hardness to a specific structural feature of the board, and searches for the smallest added constraint that removes it. That added constraint might be "a delegation chain has at most two hops" or "no one is both regular and guest editor." The proposal then measures, on real data, whether the theoretical distinction changes any actual assignment decision.

Research Program

The first step is a corpus of governance rules. We will collect conflict-of-interest, eligibility, and handling rules from public venue policies. The board tier structure will come from published front matter such as IEEE Transactions on Cybernetics publication information and Front Matter. We expect a few hundred rules. Each is hand-encoded into one of three fragments: EL with concept inclusions, Horn rules with integrity constraints, or path queries under a single covering axiom. Rules that fit none of these are recorded as out of scope rather than forced into a fragment. That fraction is itself a finding about how far the theory reaches.

The second step is the linter itself. For EL rules it reuses the decomposed rewriting algorithm of Query Rewriting under EL TBoxes: Efficient Algorithms. That algorithm already detects non-rewritability through "root cycles," and we will trace each detected cycle back to the axioms, and hence the delegation edges, that produce it. For covering-axiom rules, the linter applies the syntactic tests from the tetrachotomy. Those tests check, for example, whether a single node in the query carries both labels, or whether a lone labeled node sits on a periodic or aperiodic path. Each test reads directly off the query. For Horn rules with keys, it follows the Beth-definability route of the Horn paper.

The repair step searches a small set of candidate edits:

  • capping the depth of any recursive role,
  • adding disjointness between the covering alternatives, which the tetrachotomy suggests often collapses coNP cases toward easier ones,
  • adding a foreign key or functional constraint.

The search ranks edits by how many currently legal board configurations each would forbid. That count comes from the actual rosters, so a repair that would reshape the real board is flagged as costly.

The third step is a ground-truth checker for small instances. We will use a disjunctive Datalog or answer-set solver that computes certain answers exactly. Every compiled SQL query and every naive query is validated against it. This matters because Benchmarking Ontology-Based Query Rewriting Systems found that published rewriters (Requiem, Rapid, IQAROS, Nyaya and others) produce incorrect output through normalization and subsumption bugs. Any rewriter used here must therefore be validated, not trusted.

Baselines

The naive reference point is closed-world SQL. A competent engineer writes the conflict or eligibility check directly against the joined records and treats any fact that is not stored as false. This is what most venues effectively do. It runs on the same database as our compiled queries. We beat it when, on realistically incomplete data, it disagrees with the exact certain answers on a measurable share of reviewer–paper pairs while our compiled queries agree on all of them.

The strongest existing reasoning baseline is to run an off-the-shelf rewriter and wait to see whether it terminates. For EL this is the decomposed algorithm of Query Rewriting under EL TBoxes: Efficient Algorithms, which is already a decider for that fragment. For Horn fragments, the systems evaluated in Benchmarking Ontology-Based Query Rewriting Systems can be used, with the same time limit and the same encoded rules. No reported result was found on Lacuna for any rewriter's accuracy or runtime on governance or editorial ontologies. Its performance on the generic suites (the Sygenia suite and the EL decomposed suite of 7 ontologies and 15,970 queries) will be re-measured here rather than quoted. Our linter adds explanation and repair on top of this baseline, not a faster decision. We beat it in two cases. On covering-axiom and keyed rules the baseline either cannot decide or produces no explanation. And on non-rewritable EL rules, a repair our linter proposes should restore rewritability while forbidding few real configurations.

The third baseline is an LLM given the policy as a prompt, as in Policy-as-Prompt: Rethinking Content Moderation in the Age of Large Language Models. That paper reports that changing only the prompt's format (JSON, XML or YAML) changes decisions on identical inputs. We will give the model the same records, serialized in each of the three formats, under a matched budget of prompt tuning. In the visible portion of the file, no reported multiplicity rate was found on Lacuna for that paper's Spotify moderation set. We beat this baseline if the model's decisions differ from the certain answers, or from each other across formats, while the compiled queries remain exact.

The ablation that isolates the key ingredient removes the attribution and repair step. It reports only the class label, so the linter is reduced to a classifier. Comparing editor-facing usefulness with and without repair shows whether the structural mapping adds anything beyond the complexity labels.

Why not just…?

Why not just write recursive SQL or Datalog and skip the rewritability question? Modern engines run recursive queries, and at conference scale (thousands of papers) performance is unlikely to be the problem. We concede this. The argument for the proposal does not rest on speed. It rests on correctness under incompleteness and on deployment. Recursion handles delegation chains. It does not handle disjunction, and that is where naive checks go wrong. A plain SQL query can also be pushed to each source separately when records sit in different systems that cannot be materialized together. If the experiments show that recursion-only rules dominate the corpus and incompleteness rarely changes answers, the proposal's value shrinks to documentation. The experiment below is designed to reveal that outcome.

Why not just materialize all implied facts once and query the result? Precomputing every implied fact fails in exactly the setting of interest. The coauthorship and role sources update independently. More importantly, the covering axiom has no single completed database to compute: the certain answer is whatever holds in every possible completion. Materialization therefore cannot express the coNP cases the tetrachotomy identifies. It can only express the Horn cases.

Why not just let an LLM read the policy and decide? Prompt-based enforcement gives no guarantee of soundness, and Policy-as-Prompt: Rethinking Content Moderation in the Age of Large Language Models documents format-dependent disagreement. The LLM baseline does cover rules our fragments cannot express, and that is a real advantage. We will report the out-of-scope fraction honestly and suggest a hybrid arrangement: compiled queries for the in-scope rules, and the model reserved for the rest.

Proposed Experiments

The decisive experiment comes first. It uses the reviewer-assignment records from the TPDP '21 (95 papers) and AAAI '22 (8,450 papers) settings studied in Counterfactual Evaluation of Peer-Review Assignment Policies, joined with public coauthorship data. To these records we inject incompleteness at rates calibrated to observed gaps, such as missing or ambiguous affiliations and unknown handler type.

For each encoded rule, we compute the share of assignments where closed-world SQL disagrees with the exact certain answer. The kill criterion is as follows. If disagreement is below one in a thousand pairs across all rules, practical incompleteness does not matter for editorial checking. In that case we would redirect the work to the repair-as-design question alone.

The second experiment measures coverage. It reports the fraction of corpus rules in each of the four classes and the fraction that are out of scope. It then checks, against the exact solver, that the compiled queries are correct on all small instances. The third experiment evaluates repair. For each non-rewritable rule, it reports whether the cheapest proposed constraint restores rewritability, how many existing roster configurations that constraint would forbid, and the size and runtime of the resulting SQL. Size is measured because the EL and tetrachotomy papers warn of exponential blowup in rewritten queries. The fourth experiment runs the LLM baseline under the three prompt formats on the same pairs. It reports disagreement with the certain answers and across formats.

FIRSTPASS (FIRSTPASS: A Multi-Domain, Multi-Round Peer Review Dataset Grounded in Real Editorial Outcomes) is outside the core experiments, because it concerns review content rather than eligibility. It reports 80.5% accuracy for outcome prediction. It would serve only as an optional source of multi-round handling records if handler roles can be extracted from it.