Portfolio Allocation: Best Within the Model

This project was a fun exploration project. For my solo IF2211 Algorithm Strategies paper, I could choose any problem and algorithmic approach I wanted. At the time I was diving deeper into economics, especially stocks, so portfolio allocation gave me a way to connect that interest with backtracking.

The primary goal was not to build an investment product people should follow. I wanted to demonstrate how backtracking could search for the best answer under a collection of financial constraints.

To optimize a portfolio, I needed some definition of return. Building a real forecasting model would have become a separate project, so I made a deliberate assumption: use twenty years of historical compound annual growth as the expected return for the next year.

That choice made the problem computable, but not necessarily realistic. It replaced an unknown future with a measurable historical value, allowing the paper to focus on the search algorithm while keeping the limitation visible.

Without additional constraints, the answer would barely be a portfolio. The algorithm could simply place all available money into the stock with the highest historical return.

I limited the portfolio to one stock per industry, capped the allocation to each stock, and prevented a purchase from exceeding roughly one percent of its market capitalization. The diversification rule gave backtracking a meaningful combination problem, while the liquidity limit came from reading about the Indonesian market and from my own experience with how difficult large positions can be to trade.

I chose backtracking because I wanted the result to be the best portfolio that complied with the constraints, not merely the first attractive answer produced by a greedy choice. The search explored stock combinations, rejected candidates that broke a constraint, and restored its state as it returned from each recursive branch.

That guarantee had an important boundary. “Best” only meant best according to my historical-return objective and simplified constraints. The algorithm could solve the model exactly without proving that the model described good investing.

I narrowed the Indonesian stock universe to 98 candidates so clearly unsuitable stocks would not enter the search. Even then, I knew the combinations could grow quickly. The difficult part of the project became improving performance without losing the exhaustive character I wanted.

Constraint checks eliminated branches that could not afford a stock, repeated an industry, or exceeded an allocation limit. A full Rp500 million experiment still took around 43 seconds, which did not surprise me. Exponential exploration was expensive, but that cost was part of what I wanted to investigate.

I first implemented the idea in Python, then reproduced it in C++ because the search was too slow. I also experimented with placing the algorithm in another thread because I was considering parallel execution.

The program immediately waited for that thread, so it did not create useful parallelism in the final version. That experiment reminded me that concurrency by itself does not reduce a search space. The structure of the algorithm matters more than merely giving the same work another thread.

When the program finally produced a complete portfolio, that was the most satisfying moment. One experiment returned seven stocks and a modeled one-year gain above 100 percent.

I treated that number as a mathematical consequence of the historical CAGR assumptions, not as a realistic forecast. The result demonstrated that the implementation worked, while its implausibility also exposed how much the objective depended on the model behind it.

If I rebuilt this today, I would use a different optimization approach and model financial considerations such as risk, volatility, and correlation more carefully. Those factors would need their own heuristic quantification instead of being hidden behind historical return alone.

The lasting lesson is that an algorithm cannot solve a problem the model fails to express. Backtracking can find the best answer inside the world I define, but human judgment still decides whether that world contains the right assumptions.