An Easy Mistake With Returns: Portfolio Analysis

As investors, we've all heard the mantra "it's not about being right, it's about being consistent." This philosophy underlies many investment strategies, including portfolio analysis. However, when done correctly, this approach can lead to impressive returns over long periods. Yet, despite its popularity, one common mistake plagues many portfolios: aggregation.

The Order of Aggregation Matters

When calculating the return on a portfolio, we often find ourselves faced with decisions about how to aggregate our returns. The order in which we combine our returns is crucial. This may seem like an insignificant detail, but it can have a significant impact on our final returns.

The weights for a portfolio are typically determined based on its asset allocation. However, these weights change over time due to changes in market conditions and investor attitudes. If not managed properly, the aggregation of returns can lead to suboptimal performance.

Aggregation Over Time vs. Assets

To illustrate this point, let's consider an example using hypothetical data from 2007 to 2011.

| Asset | Return | | --- | --- | | A | 24% | | B | 48% | | C | 54% |

These returns are presented in simple terms, with a focus on their arithmetic values. However, the log return matrix offers a more nuanced view of these numbers.

Log Returns vs. Simple Returns

A log return is a more meaningful measure of returns when dealing with markets that exhibit high volatility. In our example:

| Asset | Log Return | | --- | --- | | A | 0.2231436 | | B | -0.47000363 | | C | -0.55499684 |

The simple return, on the other hand, is a more straightforward calculation.

| Asset | Simple Return | | --- | --- | | A | 0.2500000 | | B | -0.37500000 | | C | -0.4259259 |

The Initial Weights: A Right Way

The initial weights for our portfolio are:

| Asset | Weight | | --- | --- | | A | 0.25 | | B | 0.50 | | C | 0.25 |

This setup is a good starting point, but it's essential to remember that the weights will change over time.

The Starting Ingredients: Aggregation

We'll combine our returns in log return form and then transform them back into simple returns using the initial weights.

# Define the log return matrix logRet <- c(0.2231436, -0.47000363, -0.55499684)


Calculate the sum of the log returns for each asset sumlogreturns <- sum(logRet)

# Transform the time-aggregated log returns to simple returns using the initial weights simpleReturns <- sum(logRet  wt07) / (1 + sum(wt07))

Multiplying by Weights and Summing

If we multiply our simple returns by the weights, we can combine them into a single portfolio return.

# Define the weights for each asset wt07 <- c(0.25, 0.50, 0.25)


# Calculate the weighted sum of the simple returns weighted_sum <- simpleReturns  wt07

The Result: A Simple Return

Our calculation yields a simple return of 81.37%.

Why This is an Easy Mistake with Returns

The aggregation process over time can lead to suboptimal performance due to changes in market conditions and investor attitudes.

To avoid this mistake, it's essential to:

1. Understand the order of aggregation matters. 2. Calculate returns separately for each asset using simple returns. 3. Combine these returns into a single portfolio return using the initial weights.

A Wrong Way: Aggregation Over Time

Let's try an example where we use the starting weights and then collapse to portfolio returns at each time point, transforming to log returns and aggregating across time by summing the log returns.

# Define the simple return matrix simpleRet <- c(0.2500000, 0.26666667, 1.0322581)


Calculate the weights for each asset using the starting weights wt07 <- c(0.25, 0.50, 0.25) weightReturns <- simpleRet  wt07


Define a function to transform time-aggregated log returns back into simple returns generateRandomPortfolioProbe <- function() { # Generate random portfolio probe data return <- rnorm(n = 100, mean = c(10417, 10417, 4630), sd = c(0.1, 0.2, 0.3))

Calculate the simple returns using the weights and a function that takes into account time-aggregated log returns simpleReturns <- generateSimpleReturnFromLogReturns(weightReturns)

Return the portfolio return return(simpleReturns) }

Define a function to calculate the simple return from log returns generateSimpleReturnFromLogReturns <- function(logRet) { # Calculate the natural logarithm of each log return value and sum it with 1 sumlogreturns <- sum(logRet  exp(colSums(logRet)) - 1)

Return the calculated simple return return(sumlogreturns / (1 + sum(logRet))) }

Generate a random portfolio probe using our function randomPortfolioProbe <- generateRandomPortfolioProbe()

# Print the result print(randomPortfolioProbe)

An Easy Mistake with Returns: Portfolio Probe

The `PortfolioProbe` website offers an interesting solution to this problem, but it's essential to understand how they use aggregation.

When aggregating returns using simple returns and weights, we transform time-aggregated log returns back into simple returns. This process is crucial for obtaining a consistent portfolio return over long periods.

However, when aggregating returns in the opposite manner (i.e., starting with weights and then collapsing), we may end up with suboptimal performance due to changes in market conditions and investor attitudes.

To avoid this mistake, it's essential to:

1. Understand how aggregation works. 2. Calculate returns separately for each asset using simple returns. 3. Combine these returns into a single portfolio return using the initial weights.

By following these guidelines and understanding the importance of proper aggregation, you can ensure that your investment strategy is well-optimized over long periods.