Consciousness Simulation Engine v1

on

 

CSE‑v1 Dashboard: Researcher User Guide

This guide is for researchers who want to use the Consciousness Simulation Engine v1 (CSE‑v1) dashboard for exploratory modelling, parameter sweeps, and data collection. It explains the interface, the formal meaning of each metric, how to run reproducible experiments, and how to export and analyse the results.

Important: CSE‑v1 is a computational sample model. Its Φ is a linear‑Gaussian proxy for integrated information, not full IIT 4.0. Use it for hypothesis generation and teaching, not as a validated theory of consciousness.

1. What the dashboard is

CSE‑v1 is a self‑contained HTML file that runs a four‑layer cognitive architecture in a Web Worker and renders its state in real time.

Layer

Role

Core variables

J‑Space

Micro‑level recurrent dynamics

x ∈ [0,1]^N, N = 8

GWT

Global workspace with broadcast hub

g ∈ [0,1]^M, M = 10

HOT

Higher‑order re‑representation and gate

h, m

IIT / Φ

Integration via minimum information bipartition

Φ_raw, Φ̂

H‑Space

Macro order parameters and downward constraint

V, κ_eff, stability

The worker performs all heavy computation; the main thread only draws charts and updates the DOM. The simulation tick interval is 120 ms (about 8.3 Hz). The history buffer stores up to 20,000 samples (roughly 40 minutes of continuous run).

2. Requirements and launching

Browser requirements

  • Modern browser with Web Workers, WebGL, and ES modules.
  • Recommended: Chrome, Edge, Firefox, or Safari (latest versions).
  • Internet access for the first load (Chart.js and Three.js are loaded from CDNs). For offline use, download these libraries and adjust the script tags.

Launching

  1. Save the HTML file locally. LINK at the Bottom
  2. Open it directly in your browser.
  3. If the header shows “core offline” or a worker error, serve the file over a local HTTP server. Some browsers block Blob‑backed workers from file://.

bash

python -m http.server 8000

# then open http://localhost:8000/cse-v1.html

  1. Wait for “core online · Φ via 127 bipartitions” in the header.

3. Interface tour

Area

What it shows

Header

Tick number t, simulation state, core status, Model Reference button.

Panel A

J‑Space: line chart of external stimuli u(t) and mean activation x̄(t). Metrics: input dimension, local activation, effective feedback.

Panel B

GWT network graph: modules and broadcast hub. Metrics: broadcast efficiency, signal distribution, HOT gate.

Panel C

IIT: heatmap of the effective Jacobian |J_eff|, Φ gauge, metrics for mean partition MI, threshold status, causal density.

Panel D

H‑Space: 3D emergent seed (icosahedron) and feedback arc. Metrics: macro spatial volume, downward constraint, seed stability.

Controls

Three sliders and six buttons.

Log preview

Last 12 samples in human‑readable form.

Model Reference drawer

Formal equations and definitions for every metric. Open with the header button or press Esc to close.

Tooltips: Hover over any metric card (the i icon or the card itself) to see its formal definition and interpretation.

4. Quick start

  1. Open the file and wait for the core to come online.
  2. Set the three sliders to your desired initial values.
  3. Click Initialize. The simulation starts running immediately.
  4. Observe the panels. Use Pause to freeze, then Step Once to advance one tick at a time.
  5. When finished, click Export JSON or Export CSV.
  6. To start a new run with the same baseline, click Reset Baseline and then Initialize again.

5. Controls and parameters

Sliders

Control

Symbol

Range

Effect

Feedback Gain

κ

0–1

Scales the downward constraint from H‑Space to J‑Space. The actual gain is κ_eff = κ · h(t).

Integration Threshold

Φ_thr

0–1

Threshold for partitionPassed and seed formation. A tick “passes” when Φ̂ > Φ_thr.

Input Novelty Rate

novelty

0–1

Scales the zero‑mean noise added to the external stimulus u(t).

Slider changes are sent to the worker immediately and affect subsequent ticks. For reproducible experiments, keep them fixed during a run.

Buttons

Button

Action

Initialize

Seeds the core, resets state, and starts the simulation.

Pause / Resume

Toggles continuous running.

Step Once

Pauses (if running) and advances exactly one tick.

Reset Baseline

Clears state, history, and charts; uses the same seed.

Export JSON

Downloads full sample history plus metadata as a .json file.

Export CSV

Downloads a flat table of key variables as a .csv file.

6. Metrics and formal definitions

A complete reference is built into the dashboard under Model Reference. The following is a condensed guide.

6.1 J‑Space (micro level)

Metric

Definition

Interpretation

Input vector dim

N = 8

Number of micro units.

Local activation

x̄(t) = (1/N) Σ x_i(t)

Mean micro activity.

Effective feedback

κ_eff = κ · h(t)

Actual strength of H→J feedback at this tick.

 

Update rule (per unit i):

text

x_i(t+1) = clip₀₁[ 0.5

  + Σ_j W_ij (2x_j(t) − 1)

  + 0.45 (2u_i(t) − 1)

  + 1.10 · κ_eff · (2m_i(t) − 1)

  + noise ]

W is a ring lattice with sparse long‑range connections, rescaled so max_i Σ_j |W_ij| = 0.5.

6.2 Global Workspace (GWT) and HOT

Metric

Definition

Interpretation

Broadcast efficiency

Coalition share: Σ_{g_i > mean(g)} g_i / Σ_i g_i

How concentrated the workspace activation is. High = a tight coalition dominates.

Signal distribution

H(g) / log₂(M)

Normalized Shannon entropy of the activation profile. 0 = one module dominates; 1 = uniform.

HOT gate

h = clip₀₁((g_hub − 0.50) / 0.50)

Higher‑order gate. Reports “active” when h > 0.25.

The meta‑representation is m_i = 0.5 + h · (x_i − 0.5). The workspace hub is module M−1; ignition is implemented by three Jacobi relaxation sweeps per tick.

6.3 IIT and Φ

Metric

Definition

Interpretation

Φ̂ (gauge)

1 − exp(−Φ_raw / 2)

Normalized integration. Raw bits shown below the gauge.

Mean partition MI

Mean of MI over all 127 bipartitions, normalized the same way

Coarse measure of average integration.

Partition threshold

Φ̂ > Φ_thr

Whether the system passes the integration threshold.

Causal density

mean_{i≠j} |J_ij|

Density of effective causal influences.

Heatmap

|J_eff| matrix

Row‑to‑column effective Jacobian.

Φ computation:

text

a_i = 1 if 0.02 < x_i < 0.98 else 0.15      (saturation mask)

J_ij = 2 · W_ij · a_i

J_ii += 2 · 1.10 · κ_eff · h · a_i

 Σ = (I − J)⁻¹ (I − J)⁻ᵀ + εI

MI(A;B) = ½ log₂( det Σ_A · det Σ_B / det Σ )

 Φ_raw = min over 127 bipartitions of MI(A;B)   [bits]

Φ̂     = 1 − exp(−Φ_raw / 2)

All log‑determinants are computed via Cholesky factorisation.

6.4 H‑Space (macro level)

Metric

Definition

Interpretation

Macro spatial volume

V = (PR − 1) / (N − 1) with PR = (tr Σ)² / ‖Σ‖_F²

Effective dimensionality of the macro state.

Downward constraint

κ_eff

Strength of the H→J feedback.

Seed stability

S = 1 / (1 + 12 σ_Φ) over last 24 ticks

low if S < 0.45, medium if S < 0.75, else high.

An emergent seed is declared on a tick when Φ̂ > Φ_thr and h > 0.25. The 3D icosahedron’s scale and brightness are driven by V and κ_eff.

7. Exporting and analysing data

JSON export

The JSON file contains two top‑level keys:

  • meta — engine version, timestamp, sample count, tick interval, slider parameters, model equations, and a disclaimer.
  • samples — array of per‑tick records. Each record includes:
    t, N, M, u, xMean, xVec, J, g, gwtEff, gwtDist, hubAct, hotGate, hotActive, phi, phiRaw, phiMean, phiDensity, partitionPassed, mipIndex, kappaEff, hVolume, hConstraint, hStability, seedFormed.

CSV export

A flat table with columns:
t, u_mean, x_mean, phi_raw, phi_norm, phi_mean, gwt_eff, gwt_dist, hub_act, hot_gate, hot_active, kappa_eff, h_volume, h_constraint, h_stability, seed

The first two lines are comments containing the export timestamp and current slider parameters.

Example Python analysis

python

import pandas as pd

import matplotlib.pyplot as plt

 

df = pd.read_csv("cse-v1-state-YYYYMMDD-HHMMSS.csv", comment="#")

print(df.describe())

 

# Plot Φ over time

plt.plot(df["t"], df["phi_norm"], label="Φ̂")

plt.plot(df["t"], df["phi_raw"], label="Φ_raw (bits)")

plt.xlabel("tick")

plt.legend()

plt.show()

 

# Seed events

seeds = df[df["seed"] == True]

print(f"{len(seeds)} seed events")

8. Recommended experimental workflow

  1. Define a hypothesis — e.g., “Increasing κ raises the frequency of seed events.”
  2. Fix parameters — set κ, Φ_thr, and novelty to chosen values. Avoid changing them mid‑run for reproducibility.
  3. Initialize and let the simulation run for a fixed number of ticks (e.g., 2,000 ticks ≈ 4 minutes at 120 ms).
  4. Export CSV.
  5. Analyse — compute seed frequency, mean Φ, stability distribution, etc.
  6. Repeat for each parameter condition. Use the same seed (20240517) for reproducibility; to change the seed, edit the seed value in the btnInit and btnReset handlers in the HTML.
  7. Document — keep the JSON meta block with each dataset; it records the final parameter values.

Reproducibility notes

  • The worker uses a deterministic PRNG seeded with 20240517 on Initialize and Reset.
  • Slider changes are not timestamped in the export. The meta block records the final slider values only.
  • For exact replay, keep all sliders fixed and always use the same seed.

9. Troubleshooting

Symptom

Likely cause

Fix

Header says “core offline”

Blob worker blocked

Serve over http://localhost instead of file://.

3D panel blank

WebGL unavailable or disabled

Enable hardware acceleration; try another browser.

Export does nothing

No samples yet

Click Initialize and let it run at least one tick.

Charts not updating

Worker error

Open browser console; check for errors.

Slow performance

Very long run with JSON export

Use CSV for large runs; JSON includes full J and xVec per tick.

“Nothing to export”

History empty

Run the simulation before exporting.

10. Limitations and caveats

  • Φ is a proxy. It measures integration of a linearised response covariance, not cause–effect repertoires as in IIT 4.0. Treat Φ̂ as a relative indicator within this model, not an absolute measure of consciousness.
  • GWT and HOT are simplified. The workspace has 10 modules and a single hub; ignition is a relaxation heuristic. HOT is a scalar gate, not a full higher‑order representation.
  • No learning or plasticity. Weights W and P are fixed at initialisation.
  • Deterministic but stochastic. The PRNG makes runs reproducible given the same seed and parameter timeline, but external noise still makes individual ticks non‑deterministic in practice if you change parameters mid‑run.
  • Not a neural simulator. It does not model spiking neurons, neurotransmitters, or anatomical connectivity.

11. Quick reference

Symbol

Meaning

Default

N

Micro units

8

M

Workspace modules

10

κ

Feedback gain slider

0.50

Φ_thr

Integration threshold slider

0.30

novelty

Input novelty slider

0.40

κ_eff

κ · h

computed

h

HOT gate

computed

Φ_raw

Minimum bipartition MI

bits

Φ̂

1 − exp(−Φ_raw/2)

0–1

V

Macro spatial volume

0–1

S

Seed stability index

0–1

For the full formal model, open the Model Reference panel in the dashboard. It contains the complete equations, variable definitions, and interpretation notes for every metric.




Comments

Post a Comment