Lexifi.com > Products > Quantitative Analysts

Quantitative Analysts

Quantitative analysts act on many fronts, from implementing financial models and calibration algorithms, to linking contract definitions with model implementations, calculating risk measures, and integrating pricing and risk management functionality with core trading systems. These tasks raise significant process, system, and communication challenges.

The efforts of quantitative analysts are often hampered by an inadequate representation of financial contracts.

In the past decade, many research teams have developed payoff languages that define a product's meaning in the context of pricing. For example, in a Monte Carlo pricing context, a product is a program—a "machine"—that takes a simulated market scenario as input and returns the list of cash flows induced by the scenario, on the correct dates. Products are mapped from inception into the world of valuation algorithms: cash flows, options, and other potential events are expressed in a way that is understandable by the stochastic machinery used to value financial contracts. This mapping implies a loss of information and causes potentially severe limitations:

existing modeling environments do not always facilitate pricing code reuse, and sometimes require new code even for minor product variations. This situation slows down the model development and deployment process, and creates a maintenance burden on the quantitative analysis team who needs to maintain and document dozens of programs that may differ only slightly;
the evolving structure of a contract, as it progresses in its life cycle, is challenging to represent;
pricing is inefficient as the contract's history must be replayed for each Monte Carlo path and the changing dimension of a valuation problem—for example when underlyings are removed from a basket, based on predefined rules—is unlikely to be correctly reflected;
pricing model implementers must deal with market conventions and business rules instead of focusing exclusively on the mathematics of valuation;
payoff languages offer limited flexibility to accommodate changes in models, numerical implementations, and contract execution rules—e.g., to simulate future exercise decisions;
back office reconciliation is impossible as payoffs are defined from inception to generate a series of numerical calculation steps and therefore do not distinguish between physically-settled and cash-settled options or automatic and discretionary option exercises;
event planning is cumbersome as payoff code does not lend itself to introspection: a comprehensive list of future events can be very difficult, if not impossible, to extract;
in order to avoid double counting, payoff language programmers must be careful to exclude cash flows that hit the cash balance from pricing.

After LexiFi

Key Features

Precise and Exhaustive Product Definitions. LexiFi enables users to precisely and exhaustively describe sophisticated financial products, based on any type and combination of underlyings, using a limited set of core constructs.
Compile-Time Error Detection. Errors in financial product design are detected at the earliest possible stage. LexiFi checks types, date consistency, and other elements in an instantaneous compilation process: all contract code must pass type-safety and time-related verifications before it is allowed to execute.
Contract and Process Independence. LexiFi describes what contracts "are" independently from what they "do," and the resulting specification is used to derive pricing, simulation, operational management, and other processing capabilities, with the guarantee that the behavior across these environments will be consistent. The fact that a single program may manipulate all MLFi contract definitions, without exception, means that processes do not need to be reprogrammed each time a new financial instrument is introduced.
Monte Carlo and PDE Pricing Code Generation. Contracts are valued with the appropriate financial model and discrete numerical method—typically Monte Carlo or PDE. LexiFi automates the specification of how a contract's definition should drive the sequence of numerical calculation steps. For each contract, LexiFi generates specialized pricing code that is then compiled and run natively to perform the valuation.
Custom Models and Closed Forms. LexiFi's model specifications recognize contracts—or, more importantly, contract sub-parts—that should be priced with an optimized algorithm or a closed form instead of calling the full succession of default numerical calculation steps. Armed with a choice of models and numerical methods, users may exploit the performance gains afforded by optimized pricing algorithms.
Compile-Time Verification of Model's Capabilities. In order to avoid run-time errors, LexiFi checks at compile time, before generating pricing code and before calling a model's implementation, that a contract is eligible for pricing with the chosen model. In particular, LexiFi verifies that the contract's currencies and underlyings are supported by the model's implementation.

Reference Model Implementations with Source Code. LexiFi users can get started immediately with a large collection of out-of-the-box, Monte Carlo and PDE implementations of industry-standard interest rate and equity models, all delivered with source code.

Industry-Standard Models

LexiFi's Monte Carlo framework automatically generates multi-dimensional pricing routines. The user-definable output includes price, Greeks, cash flow distribution, pricing error estimates, and runtimes.

Click image to enlarge.

Scientific Libraries. In addition to providing Monte Carlo and PDE pricing model implementations, LexiFi is delivered with bindings to the GNU Scientific Library (GSL), a robust scientific library written in C. With GSL bindings, LexiFi users are immediately productive with sophisticated and field-tested routines, which enable the development of fast, accurate, and stable valuation algorithms.
LexiFi also comprises a native linear algebra library, delivered in source code. Additionally, bindings to ATLAS, BLAS, COIN, DIRECT and LAPACK are available.
Maximal Sharing. Maximal sharing significantly improves Monte Carlo pricing code in terms of size, speed, and memory usage. More importantly, maximal sharing enables the efficient pricing of multiple contracts in a single pass. LexiFi automatically detects and exploits contract similarities and ensures that all prices are calculated along the same random trajectories.
Maximal sharing improves performance for a number of applications that involve, or may be described in terms of, the valuation of a portfolio:
- Pricing Sheets. The task of calculating a pricing sheet in which contract terms are altered, using a range of possible values, is equivalent to valuing a portfolio of similar contracts. LexiFi treats a set of contracts as one large contract for valuation purposes and identifies shared contract clauses to avoid duplicate calculations.
- Sensitivity Measures. In the case of simple multi-dimensional Black-Scholes-style models, maximal sharing dramatically accelerates delta calculations and the generation of spot sensitivity analyses. One can show that the completion of such tasks is equivalent to pricing slightly different contracts on the same paths.

Benefits

LexiFi's ability to describe what contracts "are" independently from what they "do," combined with pre-packaged valuation capabilities, simplifies the job of quantitative analysts and facilitates the dissemination of their work throughout the organization:

Streamlined Software Process. LexiFi rationalizes the development, validation, deployment, and maintenance of valuation algorithms:
- Market Conventions Resolved in Contract Definitions. MLFi contract definitions resolve all market conventions. Model developers can focus exclusively on the mathematics of valuation.
- Limited Number of Pricing Primitives. Financial engineers only need to implement a limited number of valuation primitives. For example, the implementation of a Monte Carlo algorithm requires the following functions: (i) for each path, begin a trajectory, go to the following date on which a fixing is required, get the value of the underlying, record the cash flows derived from the contract, end the trajectory and (ii) a result function that calculates, for example, the average net present value of recorded cash flows. The pricing code derived automatically from MLFi contract definitions drives the calls to pricing primitives.
- Rapid Prototyping and Staged Deployment of New Valuation Algorithms. MLFi may serve as a shared contract description language that generates pricing code to drive internally developed or commercially available pricing libraries. MLFi can drive both prototyping and production valuation libraries. For example, in order to rapidly respond to a customer inquiry, quantitative analysts may initially want to generate prototype code in the language of their choice. After the transaction is consummated, MLFi may generate production code in C in order to integrate the new product in the trading system. The MLFi compiler's ability to output different flavors of valuation code from the same product definition eases the programming and maintenance workload of financial engineers, and allows them to spend more time on value-added tasks such as deepening their understanding of exotic derivatives.
- Centralized Software Development Process. LexiFi's architecture facilitates the development, reuse, and maintenance of shared contract and model libraries. In particular, LexiFi avoids the dissemination of code inherent in spreadsheet solutions.
Robust Model Vetting through Method and Code Redundancy. LexiFi's ability to value the same contract with different models enables a number of model verification strategies:
- Comparison of Closed Forms and Numerical Methods. When a contract admits a closed form for a given model, users may easily confront numerical and closed form results.
- Comparison of Financial Models. Users may also compare implementations of different financial models.
- Implementation in Several Programming Languages. Model errors may be minimized by implementing the same model and the same numerical method in different programming languages. LexiFi delivers a collection of models implemented both in MLFi and in C.
- Choice of Scientific Library. As described above, MLFi is interfaced with a number of proven scientific libraries. Users may switch scientific library by modifying a single parameter in many of LexiFi's model implementations. This provides an additional means of validating valuation algorithms.
Improved Communication Inside and Outside the Firm. LexiFi's formal product description and contract exploration tools improve communication between parties: they help reduce the time needed to explain the features of exotic products and help to "debug" natural language documents.