🤖 AI

YUKTI: From Natural-Language Situations to Robust, Verifiable Decisions An Uncertainty-Typed Proposition IR, Assumption-Robust Pareto Frontiers, and a Regret Certificate

YUKTI is a robust decision-making framework that transforms natural-language situations into uncertainty-typed proposition graphs to generate assumption-robust Pareto frontiers and verifiable regret certificates, significantly outperforming standard single-objective optimization and LLM-based planners by minimizing decision regret under coefficient uncertainty and structural misspecification.

Original authors: Suyash Mishra

Published 2026-07-14

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Suyash Mishra

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are the captain of a massive ship, and you have a map drawn by a very smart, very chatty AI. The AI looks at your destination and says, "Go exactly 42.3 degrees north at 15 knots." It sounds confident. It sounds perfect. But here's the catch: the AI had to guess the wind speed, the current, and the weight of your cargo to draw that line. If the wind is just a tiny bit stronger than the AI guessed, your ship might crash into a reef.

This is the problem with most current AI decision-makers. They take a messy, wordy situation ("We need to sell more medicine but not annoy doctors") and turn it into a single, rigid number-crunching plan. They act like they know the future. The paper calls this "mimicry of computation." It looks like a math solution, but it's actually just a guess dressed up in a suit. If the guess is wrong, the plan is "silently fragile."

Enter YUKTI (pronounced yook-tee). Think of YUKTI not as a captain who steers the ship, but as a super-smart navigator who refuses to trust a single map.

The Old Way: The "One-Number" Trap

Most systems try to solve a problem by picking one goal (like "make the most money") and guessing one number for every variable.

The Flaw: If you guess the cost of fuel is $50, the plan is built for $50. If fuel is actually $51, the whole plan falls apart.
The Paper's Verdict: This is dangerous. The paper explicitly argues against this "point-valued" approach. It says that turning a worded situation into a single number is where the failure happens.

The YUKTI Way: The "Cloud of Possibilities"

YUKTI changes the game. Instead of guessing one number, it treats every guess as a cloud of possibilities.

The Metaphor: Imagine you are packing for a trip. The old way says, "It will be 70°F, so pack one t-shirt." YUKTI says, "It might be 60°F, 70°F, or 80°F. So, let's pack a t-shirt, a light jacket, and a sweater, and see which combination works best no matter what the weather does."
How it works: YUKTI creates a "Typed Proposition" map. Every relationship (like "more emails = more clicks") carries a cloud of uncertainty. It doesn't just say "clicks will go up"; it says "clicks will likely go up, but maybe a little, maybe a lot, and maybe not at all if we spam people."

The Magic Trick: The "Robustness Score" (ρ)

This is the paper's biggest innovation. After YUKTI runs its simulations, it doesn't just give you a plan. It gives you a survival score, called ρ (rho).

What it means: If a plan has a score of 0.99, it means that if you re-ran the world 100 times with slightly different guesses (different winds, different currents), this plan would still work 99 times.
The Result: YUKTI picks the plan that survives the most storms. It's not the plan that wins the most in a perfect world; it's the plan that wins the most when things go wrong.

The "Stress Test" Lab

The paper didn't just talk about this; they built a lab to break things.

The Simulation: They created a fake world where the AI's guesses were slightly wrong (like assuming a drug works better than it actually does).
The Outcome: When they tested the "old way" (the single-number plan) against the "YUKTI way," the old plan failed miserably. The YUKTI plan cut the regret (the pain of making a bad choice) by over 90%.
Real-World Check: They also tested this on a real dataset of 41,188 actual bank marketing calls. The YUKTI method beat the bank's current strategy by 34% and beat the "naive" AI guess by 4%. It proved that being "robust" (safe against mistakes) is better than being "optimistic" (hoping for the best).

The "Two-Stage" Dance

Sometimes decisions happen in steps. First, you design a campaign; then, you roll it out.

The Problem: If you hand off a single number from step one to step two, you hide the risk.
YUKTI's Fix: It passes a distribution (a whole cloud of numbers) from step one to step two.
The Example: In a test with cancer treatment marketing, YUKTI realized that pushing too hard on email might annoy doctors. It found a "robust compromise" that kept the doctors happy while still getting results. It showed that if you just looked at the average, you'd think you were safe, but YUKTI saw a 60% chance you'd actually fail.

What YUKTI is NOT

The paper is very clear about what this tool is not:

It is not a magic solver that finds the "perfect" answer. The paper explicitly states that the solvers used are standard, old-school math tools. The magic is in how they are used.
It is not a system that replaces human judgment. It is a "decision stress-testing layer." It tells you, "Here is a plan, and here is exactly how likely it is to fail if your assumptions are wrong."
It is not perfect for everything. The paper admits that if decisions are linked in very long, complex chains (like a domino effect over years), this method might get "optimistic" and need to change its approach.

The Bottom Line

The paper concludes that Large Language Models (LLMs) are amazing at formulating the problem (reading the words and understanding the rules), but they are terrible at solving it (guessing the numbers).

YUKTI keeps the AI in the driver's seat for the story, but hands the math to a system that respects uncertainty. It turns a "maybe" into a "probably safe."

In the end, the paper suggests that for high-stakes decisions—like spending real money, treating patients, or managing energy—confidence is a failure mode. The best decision isn't the one that looks the most certain; it's the one that admits it might be wrong and has a backup plan ready. YUKTI is the tool that builds that backup plan.

Technical Summary: YUKTI – From Natural-Language Situations to Robust, Verifiable Decisions

1. The Problem: The Fragility of "Mimicry of Computation"
Current pipelines for converting natural language decision briefs into optimization problems (e.g., NL4Opt, OptiMUS, OR-LLM-Agent) suffer from three critical limitations that render them fragile in high-stakes environments:

Single-Objective: They collapse complex trade-offs (e.g., reach vs. cost vs. risk) into a single weighted scalar, hiding the decision-maker's actual trade-offs.
Single-Shot: They treat decisions as one-off events rather than sequential processes where later stages are constrained by earlier outcomes.
Point-Valued Coefficients: They require the language model (LLM) to invent specific numeric coefficients for relationships (e.g., "oncologists respond well to content"). These invented numbers are treated as facts. A plan optimal only at these specific guessed values is "silently fragile."

The paper argues that the primary risk is the "mimicry of computation": generating text that looks like an optimized recommendation but lacks the substance of a solved model, stated coefficients, or sensitivity analysis. When these plans drive real resource allocation (clinical, financial, public health), the failure mode is silent brittleness.

2. Methodology: The YUKTI Framework
YUKTI shifts the target of autoformulation from solving a single point-valued problem to managing uncertainty across a decision DAG (Directed Acyclic Graph).

Typed Proposition Intermediate Representation (IR):
Instead of fixed numbers, YUKTI represents relationships as tuples $p = \langle \phi, \theta, \Theta, \sigma, \pi \rangle$ :
- $\phi$ : A parametric functional form.
- $\theta$ : Nominal coefficients.
- $\Theta$ : A distribution over coefficients (e.g., lognormal) representing uncertainty.
- $\sigma$ : Qualitative shape priors (monotonicity, curvature).
- $\pi$ : Provenance tags (given, assumed, or benchmark).
  This allows the system to distinguish between hard data and LLM assumptions.
Structure-Aware Routing:
Before solving, YUKTI probes the stage's mathematical structure (affine, convex, or nonconvex) using random pairs and interpolation checks. It then routes the stage to the appropriate solver:
- Affine: Exact solvers (Augmented $\epsilon$ -constraint with HiGHS).
- Convex/Smooth: Nonlinear programming (SLSQP).
- Nonconvex/Black-box: Evolutionary algorithms (NSGA-II/NSGA-III via pymoo).
Multi-Stage Frontier Hand-off:
Stages are solved in topological order. Instead of passing a single point value to the next stage, YUKTI passes a distributional hand-off (quantiles of the signal values). This ensures downstream stages evaluate feasibility and value in expectation over the uncertainty of upstream decisions, preventing the masking of tail risks.
Assumption-Robust Pareto Frontiers (ARPF):
This is the core robustness mechanism. YUKTI resamples the coefficient distributions $\Theta$ (including structural misspecification via $\epsilon$ -contamination) $K$ times. For every candidate solution in the discovered pool, it calculates $\rho(x)$ , the empirical probability that the solution remains feasible and non-dominated across these resampled worlds.
- The system selects a Robust Compromise: a solution that maximizes the distance to the ideal point while satisfying $\rho(x) \geq 0.5$ (or a similar threshold).
SRJANA (Benchmark-Anchored Contextual Synthesis):
When no real dataset exists, SRJANA synthesizes a contextual dataset. It pulls benchmark anchors (e.g., industry click rates) from the web, defines a population with latent affinities, and calibrates the synthetic data to match these anchors and effect ratios. The optimizer then fits propositions to this synthetic data, inheriting honest, data-derived uncertainty.
Decision Traceability:
The output includes Segment Attribution (which population segments drive the result) and Shadow Price Analysis (which constraints bind and the marginal value of relaxing them), making the recommendation auditable rather than merely persuasive.

3. Key Contributions

Uncertainty-Typed IR: A formalism where every coefficient carries a distribution and provenance, transforming "invented numbers" into quantified inputs.
ARPF Mechanism: A method to score solutions based on their survival probability under assumption uncertainty, including structural misspecification.
Regret Bound (Theorem 1): A theoretical proof showing that the robustness score $\rho$ is an exact factor of decision regret. Specifically, $R(\hat{x}) = (1 - \rho(\hat{x}))\bar{g}(\hat{x})$ , where $R$ is regret and $\bar{g}$ is the average loss when the choice is suboptimal. This certifies that maximizing $\rho$ minimizes the upper bound of regret under 0-1 pool-optimality loss.
Distributional Hand-off: A mechanism to propagate uncertainty between sequential stages, avoiding the "optimizer's curse" of point-value commitments.
Deployment Posture: YUKTI is positioned not as a system of record or a benchmark-SOTA solver, but as a decision stress-testing layer that sits on top of standard solvers.

4. Results and Validation
The paper validates the framework through three distinct lenses:

Controlled Structural Misspecification:
In a held-out "true world" with hidden negative interactions (saturation) that the optimizer's additive surrogate missed, the naive point plan incurred high regret. The ARPF robust compromise reduced mean regret by 98% and tail regret (CVaR) by 92% compared to the naive plan. The Theorem 1 certificate was verified numerically.
Real-World Backtest (UCI Bank Marketing):
Using 41,188 real telemarketing decisions (not generated by the authors), the robust rule achieved a 34% higher conversion rate than the logged status quo and 4% higher than a naive point-rule. It significantly reduced the "optimizer's curse" (the gap between training estimates and realized value).
Regulated Commercial Deployment (Oncology):
In a simulated loss-of-exclusivity scenario for oncology brands, YUKTI optimized within lawful constraints (GDPR consent, frequency caps). It produced a robust compromise that priced downside risk in euros, demonstrating the ability to operate within strict regulatory action spaces.
Limitations and Boundaries:
The paper explicitly notes that under long-range causal coupling between actions, the forward multi-stage hand-off becomes unsound; regret grows with coupling, and the per-stage certificate becomes optimistic. This marks the boundary where the formalism must shift to a backward-induction causal policy.

5. Significance and Claims
The paper claims that YUKTI addresses the critical gap between LLMs as "formulators" and classical solvers as "solv ers."

LLMs are Formulators, Not Solvers: The authors demonstrate that even a large reasoning model (LRM) handed the correct numbers, when paired with single-objective optimization, incurs ~47× the held-out regret of YUKTI's robust compromise.
From Persuasion to Auditability: The system moves decision support from "persuasive narrative" to "auditable traceability," allowing decision-makers to see exactly which assumptions drive a recommendation and how often it survives being wrong.
Modest Scope: The authors explicitly state they make no claim of benchmark superiority in terms of raw solver speed or Pareto front size. The contribution is the methodology of uncertainty-typed autoformulation, the ARPF mechanism, and the regret-bounded decision traceability.

In summary, YUKTI proposes that for high-stakes decisions, the goal is not to find the single "optimal" plan based on guessed numbers, but to find a robust compromise that is explicitly aware of its own fragility, quantified by a regret-bounded probability of survival.