class MinimalChessSolver:
    def __init__(self):
        self.transposition_table = {}  # ❌ Dictionary
        self.positions_explored = 0    # ❌ Counter
        self.time_budget = 60          # ❌ State variable

class ChessGameSeries:
    """
    Chess game = single series evolving over time
    No other data structures needed
    """
    def __init__(self):
        # Single series: list of game states
        self.series = []
        
    def append(self, state):
        """
        Add new state at time t
        
        state = {
            't': time,
            'position': FEN string,
            'move': move made,
            'eval': evaluation,
            'confidence': C value,
            'entropy': random component
        }
        """
        self.series.append(state)
    
    def at(self, t):
        """
        Get state at time t
        Compute on demand if needed
        """
        if t < len(self.series):
            return self.series[t]
        else:
            # Compute future state
            return self.compute_state(t)

# Store in dictionary
self.transposition_table[position] = move

# Later, look up
if position in self.transposition_table:
    return self.transposition_table[position]

def has_seen_position(self, position, series):
    """
    Check if position appears in series
    Compute on demand, don't store
    """
    for state in series:
        if state['position'] == position:
            return True, state['t']
    return False, None

def best_move_for_position(self, position, series):
    """
    Find best move for position from series
    Compute from series history, don't lookup dictionary
    """
    matches = [
        state for state in series 
        if state['position'] == position
    ]
    
    if not matches:
        return None
    
    # Return move with best evaluation
    best = max(matches, key=lambda s: s['eval'])
    return best['move']

self.positions_explored = 0

# Increment counter
self.positions_explored += 1

# Check count
if self.positions_explored > budget:
    stop()

def positions_explored(series):
    """
    Count positions from series
    No counter needed
    """
    return len(series)

def under_budget(series, budget):
    """
    Check if under budget
    Compute from series length
    """
    return len(series) < budget

self.time_budget = 60
start_time = time.now()

# Later
elapsed = time.now() - start_time
if elapsed > self.time_budget:
    stop()

def time_elapsed(series):
    """
    Compute time from series timestamps
    No variables needed
    """
    if len(series) == 0:
        return 0
    
    t_start = series[0]['t']
    t_now = series[-1]['t']
    return t_now - t_start

def time_per_move(series):
    """
    Compute average time per move
    """
    if len(series) <= 1:
        return 0
    
    return time_elapsed(series) / len(series)

def time_remaining(series, budget):
    """
    Compute remaining time
    """
    return budget - time_elapsed(series)

# Compute and store
eval_score = self.evaluate(position)
self.store(position, eval_score)  # Store it

def evaluate(position):
    """
    Compute evaluation on demand
    Don't store it
    """
    material = material_balance(position)
    positional = positional_score(position)
    return material + positional

def evaluate_at_t(series, t):
    """
    Evaluate position at time t
    Compute from series
    """
    state = series[t]
    return evaluate(state['position'])

eval_score = self.evaluate(position)
if eval_score >= 2.0:
    confidence = 1  # Store confidence

def confidence(series, t):
    """
    Compute confidence at time t
    From evaluation, not stored
    """
    eval_score = evaluate_at_t(series, t)
    
    if eval_score >= 2.0:
        return 1  # Confident
    else:
        return eval_score / 2.0  # Proportional

def is_confident(series, t):
    """
    Check if confident
    Compute from series
    """
    return confidence(series, t) >= 0.8

if position not in self.transposition_table:
    information = 0  # Store flag
else:
    information = 1

def has_information(series, position):
    """
    Check if position seen before
    Compute from series search
    """
    for state in series:
        if state['position'] == position:
            return 1  # Have information
    return 0  # No information

def information_at_t(series, t):
    """
    Information level at time t
    """
    current_position = series[t]['position']
    
    # Search earlier in series
    for i in range(t):
        if series[i]['position'] == current_position:
            return 1  # Seen before
    
    return 0  # Novel position

def rate_limiter_economic(series, budget):
    """
    Economic limiter: time remaining
    Compute from series
    """
    remaining = time_remaining(series, budget)
    total = budget
    return remaining / total  # 0.0 to 1.0

def rate_limiter_objective(series, t):
    """
    Objective limiter: position quality
    Compute from evaluation
    """
    eval_score = evaluate_at_t(series, t)
    
    if abs(eval_score) < 0.5:
        return 1.0  # Critical position
    elif abs(eval_score) < 1.5:
        return 0.6  # Moderate
    else:
        return 0.2  # One-sided

def rate_limiter_w_tracking(series, budget):
    """
    W tracking: positions explored
    Compute from series length
    """
    explored = len(series)
    ratio = explored / budget
    
    if ratio < 0.5:
        return 1.0
    elif ratio < 0.9:
        return 0.5
    else:
        return 0.1

def rate_limiter_topology(series, t):
    """
    Topology: legal moves
    Compute from position
    """
    position = series[t]['position']
    legal_moves = count_legal_moves(position)
    
    return min(1.0, legal_moves / 50)

def combined_rate_limiter(series, t, budget):
    """
    Combine all four limiters
    All computed from series
    """
    R = (
        rate_limiter_economic(series, budget) * 0.3 +
        rate_limiter_objective(series, t) * 0.3 +
        rate_limiter_w_tracking(series, budget) * 0.2 +
        rate_limiter_topology(series, t) * 0.2
    )
    return R

class PureSeriesChessSolver:
    """
    Chess solver using only series
    Compute everything on demand
    """
    
    def __init__(self):
        # Only series - no other data structures
        self.series = []
    
    def play_move(self, position, budget=60):
        """
        Choose move using three-state decision
        Everything computed from series
        """
        t = len(self.series)
        
        # STATE 1: Check confidence (computed from evaluation)
        eval_score = evaluate(position)
        
        if eval_score >= 2.0:
            # Confident - execute immediately
            move = self.execute_immediately(position)
            
        # STATE 2: Check information (computed from series)
        elif not has_information(self.series, position):
            # No information - randomize
            move = self.randomize(position)
            
        # STATE 3: Search with rate limiters (computed from series)
        else:
            # Have info, not confident - search
            R = combined_rate_limiter(self.series, t, budget)
            depth = self.adaptive_depth(R)
            move = self.search(position, depth)
        
        # Add to series
        self.append_to_series(t, position, move, eval_score)
        
        return move
    
    def execute_immediately(self, position):
        """
        STATE 1: Confident execution
        No data structures, just compute best move
        """
        legal = generate_legal_moves(position)
        
        # Evaluate each move
        evaluations = [
            (move, evaluate(apply_move(position, move)))
            for move in legal
        ]
        
        # Return best
        best_move, _ = max(evaluations, key=lambda x: x[1])
        return best_move
    
    def randomize(self, position):
        """
        STATE 2: Random exploration
        No storage, just random selection
        """
        legal = generate_legal_moves(position)
        return random.choice(legal)
    
    def search(self, position, depth):
        """
        STATE 3: Alpha-beta search
        No transposition table, pure recursive computation
        """
        best_move, _ = self.alpha_beta(
            position, 
            depth, 
            -999, 
            999, 
            True
        )
        return best_move
    
    def alpha_beta(self, position, depth, alpha, beta, maximizing):
        """
        Alpha-beta without transposition table
        Pure computation
        """
        if depth == 0:
            return None, evaluate(position)
        
        legal = generate_legal_moves(position)
        
        if maximizing:
            max_eval = -999
            best_move = None
            
            for move in legal:
                next_pos = apply_move(position, move)
                _, eval_score = self.alpha_beta(
                    next_pos, 
                    depth - 1, 
                    alpha, 
                    beta, 
                    False
                )
                
                if eval_score > max_eval:
                    max_eval = eval_score
                    best_move = move
                
                alpha = max(alpha, eval_score)
                if beta <= alpha:
                    break
            
            return best_move, max_eval
        
        else:
            min_eval = 999
            best_move = None
            
            for move in legal:
                next_pos = apply_move(position, move)
                _, eval_score = self.alpha_beta(
                    next_pos, 
                    depth - 1, 
                    alpha, 
                    beta, 
                    True
                )
                
                if eval_score < min_eval:
                    min_eval = eval_score
                    best_move = move
                
                beta = min(beta, eval_score)
                if beta <= alpha:
                    break
            
            return best_move, min_eval
    
    def adaptive_depth(self, R):
        """
        Compute search depth from rate limiter
        No state, pure function
        """
        if R > 0.7:
            return 5
        elif R > 0.4:
            return 3
        else:
            return 1
    
    def append_to_series(self, t, position, move, eval_score):
        """
        Add state to series
        Single source of truth
        """
        state = {
            't': t,
            'position': position,
            'move': move,
            'eval': eval_score,
            'timestamp': time.time()
        }
        self.series.append(state)

class MinimalChessSolver:
    def __init__(self):
        self.transposition_table = {}  # Dictionary
        self.positions_explored = 0    # Counter  
        self.time_budget = 60          # Variable

class PureSeriesChessSolver:
    def __init__(self):
        self.series = []  # Only series
        
    # Everything else computed on demand from series

# Post 858: Position stored in series AND dictionary
self.series.append(state)
self.transposition_table[position] = move  # Duplicate!

# Post 859: Position stored once in series
self.series.append(state)  # Single source of truth

# Post 858: Must keep dictionary and series in sync
self.series.append(state)
self.transposition_table[position] = move  # Must match!

# Post 859: Series is always consistent
self.series.append(state)  # Done - always in sync

# Post 858: Multiple state variables
transposition_table = {...}
positions_explored = 42
time_budget = 60
# Which is source of truth?

# Post 859: One series
series = [...]  # Everything here

# Post 859: Can compute state at any time t
state_at_t5 = series[5]
state_at_t10 = series[10]

# Can recompute anything from series
eval_at_t5 = evaluate(series[5]['position'])

def evolve_series(series, t, entropy):
    """
    Chess series evolution
    Following Post 810 universal format
    """
    if t == 0:
        # Initial state
        return initial_position()
    
    # Current state
    current = series[t-1]
    
    # Deterministic component: f(data(t))
    position = current['position']
    confidence = compute_confidence(position)
    information = compute_information(series, position)
    
    # Entropy component: random exploration
    if information == 0:
        # STATE 2: Inject entropy
        move = random_move(position, entropy)
    elif confidence >= 0.8:
        # STATE 1: Deterministic (no entropy)
        move = best_move(position)
    else:
        # STATE 3: Guided search (small entropy in move ordering)
        move = search_move(position, entropy)
    
    # Next state
    next_position = apply_move(position, move)
    next_eval = evaluate(next_position)
    
    return {
        't': t,
        'position': next_position,
        'move': move,
        'eval': next_eval,
        'entropy': entropy
    }

# Linear search through series
# For chess game: ~100 moves average
# 100 comparisons = negligible

# Dictionary lookup:
# O(1) but with overhead
# Hash computation, collision handling

# For small n, linear ≈ hash

# Post 858: Allocate dictionary entries
transposition_table[pos] = move  # Memory allocation

# Post 859: No allocation
# Just search existing series

# Series: Sequential memory access
# Good cache locality

# Dictionary: Random memory access
# Poor cache locality

# Material count: O(64) square scan
# Positional score: O(64) square scan
# Total: ~100 operations

# Lookup overhead:
# Hash function: ~50 operations
# Not much savings

# Query any value from series

def get_position_at_t(series, t):
    """Position at time t"""
    return series[t]['position']

def get_move_at_t(series, t):
    """Move at time t"""
    return series[t]['move']

def get_evaluation_at_t(series, t):
    """Evaluation at time t (compute if not stored)"""
    if 'eval' in series[t]:
        return series[t]['eval']
    else:
        return evaluate(series[t]['position'])

def get_all_positions(series):
    """All positions in game"""
    return [state['position'] for state in series]

def get_move_history(series):
    """All moves in order"""
    return [state['move'] for state in series]

def get_evaluation_series(series):
    """Evaluation over time"""
    return [
        evaluate(state['position']) 
        for state in series
    ]

def find_position_occurrences(series, position):
    """Times position appeared"""
    return [
        state['t'] 
        for state in series 
        if state['position'] == position
    ]

# All functions pure (no side effects)

def evaluate(position):
    """Pure: same input → same output"""
    return material_balance(position) + positional_score(position)

def has_information(series, position):
    """Pure: only reads series, doesn't modify"""
    return any(s['position'] == position for s in series)

def rate_limiter(series, t, budget):
    """Pure: computes from series"""
    return compute_R(series, t, budget)

def choose_move(series, position, budget):
    """Pure: returns move, doesn't mutate"""
    # Compute everything from inputs
    eval_score = evaluate(position)
    info = has_information(series, position)
    R = rate_limiter(series, len(series), budget)
    
    # Return move based on computations
    if eval_score >= 2.0:
        return execute_immediately(position)
    elif info == 0:
        return randomize(position)
    else:
        return search(position, adaptive_depth(R))

def query_series(series):
    """
    Rich queries from single series
    No indexes, no caching - pure computation
    """
    return {
        # Basic queries
        'game_length': len(series),
        'current_position': series[-1]['position'],
        'current_eval': evaluate(series[-1]['position']),
        
        # Time queries
        'time_elapsed': time_elapsed(series),
        'avg_time_per_move': time_per_move(series),
        
        # Position queries
        'positions_explored': len(series),
        'unique_positions': len(set(s['position'] for s in series)),
        'repeated_positions': find_repetitions(series),
        
        # Evaluation queries
        'max_eval': max(evaluate(s['position']) for s in series),
        'min_eval': min(evaluate(s['position']) for s in series),
        'eval_trend': [evaluate(s['position']) for s in series],
        
        # Move queries
        'most_common_move': most_common_move(series),
        'move_diversity': len(set(s['move'] for s in series)),
        
        # State queries
        'confident_moves': sum(1 for s in series if evaluate(s['position']) >= 2.0),
        'exploratory_moves': sum(1 for s in series if not has_info_before(series, s)),
        'search_moves': len(series) - confident_moves - exploratory_moves
    }