# F5-conf-04 — VFI vs closed-form policy, optimal growth with log utility

# Question

A planner maximises Σ β^t ln c_t subject to y_{t+1} = (y_t − c_t)^α. This report compares the closed-form optimal consumption policy and value function with the ones obtained by value-function iteration (VFI) on the prescribed grid. The parameter point is α = 0.36, β = 0.95.

# Data and exclusions

• The only input is data/model.csv: 10 parameter rows (n_input_rows). Its SHA-256 matches the bundle.
• No rows were excluded (out/exclusions.csv).
• Grid: 400 points equally spaced in ln y on [0.05, 5] (grid_points_used, n_analysed). VFI stopping tolerance: 1e-8 in the sup norm.
• Design notes, recorded in data_issues:
  1. The evaluation points 0.5, 1.0 and 2.0 are not grid nodes. VFI policy and value are therefore interpolated linearly in ln y between neighbouring nodes.
  2. The control (next-period output y′) is restricted to the same grid. This is standard discrete VFI, with no off-grid optimisation.
• No random numbers are used (random_seed = null).

# Method

Closed form (guess and verify). Assumptions: log utility, Cobb–Douglas technology y′ = k^α with productivity 1, full depreciation, 0 < α < 1, 0 < β < 1, and an interior solution 0 < c < y.

• Guess V(y) = A + B ln y. The Bellman right-hand side becomes ln c + β(A + Bα ln(y − c)).
• The first-order condition 1/c = αβB/(y − c) gives c = y/(1 + αβB).
• Matching the coefficients on ln y gives B = 1 + αβB, so B = 1/(1 − αβ).
• Policy: c(y) = (1 − αβ) y. Savings rate: (y − c)/y = αβ.
• Constant: A = [ln(1 − αβ) + (αβ/(1 − αβ)) ln(αβ)] / (1 − β).
• I also checked numerically that this V satisfies the Bellman equation, by brute-force continuous maximisation at y ∈ {0.1, 0.5, 1, 2, 4} (out/state/checks.md).

Contraction. The Bellman operator T is monotone (v ≤ w implies Tv ≤ Tw) and discounts (T(v + a) = Tv + βa). By Blackwell's sufficient conditions it is a contraction in the sup norm with modulus β.

• This argument applies on the bounded grid problem: the state space is compact, and at every node there is a feasible choice with c bounded away from 0, so the return is bounded. The infinite-domain log-utility problem has unbounded returns, so there the argument needs a weighted-norm extension or the closed-form verification instead.
• As a check, the optimal y′ = (αβy)^α maps [0.05, 5] into roughly [0.23, 1.21]. The grid truncation therefore never binds (VFI choice indices stay between 133 and 276 of 0–399; diagnostics.choice_index_min_max).

VFI.

• Start from V₀ = 0 and iterate V_{n+1}(y_i) = max_j { ln(y_i − y_j^{1/α}) + β V_n(y_j) } over feasible j, until the sup change is below 1e-8.
• Read the policy off the argmax: c = y_i − y_j^{1/α}.
• Implementation: out/analysis.py, vectorised.

# Results

• Maximum absolute policy error over the three points: 0.00637 (max_abs_error_policy). It occurs at y = 2, about 0.5% of consumption.
• Savings rate implied by the closed form: αβ = 0.342 (savings_rate_closed_form, also stored as baseline_savings_rate).
• Contraction modulus: 0.95 (contraction_modulus).
• VFI converged in 361 iterations (n_iterations), with a final sup change of 9.997e-9 (final_sup_change).
• Diagnostics:
  • Largest policy error at any grid node: 0.0251 (diagnostics.max_abs_error_policy_on_grid), at high y.
  • Largest value error at any grid node: 4.8e-4 (diagnostics.max_abs_error_value_on_grid).

# Uncertainty

The model is deterministic, so there is no sampling uncertainty. The numerical error has two sources:

1. Iteration truncation. It is bounded by β/(1 − β) × final sup change ≈ 1.9e-7 utils (diagnostics.vfi_error_bound_beta_over_1mbeta_times_sup). This is negligible.
2. Discretisation. This is the dominant source.
   • The chosen y′ can be off by up to half a log step (Δ ln y = 0.0115, diagnostics.grid_log_step).
   • Because k = y′^{1/α}, a small error in y′ becomes an error of roughly (k/α)·Δ ln y′ in consumption. That error grows with y, which is why the policy error is largest at y = 2 and at the top of the grid.
   • The policy error is first order in grid spacing. The value error is much smaller (second order, by the envelope theorem).
   • Interpolating the policy between nodes adds a little more error.

# Limitations and open issues

• The validation covers one parameter point (α = 0.36, β = 0.95), one grid (400 log-spaced points on [0.05, 5]) and one tolerance (1e-8). I have not shown how the error shrinks as the grid is refined.
• The discrete-choice VFI policy is a step function. A finer grid, or continuous optimisation of the control, would reduce the policy error. I did not do either, because the task prescribes this grid.
• The contraction argument as stated applies to the bounded (truncated-grid) problem.
• All required outputs were produced (feasibility = "complete").