CPPI Dr. Jörg Kienitz Treasury OTC Derivatives – Head of Quantitative Analysis

1. CPPIDr. Jörg KienitzTreasury OTC Derivatives – Head of Quantitative Analysis March 2007

2. CPPI – The Basics CPPI is the abbrevation for Constant Proportion Portfolio Insurance The CPPI mechanism is a rules-based trading strategy. It seeks to maximise returns by way of leveraged exposure to a (portfolio) of risky asset(s) and providing a principal protection. This takes place in certain risk thresholds. The risks are known as gap risk. The are many modifications of the basic CPPI rules around.

3. CPPI – Vocabulary Bond Floor The value of a Zerobond with the same time to maturity as the CPPI strategy. Could also be a coupon bearing bond. Cushion The cushion is the difference of the Bond Floor and the current value of the CPPI insured portfolio Leverage Factor (Multiplier) The LF is the factor multiplied with the cushion to give the possible amount to be invested in the risky assets. It represents the overnight risk inherent in the risky assets. Protection Level This is the amount of principal which should be protected. In classical CPPI the PL = 100%

4. CPPI – Vocabulary Maximum Exposure The ME of the CPPI is the maximum level to which the capital is invested into the risky assets Minimum Exposure The ME of the CPPI is the minimum level to which the capital is invested into the risky asset. For classical CPPI the ME = 0. Lock In The Lock-In mechanism allows to lock in an upside already achieved during the lifetime of the CPPI Deleverage Deleverage is the event occuring if Cushion = 0. Then the portfolio is only worth the BF

5. CPPI – CPPI Mechanics Cushion Principal Protection Reserve

6. CPPI – CPPI Full Deleverage Time of Deleverage

7. CPPI – Risky Assets Lock In Event

8. CPPI – With Coupons To achieve periodic payments the basic CPPI strategy could be modified to pay (half-) yearly coupons linked to LIBOR, e.g. LIBOR + 50 bp Increases the risk of deleveraging, since one takes money out which decreases the cushion periodically! The coupon is not guaranteed, e.g. would only be paid if the strategy would not deleverage. A new risk arises, namely coupon shortfall In our CPPI setting we examine Deleverage Probability, Coupon Shortfall Probability and Return

9. CPPI – Risky Assets • The CPPI technique has been successfully applied to numerous asset classes. • Credit • Equity • Funds • Fixed Income • The observed distributions for each asset class can be considerably different, as for example

10. CPPI – Baskets of Risky Assets For real applications we consider a basket of risky assets, e.g. funds. This allows to use correlation effects to increase the overall return and to reduce deleverage as well as coupon shorfall probability.

11. CPPI – Our Approach • To Do • Determine the universe of risky assets (mainly qualitative) • Analysis of the universe using methods from time series analysis (mean, volatility, skew, kurtosis, correlation, etc.) • Asset Allocation Approach to determine the efficient frontier • Simulate the CPPI Mechanism for „optimal“ portfolios • The Simplest Setting • Assume a Gaussian world and determine the mean vector and the covariance matrix • Compute the Markowitz efficient frontier • Run a one-factor simulation along the efficient frontier using • Mean basket = sum basket const • Variance basket = sum cov(basket const, basket const)

12. CPPI „optimal“ portfolio CPPI – The Process Simulate Stochastic Process (FX, Rate, Fund) Compute Market Effects Compute CPPI Summarise Distribution Deleverage Probability Coupon ShortFall Probability Output Statistics

13. CPPI – An Extended Approach • Extend the Models to cover a bright range of asset classes • Since there are many asset classes involved the Gaussian hypothesis is too restrictive • -> Use complex processes (e.g. NIG (Normal Inverse Gaussian) or VG ( Variance Gamma)) • Compute the efficient frontier • -> Optimization is complex • Therefore • We need a method to compute relevant figures from time series data • We need a method to compute the efficient frontier • We need a method to simulate fairly complex multidimensional processes • For creating optimization data • For simulating the CPPI strategy

14. Tools • Time Series Analysis • Methods to determine figures from given historic data • Optimization • What is the best suited characterisation of risk? • Simulation • Flexible, robust Monte Carlo Engine

15. Time Series Analysis To use more complex stochastic processes we must be able to extract the relevant data to determine the processes parameters out of data. For Geometric Brownian motion this can be done by computing the mean and the covariance structure using either time series data (for example if no quoted option data is available) or quoted prices (if available). Therefore, we have to investigate for methods to compute the necessary parameters. Our findings suggest that it is possible for classes of Lévy processes such as variance gamma or normal inverse gaussian. Use [P 04] as starting point

16. Time Series Analysis We consider the class of generalized hyperbolic distributions, i.e. processes which can be written as With N a standard multivariate normal, W is a positive random variable independent of N and A is a dxk matrix.  and  are vectors. In fact one could show Both models allow the derivation of parameters out of time series data as well as quoted option prices.

17. Monte Carlo Implementation • Once having the necessary data at hand we need to model the evolution of paths in the considered models. To this end we1 have developed a bunch of loosely coupled classes for simluation purposes: • Random Number Generator • Distributions • Finite Difference Schemes for SDE Discretization • PayOffs (The CPPI can be modelled as a path-dependent PayOff • Risk Figures • Regression • … 1 joined work with Daniel Duffy from Datasim

18. MC Output MC Director MC Option MC Stats MC PayOff (Factory) MC Path Generator (Mediator) MC Mesher MC Random (Template) FDM (Visitor) SDE Monte Carlo Implementation – Big Picture

19. MC Path Generator (Mediator) MC Mesher Equidistant Numerical Scheme FDM (Visitor) Dates specific … Euler SDE Predictor Corrector Milstein L/L L/NL NL/L Exact M1 M1 M1 M1 … … … … … Monte Carlo Implementation – Path Generation NL/NL

20. MC Random (Template) Random Generator Ran3 Distribution Mersenne Twister Sobol … Normal Poisson Multi Normal … Monte Carlo Implementation – Random Numbers

21. MC Option MC PayOff (Factory) One Asset Non Path Dependent One Asset Path Dependent Multi Asset Non Path Dependent Multi Asset Path Dependent Call Barrier Spread Altiplano Asian Quanto Lookback Spread Lookback Basket CPPI … … … … Monte Carlo Implementation - PayOffs

22. Monte Carlo Implementation – Design Patterns • We want to achieve efficiency, performance, accuracy, maintainability and interoperability. • Therefore we use C++ and several design patterns among them are:2 • Factory • Define an interface for creating an object, but let derived classes decide which class to instantiate. The pattern is may better known as virtual construction because it allows to eliminate the need to bind specific classes into the code • Property Pattern • Creating C++ classes means also to declare data and member functions that operate on data which in general is private. This implies that set/get functionality must be implemented for each object and hard coded data remain a compile-time phenomenom. • Taking this into account we model such data as property sets or idioms which are template classes with named member data. The member data can in general be heterogenous. This means for example double, vector, classes, etc. 2For a description of many more design patterns see [D 04] and [D 05]. For the design patterns used for Monte Carlo see [DK 07]

23. Monte Carlo Implementation – Example: PayOff Factory The CPPI can be seen as strategy depending on the taken path of the underlying. Therefore, we will model it as a (path dependent) PayOff. We will describe our setting in which the CPPI can be handled.

24. Monte Carlo Implementation – Example: PayOff The Base Class template<class D, class T> class PayOff { //Base class from which all payoff classes inherit //Any instance has to define operator(), clone and the destructor public: PayOff(){}; // Constructor virtual double operator()(D Discount, T Spot) const=0; // Price operators given discounts and Spots virtual PayOff<D, T>* clone() const=0; // clone virtual ~PayOff(){} // Destructor private: };

25. Monte Carlo Implementation – PayOff Classes In Detail CPPI for one asset; For multiple assets just use your favourite matrix class! Construction with given Property Set class PayOffCPPI : public PayOff<double, std::vector<double> > { public: PayOffCPPI(); PayOffCPPI(const SimplePropertySet<string, double>& pset); virtual double operator()(double Discount, std::vector<double> Spot) const; virtual double PayOff_Value(double Discount, std::vector<double> Spot) const; virtual PayOff<double, std::vector<double> >* clone() const; virtual ~PayOffCPPI(){} SimplePropertySet<string, double> PayOffCPPI_Properties; private: }; For one realized path the value from CPPI strategy is computed All CPPI parameters are stored as properties gathered into PayOffCPPI_Properties set

26. Monte Carlo Implementation – Example: The Factory Class template<class D, class T> class PayOffFactory { public: typedef PayOff<D, T>* (*CreatePayOffFunction)(SimplePropertySet<string,double>); static PayOffFactory<D, T>& Instance(); void RegisterPayOff(std::string, CreatePayOffFunction); PayOff<D, T>* CreatePayOff(std::string PayOffId, SimplePropertySet<string, double> pset); ~PayOffFactory(){}; private: std::map<std::string, CreatePayOffFunction> TheCreatorFunctions; PayOffFactory(){} PayOffFactory(const PayOffFactory<D, T>&){} PayOffFactory& operator=(const PayOffFactory<D, T>&){ return *this;} }; Used to represent spot value(s) Used to represent discount factors At runtime make the payoff known

27. Monte Carlo Implementation – Example: Implementation of the Factory template<class D, class T> PayOff<D, T>* PayOffFactory<D, T>::CreatePayOff(string PayOffId, SimplePropertySet<string, double> pset) { map<string, CreatePayOffFunction>::const_iterator i = TheCreatorFunctions.find(PayOffId); if (i == TheCreatorFunctions.end()) { std::cout << PayOffId << " is an unknown payoff" << std::endl; return NULL; } return (i->second)(pset); } template<class D, class T> PayOffFactory<D, T>& PayOffFactory<D, T>::Instance() { static PayOffFactory<D, T> theFactory; return theFactory; }

28. Monte Carlo Implementation – Example: PayOff Construction using Factory class PayOffConstructor { public: PayOffConstructor(std::string); static PayOff<D, T>* Create(SimplePropertySet<string, double>); }; template <class D, class T, class P> PayOffConstructor<D,T,P>::PayOffConstructor(std::string id) { PayOffFactory<D, T>& thePayOffFactory = PayOffFactory<D, T>::Instance(); thePayOffFactory.RegisterPayOff(id,PayOffConstructor<D,T,P>::Create); } template <class D, class T, class P> PayOff<D, T>* PayOffConstructor<D, T, P>::Create(SimplePropertySet<string, double> pset) { return new P(pset); }

29. Monte Carlo Implementation – Defining Property Sets //Define a Simple Property Set SimplePropertySet<string, double> CPPI_Set; //Define Properties to be collected into CPPI_Set Property<string, double> Prop_CouponSpread; Property<string, double> Prop_InvestmentLevel; Property<string, double> Prop_Multiplier; //Initalisation of Properties Prop_CouponSpread = Property<string, double> („CouponSpread", 0.0085); Prop_Barrier = Property<string, double> („InvestmentLevel", 1); Prop_Barrier = Property<string, double> („Multiplier", 10); //Adding properties to the set CPPI_Set(Prop_CouponSpread); CPPI_Set(Prop_InvestmentLevel); CPPI_Set(Prop_Multiplier); Heterogenous properties are possible such as vectors, matrices, etc. see [D 06] for details

30. Monte Carlo Implementation – How to use Property Sets in Coding //Using the Properties for coding the CPPI strategy double CouponSpread = PayOffCPPI_Properties.value(„Coupon Spread“); double MaximumExposure = PayOffCPPI_Properties.value(„MaxExposure“); Therefore, coding the payoff uses essentially the names of the properties which can be used to model any derivative using payoff description languages and therefore extends the flexibility. The usage of properties allows flexibility as we see it is easy to model any payoff (time dependent, multi factor, etc.). All that is needed can be put into the Property Set. E.g. if we want to have a barrier option not with one but two barriers simply extend the Property Set.

31. Beyond the Basics Let us come back to the initial problem of creating a „CPPI optimal“ basket We are now able to use advanced models for simulation. But the optimization step is still missing. To this end we have to investigate for a method replacing the Markowitz model in the Gaussian setting. The optimal approach would be a distribution free ansatz using time series or simulated time series data directly. -> Enables us to use short time series To this end we use CVAR (Expected Shortfall, … ) as a coherent risk measure. The efficient frontier can then be computed by minimizing: This approach allows for using complicated dynamics, e.g. NIG, VG, Stochastic Vol, Stochastic Vol with jumps for CPPI purposes. See [RU 99] for details. yield

32. Input to Optimization 6 Asset Time Series with 5000 computed returns Constraints, such that each weight should not exceed 30% and each weight is positive Constraint, such that the sum of all weights is 1 and weight2 + weight3 < 50% Views can be added, such as the portfolio managers sees lower / higher returns for the period to be considered For real applications we use a universe of up to 30 assets!

33. Output of Optimization

34. Output of Optimization

35. Output of Monte Carlo Simulation

36. Output of Monte Carlo Simulation

37. Literature [D 04] Duffy, D., „Financial Instrument Pricing Using C++“, Wiley 2004 [D 06] Duffy, D., „Introduction to C++ for Financial Engineers“, Wiley 2006 [DK 06] Duffy, D., Kienitz, J., Monte Carlo Methods in Finance Generic and Efficient MC Solver in C++, Wilmott November 2005 [DK 07] Duffy, D., Kienitz, J., Software Frameworks in Quantitative Finance, Part I [DK 07] Duffy, D., Kienitz, J., „Monte Carlo Methods in C++“, Wiley forthcoming [K 07] Kienitz, J., Stochastic Processes in Finance Part I, forthcoming [LS 05] Luciano, E., Schoutens, W., Multivariate Variance Gamma Modelling with Applications in Equity and Credit Risk Derivatives Pricing, ULM, Financial Modelling Workshop, September 2005 [P 04] Protassov, R. „EM-based maximum likelihood parameter estimation for multivariate generalized hyperbolic distributions with fixed . Statistics and Computing. Vol 14, issue 1. [RU 99] Rockafellar, T., Urysaev, S., „Optimization of Conditional Value at Risk“, Research report 99-4, Center for Applied Optimization, University of Florida.

38. Disclaimer The usual disclaimers apply. The views expressed in this presentation are solely that of the author and do not of Deutsche Postbank AG. The author is responsible for any inaccuracies, omissions or errors.