You've seen that JAX builds upon the idea of pure functions, functions whose output depends only on their explicit inputs, without causing external changes or side effects like modifying global variables or changing the state of input objects. This purity is fundamental to how transformations like jax.jit and jax.grad operate. They trace the function's execution once with symbolic inputs to understand the sequence of operations, which they can then compile, differentiate, or parallelize efficiently.

Now, consider common programming patterns in standard Python. We often manage changing information, or state, by modifying objects directly. Think about updating a list in place using its .append() method, changing a value within a dictionary, or modifying an attribute of a class instance.

# Standard Python state modification (NOT JAX-friendly)
my_data = {'values': [10, 20]}

def update_data(data_dict, new_value):
  # Modifies the dictionary passed in - a side effect
  data_dict['values'].append(new_value)
  data_dict['last_added'] = new_value

update_data(my_data, 30)
print(my_data)
# Output: {'values': [10, 20, 30], 'last_added': 30}

This imperative style, characterized by in-place modifications and hidden state changes, while natural in many contexts, presents a significant challenge within JAX's functional framework. Why is this the case?

Breaking jax.jit: When jax.jit traces a function for compilation, it fundamentally assumes the function behaves purely. If the function modifies some external state (like a global variable or an object attribute that wasn't explicitly passed in and returned), the trace captures the state at the time of tracing. The compiled version, designed for speed, will likely reuse this initial trace. It won't automatically track subsequent changes to that external state made outside the function or between calls. This leads to results that might be subtly wrong or completely unexpected, as the compiled code's behavior depends on a stale, hidden history rather than just its current inputs.
Confusing jax.grad: Automatic differentiation, the engine behind jax.grad, needs to track the precise flow of data through computations to calculate gradients correctly. In-place modifications obscure this data flow. If a value within an array or object is changed midway through a function, how can grad accurately determine the mathematical relationship between the final output and the original input? It effectively breaks the chain of operations needed for reverse-mode differentiation. Attempting to differentiate functions with such side effects often leads to errors or, worse, mathematically incorrect gradients that silently derail optimization processes like model training.
Impeding jax.vmap and jax.pmap: Vectorization (jax.vmap) and multi-device parallelization (jax.pmap) rely on the assumption that multiple instances of a function can run independently, perhaps operating on different slices of data or executing simultaneously on different hardware accelerators. If these operations all attempt to read from and write to the same mutable state object, you introduce conflicts and potential race conditions. This fundamentally breaks the assumption of independence required for safe and correct parallel execution. Each vectorized or parallel instance effectively needs its own isolated state, which direct mutation makes difficult to manage reliably.

Consider a simplified scenario attempting to jit a function that modifies an attribute of an object passed into it:

import jax
import jax.numpy as jnp

class StateHolder:
    def __init__(self, value):
        self.value = jnp.array(value)

def update_state_impurely(state_obj, increment):
  # Impure: Modifies the object's attribute in-place
  state_obj.value = state_obj.value + increment
  return state_obj.value # Returns the new value, but the mutation happened

my_state = StateHolder(10.0)

# Without JIT, this works as expected by mutation
print("Without JIT:")
print(update_state_impurely(my_state, 5.0)) # Output: 15.0
print(my_state.value)                     # Output: 15.0
print(update_state_impurely(my_state, 3.0)) # Output: 18.0
print(my_state.value)                     # Output: 18.0

# Reset state and try with JIT
my_state_jit = StateHolder(10.0)
jitted_update = jax.jit(update_state_impurely)

print("\nWith JIT (potential issues):")
try:
    # First call triggers tracing and compilation
    print(jitted_update(my_state_jit, 5.0))
    # The compiled function might operate on the *traced* value (10.0)
    # The mutation might happen outside the compiled function's view,
    # or JAX might raise an error/warning about the side effect.
    print(my_state_jit.value) # State might or might not be updated as expected
    print(jitted_update(my_state_jit, 3.0)) # Might reuse the stale trace
    print(my_state_jit.value)
except Exception as e:
    print(f"JIT attempt encountered an issue: {e}")

The JIT compilation process might trace the function using the initial value (10.0). The compiled function might then be fixed based on that trace. The in-place update state_obj.value = ... represents a side effect that JAX transformations struggle with. Depending on the specifics and JAX version, this could lead to errors during compilation, warnings about impure callbacks, or silently incorrect behavior where the compiled function doesn't reflect the intended state updates on subsequent calls.

Therefore, any task within JAX that involves information changing over time or across computation steps, such as updating model parameters during training, managing the momentum values in an optimizer, or carrying hidden states forward in recurrent neural networks, demands a different programming pattern. We cannot rely on modifying objects or variables in place if we want our code to be reliably compatible with JAX's powerful transformations (jit, grad, vmap, pmap).

We need patterns that handle state explicitly, making its flow transparent and controllable within the functional paradigm. This means functions that need to update state should typically take the current state as input and return the new, updated state as output, leaving the original state untouched. The following sections will introduce these essential functional patterns for state management in JAX.