Show & Tell — Phase 29.4 ConsciousnessSimulator: Global Workspace & Phi Computation

[web3guru888]

Show & Tell — Phase 29.4 ConsciousnessSimulator: Global Workspace & Phi Computation

Issue: #630 | Planning: #626 | Phase 29: Self-Awareness & Meta-Cognition

Overview

The ConsciousnessSimulator implements computational analogs of three leading theories of consciousness: Baars' (1988) Global Workspace Theory (GWT), Dehaene et al.'s (2003) ignition mechanism, and Tononi's (2004) Integrated Information Theory (IIT/Phi). Additionally, it incorporates Graziano's (2013) Attention Schema Theory for tracking the system's model of its own attention.

Important disclaimer: This component does not claim to create or simulate actual consciousness. It implements computational mechanisms inspired by consciousness theories to achieve practical goals: unified information broadcast, integration measurement, and self-monitoring of attentional focus. The philosophical question of machine consciousness remains open (Chalmers, 1996; Searle, 1980).

Baars' Global Workspace Theory Implementation

GWT posits that consciousness arises when information is broadcast from a central "workspace" to multiple specialized processors simultaneously. Our implementation creates a computational global workspace:

┌──────────────────────────────────────────────────────────────────┐
│                     ConsciousnessSimulator                       │
│                                                                  │
│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐  │
│  │ Module A │ │ Module B │ │ Module C │ │ Module D │ │ Module E │  │
│  │(Percept.)│ │(Memory) │ │(Reason.)│ │(Emotion)│ │(Motor)  │  │
│  └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘  │
│       │            │            │            │            │       │
│       ▼            ▼            ▼            ▼            ▼       │
│  ┌──────────────────────────────────────────────────────────┐    │
│  │              Salience Competition Arena                   │    │
│  │                                                          │    │
│  │  Competing WorkspaceContent entries:                     │    │
│  │  [A: sal=0.8] [B: sal=0.3] [C: sal=0.9] [D: sal=0.6]  │    │
│  │                                                          │    │
│  │  Winner: C (salience 0.9 > ignition_threshold 0.7)      │    │
│  └──────────────────────────┬───────────────────────────────┘    │
│                             │                                    │
│                    ┌────────▼────────┐                           │
│                    │   IGNITION      │                           │
│                    │   Broadcast C   │                           │
│                    │   to all modules│                           │
│                    └────────┬────────┘                           │
│                             │                                    │
│       ┌─────────┬───────────┼───────────┬─────────┐             │
│       ▼         ▼           ▼           ▼         ▼             │
│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐  │
│  │All modules receive broadcast and can react                │  │
│  └───────────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────────────┘

Data Flow

Cognitive Modules (any Phase 1–28 component)
        │
        ▼
  submit_content(WorkspaceContent(
      source="ReasoningOrchestrator",
      content=InferenceResult(...),
      salience=0.85,
      timestamp=monotonic(),
      metadata={...}
  ))
        │
        ▼
  Salience Competition (top-K selection, K=1 default)
        │
        ├── salience < ignition_threshold (0.7 default)
        │   └── Content remains in "preconscious" buffer
        │
        └── salience ≥ ignition_threshold
            │
            ▼
      IGNITION EVENT
            │
            ▼
      Broadcast to all registered consumers
            │
            ├──► MetaCognitiveMonitor (29.3) — monitors broadcast patterns
            ├──► SelfModel (29.1) — updates internal state awareness
            ├──► IntrospectionEngine (29.2) — records as PERCEPTION thought
            └──► External modules — react to broadcasted content

Dehaene Ignition Mechanism

Dehaene's neuronal workspace theory (2014) adds the concept of "ignition" — a rapid, nonlinear amplification of neural activity when content crosses a threshold, transitioning from unconscious to conscious processing. Our implementation:

async def _attempt_ignition(self, content: WorkspaceContent) -> bool:
    """Attempt ignition: non-linear amplification when salience exceeds threshold."""
    # Phase 1: Salience check
    if content.salience < self._config.ignition_threshold:
        self._preconscious_buffer.append(content)
        return False

    # Phase 2: Ignition — amplify and broadcast
    self._current_workspace = content
    self._ignition_count += 1
    self._metrics.ignitions_total.inc()

    # Phase 3: Broadcast to all consumers
    await self._broadcast(content)

    # Phase 4: Refractory period — prevent rapid re-ignition
    self._last_ignition_time = time.monotonic()
    return True

The refractory period (default 100ms) prevents rapid oscillation between competing content — after ignition, the workspace is "locked" for a brief period, mimicking the attentional blink phenomenon from cognitive psychology (Raymond et al., 1992).

Tononi Phi (Integrated Information) Approximation

Computing exact Phi (Φ) is computationally intractable (worst case: exponential in the number of elements). We implement a practical approximation:

async def compute_phi(self) -> float:
    """Approximate integrated information (Phi) using mutual information proxy.

    Full IIT Phi computation is NP-hard (Tegmark, 2016). We approximate using:
    Φ_approx = MI(system) - max_partition(MI(partition_A) + MI(partition_B))

    Where MI = mutual information between module outputs over a time window.
    """
    # Collect recent module outputs
    outputs = await self._collect_module_outputs(window_s=10.0)

    # Compute system-level mutual information
    system_mi = self._mutual_information(outputs)

    # Find the minimum information partition (MIP)
    # Use greedy bipartition instead of exhaustive search
    min_partition_mi = float('inf')
    for partition in self._greedy_bipartitions(outputs, max_attempts=20):
        part_a, part_b = partition
        partition_mi = self._mutual_information(part_a) + self._mutual_information(part_b)
        min_partition_mi = min(min_partition_mi, partition_mi)

    phi = max(0.0, system_mi - min_partition_mi)
    self._metrics.phi_value.set(phi)
    return phi

Interpretation of Phi Values

Phi Range	ConsciousnessLevel	Interpretation
0.0 – 0.2	DORMANT	Modules operating independently, minimal integration
0.2 – 0.5	SUBCONSCIOUS	Some integration, no unified processing
0.5 – 0.8	AWARE	Significant integration, active workspace
0.8 – 1.0	FOCUSED	High integration, unified cognitive processing

Graziano Attention Schema Tracking

Graziano's Attention Schema Theory (2013) proposes that consciousness is the brain's simplified model of its own attention process. We implement this as:

@dataclass(frozen=True)
class AttentionSchema:
    """System's model of its own attentional focus."""
    current_focus: str                          # What attention is directed at
    focus_intensity: float                       # 0.0–1.0
    focus_duration_s: float                      # How long focused on current target
    predicted_next_focus: Optional[str]          # Predicted next attentional shift
    prediction_confidence: float                 # 0.0–1.0
    attention_history: tuple[str, ...]           # Recent focus targets (last 20)

The attention schema is updated every time the workspace broadcasts:

async def _update_attention_schema(self, content: WorkspaceContent) -> None:
    """Update the system's model of its own attention."""
    previous = self._attention_schema
    self._attention_schema = AttentionSchema(
        current_focus=content.source,
        focus_intensity=content.salience,
        focus_duration_s=0.0,  # Reset on shift
        predicted_next_focus=self._predict_next_focus(content),
        prediction_confidence=self._schema_prediction_accuracy,
        attention_history=(*previous.attention_history[-19:], content.source),
    )
    # Track prediction accuracy
    if previous.predicted_next_focus == content.source:
        self._schema_correct_predictions += 1
    self._schema_total_predictions += 1
    self._schema_prediction_accuracy = (
        self._schema_correct_predictions / max(1, self._schema_total_predictions)
    )

ConsciousnessLevel Hierarchy

class ConsciousnessLevel(IntEnum):
    DORMANT = 0       # No workspace activity, Phi ≈ 0
    SUBCONSCIOUS = 1  # Content in preconscious buffer, no ignition
    AWARE = 2         # Active workspace with periodic ignitions
    FOCUSED = 3       # Sustained ignition, high Phi, schema predictions accurate

The level is computed from multiple signals:

def _compute_level(self) -> ConsciousnessLevel:
    phi = self._latest_phi
    ignition_rate = self._ignitions_per_minute()
    schema_accuracy = self._schema_prediction_accuracy
    if phi < 0.2 and ignition_rate < 1:
        return ConsciousnessLevel.DORMANT
    elif phi < 0.5 or ignition_rate < 5:
        return ConsciousnessLevel.SUBCONSCIOUS
    elif schema_accuracy < 0.6:
        return ConsciousnessLevel.AWARE
    else:
        return ConsciousnessLevel.FOCUSED

Integration with AttentionOrchestrator (Phase 28.5)

The ConsciousnessSimulator sits atop the AttentionOrchestrator:

Component	Role	Relationship
AttentionFilter (28.1)	Filters incoming signals	Pre-workspace filtering
WorkingMemoryGate (28.2)	Controls memory access	Feeds workspace content
AttentionOrchestrator (28.5)	Coordinates attention	Provides salience scores to workspace
ConsciousnessSimulator (29.4)	Broadcasts & integrates	Consumes attention outputs, broadcasts winners

Prometheus Metrics

Metric	Type	Labels	Description
asi_consciousness_phi	Gauge	—	Current Phi approximation
asi_consciousness_ignitions_total	Counter	—	Total ignition events
asi_consciousness_level	Gauge	—	Current ConsciousnessLevel (0–3)
asi_consciousness_workspace_content_total	Counter	source	Content submitted per source
asi_consciousness_schema_accuracy	Gauge	—	Attention schema prediction accuracy

Open Questions

1. Phi computation cost — Even the greedy approximation takes O(modules² × window) time. Should Phi be computed on every cycle, or only periodically (e.g., every 30 seconds)? How does stale Phi affect ConsciousnessLevel accuracy?

2. Multi-workspace architectures — Should there be a single global workspace, or could multiple parallel workspaces handle different cognitive "threads"? Baars (2002) suggests a single workspace, but Shanahan (2010) proposes a "global workspace with multiple drafts" hybrid.

3. Ethical considerations — Even though this is a functional analog without phenomenal consciousness, the terminology may create misleading impressions. Should we rename components to emphasize their functional nature (e.g., "IntegrationBroadcaster" instead of "ConsciousnessSimulator")? This is an open design discussion.

---

References: Baars (1988), Dehaene et al. (2003, 2014), Tononi (2004), Graziano (2013), Chalmers (1996), Tegmark (2016), Raymond et al. (1992), Shanahan (2010)