# Homotopy Methods for solving General Eqm

**URL:** https://discourse.vfitoolkit.com/t/homotopy-methods-for-solving-general-eqm/713
**Category:** Uncategorized
**Created:** [September 28, 2026, 8:26am UTC](https://discourse.vfitoolkit.com/t/homotopy-methods-for-solving-general-eqm/713 "2026-09-28T08:26:08Z")
**Posts on this page:** 1
**Page:** 1

<div class="post-metadata">

### Author: ![robertdkirkby](https://discourse.vfitoolkit.com/user_avatar/discourse.vfitoolkit.com/robertdkirkby/32/287_2.png) [@robertdkirkby](https://discourse.vfitoolkit.com/u/robertdkirkby)
#### Post date: [September 28, 2026, 8:26am UTC](https://discourse.vfitoolkit.com/t/homotopy-methods-for-solving-general-eqm/713/1 "2026-09-28T08:26:09Z")

</div>

A friend told me they were using a Homotopy method to find the stationary general eqm of an OLG model. I had no idea what that was, so I read [Chapter 5 of Judd’s Numerical Methods in Economics](https://www.business.uzh.ch/dam/jcr:ffffffff-cd5d-ce16-0000-000076c01f71/NumericalMethodsJuddPartIPP1-307.pdf) and [Eaves & Schmedders (1999)](https://ideas.repec.org/a/eee/dyncon/v23y1999i9-10p1249-1279.html), and this post is my summary for future myself. The idea is that we want to solve the general eqm, which is the solution to f(x)=0. [If you use VFI Toolkit, f(x)=0 is exactly how it thinks about what constitutes a general eqm; you write the general eqm eqns and it finds where they equal zero.]

Standard approaches might be something like a shooting method or a Newton-method, we guess x^0, and then update it as x^1=\*(1-\phi) x^0+\phi f(x^0) or x^1=x^0+ \frac{f(x^0)}{f'(x^0)}. This gives us a sequence of guesses x^0, x^1, \dots, x^n and we hope/expected/prove that these will converge to x^\* which satisfies f(x^\*)=0. That is, we hope these converge to (a solution to) the general eqm. [This leaves open issues of uniqueness, but we will ignore them today.]

Homotopy methods also involve creating a sequence of guesses x^0, x^1, \dots, x^n that we hope will converge to x^\* which satisfies f(x^\*)=0. But the approach to constructing this sequence is quite different. We have our main model we want to solve f(x)=0, which we relabel f\_1(x)=0. We also think of some simple model that we already know the solution to (or at least we can easily get the solution to), and we denote this f\_0(x)=0. So f\_0 is the easy known model, and f\_1 is the model we want to solve.

The key idea is that we define a ‘path’ of models f\_t(x) for t\in [0,1] which goes smoothly from f\_0(x) (our simple model) to f\_1(x) which we wish to solve. An alternative notation for all this is that f(x,0)=0 is the easy model, f(x,1)=0 is the model we want to solve, and f(x,t)=0 defines the path over t\in [0,1]. The art is all in how we can define the easy-to-solve model f(x,0)=0 and the smooth path f(x,t)=0 for t\in [0,1]. The word Homotopy means ‘a continuous deformation of one mathematical function or path into another’, which is exactly the role of the t in our f(x,t)=0 notation: t deforms the simple model into our full model.

For example, we might want to solve a model where an agent has endowment \bar{e}, and we can easily solve the model where their endowment is 0 (they will get nothing), so we define the path as the models with endowment t \bar{e}. Or maybe we can easily solve an OLG without idiosyncratic shocks, but we want to solve one with idiosyncratic shock z. We might set tz as the shocks for the path.

This makes the general idea of Homotopy methods clear. We are somehow going to first solve the easy model f(x,0)=0, then based on this we solve along the path, say f(x,0.1)=0, f(x,0.2)=0, \dots, f(x,0.9)=0 and finally the f(x,1)=0 that is the model we want to solve. But this leaves open two questions, how do we move along the path in terms of stepping along t (the 0.1 each time above is just something I made up arbitrarily), and how much do we ‘solve’ a given t exactly versus incrementing t again (clearly we cannot just keep exactly solving for each t \in [0,1] or the algorithm is going to take forever). But this leaves a wide open question of how to actually implement the idea?

Eaves & Schmedder state that “Path-following has many variations”, and what follows here is the protoyupe of the predictor-corrector method. We start from x^0 which is the solution to our easy model f(x,0)=0. The predictor-corrector method alternates predictor-steps (loosely movements in t and x) with corrector-steps (loosely movements in x).  
_Predictor Step_: The predictor-step, often called an Euler step, begins at a point near the path and moves in an approximately tangent direction of the route (so along t, but adjusting x to hopefully stay near the path while we increase t). Given a point c=(x,t) on or near the path, the next iterate, the Euler predictor, is c+sc' where Df(c)c'\approx0 and the scalar s is the positive stepsize. Such c' is an approximate tangent direction of the path at c.  
_Corrector Step_: The purpose of the corrector-step, often called a Newton step, is to move from the predicted point to a nearby point back on the path. This operation is often carried out in the space perpendicular to the predictor direction.  
As an example, here is Figure 4 of Eaves & Schmedders (1999)

 ![https://ars.els-cdn.com/content/image/1-s2.0-S0165188998000736-gr4.gif](https://discourse.vfitoolkit.com/uploads/default/original/1X/a444b4e3445fc15bd8d219daca4465dc883f8d78.gif)  
the idea is that “primary route” is the path traced out be f(x,t)=0 (t is the vertical axis from 0 to 1, x is the horizontal axis in region X). We start at point ‘1’ on the path, the predictor moves us to point ‘2’ (along a tangent to the path), and the corrector moves us to point ‘3’ (back to the path). Of course reality won’t always be this nice to us, so you might end up doing two or three corrector steps in a row to get close to the path before doing the next predictor step along the path.  
In the end what we are getting is a sequence of pairs of points (x^0,0), (x^1,t^1), (x^2,t^2), \dots, (x^{n-1},t^n\_1), (x^n,t^n), and the hope/expectation is that (x^n,t^n) ends up converging to (x^\*,1) [Theory tells us this will work if the homotopy is smooth and regular, but whether your homotopy is smooth in a given application is going to be hard to say].

So in the end it looks like a derivative-based method like Newton, just that instead of following the gradient you follow the gradient-along-the-path. So it has a bit more structure, and the hope is that that structure helps you find the solution to your model faster and more reliably. The catch is that f(x,t) is a lot harder to code up than just the f(x) which is all most methods need.

Unfortunately neither Judd nor Eaves and Schmedders have nothing to say about how Homotopy methods perform for solving incomplete markets models of today (unsurprisingly since both predate these models being widely used). So whether or not Homotopy methods are something worthwhile for solving BIHA models or OLGs remains an open question. There seem to be a few articles about using Homotopy methods for solving dynamic stochastic games for Nash equilbiria and the like, so it appear game theory is the main ‘live’ application.