Deploy optimisation from main (6727a1a)

.dockerignore

@@ -0,0 +1,18 @@
+# Dependency folders (The biggest space eaters)
+node_modules/
+__pycache__/
+*.pyc
+venv/
+.env
+
+# Git history (Not needed inside the container)
+.git
+.gitignore
+
+# Build outputs from your local machine
+dist/
+build/
+
+# OS trash
+.DS_Store
+Thumbs.db

README.md

@@ -1,10 +1,59 @@
 ---
-title: Optimization Dev
-emoji: 🏆
-colorFrom: indigo
-colorTo: purple
+title: Optimization
+emoji: 🚀
+colorFrom: purple
+colorTo: indigo
 sdk: static
+app_file: dist/index.html
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Developer's Guide for React frontend
+
+## Prerequisites
+
+Install **Node.js** if not done yet. The following commands should run if you have it installed.
+
+```bash
+node -v
+npm -v
+```
+
+## Local Development 
+
+First go to the react frontend folder:
+```bash
+cd frontends/react
+```
+
+Run the following commands to install required packages when you run the code the first time or after you make changes to `package.json`.
+```bash
+npm install
+```
+
+Now you should be able to start the local development server:
+```bash
+npm run dev
+```
+Open the link printed out on the terminal. The webpage automatically reloads when files are edited. 
+
+## Deploy to Hugging Face
+
+### Build the production version:
+
+```bash
+npm run build
+```
+
+This generates the production build inside the `dist/` directory.
+
+### Commit and push:
+
+```bash
+git add <files>
+git commit
+git push
+```
+
+⚠️ Make sure the `dist/` directory is included when adding to git.  
+⚠️ Even if you only changed the backend, you must still run `npm run build` when deploying or it will not update.

backend/.python-version

@@ -0,0 +1 @@
+3.12

backend/README 2.md

@@ -0,0 +1,10 @@
+# Optimisation backend
+
+Python run in the browser by Pyodide (see `frontends/react/src/pyodide.worker.ts`).
+
+- `src/logic.py`: parsing the function, its derivatives, the optimisers and runs
+- `src/manager.py`: the `Manager` methods the UI calls
+- `src/algorithms.json`: each optimiser's settings, shared with the UI
+- `contract/`: example calls, checked by `tests/test_contract.py` and the frontend's `contract.check.ts`
+
+Run the tests with `uv run pytest`.

backend/README.md

@@ -0,0 +1,10 @@
+# Optimisation backend
+
+Python run in the browser by Pyodide (see `frontends/react/src/pyodide.worker.ts`).
+
+- `src/logic.py`: parsing the function, its derivatives, the optimisers and runs
+- `src/manager.py`: the `Manager` methods the UI calls
+- `src/algorithms.json`: each optimiser's settings, shared with the UI
+- `contract/`: example calls, checked by `tests/test_contract.py` and the frontend's `contract.check.ts`
+
+Run the tests with `uv run pytest`.

backend/contract/gradient_descent_quadratic 2.json

@@ -0,0 +1,11 @@
+{
+  "description": "Gradient descent on x^2 from x = 1 with learning rate 0.25 halves x each iteration",
+  "calls": {
+    "handle_set_function": { "args": { "variables": 1, "expression": "x^2" }, "result": null },
+    "handle_set_runs": { "args": { "runs": [{ "algorithm": "gradient_descent", "start": [1.0], "params": { "learning_rate": 0.25 } }] }, "result": null },
+    "handle_state": {
+      "args": { "iteration": 2 },
+      "result": { "runs": [{ "point": { "position": [0.25], "value": 0.0625, "gradient": [0.5], "hessian": [[2.0]] }, "stopped": null }] }
+    }
+  }
+}

backend/contract/gradient_descent_quadratic.json

@@ -0,0 +1,11 @@
+{
+  "description": "Gradient descent on x^2 from x = 1 with learning rate 0.25 halves x each iteration",
+  "calls": {
+    "handle_set_function": { "args": { "variables": 1, "expression": "x^2" }, "result": null },
+    "handle_set_runs": { "args": { "runs": [{ "algorithm": "gradient_descent", "start": [1.0], "params": { "learning_rate": 0.25 } }] }, "result": null },
+    "handle_state": {
+      "args": { "iteration": 2 },
+      "result": { "runs": [{ "point": { "position": [0.25], "value": 0.0625, "gradient": [0.5], "hessian": [[2.0]] }, "stopped": null }] }
+    }
+  }
+}

backend/contract/invalid_function 2.json

@@ -0,0 +1,6 @@
+{
+  "description": "A function of one variable can't use y",
+  "calls": {
+    "handle_set_function": { "args": { "variables": 1, "expression": "x^2 + y" }, "error": { "kind": "user", "message": "use only x" } }
+  }
+}

backend/contract/invalid_function.json

@@ -0,0 +1,6 @@
+{
+  "description": "A function of one variable can't use y",
+  "calls": {
+    "handle_set_function": { "args": { "variables": 1, "expression": "x^2 + y" }, "error": { "kind": "user", "message": "use only x" } }
+  }
+}

backend/contract/newton_singular_hessian 2.json

@@ -0,0 +1,20 @@
+{
+  "description": "Two runs stepped together on x^2 + 0y: Newton stops at once (singular Hessian), gradient descent (default learning rate 0.1) carries on",
+  "calls": {
+    "handle_set_function": { "args": { "variables": 2, "expression": "x^2 + 0y" }, "result": null },
+    "handle_set_runs": {
+      "args": { "runs": [
+        { "algorithm": "gradient_descent", "start": [1.0, 1.0], "params": {} },
+        { "algorithm": "newton", "start": [1.0, 1.0], "params": {} }
+      ] },
+      "result": null
+    },
+    "handle_state": {
+      "args": { "iteration": 1 },
+      "result": { "runs": [
+        { "point": { "position": [0.8, 1.0], "value": 0.64, "gradient": [1.6, 0.0], "hessian": [[2.0, 0.0], [0.0, 0.0]] }, "stopped": null },
+        { "point": null, "stopped": "The Hessian is singular here, so Newton's method can't take a step." }
+      ] }
+    }
+  }
+}

backend/contract/newton_singular_hessian.json

@@ -0,0 +1,20 @@
+{
+  "description": "Two runs stepped together on x^2 + 0y: Newton stops at once (singular Hessian), gradient descent (default learning rate 0.1) carries on",
+  "calls": {
+    "handle_set_function": { "args": { "variables": 2, "expression": "x^2 + 0y" }, "result": null },
+    "handle_set_runs": {
+      "args": { "runs": [
+        { "algorithm": "gradient_descent", "start": [1.0, 1.0], "params": {} },
+        { "algorithm": "newton", "start": [1.0, 1.0], "params": {} }
+      ] },
+      "result": null
+    },
+    "handle_state": {
+      "args": { "iteration": 1 },
+      "result": { "runs": [
+        { "point": { "position": [0.8, 1.0], "value": 0.64, "gradient": [1.6, 0.0], "hessian": [[2.0, 0.0], [0.0, 0.0]] }, "stopped": null },
+        { "point": null, "stopped": "The Hessian is singular here, so Newton's method can't take a step." }
+      ] }
+    }
+  }
+}

backend/contract/past_the_end 2.json

@@ -0,0 +1,6 @@
+{
+  "description": "Before any runs are set there is no state, so the stepper finds the end at iteration 0",
+  "calls": {
+    "handle_state": { "args": { "iteration": 0 }, "result": null }
+  }
+}

backend/contract/past_the_end.json

@@ -0,0 +1,6 @@
+{
+  "description": "Before any runs are set there is no state, so the stepper finds the end at iteration 0",
+  "calls": {
+    "handle_state": { "args": { "iteration": 0 }, "result": null }
+  }
+}

backend/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "backend"
+version = "0.1.0"
+description = "Optimisation visualisation: objective functions and optimisers, run in the browser by Pyodide"
+requires-python = ">=3.12"
+dependencies = [
+    "numpy>=2.4.0",
+    "sympy>=1.14.0",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.2.0",
+]
+
+[tool.pytest.ini_options]
+pythonpath = ["src", "."]
+testpaths = ["tests"]

backend/src/algorithms 2.json

@@ -0,0 +1,60 @@
+{
+  "algorithms": [
+    {
+      "id": "gradient_descent",
+      "label": "Gradient descent",
+      "params": [
+        { "name": "learning_rate", "label": "Learning rate η", "symbol": "η", "kind": "number", "min": 0, "minExclusive": true, "default": 0.1, "description": "How far each step moves along the negative gradient." },
+        { "name": "momentum", "label": "Momentum μ", "symbol": "μ", "kind": "number", "min": 0, "max": 1, "maxExclusive": true, "default": 0.0, "description": "How much of the previous step carries over into the next one." }
+      ]
+    },
+    {
+      "id": "nesterov",
+      "label": "Nesterov momentum",
+      "params": [
+        { "name": "learning_rate", "label": "Learning rate η", "symbol": "η", "kind": "number", "min": 0, "minExclusive": true, "default": 0.1, "description": "How far each step moves along the negative gradient." },
+        { "name": "momentum", "label": "Momentum μ", "symbol": "μ", "kind": "number", "min": 0, "max": 1, "maxExclusive": true, "default": 0.1, "description": "How much of the previous step carries over; the gradient is taken at the look-ahead point." }
+      ]
+    },
+    {
+      "id": "newton",
+      "label": "Newton's method",
+      "params": []
+    },
+    {
+      "id": "adam",
+      "label": "Adam",
+      "params": [
+        { "name": "learning_rate", "label": "Learning rate η", "symbol": "η", "kind": "number", "min": 0, "minExclusive": true, "default": 0.1, "description": "The largest step size, roughly." },
+        { "name": "beta1", "label": "Decay β₁", "symbol": "β₁", "kind": "number", "min": 0, "max": 1, "maxExclusive": true, "default": 0.9, "description": "Decay rate of the moving average of gradients (first moment)." },
+        { "name": "beta2", "label": "Decay β₂", "symbol": "β₂", "kind": "number", "min": 0, "max": 1, "maxExclusive": true, "default": 0.999, "description": "Decay rate of the moving average of squared gradients (second moment)." },
+        { "name": "epsilon", "label": "Epsilon ε", "symbol": "ε", "kind": "number", "min": 0, "minExclusive": true, "default": 1e-8, "description": "Added to the denominator to avoid dividing by zero." }
+      ]
+    },
+    {
+      "id": "adagrad",
+      "label": "Adagrad",
+      "params": [
+        { "name": "learning_rate", "label": "Learning rate η", "symbol": "η", "kind": "number", "min": 0, "minExclusive": true, "default": 0.1, "description": "Divided by the root of the summed squared gradients." },
+        { "name": "epsilon", "label": "Epsilon ε", "symbol": "ε", "kind": "number", "min": 0, "minExclusive": true, "default": 1e-8, "description": "Added to the denominator to avoid dividing by zero." }
+      ]
+    },
+    {
+      "id": "rmsprop",
+      "label": "RMSProp",
+      "params": [
+        { "name": "learning_rate", "label": "Learning rate η", "symbol": "η", "kind": "number", "min": 0, "minExclusive": true, "default": 0.1, "description": "Divided by the root of the moving average of squared gradients." },
+        { "name": "beta", "label": "Decay β", "symbol": "β", "kind": "number", "min": 0, "max": 1, "maxExclusive": true, "default": 0.9, "description": "Decay rate of the moving average of squared gradients." },
+        { "name": "epsilon", "label": "Epsilon ε", "symbol": "ε", "kind": "number", "min": 0, "minExclusive": true, "default": 1e-8, "description": "Added to the denominator to avoid dividing by zero." }
+      ]
+    },
+    {
+      "id": "adadelta",
+      "label": "Adadelta",
+      "params": [
+        { "name": "beta", "label": "Decay β", "symbol": "β", "kind": "number", "min": 0, "max": 1, "maxExclusive": true, "default": 0.9, "description": "Decay rate of the moving averages of squared gradients and squared updates." },
+        { "name": "epsilon", "label": "Epsilon ε", "symbol": "ε", "kind": "number", "min": 0, "minExclusive": true, "default": 0.001, "description": "Sets the first step size, and avoids dividing by zero." }
+      ]
+    }
+  ]
+}

backend/src/algorithms.json

@@ -0,0 +1,60 @@
+{
+  "algorithms": [
+    {
+      "id": "gradient_descent",
+      "label": "Gradient descent",
+      "params": [
+        { "name": "learning_rate", "label": "Learning rate η", "symbol": "η", "kind": "number", "min": 0, "minExclusive": true, "default": 0.1, "description": "How far each step moves along the negative gradient." },
+        { "name": "momentum", "label": "Momentum μ", "symbol": "μ", "kind": "number", "min": 0, "max": 1, "maxExclusive": true, "default": 0.0, "description": "How much of the previous step carries over into the next one." }
+      ]
+    },
+    {
+      "id": "nesterov",
+      "label": "Nesterov momentum",
+      "params": [
+        { "name": "learning_rate", "label": "Learning rate η", "symbol": "η", "kind": "number", "min": 0, "minExclusive": true, "default": 0.1, "description": "How far each step moves along the negative gradient." },
+        { "name": "momentum", "label": "Momentum μ", "symbol": "μ", "kind": "number", "min": 0, "max": 1, "maxExclusive": true, "default": 0.1, "description": "How much of the previous step carries over; the gradient is taken at the look-ahead point." }
+      ]
+    },
+    {
+      "id": "newton",
+      "label": "Newton's method",
+      "params": []
+    },
+    {
+      "id": "adam",
+      "label": "Adam",
+      "params": [
+        { "name": "learning_rate", "label": "Learning rate η", "symbol": "η", "kind": "number", "min": 0, "minExclusive": true, "default": 0.1, "description": "The largest step size, roughly." },
+        { "name": "beta1", "label": "Decay β₁", "symbol": "β₁", "kind": "number", "min": 0, "max": 1, "maxExclusive": true, "default": 0.9, "description": "Decay rate of the moving average of gradients (first moment)." },
+        { "name": "beta2", "label": "Decay β₂", "symbol": "β₂", "kind": "number", "min": 0, "max": 1, "maxExclusive": true, "default": 0.999, "description": "Decay rate of the moving average of squared gradients (second moment)." },
+        { "name": "epsilon", "label": "Epsilon ε", "symbol": "ε", "kind": "number", "min": 0, "minExclusive": true, "default": 1e-8, "description": "Added to the denominator to avoid dividing by zero." }
+      ]
+    },
+    {
+      "id": "adagrad",
+      "label": "Adagrad",
+      "params": [
+        { "name": "learning_rate", "label": "Learning rate η", "symbol": "η", "kind": "number", "min": 0, "minExclusive": true, "default": 0.1, "description": "Divided by the root of the summed squared gradients." },
+        { "name": "epsilon", "label": "Epsilon ε", "symbol": "ε", "kind": "number", "min": 0, "minExclusive": true, "default": 1e-8, "description": "Added to the denominator to avoid dividing by zero." }
+      ]
+    },
+    {
+      "id": "rmsprop",
+      "label": "RMSProp",
+      "params": [
+        { "name": "learning_rate", "label": "Learning rate η", "symbol": "η", "kind": "number", "min": 0, "minExclusive": true, "default": 0.1, "description": "Divided by the root of the moving average of squared gradients." },
+        { "name": "beta", "label": "Decay β", "symbol": "β", "kind": "number", "min": 0, "max": 1, "maxExclusive": true, "default": 0.9, "description": "Decay rate of the moving average of squared gradients." },
+        { "name": "epsilon", "label": "Epsilon ε", "symbol": "ε", "kind": "number", "min": 0, "minExclusive": true, "default": 1e-8, "description": "Added to the denominator to avoid dividing by zero." }
+      ]
+    },
+    {
+      "id": "adadelta",
+      "label": "Adadelta",
+      "params": [
+        { "name": "beta", "label": "Decay β", "symbol": "β", "kind": "number", "min": 0, "max": 1, "maxExclusive": true, "default": 0.9, "description": "Decay rate of the moving averages of squared gradients and squared updates." },
+        { "name": "epsilon", "label": "Epsilon ε", "symbol": "ε", "kind": "number", "min": 0, "minExclusive": true, "default": 0.001, "description": "Sets the first step size, and avoids dividing by zero." }
+      ]
+    }
+  ]
+}

backend/src/logic.py

@@ -0,0 +1,231 @@
+"""Objective functions and optimisers, in one or two variables.
+
+Positions, gradients and Hessians are NumPy arrays of length 1 or 2, so each
+optimiser is written once for both.
+"""
+
+import numpy as np
+from sympy import Abs, Expr, acos, asin, atan, cos, exp, lambdify, log, pi, sin, sqrt, symbols, tan
+from sympy.parsing.sympy_parser import (
+    convert_xor,
+    implicit_multiplication_application,
+    parse_expr,
+    standard_transformations,
+)
+
+# Real, so that e.g. d/dx |x| is sign(x)
+VARIABLES = symbols("x y", real=True)
+
+ALLOWED_NAMES = {
+    "sin": sin, "cos": cos, "tan": tan, "asin": asin, "acos": acos, "atan": atan,
+    "log": log, "ln": log, "sqrt": sqrt, "abs": Abs, "exp": exp,
+    "e": exp(1), "pi": pi, "π": pi,
+}
+
+
+def parse_function(expression: str, n_variables: int) -> Expr:
+    """Parse e.g. "x^2 + 3y^2"; raises ValueError with a message for students."""
+    if not expression.strip():
+        raise ValueError("Enter a function.")
+    variables = VARIABLES[:n_variables]
+    names = {str(v): v for v in VARIABLES} | ALLOWED_NAMES
+    try:
+        expr = parse_expr(
+            expression,
+            local_dict=names,
+            transformations=standard_transformations + (implicit_multiplication_application, convert_xor),
+        )
+    except Exception:
+        raise ValueError("This isn't a function sympy can read. Check the brackets and operators.")
+    if not isinstance(expr, Expr):
+        raise ValueError("This isn't a function sympy can read. Check the brackets and operators.")
+    unknown = expr.free_symbols - set(variables)
+    if unknown:
+        allowed = " and ".join(str(v) for v in variables)
+        raise ValueError(f"Unknown name {', '.join(sorted(map(str, unknown)))}: use only {allowed}.")
+    return expr
+
+
+class Objective:
+    """f with its gradient and Hessian, evaluated at a point or on a grid."""
+
+    def __init__(self, expr: Expr, n_variables: int):
+        variables = VARIABLES[:n_variables]
+        self.n = n_variables
+        self._f = lambdify(variables, expr, modules="numpy")
+        self._gradient = [lambdify(variables, expr.diff(v), modules="numpy") for v in variables]
+        self._hessian = [[lambdify(variables, expr.diff(a, b), modules="numpy") for b in variables] for a in variables]
+
+    def value(self, p: np.ndarray) -> float:
+        return float(self._f(*p))
+
+    def gradient(self, p: np.ndarray) -> np.ndarray:
+        return np.array([float(g(*p)) for g in self._gradient])
+
+    def hessian(self, p: np.ndarray) -> np.ndarray:
+        return np.array([[float(h(*p)) for h in row] for row in self._hessian])
+
+    def values_on(self, *grid: np.ndarray) -> np.ndarray:
+        # Constant expressions give a scalar; spread it over the grid
+        return np.broadcast_to(np.asarray(self._f(*grid), dtype=float), grid[0].shape)
+
+    def gradient_on(self, *grid: np.ndarray) -> list[np.ndarray]:
+        return [np.broadcast_to(np.asarray(g(*grid), dtype=float), grid[0].shape) for g in self._gradient]
+
+
+class SingularHessian(Exception):
+    pass
+
+
+# Each optimiser keeps its own state between steps; step(p) returns the next position.
+
+class GradientDescent:
+    """Heavy-ball momentum: v ← μv − η∇f(x), x ← x + v."""
+
+    def __init__(self, objective: Objective, learning_rate: float, momentum: float):
+        self.f, self.lr, self.momentum = objective, learning_rate, momentum
+        self.v = 0.0
+
+    def step(self, p: np.ndarray) -> np.ndarray:
+        self.v = self.momentum * self.v - self.lr * self.f.gradient(p)
+        return p + self.v
+
+
+class Nesterov:
+    """Gradient taken at the look-ahead point x + μv."""
+
+    def __init__(self, objective: Objective, learning_rate: float, momentum: float):
+        self.f, self.lr, self.momentum = objective, learning_rate, momentum
+        self.v = 0.0
+
+    def step(self, p: np.ndarray) -> np.ndarray:
+        self.v = self.momentum * self.v - self.lr * self.f.gradient(p + self.momentum * self.v)
+        return p + self.v
+
+
+class Newton:
+    """x ← x − H⁻¹∇f(x)."""
+
+    def __init__(self, objective: Objective):
+        self.f = objective
+
+    def step(self, p: np.ndarray) -> np.ndarray:
+        h, g = self.f.hessian(p), self.f.gradient(p)
+        try:
+            delta = np.linalg.solve(h, g)
+        except np.linalg.LinAlgError:
+            raise SingularHessian()
+        # Pyodide's NumPy can't see floating-point errors, so solve returns inf or nan instead of raising
+        if np.all(np.isfinite(h)) and np.all(np.isfinite(g)) and not np.all(np.isfinite(delta)):
+            raise SingularHessian()
+        return p - delta
+
+
+class Adagrad:
+    def __init__(self, objective: Objective, learning_rate: float, epsilon: float):
+        self.f, self.lr, self.eps = objective, learning_rate, epsilon
+        self.v = 0.0  # sum of squared gradients
+
+    def step(self, p: np.ndarray) -> np.ndarray:
+        g = self.f.gradient(p)
+        self.v = self.v + g**2
+        return p - self.lr / np.sqrt(self.v + self.eps) * g
+
+
+class RMSProp:
+    def __init__(self, objective: Objective, learning_rate: float, beta: float, epsilon: float):
+        self.f, self.lr, self.beta, self.eps = objective, learning_rate, beta, epsilon
+        self.v = 0.0  # moving average of squared gradients
+
+    def step(self, p: np.ndarray) -> np.ndarray:
+        g = self.f.gradient(p)
+        self.v = self.beta * self.v + (1 - self.beta) * g**2
+        return p - self.lr / np.sqrt(self.v + self.eps) * g
+
+
+class Adadelta:
+    def __init__(self, objective: Objective, beta: float, epsilon: float):
+        self.f, self.beta, self.eps = objective, beta, epsilon
+        self.v = 0.0  # moving average of squared gradients
+        self.s = 0.0  # moving average of squared updates
+
+    def step(self, p: np.ndarray) -> np.ndarray:
+        g = self.f.gradient(p)
+        self.v = self.beta * self.v + (1 - self.beta) * g**2
+        delta = -np.sqrt(self.s + self.eps) / np.sqrt(self.v + self.eps) * g
+        self.s = self.beta * self.s + (1 - self.beta) * delta**2
+        return p + delta
+
+
+class Adam:
+    def __init__(self, objective: Objective, learning_rate: float, beta1: float, beta2: float, epsilon: float):
+        self.f, self.lr, self.beta1, self.beta2, self.eps = objective, learning_rate, beta1, beta2, epsilon
+        self.m = 0.0  # first moment
+        self.v = 0.0  # second moment
+        self.t = 0
+
+    def step(self, p: np.ndarray) -> np.ndarray:
+        g = self.f.gradient(p)
+        self.t += 1
+        self.m = self.beta1 * self.m + (1 - self.beta1) * g
+        self.v = self.beta2 * self.v + (1 - self.beta2) * g**2
+        m_hat = self.m / (1 - self.beta1**self.t)
+        v_hat = self.v / (1 - self.beta2**self.t)
+        return p - self.lr / (np.sqrt(v_hat) + self.eps) * m_hat
+
+
+# Ids match backend/src/algorithms.json
+OPTIMISERS = {
+    "gradient_descent": GradientDescent,
+    "nesterov": Nesterov,
+    "newton": Newton,
+    "adam": Adam,
+    "adagrad": Adagrad,
+    "rmsprop": RMSProp,
+    "adadelta": Adadelta,
+}
+
+# A run that gets further than this from the origin has diverged
+DIVERGENCE_LIMIT = 1e6
+
+DIVERGED = "The next point has no finite value or is beyond 1,000,000: the run diverged or left the function's domain."
+SINGULAR = "The Hessian is singular here, so Newton's method can't take a step."
+
+
+class Run:
+    """One optimiser's trajectory, computed as far as it has been asked for."""
+
+    def __init__(self, objective: Objective, optimiser, start: np.ndarray):
+        self.f = objective
+        self.optimiser = optimiser
+        self.points = [self._describe(start)]
+        self.position = start
+        # Why the run ended, once it has
+        self.stopped: str | None = None
+
+    def point(self, k: int) -> dict | None:
+        """The point after k iterations, or None if the run stopped before then."""
+        with np.errstate(all="ignore"):
+            while len(self.points) <= k and self.stopped is None:
+                self._advance()
+        return self.points[k] if k < len(self.points) else None
+
+    def _advance(self) -> None:
+        try:
+            p = self.optimiser.step(self.position)
+        except SingularHessian:
+            self.stopped = SINGULAR
+            return
+        if not np.all(np.abs(p) <= DIVERGENCE_LIMIT) or not np.isfinite(self.f.value(p)):
+            self.stopped = DIVERGED
+            return
+        self.position = p
+        self.points.append(self._describe(p))
+
+    def _describe(self, p: np.ndarray) -> dict:
+        return {
+            "position": p.tolist(),
+            "value": self.f.value(p),
+            "gradient": self.f.gradient(p).tolist(),
+            "hessian": self.f.hessian(p).tolist(),
+        }

backend/src/manager 2.py

@@ -0,0 +1,118 @@
+import json
+from pathlib import Path
+
+import numpy as np
+
+from logic import OPTIMISERS, Objective, Run, parse_function
+
+ALGORITHMS = {
+    spec["id"]: spec
+    for spec in json.loads((Path(__file__).parent / "algorithms.json").read_text())["algorithms"]
+}
+
+# Iterations a run can take before stepping stops
+MAX_ITERATIONS = 1000
+# Sample points for the plotted curve (one variable) or surface (two, per side)
+CURVE_POINTS = 401
+GRID_POINTS = 101
+# Gradient arrows per side
+ARROW_POINTS = 15
+
+
+class UserError(Exception):
+    """A mistake the student can fix; its message is shown in the UI."""
+
+
+def _json_values(values: np.ndarray) -> list:
+    """Values as JSON numbers, with null where f has no finite value."""
+    return [float(v) if np.isfinite(v) else None for v in values]
+
+
+class Manager:
+    def __init__(self):
+        self._objective: Objective | None = None
+        self._runs: list[Run] = []
+
+    def handle_set_function(self, args: dict) -> None:
+        """{variables: 1 | 2, expression}; clears the runs."""
+        self._objective = None
+        self._runs = []
+        n = int(args["variables"])
+        try:
+            expr = parse_function(str(args["expression"]), n)
+        except ValueError as e:
+            raise UserError(str(e))
+        try:
+            self._objective = Objective(expr, n)
+        except Exception:
+            raise UserError("This function can't be differentiated here. Try writing it another way.")
+
+    def handle_function_values(self, args: dict) -> dict | None:
+        """f sampled over the plot's {x_range, y_range}; None with no function."""
+        f = self._objective
+        if f is None:
+            return None
+        with np.errstate(all="ignore"):
+            if f.n == 1:
+                x = np.linspace(*args["x_range"], CURVE_POINTS)
+                return {"x": x.tolist(), "f": _json_values(f.values_on(x))}
+
+            x = np.linspace(*args["x_range"], GRID_POINTS)
+            y = np.linspace(*args["y_range"], GRID_POINTS)
+            z = f.values_on(*np.meshgrid(x, y))
+            ax, ay = np.meshgrid(np.linspace(*args["x_range"], ARROW_POINTS), np.linspace(*args["y_range"], ARROW_POINTS))
+            u, v = f.gradient_on(ax, ay)
+            return {
+                "x": x.tolist(),
+                "y": y.tolist(),
+                # Rows follow y, columns follow x
+                "f": [_json_values(row) for row in z],
+                "arrows": {
+                    "x": ax.ravel().tolist(),
+                    "y": ay.ravel().tolist(),
+                    "u": _json_values(u.ravel()),
+                    "v": _json_values(v.ravel()),
+                },
+            }
+
+    def handle_set_runs(self, args: dict) -> None:
+        """{runs: [{algorithm, start, params}]}: the optimisers to step together."""
+        self._runs = []
+        f = self._objective
+        if f is None:
+            raise ValueError("Function not set")
+        runs = []
+        for run in args["runs"]:
+            spec = ALGORITHMS[run["algorithm"]]
+            given = dict(run.get("params", {}))
+            params = {p["name"]: float(given.get(p["name"], p["default"])) for p in spec["params"]}
+            start = np.array(run["start"], dtype=float)
+            if start.shape != (f.n,):
+                raise ValueError(f"Start point needs {f.n} coordinates, got {start.tolist()}")
+            with np.errstate(all="ignore"):
+                if not np.isfinite(f.value(start)):
+                    point = ", ".join(f"{c:g}" for c in start)
+                    raise UserError(f"The function has no finite value at the initial point ({point}).")
+            runs.append(Run(f, OPTIMISERS[spec["id"]](f, **params), start))
+        self._runs = runs
+
+    def handle_state(self, args: dict) -> dict | None:
+        """Every run after {iteration} iterations; None once all have stopped.
+
+        "stopped" says why a run ended, at its last point and after it (where
+        point is None). It is None while the run carries on.
+        """
+        k = int(args["iteration"])
+        if not self._runs or k > MAX_ITERATIONS:
+            return None
+        points = [run.point(k) for run in self._runs]
+        if all(p is None for p in points):
+            return None
+        # Look one iteration ahead to know whether this is a run's last point
+        ended = [p is None or run.point(k + 1) is None for run, p in zip(self._runs, points)]
+        return {
+            "runs": [
+                {"point": p, "stopped": run.stopped if end else None}
+                for run, p, end in zip(self._runs, points, ended)
+            ]
+        }

backend/src/manager.py

@@ -0,0 +1,118 @@
+import json
+from pathlib import Path
+
+import numpy as np
+
+from logic import OPTIMISERS, Objective, Run, parse_function
+
+ALGORITHMS = {
+    spec["id"]: spec
+    for spec in json.loads((Path(__file__).parent / "algorithms.json").read_text())["algorithms"]
+}
+
+# Iterations a run can take before stepping stops
+MAX_ITERATIONS = 1000
+# Sample points for the plotted curve (one variable) or surface (two, per side)
+CURVE_POINTS = 401
+GRID_POINTS = 101
+# Gradient arrows per side
+ARROW_POINTS = 15
+
+
+class UserError(Exception):
+    """A mistake the student can fix; its message is shown in the UI."""
+
+
+def _json_values(values: np.ndarray) -> list:
+    """Values as JSON numbers, with null where f has no finite value."""
+    return [float(v) if np.isfinite(v) else None for v in values]
+
+
+class Manager:
+    def __init__(self):
+        self._objective: Objective | None = None
+        self._runs: list[Run] = []
+
+    def handle_set_function(self, args: dict) -> None:
+        """{variables: 1 | 2, expression}; clears the runs."""
+        self._objective = None
+        self._runs = []
+        n = int(args["variables"])
+        try:
+            expr = parse_function(str(args["expression"]), n)
+        except ValueError as e:
+            raise UserError(str(e))
+        try:
+            self._objective = Objective(expr, n)
+        except Exception:
+            raise UserError("This function can't be differentiated here. Try writing it another way.")
+
+    def handle_function_values(self, args: dict) -> dict | None:
+        """f sampled over the plot's {x_range, y_range}; None with no function."""
+        f = self._objective
+        if f is None:
+            return None
+        with np.errstate(all="ignore"):
+            if f.n == 1:
+                x = np.linspace(*args["x_range"], CURVE_POINTS)
+                return {"x": x.tolist(), "f": _json_values(f.values_on(x))}
+
+            x = np.linspace(*args["x_range"], GRID_POINTS)
+            y = np.linspace(*args["y_range"], GRID_POINTS)
+            z = f.values_on(*np.meshgrid(x, y))
+            ax, ay = np.meshgrid(np.linspace(*args["x_range"], ARROW_POINTS), np.linspace(*args["y_range"], ARROW_POINTS))
+            u, v = f.gradient_on(ax, ay)
+            return {
+                "x": x.tolist(),
+                "y": y.tolist(),
+                # Rows follow y, columns follow x
+                "f": [_json_values(row) for row in z],
+                "arrows": {
+                    "x": ax.ravel().tolist(),
+                    "y": ay.ravel().tolist(),
+                    "u": _json_values(u.ravel()),
+                    "v": _json_values(v.ravel()),
+                },
+            }
+
+    def handle_set_runs(self, args: dict) -> None:
+        """{runs: [{algorithm, start, params}]}: the optimisers to step together."""
+        self._runs = []
+        f = self._objective
+        if f is None:
+            raise ValueError("Function not set")
+        runs = []
+        for run in args["runs"]:
+            spec = ALGORITHMS[run["algorithm"]]
+            given = dict(run.get("params", {}))
+            params = {p["name"]: float(given.get(p["name"], p["default"])) for p in spec["params"]}
+            start = np.array(run["start"], dtype=float)
+            if start.shape != (f.n,):
+                raise ValueError(f"Start point needs {f.n} coordinates, got {start.tolist()}")
+            with np.errstate(all="ignore"):
+                if not np.isfinite(f.value(start)):
+                    point = ", ".join(f"{c:g}" for c in start)
+                    raise UserError(f"The function has no finite value at the initial point ({point}).")
+            runs.append(Run(f, OPTIMISERS[spec["id"]](f, **params), start))
+        self._runs = runs
+
+    def handle_state(self, args: dict) -> dict | None:
+        """Every run after {iteration} iterations; None once all have stopped.
+
+        "stopped" says why a run ended, at its last point and after it (where
+        point is None). It is None while the run carries on.
+        """
+        k = int(args["iteration"])
+        if not self._runs or k > MAX_ITERATIONS:
+            return None
+        points = [run.point(k) for run in self._runs]
+        if all(p is None for p in points):
+            return None
+        # Look one iteration ahead to know whether this is a run's last point
+        ended = [p is None or run.point(k + 1) is None for run, p in zip(self._runs, points)]
+        return {
+            "runs": [
+                {"point": p, "stopped": run.stopped if end else None}
+                for run, p, end in zip(self._runs, points, ended)
+            ]
+        }

backend/tests/test_contract.py

@@ -0,0 +1,53 @@
+"""Replay each contract example in ../contract against a fresh Manager.
+
+Each example lists calls in order, keyed by method name. A call has "args"
+(omitted for methods that take none) and either "result" (the expected return
+value as JSON; floats are compared to 6 significant figures) or "error" (a
+UserError of "kind": "user", whose text contains "message" if given). This
+mirrors what @elvis/pyodide's worker sends to the UI.
+"""
+
+import json
+from pathlib import Path
+
+import pytest
+
+from manager import Manager
+
+CONTRACT_DIR = Path(__file__).parent.parent / "contract"
+EXAMPLES = sorted(CONTRACT_DIR.glob("*.json"))
+
+
+def same(actual, expected) -> bool:
+    """Equal JSON values, with floats compared approximately."""
+    if isinstance(expected, float) or isinstance(actual, float):
+        return isinstance(actual, (int, float)) and actual == pytest.approx(expected, rel=1e-6, abs=1e-12)
+    if isinstance(expected, dict):
+        return isinstance(actual, dict) and actual.keys() == expected.keys() and all(same(actual[k], expected[k]) for k in expected)
+    if isinstance(expected, list):
+        return isinstance(actual, list) and len(actual) == len(expected) and all(same(a, e) for a, e in zip(actual, expected))
+    return actual == expected
+
+
+@pytest.mark.parametrize("path", EXAMPLES, ids=[p.stem for p in EXAMPLES])
+def test_contract_example(path: Path) -> None:
+    example = json.loads(path.read_text())
+    manager = Manager()
+
+    for method, call in example["calls"].items():
+        fn = getattr(manager, method)
+        try:
+            data = fn(call["args"]) if "args" in call else fn()
+        except Exception as e:
+            # The worker treats only UserError as a user error; anything else is a bug
+            if type(e).__name__ != "UserError":
+                raise
+            assert "error" in call, f"{method} raised UserError: {e}"
+            assert call["error"]["kind"] == "user"
+            assert call["error"].get("message", "") in str(e)
+            continue
+
+        assert "error" not in call, f"{method} returned {data!r} instead of raising UserError"
+        # Results must be plain JSON values (no NumPy types) to reach the UI unchanged
+        actual = json.loads(json.dumps(data))
+        assert same(actual, call["result"]), f"{method} returned {actual!r}"

backend/tests/test_logic 2.py

@@ -0,0 +1,175 @@
+import inspect
+import json
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from logic import DIVERGED, OPTIMISERS, SINGULAR, Objective, Run, parse_function
+from manager import MAX_ITERATIONS, Manager, UserError
+
+SPEC = json.loads((Path(__file__).parent.parent / "src" / "algorithms.json").read_text())["algorithms"]
+DEFAULTS = {spec["id"]: {p["name"]: p["default"] for p in spec["params"]} for spec in SPEC}
+
+
+def run(expression: str, algorithm: str, start: list[float], **params) -> Run:
+    f = Objective(parse_function(expression, len(start)), len(start))
+    return Run(f, OPTIMISERS[algorithm](f, **(DEFAULTS[algorithm] | params)), np.array(start, dtype=float))
+
+
+def test_spec_matches_optimisers():
+    assert [spec["id"] for spec in SPEC] == list(OPTIMISERS)
+    for spec in SPEC:
+        names = list(inspect.signature(OPTIMISERS[spec["id"]]).parameters)[1:]
+        assert names == [p["name"] for p in spec["params"]], spec["id"]
+
+
+@pytest.mark.parametrize("expression, n, expected", [
+    ("x^2 - 0.1cos(20x)", 1, 0.81 - 0.1 * np.cos(18)),
+    ("2x y + e", 2, 2 * 0.9 * -0.5 + np.e),
+    ("sqrt(abs(x)) + ln(exp(y))", 2, np.sqrt(0.9) - 0.5),
+])
+def test_parse_function(expression, n, expected):
+    f = Objective(parse_function(expression, n), n)
+    point = np.array([0.9, -0.5][:n])
+    assert f.value(point) == pytest.approx(expected)
+
+
+@pytest.mark.parametrize("expression, message", [
+    ("", "Enter a function"),
+    ("x^2 + (", "can read"),
+    ("x + z", "Unknown name z"),
+])
+def test_parse_function_errors(expression, message):
+    with pytest.raises(ValueError, match=message):
+        parse_function(expression, 2)
+
+
+def test_gradient_and_hessian():
+    f = Objective(parse_function("x^2 y + y^3", 2), 2)
+    p = np.array([1.0, 2.0])
+    assert f.gradient(p).tolist() == [4.0, 13.0]
+    assert f.hessian(p).tolist() == [[4.0, 2.0], [2.0, 12.0]]
+
+
+def test_gradient_descent_on_a_quadratic():
+    # x_k = (1 - 2η)^k x_0
+    r = run("x^2", "gradient_descent", [1.0], learning_rate=0.1)
+    assert r.point(10)["position"][0] == pytest.approx(0.8**10)
+
+
+def test_momentum_overshoots_and_nesterov_damps_it():
+    plain = run("x^2", "gradient_descent", [1.0], learning_rate=0.1, momentum=0.9)
+    nesterov = run("x^2", "nesterov", [1.0], learning_rate=0.1, momentum=0.9)
+    assert min(plain.point(k)["position"][0] for k in range(20)) < -0.5
+    assert abs(nesterov.point(20)["position"][0]) < abs(plain.point(20)["position"][0])
+
+
+def test_newton_solves_a_quadratic_in_one_step():
+    r = run("(x - 1)^2 + 3(y + 2)^2 + x y", "newton", [5.0, 5.0])
+    assert r.point(1)["gradient"] == pytest.approx([0, 0], abs=1e-12)
+
+
+@pytest.mark.parametrize("algorithm", [spec["id"] for spec in SPEC])
+def test_every_optimiser_goes_downhill_on_a_bowl(algorithm):
+    r = run("x^2 + 3y^2", algorithm, [0.8, -0.6])
+    assert r.point(50)["value"] < r.point(0)["value"]
+
+
+def test_divergence_stops_the_run():
+    r = run("x^2", "gradient_descent", [1.0], learning_rate=1.5)
+    # |x| doubles each step, so it passes 1e6 after 20 steps
+    assert r.point(20) is None and r.point(19) is not None
+    assert r.stopped == DIVERGED
+
+
+def test_leaving_the_domain_stops_the_run():
+    r = run("sqrt(x)", "gradient_descent", [0.5], learning_rate=1.0)
+    assert r.point(3) is None
+    assert r.stopped == DIVERGED
+
+
+def test_singular_hessian_stops_newton():
+    r = run("x^3", "newton", [0.0])
+    assert r.point(1) is None
+    assert r.stopped == SINGULAR
+
+
+def test_singular_hessian_stops_newton_in_pyodide(monkeypatch):
+    # Pyodide's solve returns inf rather than raising LinAlgError
+    monkeypatch.setattr(np.linalg, "solve", lambda a, b: np.full_like(b, np.inf))
+    r = run("x^2 + 0y", "newton", [1.0, 1.0])
+    assert r.point(1) is None
+    assert r.stopped == SINGULAR
+
+
+def test_points_are_cached_and_asked_for_in_any_order():
+    r = run("x^2 + y^2", "adam", [1.0, 1.0])
+    late = r.point(30)
+    assert r.point(3) == r.points[3]
+    assert r.point(30) == late
+
+
+def manager_with(expression: str, *runs: dict) -> Manager:
+    m = Manager()
+    m.handle_set_function({"variables": len(runs[0]["start"]), "expression": expression})
+    m.handle_set_runs({"runs": list(runs)})
+    return m
+
+
+def test_state_past_the_last_iteration():
+    m = manager_with("x^2", {"algorithm": "gradient_descent", "start": [1.0], "params": {}})
+    assert m.handle_state({"iteration": MAX_ITERATIONS}) is not None
+    assert m.handle_state({"iteration": MAX_ITERATIONS + 1}) is None
+
+
+def test_state_ends_when_every_run_has_stopped():
+    m = manager_with(
+        "x^3 + x^2",
+        {"algorithm": "gradient_descent", "start": [1.0], "params": {"learning_rate": 1.5}},
+        {"algorithm": "newton", "start": [-1/3], "params": {}},  # f'' = 0 here
+    )
+    states = [m.handle_state({"iteration": k}) for k in range(MAX_ITERATIONS)]
+    end = states.index(None)
+    assert 1 < end and all(s is None for s in states[end:])
+    # Newton stops first and says why while gradient descent carries on
+    assert states[1]["runs"][1] == {"point": None, "stopped": SINGULAR}
+    assert states[1]["runs"][0]["point"] is not None
+    # Each run says why at its last point
+    assert states[0]["runs"][1]["stopped"] == SINGULAR
+    assert states[end - 2]["runs"][0]["stopped"] is None
+    assert states[end - 1]["runs"][0]["stopped"] == DIVERGED
+
+
+def test_start_point_outside_the_domain():
+    m = Manager()
+    m.handle_set_function({"variables": 1, "expression": "log(x)"})
+    with pytest.raises(UserError, match="no finite value at the initial point"):
+        m.handle_set_runs({"runs": [{"algorithm": "adam", "start": [-1.0], "params": {}}]})
+
+
+def test_failed_runs_replace_the_old_ones():
+    m = manager_with("log(x)", {"algorithm": "adam", "start": [1.0], "params": {}})
+    with pytest.raises(UserError):
+        m.handle_set_runs({"runs": [{"algorithm": "adam", "start": [-1.0], "params": {}}]})
+    assert m.handle_state({"iteration": 0}) is None
+
+
+def test_function_values_one_variable():
+    m = Manager()
+    m.handle_set_function({"variables": 1, "expression": "log(x)"})
+    values = m.handle_function_values({"x_range": [-1, 1], "y_range": [0, 1]})
+    assert len(values["x"]) == len(values["f"])
+    assert values["f"][0] is None and values["f"][-1] == 0.0
+
+
+def test_function_values_two_variables():
+    m = Manager()
+    m.handle_set_function({"variables": 2, "expression": "x + 2y"})
+    values = m.handle_function_values({"x_range": [0, 1], "y_range": [0, 2]})
+    assert values["f"][-1][0] == 4.0  # rows follow y
+    assert set(values["arrows"]["u"]) == {1.0} and set(values["arrows"]["v"]) == {2.0}
+
+
+def test_no_function_values_without_a_function():
+    assert Manager().handle_function_values({"x_range": [0, 1], "y_range": [0, 1]}) is None

backend/tests/test_logic.py

@@ -0,0 +1,175 @@
+import inspect
+import json
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from logic import DIVERGED, OPTIMISERS, SINGULAR, Objective, Run, parse_function
+from manager import MAX_ITERATIONS, Manager, UserError
+
+SPEC = json.loads((Path(__file__).parent.parent / "src" / "algorithms.json").read_text())["algorithms"]
+DEFAULTS = {spec["id"]: {p["name"]: p["default"] for p in spec["params"]} for spec in SPEC}
+
+
+def run(expression: str, algorithm: str, start: list[float], **params) -> Run:
+    f = Objective(parse_function(expression, len(start)), len(start))
+    return Run(f, OPTIMISERS[algorithm](f, **(DEFAULTS[algorithm] | params)), np.array(start, dtype=float))
+
+
+def test_spec_matches_optimisers():
+    assert [spec["id"] for spec in SPEC] == list(OPTIMISERS)
+    for spec in SPEC:
+        names = list(inspect.signature(OPTIMISERS[spec["id"]]).parameters)[1:]
+        assert names == [p["name"] for p in spec["params"]], spec["id"]
+
+
+@pytest.mark.parametrize("expression, n, expected", [
+    ("x^2 - 0.1cos(20x)", 1, 0.81 - 0.1 * np.cos(18)),
+    ("2x y + e", 2, 2 * 0.9 * -0.5 + np.e),
+    ("sqrt(abs(x)) + ln(exp(y))", 2, np.sqrt(0.9) - 0.5),
+])
+def test_parse_function(expression, n, expected):
+    f = Objective(parse_function(expression, n), n)
+    point = np.array([0.9, -0.5][:n])
+    assert f.value(point) == pytest.approx(expected)
+
+
+@pytest.mark.parametrize("expression, message", [
+    ("", "Enter a function"),
+    ("x^2 + (", "can read"),
+    ("x + z", "Unknown name z"),
+])
+def test_parse_function_errors(expression, message):
+    with pytest.raises(ValueError, match=message):
+        parse_function(expression, 2)
+
+
+def test_gradient_and_hessian():
+    f = Objective(parse_function("x^2 y + y^3", 2), 2)
+    p = np.array([1.0, 2.0])
+    assert f.gradient(p).tolist() == [4.0, 13.0]
+    assert f.hessian(p).tolist() == [[4.0, 2.0], [2.0, 12.0]]
+
+
+def test_gradient_descent_on_a_quadratic():
+    # x_k = (1 - 2η)^k x_0
+    r = run("x^2", "gradient_descent", [1.0], learning_rate=0.1)
+    assert r.point(10)["position"][0] == pytest.approx(0.8**10)
+
+
+def test_momentum_overshoots_and_nesterov_damps_it():
+    plain = run("x^2", "gradient_descent", [1.0], learning_rate=0.1, momentum=0.9)
+    nesterov = run("x^2", "nesterov", [1.0], learning_rate=0.1, momentum=0.9)
+    assert min(plain.point(k)["position"][0] for k in range(20)) < -0.5
+    assert abs(nesterov.point(20)["position"][0]) < abs(plain.point(20)["position"][0])
+
+
+def test_newton_solves_a_quadratic_in_one_step():
+    r = run("(x - 1)^2 + 3(y + 2)^2 + x y", "newton", [5.0, 5.0])
+    assert r.point(1)["gradient"] == pytest.approx([0, 0], abs=1e-12)
+
+
+@pytest.mark.parametrize("algorithm", [spec["id"] for spec in SPEC])
+def test_every_optimiser_goes_downhill_on_a_bowl(algorithm):
+    r = run("x^2 + 3y^2", algorithm, [0.8, -0.6])
+    assert r.point(50)["value"] < r.point(0)["value"]
+
+
+def test_divergence_stops_the_run():
+    r = run("x^2", "gradient_descent", [1.0], learning_rate=1.5)
+    # |x| doubles each step, so it passes 1e6 after 20 steps
+    assert r.point(20) is None and r.point(19) is not None
+    assert r.stopped == DIVERGED
+
+
+def test_leaving_the_domain_stops_the_run():
+    r = run("sqrt(x)", "gradient_descent", [0.5], learning_rate=1.0)
+    assert r.point(3) is None
+    assert r.stopped == DIVERGED
+
+
+def test_singular_hessian_stops_newton():
+    r = run("x^3", "newton", [0.0])
+    assert r.point(1) is None
+    assert r.stopped == SINGULAR
+
+
+def test_singular_hessian_stops_newton_in_pyodide(monkeypatch):
+    # Pyodide's solve returns inf rather than raising LinAlgError
+    monkeypatch.setattr(np.linalg, "solve", lambda a, b: np.full_like(b, np.inf))
+    r = run("x^2 + 0y", "newton", [1.0, 1.0])
+    assert r.point(1) is None
+    assert r.stopped == SINGULAR
+
+
+def test_points_are_cached_and_asked_for_in_any_order():
+    r = run("x^2 + y^2", "adam", [1.0, 1.0])
+    late = r.point(30)
+    assert r.point(3) == r.points[3]
+    assert r.point(30) == late
+
+
+def manager_with(expression: str, *runs: dict) -> Manager:
+    m = Manager()
+    m.handle_set_function({"variables": len(runs[0]["start"]), "expression": expression})
+    m.handle_set_runs({"runs": list(runs)})
+    return m
+
+
+def test_state_past_the_last_iteration():
+    m = manager_with("x^2", {"algorithm": "gradient_descent", "start": [1.0], "params": {}})
+    assert m.handle_state({"iteration": MAX_ITERATIONS}) is not None
+    assert m.handle_state({"iteration": MAX_ITERATIONS + 1}) is None
+
+
+def test_state_ends_when_every_run_has_stopped():
+    m = manager_with(
+        "x^3 + x^2",
+        {"algorithm": "gradient_descent", "start": [1.0], "params": {"learning_rate": 1.5}},
+        {"algorithm": "newton", "start": [-1/3], "params": {}},  # f'' = 0 here
+    )
+    states = [m.handle_state({"iteration": k}) for k in range(MAX_ITERATIONS)]
+    end = states.index(None)
+    assert 1 < end and all(s is None for s in states[end:])
+    # Newton stops first and says why while gradient descent carries on
+    assert states[1]["runs"][1] == {"point": None, "stopped": SINGULAR}
+    assert states[1]["runs"][0]["point"] is not None
+    # Each run says why at its last point
+    assert states[0]["runs"][1]["stopped"] == SINGULAR
+    assert states[end - 2]["runs"][0]["stopped"] is None
+    assert states[end - 1]["runs"][0]["stopped"] == DIVERGED
+
+
+def test_start_point_outside_the_domain():
+    m = Manager()
+    m.handle_set_function({"variables": 1, "expression": "log(x)"})
+    with pytest.raises(UserError, match="no finite value at the initial point"):
+        m.handle_set_runs({"runs": [{"algorithm": "adam", "start": [-1.0], "params": {}}]})
+
+
+def test_failed_runs_replace_the_old_ones():
+    m = manager_with("log(x)", {"algorithm": "adam", "start": [1.0], "params": {}})
+    with pytest.raises(UserError):
+        m.handle_set_runs({"runs": [{"algorithm": "adam", "start": [-1.0], "params": {}}]})
+    assert m.handle_state({"iteration": 0}) is None
+
+
+def test_function_values_one_variable():
+    m = Manager()
+    m.handle_set_function({"variables": 1, "expression": "log(x)"})
+    values = m.handle_function_values({"x_range": [-1, 1], "y_range": [0, 1]})
+    assert len(values["x"]) == len(values["f"])
+    assert values["f"][0] is None and values["f"][-1] == 0.0
+
+
+def test_function_values_two_variables():
+    m = Manager()
+    m.handle_set_function({"variables": 2, "expression": "x + 2y"})
+    values = m.handle_function_values({"x_range": [0, 1], "y_range": [0, 2]})
+    assert values["f"][-1][0] == 4.0  # rows follow y
+    assert set(values["arrows"]["u"]) == {1.0} and set(values["arrows"]["v"]) == {2.0}
+
+
+def test_no_function_values_without_a_function():
+    assert Manager().handle_function_values({"x_range": [0, 1], "y_range": [0, 1]}) is None

backend/uv.lock

@@ -0,0 +1,169 @@
+version = 1
+revision = 5
+requires-python = ">=3.12"
+
+[[package]]
+name = "backend"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "numpy" },
+    { name = "sympy" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "pytest" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "numpy", specifier = ">=2.4.0" },
+    { name = "sympy", specifier = ">=1.14.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [{ name = "pytest", specifier = ">=9.2.0" }]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/e1/2069291243c926a2ff1cd706c7f3eeb9b62144bf60f77c9fb9ff2fb26bd3/iniconfig-2.3.1.tar.gz", hash = "sha256:67f4b9c50da0dedf52af349e7749a80a9057a5031199791b906c3bb3ae878960", size = 21209, upload-time = "2026-10-06T22:48:38.076Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/56/43/4ca9e49d27a1fcf6bece6f6aec0ea46bb9112489b93d4b688fb415457bdb/iniconfig-2.3.1-py3-none-any.whl", hash = "sha256:9121e2c1fdb355232495be3194c8dfe87ccc2d5dee45947b78e68f499790d7a7", size = 7552, upload-time = "2026-10-06T22:48:36.959Z" },
+]
+
+[[package]]
+name = "mpmath"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a4/7a/6a3d14e205d292b738db449d0de649b373a59edb0d0b4493821d0a3e8718/numpy-2.4.0.tar.gz", hash = "sha256:6e504f7b16118198f138ef31ba24d985b124c2c469fe8467007cf30fd992f934", size = 20685720, upload-time = "2025-12-20T16:18:19.023Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8b/ff/f6400ffec95de41c74b8e73df32e3fff1830633193a7b1e409be7fb1bb8c/numpy-2.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2a8b6bb8369abefb8bd1801b054ad50e02b3275c8614dc6e5b0373c305291037", size = 16653117, upload-time = "2025-12-20T16:16:06.709Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/28/6c23e97450035072e8d830a3c411bf1abd1f42c611ff9d29e3d8f55c6252/numpy-2.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2e284ca13d5a8367e43734148622caf0b261b275673823593e3e3634a6490f83", size = 12369711, upload-time = "2025-12-20T16:16:08.758Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/af/acbef97b630ab1bb45e6a7d01d1452e4251aa88ce680ac36e56c272120ec/numpy-2.4.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:49ff32b09f5aa0cd30a20c2b39db3e669c845589f2b7fc910365210887e39344", size = 5198355, upload-time = "2025-12-20T16:16:10.902Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/c8/4e0d436b66b826f2e53330adaa6311f5cac9871a5b5c31ad773b27f25a74/numpy-2.4.0-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:36cbfb13c152b1c7c184ddac43765db8ad672567e7bafff2cc755a09917ed2e6", size = 6545298, upload-time = "2025-12-20T16:16:12.607Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/27/e1f5d144ab54eac34875e79037011d511ac57b21b220063310cb96c80fbc/numpy-2.4.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:35ddc8f4914466e6fc954c76527aa91aa763682a4f6d73249ef20b418fe6effb", size = 14398387, upload-time = "2025-12-20T16:16:14.257Z" },
+    { url = "https://files.pythonhosted.org/packages/67/64/4cb909dd5ab09a9a5d086eff9586e69e827b88a5585517386879474f4cf7/numpy-2.4.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dc578891de1db95b2a35001b695451767b580bb45753717498213c5ff3c41d63", size = 16363091, upload-time = "2025-12-20T16:16:17.32Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/9c/8efe24577523ec6809261859737cf117b0eb6fdb655abdfdc81b2e468ce4/numpy-2.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:98e81648e0b36e325ab67e46b5400a7a6d4a22b8a7c8e8bbfe20e7db7906bf95", size = 16176394, upload-time = "2025-12-20T16:16:19.524Z" },
+    { url = "https://files.pythonhosted.org/packages/61/f0/1687441ece7b47a62e45a1f82015352c240765c707928edd8aef875d5951/numpy-2.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d57b5046c120561ba8fa8e4030fbb8b822f3063910fa901ffadf16e2b7128ad6", size = 18287378, upload-time = "2025-12-20T16:16:22.866Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/6f/f868765d44e6fc466467ed810ba9d8d6db1add7d4a748abfa2a4c99a3194/numpy-2.4.0-cp312-cp312-win32.whl", hash = "sha256:92190db305a6f48734d3982f2c60fa30d6b5ee9bff10f2887b930d7b40119f4c", size = 5955432, upload-time = "2025-12-20T16:16:25.06Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/b5/94c1e79fcbab38d1ca15e13777477b2914dd2d559b410f96949d6637b085/numpy-2.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:680060061adb2d74ce352628cb798cfdec399068aa7f07ba9fb818b2b3305f98", size = 12306201, upload-time = "2025-12-20T16:16:26.979Z" },
+    { url = "https://files.pythonhosted.org/packages/70/09/c39dadf0b13bb0768cd29d6a3aaff1fb7c6905ac40e9aaeca26b1c086e06/numpy-2.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:39699233bc72dd482da1415dcb06076e32f60eddc796a796c5fb6c5efce94667", size = 10308234, upload-time = "2025-12-20T16:16:29.417Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/0d/853fd96372eda07c824d24adf02e8bc92bb3731b43a9b2a39161c3667cc4/numpy-2.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a152d86a3ae00ba5f47b3acf3b827509fd0b6cb7d3259665e63dafbad22a75ea", size = 16649088, upload-time = "2025-12-20T16:16:31.421Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/37/cc636f1f2a9f585434e20a3e6e63422f70bfe4f7f6698e941db52ea1ac9a/numpy-2.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:39b19251dec4de8ff8496cd0806cbe27bf0684f765abb1f4809554de93785f2d", size = 12364065, upload-time = "2025-12-20T16:16:33.491Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/69/0b78f37ca3690969beee54103ce5f6021709134e8020767e93ba691a72f1/numpy-2.4.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:009bd0ea12d3c784b6639a8457537016ce5172109e585338e11334f6a7bb88ee", size = 5192640, upload-time = "2025-12-20T16:16:35.636Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/2a/08569f8252abf590294dbb09a430543ec8f8cc710383abfb3e75cc73aeda/numpy-2.4.0-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:5fe44e277225fd3dff6882d86d3d447205d43532c3627313d17e754fb3905a0e", size = 6541556, upload-time = "2025-12-20T16:16:37.276Z" },
+    { url = "https://files.pythonhosted.org/packages/93/e9/a949885a4e177493d61519377952186b6cbfdf1d6002764c664ba28349b5/numpy-2.4.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f935c4493eda9069851058fa0d9e39dbf6286be690066509305e52912714dbb2", size = 14396562, upload-time = "2025-12-20T16:16:38.953Z" },
+    { url = "https://files.pythonhosted.org/packages/99/98/9d4ad53b0e9ef901c2ef1d550d2136f5ac42d3fd2988390a6def32e23e48/numpy-2.4.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8cfa5f29a695cb7438965e6c3e8d06e0416060cf0d709c1b1c1653a939bf5c2a", size = 16351719, upload-time = "2025-12-20T16:16:41.503Z" },
+    { url = "https://files.pythonhosted.org/packages/28/de/5f3711a38341d6e8dd619f6353251a0cdd07f3d6d101a8fd46f4ef87f895/numpy-2.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ba0cb30acd3ef11c94dc27fbfba68940652492bc107075e7ffe23057f9425681", size = 16176053, upload-time = "2025-12-20T16:16:44.552Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/5b/2a3753dc43916501b4183532e7ace862e13211042bceafa253afb5c71272/numpy-2.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:60e8c196cd82cbbd4f130b5290007e13e6de3eca79f0d4d38014769d96a7c475", size = 18277859, upload-time = "2025-12-20T16:16:47.174Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/c5/a18bcdd07a941db3076ef489d036ab16d2bfc2eae0cf27e5a26e29189434/numpy-2.4.0-cp313-cp313-win32.whl", hash = "sha256:5f48cb3e88fbc294dc90e215d86fbaf1c852c63dbdb6c3a3e63f45c4b57f7344", size = 5953849, upload-time = "2025-12-20T16:16:49.554Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/f1/719010ff8061da6e8a26e1980cf090412d4f5f8060b31f0c45d77dd67a01/numpy-2.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:a899699294f28f7be8992853c0c60741f16ff199205e2e6cdca155762cbaa59d", size = 12302840, upload-time = "2025-12-20T16:16:51.227Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/5a/b3d259083ed8b4d335270c76966cb6cf14a5d1b69e1a608994ac57a659e6/numpy-2.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:9198f447e1dc5647d07c9a6bbe2063cc0132728cc7175b39dbc796da5b54920d", size = 10308509, upload-time = "2025-12-20T16:16:53.313Z" },
+    { url = "https://files.pythonhosted.org/packages/31/01/95edcffd1bb6c0633df4e808130545c4f07383ab629ac7e316fb44fff677/numpy-2.4.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:74623f2ab5cc3f7c886add4f735d1031a1d2be4a4ae63c0546cfd74e7a31ddf6", size = 12491815, upload-time = "2025-12-20T16:16:55.496Z" },
+    { url = "https://files.pythonhosted.org/packages/59/ea/5644b8baa92cc1c7163b4b4458c8679852733fa74ca49c942cfa82ded4e0/numpy-2.4.0-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:0804a8e4ab070d1d35496e65ffd3cf8114c136a2b81f61dfab0de4b218aacfd5", size = 5320321, upload-time = "2025-12-20T16:16:57.468Z" },
+    { url = "https://files.pythonhosted.org/packages/26/4e/e10938106d70bc21319bd6a86ae726da37edc802ce35a3a71ecdf1fdfe7f/numpy-2.4.0-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:02a2038eb27f9443a8b266a66911e926566b5a6ffd1a689b588f7f35b81e7dc3", size = 6641635, upload-time = "2025-12-20T16:16:59.379Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/8d/a8828e3eaf5c0b4ab116924df82f24ce3416fa38d0674d8f708ddc6c8aac/numpy-2.4.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1889b3a3f47a7b5bee16bc25a2145bd7cb91897f815ce3499db64c7458b6d91d", size = 14456053, upload-time = "2025-12-20T16:17:01.768Z" },
+    { url = "https://files.pythonhosted.org/packages/68/a1/17d97609d87d4520aa5ae2dcfb32305654550ac6a35effb946d303e594ce/numpy-2.4.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85eef4cb5625c47ee6425c58a3502555e10f45ee973da878ac8248ad58c136f3", size = 16401702, upload-time = "2025-12-20T16:17:04.235Z" },
+    { url = "https://files.pythonhosted.org/packages/18/32/0f13c1b2d22bea1118356b8b963195446f3af124ed7a5adfa8fdecb1b6ca/numpy-2.4.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6dc8b7e2f4eb184b37655195f421836cfae6f58197b67e3ffc501f1333d993fa", size = 16242493, upload-time = "2025-12-20T16:17:06.856Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/23/48f21e3d309fbc137c068a1475358cbd3a901b3987dcfc97a029ab3068e2/numpy-2.4.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:44aba2f0cafd287871a495fb3163408b0bd25bbce135c6f621534a07f4f7875c", size = 18324222, upload-time = "2025-12-20T16:17:09.392Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/52/41f3d71296a3dcaa4f456aaa3c6fc8e745b43d0552b6bde56571bb4b4a0f/numpy-2.4.0-cp313-cp313t-win32.whl", hash = "sha256:20c115517513831860c573996e395707aa9fb691eb179200125c250e895fcd93", size = 6076216, upload-time = "2025-12-20T16:17:11.437Z" },
+    { url = "https://files.pythonhosted.org/packages/35/ff/46fbfe60ab0710d2a2b16995f708750307d30eccbb4c38371ea9e986866e/numpy-2.4.0-cp313-cp313t-win_amd64.whl", hash = "sha256:b48e35f4ab6f6a7597c46e301126ceba4c44cd3280e3750f85db48b082624fa4", size = 12444263, upload-time = "2025-12-20T16:17:13.182Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/e3/9189ab319c01d2ed556c932ccf55064c5d75bb5850d1df7a482ce0badead/numpy-2.4.0-cp313-cp313t-win_arm64.whl", hash = "sha256:4d1cfce39e511069b11e67cd0bd78ceff31443b7c9e5c04db73c7a19f572967c", size = 10378265, upload-time = "2025-12-20T16:17:15.211Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/ed/52eac27de39d5e5a6c9aadabe672bc06f55e24a3d9010cd1183948055d76/numpy-2.4.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:c95eb6db2884917d86cde0b4d4cf31adf485c8ec36bf8696dd66fa70de96f36b", size = 16647476, upload-time = "2025-12-20T16:17:17.671Z" },
+    { url = "https://files.pythonhosted.org/packages/77/c0/990ce1b7fcd4e09aeaa574e2a0a839589e4b08b2ca68070f1acb1fea6736/numpy-2.4.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:65167da969cd1ec3a1df31cb221ca3a19a8aaa25370ecb17d428415e93c1935e", size = 12374563, upload-time = "2025-12-20T16:17:20.216Z" },
+    { url = "https://files.pythonhosted.org/packages/37/7c/8c5e389c6ae8f5fd2277a988600d79e9625db3fff011a2d87ac80b881a4c/numpy-2.4.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:3de19cfecd1465d0dcf8a5b5ea8b3155b42ed0b639dba4b71e323d74f2a3be5e", size = 5203107, upload-time = "2025-12-20T16:17:22.47Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/94/ca5b3bd6a8a70a5eec9a0b8dd7f980c1eff4b8a54970a9a7fef248ef564f/numpy-2.4.0-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:6c05483c3136ac4c91b4e81903cb53a8707d316f488124d0398499a4f8e8ef51", size = 6538067, upload-time = "2025-12-20T16:17:24.001Z" },
+    { url = "https://files.pythonhosted.org/packages/79/43/993eb7bb5be6761dde2b3a3a594d689cec83398e3f58f4758010f3b85727/numpy-2.4.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:36667db4d6c1cea79c8930ab72fadfb4060feb4bfe724141cd4bd064d2e5f8ce", size = 14411926, upload-time = "2025-12-20T16:17:25.822Z" },
+    { url = "https://files.pythonhosted.org/packages/03/75/d4c43b61de473912496317a854dac54f1efec3eeb158438da6884b70bb90/numpy-2.4.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9a818668b674047fd88c4cddada7ab8f1c298812783e8328e956b78dc4807f9f", size = 16354295, upload-time = "2025-12-20T16:17:28.308Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/0a/b54615b47ee8736a6461a4bb6749128dd3435c5a759d5663f11f0e9af4ac/numpy-2.4.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1ee32359fb7543b7b7bd0b2f46294db27e29e7bbdf70541e81b190836cd83ded", size = 16190242, upload-time = "2025-12-20T16:17:30.993Z" },
+    { url = "https://files.pythonhosted.org/packages/98/ce/ea207769aacad6246525ec6c6bbd66a2bf56c72443dc10e2f90feed29290/numpy-2.4.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e493962256a38f58283de033d8af176c5c91c084ea30f15834f7545451c42059", size = 18280875, upload-time = "2025-12-20T16:17:33.327Z" },
+    { url = "https://files.pythonhosted.org/packages/17/ef/ec409437aa962ea372ed601c519a2b141701683ff028f894b7466f0ab42b/numpy-2.4.0-cp314-cp314-win32.whl", hash = "sha256:6bbaebf0d11567fa8926215ae731e1d58e6ec28a8a25235b8a47405d301332db", size = 6002530, upload-time = "2025-12-20T16:17:35.729Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/4a/5cb94c787a3ed1ac65e1271b968686521169a7b3ec0b6544bb3ca32960b0/numpy-2.4.0-cp314-cp314-win_amd64.whl", hash = "sha256:3d857f55e7fdf7c38ab96c4558c95b97d1c685be6b05c249f5fdafcbd6f9899e", size = 12435890, upload-time = "2025-12-20T16:17:37.599Z" },
+    { url = "https://files.pythonhosted.org/packages/48/a0/04b89db963af9de1104975e2544f30de89adbf75b9e75f7dd2599be12c79/numpy-2.4.0-cp314-cp314-win_arm64.whl", hash = "sha256:bb50ce5fb202a26fd5404620e7ef820ad1ab3558b444cb0b55beb7ef66cd2d63", size = 10591892, upload-time = "2025-12-20T16:17:39.649Z" },
+    { url = "https://files.pythonhosted.org/packages/53/e5/d74b5ccf6712c06c7a545025a6a71bfa03bdc7e0568b405b0d655232fd92/numpy-2.4.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:355354388cba60f2132df297e2d53053d4063f79077b67b481d21276d61fc4df", size = 12494312, upload-time = "2025-12-20T16:17:41.714Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/08/3ca9cc2ddf54dfee7ae9a6479c071092a228c68aef08252aa08dac2af002/numpy-2.4.0-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:1d8f9fde5f6dc1b6fc34df8162f3b3079365468703fee7f31d4e0cc8c63baed9", size = 5322862, upload-time = "2025-12-20T16:17:44.145Z" },
+    { url = "https://files.pythonhosted.org/packages/87/74/0bb63a68394c0c1e52670cfff2e309afa41edbe11b3327d9af29e4383f34/numpy-2.4.0-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:e0434aa22c821f44eeb4c650b81c7fbdd8c0122c6c4b5a576a76d5a35625ecd9", size = 6644986, upload-time = "2025-12-20T16:17:46.203Z" },
+    { url = "https://files.pythonhosted.org/packages/06/8f/9264d9bdbcf8236af2823623fe2f3981d740fc3461e2787e231d97c38c28/numpy-2.4.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40483b2f2d3ba7aad426443767ff5632ec3156ef09742b96913787d13c336471", size = 14457958, upload-time = "2025-12-20T16:17:48.017Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/d9/f9a69ae564bbc7236a35aa883319364ef5fd41f72aa320cc1cbe66148fe2/numpy-2.4.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d9e6a7664ddd9746e20b7325351fe1a8408d0a2bf9c63b5e898290ddc8f09544", size = 16398394, upload-time = "2025-12-20T16:17:50.409Z" },
+    { url = "https://files.pythonhosted.org/packages/34/c7/39241501408dde7f885d241a98caba5421061a2c6d2b2197ac5e3aa842d8/numpy-2.4.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ecb0019d44f4cdb50b676c5d0cb4b1eae8e15d1ed3d3e6639f986fc92b2ec52c", size = 16241044, upload-time = "2025-12-20T16:17:52.661Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/95/cae7effd90e065a95e59fe710eeee05d7328ed169776dfdd9f789e032125/numpy-2.4.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d0ffd9e2e4441c96a9c91ec1783285d80bf835b677853fc2770a89d50c1e48ac", size = 18321772, upload-time = "2025-12-20T16:17:54.947Z" },
+    { url = "https://files.pythonhosted.org/packages/96/df/3c6c279accd2bfb968a76298e5b276310bd55d243df4fa8ac5816d79347d/numpy-2.4.0-cp314-cp314t-win32.whl", hash = "sha256:77f0d13fa87036d7553bf81f0e1fe3ce68d14c9976c9851744e4d3e91127e95f", size = 6148320, upload-time = "2025-12-20T16:17:57.249Z" },
+    { url = "https://files.pythonhosted.org/packages/92/8d/f23033cce252e7a75cae853d17f582e86534c46404dea1c8ee094a9d6d84/numpy-2.4.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b1f5b45829ac1848893f0ddf5cb326110604d6df96cdc255b0bf9edd154104d4", size = 12623460, upload-time = "2025-12-20T16:17:58.963Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/4f/1f8475907d1a7c4ef9020edf7f39ea2422ec896849245f00688e4b268a71/numpy-2.4.0-cp314-cp314t-win_arm64.whl", hash = "sha256:23a3e9d1a6f360267e8fbb38ba5db355a6a7e9be71d7fce7ab3125e88bb646c8", size = 10661799, upload-time = "2025-12-20T16:18:01.078Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/bf/db/7fc19e6f2dc92a966727031389fc2e08b558f0f25eb7403c1119ad4713cd/pluggy-1.7.0.tar.gz", hash = "sha256:d1eaa46ebb595891b860ab086b4d09c8588af65ebd4361b8e8f4bb8920b90ba8", size = 123304, upload-time = "2026-10-15T09:50:58.343Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/40/9e/2b38731e0fc536806f16490e1a12d7f0dc2a1235aa8cc07bcc75416a7daa/pluggy-1.7.0-py3-none-any.whl", hash = "sha256:7dd7b0d8832ba3cb632c306926ded123429211b83641b35dc5c41ad2d34f9bec", size = 27082, upload-time = "2026-10-15T09:50:56.808Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.21.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/79/42/bb4641652e58dedeac2ec51abc1f8cae4fee4ec63899a0999016229a0f2a/pytest-9.2.0.tar.gz", hash = "sha256:97c4f3b1f3c7414aa36465e09b8220f1d03627993bd51b1282e193753c80557b", size = 1797555, upload-time = "2026-10-27T21:30:20.728Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/51/39/1f5d8c8877a0fa327db959c19341d4be61660de1ab6b7391f9eb805bcd67/pytest-9.2.0-py3-none-any.whl", hash = "sha256:07acdcf88ec174f907dc01af70bf52d49b014bbab03faeeade31c96b18c2e588", size = 411776, upload-time = "2026-10-27T21:30:19.131Z" },
+]
+
+[[package]]
+name = "sympy"
+version = "1.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mpmath" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" },
+]