acceptodds
Under review as a conference paper at ICLR 2027

Learning Oblique Abstractions for the Safety Verification of Oblique DT Policies

Abstract

Deep Reinforcement Learning (DRL) has shown major success. In safety-critical systems, though, a question mark remains on the safety of policies learned by DRL. In this paper, we consider the verification of classical reach-avoid properties for DRL problems. Our approach is the following: i) Consider Oblique Decision Trees (ODTs) as policies, which are more efficient than axis-aligned DT policies, ii) Learn unions of polytopes as abstractions of the sets reached after steps for all till goal is reached (reach-avoid), or as an invariant (pure safety), iii) Verify these candidate abstractions or invariants formally. The main tools we leverage are neurosymbolic architectures encoding ODTs as differentiable neural networks. They have already been shown to generate small ODT policies as efficient as pure Deep RL for Cyber-Physical Systems. The novelty here is to equip them with dedicated loss functions, to learn abstractions and invariants in the form of unions of polytopes. We demonstrate our techniques on \em discrete actions, discrete time environments MountainCar and Quadrotor (reach-avoid) as well as CartPole (safety). The number of polytopes to verify the policy is reduced by 1-2 orders of magnitude compared with using axis-aligned polytopes.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
Safety, Verification, Neurosymbolic Methods, Abstractions, Polytope Abstractions

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_a8ELOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The authors presents a neurosymbolic approach for verifying oblique decision tree policies for reach-avoid specifications (of which safety specifications are a special case). The main idea is to learn abstractions of the reachable states in the form of unions of polytopes and subsequently verify these candidate abstractions using LP/MILP-based symbolic verification. The learning and verification procedures are combined in a counterexample-guided loop. The MountainCar, QuadRotor, and CartPole benchmarks are used to demonstrate the approach. Compared with axis-aligned decision tree policies and axis-aligned abstractions, considerably fewer polytopes are needed in the considered examples.

Critical strengths
  • The addressed problem is relevant.
  • Learning is used to obtain suitable abstraction candidates, while the final containment properties are checked using LP/MILP formulations. This is thus a contribution to the promising direction of "learning for verification".
  • Experiments demonstrate that the number of sets required is reduced.
  • The authors also consider unbounded-horizon safety through invariant sets.
  • The paper contains theoretical results on the existence of ODT certificates for robustly safe ODT policies.
Critical weaknesses
  • The system is formally introduced through a discrete-time successor function, and the paper states that this successor function is given by Runge-Kutta RK4 equations. For CartPole, the original continuous dynamics are integrated with RK4 using a control period of 0.02 to obtain the successor function. RK4, however, only approximates the solution of the underlying differential equations. The verification therefore appears to establish properties of the RK4-discretized model rather than of the original continuous-time system. Unless the numerical integration error is rigorously bounded and incorporated into the reachable sets, it is unclear to me how the claimed guarantees transfer to the continuous dynamics. This distinction is particularly important for a paper whose primary objective is formal safety verification.

  • The considered control systems are restricted to a discrete set of actions. This is explicitly part of the system definition, and the experiments use, for example, eight discrete actions for QuadRotor and two actions for CartPole. This substantially restricts the applicability of the approach. Many real-world cyber-physical control problems involve continuous control inputs. This requires an appropriate justification.

  • The main quantitative comparison emphasizes the number of polytopes. The authors show impressive reductions compared with the axis-aligned baseline. However, this metric alone does not establish computational efficiency. Axis-aligned boxes have particularly simple representations and operations, whereas general polytopes, and especially unions of polytopes, can require substantially more expensive computations. In fact, the proposed containment verification for a union introduces binary variables and an MILP formulation. I am missing a convincing runtime and complexity comparison. Without such a comparison, it is unclear whether reducing the number of sets actually results in computational improvements.

  • Previous reachability and abstract-interpretation approaches have already considered general polytopes. The paper argues that it learns polytopic flowpipes directly and represents abstractions as unions of polytopes. The manuscript should explain much more explicitly what the non-trivial methodological step is in going from existing polytope abstractions to the proposed unions of learned polytopes.

  • The experimental evaluation is too small to assess scalability: MountainCar is two-dimensional, CartPole is reduced from four states to a two-dimensional subsystem for verification, and QuadRotor has six state variables but has additional structure that the implementation exploits. For example, at each QuadRotor step the authors group states according to variables that take only 1–4 distinct values and learn polytopes over only (x,y)(x,y)(x,y) for each group. These are useful proof-of-concept examples, but they provide little evidence that the method scales to higher-dimensional CPS problems.

  • The presentation and language need improvement. There are numerous grammatical problems and typographical errors. Some parts are difficult to understand.

Questions for authors
  1. What exactly is formally verified when RK4 is used for the successor relation? Is the guarantee only with respect to the RK4-discretized dynamics, or is there also a guarantee for the original continuous-time differential equations? If the latter, where is the RK4 truncation error bounded and incorporated into the abstraction?

  2. Could the authors provide a formal treatment of numerical integration error? In particular, could an interval or set-valued enclosure of the RK4 error be incorporated into succ so that verification also covers trajectories of the underlying continuous dynamics?

  3. How could the approach be extended to continuous control actions? The formulation assumes a finite action set and exploits the fact that every ODT leaf corresponds to one fixed action. Is this assumption fundamental to the proposed verification formulation?

  4. What is the computational complexity of NeSyVerif? How does it depend on the state dimension, the number of policy leaves, the number of polytopes, the number of inequalities per polytope, and the number of time steps? The scalability with respect to the number of continuous state variables is the most important one.

  5. Can the authors provide runtime comparisons with the axis-aligned baseline? A reduction from 8241 boxes to 84 polytopes sounds substantial, but fewer sets do not necessarily imply a faster verification procedure because general polytope operations and MILPs are more expensive.

  6. How much of the improvement is attributable to the ODT policy and how much to the oblique abstraction? Interestingly, the appendix already reports NeSyVerif on an AADT policy for MountainCar: 153 polytopes versus 1481 for VeriXAI, while NeSyVerif with an ODT policy requires 129. This suggests that comparing AADT/ODT policies and axis-aligned/oblique abstractions separately could provide considerably more insight.

  7. What is the essential novelty of using unions of polytopes compared with previous work on polytope abstractions? Is the contribution the representation, the adaptive construction of that representation, the loss functions, or the counterexample-guided learning procedure? This should be made more explicit.

  8. Could the authors provide at least one substantially higher-dimensional benchmark where the special low-dimensional reductions used for CartPole and QuadRotor are unavailable?

9 comments

We thank the reviewer for the constructive review. We have answered the questions and addressed the weaknesses, and we will update the PDF in the following days.


A1. We consider the exact same setting as in the [VeriXai, NeurIPS'23] paper. Namely, on line 150, we assume that the dynamics is given by an RK4 equation.

[VeriXAI]: Schilling, Christian, et al. "Safety verification of decision-tree policies in continuous time." NeurIPS’23.


A2. Errors can be incorporated in the verification process. For instance, in Theorem 2, if a policy is ϵ\epsilon-robustly safe, then there exists an invariant for any ϵ′\epsilon'-perturbed system for ϵ′<ϵ\epsilon' < \epsilon. In practice, the closer ϵ′\epsilon' is to ϵ\epsilon, the narrower the invariant will be, and it will be very hard to find. Still, we could account for ϵ′=ϵ/2\epsilon' = \epsilon/2 errors without too many issues. That being said, errors were not part of the [VeriXAI] setting, so we did not incorporate them.


A3. Few works have succeeded in producing concrete results for systems with discontinuities, unlike for continuous systems where many works can be applied. We thus focused on this more challenging discrete-action, discrete-time setting; handling continuous actions has already been dealt with by others.


A4. The learning part handles high dimensions (number of continuous variables) well. Concerning the verification part, we need to check that Next(⋃i≤nPi)Next(\bigcup_{i \leq n} P_i) is included into ⋃j≤mPj′\bigcup_{j \leq m} P'_j. The complexity is linear in mm, polynomially in the number of equations kk of each PP, and potentially exponential in nj<nn_j < n, the number of polytopes PiP_i whose image intersects a given Pj′P'_j: the complexity is in O(∑jknj)O(\sum_j k^{n_j}). There are ways to efficiently compute that when njn_j is not too big (in the paper, brute force was efficient because njn_j was 1 or 2). The number nn depends linearly on the number of leaves in the policy. ODT ensures that nn is reasonably small (compared e.g. to AADT or ReLU NN).


A5. Since training and verification are performed offline (once only), computational efficiency is not crucial. Rather, we claim that more expressive certificates make it possible to synthesize certificates that VeriXAI cannot. Regarding global runtime, our method finds an invariant for CartPole in 1 hour, whereas Fossil 2.0 fails to find one even after 4 hours.

The verification part, which is based on LP and the abstraction-refinement loop, takes negligible time: 1.3 seconds for CartPole invariant. The learning part is what takes time (with the current PyTorch implementation, which is not very efficient). For instance, it took 1 hour to learn sequentially the 2 polytopes to obtain the invariant.

VeriXAI, the axis-aligned baseline, performs reachability analysis alone and does not provide an invariant certificate, so a direct runtime comparison is not meaningful. Moreover, invariants are not axis-aligned in general. Learning an invariant is very challenging for systems with discontinuities (see above for FOSSIL 2.0).

Our main contribution is theoretical, with Theorem 2 showing that simple ODT invariants are sufficient, and experiments show that this is also learnable in practice (in different cases of ODT policies, but also AADT policies in the appendix).


continued...

A6. In short: the ODT policy ensures better policy efficiency (better reward and/or fewer leaves), while the ODT abstractions ensure fewer polytopes and make invariants possible. Notice that AADT abstractions cannot handle ODT policies, while ODT abstractions handle AADT policies better than AADT abstractions.

The appendix results decompose the two effects. With the AADT policy fixed, replacing VeriXAI’s axis-aligned abstraction with our oblique abstraction reduces the polytope count from 1481 to 153. With our oblique abstraction, switching from AADT to ODT reduces it further to 129, partly because the ODT policy also performs better (reward –109 vs. –126). Most of the improvement therefore comes from the oblique abstraction. The axis-aligned abstraction with ODT policy combination cannot be evaluated, since VeriXAI does not support ODT policies, whereas NeSyVerif supports both.


A7. Both VeriXAI and NeSyVerif use unions of polytopes. The difference lies in the shape of the polytopes used in the abstraction. Previous work on polytope abstraction uses fixed polytope templates (axis-aligned hyperrectangles); that is, it does not learn the shape of the polytopes. Our contributions are therefore threefold: (i) an adaptive representation of the abstraction; (ii) adaptive learning, in which we learn the oblique DT and thereby the structure and shape of the polytopes; and (iii) novel loss functions for the discrete-time, discrete-action setting, which differ from those in existing work. And most importantly, Theorem 2 establishes that ODT invariants are sufficient for ODT policies.


A8. Existing work focuses on learning certificates for continuous systems, with continuous-time and continuous-action, and the set of baselines available for comparison for systems with discrete actions in discrete time is limited. We use the baselines from VeriXAI (NeurIPS’23) as is; no special reductions or modifications were made for this work. These environments are challenging, and the fact that our method handles them successfully is itself a contribution, in particular for finding and proving an invariant. For perspective, Fossil 2.0, which was extended to handle discrete actions in discrete time, uses 2D baselines and failed to learn an invariant for the CartPole environment. Extending the method to higher dimensions is planned for future work.

Reviewer_a8ELOpenReview ↗

Formal guarantees and computational complexity

The results do not seem to be formally correct and the computational complexity is exponential in the number of system dimensions. Pointing to another paper that is also not formally correct is not helping much in my opinion.

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

This work proposes a neurosymbolic framework for the verification of safety and liveness verification of dynamical systems with Oblique Decision Tree (ODT) policies. The certificates themselves are ODTs, representing a successive chain of polytopes containing satisfactory trajectories. The polytope abstractions are learned using a differentiable encoding of ODTs (DTSemNet), and then verified or further refined using mathematical optimization until a chain of polytopes representing the reachable set is formed. By construction the polytopes are safe (do not contain any points in a deemed unsafe set), and contain the flow of initial states under a policy, thereby providing a certificate that the policy satisfies reach-avoid specifications. A routine for learning a forward invariant safe set as an ODT is also provided. The ODT representations are more expressive and in general require less nodes compared to the alternative approach of using axis-aligned decision trees. The framework is demonstrated experimentally by generating certificates for mountaincar, quadrotor, and cartpole environments.

Critical strengths

The authors investigate a historically challenging problem and provide a contribution in verification of reinforcement learning policies. The approach is novel, and successfully generates certificates, exploring both safety and liveness specifications. The learned certificates have a small footprint and can be verified quickly and efficiently.

General polytope abstractions undoubtedly are more expressive than axis-aligned polytope abstractions, therefore the generated certificates capture more precise information about the system behavior.

The authors include an anonymous code base which is helpful in understanding the implementation details of their approach and verifying reproducibility of the results.

Critical weaknesses

The authors only consider policies that are themselves decision trees, likely to ensure that verification can be formulated as a linear program. Therefore the application of the verification methods are limited to a small class of policies. Investigation of other applicable policy architectures would strengthen the paper.

The authors compare their work to the closest related work (VeriXAI for axis-aligned DTs) and use the same baselines. There is no discussion of alternative comparisons or novel experiments to conclusively demonstrate that OTDs are definitively the better approach.

Training and verification times are not reported in the paper. A direct comparison to the AADT demonstrating improved verification and training times would strengthen the paper’s claims.

Typos: L244 “datea” L300&302 “negligeabe”

Questions for authors

Can your verification pipeline be applied to FF Relu policies which also have a sound MILP encoding? It would be helpful to know if the use of ODT policies is a choice due to the LP/MILP encoding or if the certificate exploits the policy architecture in a way that is not possible with other policy types that have a MILP encoding.

1 comment

We would like to thank the reviewer for the constructive review. We have addressed the questions and weaknesses, and we will update the PDF in the coming days.


Q1. Can your verification pipeline be applied to FF ReLU policies which also have a sound MILP encoding? It would be helpful to know if the use of ODT policies is a choice due to the LP/MILP encoding or if the certificate exploits the policy architecture in a way that is not possible with other policy types that have a MILP encoding. 

A1. The dynamics is highly non-linear and non-polynomial, so the fact that the ReLU DNN can be encoded in MILP is not sufficient. Hence, it is not accurate that verification can be formulated as a linear program, even for ODTs. We rely on learning abstractions (or invariants), and verify them through an abstraction-refinement loop (which ultimately calls an LP engine that overapproximates the dynamics).

Further, to learn the invariant exactly, the existence of a "simple" ODT invariant is crucial in order to learn the invariant exactly, which is the very decisive result of our paper in Theorem 2. Theorem 2 does not hold for ReLU FF policies as is. Replacing "ODT invariant" with "ReLU Neural Network invariant" would theoretically work in Theorem 2. However, the invariant would be so complicated that learning it exactly is infeasible in practice; even a very close function would not be verified, and tending towards it is not sufficient, which is what the learning ensures. Considering ODT seems necessary.

That being said, there is a misconception that ODT policies restrict the class of problems they can address. Existing works (e.g., DTSemNet [Panda et al. 2026]) show that for Cyber-Physical Systems (less than 100 continuous physical dimensions), ODTs have comparable, if not slightly better, rewards than Neural Network policies, without any drawbacks. Further, the learning process of DTSemNet relies on the exact same Deep RL learning framework used for Neural Networks (e.g., Stable-Baselines3, Adam, PyTorch, etc.), because DTSemNet is just a ReLU neural network. Its specific shape allows us to convert it into a semantically equivalent ODT. In turn, it is true that oblique decision trees make verification easier, which is why we consider them. For instance, Theorem 2 on the existence of an ODT invariant is valid only for ODT policies, not for generic NN policies.


Q2. The authors compare their work to the closest related work (VeriXAI for axis-aligned DTs) and use the same baselines. There is no discussion of alternative comparisons or novel experiments to conclusively demonstrate that OTDs are definitively the better approach. 

A2. For systems with discrete actions in discrete time, which display discontinuity, there is no other working alternative. For instance, our method is the first that can learn the invariant directly; while Fossil 2.0 has a mode to handle discrete actions in discrete time, it fails to learn such invariant for CartPole, even with 4 hours of runtime.


Q3. Training and verification times are not reported in the paper. A direct comparison to the AADT demonstrating improved verification and training times would strengthen the paper’s claims. 

A3. Since training and verification are performed offline (once only), computational efficiency is not crucial. Rather, we claim that more expressive certificates make it possible to synthesize certificates that VeriXAI cannot. Regarding global runtime, our method finds an invariant for CartPole in 1 hour, whereas Fossil 2.0 fails to find one even after 4 hours.

The verification part, which is based on LP and the abstraction-refinement loop, takes negligible time: 1.3 seconds for CartPole invariant. The learning part is what takes time (with the current PyTorch implementation, which is not very efficient). For instance, it took 1 hour to learn sequentially the 2 polytopes to obtain the invariant.

VeriXAI, the axis-aligned baseline, performs reachability analysis alone and does not provide an invariant certificate, so a direct runtime comparison is not meaningful. Moreover, invariants are not axis-aligned in general. Learning an invariant is very challenging for systems with discontinuities (see above for FOSSIL 2.0).

Our main contribution is theoretical, with Theorem 2 showing that simple ODT invariants are sufficient, and experiments show that this is also learnable in practice (for different cases of ODT policies, but also for AADT policies in the appendix).

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

This paper introduces NeSyVerif, a neurosymbolic framework for formally verifying policies represented by oblique decision trees (ODTs). The main idea is to learn unions of general polytopes as candidate reachability abstractions or invariant safety certificates using differentiable ODT representations, and then formally certify these candidates using symbolic LP/MILP-based verification. Counterexamples produced during falsification or formal verification are fed back into the learning procedure. Empirical evaluation on MountainCar, CartPole (2D), and QuadRotor shows that NeSyVerif reduces the number of polytopes required for verification compared to axis-aligned DTs verification baseline. Overall, I find the central idea promising, particularly the use of learned oblique abstractions that can better align with both the policy boundaries and reachable-set geometry.However, I have several concerns regarding novelty, experimental scope, computational efficiency and ablations.

  1.  The overall paradigm of learning candidate invariant/certificate sets and subsequently formally certifying them appears conceptually related to recent work on certificate/invariant learning for neural-controlled systems. In particular, I would like the authors to discuss and clearly distinguish NeSyVerif from:
    

• Harapanahalli, A., & Coogan, S. (2024). Certified robust invariant polytope training in neural controlled odes. arXiv preprint arXiv:2408.01273. • Shi, Z., Li, H., Hsieh, C. J., & Zhang, H. (2024). Certified Training with Branch-and-Bound for Lyapunov-stable Neural Control. arXiv preprint arXiv:2411.18235.

  1.  Experiment section is limited to three discrete case studies and comparison with one baseline. The authors didn’t provide the wall-clock time comparison.  Solving an MILP over general polytopes is NP-hard while checking axis-aligned boxes is linear. Without wall-clock timings for DTSemNet training, Optuna tuning, and Gurobi MILP solving, the efficiency claim sounds incomplete to this reviewer. 
    
  2.  The limitations of the pipeline should be discussed explicitly.
    
  3.  Regarding QuadRotor, can NeSyVerif synthesize a full 6D polytope directly and without grouping? For Cart-pole case study, please add the confidence bounds of reward.
    
  4.  Can authors provide ablations on NeSyVerif different losses and fixed $\beta$ vs adaptive ladder? How sensitive is the method to the hyper-parameters?
    
  5.  Can authors provide comparisons with more baselines?If not, please discuss why.
    
  6.  For theorem 1, is $R_{\delta}$ compact?
    
  7.  Minor: Theorem 2 should be counted as Theorem 1 and Caption of Figure 5: Comparision between VeriTree and NeSyVerif should be corrected to VeriXAI. There are also some typos like: "partitin" in the manuscript.
    
Critical strengths

Please refer to the review

Critical weaknesses

Please refer to the review

Questions for authors

Please refer to the review

1 comment

We thank the reviewer for the constructive review. We have answered the questions and addressed the weaknesses, and we will update the PDF in the following days.


A1. Both works (as well as many others cited in the related work l.117-127 under neural control with certificates) consider continuous systems, with continuous action in continuous time. They cannot handle discrete actions in discrete time, because such systems display discontinuities (see l.150-152). For instance, Theorem 2 is a variant for systems with discontinuities of the converse Lyapunov Theorem, which necessitates continuous systems. We will revise the pdf to make this more explicit.


Q2a. Experiment section is limited to three discrete case studies and comparison with one baseline. 

A2a. Few works succeed in producing concrete results for systems with discontinuities, unlike for continuous systems. VeriXAI [Schilling et al. 23] is such a work, reason why this is the baseline we compare with, for the same environments. Notice that Fossil [Abate et al.] has been extended to handle systems with discrete actions in discrete time, but it is unable to find an invariant for CartPole with discrete actions in discrete time, even with a very long timeout (4hours). For comparison, if time is considered continuous, then Fossil 2.0 finds an invariant in seconds. This is another indication that the setting of discrete actions in discrete time is particularly complicated and deserves specific tools, whereas the setting of continuous systems has plenty of dedicated tools already.

Q2b. The authors didn’t provide the wall-clock time comparison.  Solving an MILP over general polytopes is NP-hard while checking axis-aligned boxes is linear. Without wall-clock timings for DTSemNet training, Optuna tuning, and Gurobi MILP solving, the efficiency claim sounds incomplete to this reviewer. 

A2b. Since training and verification are performed offline (once only), computational efficiency is not crucial. Rather, we claim that more expressive certificates make it possible to synthesize certificates that VeriXAI cannot. Regarding global runtime, our method finds an invariant for CartPole in 1 hour, whereas Fossil 2.0 fails to find one even after 4 hours.

The verification part, which is based on LP and the abstraction-refinement loop, takes negligible time: 1.3 seconds (for CartPole invariant). The learning part is what takes time (with current PyTorch implementation, which is not very efficient). For instance, it took 1 hour to learn sequentially the 2 polytopes to obtain the invariant.


A3. Current tool pipeline focuses on deterministic environments and does not handle stochastic environments.


A4. Yes, NeSyVerif can synthesize a full 6D polytope, but such abstractions are loose and not coarse enough for QuadRotor. The fact is that 4 dimensions take discrete values, so abstracting these dimensions blows up the polytope and its successors. We hence resort, as in [Schilling et al. 23], to a union over the 4D discrete values of polytopes in the remaining 2 dimensions. The polytopes are generated directly as explained in the paper.

For Cart-Pole, we report the mean and std of the reward in Table 1. If a confidence interval (CI) is expected instead, here is the Student-t 95% confidence interval: ODT policy CI is [499.65, 499.90], and AADT policy CI is [405.26, 409.82].


A5. In CartPole, β\beta decreased from 1.0 to 0.917 at epoch 20 and remained there. In Mountaincar β\beta decrease from 1.0 to 0.8, 0.6, 0.4 or 0.2 depending on the step.

So a single fixed β\beta does not work throughout training because the appropriate value depends on the samples. We therefore propose an adaptive β\beta, which adjusts automatically and removes the need to tune β\beta for each polytope. Fixing β\beta too high makes the polytope not sound (e.g., it includes some "unsafe" samples), while making it too low makes the loss almost disregard admissible samples.

Regarding loss ablations, LinL_{in} and LunL_{un} are essential, and removing either one prevents the pipeline from learning a valid abstraction. Removing LadmL_{adm} still produces sound abstractions, but they are often very loose. We will add figures comparing results with and without LadmL_{adm} in the pdf.


A6. There are lots of benchmarks for safety, but fewer are amenable to verification in the more complex setting of a system with discontinuities. We compare to benchmarks in the VeriXAI, NeurIPS'23 paper [Schilling et al. 23], with discrete actions in discrete time. Most existing work focuses on learning certificates for continuous time and/or continuous actions, so the set of baselines available for comparison is limited.


A7. It is not necessarily compact, because we do not require the set to be closed. On the other hand, we require it to be bounded.


A8. Thanks for pointing them out, we will fix them.

Comments on the paper

1 comment

Thank you for your clarifications. I agree that there is not a direct and meaningful runtime comparison of the technique. However, I disagree that computational efficiency is not crucial. Being the first such method for learning invariants, a thorough accounting of its cost would be well warranted, providing an indication of how the technique scales with dimension and policy size. This would also provide a baseline for comparison with future investigations.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.