Pith. sign in

REVIEW 3 major objections 5 minor 15 references

Continuous robot-control policies can be represented as sparse boolean lookup-table circuits and still match deep neural networks on four of five standard benchmarks, with few-clock-cycle latency and nanojoule-level energy per action.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · deepseek-v4-flash

2026-08-03 19:11 UTC pith:2B3FDGG7

load-bearing objection A credible extension of weightless networks to continuous control that deserves review, but the headline efficiency claim only covers the logic core, not the full controller. the 3 major comments →

arxiv 2512.01467 v2 pith:2B3FDGG7 submitted 2025-12-01 cs.LG cs.ARcs.SC

Differentiable Weightless Controllers: Learning Logic Circuits for Continuous Control

Fabian Kresse , Christoph H. Lampert This is my paper
classification cs.LG cs.ARcs.SC
keywords differentiable weightless networkslogic gate networkscontinuous controlreinforcement learningFPGA inferencelow-power controlinterpretable policieslookup tables
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

This paper sets out to show that continuous control—a domain dominated by floating-point neural networks—can instead be handled by sparse boolean logic circuits. It introduces Differentiable Weightless Controllers (DWCs), which convert real-valued observations into thermometer-encoded bitstrings, process them through learned lookup tables connected by a learned sparse interconnect, and convert the final bits into continuous actions with a simple popcount and affine mapping. Trained end-to-end with standard gradient-based reinforcement learning, DWCs match or exceed full-precision and quantized neural baselines on Ant, Hopper, Humanoid, and Walker2d, and come close on HalfCheetah, where the paper argues the gap is a matter of circuit capacity rather than a fundamental limitation. On an entry-level FPGA, the resulting circuits use no DSP blocks, reach 100 million actions per second with 2–3 cycle latency (one cycle for the smallest variant), and consume about two nanojoules per action. The authors also show that learned connectivity is sparse and consistent across random seeds, offering direct insight into which observation dimensions and thresholds drive control decisions.

Core claim

The paper's central claim is that weight-based neural networks are not necessary for continuous control: a controller built entirely from boolean lookup tables can be trained with backpropagation-style surrogate gradients and, once trained, executes as a pure digital circuit. The DWC pipeline fixes input thresholds at stretched-Gaussian quantiles of a normalized observation distribution, so each real-valued input becomes a 63-bit thermometer code; two layers of arity-6 lookup tables with learned interconnect compute a sparse boolean feature vector; and a per-action group sum, scaled and shifted by learned affine parameters, produces the continuous action. Across five MuJoCo environments, DWC

What carries the argument

The load-bearing machinery is the differentiable weightless network (DWN) turned into a controller: layers of k-input, single-bit-output lookup tables (LUTs) whose tables and sparse input connections are learned via the extended finite-difference surrogate gradient, so gradients can flow through discrete boolean operations. Two adaptations make it a controller: a data-adaptive thermometer input encoding with quantile thresholds (63 levels per dimension), and a continuous-output head that replaces the classification softmax with a per-action group sum, an affine transform, and an optional tanh; at inference this head collapses to a popcount followed by an SRAM lookup. Because every operation

Load-bearing premise

The few-cycle and nanojoule figures assume that observation normalization, clipping, and the final action-scaling table live outside the FPGA; if those steps must be implemented on-chip in the same circuit, the stated latency and energy per action undercount the complete controller.

What would settle it

Synthesize the complete pipeline—normalization, thermometer encoding, both LUT layers, popcount, and the SRAM action lookup—on the same small FPGA, run at 100 MHz, and measure end-to-end latency and power; if the full circuit exceeds a few clock cycles or several nanojoules per action, the headline efficiency claim is not supported. A second check: on HalfCheetah, a 16k-LUT/255-level DWC should reach the floating-point median of 11.5k return, not just the quantized 10.4k, if capacity is truly the only bottleneck.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • DWC policies can replace weight-based controllers on four of the five tested MuJoCo tasks without losing reward, while cutting inference latency from microseconds and tens of thousands of cycles down to 2–3 clock cycles.
  • The efficiency path is not limited to simulation: because the core uses only LUTs and flip-flops, it fits on very small FPGAs and leaves DSPs and block RAM unused, opening deployment on ultra-low-resource robots and wearables.
  • The sparse, consistent first-layer connectivity means a trained controller can be inspected to see which observation dimensions receive no connections at all; on Humanoid roughly a quarter of dimensions are unused, indicating they can be dropped without harming performance.
  • On HalfCheetah, performance grows monotonically with LUT count and input resolution, isolating network capacity as the limiting factor and showing that DWC scaling is a predictable route to closing remaining gaps.
  • The high training cost (several floating-point parameters per boolean gate, plus a 25-GPU-day hyperparameter search for PPO) means DWCs are currently trained in simulation, not on-device; the authors state this as an open limitation.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The paper's efficiency numbers assume the thermometer encoding and final SRAM action lookup live off-chip; the true end-to-end budget for a fully integrated controller on the same FPGA would likely be a few extra cycles and modestly higher energy, so the practical edge over quantized networks should be measured with those included.
  • Because a DWC is an ordinary boolean circuit, the formal-verification techniques developed for logic-gate networks could be applied directly to these policies, potentially producing controllers with certified safety properties—a natural next step the paper does not pursue.
  • The capacity curve on HalfCheetah suggests a practical design rule: pick LUT count and bit width from a target return, then read off the required FPGA resources; one could test this by extrapolating from the reported widths (128 to 16,384).
  • The interpretability finding—that connectivity concentrates near observation value zero with two modes—invites the hypothesis that DWCs implement bang-bang control around set-points; testing which LUTs toggle during episodes would make the learned policy's regime structure explicit.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

3 major / 5 minor

Summary. The paper proposes Differentiable Weightless Controllers (DWCs), a discrete-logic architecture for continuous control. Real-valued observations are normalized and thermometer-encoded into bitvectors, processed by sparse layers of k-input boolean LUTs with learnable interconnect, and final group-sum/popcount outputs are mapped through per-action affine/tanh heads. Training is performed end-to-end with SAC (and DDPG/PPO in the appendix) using surrogate gradients. The paper reports median returns over 10 seeds for five MuJoCo tasks, showing parity with a floating-point SAC baseline and a quantized baseline on four tasks and a gap on HalfCheetah, which a larger DWC model reduces. FPGA synthesis (Table 2) reports very low resource usage, 1–3 cycle latency, and ~2 nJ per action for the implemented LUT core. Ablations cover layer width, LUT arity, input bit-width, number of layers, and noise robustness, and connectivity statistics are used for input-feature diagnostics.

Significance. If the efficiency claims hold, DWCs would be a meaningful advance in deploying learned continuous-control policies on tiny FPGAs: a sparse boolean LUT policy with RL-comparable returns and single-digit-cycle latency has practical value for drones, wearable devices, and other low-power platforms. The paper is careful in several ways: it trains 10 seeds per configuration for the main SAC results, reports standard baselines and confidence quantiles, studies noise robustness, includes extensive ablations, and performs actual vendor-tool synthesis rather than estimating. The interpretability analysis via connectivity statistics is a useful, albeit limited, diagnostic. The main reservations concern the scope of the efficiency accounting and the controlledness of the HalfCheetah capacity experiment; both appear fixable within the manuscript's scope.

major comments (3)
  1. [§4.3 (Table 2) and §3.2] The reported synthesis covers only the LUT/popcount core. §3.2's deployment description places an SRAM lookup after the popcount and an integer-to-thermometer lookup per sensor channel in the pipeline, while §4.3 assumes 'all observation normalization steps and the final BRAM lookup for the action scaling take place outside of the FPGA.' The abstract and Section 1 claim 'few- or even single-clock-cycle latency and nanojoule-level energy cost per action' for the DWC controller as a whole, not for the core alone. For Humanoid, B=63 thresholds across 376 observation dimensions implies tens of thousands of threshold comparisons per action, which can exceed the 10,400 LUT6 budget of the Artix-7 XC7A15T. Please synthesize the complete pipeline, or explicitly re-scope the efficiency claim to the LUT core throughout the abstract, introduction, and conclusions.
  2. [§5.1 (HalfCheetah high-capacity run)] The special HalfCheetah run changes three design choices simultaneously: layer width (1024 -> 16,384), thermometer bit-width (63 -> 255), and second-layer interconnect (learnable -> randomly initialized and fixed). The improvement from 7.5k to 10.3k cannot therefore be attributed to 'network capacity' alone; the earlier text itself lists 'smoother actions' as an alternative. I recommend a controlled experiment varying width alone at B=63, and B alone at D_l=1024, and reporting the number of seeds for the 16,384-LUT run. The claim that the result 'falls within the region of uncertainty' of the FP baseline should be quantified with CIs or rank-based tests.
  3. [§4.3 (Table 2)] The comparison of energy per action and power against the quantized baselines is only meaningful if both sets of numbers are produced by the same estimation methodology. The text says 'our values for power estimation are based on the toolchain's post-implementation power report, rather than the less accurate Vivado Power Estimator,' which suggests the DWC numbers and the Kresse & Lampert (2025) numbers may have been obtained with different tools. Please clarify whether the baseline rows were recomputed with the post-implementation report as well; otherwise the 'orders of magnitude' improvement may be partly a tool artifact.
minor comments (5)
  1. [Throughout] Typos and inconsistencies: 'cconsist' (Section 1), 'Prunning' (Appendix A), 'enviroments' (Appendix E figure captions), 'V ouros' in references, '32klookups' (Section 5.1). Please also make the notation for layer width consistent between the text (D_l), figures ('l'), and tables.
  2. [§3.2] Equation (1) defines z_d with a 'normalise' typo, and the deployment text says 'an SRAM then implements the mapping from this popcount to the emitted control word' — clarify whether this SRAM is a separate BRAM block or is meant to be folded into the LUT core, to align with the efficiency discussion.
  3. [§5.2] The sentence 'a large number of observation dimensions receive no connections at all (on average 275 out of 376 receive a connection)' is potentially confusing: I think it means 275 receive a connection, so about 101 receive none. Rephrase for clarity.
  4. [Table 2] The column header 'B' for BRAM count may be confused with the thermometer bit-width B defined in Section 3.1. Consider renaming to 'BRAM' or 'RAMB36'.
  5. [§4.3] The sentence about the 'only difference' to the Kresse & Lampert setup needs rewriting to make clear which numbers were produced by which power-estimation method. As written, it can be read in two conflicting ways.

Circularity Check

0 steps flagged

No circular derivation: the central claims are measured returns and post-synthesis resource reports, not fitted predictions or definitional identities.

full rationale

The paper's central assertions are empirical. DWC returns are obtained by training 10 seeds and evaluating 1000 rollouts per model on standard MuJoCo tasks (Table 1, Figure 3), and the efficiency numbers are post-synthesis reports from Vivado for an Artix-7 (Table 2). Nothing in the training or evaluation pipeline fits a parameter to the reported quantity and then calls it a prediction. The thermometer thresholds, LUT entries, interconnects, and action-head scales are learned, but the reported returns are measured rollouts, not quantities derived from those fitted values by construction. The resource/latency/energy claim is explicitly scoped: Section 4.3 states 'we assume that all observation normalization steps and the final BRAM lookup for the action scaling take place outside of the FPGA.' That is a limitation in the fairness of the efficiency comparison, not a circular reduction; it does not make the synthesis numbers equal to an input. The paper also cites prior work by the same group for baselines and for the choice to make later-layer interconnects learnable (Kresse & Lampert 2025; Kresse et al. 2025b), but these are used as independent prior experiments or design choices, not as a substitute for the derivation. The central comparisons are externally grounded by standard MuJoCo benchmarks and a standard CleanRL SAC baseline. No equation defines the claimed result in terms of the result itself, and no fitted parameter is renamed as a held-out prediction. Therefore no significant circularity is present.

Axiom & Free-Parameter Ledger

7 free parameters · 5 axioms · 0 invented entities

The paper introduces no new physical entity; the DWC is a new architecture built from existing LUT/weightless-network components. The key external inputs are free hyperparameters (B, k, D_l, L), a fixed thresholding scheme, and assumptions that prior surrogate-gradient machinery transfers to RL and that off-chip preprocessing is acceptable for the efficiency numbers.

free parameters (7)
  • Thermometer bit width B = 63 (default); 255 used in the high-capacity HalfCheetah run
    Number of thresholds per input dimension chosen by hand; ablated in Appendix E. Larger B clearly helps HalfCheetah.
  • Thermometer threshold placement = stretched-Gaussian quantiles with clip range ±10
    Section 3.1 fixes thresholds by a hand-designed formula; thresholds are not learned and are identical for all dimensions.
  • LUT arity k = 6 (default)
    Number of binary inputs per lookup table, chosen to match FPGA LUT6 hardware; ablated in Appendix D.
  • Layer width D_l = 1024 (default); 256 for small models; up to 16384 for the special HalfCheetah model
    Number of LUTs per layer; capacity hyperparameter chosen per experiment, not learned. The HalfCheetah run also changes this value.
  • Number of layers L = 2 (default)
    Depth chosen by hand; one layer often suffices, while HalfCheetah benefits from more layers (Appendix E).
  • Action-head initialization (alpha_d, beta_d) = alpha_d initialized to restrict initial actions; beta_d not specified in detail
    Initialization strategy comparable to low-standard-deviation final layer in RL; affects learning dynamics but exact values are not reported.
  • HalfCheetah high-capacity run settings = D_l=16384, B=255, second-layer interconnect random and fixed
    Ad hoc configuration used to close the HalfCheetah gap; changes capacity and input resolution simultaneously, so capacity is not cleanly isolated.
axioms (5)
  • domain assumption Discrete LUT networks can be trained in RL through the EFD surrogate-gradient and learnable-interconnect machinery of Bacellar et al. (2024) and Kresse et al. (2025b).
    No proof is given that these gradients work for off-policy RL; Section 2.2 invokes these prior methods as the training foundation.
  • domain assumption MuJoCo v4 environments with the CleanRL SAC protocol are a valid proxy for continuous-control performance.
    The central empirical claim is based on these benchmarks and hyperparameters; no real-world closed-loop deployment experiments are reported.
  • domain assumption Fixed thermometer encoding with 63 thresholds and ±10 clipping preserves enough information for good control.
    Thresholds are not learned (Section 3.1); the paper validates indirectly via ablations, not by a bounded-error or representational argument.
  • domain assumption Reported FPGA synthesis (OOC, 100 MHz, Artix-7) with observation normalization and final action-scaling lookup excluded is representative of deployable efficiency.
    Section 4.3 explicitly assumes those parts are off-chip; the few-cycle/nanojoule claim depends on this exclusion.
  • domain assumption Baseline FP and Quant returns from Kresse & Lampert (2025) are comparable to the new DWC runs without re-running baselines in this paper's codebase.
    Tables 1 and 3 reuse baseline numbers from the same authors' prior paper; protocol is claimed identical but no shared code or artifacts are provided.

pith-pipeline@v1.3.0-alltime-deepseek · 17078 in / 15348 out tokens · 150365 ms · 2026-08-03T19:11:19.777624+00:00 · methodology

0 comments
read the original abstract

Controlling autonomous systems under real-world conditions often requires policies that can be evaluated with low latency and minimal energy consumption. Unfortunately, these conditions are at odds with the use of high-precision deep neural networks as controllers. In this work, we introduce Differentiable Weightless Controllers (DWCs), a symbolic-differentiable architecture that learns flexible, non-linear, yet highly efficient control policies. DWCs can be trained end-to-end via gradient-based techniques, yet compile directly into FPGA-compatible circuits with few- or even single-clock-cycle latency and nanojoule-level energy cost per action. Across five MuJoCo benchmarks, including high-dimensional Humanoid, DWCs achieve returns competitive with standard deep policies (full-precision or quantized neural networks). Furthermore, DWCs exhibit structurally sparse and interpretable connectivity patterns, enabling direct inspection of which input values influence control decisions.

Figures

Figures reproduced from arXiv: 2512.01467 by Christoph H. Lampert, Fabian Kresse.

Figure 1
Figure 1. Figure 1: Differentiable Weightless Controllers (DWCs): real￾valued observations are thermometer-encoded into bitvectors, pro￾cessed by two layers of multi-input boolean-output lookup tables (here drawn with 2 inputs), aggregated by group summation, and mapped via per-action memory lookups to final action values. However, policies implemented as neural networks rely on large numbers of compute-intensive multiply and… view at source ↗
Figure 2
Figure 2. Figure 2: DWC thermometer threshold positions. where addr(·) maps the k-bit vector to its integer index. Concatenating all output bits yields b (ℓ+1) . Group aggregation. To allow for multi-dimensional out￾puts, the final binary features b (L) of a DWN are partitioned into disjoint groups. For a group G, a group sum is com￾puted, sG = 1 τ X i∈G b (L) i , with a temperature τ > 0 used as a scale during training. For … view at source ↗
Figure 3
Figure 3. Figure 3: Mean return and standard deviation for ten models evaluated across the training steps, ten evaluation episodes per datapoint and model. Except for HalfCheetah (see main text), training trajectories are comparable to the FP baseline. Environment Reward LUTs FFs B DSP Lat [µs] P [W] TP E.p.A. [J] Dℓ = 256 Ant 4.5k[3.4k, 5.2k] 0.8k 0.5k 0 0 0.01 0.105 1.0 × 108 1.1 × 10−9 HalfCheetah 7.1k[6.0k, 7.9k] 0.8k 0.4… view at source ↗
Figure 4
Figure 4. Figure 4: Policy returns for FP, Quant and DWCs with varying LUT layer widths. Generally, already models with 256 to 512 LUTs per layer achieve returns on par with the FP baseline. Only for HalfCheetah, we observe a monotonically increasing median return with increasing LUT layer width. * indicates a special high-capacity model with 16k-LUTs per layer and 255-bit per input dimension, see Section 5. due to a higher o… view at source ↗
Figure 5
Figure 5. Figure 5: Reward performance under injected observation noise with varying noise level σ. Floating-point (FP), QAT policies from Kresse & Lampert (2025) and our DWCs on MuJoCo tasks. Bands show one standard deviation across trained models. The quantized models and DWCs perform better, or on par, with the FP baseline under injection, except for Humanoid, where the smaller DWCs show reduced rewards for larger noise. 0… view at source ↗
Figure 6
Figure 6. Figure 6: Number of connections received for (sorted) input dimension averaged over trained DWCs (Dℓ = 1024) for all five environments. 0 32 0 100 200 300 400 Connections Ant 0 32 HalfCheetah 0 32 Hopper 0 32 Humanoid 0 32 Walker2d [PITH_FULL_IMAGE:figures/full_fig_p008_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: Distribution of connections per threshold bit index across all environments. We consistently observe a two-modal distribution slightly left and right of the center (index 31, corresponding to normalized observation value 0). corresponds to the normalized observation value of 0, index 0 corresponds to the normalized value of −10 and index 63 to 10 (Section 3). Perhaps unsurprisingly, the highest connectivit… view at source ↗
Figure 8
Figure 8. Figure 8: Showing floating-point (FP) baseline returns across environments and DWCs with varying LUT-inputs (l = 1024). Generally, already models with 2-input LUTs achieve returns comparable to the FP baseline. Only for HalfCheetah, we observe a generally monotonically increasing median return with increasing LUT table size. Ant HalfCheetah Hopper Humanoid Walker2d 0 5 10 Reward ×1000 FP Quant B = 5 B = 31 B = 63 B … view at source ↗
Figure 9
Figure 9. Figure 9: Showing floating-point baseline and DWCs return across enviroments with varying input bit width B. While having only 5 threshold bits per layer can harm policy performance. For most environments, 63 input bits suffice to saturate returns. As in other cases, the exception is HalfCheetah, which benefits monotonically from more fined-grained input binarizations. the learned per-bit index connectivity for all … view at source ↗
Figure 10
Figure 10. Figure 10: Showing floating-point baseline and DWCs return across environments with varying number of layers L. For Dℓ=1024, one layer generally suffices for attaining floating-point performance. Again, HalfCheetah, seems to benefit from additional layers, and hence, increased capacity. 0 32 0 20 40 60 80 Bit Index Connections Ant 0 32 Bit Index Hopper 0 32 Bit Index Walker2d 0 32 Bit Index Humanoid 0 32 Bit Index H… view at source ↗
Figure 11
Figure 11. Figure 11: Distribution of connections per Bit Index across all environments. l = 128 [PITH_FULL_IMAGE:figures/full_fig_p016_11.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

15 extracted references · 8 linked inside Pith

  1. [7]

    The impact of quantization and pruning on deep reinforcement learning models.arXiv preprint arXiv:2407.04803,

    Lu, H., Alemi, M., and Rawassizadeh, R. The impact of quantization and pruning on deep reinforcement learning models.arXiv preprint arXiv:2407.04803,

    Pith/arXiv arXiv

  2. [9]

    Differentiable logic cellular automata: From game of life to pattern generation.arXiv preprint arXiv:2506.04912,

    Miotti, P., Niklasson, E., Randazzo, E., and Mordvintsev, A. Differentiable logic cellular automata: From game of life to pattern generation.arXiv preprint arXiv:2506.04912,

    Pith/arXiv arXiv

  3. [12]

    and pruning deep continuous control RL policies, or both simultaneously (Ivanov et al., 2025; Lu et al., 2024)—which reduces their memory footprint and computational cost— showing that substantial pruning (≥95% ) (Graesser et al., 2022; Tan et al.,

    2025

  4. [13]

    and quantization of most of the network to 3 or 2-bits is possible without harming policy returns (Kresse & Lampert, 2025). Additionally, there has been work on binary, one-bit, quantized RL policies (Lazarus & Kochenderfer, 2022; Kadokawa et al., 2021; Chevtchenko & Ludermir, 2021; Valencia et al., 2019). However, these focus on discrete action spaces or...

    2025

  5. [15]

    The hyperparameter search for DWCs took 25 days of compute, which we distributed over 10 GPUs

    using the Tree-Structured Parzen Estimator with 100 trials. The hyperparameter search for DWCs took 25 days of compute, which we distributed over 10 GPUs. Table 4.SAC hyperparameters. Hyperparameter Value Total timesteps1,000,000 Replay buffer size1×10 6 Discountγ0.99 Target smoothingτ0.005 Batch size 256 Learning starts5×10 3 Policy LR3×10 −4 Q-network L...

    2048

  6. [1994]

    High- performance reinforcement learning on spot: Optimizing simulation parameters with distributional masures.arXiv preprint arXiv:2504.17857,

    Miller, A., Yu, F., Brauckmann, M., and Farshidian, F. High- performance reinforcement learning on spot: Optimizing simulation parameters with distributional masures.arXiv preprint arXiv:2504.17857,

    Pith/arXiv arXiv

  7. [2012]

    and Kochenderfer, M

    Lazarus, C. and Kochenderfer, M. J. Deep binary reinforce- ment learning for scalable verification.arXiv preprint arXiv:2203.05704,

    Pith/arXiv arXiv

  8. [2016]

    H., and Ojalvo, I

    Gerlach, L., Kauffman, E., V ˚age, L. H., and Ojalvo, I. Rapid inference of logic gate neural networks for anomaly detection in high energy physics.arXiv preprint arXiv:2511.01908, 2025a. Gerlach, L., V˚age, L., Gerlach, T., and Kauffman, E. W ARP- LUTs-walsh-assisted relaxation for probabilistic look up tables.arXiv preprint arXiv:2510.15655, 2025b. Ghol...

    arXiv

  9. [2018]

    Re- current deep differentiable logic gate networks.arXiv preprint arXiv:2508.06097,

    B¨uhrer, S., Plesner, A., Aczel, T., and Wattenhofer, R. Re- current deep differentiable logic gate networks.arXiv preprint arXiv:2508.06097,

    Pith/arXiv arXiv

  10. [2019]

    Proximal policy optimization algorithms

    Schulman, J., Wolski, F., Dhariwal, P., Radford, A., and Klimov, O. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347,

    Pith/arXiv arXiv

  11. [2020]

    What matters in on-policy rein- forcement learning? a large-scale empirical study.arXiv preprint arXiv:2006.05990,

    Andrychowicz, M., Raichuk, A., Sta´nczyk, P., Orsini, M., Girgin, S., Marinier, R., Hussenot, L., Geist, M., Pietquin, O., Michalski, M., et al. What matters in on-policy rein- forcement learning? a large-scale empirical study.arXiv preprint arXiv:2006.05990,

    Pith/arXiv arXiv 2006

  12. [2022]

    Mind the gap: Removing the discretization gap in differentiable logic gate networks.arXiv preprint arXiv:2506.07500,

    Yousefi, S., Plesner, A., Aczel, T., and Wattenhofer, R. Mind the gap: Removing the discretization gap in differentiable logic gate networks.arXiv preprint arXiv:2506.07500,

    arXiv

  13. [2023]

    and Lampert, C

    Kresse, F. and Lampert, C. H. Learning quantized con- tinuous controllers for integer hardware.arXiv preprint arXiv:2511.07046,

    Pith/arXiv arXiv

  14. [2024]

    Various other improvements to scalability and convergence have also been performed (Kim, 2023; Yousefi et al., 2025; Yue & Jha, 2024)

    and the original formulation, which required2kk parameters for k-input LUTs was improved to only require 2k parameters per LUT (Bacellar et al., 2024; Gerlach et al., 2025b). Various other improvements to scalability and convergence have also been performed (Kim, 2023; Yousefi et al., 2025; Yue & Jha, 2024). Most commonly, DBNs have been applied to small-...

    2024

  15. [2025]

    Kresse, F., Yu, E., Lampert, C., and Henzinger, T. A. Logic gate neural networks are good for verification. InInter- national Conference on Neuro-symbolic Systems (NeuS), 2025a. Kresse, F., Yu, E., and Lampert, C. H. Scalable inter- connect learning in boolean networks.arXiv preprint arXiv:2507.02585, 2025b. Krishnan, S., Lam, M., Chitlangia, S., Wan, Z.,...

    arXiv