Paper deep dive
An Embedded RISC-V Evaluation of Kolmogorov--Arnold Networks in Hard-Constrained Recurrent Physics-Informed Models
Enzo Nicolas Spotorno, Josafat Leal Filho
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 91%
Last extracted: 8/4/2026, 4:56:49 AM
Summary
This paper evaluates the deployment efficiency of Kolmogorov-Arnold Networks (KANs) versus Multilayer Perceptrons (MLPs) as residual branches in Hard-Constrained Recurrent Physics-Informed Neural Networks (HRPINNs) on embedded RISC-V hardware. The study finds that while KANs are parameter-efficient, they suffer from significantly higher execution latency (4.7x–14.5x slower) and energy consumption (4.7x–18.7x higher) compared to MLPs on scalar cores. Furthermore, KANs exhibit poor robustness under INT8 post-training quantization, diverging up to 43x earlier than MLPs, leading to the conclusion that MLPs are more dependable for embedded HRPINN deployment unless specific quantization co-design is employed.
Entities (10)
Relation Signals (6)
Kolmogorov-Arnold Networks → outperformsinenergy → Multilayer perceptrons
confidence 95% · consumed 11.3x and 5.6x more energy per integration step
Kolmogorov-Arnold Networks → outperformsinlatency → Multilayer perceptrons
confidence 95% · the KAN residual branch executed 13.5x and 8.0x slower
StarFive VisionFive 2 → runson → RISC-V RV64GC
confidence 95% · on a RISC-V RV64GC platform without vector extensions (StarFive VisionFive 2, SiFive U74)
Kolmogorov-Arnold Networks → degradesunderquantization → Int8 Quantization
confidence 90% · Under INT8 quantization, KAN trajectories diverged up to 43x earlier than matched MLPs
Hard-Constrained Recurrent Physics-Informed Neural Networks → usesasresidualbranch → Kolmogorov-Arnold Networks
confidence 90% · KANs have been proposed as parameter-efficient replacements for multilayer perceptrons (MLPs) in such residual branches
Hard-Constrained Recurrent Physics-Informed Neural Networks → usesasresidualbranch → Multilayer perceptrons
confidence 90% · parameter-efficient replacements for multilayer perceptrons (MLPs) in such residual branches
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Hard-constrained recurrent physics-informed networks (HRPINNs) embed known dynamics inside a recurrent numerical integrator and restrict a neural branch to learning only the residual dynamics that the first-principles model does not capture. Kolmogorov--Arnold Networks (KANs) have been proposed as parameter-efficient replacements for multilayer perceptrons (MLPs) in such residual branches, but their learnable B-spline activations follow a markedly different execution profile. Building on prior work that characterized when a vanilla B-spline KAN matches or underperforms an MLP as an HRPINN residual branch in discovery accuracy, this paper asks whether that parameter efficiency survives deployment. Using identical trained weights, we measured execution latency, energy per integration step, and dependability under post-training quantization in the closed recurrent loop on a RISC-V RV64GC platform without vector extensions (StarFive VisionFive~2, SiFive U74). For the two accuracy-comparable pairs, the KAN residual branch executed $13.5\times$ and $8.0\times$ slower and consumed $11.3\times$ and $5.6\times$ more energy per integration step (3.7\,$\mu$J against 0.33\,$\mu$J for the smallest pair); across all four parameter-matched size tiers the ranges are $4.7\times$--$14.5\times$ and $4.7\times$--$18.7\times$. Under INT8 quantization, KAN trajectories diverged up to $43\times$ earlier than matched MLPs; the damage traces to weight quantization, not to input-side knot-interval misassignment. These results indicate that the parameter efficiency reported for KANs does not transfer to deployment cost on scalar embedded cores, and that an MLP residual branch is the more dependable default for embedded HRPINN deployment unless specific quantization co-design is used.
Tags
Links
- Source: https://arxiv.org/abs/2608.00737v1
- Canonical: https://arxiv.org/abs/2608.00737v1
Trouble viewing inline? Open PDF directly →
Full Text
40,058 characters extracted from source content.
Expand or collapse full text
An Embedded RISC-V Evaluation of Kolmogorov–Arnold Networks in Hard-Constrained Recurrent Physics-Informed Models Enzo Nicolás Spotorno, Josafat Leal Filho Abstract Hard-constrained recurrent physics-informed networks (HRPINNs) embed known dynamics inside a recurrent numerical integrator and restrict a neural branch to learning only the residual dynamics that the first-principles model does not capture. Kolmogorov–Arnold Networks (KANs) have been proposed as parameter-efficient replacements for multilayer perceptrons (MLPs) in such residual branches, but their learnable B-spline activations follow a markedly different execution profile. Building on prior work that characterized when a vanilla B-spline KAN matches or underperforms an MLP as an HRPINN residual branch in discovery accuracy, this paper asks whether that parameter efficiency survives deployment. Using identical trained weights, we measured execution latency, energy per integration step, and dependability under post-training quantization in the closed recurrent loop on a RISC-V RV64GC platform without vector extensions (StarFive VisionFive 2, SiFive U74). For the two accuracy-comparable pairs, the KAN residual branch executed 13.5×13.5× and 8.0×8.0× slower and consumed 11.3×11.3× and 5.6×5.6× more energy per integration step (3.7 μ against 0.33 μ for the smallest pair); across all four parameter-matched size tiers the ranges are 4.7×4.7×–14.5×14.5× and 4.7×4.7×–18.7×18.7×. Under INT8 quantization, KAN trajectories diverged up to 43×43× earlier than matched MLPs; the damage traces to weight quantization, not to input-side knot-interval misassignment. These results indicate that the parameter efficiency reported for KANs does not transfer to deployment cost on scalar embedded cores, and that an MLP residual branch is the more dependable default for embedded HRPINN deployment unless specific quantization co-design is used. I Introduction Modern cyber-physical systems (CPS) increasingly rely on executable models of their own physics for prediction, anomaly detection, and control. When such a model runs on the system itself, under real-time and energy budgets, its predictions must also remain trustworthy, since a learned component that degrades under deployment conditions can propagate into the control decisions it informs [2]. Hard-constrained architectures address this structurally rather than through training pressure, by embedding the imposed constraints in the computation instead of in a loss term (Section I). The Hybrid Recurrent Physics-Informed Neural Network (HRPINN) [17] applies this principle to a recurrent setting: the known dynamics and the numerical integrator are fixed inside the update rule, and a neural branch learns only the residual dynamics that the first-principles model does not capture, so the imposed structure holds for any behavior of that branch, with similar approaches having also been studied across CPS prognostics, including battery-health and remaining-useful-life estimation [12, 14]. Because that residual branch is the only learned component, the architecture chosen for it determines the model’s deployment cost. Kolmogorov–Arnold Networks (KANs) [10] have been proposed as an alternative to MLPs for scientific machine learning. They replace fixed node activations with learnable univariate B-spline functions on each edge, summed at every node, and have shown promise for recovering hidden terms in dynamical systems (Section I). In prior work [18], summarized in Section I, we characterized when a vanilla B-spline KAN matches or underperforms an MLP as an HRPINN residual branch in discovery accuracy and training stability. That characterization concerns accuracy, not execution cost. Studies of KAN hardware implementation consistently report B-spline evaluation as expensive relative to parameter count [5, 7], but they characterize KANs as generic function approximators, without an enclosing physics-informed integrator and without an accuracy figure attached to the specific model measured. This leaves open the question that motivates this paper: does the parameter efficiency KANs exhibit on separable residuals translate into computational efficiency once deployed, or does the B-spline formulation introduce execution- and precision-level costs that offset it? We investigate three hypotheses. H1: the KAN residual branch incurs higher per-step execution latency than an accuracy-comparable MLP. H2: that latency difference translates into higher energy per integration step. H3: the KAN branch loses trajectory fidelity earlier than the MLP under post-training quantization inside the closed recurrent loop, a regime in which memory and instruction-set constraints often make integer execution the only option. Testing these hypotheses requires a platform on which the cost of each computational topology is exposed directly. We target the StarFive VisionFive 2 (SiFive U74, RV64GC) [19], which provides no vector extension, so both the MLP’s matrix products and the KAN’s spline recursion compile to scalar instruction sequences and neither can draw on vendor-tuned vector kernels; the measured difference therefore reflects the operation mix and memory-access pattern of the two topologies themselves. Thus, this paper contributes: (i) latency and energy measurements on a RISC-V core without vector extensions, on identical trained weights, including a deployment-optimized KAN variant that quantifies the sensitivity of the comparison to implementation effort; (i) a dependability evaluation under post-training quantization in the closed loop, with an attribution analysis identifying which quantization step drives the difference between architectures; and (i) deployment guidance for choosing a residual-branch architecture in embedded physics-informed CPS. The inference engine, the trained models, and the measurement scripts are publicly available.111All resources are publicly available at https://github.com/enzoniko/khrpinn I Related Work Physics-informed neural networks impose physical laws as a loss penalty [15], which leaves constraint satisfaction unguaranteed at inference; architecture-level enforcement makes the constraint structural instead, for example through projection layers for linear equality constraints [3], and HRPINN [17] fixes both the known dynamics and the integrator inside a recurrent cell, the broader motivation for such guarantees being surveyed by Brunke et al. [2]. Within that setting, KANs have been applied to dynamical systems principally as neural-ODE backbones recovering hidden physics, symbolic source terms and structured latent states [10, 8, 9]. The hyperparameter sensitivity documented in practical guidance [13] motivates the stability characterization summarized in Section I, and a benchmark of physics-informed KANs independently reports that the original B-spline parameterization lacks both accuracy and efficiency against MLP-based PINNs and remains sensitive to random seed [16], a record to which this paper adds the deployment dimension. Many variants replace the B-spline basis with Chebyshev, operator-network or hybrid recurrent formulations [11, 1, 20], but all retain the defining primitive of a per-edge univariate function evaluation followed by summation, so this paper evaluates the baseline vanilla formulation as the reference an optimized descendant would have to beat. On the hardware side, Huang et al. [5] show that mapping B-splines into lookup tables still demands substantial circuit resources and propose an algorithm-hardware co-design, while Khalid et al. [7] derive platform-independent complexity formulae across basis variants; both evaluate KANs as generic function approximators on dedicated or abstract hardware, which is the gap this paper addresses. I Background and Prior Results HRPINN advances a state vector st=[xt,vt]⊤∈ℝ2s_t=[x_t,v_t] ^2, where xtx_t is position and vtv_t velocity in a normalized coordinate frame, through a hard-constrained explicit-Euler cell: v˙t=aknown(st)+Rθ(st) v_t=a_known(s_t)+R_θ(s_t), xt+1=xt+Δtvtx_t+1=x_t+ t\,v_t, and vt+1=vt+Δtv˙tv_t+1=v_t+ t\, v_t. Both aknowna_known and RθR_θ take the full state vector as argument; for the Van der Pol system below the known term depends on xtx_t alone while the residual depends on both. The integrator is explicit (forward) Euler, as in the prior study [18], which keeps the trained models and their reported accuracy directly transferable to this evaluation, and which is also the cheapest choice, requiring one residual-branch evaluation per step against p for a Runge–Kutta scheme of order p. For the comparison reported here the decisive property is that the integrator is identical and fixed across both architectures: it contributes an additive constant to every measurement and cancels in every architecture-to-architecture ratio. The learned branch is evaluated once per step and the remaining terms are closed-form expressions of a few floating-point operations, so the per-step cost is dominated by the branch; where the first-principles term is itself expensive, requiring an implicit solve or a large tabulated lookup, the costs reported here bound only the learned part of the budget. Only RθR_θ is trained, by backpropagation through time (BPTT) over 20-step windows. Because RθR_θ is the only component that changes when the residual-branch architecture changes, comparing two architectures under this cell isolates the comparison to the branch itself. The benchmark systems are the Duffing oscillator (v˙=−x−0.2v−0.3x3 v=-x-0.2v-0.3x^3; known part −x−0.2v-x-0.2v, residual −0.3x3-0.3x^3) and the Van der Pol oscillator (v˙=−x+(1−x2)v v=-x+(1-x^2)v; known part −x-x, residual (1−x2)v(1-x^2)v). Both have unit natural frequency, giving a characteristic period T=2π≈6.28T=2π≈ 6.28 s, so the step Δt=0.05 t=0.05 s corresponds to T/126T/126, a resolution at which explicit Euler remains stable for these dynamics, and the 20-step training window spans 1.01.0 s, or T/6T/6, long enough for compounding error to appear in the loss while keeping the unrolled graph small enough for stable gradients. Expressing both as fractions of the system timescale lets them transfer to plants with different natural frequencies. Discovery accuracy is reported as the R2R^2 between the learned surface Rθ(x,v)R_θ(x,v) and the analytical residual on a 50×5050× 50 grid over [−2,2]2[-2,2]^2. The residual branch is implemented as a ReLU MLP or as a vanilla B-spline KAN. A KAN layer replaces each fixed scalar activation of an MLP with a learnable univariate function, implemented as a B-spline of order k over G grid intervals, combining base and spline paths as ϕ(x)=wbSiLU(x)+ws∑jcjBj(x)φ(x)=w_b\,SiLU(x)+w_s _jc_jB_j(x), where BjB_j are the order-k basis functions on that edge’s knot vector and cjc_j are learned coefficients [10]. Each output node sums its incoming edges, so a single layer combines its inputs additively, and a multiplicative interaction such as the Van der Pol residual (1−x2)v(1-x^2)v can be represented only through composition across depth; the Van der Pol benchmark probes exactly this. The default configuration uses grid size G=5G=5 and spline order k=3k=3, and training applies grid updates, so the knot vector is generally non-uniform and specific to the trained model. The prior study ran two ablations, each over 100 random seeds with 95% bootstrap confidence intervals. A configuration ablation over grid size, spline-scale weighting, sparsity regularization and grid-update frequency, for a fixed KAN architecture ([2,8,1][2,8,1]), found accuracy highly sensitive to these hyperparameters: three of seven configurations produced a negative Van der Pol R2R^2, the worst at −5.23-5.23 against 0.770.77 for a 337-parameter MLP reference, a sensitivity absent in the MLP and consistent with reported KAN practice [13]; the two most stable settings, G=5G=5 and G=3G=3, are carried forward as the KAN defaults. A parameter-efficiency ablation over four KAN and four MLP widths and depths (Table I) shows three behaviors that frame this evaluation: small KANs match or exceed similarly sized MLPs on the separable, univariate Duffing residual; KANs consistently fail to recover the multiplicative Van der Pol interaction, where MLPs scale gracefully with parameter count; and the Wide and Deep KAN configurations are unstable, failing to converge in most seeds on Duffing. IV Embedded Inference Framework Training is performed off-line in PyTorch on an x86-64 development host; deployment proceeds through export to a compact binary, verification of numerical equivalence, and execution by a scalar inference engine that depends only on the C++17 standard library and libm and is linked statically, so deployment is a copy of two files onto a minimal Linux image. The benchmark executable occupies 893 KB and the model files range from 511 B (MLP Tiny) to 17.8 KB (MLP Large), against several hundred megabytes for a PyTorch runtime, justifying not training on the target platform. The exported file is a flat, little-endian, positional binary: a fixed header (magic, version, architecture and system identifiers, Δt t, state normalizer) followed by per-layer records holding, for an MLP, the weight matrix, bias vector and activation flag, and for a KAN, the knot vector, base weights and spline coefficients with the per-edge scale already folded in, so no scaling multiply remains in the inference path. Each record also carries the per-tensor calibration ranges used by the quantized path, so a quantized deployment needs no run-time calibration data, and weights are stored in the layout the kernels iterate over, so loading is a single contiguous read with no dynamic allocation. All models fit within the U74’s 32 KB L1 data cache, keeping the latency comparison a measure of computation rather than of memory-hierarchy behavior. Both branches are allocation-free, contiguous scalar loops. The MLP is a chain of fused matrix-vector product-and-ReLU passes over row-major weights; the KAN evaluates, per input feature, the SiLU base path and the Cox–de Boor spline recursion over that feature’s knot vector, followed by a spline matrix-vector product. Two properties of the KAN kernel matter for the measurements that follow. First, the SiLU base path requires one e−xe^-x evaluation per input feature, and transcendental functions have no single hardware instruction on the cores evaluated here: libm resolves them through iterative polynomial approximations (expf) costing several times a multiply-accumulate, with a range-reduction step that branches on the input magnitude, which is why Table I counts them separately. Second, the KAN’s memory access is data-dependent: the MLP’s forward pass is a fixed sequence of matrix-vector products over contiguous memory, friendly to prefetching, whereas the spline recursion selects a different active knot interval, and therefore a different offset into the spline-coefficient tensor, for every input value. The engine implements the spline recursion in two variants: a default that reproduces the reference PyTorch numerics operation for operation, including explicit divisions by knot differences, which is what allows it to be pinned against the training framework, and an optimized variant that precomputes the reciprocal of every knot-difference denominator at model load, legitimate because the knot vector is frozen after training. Both are reported, since omitting the optimization would understate the KAN’s achievable performance. In every other respect the architectures receive identical treatment: the same compiler and flags (-O2, -ffp-contract=off), single-threaded execution, and the same measurement harness. The engine is pinned to the training stack by golden-vector tests spanning the input range, knot boundaries, out-of-domain points, closed-loop states, single cell steps and full rollouts: the floating-point path matches PyTorch within 10−410^-4 relative error on branch outputs and 5×10−35× 10^-3 normalized state error over full rollouts on every exported model, the MLP path is bit-identical to an independent NumPy reference, and the quantized path is pinned within one quantization step against an independent Python implementation. The suite is run under qemu-riscv64 and on-device before every hardware session, with integer-path outputs bit-exact between both. For the dependability evaluation, we implement post-training static quantization in its standard, architecture-agnostic form [6]: symmetric per-tensor weight quantization (scale=max|w|/qmaxscale= |w|/q_ ) and affine per-tensor activation and state quantization calibrated from minimum/maximum ranges over the training trajectories, at INT16, INT8 and, as further degradation points, INT6 and INT4. Per-tensor scaling is the deliberate choice here rather than the finer per-channel granularity also in common use, since it is precisely the granularity the attribution below implicates. No KAN-specific co-design is applied, so that the unmodified topology is characterized under a scheme treating both architectures identically, establishing the baseline a co-designed scheme would have to improve upon [5]. Execution follows the standard simulated-integer model: values are held with intN semantics and dequantized for floating-point arithmetic at tensor boundaries, the spline recursion’s bin search consumes the truncated input, so the interval-selection pathway specific to spline bases is exercised and can be isolated, and MLP biases remain unquantized, as int32 biases are in a real integer pipeline [6]. This reproduces the numerical effect of integer execution exactly but not its speed, so quantized configurations are evaluated only for accuracy and stability; no latency or energy claim about integer execution is made. The memory side of the trade-off is analytic rather than measured: INT8 weight storage is one quarter of FP32 (511 B–17.8 KB to approx. 128 B–4.5 KB), a reduction Section VI shows the KAN cannot rely on, since its trajectory collapses at INT8 well before the matched MLP’s does. Five modes support the attribution analysis of Section VI: full, quantizing state, weights and activations and requantizing the state every step, as an end-to-end integer loop would require; residual_only, a floating-point loop with only the branch quantized, which removes the state-requantization floor; and isolated single-component modes (input-, weights-, and activations-only). V Experimental Methodology The eight configurations of Table I are the four KAN and four MLP architectures evaluated for accuracy in the prior study, so that the established accuracy transfers unchanged to the hardware measurements. All eight are trained per system across five random seeds, and the model deployed is the one achieving the median discovery accuracy across those seeds, not the best, so that the results reflect a representative training outcome. Latency is measured with a single core pinned, 10410^4 warmup calls, and three interleaved rounds of ten repetitions of 2×1042× 10^4 calls each over a fixed buffer of 1024 states drawn from the models’ input domain, with a checksum accumulated over every output to prevent the compiler from eliminating the computation; we report medians. Both the residual branch alone and the full HRPINN step are measured, since the branch is what differs between architectures while the step is what a deployed controller executes. The CPU frequency governor is pinned to performance throughout, which removes frequency transitions as a source of run-to-run variance and ensures that latency and energy are measured at the same operating point. The board is powered through an inline USB coulomb counter at its USB-C input, so the measurement covers the whole board and each reading is already a hardware time integral of current, in mAh, with no sampling rate that could alias the per-step transients. Supply voltage was a stable V=5.11V=5.11 V, so charge converts to energy as E=QVE=Q\,V with Q[C]=3.6Q[mAh]Q\,[C]=3.6\,Q\,[mAh]. An automated script runs a 60 s idle baseline, then per model a 120 s fixed-duration loop of HRPINN steps whose throughput is logged by the same binary used for latency, separated by 30 s idle gaps, and a closing idle baseline; meter readings are timestamped so the idle charge accumulated during operator readout (at most 21 s) is subtracted. Per-step energy is obtained differentially, Estep=Pload−Pidlesteps/s,E_step= P_load-P_idlesteps/s, so that the board’s static power is subtracted and only the incremental cost of running the model is attributed to it. The meter resolves 1 mAh, which over a 120 s window corresponds to 30 mA, or 153 mW at 5.11 V. This bounds the per-model figures to approximately ± 19%, and bounds any difference in incremental active power between two architectures to below 153 mW; the latter is the quantity the energy conclusion rests on. All energy measurements are FP32. For every model we draw 20 initial conditions uniformly from [−1.5,1.5]2[-1.5,1.5]^2 and run 2000-step (100 s) closed-loop rollouts at FP32, INT16, INT8, INT6 and INT4, in the quantization modes defined in Section IV. At every step we record the Euclidean distance, in normalized state space, between the quantized rollout and the same model’s own floating-point rollout from the same initial condition, which isolates the effect of quantization from the model’s baseline accuracy. We report when this distance first exceeds 0.10.1, a threshold safely between floating-point noise and the state-space scale. Because computation is deterministic and bit-reproducible, results are generated on the host and spot-checked on the board. VI Results TABLE I: Prior discovery accuracy and measured deployment cost on the VisionFive 2, for the same trained models. Accuracy is mean ± 95% bootstrap CI over 100 seeds. Ops: analytical count of scalar floating-point adds and multiplies per branch inference, excluding the parenthesized transcendental (expf) calls, each costing several multiply–accumulates. Latency: median per residual-branch call. Energy: per HRPINN step, differential, carrying approximately ± 19% from meter resolution. Discovery R2R^2 Energy (μ ) Arch. Config. Params Ops (+exp) Lat. (μ ) Duffing VdP Duffing VdP KAN Very Small 120 1350 (+6) 11.1 .914±.061.914±.061 .743±.061.743±.061 3.68 4.38 Small 240 2322 (+10) 18.7 .874±.080.874±.080 .785±.073.785±.073 7.05 7.90 Wide 480 4266 (+18) 33.8 .468±.773.468±.773 −.602±2.84-.602±2.84 12.97 14.52 Deep 880 4986 (+18) 36.2 (unstable) .754±.079.754±.079 17.74 14.70 MLP Tiny 105 209 0.83 .906±.092.906±.092 .622±.173.622±.173 0.33 0.23 Small 337 673 2.33 .937±.047.937±.047 .879±.032.879±.032 1.27 1.00 Medium 1185 2369 7.68 .951±.033.951±.033 .879±.019.879±.019 2.95 3.14 Large 4417 8833 27.5 .932±.063.932±.063 .898±.017.898±.017 10.56 10.98 TABLE I: Closed-loop divergence under quantization (full mode): fraction of 20 initial conditions diverged, and median divergence step, out of a 2000-step (100 s) horizon. A dash denotes no divergence within the horizon. INT16 INT8 System Model div. step div. step Duffing KAN Very Small 0 % — 100 % 6.5 MLP Tiny 0 % — 100 % 282 KAN Small 0 % — 100 % 119 MLP Small 0 % — 100 % 316 Van der Pol KAN Very Small 0 % — 100 % 78 MLP Tiny 0 % — 100 % 196 KAN Small 100 % 575 100 % 93 MLP Small 0 % — 100 % 146 H1 is confirmed. The size tiers pair KAN Very Small with MLP Tiny, KAN Small and KAN Wide with MLP Small, and KAN Deep with MLP Medium. Only the first two are also accuracy-comparable in Table I: KAN Wide and KAN Deep are the configurations the prior study found unstable, so their tiers test scaling rather than equal-accuracy cost. For the two accuracy-comparable pairs, KAN Very Small (120 params) takes 11.1 μ per call against 0.83 μ for MLP Tiny (105 params), a 13.5×13.5× difference, and KAN Small is 8.0×8.0× slower than MLP Small; across all four tiers the ratio spans 4.7×4.7×–14.5×14.5×. Normalized per parameter, the KAN spends 41–93 ns (mean 73) against 6.2–8.0 ns for the MLP (mean 6.9), an order of magnitude apart and the reverse of what parameter counts alone would suggest: MLP latency tracks its analytical operation count closely across the full range, while the KAN’s latency per operation is consistently higher. The optimized reciprocal variant recovers 6–18% of KAN latency without altering the trend. Both system instances (Duffing and Van der Pol, with different knot vectors) agree within 1.5%, showing KAN latency on this core is boundable from architecture alone, as worst-case execution-time analysis requires. H2 is also confirmed. Over the fixed 120 s window every model drew 8–10 mAh, constant to within the meter’s 1 mAh resolution, while the throughput of those same runs varied by a factor of 40 (2.8×1042.8× 10^4 to 1.15×1061.15× 10^6 steps/s): the board draws essentially the same power whatever it computes, and what differs is how many integration steps that power buys. Two derived quantities confirm this: the incremental active power Pload−PidleP_load-P_idle spans 268–537 mW, only 1.75 meter counts and so indistinguishable from a constant, and the energy-ratio to latency-ratio quotient over the four tiers on both systems has mean 1.01 with scatter 0.70–1.46, consistent with the ± 27% a propagated half-count error produces. The KAN’s energy penalty therefore equals rather than compounds its latency penalty: the accuracy-comparable pairs cost 11.3×11.3× and 5.6×5.6× more energy, and all four tiers span 4.7×4.7×–18.7×18.7×. Finally, Table I confirms H3. At INT16 every pair stays within the threshold for the full 100 s horizon, the sole exception being a KAN configuration already flagged as unstable in the prior study. At INT8 in full mode, where the recurrent state itself is requantized every step, every model eventually crosses the threshold, because an 8-bit state resolution (2/2552/255 of the normalized range) compounds over a long enough rollout regardless of architecture; the architectures differ sharply in when. Duffing KAN Very Small diverges at a median of 6.5 steps (0.3 s) against 282 steps (14 s) for the matched MLP, a 43×43× difference, with the same ordering in every pair. The effect is one of precision and not of measurement: the non-diverging fraction decreases monotonically from FP32 through INT16 to INT8, INT6 and INT4 for all models, and the only models diverging already at INT16 are those the prior study independently flagged as unstable. Under residual_only, which removes the state-requantization floor, the gap persists: on Duffing, KAN Small diverges at a median step of 137 against 1183 for MLP Small. Quantizing one component at a time isolates the responsible mechanism. Quantizing only the input, a pathway with no analogue in a dense layer, since a perturbed input can select a different set of basis functions rather than merely perturb a product, is essentially harmless to both architectures (3×10−63× 10^-6 and 2×10−62× 10^-6 median trajectory MSE against each model’s own FP32 rollout): at INT8 the input quantization step (≈0.008≈ 0.008) is about 50×50× smaller than a spline grid interval (0.40.4), so it rarely moves an input into a neighbouring interval. Quantizing only the weights reproduces most of the full-loop degradation for the KAN (0.2040.204 against 0.2750.275) but almost none of it for the MLP (6×10−56× 10^-5 against 4×10−34× 10^-3), with activations-only intermediate for the KAN (0.0480.048) and negligible for the MLP (2×10−52× 10^-5). Recomputing discovery R2R^2 through the quantized engine ties this to the accuracy metric: on Duffing, KAN Very Small falls from 0.900.90 to −0.10-0.10 at INT8 and KAN Deep to −0.20-0.20, while MLP Tiny and MLP Medium retain 0.920.92 and 0.940.94; on Van der Pol both degrade by ≤0.02≤ 0.02, so the collapse depends on the trained weight distribution. VII Discussion and Conclusion Three questions follow from these measurements: why energy tracks latency so closely, whether kernel engineering could close the latency gap, and what the quantization attribution implies for KAN co-design. The first is a property of the operating regime. With the governor pinned the core runs at a fixed clock, and the difference in incremental active power between a spline recursion and a matrix-vector product is below the meter’s resolution, so energy per step is constant power multiplied by execution time. That proxy would not survive an on-demand governor, under which a longer-running workload also tends to drive the core to a higher operating point, and the energy penalty could then exceed the latency penalty. The second question has a quantitative answer: two classical embedded-ML optimizations bound how far a tuned scalar kernel could go. Replacing the SiLU base path’s expf with a lookup table removes at most the 6–18 transcendental calls per inference of Table I, against 1350–4986 scalar operations, so at a generous twenty operations per call it addresses under 10% of the work. Table-driven B-spline evaluation targets the dominant term instead, but training applies grid updates, so every edge carries its own non-uniform knot vector and the table would have to be materialized per edge, trading away the parameter-count advantage that motivates KANs in the first place; dedicated designs likewise find lookup-table mappings of B-splines circuit-expensive [5]. Our precomputed-reciprocal variant, which eliminates every division from the recursion, recovers 6–18%. Together these bound arithmetic-level tuning at roughly a quarter of the KAN’s cost, against gaps of 8.0×8.0× and 13.5×13.5× on the accuracy-comparable pairs: a fully optimized scalar kernel would remain an order of magnitude behind. The attribution result rules out a failure mode with no dense-layer analogue, input misassignment across knot intervals, and concentrates the damage in a mechanism both architectures share, weight quantization, where what differs is the coefficient distribution rather than the operation. This extends to a closed recurrent loop, and to trajectory divergence rather than classification accuracy, what component-wise studies of feedforward KANs report: that the learnable coefficients are the most quantization-sensitive tensor and their heterogeneous distribution is what makes low-precision KAN deployment hard [4]. A plausible structural reason is that a KAN layer’s spline-coefficient tensor holds sub-functions with heterogeneous per-edge magnitudes, so a single per-tensor scale compresses the small coefficients shaping individual spline segments far more than it compresses an MLP’s comparatively homogeneous weight matrix. If this generalizes, per-edge or per-channel spline-weight scales are a more promising co-design direction than finer input grids. What such co-design must overcome is quantified by the contrast with dedicated accelerators, which report order-of-magnitude energy and area gains over a DNN baseline [5]: without co-design, on a general-purpose scalar core, the same formulation costs 4.7×4.7×–14.5×14.5× more and fails at INT8 where the MLP survives. An MLP residual branch is therefore the more dependable default in the regimes evaluated, while a vanilla KAN remains defensible where memory footprint is the binding constraint, the residual is additively separable, and execution stays at FP32 or INT16. These conclusions hold within a deliberately narrow scope. The two oscillators were chosen so that every hardware measurement could be paired with an exactly computable discovery accuracy, which an unidentified real plant does not permit without introducing identification error as a confound. They are not a complete verification set: both are second-order, two-state, autonomous and unforced, and they do not exercise higher state dimensionality, external forcing, discontinuous or hysteretic dynamics, stiff systems requiring implicit integration, or multi-rate behavior. What they do span is the structural axis this comparison turns on, an additively separable residual against a multiplicatively coupled one; and since the per-step cost of both architectures is an exactly countable function of layer width and depth rather than of state dimensionality, the cost mechanisms carry over directionally to larger plants built from the same primitives, though accuracy conclusions would need re-establishing per system. On the measurement side, the meter’s 1 mAh resolution bounds any difference in incremental active power between the architectures at 153 mW, and it is that bound, not any per-model figure, that supports the energy conclusion; five board sessions differed by less than instrument resolution, so one representative session is reported, and finer attribution would require core-rail instrumentation. Quantized execution is simulated at the arithmetic level rather than run through a genuine integer pipeline, so the precision findings support accuracy and stability conclusions but not integer latency or energy claims. Finally, the evaluation covers one scalar core and standard per-tensor post-training quantization, and a vector-capable core would change both architectures’ constants, though the KAN’s gather-heavy, branchy recursion is in principle harder to vectorize than dense matrix products. Taken together, these measurements indicate that the parameter efficiency reported for KANs on separable residuals does not transfer to deployment cost on a scalar embedded core, and that neither classical kernel tuning nor architecture-agnostic post-training quantization closes the gap. Future work should evaluate co-designed quantization and per-edge tabulated basis evaluation, including the memory-for-latency exchange the latter implies, against the baseline established here; extend the methodology to higher-dimensional and eventually industrial plants now that the architectural variables are characterized in isolation; and implement both architectures with RISC-V vector extensions to test whether the scalar gap narrows or widens under data-level parallelism. References [1] D. W. Abueidda, P. Pantidis, and M. E. Mobasher (2025) DeepOKAN: deep operator network based on kolmogorov arnold networks for mechanics problems. Computer Methods in Applied Mechanics and Engineering 436, p. 117699. External Links: Document Cited by: §I. [2] L. Brunke, M. Greeff, A. W. Hall, Z. Yuan, S. Zhou, J. Panerati, and A. P. Schoellig (2022) Safe learning in robotics: from learning-based control to safe reinforcement learning. Annual Review of Control, Robotics, and Autonomous Systems 5, p. 411–444. External Links: Document Cited by: §I, §I. [3] H. Chen, G. E. Constante Flores, and C. Li (2024) Physics-informed neural networks with hard linear equality constraints. Computers & Chemical Engineering 189, p. 108764. External Links: Document Cited by: §I. [4] S. Errabii, O. Sentieys, and M. Traiola (2026) KANtize: exploring low-bit quantization of kolmogorov-arnold networks for efficient inference. arXiv preprint arXiv:2603.17230. Cited by: §VII. [5] W. Huang, J. Jia, Y. Kong, F. Waqar, T. Wen, M. Chang, and S. Yu (2025) Hardware acceleration of kolmogorov-arnold network (kan) for lightweight edge inference. In Proceedings of the 30th Asia and South Pacific Design Automation Conference (ASP-DAC), p. 693–699. External Links: Document Cited by: §I, §I, §IV, §VII, §VII. [6] B. Jacob, S. Kligys, B. Chen, M. Zhu, M. Tang, A. Howard, H. Adam, and D. Kalenichenko (2018) Quantization and training of neural networks for efficient integer-arithmetic-only inference. In Proc. IEEE/CVF Conf. on Computer Vision and Pattern Recognition (CVPR), p. 2704–2713. External Links: Document Cited by: §IV. [7] B. Khalid, P. J. Freire, S. K. Turitsyn, and J. E. Prilepsky (2026) Hardware-oriented inference complexity of kolmogorov-arnold networks. IEEE Access. Note: Also available at: https://arxiv.org/abs/2604.03345 External Links: Document Cited by: §I, §I. [8] B. C. Koenig, S. Kim, and S. Deng (2024) KAN-odes: kolmogorov–arnold network ordinary differential equations for learning dynamical systems and hidden physics. Computer Methods in Applied Mechanics and Engineering 432, p. 117397. External Links: Document Cited by: §I. [9] W. Liu, K. Bacsa, L. C. Tang, and E. Chatzi (2025) Structured kolmogorov-arnold neural odes for interpretable learning and symbolic discovery of nonlinear dynamics. arXiv preprint arXiv:2506.18339. External Links: 2506.18339 Cited by: §I. [10] Z. Liu, Y. Wang, S. Vaidya, F. Ruehle, J. Halverson, M. Soljacic, T. Hou, and M. Tegmark (2025) KAN: kolmogorov–arnold networks. In International Conference on Learning Representations, Y. Yue, A. Garg, N. Peng, F. Sha, and R. Yu (Eds.), Vol. 2025, p. 70367–70413. External Links: Link Cited by: §I, §I, §I. [11] F. Mostajeran and S. A. Faroughi (2025) Scaled-cpikans: spatial variable and residual scaling in chebyshev-based physics-informed kolmogorov-arnold networks. Journal of Computational Physics 537, p. 114116. External Links: Document Cited by: §I. [12] R. G. Nascimento, M. Corbetta, C. S. Kulkarni, and F. A. C. Viana (2021) Hybrid physics-informed neural networks for lithium-ion battery modeling and prognosis. Journal of Power Sources 513, p. 230526. External Links: Document Cited by: §I. [13] A. Noorizadegan, S. Wang, L. Ling, and J. P. Dominguez-Morales (2026) A practitioner’s guide to kolmogorov-arnold networks. Computer Science Review 62, p. 100991. External Links: Document Cited by: §I, §I. [14] R. Rai and C. K. Sahu (2020) Driven by data or derived through physics? a review of hybrid physics guided machine learning techniques with cyber-physical system (cps) focus. IEEE Access 8, p. 71050–71073. External Links: Document Cited by: §I. [15] M. Raissi, P. Perdikaris, and G. E. Karniadakis (2019) Physics-informed neural networks: a deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations. Journal of Computational Physics 378, p. 686–707. External Links: Document Cited by: §I. [16] K. Shukla, J. D. Toscano, Z. Wang, Z. Zou, and G. E. Karniadakis (2024) A comprehensive and fair comparison between mlp and kan representations for differential equations and operator networks. Computer Methods in Applied Mechanics and Engineering 431, p. 117290. External Links: ISSN 0045-7825, Document, Link Cited by: §I. [17] E. N. Spotorno, J. Leal Filho, and A. A. Fröhlich (2025) Hard-constrained neural networks with physics-embedded architecture for residual dynamics learning and invariant enforcement in cyber-physical systems. arXiv preprint arXiv:2511.23307. External Links: 2511.23307 Cited by: §I, §I. [18] E. N. Spotorno, J. Leal Filho, and A. A. Fröhlich (2026) Empirical stability analysis of kolmogorov-arnold networks in hard-constrained recurrent physics-informed discovery. Note: Poster at the AI&PDE Workshop, ICLR 2026 External Links: 2602.09988 Cited by: §I, §I. [19] StarFive Technology (2023) VisionFive 2 datasheet. Note: Version 1.53, accessed 27 July 2026 External Links: Link Cited by: §I. [20] Z. Zhang, Q. Wang, Y. Zhang, T. Shen, and W. Zhang (2025) Physics-informed neural networks with hybrid kolmogorov-arnold network and augmented lagrangian function for solving partial differential equations. Scientific Reports 15 (1), p. 10523. External Links: Document Cited by: §I.