Standard Python if/else statements present a challenge for JAX's compilation process. When JAX traces a function using jax.jit, it converts the Python code into an intermediate representation (jaxpr). A standard Python if statement executes only one branch during tracing, based on the Python-level values available at that time. If the condition depends on the value of a traced variable (a JAX array), this approach fails because the actual value isn't known until runtime. JAX needs a way to represent conditional logic within the computation graph itself.

This is where jax.lax.cond comes in. It provides functional, traceable conditional execution, allowing you to branch computation paths based on runtime values within jit-compiled code.

The `lax.cond` Primitive

The lax.cond function has the following signature:

jax.lax.cond(pred, true_fun, false_fun, *operands)

Or, more commonly used when passing a single operand (which might be a pytree):

jax.lax.cond(pred, true_fun, false_fun, operand)

Let's break down its components:

pred: This is a scalar boolean JAX array (i.e., an array with shape () and dtype bool). The value of pred at runtime determines which branch is executed. It must be a JAX array value, not a plain Python boolean, if its value depends on traced inputs.
true_fun: A Python callable (like a function or lambda) that is executed if pred is True. It takes operand (or *operands) as input.
false_fun: A Python callable executed if pred is False. It also takes operand (or *operands) as input.
operand (or *operands): The input value(s) passed to either true_fun or false_fun. This can be a single JAX array, multiple arrays, or a pytree (like a tuple or dictionary) containing JAX arrays.

A significant requirement of lax.cond is that true_fun and false_fun must operate on operands of the same type, shape, and dtype, and they must return outputs that also have the exact same structure (type, shape, and dtype). This structural consistency is necessary because JAX determines the shape and dtype of the output during tracing (compile time), before the actual value of pred is known.

How `lax.cond` Works Under the Hood

Unlike a Python if, lax.cond doesn't execute just one branch during tracing. Instead, JAX traces both true_fun and false_fun to ensure they are valid computations and to determine the output structure. The resulting compiled code, however, will contain logic (often implemented using specialized instructions on the accelerator) to evaluate pred at runtime and execute only the chosen branch.

lax.cond evaluates the predicate pred at runtime. Based on the result, it routes the Operand to either true_fun or false_fun and executes that function, producing a Result with a structure consistent across both branches.

Example: Conditional Processing

Let's consider a function where we want to either square or cube an array x based on whether the sum of its elements is positive.

First, attempting this with a standard Python if inside a jit-compiled function:

import jax
import jax.numpy as jnp

def python_conditional_process(x):
  if jnp.sum(x) > 0: # Condition depends on the value of x
    print("Executing Python 'if' branch (Tracing)")
    return x * x
  else:
    print("Executing Python 'else' branch (Tracing)")
    return x * x * x

# Try JIT compiling
jitted_python_conditional = jax.jit(python_conditional_process)

data_pos = jnp.array([1., 2., 3.])
data_neg = jnp.array([-1., -2., -3.])

# This will likely raise a ConcretizationTypeError or trace only one branch
try:
  print("Running with positive data:")
  result_pos = jitted_python_conditional(data_pos)
  print("Result:", result_pos)

  # This might trigger a re-compilation or use the trace from the first call
  print("\nRunning with negative data:")
  result_neg = jitted_python_conditional(data_neg)
  print("Result:", result_neg)
except Exception as e:
  print("\nError:", e)

You'll likely encounter a ConcretizationTypeError because the boolean result of jnp.sum(x) > 0 is needed during tracing to decide the control flow of the Python if, but JAX treats x as an abstract tracer object at this stage. JAX cannot commit to a specific branch based on an abstract value.

Now, let's implement this correctly using lax.cond:

import jax
import jax.numpy as jnp
import jax.lax as lax

def lax_conditional_process(x):
  # Define the functions for the two branches
  # They must accept the same input structure (x)
  # and return the same output structure (an array with the same shape/dtype as x)
  def true_branch(operand):
    print("Tracing true_branch (square)")
    return operand * operand

  def false_branch(operand):
    print("Tracing false_branch (cube)")
    return operand * operand * operand

  # The condition must be a scalar boolean JAX array
  pred = jnp.sum(x) > 0

  # Apply lax.cond
  return lax.cond(pred, true_branch, false_branch, x)

# JIT compile the function
jitted_lax_conditional = jax.jit(lax_conditional_process)

data_pos = jnp.array([1., 2., 3.])
data_neg = jnp.array([-1., -2., -3.])

# First run: Traces both branches, compiles, then executes the true branch
print("Running with positive data (first call):")
result_pos = jitted_lax_conditional(data_pos)
# Block to see print statements from execution if any (usually optimized away)
result_pos.block_until_ready()
print("Result:", result_pos)
# Expected: Tracing messages for both branches, then result [1., 4., 9.]

print("\nRunning with negative data (cached call):")
# Second run: Uses the cached compilation, executes the false branch
result_neg = jitted_lax_conditional(data_neg)
result_neg.block_until_ready()
print("Result:", result_neg)
# Expected: No new tracing messages, then result [-1., -8., -27.]

Notice that during the first execution (which triggers compilation), the print statements inside true_branch and false_branch will both execute. This confirms that JAX traces both paths to build the complete computation graph. Subsequent calls with different data (but the same input shapes/dtypes) will reuse the compiled code, efficiently executing only the necessary branch at runtime without Python overhead or retracing.

Interaction with Other Transformations

lax.cond is designed to work smoothly with other JAX transformations:

jax.vmap: You can vectorize a function containing lax.cond. If you map over an array of operands and a corresponding array of predicates, vmap will effectively apply lax.cond element-wise across the batch dimension. The appropriate branch (true_fun or false_fun) will be chosen independently for each item in the batch based on its corresponding predicate value.
jax.grad: Automatic differentiation works through lax.cond. The gradient calculation will correspond to the branch that was actually executed at runtime for the forward pass. If pred itself depends on differentiable variables, gradients will flow through that calculation as well. Be mindful that if the two branches have very different mathematical properties, it could affect optimization stability, but the differentiation mechanism itself handles the conditional structure.

Comparison with `jnp.where`

It's important to distinguish lax.cond from jnp.where.

jnp.where(condition, x, y): This function operates element-wise. It requires condition, x, and y to be broadcastable to the same shape. It evaluates both x and y entirely and then selects elements from x where condition is true and elements from y where condition is false to construct the output array.
lax.cond(pred, true_fun, false_fun, operand): This function selects which computation (true_fun or false_fun) to execute based on a single scalar boolean pred. It executes only one of the functions at runtime.

Use lax.cond when you need to choose between fundamentally different computational paths based on a scalar condition. Use jnp.where when you need to select values element-wise based on a boolean mask.

Performance and Limitations

Compilation Overhead: Since both branches are traced and compiled, there's a compile-time cost associated with both. However, the runtime cost only involves executing the selected branch.
Scalar Predicate: lax.cond requires a scalar predicate. If you need conditional logic based on multiple boolean values (e.g., element-wise conditions for selecting different operations), you might need to combine lax.cond with vmap or use jnp.where, or potentially restructure your logic.
Structural Consistency: The strict requirement for matching input/output structures between branches is the most common source of errors when using lax.cond. Careful function design is needed.

lax.cond is an indispensable tool for implementing algorithms with data-dependent control flow, such as certain optimization routines, reinforcement learning policies, or models with conditional computation layers, all within the performant, compiled environment of JAX.

The lax.cond Primitive

Conditional Execution with lax.cond