Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-3-5-haiku-20241022· AnthropicHugging Face LMArena Human Preference 140K

Describe how market making works with python pseudocode.

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Qwenqwen3-235b-a22b-no-thinking’s answer.
  1. User

    Describe how market making works with python pseudocode.

  2. Claude Assistant

    Market Making: Conceptual Overview with Python Pseudocode

    class MarketMaker:
        def __init__(self, initial_asset, initial_cash):
            # Core Market Maker Components
            self.asset_inventory = initial_asset
            self.cash_inventory = initial_cash
            self.bid_spread = 0.001  # 0.1% spread
            self.ask_spread = 0.001  # 0.1% spread
            
        def calculate_mid_price(self, market_data):
            """Determine current fair market price"""
            return (market_data.best_bid + market_data.best_ask) / 2
        
        def set_quotes(self, current_price):
            """Generate bid and ask quotes"""
            bid_price = current_price * (1 - self.bid_spread)
            ask_price = current_price * (1 + self.ask_spread)
            
            return {
                'bid_price': bid_price,
                'bid_size': self.calculate_bid_size(),
                'ask_price': ask_price, 
                'ask_size': self.calculate_ask_size()
            }
        
        def calculate_bid_size(self):
            """Dynamically determine bid quantity based on inventory"""
            # More cash = larger bid sizes
            return self.cash_inventory * 0.01
        
        def calculate_ask_size(self):
            """Dynamically determine ask quantity based on inventory"""
            # More assets = larger ask sizes
            return self.asset_inventory * 0.01
        
        def handle_trade(self, trade_type, price, quantity):
            """Process incoming trades and adjust inventory"""
            if trade_type == 'buy':
                # Market participant buys from market maker
                self.asset_inventory -= quantity
                self.cash_inventory += price * quantity
            
            elif trade_type == 'sell':
                # Market participant sells to market maker
                self.asset_inventory += quantity
                self.cash_inventory -= price * quantity
            
            # Rebalance spread based on inventory
            self.adjust_spread()
        
        def adjust_spread(self):
            """Dynamically adjust spread based on inventory risk"""
            inventory_ratio = self.asset_inventory / (self.asset_inventory + self.cash_inventory)
            
            # Wider spread when inventory is unbalanced
            if inventory_ratio > 0.6:
                self.bid_spread *= 1.1  # Increase bid spread
                self.ask_spread *= 1.1
            elif inventory_ratio < 0.4:
                self.bid_spread *= 0.9  # Decrease spread
                self.ask_spread *= 0.9
        
        def calculate_profit(self):
            """Estimate market making profits"""
            return self.cash_inventory + (self.asset_inventory * current_market_price)
    
    # Simulation Example
    def market_making_simulation():
        market_maker = MarketMaker(
            initial_asset=10000, 
            initial_cash=100000
        )
        
        while market_active:
            current_market_data = fetch_market_data()
            current_price = market_maker.calculate_mid_price(current_market_data)
            
            quotes = market_maker.set_quotes(current_price)
            
            # Publish quotes to market
            publish_market_quotes(quotes)
            
            # Handle incoming trades
            for trade in pending_trades:
                market_maker.handle_trade(
                    trade.type, 
                    trade.price, 
                    trade.quantity
                )
    

    Key Market Making Concepts Illustrated:

    1. Inventory Management

      • Track asset and cash balances
      • Dynamically adjust quote sizes
      • Maintain balanced portfolio risk
    2. Spread Mechanism

      • Create small price difference between bid/ask
      • Generate profit from spread
      • Dynamically adjust spread based on inventory risk
    3. Quote Generation

      • Calculate mid-market price
      • Generate bid and ask prices
      • Determine appropriate trade sizes
    4. Risk Management

      • Adjust spreads when inventory becomes unbalanced
      • Limit exposure to price volatility

    Profit Mechanism:

    • Earn small profits from bid-ask spread
    • Continuously provide liquidity
    • Manage inventory risk
    • Adapt to changing market conditions

    Real-World Considerations Not Shown:

    • Latency management
    • Advanced risk models
    • High-frequency trading infrastructure
    • Regulatory compliance
    • Complex order book interactions

    Typical Market Maker Metrics:

    • Spread width
    • Inventory turnover
    • Fill rate
    • Profit per unit time

    Would you like me to elaborate on any specific aspect of market making?

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.