acceptodds
Under review as a conference paper at ICLR 2027

RelShield: Maximally Permissive Shields for Tool-Using Agents over Relational Data

Abstract

Tool-using language agents can automate business processes without hard-coding a separate control flow for every user request, but they must still satisfy standing requirements over the data they modify. Existing guardrails typically enforce safety specifications over simplified views of application state, which may omit relationships needed to enforce them correctly. This can cause guardrails to permit unsafe calls or unnecessarily block safe ones. To alleviate this problem, we introduce RelShield, a novel shielding framework that synthesizes restrictions directly from a first-order safety requirement over the underlying relational application state, together with tool specifications, legal initial states, and uncontrollable environment actions. From these inputs, we provide the safety-game fixed point characterization of the maximally permissive shield, i.e., the largest set of grounded calls that can remain available at each state while guaranteeing that every execution preserves the requirement. We first prove that shield synthesis is undecidable in this relational setting, and then give a general sound symbolic synthesis procedure. For a class of instances whose reachable safe states have bounded size, we prove synthesis becomes decidable and give a sound and complete synthesis method. We implement both procedures in RelShield and evaluate them on relational instances constructed from three established tool-using agentic benchmarks. Under a fixed budget, RelShield successfully synthesizes the maximally permissive shield for 78.0% of instances. For 31.3% of solved instances, RelShield proves that no additional shield restrictions are needed, certifying that the environment itself enforces compliance. Finally, we compare against an LLM baseline and find that its synthesized shields fail to match those produced by RelShield on at least a third of instances.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
LLM agents, agent safety, tool-using agents, formal verification, shield synthesis

Reviews

Among:
Shape:
1234this paper, Top 17%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.75 over 4 reviews, above 83% of the others.
Reviewer_BcikOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper is motivated by the observation that existing guardrails cannot express complex relational requirements over the application's database, and proposes a principled way to synthesize those restrictions automatically. It then formulates the maximally permissive shield problem, and propose two synthesis procedures for it. The implementation RelShield runs symbolic synthesis first and falls back to finite synthesis when stabilization is not certified within budget. The evaluation shows that RelShield constructs 78.0% successful synthesis.

Critical strengths
  • The paper is generally well-written.

  • The paper formulates the problem in a theoretical and clear way, and the provided theorems seem correct to me. The fixed-point characterization is a natural generalization of classical safety-game shielding to the relational, data-dependent, nondeterministic-outcome setting.

  • Experimental evaluations show the effectiveness of the proposed method.

Critical weaknesses

A more direct motivation example would be helpful. The motivation would benefit from a concrete case where an existing guardrail would silently fail on a relational requirement rather than merely being inconvenient to write.

The manual effort and the practical deployment are not discussed. The paper does not quantify the manual effort of deploying the proposed solution. To use RelShield, a developer must produce a first-order relational specification of the tool interface, the tool effects, the initial states, and the requirement. This is a substantial modeling effort, and the paper does not quantify it.

The empirical evaluation does not yet exercise the paper's most interesting capability. The fix-point characterization (safety-continuation reasoning beyond one step) is the most interesting capability of the proposed method. However, it is only triggered by the hand-constructed extensions.

The comparison with existing guardrails is indirect. The paper argues that existing guardrails cannot express relational requirements, which is true, but it does not run a concrete guardrail on the same instances to show that they fail, especially considering that the current formulation is restricted to closed first-order sentences over the relational schema.

Questions for authors
  1. Can you report the specification effort per environment (lines of specification, number of relations, number of tools)?

  2. What fraction of the natural-language policies in the studied benchmark is expressible in your closed first-order fragment? What falls outside?

1 comment
AuthorsOpenReview ↗

Response to Reviewer Bcik

Thank you for the positive assessment, and for finding the formulation clear and the paper well written. We have uploaded a revised manuscript with changes marked in blue. Table and appendix numbers below refer to this version.

W1 (Motivating example):

Agreed. In Figure 1, a trace-level guardrail can wrongly allow resume_line(C1001,L1004) if the agent never read C1001's bills, if a billing service marked bill B7 overdue after the agent read it, or if its supplied state view is incomplete. RelShield avoids these problems by operating directly over the database state. It also blocks the call while B7 is only past due, since the billing service can still mark it overdue (App. D.1). The revised introduction now makes this examples clear.

W2 (Manual Effort):

We agree that formalizing accurate tool specifications requires effort. Formal guarantees need such specifications, as in data-aware verification and formal guardrails such as Agent-C and FORGE.

W3 (No empirical evidence for fixed point reasoning):

We respectfully disagree that this is the case. As you correctly observed, the controlled extensions in the empirical evaluation do require shields where S⋆⊊S1S^\star\subsetneq S_1. This is also the case for a main-census instance in our new ablation without state-preserving calls (Table 16). Fixed point reasoning is the theoretical backbone that guarantees that the shields that RelShield synthesises are correct and maximally permissive. It is also what establishes whether S⋆=S1S^\star=S_1, so every instance exercises it.

W4 (Comparison with existing guardrails):

We respectfully disagree that running another one would be informative. Formal guardrails such as Agent-C and FORGE enforce already-supplied operational restrictions. Supplying RelShield’s synthesized guards would test enforcement, not synthesis. But once the guards are supplied, enforcement becomes the check RelShield already does before each call, which is guaranteed to be correct. GuardAgent and other LLM-based guardrails take textual policy descriptions as inputs, so they can fail by misinterpreting the requirements. Our LLM baselines instead receive RelShield’s formal inputs, so the comparison is fairer and tests synthesis alone.

Q1 (Specification effort per environment):

The benchmark models use 3,895 specification lines. The controlled extensions add 122, giving 4,017 in total. The 32 requirements account for 642 lines (about 20 each). Relation/tool ranges cover the different configurations.

EnvironmentRelationsToolsSpecification lines
Telecom2015541
Airline10–234–13648
Banking12–252–7830
AppWorld7–238–151,409
WorkBench2610–17467

Q2 (Benchmark requirements expressible in our fragment):

Only τ2\tau^2-bench gives the agent written policies. For τ2\tau^2-bench's Airline and Telecom policies, our fragment expresses 17 of the 57 clauses that the agent's tools can violate (30%). The other 40 depend on the dialogue or on information unavailable through tools, require complex arithmetic, or impose obligations without a deadline. For Banking, we formalised only the clauses governing the modelled tools. For AppWorld and WorkBench, we derive requirements from schemas and code (Section 5.1).

Reviewer_NHyLOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
1
Soundness
3
Read review
Paper summary

The paper studies guardrails for tool-using agents whose tools update a relational database. A requirement is a first-order constraint over the database state. Besides the agent's (controllable) tools, a set of uncontrollable actions also update the state and cannot be blocked. The goal is to derive, per state, the most permissive preconditions on the agent's tool calls such that no interleaving of agent calls and uncontrollable actions reaches a violating state. This is formulated as the greatest fixed point of a safety game (Thm 1), shown undecidable in general (Thm 2), and solved by (i) symbolic regression of the constraint through tool effects with SMT-checked stabilization, and (ii) a finite abstraction for instances with bounded reachable states. The evaluation models 41 instances from τ²-bench, AppWorld and WorkBench plus 9 hand-built extensions, and compares against LLM-written guards.

Critical strengths

Treating agent guardrails as constraints over database state, and modeling guarded and unguarded updates is a sensible formulation The formalization appears rigorous, but it is hard for me to carefully judge as it is quite dense for someone that doesn't work in PL/SMT. Reproducible!
The paper reports negative results directly.

Critical weaknesses

Use database terminology. The setting is a database, and the paper would be easier to place and evaluate in those terms:

  • Database schema: the tables, e.g. customer, line(id, owner, status), bill(id, owner, status, due).
  • Database state D: the current contents of those tables.
  • Controllable actions (the agent's tools): a fixed set of parameterized, guarded insert/update/delete statements. The guardrail stops a call from running, which from the state's perspective is equivalent to the statement's guard evaluating to false.
  • Uncontrollable actions: a second fixed set of parameterized, guarded update statements on the same tables that bypass the guardrail.
  • Requirement ψ: an integrity (denial) constraint.
  • Q_ψ: the consistent instances.
  • One-step shield S1: a pre-update integrity check.

It took me a while to make this mapping. Once I understood in this way, there is considerable prior work, which is understandable because databases came out of first order logic:

  • Integrity checking and transaction safety. Nicolas (1982) and later work on simplifying integrity checks rewrite a constraint into a cheaper check that runs before an update; this is exactly the one-step shield Pre_a ∧ WP_a(ψ). Related: Sheard & Stemple (1989), "Automatic verification of database transaction safety"; Qian's weakest preconditions for transactions; Benedikt et al. on constraint maintenance.
  • Verification of data-centric systems. Deutsch, Hull, Vianu and coauthors (WAVE; artifact-centric systems; Deutsch, Hull, Patrizi & Vianu, "Automatic verification of data-centric business processes," ICDT 2009), Abiteboul, Vianu et al. ("Relational transducers for electronic commerce," PODS 1998), and Bagheri Hariri, Calvanese, De Giacomo et al. (data-centric dynamic systems) model a system as a database plus parameterized guarded actions with external inputs, and ask whether any run reaches a bad state. They map out where this becomes decidable (bounded or state-bounded databases), which is the source of the undecidability and finite-abstraction results here. The paper cites Hariri et al. (2013), Calvanese et al. (2013, 2020) and Belardinelli et al. (2012); it should state what is new beyond moving from verification to maximally permissive synthesis.
  • Active databases: Aiken, Widom & Hellerstein, "Behavior of database production rules: termination, confluence, and observable determinism" (SIGMOD 1992), relevant to unguarded updates firing alongside guarded ones.
  • Invariant preservation under uncoordinated updates: Bailis et al., "Coordination avoidance in database systems" (VLDB 2015).
  • Denial constraints and inconsistency: Arenas, Bertossi & Chomicki, "Consistent query answers in inconsistent databases" (PODS 1999); Chu, Ilyas & Papotti, "Discovering denial constraints" (VLDB 2013).
  • Encoding update transactions as constraint problems: Tiresias (Meliou & Suciu, SIGMOD 2012) and QFix (Wang, Meliou & Wu, SIGMOD 2017) translate insert/update/delete transactions over database state into constraint representations to answer similar questions, close to the SMT encoding used here.

The authors acknowledge this already, but the uncontrollable-action component is not exercised by the evaluation. Four of the five benchmark models have no uncontrollable actions. Telecom's single one, payment_received (Awaiting → Paid), never creates a violating row. So the observed benefit therefore comes from pre/post-update checks over the database state, which can already be expressed as triggers or deferred constraint checks. Look-ahead appears only in the hand-built extensions. It would be really good to identify realistic settings where the novel contributions of this work is necessary. And perhaps include trigger-based enforcement as a baseline.

The approach requires all controllable and uncontrollable actions to be pre-defined as guarded updates with exact preconditions and effects. This is a strong assumption: real tools wrap application code and external services, and the set of other writers is rarely known in full. How can this be really used in practice? Can the constraints be scalably generated?

Each tool call and each uncontrollable action is treated as an atomic, serialized step. In practice, tools issue multi-statement transactions that run concurrently with other transactions under various isolation levels. What is assumed about transaction semantics? When are constraints over how actions can interleave important?

Constraint-based reasoning over databases (which has been studied before) is usually hard to scale to large databases. The instances use small fragments (tiny initial states, frozen clocks, numeric attributes dropped), each instance is run once, and 8 time out. How long does synthesis take? and how large the "shield"s are? and the runtime overhead?

Questions for authors

Some additional questions. There are some interesting ideas in the work, but I need help understanding

  • the ceiling of this approach in terms of when and where it would be useful
  • the performance and cost of this approach
  • the extent it complements prior work from the data management literature
2 comments
AuthorsOpenReview ↗

Response to Reviewer NHyL

Thank you for the detailed review and the database pointers, and for finding our formulation sensible and rigorous. We have uploaded a revised manuscript with changes marked in blue. Section, table and appendix numbers below refer to this version. We have revised Section 3 to make the presentation of the setup we study clearer.

W1, W2 & Q3 (Databases and novelty w.r.t. related work):

We agree that data management provides relevant background and have added a dedicated paragraph in Section 2. Our formulation follows the data-aware process tradition (Calvanese et al., 2013). We keep the agentic terminology established by the applications we study.

Data-centric verification guarantees are tied to a fixed controller, while their synthesis counterparts complete an already-specified process or task. RelShield's shields apply to any agent regardless of its policy or task, which requires our new synthesis results (Thms. 3–4).

To the best of our knowledge, the remaining database work you cite does not synthesize these call restrictions. Integrity-check and trigger-based machinery could generate guards once the winning region WW is known. RelShield solves the control problem and computes WW, so the two lines are complementary.

W3 (Realistic look-ahead and uncontrollable actions):

The main census has no uncontrollable events that threaten safety, but our extensions explicitly test this realistic case. In 'C1001 + overdue event' (App. D.1, Table 14), resuming a suspended line passes the immediate integrity check because a past-due bill has not yet been marked overdue. The asynchronous billing service can then mark it overdue, violating the requirement that customers with overdue bills have no active lines. RelShield therefore blocks the call. Five of nine extensions require restrictions beyond S1S_1.

W4 (Formalization Requirements):

We agree that formal specifications of the relevant system components are not always available. However, these are needed to provide formal guarantees, as in data-aware verification and agentic guardrails such as Agent-C and FORGE. Appendix C.6 now quantifies the effort. Our results rely on semantic conditions rather than a particular syntax, so specifications could also be written in suitable SQL or Datalog fragments more familiar to developers.

W5 (Concurrent Transactions):

Each transition is atomic. Still, an asynchronous operation can be modelled as a request call that adds a flag to the state, followed by an uncontrollable completion guarded by that flag. Other actions can interleave between the two.

Q1 (Ceiling of the approach):

RelShield requires a formal model of the safety-relevant dynamics of the agentic system. The symbolic procedure needs specifications that admit first-order regression (App. B.2). The complete procedure needs dynamics invariant under renaming of object identifiers and a size bound on safe reachable states (App. B.4). The experimental evaluation shows that realistic agentic systems can be modelled this way.

Q2 (Performance and cost):

We agree, and Appendix G now reports all costs. Synthesis takes 134 s, a runtime check 0.28 ms, and guards have 953 formula nodes (all at the median). We also optimised the implementation with formula simplifications and SMT proof decompositions, without changing RelShield's framework, and updated the shared codebase. Coverage now rises from 32/41 to 40/41 (Table 1).

Thank you for the careful response. i've raised my rating.

Reviewer_19gPOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper studies maximally permissive shielding for tool-using agents operating over relational application data. Given a first-order safety requirement, tool semantics, initial states, and uncontrollable environment actions, the framework synthesizes restrictions that preserve safety while retaining all safely available calls. The authors characterize the shield through a safety-game fixed point, establish undecidability in the general setting, and develop symbolic and finite-abstraction synthesis procedures, with completeness guarantees under boundedness assumptions. On 41 benchmark-derived instances, RelShield solves 32, identifying both environments that require no additional restrictions and those where one-step checks suffice. Controlled extensions demonstrate cases requiring reasoning about future safety.

Critical strengths

A precise and useful safety objective. The framework explicitly addresses both unsafe permissiveness and unnecessary restriction. Modeling relational state and uncontrollable transitions allows it to capture dependencies that interface-level checks may miss. The resulting guarantees are independent of the agent’s behavior, making the formulation relevant to reliable tool execution.

A coherent connection between theory and implementation. The symbolic and finite-abstraction procedures provide complementary synthesis routes. In particular, the finite abstraction preserves the permitted grounded calls, not merely whether a state belongs to the winning region. The implementation and benchmark-derived models provide concrete evidence that the formulation can be operationalized.

Critical weaknesses

The technical advance over closely related formal-methods work needs sharper justification. Section 2 acknowledges first-order safety games, data-aware controller synthesis, and related approaches. The relational semantics and renaming assumptions also build directly on STEAD. While synthesizing maximally permissive tool-call restrictions is a meaningful objective, the paper does not sufficiently isolate which technical obstacles require new machinery beyond these foundations. A more explicit comparison of assumptions, expressiveness, and preserved properties would help establish the significance of the theoretical contribution.

The empirical evidence provides limited coverage of the framework’s distinctive reasoning capability. In Table 1, all 32 solved main-census instances either require no additional restriction or admit a one-step shield; only five controlled extensions require restrictions beyond one step. Moreover, when an environment has no uncontrollable transitions and an always-available read-only action, every safe state already has a safe continuation, making one-step shielding sufficient by construction. Several modeled fragments have closely related characteristics. Appendix C also documents restricted tool interfaces and fixed quantities or clocks. Consequently, the results do not yet clearly distinguish properties of the original benchmarks from consequences of the selected modeling scope. The limited reporting of synthesis time, state-space size, and runtime checking overhead further constrains the assessment of practical applicability.

Questions for authors

What is the principal technical obstacle addressed by RelShield that is not already handled by STEAD and existing first-order or data-aware synthesis frameworks? Please clarify which results are direct adaptations and which require substantively new arguments.

For how many main-census instances is one-step sufficiency implied by the absence of uncontrollable transitions together with an available safe self-loop? What evidence supports extending the benchmark-level conclusions beyond the modeled fragments?

Can you provide per-instance synthesis times, explored state counts where applicable, and representative runtime checking costs? For the extensions requiring reasoning beyond one step, how do these costs change with the number of objects or outstanding obligations?

2 comments
AuthorsOpenReview ↗

Response to Reviewer 19gP

Thank you for the detailed review, and for finding the problem relevant and the theory well connected to the implementation. We have uploaded a revised manuscript with changes marked in blue. Appendix and lemma numbers below refer to this version.

W1/Q1 (Technical advance over closely related formal-methods work):

To our knowledge, RelShield is the first shield synthesis framework for the setup we study. While we leverage the existing literature, this setup requires substantively new arguments.

Thm. 1 characterizes the synthesis problem as a greatest fixed point. The main technical challenge in computing this fixed point is unbounded relational data, with grounded tool calls whose arguments range over a changing active domain. We first put forward a symbolic procedure (Thm. 3) that regresses through every call outcome and uncontrollable event, tracking object creation and deletion (Lemma B.2). The cited first-order synthesis methods target different control problems, such as choosing the relations an update introduces (Seidl et al., 2020).

Thm. 4 then puts forward a complete procedure, based on a finite abstraction that leverages structural assumptions. Shielding a black-box agent poses a new challenge here, since we cannot rely on a supplied process or task as other data-aware synthesis methods do. Our abstraction thus maps every call and each of its outcomes to a canonical representative, so the shield keeps exactly every safe call. STEAD (Mercado & Lomuscio, 2026) targets verification, not synthesis, so it assumes the agent is given beforehand. Its finite abstraction only preserves FO-CTL truth values, which are not enough to identify the calls a shield must keep. It also requires whole-system boundedness, while Thm. 4 only needs the safe reachable states to be bounded.

Finally, Thm. 2 does adapt classical arguments to prove undecidability.

W2/Q2 (One-step shield sufficient conditions):

You are right that an always-available self-loop and no uncontrollable actions suffice for S⋆=S1S^\star=S_1. Both conditions hold in 36 of the 41 census instances. Our new ablation removes all self-loops (Appendix F), so none of its 50 instances satisfies them, yet RelShield still solves 48/50. Within the ablated main-census instances, 33 shields still need at most a one-step check, and one requires restrictions beyond S1S_1. The benchmark-level observations concern the modelled fragments, and we now make this scope explicit in the conclusion.

W3/Q3 (Costs):

We agree, and Appendix G now reports all costs. Synthesis takes 134 s, a runtime check 0.28 ms, and guards have 953 AST nodes (all at the median). Shields from the complete procedure need at most 900 canonical states.

Appendix G.2 scales the extensions that need reasoning beyond one step. Symbolic synthesis takes 9–12 s for any number of customers, and the median check of a permitted call grows from 0.3 ms with one customer to 39 ms with 64. The complete procedure takes 2–3 s with one account and 284–374 s with five accounts and up to ten obligations, and median call-check times stay below 0.3 ms.

Thank you again for your detailed review. We would be happy to respond to any questions you may have on the explanations provided.

Reviewer_UpezOpenReview ↗
Rating
3
Confidence
2
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

This paper studies how to keep agents compliant with standing safety rules over relational data without unnecessarily limiting their actions. Instead of checking call histories or custom state summaries, the authors reason directly over the database state, tool effects, and uncontrollable environment events. They synthesize a maximally permissive shield that blocks a call only if it violates a rule immediately or lets future environment changes force a violation later. Although this problem is undecidable in general, their framework, RelShield, solves nearly all tested cases from τ2\tau^2-bench, AppWorld, and WorkBench by combining symbolic reasoning with a complete finite method for bounded systems. Many benchmark rules are already guaranteed by existing tool preconditions, and the rest only need one-step checks, showing that current benchmarks rarely require multi-step safety planning unless uncontrollable dynamics like deadlines are added.

Critical strengths
  • A well-chosen problem level. Specifying safety over the application's relational state avoids hand-built abstractions, and leaving the agent unspecified makes the guarantee independent of its behavior.
  • A crisp theoretical target. Theorem 1 gives a clean characterization of S*, and the distinction between S* and S1 is useful for reasoning about future enforceability.
Critical weaknesses

W1. The main empirical finding may be largely structural. Suppose a state-preserving call, such as get_customer in Figure 1, is enabled whenever Γc(D) is nonempty. Then W is simply the largest subset of Qψ closed under uncontrollable transitions. If no uncontrollable action threatens ψ, then W = Qψ and S* = S1 follows directly. The census result may therefore reflect the modeled dynamics more than a property discovered by synthesis.

W2. The most novel machinery has thin evidence.

  • The symbolic procedure solves 0 of 9 extensions, which are the only instances containing S* ⊊ S1. There is no evidence yet that it can synthesize a shield beyond S1.
  • The claim that benchmarks need only one-step checks is conditioned on solved instances. Eight of the nine failures are budget exhaustion at the symbolic step, including 5 of 7 AppWorld instances, so the hardest cases may be missing from the census.
Questions for authors
  1. Can you state a sufficient condition under which S* = S1, along the lines of W1? How many census instances have uncontrollable actions that can actually threaten ψ?
  2. Is the inability of the agent to preempt the environment intentional?
  3. What exactly does S* = Γc guarantee about the original benchmark system, and what should a developer verify before removing a requirement from the prompt?
2 comments
AuthorsOpenReview ↗

Response to Reviewer Upez

Thank you for the review, and for finding the problem level well chosen and the theoretical target crisp. We have uploaded a revised manuscript with changes marked in blue and updated the artifact in the anonymous link. Table and appendix numbers below refer to the revised manuscript.

W1/Q1 (Empirical findings are structural):

You are right that an always-available state-preserving call and no uncontrollable action that can violate ψ\psi suffice for S⋆=S1S^\star=S_1. These conditions hold together in 38/41 census instances. No census instance has a threatening uncontrollable action, but four of the nine controlled extensions do.

This observation motivated a new ablation that removes all state-preserving calls (Appendix F). Thus, none of its 50 instances satisfies these conditions, yet RelShield still solves 48/50 (96%). Within the ablated census, 33 shields still need at most a one-step check, and one requires restrictions beyond S1S_1.

W2 (Symbolic Synthesis and Census Coverage):

Agreed. We optimised the implementation with formula simplifications and SMT proof decompositions, without changing RelShield's framework. Symbolic synthesis now certifies S⋆⊊S1S^\star\subsetneq S_1 for both Telecom extensions, including in the ablation. Main-census coverage rises from 32/41 to 40/41 (97.6%), including all seven AppWorld instances (see Tables 1 and 16 in the updated manuscript).

Q2 (Uncontrollable environment):

Yes, this is intentional. The guarantee must hold without assuming that the LLM agent responds faster than external services or users. Scheduling constraints can be encoded explicitly, as in the Banking turn-taking variants (App. D.2).

Q3 (No further restrictions):

When S⋆=ΓcS^\star=\Gamma_c, the specified system preserves the requirement regardless of the agent's choices or uncontrollable events. This can happen when tool guards already enforce the requirement. The requirement can then be omitted from the prompt, provided the initial states, tool effects, and uncontrollable actions faithfully capture the deployment.

Thank you for the response. All my questions and concerns were well addressed.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General response and summary of new results

We thank all reviewers for their careful assessments and constructive feedback. We have uploaded a revised manuscript with changes marked in blue. Table and appendix numbers below refer to this version.

To address Upez's W2 concerns about coverage, we optimised the implementation with formula simplifications and SMT proof decompositions, and updated the artifact in the anonymous link. These are implementation improvements and do not change RelShield's framework.

We re-run the experiments and updated the manuscript with the new results. The following table summarizes Table 1. Entries are symbolic ∣\mid finite counts according to which procedure yielded the final output. “Solved instances” include both synthesized shields and non-existence certificates (I⊈WI\not\subseteq W).

Original instancesSolved instancesS⋆=ΓcS^\star=\Gamma_cS⋆=S1S^\star=S_1S⋆⊊S1S^\star\subsetneq S_1I⊈WI\not\subseteq W
Main census40/4116∣016 \mid 022∣222 \mid 20∣00 \mid 00∣00 \mid 0
Controlled extensions9/91∣01 \mid 02∣02 \mid 02∣32 \mid 31∣01 \mid 0

Reviewers Upez and 19gP correctly identified sufficient structural conditions under which a one-step shield is maximally permissive. We now include an ablation where these conditions no longer hold (Appendix F), which shows that RelShield's success does not depend on them. The following is a summary of the results.

Ablation. We remove all state-preserving calls and RelShield still solves 48/50 instances.

Ablated instancesSolved instancesS⋆=ΓcS^\star=\Gamma_cS⋆=S1S^\star=S_1S⋆⊊S1S^\star\subsetneq S_1I⊈WI\not\subseteq W
Main census39/4113∣313 \mid 37∣107 \mid 100∣10 \mid 10∣50 \mid 5
Controlled extensions9/91∣01 \mid 00∣00 \mid 02∣42 \mid 41∣11 \mid 1

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.