# Pricing options in underlying problem

Let us look at options, which are cash settled, but instead of receiving cash, you receive the proportion from underlying asset with the same value as cash. Moreover, you can pay for these options in underlying asset only.

Example: ETH option expired with strike price \$1000 and the current value of ETH is \$2000. The buyer of the option will receive: (2000 − 1000)/2000 = 1 − 1000/2000 = 0.5ETH.

How can we price this option?

By Black Scholes model

We can calculate the price using BS model, which will be in USD and then divide it by current asset price.

For example:

• S = 20
• K = 20
• r = 0
• volatility = 1.3
• T = 7/365.2425

The resulted value from BS model is: $$1.43 = 1.43/S$$ ETH $$= 1.43/20 = 0.0715$$ETH.

Pricing it directly in underlying price

Instead of using BS model, we can price the option directly in the underlying asset.

We can simulate geometric Brownian motion from BS and then calculate the final price as: $$E_{FP} [(FP − K)/FP ]$$ where $$FP$$ is final price for given path in the process. Applying this to our example, we get:

$$0.05758$$ ETH $$= \\\0.05758 ∗ S = \\\1.15$$

Problem

This have resulted into to different prices for the same option:

• 0.0715 based on Black Scholes model
• 0.05758 based on second approach

Which one is correct and why the other one is incorrect?

• "instead of receiving cash you receive the proportion from underlying asset with the same value as cash". What makes this option different from an ordinary cash settled option where the option holder immediately invests his payoff into the underlying asset ? Conclusion: cash settled or otherwise settled. Prices should be same. Sep 27, 2022 at 11:38
• Sep 27, 2022 at 12:02
• @KurtG. I understand this this is why I am posting the question. It seems like dividing BS price by S assumes that at expiration you get (FP - K)+/S, which is not correct (in terms of underlying, but in USD it is ok). You get (FP - K)+/FP in underlying. Sep 27, 2022 at 12:25
• TBH I don't understand that formula you are using to price the option directly in the underlying asset. Looks like you convert the payoff to shares of ETH. A payoff is a monetary value expressed in a currency. Here that currency is your home currency USD. Looks like you are "quantoing" he payoff and this seems the heart of the problem. Sep 27, 2022 at 12:37
• @KurtG. For exercising the option, you pay in underlying (ETH), so I need to calculate how much I pay for it, which is (FP - K)^+/FP in ETH. Using this formula I can calculate the expected value in ETH using GBM and this expected value is different the (BS value in USD/ S). So the idea is to calculate how much ETH I will earn in average and compare it to how much I will pay for the option in ETH. (When the option is caluclated using BS model divided by S, which is the price of the option in ETH terms). The issue is that these two values are different. Sep 27, 2022 at 12:53

You look at ETHUSD - how many USD per one ETH. If S=K=20 you get (correctly, if vol is 130%) a price of 1.43.

However, if you swap it around to price the option as USDETH (how many ETH per USD), you need to change your strike and notional because Garman Kohlhagen (BS for FX) is is priced in terms of notional in ccy1 (ETH), and premium in ccy2 (USD). If you use USDETH, your notional is now in USD and your premium in ETH.

Using Julia, this looks like this:

function GK(S,K,ccy1,ccy2,σ)
d1 = (log(S/K) + (ccy2-ccy1+0.5*σ^2)*t)/(σ*sqrt(t))
d2 = d1 - σ*sqrt(t)
c = S*exp(-ccy1*t)*N(d1)-K*exp(-ccy2*t)*N(d2)
p = K*exp(-ccy2*t)*N(-d2) - S*exp(-ccy1*t)*N(-d1)
return c, p
end

S = K =  20
ccy1 = ccy2 = 0
σ = 1.3
t = 7/365.2425;

GK(S,K,ccy1,ccy2,σ) # ETHUSD in USD
GK(S,K,ccy1,ccy2,σ) ./S # ETHUSD in ETH

GK(1/S,1/K,ccy1,ccy2,σ).*K # USDETH in ETH


You can read some more details here.

Edit:
You are not pricing the same payoff. In Black Scholes, you have $$S_t-K$$ (or FP-K) as the original option but you price (FP-K)/FP (you do not divide by current spot), and to get the value of 0.05758 you would actually have a "final price" (FP) of something like 21.222 (for (FP−K)/FP to result in 0.05758). If you now compute 21.222 - 20 (S-K) you get 1.222 ; if you use your 0.05758 * 21.222 you get the same 1.222.

def MCSIM(S,t,r,vol,M=1000000, inverted = False):
#np.random.seed(10)
dt = t
nudt = (r - 0.5*vol**2)*dt
volsdt = vol*np.sqrt(dt)
lnS = np.log(S)
Z = np.random.normal(size=M)
delta_lnSt = nudt + volsdt*Z
if not inverted:
lnSt = lnS + delta_lnSt
else:
lnSt = lnS - delta_lnSt

# compute Expectation and SE
ST = np.exp(lnSt)
return ST


(as copied from the chat with @Kurt G) gives this value, because you compute np.average([max((FP-K)/FP,0) for FP in MCSIM(S,t,r,σ,M=1000000, inverted = False)]). However, if you think this through, you only compute this value if FP > 20, else it is 0. Since all values smaller than 20 are excluded, this results in an average FP of ~21.43 (and FP-K will be the correct BS price). You can compute this like so np.average([FP if FP >= 20 else 20 for FP in MCSIM(S,t,r,σ,M=1000000, inverted = False)]).

However, the true expected spot np.average([FP for FP in MCSIM(S,t,r,σ,M=1000000, inverted = False)]) is ~20 in your MC run, given you ignore interest rates. I used a convoluted way with comprehensions to make this difference more explicit.

Put differently, you are interested in the ETH price of the option as of today - not as of the expiry date. Hence, you would need to divide by S instead of FP in np.average([max((FP-K)/S,0) for FP in MCSIM(S,t,r,σ,M=1000000, inverted = False)]), which gives 0.0717544967742682 (not using a seed).

• Thank you for answer. That means that second approach is incorrect (Pricing it directly in underlying price). Do you have idea why? I want to figure it out. Sep 27, 2022 at 23:09
• Still, one thing is not clear to me. Let me explain it in detail. There exists services, which allows you to sell 1 week options, which are settled cash (ETH) and you put 1 ETH as collateral. So, when the option expires ITM, you will pay to the buyer (FP - K)/FP amount of ETH. So, I wanted to calculate the expected value, which I need to give up. I used the MCSIM (the second approach) to generate paths and calculate the average as np.maximum(0, (K - FP)/FP).mean(). This value is lower than BS price divided by S. So it says that selling ATM will generate yield in ETH, which is against EMH. Sep 28, 2022 at 9:10