Upload full repository structure (NDA-safe math & econ evaluation)

Author: Math-llm-lab

LICENSE

@@ -0,0 +1,3 @@
+MIT License
+
+Copyright (c) 2025

README.md

@@ -0,0 +1,129 @@
+# Math + Econ Reasoning Portfolio (NDA-safe excerpts)
+
+This repository contains **carefully selected, NDA-safe excerpts** from a larger body of **math- and economics-based analytical work** used to design, evaluate, and verify **LLM reasoning and numerical reliability**.
+
+The materials here focus on the **final verification layer** of much broader analyses:
+- reduced-form problem statements  
+- distilled numerical cores  
+- deterministic validation logic  
+
+The original tasks were typically **more complex, data-driven, and multi-stage**, but are presented here in **simplified, synthetic form** to remain fully public and NDA-compliant.
+
+This is best viewed as a **portfolio of evaluation artefacts** rather than a full reproduction of the underlying research pipelines.
+
+---
+
+## What this repo demonstrates
+
+- **Non-trivial numerical methods**  
+  (bisection / root-finding, verification inequalities, Monte Carlo sanity checks)
+
+- **Reproducible reference solutions**  
+  with explicit tolerances and deterministic outputs
+
+- **Answer validation & scoring logic**  
+  similar to LLM evaluation / grading pipelines
+
+- **Failure-mode awareness**  
+  (bounds, monotonicity assumptions, bracketing errors, model misspecification)
+
+- **Clean Python engineering**  
+  (tests, CI, no side effects on import, CLI + JSON outputs)
+
+---
+
+## Important context (NDA-safe clarification)
+
+The problems in this repository are **not full research problems** and **not client deliverables**.
+
+They are:
+- **condensed representations** of larger analytical tasks  
+- using **synthetic or normalized parameters**  
+- stripped of proprietary data, domain specifics, and contextual complexity  
+
+In practice, the original tasks:
+- involved richer stochastic structure or real datasets  
+- required additional constraints, diagnostics, and robustness checks  
+- were embedded in broader modeling or evaluation workflows  
+
+What you see here corresponds to the **final reasoning and verification step** — the part most relevant for assessing **LLM numerical reasoning, correctness, and failure behavior**.
+
+---
+
+## Repository structure
+
+- `problems/` — problem statements + failure modes  
+- `src/econ_math_portfolio/models/` — model implementations (no code runs on import)  
+- `validators/` — validators calling model code  
+- `originals/` — original standalone scripts kept for transparency (not imported)  
+- `rubrics/` — scoring rules inspired by LLM evaluation setups  
+- `tests/` — pytest  
+- `.github/workflows/ci.yml` — CI (Python 3.10–3.12)
+
+---
+
+## Quickstart
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+python -m econ_math_portfolio list
+```
+
+---
+
+## CLI usage
+
+```bash
+python -m econ_math_portfolio reference credit_var_quantile
+python -m econ_math_portfolio validate cpi_target_discount 0.26191
+```
+
+---
+
+## Notebook demo
+
+```bash
+jupyter notebook notebooks/demo.ipynb
+```
+
+---
+
+## JSON output (tool-calling friendly)
+
+```bash
+python -m econ_math_portfolio list --json
+python -m econ_math_portfolio reference cpi_target_discount --json
+python -m econ_math_portfolio validate cpi_target_discount 0.26191 --json
+```
+
+---
+
+## Scoring rubric (LLM evaluation style)
+
+```bash
+python -m econ_math_portfolio score submissions/contract_good.json --json
+```
+
+Submission format:
+
+```json
+{
+  "task_id": "cpi_target_discount",
+  "answer": 0.26191,
+  "explanation": "optional short explanation"
+}
+```
+
+---
+
+## How to interpret this portfolio
+
+This repository is a **curated slice of real analytical work**, intentionally focused on:
+- reasoning clarity  
+- numerical correctness  
+- verification and evaluation  
+
+The goal is to show **how problems are checked**, not just how they are solved.

notebooks/demo.ipynb

@@ -0,0 +1,116 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "812d9969",
+   "metadata": {},
+   "source": [
+    "# Demo notebook: Math + Econ Reasoning Portfolio\n",
+    "\n",
+    "This notebook demonstrates:\n",
+    "- CPI targeting function and the bisection solution\n",
+    "- Contract task: utility target vs. c_high (and the solved value)\n",
+    "- Credit VaR: analytic value + Monte Carlo sanity-check distribution\n",
+    "\n",
+    "Run after installing dev deps:\n",
+    "```bash\n",
+    "pip install -e \".[dev]\"\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "746a11f9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import math\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from econ_math_portfolio.models.cpi_target_discount import CpiParams, cpi, solve_t\n",
+    "from econ_math_portfolio.models.contract_stochastic_income import ContractParams, lifetime_utility, solve_c_high\n",
+    "from econ_math_portfolio.models.credit_var_quantile import CreditParams, var_analytic, var_mc\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a5b5154d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# CPI(t) curve + target\n",
+    "p = CpiParams()\n",
+    "ts = np.linspace(0, 1, 400)\n",
+    "vals = [cpi(float(t), p) for t in ts]\n",
+    "t_star = solve_t(p)\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.plot(ts, vals)\n",
+    "plt.axhline(p.target_cpi)\n",
+    "plt.axvline(t_star)\n",
+    "plt.title(\"CPI(t) and target\")\n",
+    "plt.xlabel(\"t\")\n",
+    "plt.ylabel(\"CPI(t)\")\n",
+    "plt.show()\n",
+    "\n",
+    "t_star\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3559ab6d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Contract task: utility as a function of c_high + solved c_high\n",
+    "cp = ContractParams()\n",
+    "c_grid = np.linspace(0.5, 3.0, 400)\n",
+    "u_vals = [lifetime_utility(cp.delta, cp.c_low, float(c)) for c in c_grid]\n",
+    "c_star = solve_c_high(cp)\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.plot(c_grid, u_vals)\n",
+    "plt.axhline(cp.V0)\n",
+    "plt.axvline(c_star)\n",
+    "plt.title(\"Lifetime utility target vs c_high\")\n",
+    "plt.xlabel(\"c_high\")\n",
+    "plt.ylabel(\"V(c_high)\")\n",
+    "plt.show()\n",
+    "\n",
+    "c_star\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ffb4364c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Credit VaR: analytic + Monte Carlo sanity check (infinitely granular Vasicek)\n",
+    "pp = CreditParams()\n",
+    "analytic = var_analytic(pp)\n",
+    "mc_q = var_mc(pp, n_paths=200_000, seed=7)\n",
+    "\n",
+    "# Show distribution of VaR estimates from multiple seeds\n",
+    "estimates = [var_mc(pp, n_paths=50_000, seed=s) for s in range(10, 60)]\n",
+    "plt.figure()\n",
+    "plt.hist(estimates, bins=20)\n",
+    "plt.axvline(analytic)\n",
+    "plt.title(\"MC VaR estimates (batch) vs analytic VaR\")\n",
+    "plt.xlabel(\"VaR estimate\")\n",
+    "plt.ylabel(\"count\")\n",
+    "plt.show()\n",
+    "\n",
+    "analytic, mc_q\n"
+   ]
+  }
+ ],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

originals/b7_contract_stochastic_income.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import math
+
+
+def solve_contract() -> float:
+    # --- Inputs ---
+    delta = 0.95
+    prob = 0.5  # equal probability for the two income states
+    c_low = 0.95
+    V0_target = 3.0
+
+    # Autarky utilities (if consumption equals income)
+    V_aut_high = math.log(1.1) / (1 - delta)
+
+    # Expected lifetime utility under the contract (given c_high)
+    def expected_value(c_high: float) -> float:
+        if c_high <= 0:
+            return -math.inf
+        exp_u = prob * math.log(c_low) + prob * math.log(c_high)
+        return exp_u / (1 - delta)
+
+    # Participation / exit constraint in the high-income state:
+    # log(c_high)/(1-delta) >= log(1.1)/(1-delta)  =>  c_high >= 1.1
+    def exit_constraint(c_high: float) -> bool:
+        return c_high >= 1.1
+
+    # Solve expected_value(c_high) = V0_target via bisection on (0, 10)
+    tol = 1e-8
+    low, high = 1e-8, 10.0
+
+    # Bracketing check (monotone in c_high)
+    if expected_value(low) > V0_target:
+        raise ValueError("Target too low for the chosen lower bound.")
+    if expected_value(high) < V0_target:
+        raise ValueError("Target too high for the chosen upper bound.")
+
+    while high - low > tol:
+        mid = (low + high) / 2
+        val = expected_value(mid)
+        if val < V0_target:
+            low = mid
+        else:
+            high = mid
+
+    solution = (low + high) / 2
+
+    # Enforce exit constraint if needed
+    if not exit_constraint(solution):
+        print("Exit constraint not satisfied by the utility-matching solution.")
+        print("Raising c_high to the minimum feasible value: 1.100000")
+        solution = max(solution, 1.1)
+    else:
+        print("Solution satisfies both the target utility and the exit constraint.")
+
+    print(f"c_high (income=1.1): {solution:.6f}")
+    print(f"Contract lifetime utility: {expected_value(solution):.6f}")
+    print(
+        f"High-state lifetime utility: {math.log(solution)/(1 - delta):.6f} "
+        f"(autarky minimum: {V_aut_high:.6f})"
+    )
+    return float(solution)
+
+
+if __name__ == "__main__":
+    solve_contract()

originals/check_HJB_condition.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+# Original-style script: HJB inequality check at a test state.
+#
+# Notes:
+# - This script is kept in `originals/` for transparency.
+# - The repo's main implementation lives in:
+#   `src/econ_math_portfolio/models/hjb_discount_threshold.py`
+#
+# We check the inequality in the form used in the repo:
+#   F(rho) = rho*w^gamma + b*p*gamma*y*w^(gamma-1) + 0.5*sigma^2*p^2*gamma*(gamma-1)*y^2*w^(gamma-2)
+# and compute rho_critical (smallest rho with F(rho) >= 0) at x=0,y=1,p=1.
+
+# Model parameters
+b = 1.0
+sigma = 0.2
+gamma = 0.7
+
+
+def F(rho: float, x: float, y: float, p: float) -> float:
+    w = x + p * y
+    if w <= 0:
+        raise ValueError("Wealth must be positive.")
+    return (
+        rho * (w**gamma)
+        + b * p * gamma * y * (w ** (gamma - 1))
+        + 0.5 * (sigma**2) * (p**2) * gamma * (gamma - 1) * (y**2) * (w ** (gamma - 2))
+    )
+
+
+def rho_critical(x: float, y: float, p: float) -> float:
+    w = x + p * y
+    if w <= 0:
+        raise ValueError("Wealth must be positive.")
+    const = (
+        b * p * gamma * y * (w ** (gamma - 1))
+        + 0.5 * (sigma**2) * (p**2) * gamma * (gamma - 1) * (y**2) * (w ** (gamma - 2))
+    )
+    return (-const) / (w**gamma)
+
+
+if __name__ == "__main__":
+    p_test = 1.0
+    x_test = 0.0
+    y_test = 1.0
+
+    rho_star = rho_critical(x_test, y_test, p_test)
+    test_rhos = [rho_star - 0.01, rho_star, rho_star + 0.01]
+
+    print(f"Critical rho (rho*): {rho_star:.6f}")
+    print(f"Test state: x={x_test}, y={y_test}, p={p_test}")
+    print("=" * 60)
+
+    for rho in test_rhos:
+        value = F(rho, x_test, y_test, p_test)
+        status = "SATISFIED" if value >= 0 else "VIOLATED"
+        print(f"rho = {rho:.6f}")
+        print(f"delta vs critical: {rho - rho_star:+.6f}")
+        print(f"F(rho) = {value:.6f}")
+        print(f"Inequality status: {status}")
+        print("-" * 60)