Add abc_model.py

abc_model.py

@@ -0,0 +1,262 @@
+"""
+abc_model.py - ABC Model with Displacement Matrices (CORRECTED FOR KAPPA)
+
+KEY INSIGHT:
+    - B_i represents the DISPLACEMENT from current MB position to new position
+    - If MB is at (x₁, y₁) and we place piece at (x₂, y₂):
+    - Δx = x₂ - x₁
+    - Δy = y₂ - y₁
+    - B has right column (Δx, Δy, 1)ᵀ
+
+Example:
+    - Stage 0: MB at (0, 0, 1)
+    - Stage 1: Place at (-1, -1) → Δ = (-1-0, -1-0) = (-1, -1)
+    - B₁ right column: (-1, -1, 1)ᵀ
+    - Stage 2: Place at (0, 0) → Δ = (0-(-1), 0-(-1)) = (1, 1)
+    - B₂ right column: (1, 1, 1)ᵀ ✓
+
+Author: Chaim Duchovny
+Date: January 25, 2026 (FIXED FOR KAPPA SUPPORT)
+"""
+
+import numpy as np
+
+class ABCModelDynamic:
+    """ABC Model with displacement-based B matrices."""
+    
+    def __init__(self, n: int = 2, t: float = 1.0, T: float = 1.41):
+        """
+        Initialize for 2D board.
+        
+        Args:
+            n: Dimension (2 for 2D board)
+            t: Minimum distance threshold for adjacency
+            T: Maximum distance threshold for adjacency
+        """
+        self.n = n
+        self.t = t
+        self.T = T
+        self.c0 = np.array([0.0, 0.0, 1.0])
+        self.B_blocks = []        # Displacement matrices
+        self.piece_positions = [] # Actual positions on SB
+        self.a_product = np.eye(3) # Accumulated product
+        self.delta = {}           # Delta values for each piece
+        self.kappa = {}           # Tokenized vectors for each piece (ADDED)
+        self.stage = 0
+        
+        # MB position tracking
+        self.MB_current = self.c0.copy()  # Current MB center
+        self.MB_previous = self.c0.copy() # Previous MB center
+        self.history = []
+    
+    def create_B_displacement(self, dx: float, dy: float) -> np.ndarray:
+        """
+        Create displacement matrix B.
+        
+        Moves MB by (dx, dy) displacement.
+        
+        B · current_MB = new_MB
+        
+        B = [1 0 dx]
+            [0 1 dy]
+            [0 0 1]
+        
+        Right column: (dx, dy, 1)ᵀ
+        """
+        B = np.array([
+            [1.0, 0.0, dx],
+            [0.0, 1.0, dy],
+            [0.0, 0.0, 1.0]
+        ])
+        return B
+    
+    def add_piece(self, position: tuple, delta_values: tuple, kappa_vector: np.ndarray = None):
+        """
+        Add a piece at position with delta values and optional kappa vector.
+        
+        Args:
+            position: (x, y) tuple
+            delta_values: (Δ₁, Δ₂, Δ₃) tuple
+            kappa_vector: Tokenized feature vector (optional, defaults to delta_values)
+        """
+        x, y = position
+        
+        # Current MB position
+        current_MB = self.MB_current.copy()
+        
+        # Calculate displacement
+        dx = x - current_MB[0]
+        dy = y - current_MB[1]
+        
+        # Create displacement matrix
+        B_i = self.create_B_displacement(dx, dy)
+        
+        # Store
+        idx = len(self.B_blocks)
+        self.B_blocks.append(B_i)
+        self.piece_positions.append((x, y))
+        
+        # Update accumulated product: a_t = a_{t-1} · B_t
+        self.a_product = self.a_product @ B_i
+        
+        # Track MB positions
+        self.MB_previous = self.MB_current.copy()
+        self.MB_current = self.a_product @ self.c0  # Should equal (x, y, 1)
+        
+        # Store differential vector
+        self.delta[idx] = delta_values
+        
+        # Store tokenized vector (or use delta_values as default)
+        if kappa_vector is None:
+            kappa_vector = np.array(delta_values)
+        self.kappa[idx] = kappa_vector
+        
+        # Increment stage
+        self.stage += 1
+        
+        # Record move
+        self.history.append({
+            'stage': self.stage,
+            'SB_position': (x, y),
+            'displacement': (dx, dy),
+            'B_i': B_i.copy(),
+            'a_t': self.a_product.copy(),
+            'MB_prev': self.MB_previous.copy(),
+            'MB_curr': self.MB_current.copy(),
+            'delta': delta_values,
+            'kappa': kappa_vector.copy()
+        })
+    
+    def add_move(self, x: float, y: float, player: int):
+        """
+        Convenience method: Add a move with automatic delta values.
+        
+        Args:
+            x, y: Position coordinates
+            player: 1 for X (Δ₂=1.0), 2 for O (Δ₂=1.1)
+        """
+        delta_1 = 1.0  # Occupied
+        delta_2 = 1.0 if player == 1 else 1.1  # Player color
+        delta_3 = 1.0  # Same value for all pieces
+        
+        self.add_piece((x, y), (delta_1, delta_2, delta_3))
+    
+    def get_board_state(self) -> str:
+        """Visual board state."""
+        pos_map = {
+            (-1, 1): 0, (0, 1): 1, (1, 1): 2,
+            (-1, 0): 3, (0, 0): 4, (1, 0): 5,
+            (-1, -1): 6, (0, -1): 7, (1, -1): 8
+        }
+        
+        board = [' '] * 9
+        for i, pos in enumerate(self.piece_positions):
+            if pos in pos_map:
+                player = 'X' if self.delta[i][1] == 1.0 else 'O'
+                board[pos_map[pos]] = player
+        
+        s = f" {board[0]} | {board[1]} | {board[2]} \n"
+        s += "---|---|---\n"
+        s += f" {board[3]} | {board[4]} | {board[5]} \n"
+        s += "---|---|---\n"
+        s += f" {board[6]} | {board[7]} | {board[8]} \n"
+        return s
+    
+    def describe_move(self, stage: int):
+        """Describe a specific move."""
+        if stage < 1 or stage > len(self.history):
+            return "Invalid stage"
+        
+        move = self.history[stage - 1]
+        desc = "=" * 70 + "\n"
+        desc += f"MOVE {stage}: {move['SB_position']}\n"
+        desc += "=" * 70 + "\n\n"
+        
+        idx = stage - 1
+        B_i = self.B_blocks[idx]
+        
+        desc += f"Mobile Board (MB) movement:\n"
+        desc += f" Previous MB: {move['MB_prev']}\n"
+        desc += f" Target (SB): {move['SB_position']}\n"
+        desc += f" Displacement: Δ = {move['displacement']}\n"
+        desc += f" New MB: {move['MB_curr']}\n\n"
+        
+        desc += f"Displacement matrix B_{stage}:\n{B_i}\n"
+        desc += f"Right column: {B_i[:, 2]} = (Δx={move['displacement'][0]}, Δy={move['displacement'][1]}, 1)\n\n"
+        
+        desc += f"Accumulated product a_{stage}:\n{move['a_t']}\n"
+        desc += f"Right column: {move['a_t'][:, 2]}\n\n"
+        
+        desc += f"Delta values: {move['delta']}\n"
+        desc += f"Kappa vector: {move['kappa']}\n\n"
+        
+        desc += f"Verification:\n"
+        desc += f" a_{stage} · c₀ = {move['a_t'] @ self.c0}\n"
+        desc += f" Should equal: {np.array([move['SB_position'][0], move['SB_position'][1], 1.0])}\n\n"
+        
+        desc += "Board state:\n"
+        desc += self.get_board_state()
+        
+        return desc
+
+
+if __name__ == "__main__":
+    print("\n" + "=" * 70)
+    print("TIC-TAC-TOE - DISPLACEMENT-BASED B MATRICES")
+    print("=" * 70 + "\n")
+    
+    game = ABCModelDynamic(n=2, t=1.0, T=1.41)
+    
+    # Play complete game
+    moves = [
+        ((-1, -1), 1),  # Move 1: X at (-1,-1)
+        ((0, 0), 2),    # Move 2: O at (0,0)
+        ((0, -1), 1),   # Move 3: X at (0,-1)
+        ((1, 0), 2),    # Move 4: O at (1,0)
+    ]
+    
+    for pos, player in moves:
+        game.add_move(pos[0], pos[1], player)
+    
+    # Show first 4 moves in detail
+    for i in range(1, 5):
+        print(game.describe_move(i))
+        print()
+    
+    # Verification
+    print("=" * 70)
+    print("VERIFICATION")
+    print("=" * 70 + "\n")
+    
+    print("Key property: MB position tracks piece positions on SB")
+    for i in range(1, len(game.history) + 1):
+        move = game.history[i - 1]
+        MB_curr = move['MB_curr']
+        SB_pos = move['SB_position']
+        matches = np.allclose(MB_curr[:2], SB_pos)
+        print(f"Move {i}: MB={MB_curr} SB={SB_pos} Match? {matches} {'✓' if matches else '❌'}")
+    
+    print(f"\nB matrices (right columns = displacements):")
+    for i in range(1, len(game.history) + 1):
+        move = game.history[i - 1]
+        B_i = game.B_blocks[i - 1]
+        disp = move['displacement']
+        right_col = B_i[:, 2]
+        print(f" Move {i}: Δ={disp} → B right column = {right_col} ✓")
+    
+    print(f"\nKappa vectors (tokenized features):")
+    for i in range(len(game.history)):
+        kappa = game.kappa[i]
+        print(f" Piece {i}: κ = {kappa}")
+    
+    print(f"\nSpecial case - Move 2:")
+    move2 = game.history[1]
+    print(f" From (-1, -1) to (0, 0)")
+    print(f" Displacement: {move2['displacement']}")
+    print(f" B₂ right column: {game.B_blocks[1][:, 2]} = (1, 1, 1)ᵀ ✓✓✓")
+    
+    print("\n✓ MB position correctly tracks SB piece positions!")
+    print("✓ B matrices represent displacements!")
+    print("✓ B₂ has right column (1, 1, 1)ᵀ as expected!")
+    print("✓ Kappa vectors initialized correctly!")
+    print("=" * 70 + "\n")