acceptodds
Under review as a conference paper at ICLR 2027

Blocking Is Not Recovery: Recovery-Closed Authorization for Tool-Using Agents

Abstract

Tool-using agents recover from timeouts, partial failures, and replanning. Existing authorization typically evaluates the current call, missing how prior realized effects consume authority during recovery. Once execution realizes an effect, the authority available to a replanned action may differ from the original grant: locally identical recoveries can require opposite decisions because prior effects consumed different authority. We call this failure-induced authority drift. We introduce Recovery-Closed Authorization (RCA), which carries authorization through recovery as a closure invariant over realized effects. RCA records authorization-relevant realized effects, derives residual authority, and admits a recovery only when every represented prospective effect remains within it. The model proposes actions, while the authenticated grant, realized-effect ledger, and bound tool contract determine execution. Within a declared effect abstraction, we show that authorization state must distinguish histories with different residual decisions and prove recovery-closure soundness. On held-out compositions, RCA reduces observed prefix authorization violations from 20.0% to 0.0% at the same 80.0% safe-recovery utility. Across heterogeneous current-step mechanisms, adding RCA eliminates observed recovery-time violations while preserving measured safe-recovery utility. In frozen same-candidate replay, RCA removes all 56 observed unsafe decisions and preserves all 72 observed safe decisions. These results establish residual authority as the cross-step state required for recovery authorization.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
agent safety, agent authority

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_Ca4pOpenReview ↗
Rating
1
Confidence
3(−1)
Informativeness
2
Presentation
1
Soundness
1
Read review
Paper summary

The paper studies authorization for tool-using LLM agents during failure recovery. The paper shows that per-call guards can evaluate each recovery action in isolation and therefore miss cases where earlier effects have already consumed part of the original grant. The paper proposes Recovery-Closed Authorization (RCA), keeps a trusted ledger of realized effects and allows recovery actions only if their effects stay within the remainder.

Critical strengths

The problem is real and well motivated. Stateless per-call guards may indeed fail to catch failed tool calls or compositional effects.

Pushing such decisions to a separate security layer is practical and well founded in prior work.

Critical weaknesses

Without the excess jargon (of which there is a lot, for a well known idea), the proposed RCA is a type of cumulative quota enforcement. Tracking a running total of consumed authority and rejecting actions that would exceed the limit is a relatively known idea standard in payment systems and rate limiting and the paper should position itself against that literature rather than only against recent LLM agent systems. From the perspective of that body of work, there are several hard parts of deploying such quotas, such as tracking realized effects reliably or handling authorization constraints that aren’t additive. However, in this work, all of these are placed inside the trust assumptions. The paper risks translating standard methods under generous assumptions to agentic systems without any specific insights about agentic systems themselves. Given this is not a particularly new idea, I would also heavily advise simplifying the coined jargon, e.g. "declared effect abstraction", "observed prefix authorization violations", "heterogeneous current-step mechanisms", which makes the abstract and paper difficult to understand.

Critically, the numbers in table 1 and 6 do not match (S2 is 52.8% in Table 1 but 14.33% in Table 6 for model candidate). I have significant concerns about the soundness of headline results.

The evaluation is also circular. The oracle is defined along the same frame as RCA, so complete agreement is somewhat tautological. The baselines also seem to lack the exact states RCA uses or are incomplete comparisons. Why does LedgerLocal ignore cumulative totals?

The theoretical results are somewhat overstated. Theorem 1 states that a deterministic monitor receiving identical inputs in two histories cannot make different decisions. This is again tautological. Deterministic functions must have a single output for each input by definition.

RCA usually stands for root cause analysis and I would advise changing the acronym. This does not affect my score.

Questions for authors

How does a simple cumulative-budget rule written in AgentSpec or Progent compare to RCA?

What are the actual measured quantities?

5 comments
AuthorsOpenReview ↗

Beyond Per-Call Authorization—Fair Quota Baselines and Verified Recovery Effects

4. Theory, trust assumptions, and implementation costs

We agree that the elementary indistinguishability argument underlying Theorem 1 is straightforward. Its purpose is not to claim a new general theorem about deterministic functions, but to identify which execution-history distinctions an authorization monitor must retain to make sound and permissive recovery decisions. The accompanying characterization is scoped to a declared effect abstraction and separating continuation family.

Similarly, Theorem 2 establishes a conditional recovery-closure invariant. It does not establish that arbitrary external APIs automatically provide faithful envelopes or trustworthy effect observations.

The implementation contract makes those requirements explicit: trusted effect accounting, conservative prospective envelopes, mediated execution, and per-root linearization. RCA addresses authorization within that trusted boundary, rather than claiming to solve arbitrary external-effect instrumentation.

We also report the measured runtime costs (Appendix I). In a single-worker CPU microbenchmark, p95 checks were approximately 24.9 μs for native per-call authorization, 41.9 μs for scalar accounting, and 1,868 μs for the RCA ledger path. These measurements describe the evaluated implementation, not production-scale concurrency or end-to-end latency.

We appreciate the recommendation to simplify terminology. The revised manuscript distinguishes ordinary per-call authorization, cumulative accounting, and recovery-closure enforcement more explicitly, and identifies the measured populations and metrics directly in the corresponding tables. We also acknowledge the acronym overlap with root cause analysis.

I thank the authors for the detailed response and experiments. The SQLite execution study and the fixed-candidate replay are useful additions.

However, the revised manuscript and rebuttal actually reinforces my concerns about the contribution. Line 1428 now reads "A correct per-root amount counter is sufficient for the amount-only accounting problem" and that “RCA does not improve that decision”. The next sentence says the remaining episodes "are attributable to cumulative count", line 1429, which the manuscript notes “is itself additive”. The manuscript seems to now imply that RCA is functionally equivalent to cumulative quota enforcement over both amount and count. By the revised paper's own argument and even the rebuttal ("Accordingly, we do not claim that RCA is intrinsically more expressive than a complete multidimensional history-aware policy. Indeed, documented-hook implementations supplied with equivalent trusted state and locking can reproduce RCA's decisions.") it seems they would match in performance. I do not see positioning against such quota systems in spite of this concession.

On the topic of Table 1 and Table 6, I am glad that the inconsistency was resolved. However, tables 21 and 22 on Progent and AgentSpec are identical in all reported statistics. Is there a theoretical reason these are meant to be identical? If the choice of framework does not influence the actual results, I struggle to see in what sense these frameworks are considered evaluated.

My understanding is now that the paper is proposing a method that it then concedes is functionally equivalent to a cumulative quota enforcement. Of the two theorems to demonstrate the contribution, one is now conceded as straightforward in rebuttal. The oracle evaluation is now “an upper-bound comparison within the same declared abstraction, rather than an independent validation of the abstraction itself". I will keep my score.

AuthorsOpenReview ↗

Clarifying RCA’s Problem Novelty, Technical Contributions, and Cross-Framework Evidence

We thank the reviewer for the follow-up. However, we respectfully disagree with the conclusion that RCA's functional equivalence to sufficiently expressive stateful enforcement implies a lack of research novelty. This reasoning conflates the expressibility of a security property with the originality of identifying, formalizing, and systematically evaluating that property.

1. Functional equivalence does not invalidate the problem contribution

RCA's central contribution is the identification and formalization of failure-induced authority drift as a distinct recovery-time authorization problem.

The critical observation is that two histories can expose the same failure observation and the same recovery candidate, yet require opposite authorization decisions solely because their previously realized effects differ.

This problem is not restricted to replayed requests, expired permissions, or duplicated authorization tokens. A newly generated recovery action may have valid credentials, satisfy the current-call policy, and use a fresh transaction identifier, yet exceed the authority remaining after earlier partial or successful execution.

The existence of a sufficiently expressive policy language capable of implementing the required check does not establish that the underlying security problem, its decision-state requirements, or its recovery-closure invariant were previously identified and characterized.

Indeed, the equivalence demonstrated by our documented-hook experiments establishes that existing authorization frameworks can implement the RCA contract when given the necessary trusted information and synchronization. This supports the portability of the proposed security property; it does not negate its formulation.

Our technical contributions should therefore be evaluated at the level of the security problem and its formalization:

  • Problem: Failure-induced authority drift, where locally indistinguishable recovery requests require history-dependent authorization decisions.
  • State characterization: Residual future-effect decisions identify the information that sound and permissive recovery authorization must preserve, relative to the declared effect abstraction and continuation family.
  • Security invariant: Recovery closure constrains every prospective effect against authority remaining after realized execution, including under uncertainty.
  • Composition: The invariant can be enforced alongside existing invocation-time authorization without changing their native decision rules.

Theorem 1 establishes the necessary distinction between authorization histories; Theorem 2 establishes the resulting recovery-closure guarantee under explicit trust assumptions. The originality claimed is the recovery-specific security formulation and its enforcement contract, not the complexity of the induction technique.

2. RCA studies a different authorization question from the cited work

We agree that RCA shares durable-state and authorization-checking mechanisms with CapLease [1] and commit-time authorization [2]. However, sharing implementation ingredients does not make their security objectives identical.

CapLease [1] studies the repeated consumption of token-independent authorization through reissuance and semantic replay. Commit-time authorization [2] studies whether an authorization justification remains valid and bound to the effect at the point of durable commitment.

RCA asks whether a proposed recovery remains authorized after the composition of previously realized effects has changed the authority available for further execution.

This distinction matters when the next action is neither an exact replay nor dependent on stale authorization evidence. The recovery action itself can be locally valid while its composition with prior effects violates the grant.

Our contribution is to isolate this failure mode, characterize its decision-relevant state, and evaluate the security–utility consequences of enforcing recovery closure. We do not claim that the neighboring systems could never be extended to enforce the same property.

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

This paper introduces Recovery-Closed Authorization (RCA) to address the problem, for tool-using agents, of authorization when there are communication errors such as timeouts, etc., and the right semantics don't carry over. The context of past attempts is critical. Drawing on a ledger, the idea is that RCA records authorization-relevant realized effects, derives residual authority, and admits a recovery only when every represented prospective effect remains within it. The efficacy of the approach is demonstrated through several examples. A traditional formal approach, such as temporal logic of actions (TLA) is not used.

Critical strengths

In considering the safety and security of tool-using AI agents, questions of authorization are critical. Yet, there can be perturbations in the system that are in the history and that contextually impact what should and should not be authorized. This paper formulates the basic problem in a clean way, proposes a nice RCA approach for addressing the problem, and demonstrates its efficacy on several simulated settings.

The writing is clear and well-organized.

The results, though in the simulated setting, are conclusively good.

Critical weaknesses

No real-world data or settings are considered.

The relationship to methods such as the temporal logic of actions due to Lamport is not discussed, which makes evaluation of some of the novelty claims difficult.

Formal proofs of correctness, etc. could be strengthened.

Questions for authors

How does this line of work relate to literatures such TLA in formal verification on the one hand, and emerging techniques for agentic control such as Royce Moon's containment verification method (ICML 2026 workshop)?

3 comments
AuthorsOpenReview ↗

Connections to TLA, Containment Verification, and Persistent-Effect Validation

We sincerely thank the reviewer for the positive assessment of RCA's problem formulation, design, and experimental evidence. We particularly appreciate the suggestion to clarify its relationship to formal verification and recent agentic containment approaches. We have expanded the revised manuscript to address these connections and strengthened the execution-level evaluation.

1. Connection to Lamport's TLA and formal verification

RCA is compatible with the state-based reasoning underlying TLA. Its central safety requirement can be written as the temporal invariant:

□(E(hₜ) ≼ A₀)

Here, E(hₜ) denotes the cumulative authorization-relevant effects realized through recovery, and A₀ is the authenticated authorization bound.

The distinction is between specifying a temporal safety property and constructing an authorization mechanism that enforces it at recovery boundaries.

RCA enforces this invariant by maintaining a trusted effect ledger and admitting a recovery only when every prospective effect in its contract-derived envelope preserves the authorization bound.

Our theoretical results provide two complementary properties:

  • Necessity (Theorem 1): An authorization monitor must distinguish histories whenever their remaining authority induces different decisions for a realizable recovery.
  • Soundness (Theorem 2): Given faithful prospective-effect envelopes, trustworthy effect accounting, and mediated execution, every RCA-accepted recovery prefix preserves the authorization invariant.

We have added an explicit TLA-style interpretation and clarified the corresponding proof boundaries in Appendix B, with the mathematical arguments developed in Section 4 and Appendix A.

We also exhaustively checked 101,600 state–action transitions and performed 8,128 pairwise checks over the declared finite configurations (Appendix Table 4).

These results complement temporal-logic reasoning: the proofs establish the recovery-closure property under the stated contract, while exhaustive checking validates the declared finite model. We do not characterize this as a mechanized TLA+ proof.

2. Relationship to Moon and Varshney's Containment Verification

We appreciate this connection and have incorporated Moon and Varshney's Containment Verification: AI Safety Guarantees Independent of Alignment into the revised related-work discussion (Appendix B).

The two approaches share a central principle: security guarantees should be enforced by trusted software boundaries rather than depend on the model's behavioral alignment.

However, they address different technical questions.

Containment Verification establishes framework-level safety through havoc-oracle semantics, modeling the AI as an unconstrained source of typed actions. Its forward-simulation refinement, mechanized in Dafny, verifies that the framework enforces a boundary policy across the modeled action space.

RCA focuses on a specific authorization property within such a boundary: whether a proposed action remains permitted after previous execution has consumed part of the original authority.

Its contribution is the residual-authority state and recovery-closure predicate required for this decision, including partial execution, cross-tool recovery, and uncertain prior effects.

The approaches are therefore complementary. RCA supplies a concrete history-sensitive authorization invariant that a containment-verified framework could enforce. Containment Verification provides a stronger framework-level verification methodology that could, in future work, establish refinement guarantees for an RCA-enabled implementation.

3. Additional evidence from persistent tool execution

We also appreciate the reviewer's observation that the original evaluation relied on simulated settings. To strengthen the execution-level evidence, we added an instrumented SQLite recovery experiment that evaluates actual local committed effects rather than only simulator-generated authorization labels. The experiment covers four failure modes, including commit-with-lost-acknowledgement, partial multi-transaction execution, and fresh-request-ID recovery. A separate SQL observer evaluates committed domain records independently of RCA's decisions.

For each Progent and AgentSpec integration:

  • Unauthorized committed episodes decrease from 10/48 to 0/48.
  • Authorized task completion increases from 38/48 to 48/48.
  • Total task attainment remains 48/48 in both conditions.

The evaluation independently inspects 288 SQLite databases and 1,164 committed operation/outbox receipts across the recorded conditions (Appendix Table 22).

These results establish that RCA's observed benefits extend beyond simulator-assigned safety labels to actual local persistent effects. They do not constitute a production deployment or a measurement of arbitrary external APIs.

Reviewer_C5p4OpenReview ↗

thank you

Very much appreciate the author's demonstration in more real-world-like settings, and this strengthens the case for the work. Cool to see the TLA-based interpretation: has this been brought up in AI circles before?

AuthorsOpenReview ↗

Sincere Gratitude for Your Open-Mindedness, Encouragement, and Contribution to a Positive AI Research Culture

Dear Reviewer,

We sincerely appreciate your encouraging feedback and recognition of our additional experimental evidence. Your thoughtful, open-minded, and constructive engagement means a great deal to us. We believe this kind of scholarly dialogue fosters a healthier research culture, encourages researchers to explore new problems, and contributes meaningfully to the advancement of the AI community.

Regarding your excellent question: Yes, TLA+ and related formal methods have been explored in AI-agent research. For example, TraceFix (Xia et al., ACM CAIS 2026) employs PlusCal/TLA+ and TLC to verify and repair LLM multi-agent coordination protocols, particularly addressing coordination failures and deadlocks. However, TraceFix focuses on the correctness of multi-agent coordination protocols, whereas RCA investigates a fundamentally different security problem: whether recovery actions remain authorized after earlier executions have consumed or altered the authority available for future effects. We sincerely appreciate this insightful question, which helps us further clarify RCA's relationship to existing formal-methods research. If accepted, we will expand the related-work discussion in the camera-ready version, citing relevant TLA+-based agent verification studies and explicitly distinguishing their focus on coordination and protocol correctness from RCA's recovery-specific authorization problem and security invariant. We believe this clarification will further highlight RCA's distinct scientific contribution and its connection to the broader formal verification community.

RCA contributes the identification and formalization of failure-induced authority drift and recovery-closed authorization, establishing a recovery-specific security property that connects realized effects, residual authority, prospective recovery actions, and uncertain execution outcomes.

Our TLA-style interpretation makes this contribution more explicit. It characterizes the trusted effect history, residual authority, and recovery transitions, establishing an invariant that authorized recovery must preserve. Unlike general coordination verification or temporal action constraints, RCA addresses whether a newly proposed recovery remains authorized after earlier realized effects have consumed part of the original grant.

Thus, TLA provides a complementary formal perspective on RCA's recovery-specific authorization problem and security invariant, reinforcing the conceptual and theoretical significance of our contribution. Our current appendix presents a TLA-style interpretation, not a separate TLC-verified specification.

We are especially grateful that you recognized the value of the strengthened execution evidence and engaged constructively with our formalization. Your open-minded approach exemplifies the thoughtful scientific exchange that helps our community progress.

If our additional evidence and clarifications have also strengthened your confidence in assessing the work, we would be grateful if you might consider whether an update to your confidence rating is appropriate, entirely at your discretion.

Thank you again for your valuable time, encouragement, and constructive feedback. We sincerely wish you continued success in your own research and future submissions, and hope your work receives the recognition it deserves.

The Authors

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

This paper studies failure-induced authority drift in tool-using agents, where prior realized effects may invalidate an otherwise permitted recovery action. It proposes Recovery-Closed Authorization (RCA), which tracks realized effects in a trusted ledger and checks prospective recovery effects against residual authority. The paper provides necessity and soundness arguments under a declared effect abstraction and evaluates RCA on synthetic recovery scenarios, held-out compositions, and integrations with existing authorization mechanisms.

Critical strengths
  1. Clear and practically relevant problem. The paper identifies an intuitive authorization risk under partial failures and retries, and clearly distinguishes cumulative authority consumption from per-call authorization.

  2. Clean and conservative design. RCA separates untrusted planning from trusted authorization, explicitly handles uncertain prior effects, and composes conjunctively with existing enforcement mechanisms.

  3. Useful mechanism-isolating experiments. Matched-utility comparisons, matched-information controls, frozen same-candidate replay, and integrations with heterogeneous guards help isolate the contribution of residual-authority checking.

Critical weaknesses

W1. Limited technical novelty and strong trust assumptions. RCA largely amounts to cumulative quota accounting: tracking consumed authority and rejecting prospective effects that exceed the remaining grant. Theorem 1 follows from a straightforward indistinguishability argument, while Theorem 2 is an inductive invariant under the admission rule and faithfulness assumptions. The distinction from durable consumption tracking [1] and commit-time authorization [2] appears incremental. More importantly, constructing faithful prospective-effect envelopes and maintaining reliable ledgers for non-atomic or external APIs—the difficult deployment problems—are assumed rather than solved (Sec. 2.3, Appendix C). The per-root critical section (Appendix C.3) also raises unmeasured concurrency and latency concerns.

W2. Limited discriminative evidence and weak baselines. RecoverBench is procedurally generated, and its evaluator and bounded oracle use the same declared effect abstraction as RCA. Consequently, zero violations under faithful contracts are largely expected from the admission rule. In Table 13, all four compared mechanisms achieve 0% violations and 100% utility on the primary deterministic split. The held-out separation involves 24 cases, while the semantic-OOD violations arise entirely from two families (Table 16). Several other families provide little discrimination. Moreover, LedgerLocal is given the trusted ledger but deliberately ignores cumulative effects in its decision rule. A conventional per-root cumulative budget counter would be a more informative baseline.

W3. Insufficiently reconciled results and limited external validity. The reported metrics vary substantially across tables: StructuredLocal utility is 27.8% in Table 1, 25.93% in Table 6, and 0.5% in Table 8; ModelCandidate violation rates are 52.8%, 14.33%, and 0%, respectively. Although different evaluation slices may explain some differences, the manuscript does not clearly reconcile these results or their implications for the claimed utility improvement. The live experiments rely primarily on one model, one mock domain, and 120 episodes per policy. The benchmark-validity audit also relies on AI-agent annotations rather than independent human validation (Table 23). These limitations weaken the empirical generality of the conclusions.

[1] Xu et al. Beyond Single-Use Tokens: Durable Authorization State for Replay-Resistant LLM Agent Actions. arXiv:2608.01710, 2026.

[2] Santos-Grueiro. Temporary Authority, Permanent Effects: Commit-Time Authorization for LLM Agents. arXiv:2607.10487, 2026.

Questions for authors
  1. Practical novelty. What advantages does RCA provide over a conventional per-root cumulative quota counter, particularly for cross-tool recovery, and what are its latency and concurrency costs under realistic workloads?

  2. Result consistency. Could the authors reconcile the substantially different results in Tables 1, 6, 8, and 10? Appendix J claims automated consistency checks against machine-readable statistics; how were these discrepancies handled, and which results should be considered canonical?

  3. AI-assisted evaluation and disclosure. Table 23 reports a "User-authorized independent-AI surrogate audit" with "2 AI agents" and the status "AI surrogate complete; human claim not made." What exactly were these agents responsible for, how were their annotations and adjudications independently verified, and why is this evaluation-stage AI involvement not described in the AI Use Statement, which mentions only language editing and experimental code assistance?

  4. Provenance and verification of appendix content. Table 23 contains operator-facing wording such as "User-authorized" and "Status: AI surrogate complete," while Tables 13, 14, 18, 20, and 23 contain unexplained task identifiers (A1, A2, A3/B3, A4). Do these originate from internal automated or AI-agent-generated experiment reports? Could the authors clarify how these tables were produced, incorporated into the manuscript, and independently checked for correctness?

2 comments
AuthorsOpenReview ↗

Clarifying RCA's Novelty, Experimental Evidence, and Reproducibility

We thank the reviewer for recognizing the importance of failure-induced authority drift, RCA's conservative design, and our mechanism-isolating experiments. We have strengthened the evaluation and clarified the technical contribution, experimental protocols, and reproducibility.

Anonymous experimental code and data:
https://anonymous.4open.science/r/rca-iclr2027-rebuttal-E965/

Q1. Practical novelty beyond cumulative quota accounting

RCA's contribution is recovery-closed authorization over realized and prospective effects, rather than cumulative accounting alone. It provides a common enforcement invariant across recovery steps, including partial effects, cross-tool actions, shared authority, and uncertain execution outcomes.

We added a stronger comparison using the documented Progent and AgentSpec authorization interfaces (Appendix Table 21). On 255 held-out and semantic-OOD cases:

  • Native per-action authorization: 54/255 unauthorized episodes.
  • Correct prospective per-root amount quota: 39/255.
  • RCA residual-effect authorization: 0/255.

All three retain 141/255 safe task completions. The remaining 39 violations involve cumulative count constraints: 24 duplicate retries and 15 cross-tool duplicates. On 156 amount-applicable cases, the amount quota agrees with RCA.

These results identify the value of enforcing the complete declared residual-effect predicate rather than checking only one accounting dimension. We do not claim that a fully history-aware policy with equivalent trusted state cannot express RCA; documented-hook extensions can reproduce its decisions. RCA makes this recovery authorization invariant explicit and deployable as a compositional gate.

RCA also complements the cited durable-consumption and commit-time authorization mechanisms. Its focus is whether a new recovery action remains authorized after previous realized effects, even when that action is not an exact retry or semantic replay.

Regarding deployment costs, Appendix I reports single-worker CPU p95 checks of approximately 24.9 μs for native per-call authorization, 41.9 μs for scalar accounting, and 1,868 μs for the RCA ledger path. Shared-authority execution uses per-root linearization. These measurements establish the implemented cost under the tested conditions; production-scale concurrency remains a separate evaluation question.

AuthorsOpenReview ↗

Polite Follow-up on Rebuttal

Dear Reviewer,

Thank you for your time and thoughtful review of our submission.

We have provided a detailed rebuttal and additional experimental evidence addressing your concerns. With the discussion deadline approaching on November 18, we would greatly appreciate it if you could review our responses and share any remaining questions or concerns.

We would welcome the opportunity to provide further clarification before the discussion period closes.

Thank you again for your time and consideration.

The Authors

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.