Port Log

// Two ports, one MathIR — dual provenance for every future stochastic-vol family

public static class HestonNormalFromPaper {    // Path A — SSRN 2445328, negative-i

public static double PriceOfCall(double F, double K, double tau, /* ... */) { /* ... */ }

// Φ(τ,u,ν₀) = exp(C(τ) + D(τ)ν₀ − iu·x₀)  ← paper convention

}

public static class HestonNormalFromHeritage { // Path B — heritage, positive-i

public static double PriceOfCall(double F, double K, double tau, /* ... */) { /* ... */ }

// phi(u) = exp(cv + dv·v0 + i·u·forward), called with −u ← heritage convention

}

// Cross-check: |A − B| < 1e-10 on 25 randomised parameter sweeps.

// Sidani Table 1: reproduced at 5e-5 by BOTH paths.  Heritage vectors: 1e-9.

// Priority: explicit Version > AsOf-inferred > default (V2)

public static bool IsCoicopValidAsOf(string coicop, EcoicopVersion version)

=> coicop switch {

    "CP023" => version is V2 or V3,   // COICOP 2018 — from Feb 2026

    "CP022" => version is V1,          // COICOP 1999 — pre Feb 2026

    _       => true                    // era-independent

};

// Golden key format: {GEO}.HICP.{COICOP}.{BASE}

// e.g. EUR.HICP.XTOB.2015 — HICPxT Euro Area 2015 base



var idx = InflationIndex.Parse("EUR.HICP.XTOB.2015");

// idx.GoldenKey        = "EUR.HICP.XTOB.2015"

// idx.EurostatCoicop   = "TOT_X_TBC"

// idx.LegacySymbol     = "EUR.HICPXTOB.2015"

// Xlli pipeline: structured data → renderer → HTML

var doc  = XllAiLandingPageBuilder.Build(iconResolver);

var html = XlliHtmlRenderer.RenderLandingHtml(doc, new HtmlRenderOptions

{

Version = ComponentVersions.GetVersion("xllai-web"), // "6.4.12.2"

});

use rust_decimal_macros::dec;



// Exact decimal arithmetic — no float rounding

let result = dec!(0.1) + dec!(0.2);

assert_eq!(result, dec!(0.3)); // ✓ exact



// C# cross-validation:

// decimal r = 0.1m + 0.2m;

// Debug.Assert(r == 0.3m); // ✓ same result

// Render flow: XlliDocument → GPU render passes (no Chromium)

// ExportController::render_xlli() → XlliDocument

//   → render-gpu: walk sections

//     → DirectWrite glyphs + wgpu rectangles

//     → xll-secure-app window (air-gapped)

// Black-76 vega in one pass via Dual — no finite differences

let vol   = Dual::var(0.20);       // differentiate w.r.t. vol

let price = black76(f, k, t, vol, df, cp, &norm);

// price.v  = option price

// price.dv = vega (∂price/∂vol)

// Injectable NormDist — swap erfc, lookup table, or approximation

pub trait NormDist {

fn cdf(&self, x: f64) -> f64;

fn pdf(&self, x: f64) -> f64;

}



pub fn black76<N: NormDist>(

f: f64, k: f64, t: f64, vol: f64, df: f64, cp: i32, norm: &N,

) -> f64 {

let d1 = ((f/k).ln() + 0.5*vol*vol*t) / (vol*t.sqrt());

let d2 = d1 - vol * t.sqrt();

df * cp as f64 * (f * norm.cdf(cp as f64*d1) - k * norm.cdf(cp as f64*d2))

}

# Full deploy in one command

python xll-deploy.py xllai-web --slim



# Automatically:

# 1. dotnet publish → bin/

# 2. Copy accounts/ (LettuceEncrypt certs) from last good snapshot

# 3. sc.exe config svc-xllai-web binPath= <new exe>

# 4. Restart-Service svc-xllai-web

# 5. git commit to xll.ai.production

// xll-secure-app: zero Chromium, zero network stack

// xll-secure-preview: WebView2 utility for internal tooling

// Both share the same ExportController trait



pub trait ExportController {

fn render_html(&self, route: &str) -> String;

fn render_xlli(&self, route: &str) -> XlliDocument;

}

// WIT interface — typed, versioned, language-agnostic

interface core-math {

sqrt: func(x: f64) -> result<f64, math-error>;

exp:  func(x: f64) -> result<f64, math-error>;

ln:   func(x: f64) -> result<f64, math-error>;

erf:  func(x: f64) -> result<f64, math-error>;

phi:  func(x: f64) -> result<f64, math-error>;

}

// V4 split: each assembly has one job

// Contracts  — NanoTableModel, DocSection, NanoCodeBlock (pure data)

// Prism      — colour themes, CSS token maps

// Build      — NanoTableBuilder (fluent API)

// Render     — HTML, Skia, PDF renderers

// Export     — Export controllers, Navigator wiring

// SDK        — BidAskTable, SpreadMatrix, user-facing API

// HICP revision: compare vintages of the same index

// Base 2015 → Base 2025 rebasing handled automatically

// Flash estimate vs final release delta shown in NanoTable

// Export Controller Pattern — same controller, two hosts

[HttpGet("/riskevo-site/symbology/inflation")]

public ContentResult ServePage()           // ASP.NET Kestrel

=> new() { Content = BuildHtmlPage(), ... };



[NonAction]

public string RenderHtml(string route, bool lightTheme = false)

=> BuildHtmlPage(lightTheme);          // WPF WebView2 (no HTTP)

// V2 effective date — single source of truth

public static readonly DateOnly EcoicopV2EffectiveDate = new(2026, 2, 1);



// Tobacco code lookup — correct for any date

public static string TobaccoCoicopAsOf(DateOnly asOf) =>

asOf < EcoicopV2EffectiveDate ? "CP022" : "CP023";

// One document format drives every output surface

var doc = new XlliDocument {

Format  = "xlli",

Sections = [ new DocSection { Type = DocSectionType.Hero, ... } ],

Cards    = { ["kestrel-web"] = new XlliCard { ... } },

Css      = BuildThemeCss(),   // 6-theme CSS

Script   = BuildThemeJs(),    // dark/light + colour toggles

};

# solution.ai.toml — workspace declaration

[solution]

name    = "xll.ai.main"

version = "6.4.12"



[workspace]

members = ["src/Xll.Ai.NanoLibs", "src/Xll.Ai.Components", ...]



# cps.ai.toml — component identity

[component]

name     = "nano-math-autodiff"

version  = "6.4.12.1"

languages = ["csharp", "rust"]

// Tail-stable put pricing via erfc — avoids cancellation for deep OTM puts

public class ErfcNormDist : INormDist {

public double Cdf(double x) => 0.5 * Erfc(-x / Math.Sqrt(2));

public double Pdf(double x) => Math.Exp(-0.5*x*x) / Math.Sqrt(2*Math.PI);

}



// Same interface in Rust: pub trait NormDist { fn cdf(&self, x: f64) -> f64; }

// wasm-pack build → .wasm embedded in C# DLL as resource

// C# loads it at runtime — no file path, no deployment headache

var bytes  = GetType().Assembly.GetManifestResourceStream("nanotable_wasm.wasm");

var module = WasmModule.Load(bytes);

var result = module.Call("nanotable_render", jsonInput);

// JavaScript bridge — panels communicate via XLLQ bus

window.xllq.publish('model.assign', {

panelId: 'pricing-panel',

modelId: 'EUR.HICP.XTOB.2015',

asOf: '2026-01-31'

});



window.xllq.subscribe('model.loaded', (msg) => {

renderNanoTable(msg.data);

});

# image_toml_to_csproj.py — generates image DLL from TOML manifest

# 380+ images × 3 sizes = ~1100 embedded resources

# Catalogs: proglang, flags, eco, seasonal, ...



[[images]]

catalog = "proglang"

key     = "rust"

sizes   = [64, 96, 128]

source  = "images/ProgLanguage/rust.png"

// 5 contract layers — mirrors C++ heritage

pub trait IrsContract:   PricingContract { fn fixed_rate(&self) -> f64; }

pub trait BondContract:  PricingContract { fn coupon(&self) -> f64; }

pub trait SwaptionContract: PricingContract { fn expiry(&self) -> f64; }

pub trait InflationContract: PricingContract { fn index(&self) -> &str; }

// All: Result<f64, PricingError> — no panics, no NaN propagation

// SABR implied vol — Hagan et al. approximation

pub fn sabr_vol(f: f64, k: f64, t: f64, alpha: f64, beta: f64, rho: f64, nu: f64) -> f64 {

// Full Hagan formula — handles ATM, smile wings, and time decay

// Cross-validated against C++ reference to 1e-12 precision

}

# Oracle test vectors in TOML — same file drives C#, Rust, and JS tests

[[vectors]]

description = "Black-76 lognormal ATM call"

f    = 1.02

k    = 1.02

t    = 1.0

vol  = 0.20

df   = 0.98

cp   = 1

expected = 0.07797...  # identical across all three languages

# MathIR spec — one source, five languages

[function.black76_d1]

inputs  = ["f:f64", "k:f64", "t:f64", "vol:f64"]

formula = "( ln(f/k) + 0.5 * vol^2 * t ) / ( vol * sqrt(t) )"

# Emits: C#, Rust, C++, Python, JavaScript — all correct

// 16-metric Rustification score per model

pub struct AiRanking {

pub numerical_stability: f32,  // 0–1

pub precision_parity:    f32,  // bitwise match with C++ reference

pub test_coverage:       f32,  // fraction of test vectors passing

pub wasm_compatible:     bool, // no_std + no unsafe

pub edge_cases:          f32,  // ATM, ITM/OTM extremes, t→0

// ... 11 more metrics

}

# Eurostat TSV ingestion — handles old and new format

# Old format: freq,unit,coicop,geo (M,I15,CP00,AT)

# New format: unit,coicop,geo     (I15,CP00,AT)

# Both → canonical symbol: AT.CP00.2015

// NanoTable — server-side HTML, client-side themes

var model = new NanoTableBuilder()

.AddRow(["EUR", "HICP", "XTOB", "2015", "1.0234"])

.WithTheme(NanoTheme.DarkGreen)

.Build();

var html = NanoTableRenderer.RenderHtml(model);

// Black-76 lognormal with injectable NormDist

public static double Price(double f, double k, double t, double vol,

double df, int cp, INormDist norm)

{

double d1 = (Math.Log(f/k) + 0.5*vol*vol*t) / (vol*Math.Sqrt(t));

double d2 = d1 - vol * Math.Sqrt(t);

return df * cp * (f * norm.Cdf(cp*d1) - k * norm.Cdf(cp*d2));

}

# Three tiers, one platform

# Tier 1: Kestrel → public web (xll.ai, reflexlibs.ai)

# Tier 2: WebView2 → internal desktop (Navigator)

# Tier 3: Rust secure → air-gapped, edge AI, zero Chromium

// Rustification philosophy:

// No NaN propagation → Result<f64, PricingError>

// No exceptions      → explicit error handling

// No unsafe          → safe abstractions only

// No hidden state    → pure functions, injectable dependencies

// Bitwise parity     → same output as C++ reference

// C++ heritage — production since 2010

// Black-76 family: lognormal, Bachelier, shifted-lognormal

// SABR: full vol surface calibration (Hagan et al.)

// Inflation: HICP seasonality, ZC swap pricing, ECB curve

// All: deterministic, reproducible, trading-floor grade

double black76_lognormal(double f, double k, double t,

double vol, double df, int cp, const NormDist& norm);