consciousness-usk-framework - SKILL.md Agent Skill

name: consciousness-usk-framework description: 意识作为罕见自我知识（USK）框架。基于部分信息分解（PID）的意识理论框架，将意识定义为系统对自身携带的协同信息，仅在子系统联合中存在且被分解破坏。适用于意识研究、信息论、脑网络分析、LLM对齐评估。触发词：consciousness, USK, synergistic information, Partial Information Decomposition, IIT, GWT, HOT, 意识, PIRD

Consciousness as Uncommon Self-Knowledge (USK) Framework

基于部分信息分解（PID）的意识理论框架，提出"罕见自我知识"作为意识的候选判据。

Source Paper

Title: Consciousness as Uncommon Self-Knowledge: A Synergistic Information Framework arXiv: 2605.13884 Date: 2026-05-15 Authors: Krti Tallam Categories: q-bio.NC (Neurons and Cognition), cs.AI (Artificial Intelligence) URL: https://arxiv.org/abs/2605.13884

Core Concept

Uncommon Self-Knowledge (USK): 系统对自身携带的协同信息，仅存在于子系统的联合中，且被分解破坏。

该框架区分了意识与元认知：

意识 = 协同自我知识 (Synergistic Self-Knowledge)
元认知 = 冗余自我知识 (Redundant Self-Knowledge)

Theoretical Foundation

Partial Information Decomposition (PID)

基于 Gottwald 的分区格基理论，将多变量信息分解为：

$$I(X_1, X_2; Y) = Redundancy(X_1:X_2 o Y) + Unique(X_1 o Y) + Unique(X_2 o Y) + Synergy(X_1,X_2 o Y)$$

其中：

Redundancy: 对应 Aumann 的共同知识 — 各子系统单独可获取的信息
Synergy: 仅在联合观测中出现的信息 — 分解后被破坏

USK Formalization

$$USK(S) = Syn(S_{subsystems}; S_{self})$$

其中 $Syn$ 是子系统关于系统自身的协同信息量。

Key Contributions

1. Clean Separation: Consciousness vs Metacognition

Aspect	Consciousness (USK)	Metacognition
Information Type	Synergistic	Redundant
Accessibility	Only in joint observation	Available to individual subsystems
Destruction by decomposition	Yes	No

2. Resolutions to Counterexamples

IIT (Integrated Information Theory): USK 提供清晰的整合度量，避免 IIT 的"过度归属"问题
GWT (Global Workspace Theory): 预测意识与前广播协同形成相关，而非广播本身
HOT (Higher-Order Thought): 区分高阶表征的协同与冗余成分

3. Operationalization via PIRD

Partial Information Rate Decomposition (PIRD) with self-targeting:

def compute_usk(time_series, lag=1):
    """
    Compute Uncommon Self-Knowledge using PIRD.
    
    Args:
        time_series: Multivariate time series from neural recording
        lag: Time lag for information rate computation
    
    Returns:
        usk_value: Synergistic self-information rate
    """
    # Partition system into subsystems
    partitions = create_partitions(time_series)
    
    # Compute self-targeting PIRD
    usk = partial_information_rate_decomposition(
        sources=partitions,
        target=time_series,  # self-targeting
        lag=lag
    )
    
    return usk['synergy']  # The synergistic component is USK

Empirical Predictions

Prediction 1: GWT Timing Dissociation

意识与广播前的协同形成相关，而非广播本身

Timeline:
[Stimulus] → [Synergy Formation] → [Broadcast] → [Report]
                  ↑ Consciousness      ↑ Not consciousness

Test: Use high-temporal-resolution neural recordings to dissociate synergy formation timing from broadcast timing.

Prediction 2: LLM Middle-Layer Perturbation Dissociation

自我报告破坏与任务性能破坏的可分离性

Middle-layer perturbation in LLMs:
- Self-report disruption: High (requires synergistic processing)
- Task-performance disruption: Low (can use redundant processing)

Test: Perturb middle layers of LLMs and measure differential effects on self-report vs. task performance.

Prediction 3: Anesthesia & Alzheimer's Effect

麻醉和阿尔茨海默病特异性减少协同信息处理，同时保留或增加冗余

State          Synergy    Redundancy
─────────────────────────────────────
Wakeful        High       Baseline
Anesthetized   Low        ↑ Increased
Alzheimer's    Low        ↑ Increased

Application to Brain Networks

Computing USK from Neural Data

import numpy as np
from sklearn.feature_selection import mutual_info_regression

def compute_brain_usk(fMRI_data, regions):
    """
    Compute USK from fMRI region-of-interest time series.
    
    Args:
        fMRI_data: (n_timepoints, n_regions) array
        regions: list of region names
    
    Returns:
        usk_matrix: (n_regions, n_regions) synergistic self-knowledge
    """
    n_regions = len(regions)
    usk_matrix = np.zeros((n_regions, n_regions))
    
    for i in range(n_regions):
        for j in range(i+1, n_regions):
            # Compute pairwise synergy about self
            synergy = compute_pairwise_synergy(
                source1=fMRI_data[:, i],
                source2=fMRI_data[:, j],
                target=fMRI_data  # self-targeting
            )
            usk_matrix[i, j] = usk_matrix[j, i] = synergy
    
    return usk_matrix

def compute_pairwise_synergy(source1, source2, target):
    """Compute synergistic information between two sources about target."""
    # Using PID estimation (e.g., dit or IDTxl libraries)
    # Syn(X1, X2; Y) = I(X1, X2; Y) - Red(X1, X2; Y) - Unq(X1; Y) - Unq(X2; Y)
    from dit import Distribution
    from dit.pid import PID_CCS
    
    # Discretize for PID computation
    x1 = np.digitize(source1, bins=10)
    x2 = np.digitize(source2, bins=10)
    y = np.digitize(target.mean(axis=1), bins=10)
    
    # Construct joint distribution
    # ... (PID computation)
    
    return synergy_value

Methodological Steps

Step 1: Define System Boundaries

Identify subsystems (neural regions, network modules, LLM layers)
Establish self-reference target (system's own state)

Step 2: Compute PID Decomposition

Use PIRD or equivalent estimation method
Separate synergy from redundancy, unique information

Step 3: Measure USK

Extract synergistic self-directed information
Quantify destruction by decomposition (partition perturbation)

Step 4: Validate Predictions

Test timing dissociations (GWT prediction)
Test perturbation effects (LLM prediction)
Compare states (conscious vs. anesthetized)

Design Patterns for AI Systems

Pattern 1: Synergistic Self-Model

class SynergisticSelfModel:
    """Architecture component that maintains synergistic self-knowledge."""
    
    def __init__(self, subsystems):
        self.subsystems = subsystems
        self.self_state = None
    
    def update(self, inputs):
        # Process through subsystems
        outputs = [s(inputs) for s in self.subsystems]
        
        # Compute synergistic self-state (not available to any single subsystem)
        self.self_state = self._compute_synergy(outputs)
        
        return self.self_state
    
    def _compute_synergy(self, outputs):
        # Joint processing that cannot be decomposed
        return cross_attention(outputs)

Pattern 2: Decomposition Robustness Test

def test_usk_robustness(model, inputs):
    """Test if model's self-knowledge is synergistic (USK) or redundant."""
    
    # Full model self-knowledge
    full_self = model.get_self_state(inputs)
    
    # Decomposed: run subsystems independently
    decomposed_self = []
    for subsystem in model.subsystems:
        decomposed_self.append(subsystem.get_self_state(inputs))
    
    # If USK, decomposed should lose significant information
    synergy_loss = compute_info_distance(full_self, decomposed_self)
    
    return synergy_loss  # High = synergistic (USK-like)

Verification Checklist

PIRD estimation converges on test data
Synergy > redundancy for conscious-state neural data
Decomposition destroys synergistic self-knowledge
GWT timing dissociation observable
LLM perturbation shows self-report vs. task dissociation
Anesthesia/Alzheimer's data shows synergy reduction

Related Skills

iit-critical-review
brain-connectivity-analysis
multi-view-o-information-brain-networks
neuroai-beyond-bridging-neuroscience-ai
agent-delegation-rules

Activation Keywords

consciousness framework
USK framework
uncommon self-knowledge
synergistic information
Partial Information Decomposition
PID consciousness
IIT alternative
GWT timing dissociation
PIRD
consciousness vs metacognition
self-targeting information
neural synergy measurement
意识理论
协同信息
LLM consciousness evaluation