Here are some well-established strategies, while noting that past performance doesn't guarantee future results:


1. Statistical Arbitrage
The most well-documented successful strategy involves identifying price discrepancies between related securities. For example, pairs trading between two highly correlated stocks (like Coca-Cola and Pepsi) to profit from temporary price divergences.

2. Market Making
This provides liquidity to markets by simultaneously maintaining buy and sell orders with a small spread. Renaissance Technologies and Citadel have successfully used sophisticated versions of this approach.

3. Trend Following
Following medium to long-term price trends using moving averages and other technical indicators. The most notable example is AQR Capital Management, which has successfully implemented trend-following across multiple asset classes.

4. Mean Reversion
Trading based on the assumption that asset prices tend to move back toward their historical average. Many high-frequency trading firms use this approach for short-term trades.

Key success factors include:
- Low latency infrastructure
- High-quality data processing
- Sophisticated risk management
- Careful position sizing
- Regular strategy retraining and adaptation

import numpy as npimport pandas as pdfrom typing import List, Tuple, Dictimport yfinance as yffrom scipy import statsclass AlgoTrader:    def __init__(self, initial_capital: float = 100000):        self.capital = initial_capital        self.positions = {}        self.trades_history = []    def statistical_arbitrage(self, stock1_data: pd.DataFrame, stock2_data: pd.DataFrame,                             lookback_period: int = 20, z_score_threshold: float = 2.0) -> List[Dict]:        """        Statistical arbitrage using pairs trading strategy.                Args:            stock1_data: DataFrame with 'Close' prices for first stock            stock2_data: DataFrame with 'Close' prices for second stock            lookback_period: Period for calculating spread            z_score_threshold: Z-score threshold for trading signals        """        # Calculate price ratio        ratio = stock1_data['Close'] / stock2_data['Close']                # Calculate z-score of ratio        ratio_mean = ratio.rolling(window=lookback_period).mean()        ratio_std = ratio.rolling(window=lookback_period).std()        z_score = (ratio - ratio_mean) / ratio_std                signals = []        position = 0                for i in range(lookback_period, len(z_score)):            if z_score[i] > z_score_threshold and position <= 0:                # Short stock1, long stock2                signals.append({                    'date': stock1_data.index[i],                    'action': 'OPEN_SHORT',                    'stock1_price': stock1_data['Close'][i],                    'stock2_price': stock2_data['Close'][i],                    'z_score': z_score[i]                })                position = -1            elif z_score[i] < -z_score_threshold and position >= 0:                # Long stock1, short stock2                signals.append({                    'date': stock1_data.index[i],                    'action': 'OPEN_LONG',                    'stock1_price': stock1_data['Close'][i],                    'stock2_price': stock2_data['Close'][i],                    'z_score': z_score[i]                })                position = 1            elif abs(z_score[i]) < 0.5 and position != 0:                # Close positions                signals.append({                    'date': stock1_data.index[i],                    'action': 'CLOSE',                    'stock1_price': stock1_data['Close'][i],                    'stock2_price': stock2_data['Close'][i],                    'z_score': z_score[i]                })                position = 0                        return signals    def market_making(self, orderbook: pd.DataFrame, spread_threshold: float = 0.02,                      position_limit: int = 1000) -> List[Dict]:        """        Basic market making strategy.                Args:            orderbook: DataFrame with bid/ask prices and volumes            spread_threshold: Minimum spread to participate            position_limit: Maximum position size        """        signals = []        position = 0                for i in range(len(orderbook)):            bid = orderbook.iloc[i]['bid']            ask = orderbook.iloc[i]['ask']            spread = (ask - bid) / bid                        if spread > spread_threshold:                # Calculate order sizes based on position limits                bid_size = min(position_limit - position, 100)                ask_size = min(position_limit + position, 100)                                if bid_size > 0:                    signals.append({                        'timestamp': orderbook.index[i],                        'action': 'BID',                        'price': bid,                        'size': bid_size                    })                                if ask_size > 0:                    signals.append({                        'timestamp': orderbook.index[i],                        'action': 'ASK',                        'price': ask,                        'size': ask_size                    })                        return signals    def trend_following(self, price_data: pd.DataFrame,                        short_window: int = 20, long_window: int = 50) -> List[Dict]:        """        Trend following strategy using moving averages.                Args:            price_data: DataFrame with 'Close' prices            short_window: Short-term moving average period            long_window: Long-term moving average period        """        # Calculate moving averages        short_ma = price_data['Close'].rolling(window=short_window).mean()        long_ma = price_data['Close'].rolling(window=long_window).mean()                signals = []        position = 0                for i in range(long_window, len(price_data)):            if short_ma[i] > long_ma[i] and position <= 0:                # Generate buy signal                signals.append({                    'date': price_data.index[i],                    'action': 'BUY',                    'price': price_data['Close'][i],                    'short_ma': short_ma[i],                    'long_ma': long_ma[i]                })                position = 1            elif short_ma[i] < long_ma[i] and position >= 0:                # Generate sell signal                signals.append({                    'date': price_data.index[i],                    'action': 'SELL',                    'price': price_data['Close'][i],                    'short_ma': short_ma[i],                    'long_ma': long_ma[i]                })                position = -1                        return signals    def mean_reversion(self, price_data: pd.DataFrame,                       lookback_period: int = 20,                       std_dev_threshold: float = 2.0) -> List[Dict]:        """        Mean reversion strategy using Bollinger Bands.                Args:            price_data: DataFrame with 'Close' prices            lookback_period: Period for calculating mean and std            std_dev_threshold: Number of standard deviations for bands        """        # Calculate Bollinger Bands        rolling_mean = price_data['Close'].rolling(window=lookback_period).mean()        rolling_std = price_data['Close'].rolling(window=lookback_period).std()                upper_band = rolling_mean + (rolling_std * std_dev_threshold)        lower_band = rolling_mean - (rolling_std * std_dev_threshold)                signals = []        position = 0                for i in range(lookback_period, len(price_data)):            price = price_data['Close'][i]                        if price > upper_band[i] and position >= 0:                # Generate sell signal                signals.append({                    'date': price_data.index[i],                    'action': 'SELL',                    'price': price,                    'upper_band': upper_band[i],                    'lower_band': lower_band[i],                    'mean': rolling_mean[i]                })                position = -1            elif price < lower_band[i] and position <= 0:                # Generate buy signal                signals.append({                    'date': price_data.index[i],                    'action': 'BUY',                    'price': price,                    'upper_band': upper_band[i],                    'lower_band': lower_band[i],                    'mean': rolling_mean[i]                })                position = 1            elif abs(price - rolling_mean[i]) < rolling_std[i] and position != 0:                # Close position when price returns to mean                signals.append({                    'date': price_data.index[i],                    'action': 'CLOSE',                    'price': price,                    'upper_band': upper_band[i],                    'lower_band': lower_band[i],                    'mean': rolling_mean[i]                })                position = 0                        return signals# Example usagedef main():    # Initialize trader    trader = AlgoTrader(initial_capital=100000)        # Get sample data    stock1 = yf.download('KO', start='2023-01-01', end='2024-01-01')    stock2 = yf.download('PEP', start='2023-01-01', end='2024-01-01')        # Run statistical arbitrage    stat_arb_signals = trader.statistical_arbitrage(stock1, stock2)        # Run trend following    trend_signals = trader.trend_following(stock1)        # Run mean reversion    mean_rev_signals = trader.mean_reversion(stock1)        # Print sample results    print("Statistical Arbitrage Signals:", len(stat_arb_signals))    print("Trend Following Signals:", len(trend_signals))    print("Mean Reversion Signals:", len(mean_rev_signals))if __name__ == "__main__":    main()