feat: add multi-evidence extension with configurable evidence types

- Add Basic and Extended evidence type configuration
- Implement multi-evidence generation (e.g., ["lower", "half"])
- Update Bayesian inference for joint probability calculations
- Add UI dropdown for evidence type selection
- Maintain domain separation and architectural constraints
- Update all tests (83 passing) for new multi-evidence format

Basic Evidence: higher/lower/same
Extended Evidence: adds half/double for richer inference

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: thompsonson

CLAUDE.md

@@ -6,28 +6,39 @@ A Bayesian Game implementation featuring a Belief-based Agent using domain-drive
 ## Game Rules
 - Judge and Player 1 can see the target die value
 - Player 2 must deduce the target value using only comparison results
-- Player 1 rolls dice and reports "higher"/"lower"/"same" compared to target
-- **CRITICAL**: Player 2 receives ONLY the comparison result, NOT the dice roll value
+- Player 1 rolls dice and reports evidence based on selected evidence type
+- **CRITICAL**: Player 2 receives ONLY the evidence results, NOT the dice roll value
 - Game runs for 10 rounds
 - Judge ensures truth-telling
 
+### Evidence Types
+**Basic Evidence**: `["higher", "lower", "same"]`
+- Standard comparison between dice roll and target
+
+**Extended Evidence**: `["higher", "lower", "same", "half", "double"]`
+- Multiple evidence types can apply to single roll
+- "half": dice_roll = target/2 (exact integer matches only)
+- "double": dice_roll = target*2 (exact integer matches only)
+- Example: target=4, dice_roll=2 → evidence=`["lower", "half"]`
+
 ## Development Practices
 - Use conventional commits when committing code to git
 - Always use uv and the local venv
+- Always use the make file for devops-style tasks
 
 ## Architecture
 Domain-Driven Design with 3 modules:
 
 1. **Environment Domain** (`domains/environment/environment_domain.py`)
-   - EnvironmentEvidence dataclass (contains dice_roll AND comparison_result)
-   - Environment class for target/evidence generation
+   - EnvironmentEvidence dataclass (contains dice_roll AND comparison_results)
+   - Environment class for target/evidence generation with configurable evidence types
    - **ACCESS**: Full knowledge of dice rolls and target values
 
 2. **Belief Domain** (`domains/belief/belief_domain.py`)
-   - BeliefUpdate dataclass (contains ONLY comparison_result)
-   - BayesianBeliefState class for inference
+   - BeliefUpdate dataclass (contains ONLY comparison_results as List[str])
+   - BayesianBeliefState class for inference with multi-evidence support
    - **ACCESS**: NO knowledge of dice roll values or true target
-   - **CONSTRAINT**: Must calculate P(comparison_result | target) probabilistically
+   - **CONSTRAINT**: Must calculate P(comparison_results | target) probabilistically for multiple evidence types
 
 3. **Game Coordination** (`domains/coordination/game_coordination.py`)
    - GameState dataclass (tracks full game state)
@@ -63,43 +74,55 @@ bayesian_game/
 ## Key Design Decisions & Architectural Constraints
 
 ### Information Flow Rules
-1. **Environment → Coordination**: EnvironmentEvidence (dice_roll + comparison_result)
-2. **Coordination → Belief**: BeliefUpdate (comparison_result ONLY)
+1. **Environment → Coordination**: EnvironmentEvidence (dice_roll + comparison_results)
+2. **Coordination → Belief**: BeliefUpdate (comparison_results ONLY as List[str])
 3. **NEVER**: Direct Environment → Belief communication
 4. **NEVER**: Belief domain access to dice roll values
 
+### Multi-Evidence Processing
+- Environment generates all applicable evidence types for each roll
+- Coordination filters dice_roll information before passing to belief domain
+- Belief domain calculates joint probabilities: P(comparison_results | target)
+- UI displays evidence configuration options (Basic vs Extended)
+
 ### Domain Separation Principles
 - **Environment Domain**: No probability knowledge, pure evidence generation
 - **Belief Domain**: Pure Bayesian inference, no knowledge of actual dice values
 - **Coordination Layer**: Thin orchestration, responsible for information filtering
 - **UI Layer**: Separate from core game logic, can display full information
 
 ### Critical Implementation Rules
-- BeliefUpdate dataclass MUST contain only comparison_result
-- BayesianBeliefState MUST calculate P(comparison_result | target) probabilistically
+- BeliefUpdate dataclass MUST contain only comparison_results as List[str]
+- BayesianBeliefState MUST calculate P(comparison_results | target) probabilistically for multi-evidence
 - Game coordination MUST filter dice_roll from EnvironmentEvidence before passing to belief domain
 - Tests MUST verify that belief domain never receives dice roll values
+- Evidence type configuration MUST be passed through coordination layer, not directly to belief domain
 
 ## Maintaining Architectural Integrity
 
 ### Code Review Checklist
 When modifying the codebase, ensure:
-- [ ] BeliefUpdate contains ONLY comparison_result field
+- [ ] BeliefUpdate contains ONLY comparison_results field (List[str])
 - [ ] No dice_roll parameter passed to belief domain methods
 - [ ] Game coordination filters EnvironmentEvidence properly
 - [ ] Tests verify belief domain isolation
-- [ ] Belief calculations use probabilistic formulas, not direct dice values
+- [ ] Belief calculations use probabilistic formulas for multi-evidence: P(comparison_results | target)
+- [ ] Evidence type configuration flows through coordination layer
+- [ ] UI evidence type selection properly configures game behavior
 
 ### Anti-Patterns to Avoid
-❌ `BeliefUpdate(dice_roll=X, comparison_result=Y)` - belief shouldn't know dice value
+❌ `BeliefUpdate(dice_roll=X, comparison_results=Y)` - belief shouldn't know dice value
 ❌ Direct Environment-Belief communication
 ❌ Belief domain knowing actual dice roll or target values
-❌ Hard-coded probability values instead of calculated P(comparison_result | target)
+❌ Hard-coded probability values instead of calculated P(comparison_results | target)
+❌ Passing evidence type configuration directly to belief domain
 
 ### Correct Patterns
-✅ `BeliefUpdate(comparison_result="higher")` - only comparison result
+✅ `BeliefUpdate(comparison_results=["lower", "half"])` - only evidence results
 ✅ Environment → Coordination → Belief information flow
-✅ Probabilistic calculations: P(roll > target) = (dice_sides - target) / dice_sides
+✅ Probabilistic calculations for multi-evidence: P(comparison_results | target)
+✅ Evidence type configuration handled in coordination layer
+✅ Joint probability calculations: P(["lower", "half"] | target) = P(dice_roll=target/2 AND dice_roll<target)
 ✅ Clean domain boundaries with no cross-dependencies
 
 ## Dependencies

domains/belief/belief_domain.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Literal
 
 import numpy as np
 
@@ -8,7 +7,7 @@
 class BeliefUpdate:
     """Update information for Bayesian belief state."""
 
-    comparison_result: Literal["higher", "lower", "same"]
+    comparison_results: list[str]
 
 
 class BayesianBeliefState:
@@ -65,26 +64,19 @@ def update_beliefs(self, evidence: BeliefUpdate) -> None:
         """
         self.evidence_history.append(evidence)
 
-        comparison_result = evidence.comparison_result
+        comparison_results = evidence.comparison_results
 
         # Calculate likelihood for each possible target value
         likelihoods = np.zeros(self.dice_sides)
 
         for target_idx in range(self.dice_sides):
             target_value = target_idx + 1
 
-            # Calculate P(comparison_result | target_value)
-            # This is the probability that ANY dice roll would produce this comparison result
-            if comparison_result == "higher":
-                # P(roll > target) = (dice_sides - target) / dice_sides
-                likelihood = (self.dice_sides - target_value) / self.dice_sides
-            elif comparison_result == "lower":
-                # P(roll < target) = (target - 1) / dice_sides
-                likelihood = (target_value - 1) / self.dice_sides
-            else:  # comparison_result == "same"
-                # P(roll = target) = 1 / dice_sides
-                likelihood = 1 / self.dice_sides
-
+            # Calculate P(comparison_results | target_value)
+            # This is the joint probability that a dice roll would produce ALL these evidence types
+            likelihood = self._calculate_joint_likelihood(
+                comparison_results, target_value
+            )
             likelihoods[target_idx] = likelihood
 
         # Apply Bayes' rule: posterior ∝ prior * likelihood
@@ -99,6 +91,54 @@ def update_beliefs(self, evidence: BeliefUpdate) -> None:
             # reset to uniform distribution
             self.beliefs = np.ones(self.dice_sides) / self.dice_sides
 
+    def _calculate_joint_likelihood(
+        self, comparison_results: list[str], target_value: int
+    ) -> float:
+        """Calculate P(comparison_results | target_value) for multiple evidence types.
+
+        Args:
+            comparison_results: List of evidence results (e.g., ["lower", "half"])
+            target_value: Target value to calculate likelihood for
+
+        Returns:
+            Joint probability of observing all evidence types given the target
+        """
+        # For multiple evidence types from a single roll, we need to find
+        # the probability that a single dice roll satisfies ALL conditions
+
+        # Count dice rolls that satisfy all evidence conditions
+        satisfying_rolls = 0
+
+        for dice_roll in range(1, self.dice_sides + 1):
+            satisfies_all = True
+
+            for evidence in comparison_results:
+                if (
+                    (evidence == "higher" and not (dice_roll > target_value))
+                    or (evidence == "lower" and not (dice_roll < target_value))
+                    or (evidence == "same" and dice_roll != target_value)
+                    or (
+                        evidence == "half"
+                        and not (
+                            target_value % 2 == 0 and dice_roll == target_value // 2
+                        )
+                    )
+                    or (
+                        evidence == "double"
+                        and not (
+                            dice_roll == target_value * 2
+                            and dice_roll <= self.dice_sides
+                        )
+                    )
+                ):
+                    satisfies_all = False
+                    break
+
+            if satisfies_all:
+                satisfying_rolls += 1
+
+        return satisfying_rolls / self.dice_sides
+
     def reset_beliefs(self) -> None:
         """Reset beliefs to uniform prior and clear evidence history."""
         self.beliefs = np.ones(self.dice_sides) / self.dice_sides

domains/coordination/game_coordination.py

@@ -3,7 +3,11 @@
 from typing import Any
 
 from ..belief.belief_domain import BayesianBeliefState, BeliefUpdate
-from ..environment.environment_domain import Environment, EnvironmentEvidence
+from ..environment.environment_domain import (
+    Environment,
+    EnvironmentEvidence,
+    EvidenceType,
+)
 
 
 class GamePhase(Enum):
@@ -42,20 +46,28 @@ class BayesianGame:
     """
 
     def __init__(
-        self, dice_sides: int = 6, max_rounds: int = 10, seed: int | None = None
+        self,
+        dice_sides: int = 6,
+        max_rounds: int = 10,
+        evidence_type: EvidenceType = EvidenceType.BASIC,
+        seed: int | None = None,
     ):
         """Initialize the Bayesian Game.
 
         Args:
             dice_sides: Number of sides on the dice
             max_rounds: Maximum number of rounds to play
+            evidence_type: Type of evidence to generate (basic or extended)
             seed: Random seed for reproducible results
         """
         self.dice_sides = dice_sides
         self.max_rounds = max_rounds
+        self.evidence_type = evidence_type
 
         # Initialize domains
-        self.environment = Environment(dice_sides=dice_sides, seed=seed)
+        self.environment = Environment(
+            dice_sides=dice_sides, evidence_type=evidence_type, seed=seed
+        )
         self.belief_state = BayesianBeliefState(dice_sides=dice_sides)
 
         # Initialize game state
@@ -113,8 +125,8 @@ def play_round(self) -> GameState:
         # Generate evidence from environment
         evidence = self.environment.roll_dice_and_compare()
 
-        # Update belief state (only pass comparison result, not dice roll)
-        belief_update = BeliefUpdate(comparison_result=evidence.comparison_result)
+        # Update belief state (only pass comparison results, not dice roll)
+        belief_update = BeliefUpdate(comparison_results=evidence.comparison_results)
         self.belief_state.update_beliefs(belief_update)
 
         # Update game state

domains/environment/environment_domain.py

@@ -1,14 +1,21 @@
 import random
 from dataclasses import dataclass
-from typing import Literal
+from enum import Enum
+
+
+class EvidenceType(Enum):
+    """Types of evidence that can be generated."""
+
+    BASIC = "basic"
+    EXTENDED = "extended"
 
 
 @dataclass
 class EnvironmentEvidence:
-    """Evidence generated by the environment - dice roll and comparison result."""
+    """Evidence generated by the environment - dice roll and comparison results."""
 
     dice_roll: int
-    comparison_result: Literal["higher", "lower", "same"]
+    comparison_results: list[str]
 
 
 class Environment:
@@ -17,14 +24,21 @@ class Environment:
     Has no knowledge of probabilities - purely generates observable evidence.
     """
 
-    def __init__(self, dice_sides: int = 6, seed: int | None = None):
+    def __init__(
+        self,
+        dice_sides: int = 6,
+        evidence_type: EvidenceType = EvidenceType.BASIC,
+        seed: int | None = None,
+    ):
         """Initialize environment with dice configuration.
 
         Args:
             dice_sides: Number of sides on the dice (default 6)
+            evidence_type: Type of evidence to generate (basic or extended)
             seed: Random seed for reproducible results
         """
         self.dice_sides = dice_sides
+        self.evidence_type = evidence_type
         self._random_state = (
             random.Random(seed) if seed is not None else random.Random()
         )
@@ -67,7 +81,7 @@ def roll_dice_and_compare(self) -> EnvironmentEvidence:
         """Roll dice and compare to target, generating evidence.
 
         Returns:
-            EnvironmentEvidence with dice roll and comparison result
+            EnvironmentEvidence with dice roll and comparison results
 
         Raises:
             ValueError: If target value hasn't been set
@@ -76,14 +90,26 @@ def roll_dice_and_compare(self) -> EnvironmentEvidence:
             raise ValueError("Target value not set")
 
         dice_roll = self._random_state.randint(1, self.dice_sides)
+        comparison_results = []
 
+        # Basic evidence: higher/lower/same
         if dice_roll > self._target_value:
-            comparison_result = "higher"
+            comparison_results.append("higher")
         elif dice_roll < self._target_value:
-            comparison_result = "lower"
+            comparison_results.append("lower")
         else:
-            comparison_result = "same"
+            comparison_results.append("same")
+
+        # Extended evidence: half/double (only for extended type)
+        if self.evidence_type == EvidenceType.EXTENDED:
+            # Check for "half" - dice_roll = target/2 (exact integer only)
+            if self._target_value % 2 == 0 and dice_roll == self._target_value // 2:
+                comparison_results.append("half")
+
+            # Check for "double" - dice_roll = target*2 (within dice range)
+            if dice_roll == self._target_value * 2 and dice_roll <= self.dice_sides:
+                comparison_results.append("double")
 
         return EnvironmentEvidence(
-            dice_roll=dice_roll, comparison_result=comparison_result
+            dice_roll=dice_roll, comparison_results=comparison_results
         )