Dynamic Programming methods like Policy Iteration and Value Iteration, which we explored earlier in this chapter, offer powerful theoretical tools. They provide algorithms guaranteed to find the optimal value functions ( $V^*$ or $Q^*$ ) and thus the optimal policy ( $\pi^*$ ) for a finite Markov Decision Process. However, their practical application often hits significant roadblocks. These limitations stem primarily from two major requirements: the need for a complete model of the environment and the computational cost associated with large problems.

The Requirement of a Full Model

The most significant practical limitation of Dynamic Programming in Reinforcement Learning is its dependence on a complete and accurate model of the environment. Remember that both Policy Evaluation (within Policy Iteration) and Value Iteration rely on knowing the transition probabilities $p(s', r | s, a)$ for all states $s$ , actions $a$ , next states $s'$ , and rewards $r$ .

Think about what this means:

Knowledge of Dynamics: We need to know exactly how the environment works. For any state we are in, and any action we might take, we must know the probability of transitioning to every other possible state and the probability of receiving every possible reward.
Accessibility of the Model: This complete model information must be available to the algorithm in a usable format.

In many situations of interest, having such a perfect model is simply unrealistic:

Unknown Environments: We often want agents to learn in environments where the rules are unknown beforehand. Consider a robot learning to navigate a new building or an algorithm learning to play a complex video game without access to the game's source code. The transition probabilities and reward structures aren't explicitly provided.
Modeling Complexity: Even if the underlying dynamics are governed by physical laws (like in robotics), creating an accurate simulation model that captures all relevant details, including noise and uncertainty, can be incredibly difficult, time-consuming, and itself prone to errors.
Non-Stationary Environments: In some cases, the environment's dynamics might change over time. A model that was accurate yesterday might not be accurate today, rendering DP calculations based on the old model suboptimal.

This requirement essentially means DP methods are tools for planning when you have a perfect map, rather than tools for learning when you need to explore and discover the map yourself.

Computational Scalability Challenges

Even if we are fortunate enough to possess a perfect model, DP methods face another major hurdle often referred to as the "Curse of Dimensionality". This relates to the computational resources required as the problem size grows.

The core operations in both Policy Iteration and Value Iteration involve iterating through the entire state space $\mathcal{S}$ (and often the action space $\mathcal{A}$ for each state) to perform updates based on the Bellman equations.

Policy Evaluation: Requires repeated sweeps through all states, updating $V(s)$ based on the values of successor states.
Value Iteration: Requires sweeps through all states, calculating the maximum expected value over all actions. The complexity of a single iteration is often proportional to something like $O(|\mathcal{S}|^2 |\mathcal{A}|)$ or potentially worse depending on the density of transitions.

Consider the implications:

Memory: Storing the value function $V(s)$ or $Q(s,a)$ requires memory proportional to the number of states $|\mathcal{S}|$ or state-action pairs $|\mathcal{S}| \times |\mathcal{A}|$ . Storing the model $p(s', r | s, a)$ can require even more space, potentially proportional to $|\mathcal{S}|^2 |\mathcal{A}|$ .
Computation Time: The time needed for each iteration grows rapidly with the size of the state and action spaces.

While feasible for small, discrete problems (like the Gridworlds often used in examples), this computational cost quickly becomes prohibitive for problems with:

Large number of discrete states: Think of games like Chess or Go, where the number of possible board configurations ( $|\mathcal{S}|$ ) is astronomical.
Continuous state spaces: If states are represented by continuous variables (e.g., robot joint angles, sensor readings), the state space is technically infinite. DP, in its basic form, cannot handle this directly. Discretizing continuous spaces often leads to an exponential blow-up in the number of states.

Illustration of how computational cost per iteration for Dynamic Programming methods scales rapidly with the number of states. Common complexities like $O(|\mathcal{S}|^2)$ or $O(|\mathcal{S}|^2|\mathcal{A}|)$ make DP impractical for very large state spaces. Both axes use a logarithmic scale.

Moving Beyond Dynamic Programming

These limitations highlight why DP, despite its theoretical importance in establishing the Bellman equations, is often not directly applicable to many complex, real-world Reinforcement Learning problems. We need methods that can:

Learn effective policies without requiring prior knowledge of the environment's dynamics (model-free methods).
Handle large or continuous state and action spaces efficiently.

This motivates the development of the model-free algorithms we will explore in the upcoming chapters, such as Monte Carlo methods (Chapter 4) and Temporal-Difference learning (Chapter 5), which learn directly from experience gathered through interaction with the environment. Furthermore, we will investigate function approximation techniques (Chapter 6) that allow us to generalize value estimates across large state spaces, breaking free from the constraints of tabular representations inherent in basic DP.