"What is the geometry of being a bat?"
— after Thomas Nagel
Exploratory computational investigations into the geometry of conscious states, bridging Integrated Information Theory, category theory, and information geometry.
Built in Rust for performance-critical calculations and type-driven categorical guarantees.
- Can conscious experiences be meaningfully represented as shapes in information-theoretic spaces?
- What categorical structures underlie different theories of consciousness (IIT, predictive processing, free energy)?
- Are there functorial mappings between these theoretical frameworks—natural transformations that preserve experiential structure?
- What do these visualizations reveal (or obscure) about the ontological status of qualia?
Computational necessity. IIT calculations scale worse than exponentially—computing Φ requires evaluating all possible system partitions. Python implementations (PyPhi) hit walls around 10-12 nodes. Rust pushes that boundary through parallel enumeration, cache-efficient layouts, and SIMD operations on entropy calculations.
Type-driven mathematics. Categorical properties can be encoded at compile time. When exploring whether mappings between consciousness theories are genuinely functorial, the compiler enforces structure preservation:
trait Functor<Source: Category, Target: Category> {
type ObjectMap<A: Source::Object>: Target::Object;
fn map_morphism<A, B>(
&self,
f: Source::Morphism<A, B>
) -> Target::Morphism<Self::ObjectMap<A>, Self::ObjectMap<B>>;
}WASM for visualization. Rust compiles to WebAssembly, enabling performant computation kernels running directly in browser-based interactive visualizations.
Integrated Information Theory (IIT) — Tononi's framework quantifying consciousness via Φ (integrated information) and characterizing experiences as "conceptual structures" in high-dimensional quale space.
Information Geometry — Treating probability distributions as points on Riemannian manifolds equipped with Fisher information metrics. Consciousness theories implicitly define such manifolds.
Category Theory — Exploring whether mappings between consciousness frameworks exhibit functorial properties. Natural transformations as "translations" between theoretical vocabularies.
Continental Philosophy — Deleuzian multiplicities, virtual/actual distinctions, and eliminativist questions about whether these mathematical structures have genuine ontological weight.
conscious-landscapes/
├── crates/
│ ├── phi-core/ # Information-theoretic primitives
│ │ ├── entropy.rs # Shannon entropy, KL divergence
│ │ ├── mutual_info.rs # Mutual information calculations
│ │ └── integration.rs # Φ computation engine
│ │
│ ├── categorical/ # Type-level category theory
│ │ ├── category.rs # Core categorical traits
│ │ ├── functor.rs # Functorial mappings
│ │ └── natural.rs # Natural transformations
│ │
│ ├── landscapes/ # Geometric representations
│ │ ├── manifold.rs # Information manifold structures
│ │ ├── projection.rs # Dimensionality reduction
│ │ └── topology.rs # Topological invariants
│ │
│ ├── systems/ # Concrete system implementations
│ │ ├── boolean_net.rs # Boolean network models
│ │ ├── neural.rs # Simple neural circuits
│ │ └── automata.rs # Cellular automata
│ │
│ └── viz-wasm/ # WebAssembly visualization bridge
│ └── lib.rs # WASM bindings for browser
│
├── web/ # Interactive visualization frontend
│ ├── index.html
│ └── src/
│ └── landscape.js # D3/Three.js rendering
│
├── notebooks/ # Jupyter notebooks (via evcxr)
├── experiments/ # Specific investigative threads
└── docs/ # Theoretical notes and reflections
/// A probability distribution over system states
pub struct Distribution<const N: usize> {
probabilities: Vec<f64>,
cache: EntropyCache,
}
/// Partition of a system for integration calculation
pub struct Partition {
parts: Vec<Subsystem>,
}
/// The geometric "shape" of an experience
pub struct ConceptualStructure {
concepts: Vec<Concept>,
relations: InformationGeometry,
}
/// Core trait for information measures
pub trait InformationMeasure {
fn entropy(&self) -> f64;
fn mutual_information(&self, other: &Self) -> f64;
}
/// Integrated information calculation
pub trait IntegratedInformation: InformationMeasure {
fn phi(&self, partition: &Partition) -> f64;
fn minimum_information_partition(&self) -> Partition;
fn conceptual_structure(&self) -> ConceptualStructure;
}Implement parallel partition enumeration with rayon, benchmark against PyPhi, establish computational boundaries for exploration.
Encode IIT, Free Energy Principle, and Global Workspace Theory as categories. Investigate functorial mappings between them—what structure survives translation?
WASM-powered interactive exploration of quale spaces. Watch how the "shape of experience" deforms as system parameters shift.
Use code as philosophical instrumentation. What would it mean for these landscapes to be "real"?
git clone https://github.com/ibrahimcesar/conscious-landscapes.git
cd conscious-landscapes
# Build all crates
cargo build --release
# Run tests
cargo test
# Build WASM visualization component
cd crates/viz-wasm
wasm-pack build --target web
# Serve interactive visualization
cd ../../web
python -m http.server 8080[dependencies]
rayon = "1.10" # Parallel computation
ndarray = "0.16" # N-dimensional arrays
nalgebra = "0.33" # Linear algebra
petgraph = "0.6" # Graph structures
wasm-bindgen = "0.2" # WebAssembly bindings
[dev-dependencies]
criterion = "0.5" # Benchmarking- Tononi, G. — Integrated Information Theory of Consciousness (2004, and subsequent refinements)
- Oizumi, M. et al. — From the Phenomenology to the Mechanisms of Consciousness: IIT 3.0 (2014)
- Amari, S. — Information Geometry and Its Applications (2016)
- Friston, K. — The Free-Energy Principle: A Unified Brain Theory? (2010)
- Milewski, B. — Category Theory for Programmers (categorical foundations in code)
🌱 Germinal — A space for open-ended exploration, not a polished library. Expect incomplete thoughts, dead ends, and speculative leaps.
This project operates in the spirit of computational philosophy—using code not to prove theorems but to generate intuitions, test conceptual coherence, and make abstract frameworks tangible enough to critique.
The compiler becomes a philosophical collaborator. Type errors are conceptual errors. If a mapping between theories doesn't typecheck as a functor, that's information about the theories themselves.
MIT — explore freely.
"The diagram is no longer an auditory or visual archive but a map, a cartography that is coextensive with the whole social field." — Deleuze