Mobile Hamburger Menu
Desktop Hamburger Menu
Home Calculators Guides
Document Title

MONTE-CARLO SIMULATION MODEL

By ProbabilityofProfit.com

The Monte-Carlo Simulation Model is a widely used financial model for predicting the price of options that runs numerous stock price simulations to gather data. The data can then be used in conjunction with the Black-Scholes Model to estimate the value of options or other derivatives based on the distribution of potential future prices.
The Monte Carlo simulation model, while not attributed to a single creator, was developed and popularized by a team of scientists working on the Manhattan Project during World War II. The method was primarily developed by Stanislaw Ulam, a mathematician, and John von Neumann, a renowned physicist and mathematician.

THEORY & METHODOLOGY

THEORY

The Monte Carlo Simulation Model is a key tool in modern finance, widely used to predict the prices of options. By running numerous simulations of stock prices, it gathers valuable data that helps estimate the value of options or other financial derivatives. This method essentially takes the guesswork out of forecasting, providing a clearer picture of potential future prices.
  • Typically, the Monte Carlo model works alongside well-known option pricing models like the Black-Scholes model. The Black-Scholes model calculates theoretical prices for options based on factors such as volatility, the underlying asset price, time to expiration, and the risk-free interest rate. By combining the detailed data from Monte Carlo simulations with the Black-Scholes calculations, analysts can achieve more accurate and reliable option valuations.
  • One of the main advantages of the Monte Carlo Simulation Model is its flexibility. It can adapt to various alternative pricing methods, making it an essential tool for anyone involved in financial markets. This versatility helps analysts and investors manage risks and make more informed decisions.
  • With its data-driven approach, the Monte Carlo model sheds light on the complex and uncertain world of market movements, helping professionals make better strategic choices.

METHODOLOGY

The Geometric Brownian motion is commonly used with Monte-Carlo simulations to represent the random variable of price fluctuations of the price paths evolving over time.
  • While the Black-Scholes model is more efficient in valuing an options price, the Trinomial model is more flexible in that it can accommodate more complex scenarios and variations in market conditions.

 

dSt = μSt dt + σSt dWt
  • Within the Geometric Brownian motion, the drift (μ) or risk-free rate, and the volatility (σ) remains constant over the lifetime of the simulation. 
     
While the Monte Carlo simulation model can provide a high level of accuracy, the amount of time required to achieve accuracy can be high especially when considering the amount of simulations being run. 
  • The more simulations or paths being run increases the accuracy of the simulation as a broader range of potential outcomes captures more variability thus reducing random fluctuations. 
  • Calculation times can also begin to run high when you consider the amount of control variables in your simulation as each variable requires its own set of random numbers to be generated as well as its own set of calculations to be performed for each iteration. 
     
The Monte Carlo simulation itself is a computational technique rather than a specific mathematical formula. However, it relies on probability theory and statistical methods for generating random samples and analyzing results.

 

CALCULATIONS

ASSUMPTIONS

For example purposes, our version of the Monte-Carlo Simulation model follows these assumptions: 
  • The volatility of the stock price is equal to the implied volatility and remains the same over time.
  • The Geometric Brownian Motion is used to predict how the stock price moves.
  • The interest rates for risk-free investments stay the same.
  • The Black-Scholes Model is used to figure out how much options contracts are worth.
  • Money paid out to shareholders as dividends is not considered.
  • The costs of buying and selling stocks aren't part of our calculations.
  • We're not considering the possibility of being forced to buy or sell stocks at specific prices.
  • Events like when a company reports its earnings or splits its stock won't affect our calculations.

MONTE-CARLO SIMULATIONS SOLUTION

Since the calculation and applicability of the model is computationally difficult and time intensive, we will instead show you how to calculate it using python and then break down each individual step.
  • While this script doesn't inherently provide the future potential value of the option in monetary terms, it does provide a high-level insight into the likelihood of achieving a certain profit level and the average time it takes to reach a closing condition. 
  • This implementation of the Monte-Carlo simulation still holds true in value as these metrics are valuable for assessing the risk and potential outcomes associated with holding the option as the The interest rates for risk-free investments stay the same.

PYTHON IMPLEMENTATION

Import Libraries
Code Snippet Display 

import numpy as np
from numba import jit
  • numpy: Used for numerical computing, particularly for handling arrays and mathematical operations.
  • numba: Library for just-in-time (JIT) compilation of Python and NumPy code to optimize performance.
Function Definition
Code Snippet Display 

def monteCarlo(underlying, rate, sigma, days_to_expiration, closing_days_array, trials, initial_credit,
                min_profit, strikes, bsm_func):
  • This defines the monteCarlo function that takes several parameters that are defined below: 
    • underlying: The underlying asset's price.
    • rate: The risk-free interest rate.
    • sigma: The volatility of the underlying asset.
    • days_to_expiration: Number of days until the option expires.
    • closing_days_array: Array containing the days at which the option can be closed.
    • trials: Number of Monte Carlo trials to run.
    • initial_credit: Initial credit received from selling the option.
    • min_profit: Array containing the minimum profit thresholds for different combinations.
    • strikes: Strike prices of the option.
    • bsm_func: Function to calculate option prices using the Black-Scholes model.
Initialization
Code Snippet Display 

dt = 1 / 365
  • dt is set to represent the fraction of a year for time discretization in the simulation.
Parameter Adjustment
Code Snippet Display 

sigma = sigma / 100
rate = rate / 100
  • sigma and rate are converted from percentage to decimal.
Variable Initialization
Code Snippet Display 

counter1 = [0] * length
dtc = [0] * length
dtc_history = np.zeros((length, trials))
indices = [0] * length
  • Arrays and matrices are initialized to store simulation results.
Monte-Carlo Simulation
The heart of the function lies in the nested loops performing the Monte Carlo simulation. Each iteration simulates the price movements of the underlying asset and calculates option prices using the Black-Scholes model.
Looping through Trials
Code Snippet Display 

for c in range(trials):
  • This loop iterates trials times, running the entire Monte Carlo simulation for each trial.
Initialization
Code Snippet Display 

epsilon_cum = 0
t_cum = 0

for i in range(length):
    indices[i] = 0
  • Variables epsilon_cum and t_cum are initialized to zero. Indices is a list used to track which combinations have been evaluated.
Simulation Loop
Code Snippet Display 

for r in range(max_closing_days + 1):
  • This loop simulates the price movement for each day up to max_closing_days.
Brownian Motion and Geometric Brownian Motion
Brownian Motion
Code Snippet Display 

W = (dt ** (1 / 2)) * epsilon_cum
Geometric Brownian Motion
Code Snippet Display 

signal = (rate - 0.5 * (sigma ** 2)) * t_cum
noise = sigma * W
y = noise + signal
stock_price = underlying * np.exp(y)
  • These calculations simulate the random fluctuation in the stock price.
Option Pricing
Code Snippet Display 

debit = bsm_func(stock_price, strikes, rate, dt * (days_to_expiration - r), sigma)
  • The Black-Scholes model function (bsm_func) is called to calculate the option price based on the simulated stock price and other parameters.
Profit Calculatioon and Evaluation
Code Snippet Display 

profit = initial_credit - debit
  • The profit from closing the option on the current day is calculated. The code then checks if the profit meets the minimum profit threshold or if the closing days have passed for each combination.
Updating Counters and Indices
Code Snippet Display 

            sum = 0

            for i in range(length):
                if indices[i] == 1:
                    sum += 1
                    continue
                else:
                    if min_profit[i] <= profit:
                        counter1[i] += 1
                        dtc[i] += r
                        dtc_history[i, c] = r

                        indices[i] = 1
                        sum += 1
                    elif r >= closing_days_array[i]:
                        indices[i] = 1
                        sum += 1
  • The second to last segment of the actual simulation part checks if the profit meets the minimum threshold or if the closing days have passed, the counters and indices are updated accordingly.
Termination Condition
Code Snippet Display 

if sum == length:
    break
  • If all combinations have been evaluated, the loop breaks to start a new trial.
Results Calculation
After the simulation, the function calculates the probability of achieving a minimum profit and the average days to close for each combination. This section calculates the probabilities of achieving the minimum profit (pop_counter1) and the average days to close (avg_dtc) for each combination, along with their corresponding errors (pop_counter1_err and avg_dtc_error).
Calculating Probability of Achieving Minimum Profit
Code Snippet Display 

pop_counter1 = [c / trials * 100 for c in counter1]
pop_counter1 = [round(x, 2) for x in pop_counter1]
  • pop_counter1: Calculates the percentage of trials where each combination achieves the minimum profit. 
  • The second line rounds each value in pop_counter1 to two decimal places.
Calculating Error in Probability
Code Snippet Display 

pop_counter1_err = [2.58 * (x * (100 - x) / trials) ** (1 / 2) for x in pop_counter1]
pop_counter1_err = [round(x, 2) for x in pop_counter1_err]
  • pop_counter1_err: Calculates the error in the probability estimation using the formula from Monte Carlo theory.
  • The second line rounds each value in pop_counter1_err to two decimal places.
Calculating Average Days to Close and Error
Code Snippet Display 

avg_dtc = []
avg_dtc_error = []

for index in range(length):
    if counter1[index] > 0:
        avg_dtc.append(dtc[index] / counter1[index])

        n_a = counter1[index]
        mu_hat_a = dtc[index] / n_a
        summation = 0

        for value in dtc_history[index, :]:
            if value == 0:
                continue

            summation = summation + (value - mu_hat_a) ** 2

        s_a_squared = (1 / n_a) * summation
        std_dev = ((n_a - 1) * s_a_squared) ** (1 / 2) / n_a
        avg_dtc_error.append(2.58 * std_dev)
    else:
        avg_dtc.append(0)
        avg_dtc_error.append(0)

avg_dtc = [round(x, 2) for x in avg_dtc]
avg_dtc_error = [round(x, 2) for x in avg_dtc_error]
  • avg_dtc: Calculates the average days to close for each combination.
  • avg_dtc_error: Calculates the error in the average days to close using Monte Carlo theory.
  • The loops handle cases where certain combinations haven't been evaluated (counter1[index] == 0), setting their average days to close and error to zero.
Return Statement
Code Snippet Display 

return pop_counter1, pop_counter1_err, avg_dtc, avg_dtc_error
  • The function returns the probabilities of achieving the minimum profit, their errors, the average days to close, and their errors.
Implementationn
Combine the following lines of code to create your custom Monte Carlo simulation model for gaining probabilistic insights into your options positions. This script is tailored for simulating options trading strategies using the Monte Carlo simulation model. By extending this script, you can evaluate options strategies, refine risk management techniques, optimize trade strategies, and examine the impact of market condition variations on your options strategies.
Full Code
Click the button below to view the combined code.
Dropdown Button with Code Snippet 

import numpy as np
from numba import jit

@jit
def monteCarlo(underlying, rate, sigma, days_to_expiration, closing_days_array, trials, initial_credit,
               min_profit, strikes, bsm_func):
    """
    Monte Carlo simulation for option pricing and profit calculation.

    Parameters:
    underlying (float): The initial stock price.
    rate (float): The risk-free interest rate in percentage.
    sigma (float): The volatility in percentage.
    days_to_expiration (int): The number of days until the option expires.
    closing_days_array (list): Array of closing days for the simulation.
    trials (int): Number of simulation trials.
    initial_credit (float): Initial credit received from selling the option.
    min_profit (list): Minimum profit target array.
    strikes (float): Strike price of the option.
    bsm_func (callable): Black-Scholes-Merton function for pricing the option.

    Returns:
    tuple: Contains population counters, errors, average days to close, and their errors.
    """
    
    length = len(closing_days_array)
    max_closing_days = max(closing_days_array)
    
    dt = 1 / 365
    sigma /= 100
    rate /= 100

    counter1 = [0] * length
    dtc = [0] * length
    dtc_history = np.zeros((length, trials))
    indices = [0] * length

    for c in range(trials):
        epsilon_cum = 0
        t_cum = 0

        for i in range(length):
            indices[i] = 0

        for r in range(max_closing_days + 1):
            W = (dt ** 0.5) * epsilon_cum
            signal = (rate - 0.5 * (sigma ** 2)) * t_cum
            noise = sigma * W
            y = noise + signal
            stock_price = underlying * np.exp(y)
            debit = bsm_func(stock_price, strikes, rate, dt * (days_to_expiration - r), sigma)
            profit = initial_credit - debit

            for i in range(length):
                if indices[i] == 0 and profit >= min_profit[i] and r == closing_days_array[i]:
                    indices[i] = 1
                    counter1[i] += 1
                    dtc[i] += r
                    dtc_history[i, c] = r

    pop_counter1 = [c / trials * 100 for c in counter1]
    pop_counter1 = [round(x, 2) for x in pop_counter1]
    pop_counter1_err = [2.58 * ((x * (100 - x) / trials) ** 0.5) for x in pop_counter1]
    pop_counter1_err = [round(x, 2) for x in pop_counter1_err]

    avg_dtc = []
    avg_dtc_error = []

    for index in range(length):
        if counter1[index] > 0:
            avg_dtc.append(dtc[index] / counter1[index])

            n_a = counter1[index]
            mu_hat_a = dtc[index] / n_a
            summation = np.sum((dtc_history[index, :n_a] - mu_hat_a) ** 2)
            s_a_squared = (1 / n_a) * summation
            std_dev = ((n_a - 1) * s_a_squared) ** 0.5 / n_a
            avg_dtc_error.append(2.58 * std_dev)
        else:
            avg_dtc.append(0)
            avg_dtc_error.append(0)

    avg_dtc = [round(x, 2) for x in avg_dtc]
    avg_dtc_error = [round(x, 2) for x in avg_dtc_error]

    return pop_counter1, pop_counter1_err, avg_dtc, avg_dtc_error

PROS & CONS

PROS

CONS

Flexibility: Monte Carlo simulation allows for the incorporation of various complex factors and variables, making it suitable for modeling diverse financial scenarios.

Computational Intensity: Running numerous simulations can be computationally intensive and time-consuming, which can lead to high computational costs and long processing times.

Accuracy: With a large number of simulations, Monte Carlo methods can provide highly accurate estimates for the pricing of options and other derivatives while capturing a wide range of potential outcomes.

Complexity: It can be challenging to set up and validate the model correctly, leading to potential errors if not done properly.

Risk Assessment: By generating various scenarios, the Monte Carlo Simulation model helps in assessing the risk associated with different investment strategies or financial decisions.

Assumptions Dependency : The accuracy of Monte Carlo simulations heavily depends on the assumptions made regarding the underlying stochastic process, such as the distribution of stock prices and the constancy of drift and volatility.

Incorporation of Drift and Volatility: The model incorporates drift (risk-free rate) and volatility, which are essential factors in option pricing, thus providing more realistic results compared to deterministic models.

 

CONCLUSION

The Monte Carlo Simulation Model is a powerful tool for financial analysis, especially when it comes to valuing options and other derivatives. By simulating a wide range of potential future prices, it helps provide a more accurate estimate of options' values and assess associated risks. While the model is computationally intensive and depends on accurate assumptions, its ability to incorporate complex variables and adapt to various market conditions makes it invaluable in financial modeling.
 
When combined with other models, such as the Black-Scholes model, the Monte Carlo Simulation enhances the accuracy and reliability of option pricing. It allows analysts to consider a broader range of outcomes, reducing the uncertainty that is often a part of financial markets. This combination supports more informed decision-making, enabling professionals to manage risks better and optimize their trading strategies.
 
Despite its complexity and the significant computational effort required, the flexibility and comprehensive nature of the Monte Carlo Simulation offer substantial advantages over more rigid, deterministic models.  Thank you for reading this guide, and I trust that these techniques lead to successful trading outcomes for you.

REFERENCES

At ProbabilityofProfit.com, we are dedicated to delivering accurate and trustworthy content to our readers. Our team meticulously researches each topic, ensuring that the information we provide is both comprehensive and reliable. We reference high-quality sources, including academic journals, industry reports, and market analysis, to support our content. Additionally, we draw upon original studies and data from respected publishers to provide a well-rounded perspective. 
 
Our commitment to accuracy means we constantly review and update our articles to reflect the latest developments and trends in options trading. We strive to present unbiased information, allowing our readers to make informed decisions based on solid evidence. Discover more about our rigorous standards and our dedication to excellence on our website.
Dropdown Button
Related Guides