acceptodds
Under review as a conference paper at ICLR 2027

Residual Layers and Flow Calls Along a Common Path

Abstract

Residual layers and time-conditioned flow calls both build transformations through local updates, but more updates can encode a richer process or merely resolve the same process more finely. We compare them by the full path of intermediate transformations. For compactly supported, time-Lipschitz fields in fixed dimension d and spatial regularity s∈1,2, we prove a sharp worst-case all-prefix information rate on sufficiently resolved Euler grids. When d≥ s, the path and endpoint have the same leading information power, while full-field reconstruction costs more. A finite time-conditioned network attains the path rate with its implementation costs counted; its encoded path can also be traversed with O(ε^-1/2) aligned calls and linear interpolation readout on the original grid. Conditional execution bounds and controlled examples show how call placement affects path error. The distinction separates information stored about a process from the resolution used to execute it.

Primary area:
learning theory
Keywords:
approximation theory, metric entropy, residual networks, neural ordinary differential equations, weight sharing, flow maps

Reviews

Among:
Shape:
1234this paper, Top 17%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.75 over 4 reviews, above 83% of the others.
Reviewer_2sRqOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

In this paper, the authors consider residual layers and time-conditioned flow via the full path of intermediate transformations. Under the several assumptions, they provide the upper and lower bounds for the prefix information rate.

Critical strengths

The strength of this paper is to show that, when d≥sd \geq s, the full transformation path and its endpoint have same worst-case leading information power, while reconstructing the full vector field requires more information. The claim obtained theoretically is very interesting. The experiments provide good empirical support for the theoretical results.

Critical weaknesses

The authors claim the full transformation path and its endpoint have same worst-case leading information power when d≥sd \geq s. However, since s∈{1,2}s \in \{1,2\}, the condition d≥sd \geq s covers the broad range. The restriction to s∈{1,2}s \in \{1,2\} might be restrictive. Also, the analysis seems to be restricted as Euler grids. I am wondering if the rate might changed when using other discretization, such as Runge-Kutta or adaptive solvers.

Questions for authors
  1. Is there an intrinsic difficulty in extending the analysis beyond s∈{1,2}s \in \{1,2\} ? Also, if such a extension is possible, could we expect the same claim that the full transformation path and its endpoint have same worst-case leading information power when d≥sd \geq s.

  2. Could authors discuss the other discretization, such as Runge-Kutta or adaptive solvers ? I do not ask the authors to add details, but just a brief discussion on this possibility.

2 comments

Thank you for your questions on higher regularity and other solvers. They helped us extend the analysis and clarify the solver comparison.

Higher spatial regularity. New Appendix K proves matching path information bounds for every fixed integer s>2s>2. For fields supported in [−1,1]d[-1,1]^d with uniformly bounded spatial Cs−1,1C^{s-1,1} norms and time-Lipschitz values, the endpoint power is d/sd/s. On dyadic L≥Cd,sε−1/2L\ge C_{d,s}\varepsilon^{-1/2}, the all-prefix path power is max⁡{d/s,(1+d/s)/2}\max\{d/s,(1+d/s)/2\}, up to logarithms. Thus endpoint and path have the same power when d≥sd\ge s. The proof uses inverse-stable, quantized local Taylor approximations. One time-conditioned ReLU network realizes the code; its full graph and per-call work have polylog⁡(L/ε)\operatorname{polylog}(L/\varepsilon) overhead.

Runge--Kutta and adaptive solvers. New Appendix G.3 shows that one fixed graph defines a continuous flow within ε\varepsilon of every compatible teacher flow. The graph is built from L0≳ε−1L_0\gtrsim\varepsilon^{-1} full layer functions of a field in our class, with s∈{1,2}s\in\{1,2\} and exact graph arithmetic. Compatible teacher fields are in this class and agree with all source slices. If a Runge--Kutta or adaptive solver has uniform global node error δ\delta on this graph, its error against the teacher flow at those nodes is at most ε+δ\varepsilon+\delta. Our Ω(ε−1/2)\Omega(\varepsilon^{-1/2}) lower bound counts linear-output segments with original-grid knots.

Thank you very much for the clarification. I would like to keep my current score as weak acceptance.

Reviewer_jfQ5OpenReview ↗
Rating
3
Confidence
1
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

This paper investigates the information complexity and execution complexity required for a shared time-conditioned neural network to reproduce the full transformation path of a residual network satisfying specific regularity assumptions. The authors prove that:

  1. The worst-case information complexity required for the shared network to achieve the optimal result is \widetilde{\Theta}\left(\varepsilon^{-\max\left\\{\frac{d}{s},\frac{1+d/s}{2}\right\\}}\right).

  2. When the depth LL of a Residual Network is sufficiently large and continues to increase, the worst-case number of network calls required to preserve the full transformation path using aligned anchor calls and linear interpolation is Θ(ε−1/2)\Theta\left(\varepsilon^{-1/2}\right)

The authors theoretical proofs and numerical experiments to support their claims.

Critical strengths
  1. The topic is a well-motivated and interesting problem. Investigating the reconstruction of the entire transformation path, rather than the final output, is a meaningful and challenging research problem.

  2. The authors provide detailed mathematical proofs for the claims.

Critical weaknesses

The main theoretical results rely on rely on restricting the residual network to a specific class of Depth-normalized Euler Residual Networks with strong regularity assumptions (bounded residual increments, spatial Lipschitz continuity, and strong cross-layer regularity). These assumptions may be not generally guaranteed in practically trained residual networks.

Questions for authors

None.

2 comments

Thank you for highlighting the assumptions on trained residual networks. Your concern helped us extend the theory and connect it to a trained model.

A bridge to a trained network. New Appendix J uses a standard input-memory construction to connect the full pretrained PreResNet-1001 to our theory. Padding and scaling give a unit-class field whose readout recovers all 335 original map prefixes on a bounded input domain, in exact arithmetic. At original tolerance ε\varepsilon, the theorem gives a shared-evaluator existence bound at augmented accuracy ε/Γ\varepsilon/\Gamma on a sufficiently fine dyadic grid.

Separately, a fixed current-state/time ReLU graph reproduces these prefixes on 128 previously examined CIFAR-10 images. Its maximum prefix L2L_2 error is 1.55×10−41.55\times10^{-4}, and all predictions match the teacher. The graph retains the full block bank. Its 512 calls use 512 times the teacher's convolution and linear MACs (Appendix C). An extended-exponent interpreter executes the unit-class construction on four images and recovers all 335 prefixes of the rounded-BN teacher, with 335 full-teacher traversals per image.

Assumptions and extension. New Appendix H shows that for s=1s=1, endpoint and path retain the information power ε−d\varepsilon^{-d} with arbitrary layer-to-layer variation, bounded spatially Lipschitz updates at scale 1/L1/L, and dyadic L≥Cd/εL\ge C_d/\varepsilon. Under the declared stage-wise normalization, all 41,856 sampled temporal and 21,120 L2L_2 spatial necessary-bound checks exceed the unit bounds. Of the 41,856 increments checked alongside the temporal comparisons, 31,167 also exceed the unit amplitude bound (Appendix C). Independently parameterized blocks do not enforce these conditions.

More efficient shared implementations and checks on further trained networks are natural follow-up directions.

Thank you for your response. Currently I choose to maintain my original score.

Reviewer_DBn2OpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

The paper formalizes an intuitive question about iterative network architectures, such as residual networks and time-conditioned flow networks: given the transformation path from input to output, do additional network calls encode more information about the transformation, or do they merely execute the same transformation more finely? The authors measure two quantities: 1) how many bits a model needs to reproduce the transformation path by epsilon, and 2) how many network calls are needed to reproduce it. Under explicitly stated assumptions, the authors derive tight asymptotic answers to both questions: about ε−1/2\varepsilon^{-1/2} network call suffice regardless of depth, so beyond that point, extra network calls provide no information and only execute the same transformation more finely.

Critical strengths

S1: This paper formulates an intuitive but interesting question for the community. If it generalizes beyond its assumptions, this could provide some theoretically guide to how many network calls an iterative architecture actually needs, for example: how many loops a looped transformer needs, or how few network calls a flow matching generator can be distilled into. Moreover, the bound that the authors derived is tight: the upper and lower bounds match up to logarithmic factors, so the derived rate cannot be improved further.

Critical weaknesses

W1: Although theoretically sound, the theoretical setting in this paper has a gap from practical deep networks.

First, the theoretical assumption is very strong: every layer is assumed to be an Euler step of one smooth, time-Lipschitz vector field. I am not sure whether this corresponds to actual trained residual networks. I strongly suggest conducting experiments on trained trained networks (e.g., ResNet-1001), checking whether their residual blocks vary smoothly across layers.

Second, the authors' theoretical framework builds upon reproducing the whole transformation path. However, in practical application, the most interest is the output of the transformation. Path fidelity is a much stronger requirement than output fidelity. More critically, the network-call result does not hold the computation per network call fixed: in the setting, the per network call cost is allowed to grow with the requested accuracy and spatial complexity. As a result, when only the transformation output matters, a single network call already suffices if the endpoint map is directly encoded (Appendix A.5), and when the whole transformation path is required, the ε−1/2\varepsilon^{-1/2} lower bound comes from the linear-interpolation rule instead of the network itself. Therefore, the paper does not answer whether more network calls encode more information or merely execute the same transformation more finely given the computation per network call is fixed, a practically relevant setting for flow matching distillation and looped transformers.

W2: The writing is consistently hard to understand. The authors frequently use nonstandard terminology for important concepts, such as "target-independent representation contract," "legal sampled evaluator," and "public contract," which is just essentially describing a standard minimax-encoding formulation. Other phrases, including "allocation gates," "resolved-grid regime," and "the aligned-call consequence of that code," further increase the reading burden.

The notation is also overloaded: RR denotes different things in a) Proposition 1, b) Eq. (38), and c) Lemma 1. λ\lambda denotes different things in a) Eq. (23), b) Appendix D.1, and c) Appendix D.4. ρ\rho denotes different things in a) Eq. (28) and b) Appendix E.1.

Questions for authors

Q1 Please refer to the two paragraph in W1.

1 comment

Thank you for suggesting the ResNet-1001 check and asking about fixed per-call work.

Fixed per-call work. For the paper's field class, s∈{1,2}s\in\{1,2\} and sufficiently fine dyadic grids, the submitted path packing gives a fixed-graph information floor (revised Appendix A):

C[b+log⁡(C+d+2)]+Sside≳dε−β,β=max⁡{ds,1+d/s2}.C[b+\log(C+d+2)]+S_{\rm side}\gtrsim_d\varepsilon^{-\beta},\qquad \beta=\max\left\{\frac ds,\frac{1+d/s}{2}\right\}.

Here C≥dC\ge d bounds per-call operations, bb uniformly caps coefficient bits, and SsideS_{\rm side} counts extra target data. The bounded-fan-in graph executes in full, has O(C)O(C) coefficients, and uses a class-fixed decoder. Fixed budgets give a class-worst error floor: more calls can improve execution without adding target information.

New Appendix G.3 builds one graph from L0≳ε−1L_0\gtrsim\varepsilon^{-1} full layer functions. With sufficient uniform polylogarithmic precision and no extra target data, its graph bits and per-call work attain the same leading power. Compatible target fields in the class share all source slices. Its linear readout covers source and target prefixes on dyadic L≳ε−1L\gtrsim\varepsilon^{-1} and finite anchor-preserving schedules in exact arithmetic. Source access, encoding, external precision, updates, schedules and readout are separate. The Θ(ε−1/2)\Theta(\varepsilon^{-1/2}) call rate uses one call per linear-output segment; its lower bound counts segments with original-grid knots.

In submitted Figure 5(b), increasing calls from 128 to 512 on one fixed graph reduces normalized path error from 0.0650 to 0.00127 on a synthetic target and 36 prescribed initial states.

Why the path? An ε\varepsilon path guarantee bounds each fixed KK-Lipschitz intermediate head's error by KεK\varepsilon (revised Section 5). The endpoint alone can be encoded in one call (submitted Appendix A.5); for d≥sd\ge s and s∈{1,2}s\in\{1,2\}, endpoint and path have the same leading information power up to logarithms.

Presentation. We replaced the flagged terms and separated their roles: RAR_{\mathcal A} (initial radius), ninvn_{\rm inv} (inverse iterations), θ\theta (interpolation), wIw_I (mesh width), and Λfield\Lambda_{\rm field} (field bound).

Trained ResNet-1001. New Appendix J uses a standard input-memory construction to connect the entire pretrained network to our theory. Padding and scaling give a unit-class field whose readout recovers all 335 original map prefixes on a bounded input domain, in exact arithmetic. At original tolerance ε\varepsilon, the theorem gives a shared-evaluator existence bound at augmented accuracy ε/Γ\varepsilon/\Gamma on a sufficiently fine dyadic grid.

Separately, a fixed current-state/time ReLU graph reproduces these prefixes on 128 previously examined CIFAR-10 images. Its maximum prefix L2L_2 error is 1.55×10−41.55\times10^{-4}, and all predictions match the teacher. The graph retains the full block bank. Its 512 calls use 512 times the teacher's convolution and linear MACs (Appendix C). An extended-exponent interpreter executes the unit-class construction on four images and recovers all 335 prefixes of the rounded-BN teacher, with 335 full-teacher traversals per image.

As requested, we checked layer variation in the original network. Under the declared stage-wise normalization, all 41,856 sampled same-state temporal and 21,120 L2L_2 spatial necessary-bound checks exceed their unit bounds. Independently parameterized blocks do not enforce these bounds. New Appendix H shows that, for s=1s=1, endpoint and path retain the same information power ε−d\varepsilon^{-d} with arbitrary layer-to-layer variation, bounded spatially Lipschitz updates at scale 1/L1/L, and dyadic L≥Cd/εL\ge C_d/\varepsilon.

More efficient shared implementations and broader trained-network checks are natural follow-up directions.

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

This paper studies the relationship between residual networks and time-conditioned shared networks in terms of representation and execution. Its central question is how much information must be stored, and how many updates are required, to preserve the same complete transformation process to a prescribed accuracy. The authors distinguish between depth that introduces additional transformation detail and depth that provides a finer execution resolution. They compare the two implementations through the states reached by every admissible input at every intermediate layer. For depth-normalized residual systems with uniform spatial regularity and Lipschitz continuity in time, the paper analyzes the information complexity of endpoint maps, complete transformation paths, and local vector fields. The lower bounds allow general finite decoding schemes, including compressed untied representations, so the comparison is not restricted to networks that store each layer independently.

The construction uses multiscale local transports to build coherent, invertible anchor maps and interpolates between them to form an approximate path. Inverse path coordinates then turn this representation into a shared network that receives only the current state and time. The resource analysis includes inverse computations, clock logic, and finite-precision implementation costs. Matching upper and lower bounds establish that, up to logarithmic factors, preserving the full path has the same leading information-complexity exponent as preserving the endpoint when the state dimension is at least the spatial regularity order, whereas reconstructing the full vector field is more expensive. With anchor-aligned calls and piecewise-linear output, the same code can reproduce all original-grid prefixes using O(ε−1/2)O(\varepsilon^{-1/2}) calls, and this call order is worst-case optimal under the specified output rule. Controlled experiments illustrate the effect of call placement and the representation-error floor that additional calls cannot eliminate.

Critical strengths

1.The research question is theoretically meaningful, and the comparison offers a useful perspective.

Separating the information contained in a transformation process from the number of updates used to execute it provides a clear framework for understanding residual depth and shared-network calls. Although both layer counts and call counts measure sequential computation, they need not reflect the same representational complexity. Requiring fidelity to the full intermediate transformation path also makes the comparison sensitive to how computation unfolds, rather than only to the final output. This gives the comparison a well-defined basis and provides a useful theoretical perspective on parameter sharing, network conversion, and fidelity to intermediate computations.

2.The theoretical bounds are connected to an executable construction, with careful resource accounting.

The paper addresses both the information required for a prescribed accuracy and a shared-network construction that attains the corresponding leading order. The lower bounds accommodate relatively general finite representations, including compressed untied ones, which gives the comparison a strong foundation. The implementation analysis also addresses how the encoded path can be executed when the evaluator receives only the current state and time, and it counts the auxiliary computations and finite-precision costs involved. This gives the representation bound a concrete execution interpretation. Separating representation error from execution error further helps explain when additional calls improve accuracy and when they encounter the error floor imposed by the stored representation.

Critical weaknesses

1.The significance of the central technical advance could be brought into sharper focus.

Full-trajectory approximation, multiscale flow maps, and some of the relevant information upper bounds have established theoretical foundations, as the authors acknowledge. My assessment of the novelty therefore rests primarily on the matching lower bounds within the admissible dynamical class and on the construction that turns a compact path representation into a stable, executable shared network. The manuscript brings together several concepts, and these central advances are not always sufficiently prominent in the overall presentation. In particular, a more direct explanation of where existing path-approximation results fall short of the execution objective, and how the new construction overcomes that obstacle, would help readers assess the technical difficulty and extent of the advance.

2.The interpretation of the execution-complexity results is limited by the specified execution conditions.

The shared network may depend on the original execution grid, and the reduced-call guarantee relies on anchor alignment and linear interpolation of the output. In particular, the call-count lower bound primarily reflects the temporal resolution required by piecewise-linear output; it is distinct from a general lower bound on the number of evaluations required by shared networks or numerical solvers. The authors state these conditions, but they nevertheless materially limit the generality of the interpretation. The results most directly characterize the cost of executing a particular class of discrete path representations. They do not yet establish a corresponding guarantee for reusing one fixed continuous-time model across different execution resolutions.

Questions for authors

1.Why do existing path-approximation results not directly provide the shared-execution guarantee established here?

A short example or technical comparison explaining why accurate path values alone do not ensure stable inversion and repeated execution would be helpful. Please also clarify the distinct obstacles addressed by multiscale sharing and the coherent invertible construction. This would make the new contribution more apparent than a comparison of the final complexity expressions alone.

2.Which guarantees remain valid if the execution grid or call times change while the shared network is held fixed?

Please distinguish changes that can reuse the current network from those that may require reconstruction or recompilation. If this extension is outside the scope of the paper, a more explicit distinction between fixed-grid execution guarantees, resolution lower bounds for linear output, and the execution complexity of general continuous-time models would still be valuable.

2 comments

Thank you for your careful reading and clear account of the construction. We appreciate your suggestions to explain the technical advance and clarify when one network can be reused across grids. They helped us make both points more precise.

Our result. We establish a sharp finite-bit information law for the common residual path and realize it with one current-state/time network. For s∈{1,2}s\in\{1,2\} and sufficiently fine dyadic grids, the class-worst path information is Θ~(ε−β)\widetilde\Theta(\varepsilon^{-\beta}), where β=max⁡{d/s,(1+d/s)/2}\beta=\max\{d/s,(1+d/s)/2\}. The matching lower bound includes compressed untied representations; the shared construction counts graph storage and per-call work (Theorem 1 in the submitted paper). The revision makes the target-code logarithms independent of LL. The revised Introduction now brings the boundary, its extensions and the counted execution together.

For d=s=2d=s=2 and dyadic L≳ε−1L\gtrsim\varepsilon^{-1}, endpoint and full-path information are both Θ~(ε−1)\widetilde\Theta(\varepsilon^{-1}), whereas sampled-field information is Θ~(ε−2)\widetilde\Theta(\varepsilon^{-2}). For d=1,s=2d=1,s=2, the endpoint and path powers are 1/21/2 and 3/43/4. Thus the dimension-to-regularity boundary changes the information needed to retain the full path.

Relation to prior work. Our revised Appendix F compares the finite-bit cost of the Euler-prefix task with prior trajectory results. Li et al. (2026) approximate continuous trajectories with one current-state/time NODE; their 2D real-width rate can reach P−1P^{-1} under joint Sobolev regularity. Temlyakov (2016), with our scalar embedding, gives an unrestricted O~(ε−3/4)\widetilde O(\varepsilon^{-3/4}) upper bound for (d,s)=(1,2)(d,s)=(1,2); our lower bound matches that power within the Euler class. Boffi et al. (2025) use two-time flow maps to advance current states. We also adapt standard hierarchical interpolation and contraction to attain the same leading shared upper power.

Why execution needs more than path values. Our executor advances a current state at an anchor by Qj+1Qj−1Q_{j+1}Q_j^{-1}. Coherent anchors control the inverse along each segment; multiscale sharing controls storage. The revised Section 3 illustrates why value accuracy alone does not supply an inverse: x+ηsin⁡(x/η2)x+\eta\sin(x/\eta^2) is η\eta-close to identity yet noninjective for small η\eta. We count the clock, inverse computations and arithmetic in our realization.

Changing grids and calls. In new Appendix G.3, we construct one fixed network for each field in our class from L0≳ε−1L_0\gtrsim\varepsilon^{-1} full layer functions. Compatible targets belong to our class and agree with all source slices. Its linear readout approximates their prefixes and the source prefixes to ε\varepsilon uniformly on the input domain, without recompilation. This holds across all dyadic L≳ε−1L\gtrsim\varepsilon^{-1} and finite anchor-preserving schedules, including real call times in exact arithmetic. The same graph's exact continuous flow has the same uniform ε\varepsilon guarantee. Its graph bits and per-call work are O~(ε−β)\widetilde O(\varepsilon^{-\beta}); source access, external precision, schedules and readout are separate. The original evaluator instead fixes its teacher grid and may require recompilation when that grid changes. The Θ(ε−1/2)\Theta(\varepsilon^{-1/2}) call rate uses one call per linear-output segment; its lower bound counts segments with original-grid knots.

Thank you for the detailed response. The example of a noninjective map uniformly close to the identity clarified why accurate path values alone do not guarantee the stable inversion needed for shared execution. I also appreciate the distinction between the original fixed-grid construction and the conditions in Appendix G.3 under which one network can be reused across grids. These clarifications resolve both of my concerns.

Comments on the paper

1 comment

Thank you to the reviewers for their careful reading and constructive questions. Their suggestions helped us extend the theory and connect it to trained networks.

Our main result identifies the information needed to reproduce a full residual path with one time-conditioned network. For fields supported in [−1,1]d[-1,1]^d with uniformly bounded spatial Cs−1,1C^{s-1,1} norms and time-Lipschitz values, the submitted theorem for s∈{1,2}s\in\{1,2\} gives the class-worst path rate Θ~(ε−β)\widetilde\Theta(\varepsilon^{-\beta}) on dyadic L≳d,sε−1/2L\gtrsim_{d,s}\varepsilon^{-1/2}, where β=max⁡{d/s,(1+d/s)/2}\beta=\max\{d/s,(1+d/s)/2\}. The matching lower bound includes compressed untied representations. One current-state/time network realizes the path code, with graph storage and per-call work counted. The revision makes the target-code logarithms independent of LL.

This result identifies a useful boundary: endpoint and full-path information have the same leading power when d≥sd\ge s. For d=s=2d=s=2 and dyadic L≳ε−1L\gtrsim\varepsilon^{-1}, both rates are Θ~(ε−1)\widetilde\Theta(\varepsilon^{-1}), while sampled-field information is Θ~(ε−2)\widetilde\Theta(\varepsilon^{-2}). For d=1,s=2d=1,s=2, the endpoint and path powers are 1/21/2 and 3/43/4. New Appendix K extends the matching path rate and this boundary to every fixed integer s>2s>2. Li et al. (2026) approximate continuous trajectories with one NODE; our matching bounds and counted executor quantify the finite-bit cost for discrete Euler prefixes.

In response to the fixed-work and grid-reuse questions, new Appendix G.3 constructs one fixed graph from L0≳ε−1L_0\gtrsim\varepsilon^{-1} full source-layer functions for s∈{1,2}s\in\{1,2\}. It approximates source prefixes and prefixes of compatible fields, which share all source slices, across dyadic L≳ε−1L\gtrsim\varepsilon^{-1} and finite anchor-preserving schedules in exact arithmetic. With sufficient uniform polylogarithmic precision and no extra target-dependent runtime data, graph bits and per-call work match the path-information leading power up to logarithms. Source access, encoding, scheduling, external precision, updates and readout are separate. The graph's exact continuous flow also approximates the compatible teacher flows.

New Appendix H shows that for s=1s=1, arbitrary layer-to-layer variation retains the endpoint and path information power ε−d\varepsilon^{-d} when updates are bounded and spatially Lipschitz at scale 1/L1/L, on dyadic L≥Cd/εL\ge C_d/\varepsilon.

For the trained PreResNet-1001, new Appendix J adapts a standard input-memory construction to connect the entire network to the theory. Padding and scaling give a unit-class field whose readout recovers all 335 original map prefixes on the declared bounded input domain, in exact arithmetic. At original tolerance ε\varepsilon, the theorem gives a shared-evaluator existence bound at augmented accuracy ε/Γ\varepsilon/\Gamma on a sufficiently fine dyadic grid. Separately, a fixed current-state/time ReLU graph reproduces these prefixes on 128 previously examined images: its maximum prefix L2L_2 error is 1.55×10−41.55\times10^{-4} and all predictions match the teacher. This graph retains the block bank; its 512 calls use 512 times the teacher's convolution and linear MACs (Appendix C). On four images, an extended-exponent interpreter of the unit-class construction recovers all 335 prefixes of the rounded-BN teacher, using 335 full-teacher traversals per image.

The sampled original stages exceed the temporal and spatial unit bounds under our declared normalization. More efficient shared implementations, sharper call--work tradeoffs, and tests on further trained architectures are natural directions for follow-up work.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.