Original paper
Abstract
We systematically study the value of the information contained in closed-end fund (CEF) premiums. We parametrically estimate CEF expected returns as a function of the history of CEF premiums, in addition to the current premium, and buy the quintile of funds with the highest expected returns and sell the quintile of funds with the lowest expected returns. The return on this portfolio suggests that previous studies, which examine the information in current premiums only, have understated the value of the information in premiums. Our strategy values the information in the history of CEF premiums at an annualized return of 18.2%.
Keywords:Â Closed-end fund puzzle, limits to arbitrage, market efficiency
Trading rules
- Focus on: All liquid Closed-End funds
- Fundamental method: Categorize Closed-End funds into quintiles based on the prior month's discount.
- Adopt a long position on those with the most significant discounts.
- Adopt a short position on those with the most pronounced premiums.
- Adjust portfolio every month.
- Advanced method: Use the regression model.
- Incorporate past discounts and past monthly changes of discount.
- Predict next month’s performance for each fund.
- Adopt a long position on Closed-End funds anticipated to perform best.
- Adopt a short position on Closed-End funds anticipated to perform poorly.
- Rebalance monthly.
Python code
Backtrader
Here’s a basic outline of the Backtrader code for the trading strategy. Keep in mind that this is just a template and not a complete, ready-to-run code. You’ll need to add the relevant data feeds, configure the cerebro object, and specify the appropriate indicators and order execution logic.
import backtrader as bt
class ClosedEndFundMeanReversion(bt.Strategy):
params = (
('quintile_size', 0.2),
)
def __init__(self):
# Add any indicators or calculations you need for the regression model
pass
def prenext(self):
self.next()
def next(self):
# Implement the logic for sorting CEFs into quintiles based on discount
# and calculating the predictions from the regression model
cefs_sorted = sorted(self.datas, key=lambda data: data.discount[0])
quintile_length = int(len(cefs_sorted) * self.params.quintile_size)
long_cefs = cefs_sorted[:quintile_length]
short_cefs = cefs_sorted[-quintile_length:]
# Enter long positions
for data in long_cefs:
if self.getposition(data).size == 0:
self.buy(data=data)
# Enter short positions
for data in short_cefs:
if self.getposition(data).size == 0:
self.sell(data=data)
# Close positions that are no longer in the quintiles
for data in self.datas:
if data not in long_cefs and data not in short_cefs:
if self.getposition(data).size != 0:
self.close(data=data)
if __name__ == '__main__':
cerebro = bt.Cerebro()
# Add data feeds to cerebro
# cerebro.adddata(...)
cerebro.addstrategy(ClosedEndFundMeanReversion)
# Configure cerebro settings
# cerebro.broker.setcash(...)
# cerebro.broker.setcommission(...)
cerebro.run()
cerebro.plot()This code snippet provides a starting point for implementing the strategy. Be sure to import and process the data for closed-end funds, add any required indicators, and adjust the order execution logic as needed.