How Calculus of Variations Can Optimize Investment Allocation

In investing, finding the perfect balance between risk and return is crucial. But what if your portfolio could dynamically adjust its allocation over time to maximize returns while minimizing risk? Using the principles of calculus of variations, we can model and solve such problems. In this article, we’ll explore how dynamic portfolio optimization can be applied to real-world financial data using Python.

Problem Overview

Imagine a portfolio with two assets: stocks and bonds. Stocks typically offer higher returns but come with higher risk, while bonds are safer but offer lower returns. The challenge is to determine how much of the portfolio should be invested in each asset at any given time, considering changing market conditions.

By applying calculus of variations, we aim to:

• Maximize returns: Focus on growing the portfolio over time.
• Minimize risk: Ensure portfolio stability by managing volatility.

Dynamic Portfolio Optimization Using Python

Below is an example of using Python to dynamically allocate a portfolio between stocks and bonds. The historical data for stocks (SPY) and bonds (BND) is fetched from Yahoo Finance using the yfinance library.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import minimize
import yfinance as yf

# Download historical data for two assets
tickers = ["SPY", "BND"]  # SPY (S&P 500 ETF), BND (Bond ETF)
data = yf.download(tickers, start="2015-01-01", end="2023-01-01")['Adj Close']

# Calculate monthly returns
monthly_data = data.resample('ME').ffill()  # Resample to monthly data
monthly_returns = monthly_data.pct_change().dropna()

# Define the time steps and expected returns/risk
time = np.arange(len(monthly_returns))  # Time steps based on data
returns = monthly_returns.values  # Historical returns

# Separate returns for each asset
asset1_returns = returns[:, 0]  # SPY
asset2_returns = returns[:, 1]  # BND

# Calculate volatility for each asset (standard deviation of returns)
asset1_risk = np.std(asset1_returns)  # SPY volatility
asset2_risk = np.std(asset2_returns)  # BND volatility

# Define the cost function
def cost_function(weights):
    weights = np.clip(weights, 0, 1)  # Ensure weights stay between 0 and 1
    portfolio_return = 0
    portfolio_risk = 0

    for i, w1 in enumerate(weights):
        w2 = 1 - w1  # Complementary weight for Asset 2
        r = w1 * asset1_returns[i] + w2 * asset2_returns[i]
        risk = np.sqrt(w1**2 * asset1_risk**2 + w2**2 * asset2_risk**2)
        portfolio_return += -r / len(weights)  # Negate returns for minimization
        portfolio_risk += risk / len(weights)

    return portfolio_return + 0.5 * portfolio_risk  # Adjust risk-return tradeoff

# Initial weights (50% allocation to each asset)
initial_weights = np.ones(len(time)) * 0.5

# Minimize the cost function
result = minimize(cost_function, initial_weights, method='L-BFGS-B', bounds=[(0, 1)] * len(time))

# Extract optimal weights
optimal_weights = result.x

# Plot the results
plt.figure(figsize=(12, 6))
plt.plot(monthly_returns.index, optimal_weights, label="Optimal Allocation to SPY (Stocks)", color='blue')
plt.plot(monthly_returns.index, 1 - optimal_weights, label="Optimal Allocation to BND (Bonds)", color='green')
plt.title("Optimal Investment Allocation Over Time", fontsize=16)
plt.xlabel("Time", fontsize=12)
plt.ylabel("Allocation Weight", fontsize=12)
plt.legend()
plt.grid(True)
plt.show()

# Summary statistics for final allocations
portfolio_summary = pd.DataFrame({
    "Date": monthly_returns.index,
    "SPY Allocation": optimal_weights,
    "BND Allocation": 1 - optimal_weights
})

Results

The results of the optimization are visualized in the graph below, which shows how the portfolio dynamically adjusts its allocation to stocks (SPY) and bonds (BND) over time:

Applications

This dynamic allocation strategy can be applied in several practical scenarios:

• Retirement Portfolios: Gradually shift to safer assets (like bonds) as you approach retirement.
• Wealth Management: Dynamically balance growth (stocks) and stability (bonds) based on changing market conditions.
• Risk Management: Adjust portfolio allocations to minimize risk during periods of market volatility.

Conclusion

Using calculus of variations principles, this Python-based approach allows investors to dynamically optimize their portfolios over time. By balancing risk and return and adapting to market changes, this method can improve investment outcomes and reduce unnecessary risks.

Want to try this method with your own data? Let us know in the comments or feel free to share your insights!

How the Riesz Representation Theorem Applies to Investing

The Riesz Representation Theorem, a cornerstone of functional analysis, may seem purely theoretical, but it has profound implications for investing. This powerful concept helps us connect abstract performance metrics, like expected return or risk, to specific portfolios of assets. Let’s explore how this mathematical theorem can help investors optimize portfolios, manage risk, and gain deeper insights into financial performance.

1. Connecting Functionals to Portfolios

In investing, functionals can represent metrics such as:

• Expected Return: The weighted average return of a portfolio’s assets.
• Risk (Variance): The fluctuation in the portfolio’s value.

The Riesz Representation Theorem ensures that for every functional (like a way of measuring portfolio performance), there is a unique portfolio (a specific set of weights for assets) that represents it. This allows us to map abstract measures directly to tangible investment strategies.

2. Portfolio Optimization

In portfolio optimization, investors aim to maximize returns for a given level of risk. The Riesz Representation Theorem guarantees that the optimal solution corresponds to a specific portfolio on the efficient frontier. For example:

• A risk-averse investor seeks a portfolio where the trade-off between risk and return is optimal.
• The theorem ensures that this trade-off is tied to a unique, identifiable portfolio configuration.

3. Risk Management

Risk assessment in a portfolio can be simplified using the Riesz theorem. For example:

• Risk, often represented by variance, can be computed as an inner product involving the portfolio weights and a covariance matrix.
• The theorem ensures that this risk measure corresponds to a unique portfolio structure, making risk easier to quantify and manage.

4. Performance Attribution

In performance attribution, we analyze how individual assets contribute to a portfolio’s overall performance. Using the Riesz theorem:

• The contribution of each asset can be represented as part of a specific reference portfolio.
• This helps investors understand which assets drive returns or increase risk.

5. Practical Application with Python

Here’s an example of applying these concepts using Python. We calculate an optimal portfolio’s expected return and risk based on historical stock data. The efficient frontier is plotted to visualize the best trade-offs between return and risk.

import numpy as np
import yfinance as yf
import matplotlib.pyplot as plt

# Download historical stock data
tickers = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA']
data = yf.download(tickers, start="2018-01-01", end="2023-01-01")['Adj Close']

# Calculate daily returns
returns = data.pct_change().dropna()

# Compute mean returns and covariance matrix
mean_returns = returns.mean()
cov_matrix = returns.cov()

# Define portfolio weights
num_assets = len(tickers)
weights = np.random.random(num_assets)
weights /= np.sum(weights)  # Normalize weights to sum to 1

# Calculate expected portfolio return and risk (variance)
expected_return = np.dot(weights, mean_returns)
portfolio_variance = np.dot(weights.T, np.dot(cov_matrix, weights))

# Efficient frontier: Generate portfolios
def simulate_portfolios(num_portfolios, mean_returns, cov_matrix):
    results = np.zeros((3, num_portfolios))
    weights_record = []
    
    for _ in range(num_portfolios):
        weights = np.random.random(num_assets)
        weights /= np.sum(weights)
        portfolio_return = np.dot(weights, mean_returns)
        portfolio_variance = np.dot(weights.T, np.dot(cov_matrix, weights))
        results[0, _] = portfolio_return
        results[1, _] = portfolio_variance
        results[2, _] = portfolio_return / np.sqrt(portfolio_variance)  # Sharpe Ratio
        weights_record.append(weights)
    
    return results, weights_record

# Simulate portfolios
num_portfolios = 5000
results, weights_record = simulate_portfolios(num_portfolios, mean_returns, cov_matrix)

# Plot the efficient frontier
plt.figure(figsize=(10, 6))
plt.scatter(results[1, :], results[0, :], c=results[2, :], cmap='viridis', marker='o')
plt.title('Efficient Frontier')
plt.xlabel('Portfolio Risk (Variance)')
plt.ylabel('Portfolio Return')
plt.colorbar(label='Sharpe Ratio')
plt.grid(True)
plt.show()

Conclusion

The Riesz Representation Theorem simplifies the connection between abstract performance measures and concrete portfolio configurations. By ensuring that metrics like risk and return correspond to unique portfolios, this theorem provides a powerful tool for portfolio optimization, risk management, and performance analysis. Whether you’re an academic or an investor, applying these principles can lead to more informed financial decisions.