- Rating
- 2
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
The paper looks at how to repair a learned controller when closed-loop reachability verification fails. The idea is that the unsafe action often happens several steps before the violation, so the method backtracks through the reachable sets, solves small look-ahead games to find safe actions earlier on, and then solves all the resulting constraints together while staying close to the original policy. For weightless (lookup-table) controllers the fix becomes an exact circuit patch that leaves the rest of the controller untouched. The authors prove soundness, and termination and completeness under some simplifying assumptions, and show on three benchmarks (ACC, Docking2D, Car2D) that uncertifiable controllers can be repaired and then certified.
Critical strengths
The paper addresses a real gap. Most verification work stops once a controller fails, and here the failed analysis is used to actually fix the controller so that it passes. The baselines it compares to either cannot be certified afterwards or change most of the policy.
I also like the underlying idea of local repair. Since only the parts of the policy that lead to failures get changed, the cost should depend on how unsafe the policy is rather than on the size of the state space, and the rest of what the policy learned is kept. If this holds up, it would be a real advantage over building a safe controller from scratch.
Critical weaknesses
My main concern is that the advantage over existing synthesis methods is not shown. Because the controller is essentially a lookup table over a grid, one could also synthesize a safe controller on the same grid with standard abstraction-based tools (e.g., SCOTS [1], PESSOA [2]), or with lazy variants [3, 4], and then pick the safe action closest to the original policy. The paper does not compare against this, so it is hard to tell what the backtracking and local solving actually buy.
The experiments also do not really test the setting where the method should shine. The systems are small and mostly linear, the strongest results use a losing set that is known in closed form, and the only nonlinear example is a single small case without a baseline. Some of the baselines also start from a different controller, which makes the comparison less clean.
[1] M. Rungger and M. Zamani. SCOTS: A Tool for the Synthesis of Symbolic Controllers. HSCC 2016.
[2] M. Mazo Jr., A. Davitian, and P. Tabuada. PESSOA: A Tool for Embedded Controller Synthesis. CAV 2010.
[3] K. Hsu, R. Majumdar, K. Mallik, and A.-K. Schmuck. Lazy Abstraction-Based Control for Safety Specifications. CDC 2018.
[4] K. Hsu, R. Majumdar, K. Mallik, and A.-K. Schmuck. Lazy Abstraction-Based Controller Synthesis. ATVA 2019.
Questions for authors
How does the method compare with synthesizing a safe controller on the same grid and projecting to the closest safe action? Where does local repair start to win?
How does the runtime scale with grid resolution and state dimension? A scaling experiment would help a lot.
What happens if you only allow one-step repairs? This would directly support the claim that suppressing actions is not enough. How well does the method do without the known losing set in ACC?
Clarification: the termination and completeness results assume no merging and a fixed losing set, while the experiments use both. Could you comment on how often runs timed out or failed in practice?