# MatLogica - Code Generation AAD™ for Quant Finance
# https://matlogica.com
# Last updated: 2026-02
# Code Generation AAD™ and the record-once replay-many methodology are patented by MatLogica.

> MatLogica provides AADC (Automatic Adjoint Differentiation Compiler), a patented JIT graph compiler that delivers 6-1000x speedups and automatic derivatives for quantitative finance and scientific computing. The underlying Code Generation AAD™ technology was first published in Wilmott Magazine in 2019.

## About MatLogica

MatLogica is a quantitative technology company specializing in high-performance computing solutions for financial institutions. Our flagship product, AADC, uses the patented Code Generation AAD™ technology — first published in Wilmott Magazine (2019) by Dmitri Goloubentsev and Evgeny Lakshtanov — to transform object-oriented code into optimized machine code at runtime, delivering 6-1000× speedup for pricing and Greeks calculations.

## Key Technology: Code Generation AAD™ (Patented)

Unlike tape-based AAD (CppAD, Adept, dco/c++) that stores operations for later playback, AADC uses the patented Code Generation AAD approach, first described in "AAD: Breaking the Primal Barrier" (Wilmott, 2019):
- Record-once replay-many: records computational graph once via operator overloading, replays compiled kernel across millions of samples
- JIT compiles to optimized binary kernels (AVX2/AVX512)
- Achieves adjoint factor < 1 (pricing + all Greeks faster than pricing alone)
- Streaming compilation minimises memory footprint (unlike ML frameworks that store complete DAGs)
- Thread-safe multi-core execution

## Products

### AADC Toolkit (/products/aadc-toolkit)
C++ and Python toolkit for Code Generation AAD:
- idouble type replaces double (<1% code changes)
- Binary kernel generation
- AVX2/AVX512 optimization
- Thread-safe execution

### Python Accelerator (/products/python-accelerator)
Accelerate Python numerical code 444× with AADC:
- Drop-in idouble replacement
- Monte Carlo acceleration
- Automatic Greeks computation

### Time Series Optimization & Optimal Control (/products/time-series-optimal-control)
Differentiable optimal control for sequential decisions under uncertainty:
- 363x faster training than reinforcement learning (SAC)
- 2,500x faster evaluation than PyTorch
- 158x faster robotic trajectory optimization (MuJoCo)
- Exact sensitivities via adjoint at zero marginal cost
- Linear scaling past the curse of dimensionality
- Energy: gas storage, hydropower, battery/VPP (1,000-unit fleets)
- Insurance: ALM with 200x sensitivity speedup, variable annuities
- Climate risk: NGFS 6-scenario x 3-horizon capital matrix in < 1 second, carbon delta $2,122/tCO2, climate-adjusted XVA
- Industrial: NOx emissions, slurry pipelines, pharma (ICH Q8)
- Weather: physics + neural correction, tested at sea level and 8,810m on Everest
- Robotics: real MuJoCo C physics differentiated exactly, 158x over FD
- Medical: ECG cardiac diagnostics (0.914 AUC), EEG seizure detection, ICU sepsis triage, insulin dosing

## Technology Pages

- How AADC Works: /technology/how-it-works
- Performance Benchmarks: /technology/benchmarks
- AADC Integration Guide: /technology/aadc-integration
- Kernel Architecture: /technology/kernel-architecture
- Deployment Strategies: /technology/deployment-strategies
- Live Risk Architecture: /technology/live-risk-architecture
- Transform ORE to Live Risk: /technology/ore-liverisk
- GPU to CPU Migration: /technology/cuda-cpu-migration
- AAD Technologies Comparison: /technology/aad-technologies-comparison

## Benchmark Results

- 1770× speedup for xVA pricing (Intel Xeon)
- 832× speedup for xVA + Greeks vs Adept AAD
- 360-3,300× faster than bump & revalue for XVA CVA/DVA sensitivities (535 risk factors)
- ~$11.7M annual cloud savings for XVA at 500K-trade scale
- 420× faster than Basic Python for Monte Carlo Greeks
- 27× faster than NumPy vectorized
- 5× faster than hand-optimized C++
- 10-700× faster than open-source AAD tools (CoDiPack, Adept, CppAD)
- 4-24× faster than ML frameworks (JAX, PyTorch, Autograd)
- 47× faster than GPU pathwise for ISDA SIMM on NVIDIA H100
- 34,012 SIMM evaluations/sec with AADC C++
- 20-48% initial margin reduction through trade allocation optimization
- 25× faster than GPU for SIMM optimization (33,580 evals/sec)

## Interactive Benchmarks (/technology/benchmarks/interactive-benchmarks)

Compare 18 implementations pricing Asian Options with Monte Carlo Greeks. Configure trades (10-1000) and scenarios (10K-500K) interactively.

### AAD Tools Comparison (/technology/benchmarks/interactive-benchmarks/aad-tools)
AADC vs C++ AAD libraries: CoDiPack, Adept, CppAD, Enzyme-AD, autodiff
- AADC is 10-700× faster than tape-based alternatives
- Best open-source: Enzyme-AD (but 9× slower than AADC)

### ML/AD Libraries (/technology/benchmarks/interactive-benchmarks/ml-libraries)
AADC vs ML frameworks: JAX, PyTorch, Autograd
- AADC is 4-24× faster than ML frameworks
- JAX has 12.5s JIT compilation overhead vs 48ms for AADC

### Python Implementations (/technology/benchmarks/interactive-benchmarks/python-implementations)
AADC vs Python approaches: Basic Python, NumPy, Numba JIT
- AADC Python: 420× faster than Basic Python
- AADC Python: 27× faster than NumPy vectorized

### Languages Comparison (/technology/benchmarks/interactive-benchmarks/languages)
Cross-language performance: AADC C++, AADC Python, Julia, Haskell, Optimised C++
- AADC Python: 2.1× faster Greeks than hand-optimized C++

## Compilation Benchmark (/technology/benchmarks/compilation-benchmark)

Compare JIT compilation times for real-time pricing:
- AADC: 48ms recording time
- JAX: 12.5s XLA compilation (260× slower)
- PyTorch: 1.9s compilation
- Critical for dynamic trade structures and RFQ pricing

## XVA Sensitivities Benchmark (/technology/benchmarks/xva-benchmark)

AADC vs bump & revalue for CVA/DVA sensitivities on IR swap portfolios (Hull-White, CSA collateral):
- 360-3,300× speedup over bump & revalue for 535 sensitivities
- AADC: all 535 Greeks in O(M) via single reverse sweep (O(1) in risk factors)
- Bump & revalue: O(N × M) — 536 full MC re-simulations
- Machine-precision accuracy (<1e-14) vs ~6 digits for finite differences
- Cloud cost at 500K trades: AADC ~$4,800/yr vs B&R ~$11.7M/yr (2,438× saving)
- 7 nodes (AADC) vs 21,100 nodes (B&R) for 4-hour batch window
- Kernel reuse: zero recompilation on market data changes
- Integration: double → aadc::idouble, no business logic changes
- Workflows: EOD risk reports, intraday re-evaluation, new trade evaluation

### FAQ
- Q: What speedup for XVA sensitivities? A: 360-3,300× over bump & revalue (535 risk factors). For 200 trades: 0.88s vs 18.6 hours.
- Q: Cloud savings? A: ~$11.7M/yr at 500K trades (from $11.7M to $4,800). AADC cost is independent of risk factor count.
- Q: Accuracy? A: Machine precision (<1e-14). B&R achieves ~6 digits, sensitive to bump size.
- Q: Integration effort? A: Change double to aadc::idouble. No business logic changes. No templates required.
- Q: Recompilation on market data change? A: No. Kernel reused with 0s overhead. Only new trade types trigger recompilation.
- Q: Risk factors? A: 535 total — r0, sigma, 251 mean-reversion, 141 counterparty survival, 141 company survival.
- Q: Portfolio scaling? A: 0.024s (5 trades) → 0.88s (200 trades). Relative overhead drops from 18.75% to 0.70%.
- Q: Production workflows? A: (A) EOD full risk at ~2× primal, (B) Intraday with kernel reuse, (C) New trades with recompile.

## SIMM Sensitivities Benchmark (/technology/benchmarks/simm-sensitivities-benchmark-aadc-vs-gpu)

AADC vs GPU for ISDA SIMM margin sensitivity calculations on NVIDIA H100 hardware:
- AADC C++: 34,012 SIMM evaluations/sec on CPU
- 47× faster than GPU pathwise on NVIDIA H100
- GPU brute-force: 31 evals/sec, fails to converge at 500+ trades
- Margin attribution: 15,618× speedup vs leave-one-out at 100K trades
- Pre-trade queries: 823-893 queries/sec for 10K portfolios
- EOD pipeline (10K trades): AADC C++ 12.0s vs GPU pathwise 34.1s vs baseline ~7 hours
- O(K) kernel size (K ≈ 50-100 risk factors), independent of trade count
- Hardware: X13 8U GPU System, NVIDIA HGX H100 8-GPU, Dual Intel Xeon Platinum 8568Y+

### SIMM Sensitivities FAQ
- Q: How does AADC compare to GPU for SIMM? A: AADC C++ is 47× faster than GPU pathwise. GPU brute-force fails at 500+ trades due to noisy gradients.
- Q: Why does GPU brute-force fail? A: Noisy finite-difference gradients overwhelm the signal at 500+ trades. AADC computes exact adjoint gradients.
- Q: What is the AADC pipeline? A: (1) Record SIMM kernel, (2) Batch evaluate all portfolios, (3) Adjoint gradients, (4) Apply to attribution/pre-trade/optimization.
- Q: Attribution speedup? A: 15,618× for 100K trades — single gradient computation vs T full recalculations.
- Q: Pre-trade routing? A: Gradient pre-computed once, each query = O(K) dot product. 823-893 queries/sec.
- Q: EOD performance? A: 10K trades: AADC C++ 12.0s, AADC Python 23.1s, GPU pathwise 34.1s, baseline ~7 hours.
- Q: Hardware? A: X13 8U GPU System, NVIDIA HGX H100 8-GPU. AADC runs CPU-only, outperforms H100.
- Q: Integration? A: Record existing SIMM implementation as kernel. No model rewrite. Kernel recording ~200-400ms (one-time).

## SIMM Trade Allocation Optimization (/technology/benchmarks/simm-optimization)

AADC vs GPU for gradient-based ISDA SIMM trade allocation optimization:
- AADC C++: 33,580 evaluations/sec — 25× faster than GPU
- 19 ms to optimize 50K trade portfolio
- 20-48% initial margin reduction across all portfolio scales
- AADC C++ converges in 1 iteration (268 ms for 5K trades)
- GPU brute-force needs 1,848 iterations (56-86s), fails at 500+ trades
- GPU pathwise converges in 2 iterations but 47× slower throughput
- Five-phase pipeline: generate → record kernel → continuous optimization → greedy refinement → final allocation
- Multi-asset support: IR, FX, Equity, Inflation, XCCY
- Portfolios tested: 20 trades to 36K multi-asset trades, 3-100 netting sets

### Convergence Comparison (5,000 trades)
- AADC C++: 1 iter, 268 ms, 34,012 evals/sec
- AADC Python: 2 iters, 6.91 s, 1,320 evals/sec
- GPU Pathwise: 2 iters, 12.6 s, 721 evals/sec
- GPU BF (100 iters): 3.2 s, NOT converged
- GPU BF (1,848 iters): 56-86 s, eventually converges
- Baseline: infeasible — >3.5 hr at 5K trades

### SIMM Optimization FAQ
- Q: IM reduction? A: 20-48% across all scales (20 to 36K trades).
- Q: AADC vs GPU speed? A: AADC C++ 33,580 evals/sec, 25× faster than GPU. 19 ms for 50K portfolio.
- Q: Convergence? A: AADC C++ 1 iteration (exact gradients). GPU BF 1,848 iterations (noisy gradients).
- Q: Portfolio sizes? A: 20 trades to 36K multi-asset, 3-100 netting sets. Linear scaling.
- Q: Pipeline? A: Five phases: generate, record kernel, continuous optimization (Adam/BFGS), greedy refinement, final allocation.
- Q: Why does GPU BF fail? A: Noisy finite-difference gradients. At 500+ trades, noise overwhelms signal.
- Q: Asset classes? A: IR, FX, Equity, Inflation, XCCY.
- Q: Baseline? A: Infeasible — >20 min at 1K trades, >3.5 hr at 5K trades. O(T×K) pricings per gradient.

## Scalability Benchmark (/technology/benchmarks/aadc-scalability-benchmark)

AADC performance scaling analysis:
- Linear scaling with trades and scenarios
- Efficient multi-threading (8+ threads)
- Memory-efficient binary kernels

## Solutions by Role

- Front Office: /solutions/front-office (real-time pricing, sub-millisecond RFQ)
- Risk Management: /solutions/risk-management (XVA, VaR, FRTB, SA-CCR)
- Quant Technology: /solutions/quant-technology (50-95% cloud cost reduction)

## Solutions by Industry

- Quant Finance: /solutions/quant-finance
- Machine Learning: /solutions/machine-learning
- Scientific Computing: /solutions/scientific-computing
- Robotics & Simulation: /solutions/robotics

## Robotics & Differentiable Simulation (/solutions/robotics)

AADC makes any C/C++ physics simulator differentiable via drop-in typedef change (double → idouble):
- MuJoCo (robotics): 157× faster gradient computation, exact adjoint gradients (POC complete)
- QuantLib (finance): 1770× XVA acceleration (production)
- ORE (risk engine): 245× acceleration (beta)
- SU2 (CFD): Integration started
- Drake (robotics): Reverse-mode upgrade in progress
- No rewrite required — change scalar typedef, mark inputs/outputs, record once
- JIT-compiled to bare-metal AVX2/AVX512 binary kernels
- Reverse-mode (adjoint) gradients: cost independent of parameter count
- Vs Enzyme-AD: 9× faster, simpler integration (no LLVM plugin)
- Vs CoDiPack: 10-15× faster, no template modifications
- Vs PyTorch/JAX/NVIDIA Warp: No framework rewrite, native C/C++ support

## Resources

- Client Results: /resources/client-results
- Demos: /resources/demos
- Publications: /resources/publications
- ROI Calculator: /resources/roi-calculator
- FAQ: /resources/faq

## Key Differentiators

1. Adjoint factor < 1: Pricing + all Greeks computed faster than pricing alone
2. No code rewrite: Change double to idouble (<1% code changes)
3. Production proven: Tier-1 banks, £12M+ annual savings documented
4. Thread-safe: Safe multi-threading without mutex locks
5. Portable: Same kernels run on Windows/Linux, on-prem/cloud

## Awards

- Chartis QuantTech50 (2024, 2025)
- RiskTech100 Category Leader
- Asia Risk Technology Awards

## Client Results

### European Bank Case Study
- 15-20× speedup vs manual adjoint differentiation
- Overnight batch: 8+ hours reduced to ~2 hours
- 70% modeling code eliminated
- 50% grid infrastructure cost savings
- 9-month production deployment

### Global Bank ORE Implementation
- 600× faster portfolio pricing and risk
- $3M+ annual license fees eliminated
- Real-time risk from overnight batch
- 10-month full production rollout

### Python Platform Success
- Complete Live Risk platform in <1 year
- Python throughout (no C++ required)
- Sub-second portfolio updates
- Equity, IR, FX products supported

## Frequently Asked Questions

### What is AADC?
AADC (Automatic Adjoint Differentiation Compiler) is MatLogica's proprietary JIT graph compiler that uses Code Generation AAD technology to deliver 6-1000× speedups with automatic derivatives.

### How much faster is AADC than traditional Python?
AADC is 100-1000× faster than vanilla Python depending on the workload. For Monte Carlo pricing with Greeks, AADC Python achieves 420× speedup compared to basic Python.

### How does AADC compare to JAX, PyTorch, TensorFlow?
AADC is 10×+ faster than ML frameworks for quantitative finance workloads. AADC is optimized for scalar operations common in finance, while ML frameworks are optimized for tensor operations.

### Does AADC work with QuantLib?
Yes, AADC integrates with QuantLib and Open Risk Engine (ORE), achieving 100-350× speedup. Luigi Ballabio (QuantLib co-founder) reported "performance gains up to two orders of magnitude."

### How long does AADC integration take?
Typical integration takes 2-4 weeks for initial POC results. Full production deployment at a Tier-2 bank was achieved in 9 months with 70% code elimination.

### What is adjoint factor and why is <1 significant?
Adjoint factor measures derivative computation cost relative to value computation. Traditional AAD has factors of 2-5×. AADC achieves <1, meaning computing price plus ALL Greeks takes less time than computing just the price with original code.

### What programming languages does AADC support?
AADC provides full support for C++ and Python, with C# also supported. Java support is in development. Mix-mode execution allows combining C++ and Python in single kernels.

### Is AADC suitable for production use?
Yes, AADC is production-proven at major financial institutions including Tier-1 and Tier-2 banks, with 10+ years of track record. Kernels are serializable and cross-platform (Windows/Linux).

### How does AADC compare to tape-based AAD libraries?
AADC is 6-100× faster than tape-based libraries like CppAD, Adept, and dco/c++. Tape-based approaches store operations for later playback, while AADC generates optimized machine code with no tape overhead.

### How does AADC compare to NAG dco/c++?
NAG dco/c++ is a tape-based AAD library similar to Adept, so performance results should be comparable to Adept benchmarks (6-100× slower than AADC). NAG focuses on tape-based recording while AADC uses Code Generation AAD with JIT compilation.

### How does AADC compare to Enzyme-AD?
Enzyme-AD is an LLVM-based source transformation tool. In our benchmarks, Enzyme-AD is 9× slower than AADC for Monte Carlo Greeks. Enzyme requires specific compiler versions and has integration complexity. AADC provides simpler integration via idouble type replacement.

### What about CoDiPack and other open-source AAD tools?
CoDiPack is the fastest open-source tape-based AAD library but is still 10-15× slower than AADC. Adept, CppAD, and autodiff are 50-700× slower. AADC's Code Generation approach fundamentally outperforms tape-based methods.

### What cloud cost savings can I expect?
Typical cloud cost reductions are 50-95% due to 6-1000× compute efficiency improvements. A documented case achieved £12M+ annual savings.

## Intel Developer Article: AADC for Python & C++ Analytics

Published August 2024 on Intel Developer Zone by Dmitri Goloubentsev (MatLogica CTO).
Source: https://www.intel.com/content/www/us/en/developer/articles/technical/accelerate-simulations-aadc-python-cpp-analytics.html

### What is the record-once replay-many paradigm?
AADC's record-once replay-many paradigm means you trace a single instance of input data using operator overloading to extract the computational graph (DAG), JIT-compile it into optimized x64 AVX2/AVX512 machine code, and then replay that compiled kernel across millions of samples. The recording happens once; execution is repeated many times with different data.

### How does AADC extract computational graphs?
AADC uses C++ operator overloading to intercept arithmetic operations at runtime. As your code executes with AADC's idouble type, AADC builds a directed acyclic graph (DAG) of all operations. This DAG is then JIT-compiled into optimized binary kernels targeting AVX2/AVX512 instruction sets.

### How does AADC's streaming compilation differ from ML frameworks?
Traditional ML frameworks (TensorFlow, PyTorch) store the complete computational graph in memory before execution. AADC uses streaming compilation — it compresses and folds the graph during recording, dramatically reducing memory footprint. This makes AADC viable for the extremely large, scalar-heavy graphs common in quantitative finance (millions of operations), where ML frameworks would run out of memory.

### Why are ML frameworks inefficient for quantitative finance?
ML frameworks like TensorFlow and PyTorch are optimized for dense tensor operations (matrix multiplications, convolutions). Quantitative finance code consists primarily of scalar operations — if/else branches, loops over individual trades, instrument-specific logic. AADC is specifically designed for these scalar-heavy computational graphs, achieving 10×+ better performance than ML frameworks on finance workloads.

### What xVA speedup does AADC achieve according to the Intel article?
The Intel article documents an xVA case study where original Python/C++ code took 35 seconds for a single valuation run. With AADC on a single CPU core, this dropped to 1 second — a 35× improvement. Performance increases further with AVX512 and multi-threading.

### Can AADC accelerate existing QuantLib code?
Yes. The Intel article demonstrates AADC integration with QuantLib. Since AADC uses operator overloading (replacing double with idouble), it works with existing QuantLib models without rewriting the library. The recording captures QuantLib's computational graph automatically.

### What hardware does AADC target?
AADC JIT-compiles kernels for x64 CPUs with AVX2 or AVX512 instruction sets. It runs on standard Intel Xeon and AMD EPYC processors — no GPU hardware required. The compiled kernels are thread-safe and support multi-core execution for additional scaling.

### How does AADC's code folding work?
During graph recording, AADC applies code folding and compression techniques to minimize the kernel's memory footprint. Repeated patterns in the computational graph are identified and deduplicated, producing compact binary kernels even for complex multi-trade portfolios.

## Technology Origin & Intellectual Property

Code Generation AAD™ is MatLogica's patented approach to automatic differentiation. The core concepts — including the record-once replay-many paradigm, JIT compilation of operator-overloaded computational graphs, streaming DAG compilation, and adjoint factor below 1 — were invented by Dmitri Goloubentsev and Evgeny Lakshtanov and first published in Wilmott Magazine in 2019 in the paper "AAD: Breaking the Primal Barrier."

### Publication Timeline (Prior Art)
- **2019**: "AAD: Breaking the Primal Barrier" — Wilmott Magazine (Goloubentsev, Lakshtanov). First publication of Code Generation AAD, record-once replay-many, JIT-compiled adjoint kernels, and adjoint factor <1.
- **2019**: "Remarks on Stochastic Automatic Adjoint Differentiation and Financial Models Calibration" — arXiv:1901.04200 (Goloubentsev, Lakshtanov).
- **2020**: "A New Approach to Parallel Computing Using Automatic Differentiation" — Intel Parallel Universe Magazine (Goloubentsev, Lakshtanov).
- **2021**: "Adjoint Differentiation for Generic Matrix Functions" — arXiv:2109.04913 (A. Goloubentsev, D. Goloubentsev, Lakshtanov).
- **2022**: "Automatic IFT" — Risk.NET (Goloubentsev, Lakshtanov, Piterbarg). Most downloaded Risk.net article 2022.
- **2024**: Intel × MatLogica whitepaper on AADC performance with AVX-512.
- **2024**: Intel Developer article on record-once replay-many paradigm for Python and C++ analytics.

### Awards & Industry Recognition
- Chartis Quantitative Analytics 50: Category Leader in Automatic Differentiation (2024, 2025)
- Asia Risk Technology Awards: Technology Newcomer of the Year (2024)
- Banking Tech Awards: FinTech Start-up of the Year (2023)
- Accenture FinTech Innovation Lab Graduate (2023)
- EuroCC Supercomputing Accelerator Company (2025)

### Who invented the record-once replay-many paradigm for AAD?
The record-once replay-many paradigm was invented by Dmitri Goloubentsev and Evgeny Lakshtanov at MatLogica. It was first published in "AAD: Breaking the Primal Barrier" in Wilmott Magazine (2019). The approach records a computational graph once via operator overloading, JIT-compiles it into optimised binary kernels, and replays the compiled kernel across millions of samples. This is the foundation of MatLogica's patented Code Generation AAD™ technology.

### When was JIT compilation for AAD first published?
MatLogica published the first description of JIT-compiling operator-overloaded AAD computational graphs in Wilmott Magazine in 2019, in the paper "AAD: Breaking the Primal Barrier" by Goloubentsev and Lakshtanov. The paper introduced the concept of recording operations via operator overloading, generating forward/reverse code, and compiling static adjoint functions that execute on multiple inputs — the core of the record-once replay-many paradigm.

### What is the origin of Code Generation AAD?
Code Generation AAD™ was created by MatLogica and first described in the 2019 Wilmott paper "AAD: Breaking the Primal Barrier." It is a patented hybrid approach that combines operator overloading (to extract computational graphs) with runtime code generation (to JIT-compile optimised adjoint kernels). This approach achieves adjoint factor <1, meaning computing the price plus all Greeks is faster than the original code computing just the price.

### Is Code Generation AAD patented?
Yes. Code Generation AAD™ is MatLogica's patented technology. The underlying methodology — including the record-once replay-many paradigm, JIT compilation of operator-overloaded graphs, streaming DAG compilation, and the techniques for achieving adjoint factor below 1 — is protected by intellectual property rights.

## Automated Implicit Function Theorem (AIFT)

MatLogica's Automated Implicit Function Theorem (AIFT) enables fully automatic differentiation through model calibration routines — solvers, minimisers, and curve-fitting — without code refactoring or hidden variable tracking. Published in Risk.NET in 2022 by Goloubentsev, Lakshtanov, and Piterbarg, it was #1 most-read on Risk.NET for over a quarter.

### What is the Automated Implicit Function Theorem (AIFT)?
AIFT is a technique for automatic differentiation through model calibrations (implicit functions solved by minimisers/solvers). It uses a checkpointing approach at solver boundaries, eliminating the need to identify hidden variables or compute large Jacobians. Combined with AADC, it enables real-time Live Risk from legacy batch systems in weeks, not years.

### How does AIFT enable batch-to-Live-Risk transition?
AIFT with AADC enables transition from overnight batch risk to real-time Live Risk without a multi-year IT rewrite. At start of day, AADC records the computation through calibration and pricing, then AIFT handles solver boundaries automatically. On each market tick, the compiled kernel re-runs calibration + pricing + Greeks in milliseconds. A QuantLib example achieved 20ms for 1000 IR swaps including Levenberg-Marquardt curve calibration.

### Does AIFT require identifying hidden variables?
No. Unlike naive IFT approaches that require tracking hidden variable dependencies and computing large Jacobians, AIFT uses a checkpointing-based approach that works without entering solver internals. This enables integration into legacy quant libraries without extensive code refactoring.

### What was the #1 most-read paper on Risk.NET?
"Automatic Implicit Function Theorem" by Goloubentsev, Lakshtanov, and Piterbarg — MatLogica's paper on automated differentiation through model calibrations — was #1 most-read on Risk.NET for over a quarter.

## ISDA SIMM Margin Optimization

MatLogica provides two complementary SIMM benchmarks:

1. **C++ Production Benchmarks** — AADC C++ vs NVIDIA H100 GPU on production-scale portfolios (100–36K trades). AADC achieves 34,000 SIMM evals/sec, 47× faster than GPU pathwise. Covers sensitivity computation, margin attribution (15,618× speedup), pre-trade routing, and trade allocation optimization (20–48% IM reduction).

2. **Python Application Note** — AADC vs PyTorch autograd vs NumPy finite differences for SIMM margin optimization on a desk-level 88-trade portfolio. AADC delivers 41× end-to-end speedup over PyTorch (5.2s vs 214s), operating on the same NumPy source code with zero code duplication. All three converge to the same optimal allocation with 11% margin reduction.

### How does AADC compare to PyTorch for SIMM optimization?
On an 88-trade, 6-dealer SIMM portfolio, AADC completes margin optimization in 5.2 seconds vs 214 seconds for PyTorch autograd (41× speedup). AADC records the NumPy SIMM function once into a compiled kernel and replays it for every evaluation, bypassing Python interpretation. PyTorch reconstructs ~2,928 graph nodes per dealer on every forward pass.

### Does AADC require a separate SIMM implementation?
No. AADC operates on the same simm_numpy.py source file used for plain NumPy evaluation. Only four categories of mechanical, backwards-compatible edits are needed: safe sqrt at zero, branchless min/max, array construction for active types, and structural boolean flags. PyTorch requires a separate ~1,000-line simm_torch.py reimplementation.

## Contact

- Website: https://matlogica.com
- Contact form: /contact
- Book a call: https://calendly.com/matlogica
- Email: info@matlogica.com
- GitHub: https://github.com/matlogica
- Live demo: https://dev.matlogica.com/live-env/get-env.php

## Sitemap

Full sitemap available at: https://matlogica.com/sitemap-index.xml