On the Role of Computation in Reinforcement Learning

Alicja Ziarko; Benjamin Eysenbach; Micha{\l} Bortkiewicz; Raj Ghugare

REVIEW 2 major objections 4 minor 14 references

On the Role of Computation in Reinforcement Learning

T0 review · 2 major / 4 minor · reviewed 2026-08-03 · deepseek-v4-flash

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

Pith's one-line read Policies that spend more compute can solve reinforcement-learning tasks that cheaper policies provably cannot.

desk verdict Useful empirical paper with a genuinely flawed theorem quantifier: Theorem 4.1 overclaims by not restricting policies to the description-length bound that the proof requires. read the letter →

arxiv 2602.05999 v4 pith:2HYFFQLA submitted 2026-02-05 cs.LG

Raj Ghugare , Micha{l} Bortkiewicz , Alicja Ziarko , Benjamin Eysenbach This is my paper · ORCID

classification cs.LG MSC 68Q1568Q2568T05

keywords compute-boundedpoliciestimehierarchytheorempolicyrecurrentRLlong-horizongeneralizationinterpolationunitvalueofcomputegoal-conditionedreinforcementlearning

topics P versus NP

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

This paper argues that the compute a reinforcement-learning policy spends at decision time is a separate axis from its number of parameters, and that this axis can be as decisive as expressivity. To make this precise, it defines time-bounded policies via Turing machines and proves two separation results: for suitable time bounds, there exist MDPs where the optimal policy needs more compute and every less-compute policy is arbitrarily worse; and there exist goal-conditioned MDPs where a less-compute policy matches the optimum on all training tasks yet fails on infinitely many longer-horizon test tasks. The paper then introduces a minimal recurrent architecture, the interpolation recurrent unit (IRU), which repeats the same gated block a variable number of times with identical parameters, and shows across 31 tasks that more recurrent steps improve performance and long-horizon generalization, often beating residual networks with several times more parameters. A sympathetic reader would take away that 'thinking longer' is not just an engineering trick: it is a formal expressiveness and generalization boundary in RL.

What carries the argument

The central objects are time-bounded Turing machines and the policy classes Π_t they define: deterministic policies computable in at most t(n) steps on length-n binary state encodings. The argument's load-bearing step is the classical time hierarchy theorem, which supplies a language L decidable in O(t(n)) but not in o(t(n)/log t(n)); the MDP is built so that acting optimally on a state s requires deciding s ∈ L. To carry this from individual machines to whole policy classes, the paper relies on Assumption 1: every policy's Turing-machine description has length below a fixed constant K_max, which makes the hierarchy theorem's failure threshold uniform across all g-bounded policies. On the em

What would settle it

Run the proof's construction for a concrete pair (g, t): enumerate all g-bounded Turing machines with description length below K_max and test them on the MDP's states s = (⟨M⟩10^l) with l > n_max; if any such machine matches the optimal policy D on all those states, the claimed uniform separation is false.

Watch

Extended reading notes

Core claim

The central claim is a computational view of RL policies: a deterministic policy is identified with a time-bounded Turing machine, so the policy class Π_t contains all policies computable within t(n) steps on inputs of length n. The Policy Hierarchy Theorem then states that for any time-constructible g(n) ∈ o(t(n)/log t(n)), there is an MDP whose optimal policy lies in Π_{O(t(n))} while every g-bounded policy earns arbitrarily lower return. The Long-Horizon Generalization Theorem states that in some goal-conditioned MDP, the best g-bounded policy matches the optimal value function on the finite training-task distribution but is arbitrarily worse on infinitely many longer-horizon test tasks.

Load-bearing premise

The proof needs every policy's Turing-machine description to fit in a fixed constant length K_max, so that the time-hierarchy theorem's failure point can be made uniform across all cheaper policies; if descriptions can grow without bound, the constructed MDP's separation could collapse.

Editorial extensions

If this is right

Compute-boundedness is an expressiveness boundary: there exist tasks where no policy with a smaller time budget can reach the optimal return, so RL theory that ignores compute is incomplete.
Additional compute can translate into better generalization rather than worse: a less-compute policy can overfit the training distribution of goals while a more-compute policy generalizes to longer horizons.
The same parameters can be reused across different compute budgets: IRU-(N) improves performance by changing only the number of recurrent steps, decoupling compute from parameter count.
The value-of-compute estimator gives a per-state measure of how much return is lost by temporarily using fewer recurrent steps, and it peaks early in episodes when choosing correctly is both hard and crucial.
Yoked experiments suggest the gains from more compute are mostly due to the policy's added expressivity rather than better data collection, though using compute to explicitly aid exploration remains open.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

If compute is a separate axis, a natural next step is adaptively choosing the number of recurrent steps per state; the paper's own value-of-compute curves already show per-episode variation that a compute controller could exploit.
The hierarchy results suggest a testable parallel: compute-boundedness can act like partial observability, so recurrent or non-Markov policies may be necessary even in fully observed MDPs—a prediction that could be checked in benchmark design.
A concrete extension would be training IRU policies with a curriculum over the number of recurrent steps rather than a fixed N, then measuring whether the long-horizon generalization gap shrinks further.
The theory focuses on time complexity for single-tape Turing machines; analogous separations for space complexity or boolean circuits would likely carry the same conclusions to architectures closer to modern neural networks.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Desk Editor's Note

read the letter

Here's the short version: the empirical contribution is solid and the framing is useful, but the headline theory overreaches. The stress-test note is right: Theorem 4.1 quantifies over all g-time-bounded policies, but the proof only works for policies whose Turing machine description is shorter than a fixed K_max. The state space is { (⟨M⟩10^*): |⟨M⟩

What's new: the formalization of policies as time-bounded Turing machines, the two theorems as RL applications of the time hierarchy theorem, and the IRU architecture. Even though the proofs are close corollaries of Sipser's result, applying it to RL is a genuinely new step. The experiments are broad—31 tasks across discrete and continuous domains—with parameter/compute tradeoffs against MLPs and ResNets, a yoked experiment that separates data quality from model expressivity, and a value-of-compute measure. The ablation is honest: LSTM is marginally better, IRU is half the parameters and faster. Code is available.

Softer spots: hyperparameters are 'standard' and not tuned; some OGBench baselines are taken from prior work rather than rerun; the ResNet 'overfitting' claim is inferred from high variance, not directly measured; the value-of-compute figure is illustrative only. None of these are fatal.

This paper deserves a serious referee. The empirical results are useful, and the theory can be repaired. I'd send it to review with the requirement that the authors fix the quantifier in Theorems 4.1 and 4.2 and clarify Assumption 1. After that it would be a solid contribution.

Referee Report

2 major / 4 minor

Summary. The paper argues that reinforcement learning policies should be viewed as computational processes whose time budget is distinct from their parameter count. It defines time-bounded policy classes via Turing machines and proves two results: Theorem 4.1 (Policy Hierarchy Theorem), claiming that for suitable time bounds g(n) and t(n) there exists an MDP where the optimal policy is in Π_f for f(n)∈O(t(n)) while every policy in Π_g obtains arbitrarily lower return; and Theorem 4.2, claiming a similar separation for long-horizon generalization. The paper also introduces a minimal recurrent architecture, the Interpolation Recurrent Unit (IRU), and reports experiments on 31 discrete and continuous tasks showing that increasing the number of recurrent steps improves performance and generalization to longer-horizon tasks relative to MLPs and ResNets, even when the ResNet has roughly 5× more parameters.

Significance. If the theoretical claims are made rigorous, the contribution is significant: it provides a formal vocabulary for compute-constrained RL, supports the intuition that test-time compute matters independently of parameters, and gives a simple architecture that empirically delivers consistent gains over standard feedforward baselines. The paper is also commendable for sharing code, using standard hyperparameters, and including yoked experiments and a value-of-compute diagnostic. The main reservation is that the central theorems are currently over-stated relative to the proof: the proof only works for policies with description length below a fixed constant, while the theorem quantifies over all policies in Π_g. Once this is repaired by restricting the policy class, the formal result is weaker but still meaningful, and the empirical contribution stands largely unaffected.

major comments (2)

[Theorem 4.1 / Appendix A (Assumption 1)] Theorem 4.1 (and by inheritance Theorem 4.2) quantifies over all policies in Π_g, but the proof in Appendix A only establishes the claim for policies whose canonical description satisfies |⟨M⟩|<K_max. The constructed state space S={(⟨M⟩10^*): |⟨M⟩|<K_max} excludes the diagonalizing input of any g-bounded policy whose description length is at least K_max; for such a policy the time-hierarchy argument provides no state on which it must differ from D, so it could agree with D on all reachable states and achieve optimal return. Thus the theorem as stated is unsupported under the given definition of Π_g. This is a load-bearing issue for the central theoretical claim. Please either (a) reformulate the theorems and Assumption 1 so that the policy class is explicitly the finite set {π∈Π_g : |⟨M_π⟩|<K_max}, or (b) provide a construction that separates infinite policy classes with unbounded descri
[Assumption 1, Definition 2] Assumption 1 is not a well-formed restriction on the class Π_t defined in Definition 2. As written, 'For all policies we consider π∈Π_t' claims that every t-bounded policy has a canonical description shorter than K_max; but Π_t, as defined, contains all t-bounded functions, and any computable policy has infinitely many Turing machine encodings of arbitrary length (e.g., by padding). Hence the assumption is false under the given definitions. If the intended meaning is to restrict attention to policies with description length < K_max, this restriction must be incorporated into Definition 2 or into the theorem statements; otherwise it is unclear which policy class the results apply to.

minor comments (4)

[Section 6.3, Table 1] The text says 'after 2.5 (50%) and 5 (50%) million environment steps'; the second percentage should be '100%'.
[Section 6.5, Eq. (Value of Compute)] The VoC formula should specify which policy generates the trajectory s_1,...,s_n (presumably π_{t2}) and whether the expectation is over start states or trajectories; the text below mentions deterministic transitions, but the general case needs a precise definition.
[Appendix A, Theorem A.2 proof] The notation is inconsistent: S is written as a set of strings of the form ⟨M⟩10^*, but the transition function T operates on pairs (⟨M⟩, w). Use pair notation consistently throughout.
[Figure 4 caption] The caption refers to 'lightsout-4x4', but the figure panels and the text describe 'lightsout-4x5'. Please correct.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the central theorems are explicit reductions from the external time hierarchy theorem, and the experimental claims are benchmark comparisons rather than fitted predictions.

full rationale

The paper's central theoretical claim (Theorem 4.1, Appendix A) is an application of the classical time hierarchy theorem (Sipser Theorem 9.10 / Arora-Barak Theorem 3.1). The proof constructs a diagonal language L, a machine D deciding it, and then an MDP whose reward is D(s); the conclusion that Π_g policies fail follows from the external THT, not from any quantity fitted to the experimental results. No equation in the derivation is equal by construction to the return separation being claimed. Theorem 4.2 reuses the same diagonal construction and adds a finite training set; the 'best g-bounded policy' is a finite lookup table, not a parameter fit to the test tasks. The empirical sections compare IRU-(N) at different N on held-out longer horizons; the 'prediction' that more compute helps is not statistically forced because N is not fitted to the evaluation tasks. The VoC measure is introduced as a definition, not derived from the theory. The self-citations (Bortkiewicz et al. 2025, Park et al. 2025, Wang et al. 2025b, Myers et al. 2025) provide public benchmarks and baseline configurations; they are not used to justify the theorems or to forbid alternatives, and the central results would stand with those benchmarks replaced by any external implementations. There is a correctness caveat: Theorem 4.1 as written quantifies over all π∈Π_g, while the proof's state space S={⟨M⟩10*: |⟨M⟩<K_max} and start distribution U({0,1}^{≤Kmax}) only cover policies satisfying Assumption 1; a policy whose canonical machine has length ≥K_max has no diagonalizing input in S. This is an omitted-proof/quantifier gap, not a circularity, so it does not raise the circularity score.

Assumptions & free parameters 0 free parameters · 4 assumptions · 2 invented entities

The theory rests on the classical time hierarchy theorem and an ad hoc description-length assumption (Assumption 1). The empirical claims rely on domain assumptions about deterministic binary MDPs and finite training sets. The IRU architecture introduces no new invented physical entities, only a new formal policy class and a new metric.

assumptions (4)

standard math Time hierarchy theorem (Sipser Theorem 9.10 / Arora-Barak Theorem 3.1) with a universal Turing machine U simulating every step in constant time.
The proofs of both theorems rely entirely on this. The paper cites it and uses its standard statement.
domain assumption Deterministic, binary-action MDPs with a one-step episode structure for Theorem A.1 and a multi-step goal-conditioned structure for Theorem A.2.
The theoretical results are proved only for deterministic binary-action MDPs. This is stated as a domain assumption in Section 4.
ad hoc to paper Assumption 1: all policies have a fixed description length bounded by K_max.
The paper explicitly labels this as an assumption and uses it to bound the n0 state from the time hierarchy theorem. It is a real modeling assumption about the policy class, and not a standard theorem.
domain assumption Goal-conditioned MDP training and evaluation distributions can differ (ptrain ≠ ptest), and the training tasks form a finite set.
This is an explicit modeling choice in the MDP definition for Theorem A.2.

invented entities (2)

Time-bounded policy classes Π_t
purpose: Formalizing policies as Turing machines with a time budget.
A new formal construct, but defined directly from standard time-bounded Turing machines; it is a model, not an empirical entity.
Value of compute (VoC)
purpose: A scalar quantity to measure the benefit of using more recurrent steps in a state.
A new definition based on value functions; it is a formal metric, with no claim of a physical or external referent.

how reviews work

0 comments

Cite this review

Pith. "Pith review of On the Role of Computation in Reinforcement Learning." pith.science (2026). https://pith.science/paper/2HYFFQLA

@misc{pith2026260205999,
  author       = {Pith},
  title        = {Pith review of: On the Role of Computation in Reinforcement Learning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/2HYFFQLA}},
  note         = {Machine review of arXiv:2602.05999}
}

abstract

How does the amount of compute available to a reinforcement learning (RL) policy affect its learning? Can policies using a fixed amount of parameters, still benefit from additional compute? The standard RL framework does not provide a language to answer these questions formally. Empirically, deep RL policies are often parameterized as neural networks with static architectures, conflating the amount of compute and the number of parameters. In this paper, we formalize compute bounded policies and prove that policies which use more compute can solve problems and generalize to longer-horizon tasks that are outside the scope of policies with less compute. Building on prior work in algorithmic learning and model-free planning, we propose a minimal architecture that can use a variable amount of compute. Our experiments complement our theory. On a set 31 different tasks spanning online and offline RL, we show that $(1)$ this architecture achieves stronger performance simply by using more compute, and $(2)$ stronger generalization on longer-horizon test tasks compared to standard feedforward networks or deep residual network using up to 5 times more parameters.

Figures

Figures reproduced from arXiv: 2602.05999 by the authors.

**Figure 1.** Complete recurrent architecture. This figure demonstrates the architecture for training policies/value functions. The recurrent block we use is an IRU. The Complete Architecture. In our experiments, we will use this recurrent block as the core building block for our policy and value networks. These networks will take as input the observation and (for Q-functions) the action. After an initial Linear layer and Layer-… view at source ↗

**Figure 2.** Scaling recurrent steps in discrete environments. Both Boxpick tasks improve as the number of recurrent steps increases, with performance often peaking at five recurrent steps. 0.0 0.5 1.0 Training Steps (M) 0.0 0.3 0.6 Success Rate scene-play-v0 0.0 0.5 1.0 Training Steps (M) 0.0 0.3 0.6 cube-double-play-v0 0.0 0.5 1.0 Training Steps (M) 0.0 0.3 puzzle-4x4-play-v0 0.0 0.5 1.0 Training Steps (M) 0.0 0.3 antmaze-medi… view at source ↗

**Figure 3.** Scaling up recurrent steps in continuous environments improves performance in OGBench tasks (Park et al., 2025). Interestingly, additional recurrent steps considerably improve performance mainly in tasks that involve long-horizon reasoning (scene, cube, and puzzle), while performance in stitching navigation tasks increases marginally with more steps. 0.00 0.25 0.50 Env Steps (B) 0.0 0.3 0.6 Success Rate (Long horizo… view at source ↗

Figures from the paper (3 more)

**Figure 4.** Figure 4: Do recurrent steps improve generalization? Throughout training, we track how policies learned by the IRU architecture and baselines perform on unseen tasks, including those that require more steps to solve. The IRU architecture learns faster (on 5/5 tasks) and converge…

**Figure 5.** Figure 5: The Value of Compute. We plot the value of compute of IRU-(5) over IRU-(1) for different number of steps. We see that as the VoC increases with the number of steps using less compute, and VoC also peaks at the early half of the episode where choosing the correct action…

**Figure 7.** Figure 7: Ablation experiments comparing several recurrent blocks in the complete architecture ( [PITH_FULL_IMAGE:figures/full_fig_p008_7.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

14 extracted references · 5 linked inside Pith

[1]

The optimal policyπ ∗ belongs to the classΠ f
[2]

For any policyπ∈Π g,J(π)is arbitrarily lower thanJ(π ∗). Proof. Let U be a universal Turing machine that given an input of the form (⟨M⟩10 ∗), simulates the computation of M(⟨M⟩10 ∗) such that each step of the simulating M takes up some time c(|⟨M⟩|), depending only on the size of M and not on its input3. See Theorem 9.10 of (Sipser, 2006) for the descrip...

2006
[9]

ISBN 9781510838819

Curran Associates Inc. ISBN 9781510838819. V oelcker, C., Liao, V ., Garg, A., and massoud Farahmand, A. Value gradient weighted model-based reinforcement learning, 2023. URL https://arxiv.org/abs/ 2204.01464. Wang, G., Li, J., Sun, Y ., Chen, X., Liu, C., Wu, Y ., Lu, M., Song, S., and Yadkori, Y . A. Hierarchical reasoning model, 2025a. URL https://arxi...

arXiv 2023
[12]

The optimal goal conditioned policyπ ∗ belongs to the classΠ f
[13]

But for infinitely many longer-horizon test tasks,π ∗ g is arbitrarily worse thanπ ∗

For all training tasks (strain, gtrain ∼p train(s, g)), the best g-bounded policy π∗ g ∈Π g has the same value function as π∗. But for infinitely many longer-horizon test tasks,π ∗ g is arbitrarily worse thanπ ∗. Proof.We will use a lot of the components built in the policy hierarchy theorem (Theorem A.1) in this proof. We first define the MDP. The state ...

2015
[256]

The ResNets used in this task consist of two residual blocks, each with four hidden layers, following the architecture of Wang et al. (2025b). The dimensions of all layers in the residual blocks is 256. The MLPs used in this task contain 2 hidden linear layers of 256 dimensions. Table 2.DQN hyperparameters in Boxpick benchmark. Hyperparameter Value num en...

2025
[1991]

doi: 10.1145/122344.122377

ISSN 0163-5719. doi: 10.1145/122344.122377. URL https://doi.org/10.1145/122344.1 22377. Tamar, A., Wu, Y ., Thomas, G., Levine, S., and Abbeel, P. Value iteration networks. InProceedings of the 30th Inter- national Conference on Neural Information Processing Systems, NIPS’16, pp. 2154–2162, Red Hook, NY , USA,

arXiv
[2015]

Siegelmann, H

URL https://arxiv.org/abs/1506.0 4214. Siegelmann, H. T. and Sontag, E. D. On the computational power of neural nets. InProceedings of the Fifth Annual Workshop on Computational Learning Theory, COLT ’92, pp. 440–449, New York, NY , USA, 1992. Association for Computing Machinery. ISBN 089791497X. doi: 10.1145/130385.130432. URL https://doi.org/ 10.1145/13...

arXiv 1992

Show all 14 references

[2016]

Bansal, A., Schwarzschild, A., Borgnia, E., Emam, Z., Huang, F., Goldblum, M., and Goldstein, T

URL https://arxiv.org/abs/1607.0 6450. Bansal, A., Schwarzschild, A., Borgnia, E., Emam, Z., Huang, F., Goldblum, M., and Goldstein, T. End-to-end algorithm synthesis with recurrent networks: Extrapola- tion without overthinking. In Koyejo, S., Mohamed, S., Agarwal, A., Belgra...

2022
[2017]

URL https://arxiv.org/abs/1707.0 3497. OpenAI, Akkaya, I., Andrychowicz, M., Chociej, M., Litwin, M., McGrew, B., Petron, A., Paino, A., Plap- pert, M., Powell, G., Ribas, R., Schneider, J., Tezak, N., Tworek, J., Welinder, P., Weng, L., Yuan, Q., Zaremba, W., and Zhang, L. So...
[2019]

Ostrovski, G., Castro, P

URL https://arxiv.org/abs/1910.0 7113. Ostrovski, G., Castro, P. S., and Dabney, W. The difficulty of passive learning in deep reinforcement learning, 2021. URLhttps://arxiv.org/abs/2110.14020. Park, S., Frans, K., Eysenbach, B., and Levine, S. Ogbench: Benchmarking offline go...

1910 arXiv
[2020]

ISBN 9781713829546

Curran Associates Inc. ISBN 9781713829546. Bush, T., Chung, S., Anwar, U., Garriga-Alonso, A., and Krueger, D. Interpreting emergent planning in model-free reinforcement learning, 2025. URL https://arxiv. org/abs/2504.01871. Cho, H., Cha, J., Awasthi, P., Bhojanapalli, S., Gup...

2025 arXiv
[2024]

org/CorpusID:273695226

URL https://api.semanticscholar. org/CorpusID:273695226. Cho, K., van Merrienboer, B., Bahdanau, D., and Bengio, Y . On the properties of neural machine translation: Encoder- decoder approaches. In Wu, D., Carpuat, M., Carreras, X., and Vecchi, E. M. (eds.),Proceedings of SSST...

2014 arXiv
[2473]

URL https://proc eedings.mlr.press/v97/guez19a.html

PMLR, 09–15 Jun 2019a. URL https://proc eedings.mlr.press/v97/guez19a.html. Guez, A., Mirza, M., Gregor, K., Kabra, R., Racani`ere, S., Weber, T., Raposo, D., Santoro, A., Orseau, L., Eccles, T., Wayne, G., Silver, D., and Lillicrap, T. An investigation of model-free planning,...

1901 arXiv

Pith tools

Reviewed August 3, 2026 · model on record in the stance chip above.

[1] [1]

The optimal policyπ ∗ belongs to the classΠ f

[2] [2]

For any policyπ∈Π g,J(π)is arbitrarily lower thanJ(π ∗). Proof. Let U be a universal Turing machine that given an input of the form (⟨M⟩10 ∗), simulates the computation of M(⟨M⟩10 ∗) such that each step of the simulating M takes up some time c(|⟨M⟩|), depending only on the size of M and not on its input3. See Theorem 9.10 of (Sipser, 2006) for the descrip...

2006

[3] [9]

ISBN 9781510838819

Curran Associates Inc. ISBN 9781510838819. V oelcker, C., Liao, V ., Garg, A., and massoud Farahmand, A. Value gradient weighted model-based reinforcement learning, 2023. URL https://arxiv.org/abs/ 2204.01464. Wang, G., Li, J., Sun, Y ., Chen, X., Liu, C., Wu, Y ., Lu, M., Song, S., and Yadkori, Y . A. Hierarchical reasoning model, 2025a. URL https://arxi...

arXiv 2023

[4] [12]

The optimal goal conditioned policyπ ∗ belongs to the classΠ f

[5] [13]

But for infinitely many longer-horizon test tasks,π ∗ g is arbitrarily worse thanπ ∗

For all training tasks (strain, gtrain ∼p train(s, g)), the best g-bounded policy π∗ g ∈Π g has the same value function as π∗. But for infinitely many longer-horizon test tasks,π ∗ g is arbitrarily worse thanπ ∗. Proof.We will use a lot of the components built in the policy hierarchy theorem (Theorem A.1) in this proof. We first define the MDP. The state ...

2015

[6] [256]

The ResNets used in this task consist of two residual blocks, each with four hidden layers, following the architecture of Wang et al. (2025b). The dimensions of all layers in the residual blocks is 256. The MLPs used in this task contain 2 hidden linear layers of 256 dimensions. Table 2.DQN hyperparameters in Boxpick benchmark. Hyperparameter Value num en...

2025

[7] [1991]

doi: 10.1145/122344.122377

ISSN 0163-5719. doi: 10.1145/122344.122377. URL https://doi.org/10.1145/122344.1 22377. Tamar, A., Wu, Y ., Thomas, G., Levine, S., and Abbeel, P. Value iteration networks. InProceedings of the 30th Inter- national Conference on Neural Information Processing Systems, NIPS’16, pp. 2154–2162, Red Hook, NY , USA,

arXiv

[8] [2015]

Siegelmann, H

URL https://arxiv.org/abs/1506.0 4214. Siegelmann, H. T. and Sontag, E. D. On the computational power of neural nets. InProceedings of the Fifth Annual Workshop on Computational Learning Theory, COLT ’92, pp. 440–449, New York, NY , USA, 1992. Association for Computing Machinery. ISBN 089791497X. doi: 10.1145/130385.130432. URL https://doi.org/ 10.1145/13...

arXiv 1992