△ Mechanism confirmed, baseline not beaten 2026

Finite Hyperplane Representative Verification

Implementation & benchmark of arXiv:2608.07908 — Computing the Maximal Controlled Invariant Set for Neural Network Control Systems

Usefulness7/10

Difficulty7/10

Novelty8/10

Architecture Speedup Stability Scalability Rl Mlp Inference speedup Training Geometry Control theory Numerical analysis Optimization

Source paper: Computing the Maximal Controlled Invariant Set for Neural Network Control Systems arXiv:2608.07908 ⓘ · analyzed Sep 1, 2026

AI-generated research hypothesis, automatically tested. Not peer-reviewed.

Idea description

Replace dense continuous action search during neural-controller verification with a finite set of representative inputs induced by affine pieces of the interval neural dynamics. This makes safety checking parallel over state cells and candidate actions, enabling much cheaper certification or repeated safe-set updates.

Formulas

$$\mathrm{Pre}(\mathcal{S})=\{x\in\mathcal{X}:\exists u\in\mathcal{U},\;f(x,u)\in\mathcal{S}\}.$$

$$F([x],u)=[\ell([x],u),r([x],u)],\qquad \ell_j([x],u)=a_j^{\top}u+b_j,\quad r_j([x],u)=\bar a_j^{\top}u+\bar b_j.$$

$$P=\{z:Gz\le h\},\qquad F([x],u)\subseteq P\ \Leftarrow\ G_{k,:}r([x],u)\le h_k\ \text{and}\ G_{k,:}\ell([x],u)\le h_k\ \text{for all }k.$$

$$\mathcal{H}=\{u\in\mathcal{U}:a_i^{\top}u+b_i=0\text{ for some }i\},\qquad U_{\mathrm{rep}}=\{\text{vertices and one interior point of each cell of }\mathcal{U}\setminus\mathcal{H}\}.$$

Mathematical statement

The paper constructs a control-affine inclusion function for the neural-network control system and exploits the induced hyperplane arrangement in the input space. The transferable principle is that if the interval transition bound has affine dependence on u within each region, then extrema relevant to checking membership in a convex target cell occur on boundary vertices or arrangement representatives rather than requiring an infinite search over all u. For a state box [x], write an inclusion bound as F([x],u)=[A^{-}[x]+B^{-}u+c^{-},A^{+}[x]+B^{+}u+c^{+}] or, more generally, componentwise affine bounds ell_j(u)\le f_j(x,u)\le r_j(u). If the target safe cell is the polytope P=\{z:Gz\le h\}, a sufficient action certificate is G F([x],u)\le h componentwise. Each inequality is affine in u, so its sign changes occur on hyperplanes a_i^{ op}u+b_i=0. These hyperplanes partition U into cells; evaluating one representative and the relevant vertices per arrangement cell is a finite surrogate for continuous control search. The exact predecessor object is Pre(S)=\{x\in X:\exists u\in U, f(x,u)\in S\}; a state is retained when some representative action maps its interval image into the current target set.

Implementation notes

Use this inside a verifier or safe-set builder, not inside the main high-dimensional training loop. Partition the state domain into boxes and process boxes in parallel on GPU or CPU workers. For each box, propagate interval bounds through the plant and controller, then extract affine action bounds ell_j(u)=a_j^T u+b_j and r_j(u)=bar_a_j^T u+bar_b_j over the local neural activation region. Build the hyperplanes where any bound or target-polytope inequality can change activity. In one or two action dimensions, explicitly enumerate arrangement cells by intersecting half-spaces; retain each cell's vertices and a centroid. In higher action dimensions, use all box vertices plus random interior representatives as an approximation and compare against dense Monte Carlo action search. For each representative u, test interval containment in the target set and mark the state box as belonging to the predecessor if any candidate succeeds. Pseudocode is: for xbox in parallel: bounds=interval_propagate(xbox); H=make_hyperplanes(bounds,target); Urep=arrangement_representatives(H,U); keep[xbox]=any(interval_image(bounds,u) subset target for u in Urep). Exact arrangement completeness is computed only in small action dimension; sampling error is estimated by an independent dense action sweep. Begin with a 2D Dubins car or point-mass system and a small ReLU residual controller. Compare exhaustive 1,000-action verification with representatives and naive random sampling. Success is a 10x or larger reduction in action evaluations at equal certification rate, with no false certificates on an independently much denser action grid.

Verification

Mechanism confirmed, baseline not beaten

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Confirmed ✓

Stage 2 · Practical benchmark result: Inconclusive

Methodology: 8 paired seeds, permutation test (p<0.05) against a learning-rate-tuned baseline. How verification works

Stage 1 — Mechanism check agent confidence 8/10

Built a 2D affine hyperplane-arrangement verifier using polygon clipping, cell centroids, and boundary vertices. For H={2,4,8,12,16}, representatives matched the dense oracle in every case, arrangement cell counts stayed below the predicted quadratic bound, and evaluation reductions ranged from 129x to 6.3x. Boundary-only feasibility was detected via retained vertices, while random sampling repeatedly missed feasible regions.

Agent confidence: 8/10

Baseline: A 41x41 dense action grid used 1,681 evaluations per case. Random sampling missed certificates in 2/10, 7/10, and 7/10 cases with 20 actions for H=4,8,12; with 100 actions it missed 0/10, 4/10, and 5/10.
Idea: Arrangement representatives used 13, 27, 83, 167, and 267 evaluations for H=2,4,8,12,16, giving 129.31x, 62.26x, 20.25x, 10.07x, and 6.30x reductions, with 100% agreement against the dense-plus-known-feasible-point oracle.

Limitations: This is a small affine 2D verifier, not a full ReLU neural controller, plant interval propagator, GPU implementation, or parallel safe-set builder. Higher-dimensional arrangement enumeration was not tested, and the oracle included a known feasible interior point in addition to the 41x41 grid. The saved run took about 69 seconds.

How to run: python3 experiment.py

Stage 2 — Benchmark vs. tuned baseline (arXiv:2608.07908) Sep 2, 2026

Ahead of the baseline (−9.9%) but not statistically significant (p=0.0886, wins 7 / 8 paired seeds).

Benchmark: Dynamics forecasting
Model: rnn_small
Paired seeds: 8
Baseline mean: 0.0126
Idea mean: 0.0114
Effect (Δ): -0.0012 (−9.9%; negative = idea better)
Wins: 7 / 8 paired seeds
p-value: 0.0886 (permutation test, 20 000 shuffles)
Smallest detectable effect: ±11.1%
Mechanism: Confirmed ✓
Practical effect: Inconclusive
Baseline tuning: swept over 3 configs

Limitations:

Only the built-in controlled-pendulum dynamics track was tested, with 400 training samples, 200 test samples, 6 epochs, and a one-dimensional local Euler affine surrogate. The intervention used a fixed zero-centered safe target and selected actions at inference; it did not implement a full multidimensional ReLU activation-region verifier, interval plant propagation, GPU parallel cell processing, or a multi-step certified safe-set builder. The standard-metric comparison was not significant.

How to run: python3 stage2_hyperplane_bench.py

Verdict computed by deterministic test code from paired-seed statistics — not by the language model.

Stage 2 — Benchmark Sep 1, 2026 latest Failed ✗

Agent confidence: 9/10

Built a local finite-hyperplane representative action selector for the controlled-pendulum dynamics task using the shared rnn_small architecture and canonical training path. The mechanism signature was quantitatively confirmed: 3.03 representative actions versus 101 dense actions per state, with representative MSE within 0.004% of dense-search MSE. However, the paired test gave delta_mean=-0.001248 and p=0.0886, so this is an efficiency signal but not a significant standard-metric win.

Baseline: Best lr=0.006, epochs=6; 8-seed test MSE mean=0.01260863, std=0.00743564.
Idea: Best lr=0.006, epochs=6; 8-seed test MSE mean=0.01136049, std=0.00724772; paired delta=-0.00124814, 7/8 wins, permutation p=0.0886. Mechanism: 3.03 representatives/state versus 101 dense actions/state, 33.33x fewer evaluations; representative MSE=0.00810880 versus dense-best MSE=0.00810909.

Benchmark result