Simple trading rules, big impact

The Holy Grail of trading success won't be found in the cutting-edge of classical machine learning models or complex rules

Introduction

Picture this: You’re standing at the helm of a ship in stormy markets, armed with a treasure map labeled "Classical machine learning models"—a maze of algorithms, charts, and optimization routines. In the other hand, you clutch a crumpled napkin with the words "If open > last week’s open, buy" scrawled hastily. Now ask yourself: which do you trust to guide you to the treasure?

I'll say it quietly: The napkin could save your loot.

Imagine teaching a parrot to trade. If you give it 100 rules, the poor bird will freeze in decision-making paralysis. But give it one rule—something simple and easy to follow—and it might actually make a profit. Humans, algorithms, and even parrots thrive in simplicity.

Let’s quantify this with a bit of math. Suppose a trading strategy has k independent rules. Each rule has a 55% chance of being correct—better than a coin flip, but not by much. The probability that all rules align perfectly is:

\(P(\text{win}) = 0.55^k \)

For k=2, that’s 30%. For k=5, it plummets to 5%. Adding rules reduces your chances of winning, even if each rule is slightly good. Every added rule introduces a new chance to fail. Complexity isn’t just confusing—it’s mathematically self-sabotaging.

But wait, it gets worse.

In reality, rules are rarely independent. They often share hidden dependencies. If Rule 1 fails, Rule 2 is more likely to fail too. This turns our formula into:

\(P(\text{win}) = p_1 \times p_2 \times \cdots \times p_k \times \text{[dependency factor]} \)

And that dependency factor is usually less than 1, crushing your odds further. In my experience: 1 rule, okay; 2 rules, okay; More than 2… Bzzz! Although, the method of rule assembly also comes into play here (quite different from signal ensemble methods). A toy example to ilustrate that:

Conditional rules sssembly

# Define rules
rule1 = (close_price > prev_close_price)
rule2 = (spread < 0.05)
rule3 = (volume > 1_000_000)

# Assemble rules with logic
if rule1 AND rule2 OR rule3:
    decision = "Buy"
else:
    decision = "Hold"

Signals assembly

# Signals from 3 strategies
strategy_A = 1  # Buy
strategy_B = 0  # Hold
strategy_C = 1  # Buy

# Assemble signals (majority vote)
final_signal = 1 if (strategy_A + strategy_B + strategy_C) >= 2 else 0

But let's get back to the matter at hand, let’s model this with expected value. Suppose each rule you add to your strategy slightly improves your edge but massively increases your failure rate.

For example:

• 1 Rule: 55% win rate, 2% gain per win, 1% loss per fail.

  \(E = (0.55 \times 0.02) + (0.45 \times -0.01) = 0.65\% \text{ per trade} \)

• 5 Rules: 5% win rate (as calculated earlier), 5% gain per win, 1% loss per fail.

  \(E = (0.05 \times 0.05) + (0.95 \times -0.01) = -0.0075 \)

Adding rules turned your profitable strategy into a money furnace. Why? Because small gains can’t offset low win rates. A simpler approach yields steady profits, while extra complexity burns capital. Complexity opens too many paths to failure, and even marginally higher returns can’t make up for that.

Consider the classic Pareto principle: 80% of results come from 20% of inputs. In trading, this becomes even more lopsided. Adding a 5th rule to a strategy might improve accuracy by 1% but introduce 3 new failure modes.

If rules are positively correlated—as they often are, even when meticulously selected to appear uncorrelated—the joint probability collapses faster than a soufflé pulled too soon from the oven. For example, if each rule shares a 0.8 correlation with others:

\(P(\text{5 rules correct}) \approx (0.55)^5 \times 0.8^{10} = 0.05 \times 0.107 = 0.5\% \)

Now you’re relying on a 0.5% chance of success. Good luck with that.

So, what’s the fix? Embrace the One Good Rule philosophy:

1. Isolate the rule: Find a single logical condition that repeats multiple times over long periods. Because it’s no longer just about finding a high-probability rule; what we’re looking for is high persistence and to avoid false positives.

2. Stress-test it: See how it holds up in multiple scenarios, and build synthetic scenarios to test it beyond historical data.

Now, let’s see how simplicity dodges this statistical bullet. It’s important to show the beauty of dumb rules…

Simple rules like "Buy if today’s open > open 5 days ago" have one superpower: they fail loudly and clearly. You either win or lose fast, letting you adapt quickly. Complex models, however, fail in silence.

Let’s model a basic rule: Buy if today’s open > yesterday’s open, hold for 1 day. Assume:

• 55% win rate (profit = 2%)

• 45% loss rate (loss = 1%)

Expected value per trade:

\(E = (0.55 \times 0.02) + (0.45 \times -0.01) = 0.011 - 0.0045 = 0.0065\)

That’s a 0.65% average gain per trade. Compound this over 100 trades, and you’re up ~92%.

Now, let’s make this spicy. Suppose you add a time limit to your trades (e.g., "close after 5 days, no matter what"). This rule does two things:

1. Caps your losses (no hoping a losing trade will recover).

2. Forces closing (no emotional clinging to winners).

Let’s recalculate EV with a time limit. Assume the time limit:

• Reduces loss size from -1% to -0.8% (because you exit earlier).

• Slightly reduces win size from +2% to +1.8% (because you exit winners too soon sometimes).

Then, to calculate the new expected value, let’s incorporate the updated values:

\(EV = (P_{\text{win}} \times \text{Win Size}) + (P_{\text{loss}} \times \text{Loss Size}) \)

\(EV = (0.5 \times 0.018) + (0.5 \times -0.008) = 0.005\)

Even with smaller wins and losses, the rule still works because the asymmetry (bigger wins than losses) is preserved. This is the heart of simple strategies: They’re not about being right all the time—they’re about being less wrong.

Why do simple rules win? They are like your favorite hoodie—comfortable, reliable, and always there when you need them. They shine for two big reasons:

1. Clear feedback: When a simple rule stops working, it’s immediately apparent.

2. Ease of adaptation: Unlike complex systems, simple rules can be adjusted or refined without the risk of disrupting an intricate network of dependencies.

####################################################################
  #      🔥 THIS SNIPPED WILL BE COMPLETED IN FUTURE POSTS 🔥
####################################################################

def combinations(iterable, r):
    """
    Generate combinations
    """
    pool = list(iterable)
    n = len(pool)
    if r > n:
        return
    indices = list(range(r))
    yield tuple(pool[i] for i in indices)
    while True:
        for i in reversed(range(r)):
            if indices[i] != i + n - r:
                break
        else:
            return
        indices[i] += 1
        for j in range(i + 1, r):
            indices[j] = indices[j - 1] + 1
        yield tuple(pool[x] for x in indices)

def same_rule(rule1, rule2):
    """
    Return True if both rules have the same base parameters
    """
    return (
        rule1['shift'] == rule2['shift'] and
        rule1['i'] == rule2['i'] and
        rule1['operator'] == rule2['operator'] and
        rule1['price_type'] == rule2['price_type'] and
        rule1['side'] == rule2['side'])


def update_buffer(buffer, new_rule, new_scores, top_n, scores=0.99):
  ...

####################################################################
#                 🔒 FOR PAID SUBSCRIBERS ONLY 🔒
####################################################################

Not bad for a rule a toddler could understand! The same rule working for 4 years across multiple market regimes. But wait—can something this simple really compete with machine learning?

Markets are mostly noise. Even the best ML models struggle because they’re trained to find patterns in chaos—like teaching a cat to solve Sudoku. Let’s model this.

Suppose the market’s daily return rt​ is:

\(r_t = \text{Signal} + \text{Noise}\)

The signal (0.1% daily drift) is dwarfed by noise (2% standard deviation). Now, let’s assume:

• Simple rule detects the signal 55% of the time.

• ML model detects it 70% of the time (wow, such genius!).

• ML model trades 10x more frequently.