Python exercise: Short-dated at-the-money calls. There's no coding for this exercise. The Jupyter notebook "ShortDatedATMCalls_230125.ipynb" does all the work-you just need to vary some parameters and report the answers. Exercise background: Monte Carlo (first steps) "Monte Carlo" (or "MC") is a powerful technique for pricing derivative securities. It typically doesn't provide a lot of intuition, but its flexibility makes it one of the most widely used methods for doing real-world valuations of derivatives that are difficult to price. We aren't ready to study Monte Carlo in depth now (we will be studying it extensively later on), but we can do some "baby" MC pricing now, and use it to start developing some important intuitions we will use later. The value of any asset is the discounted, expected value of all its future cash flows. With options, there are two problems-the appropriate discount rate isn't immediately obvious, and the complicated, "conditional" nature of option's payouts make it hard to even calculate their expected payoffs. The Black-Scholes formula is the result of figuring out how to do that complicated valuation for a particular, fairly simple option (European call options, under a strict "log-normal" assumption on future stock prices). In general, however, there may be no way to analytically calculate the expected payoff. That's where Monte Carlo comes in. Monte Carlo does a large number of "simulations" to get a good approximation of the distribution of future possible outcomes, and uses these to calculate an expected payoff numerically. You still typically need to address the issue around the "right" discount rate. There is one type of option that is almost completely insensitive to the discount rate: "short-dated" options. These are options that are about to pay off (in the next few days), and consequently have such low sensitivity to discount rates (because they are being discounted for so little time) that we almost don't even need to worry about discounting at all. The easiest of these options to price are short-dated, at-the-money puts and calls. These mature soon, paying the holder the difference between the price of the option's "underlying" asset at maturity, and the underlying asset's current price (the strike). The call pays out if the underlying's price at maturity is higher than its current prices, while the put pays off if it's price is lower. Pricing these options provides deep, important intuitions about what kind bet you're making when you buy an option. It's what this Python exercise is about. The actual exercise: Daily stock returns are roughly normally distributed. In average market conditions, the daily standard deviation of the market is about 1\%, and 3-4 times as high for the typical individual stock. - These correspond to volatilities of 16% and 4864%, respectively. - The standard deviation scales like T. - Very important! We'll be using this fact all the time! - The volatility is an annualized standard deviation. - One day is roughly 1/252 years (there are roughly 252 trading days a year), so for one day T1/16. Multiplying the asset volatility by this gives the one day standard deviation. That is, if the price of the asset today is S0, then its price at time- T ("tomorrow") is distributed roughly S0(1+T), where is the asset's annualized standard deviation and is a standard normal random variable (mean zero and standard deviation of one). The Jupyter notebook ShortDatedATMCalls_230125.ipynb "Monte Carlos" possible price for the stock. Given S0,T, and , and a number of "draws" N, it simulates N prices at T using the distribution S0(1+T). - The first cell takes the four parameters, calculates the possible prices, - The second cell reports the standard deviation (SD) and mean absolute deviation (MAD) of the change in the stock price from 0 to T, as well as the ratio MAD/SD. - The third cell reports the "Monte Carlo price" of the ATM option. For these short-dated options we claimed they were basically priced as expected payoffs, and with Monte Carlo we estimate the expected payoff using the realized average payoff from a large number of draws. That is, the third cell reports the average call payout across the draws, N1i=1Nmax(ST,iK,0), where ST,i is the underlying price "tomorrow" in the " i th draw" and K=S0. Please use this code, and your own choice of S0,T, and (different from mine, but please choose a fairly short time-to-maturity) to answer the following question: (a) Report your "baseline" choices for the three parameters, and the number of draws you chose (bigger N gives better pricing, but slows the simulations down). (b) Report the MAD/SD ratio for your baseline case, and the (approximate) price of the ATM call. (c) What happens to the price of the ATM call if you double S0 ? (Note: It is still ATM, so the strike also needs to double.) What if you triple S0 ? What kind of relation do you see? - Please report your answers as multiples of your "baseline" price. (d) What happens to your answers if you instead double ? What if you triple it? What kind of relation do you see? - Again, report your answers as multiples of your baseline answer. (e) Finally, what happens to your answers if you instead double T ? What if you triple it? What if you quadruple it? What kind of relation do you see