This repository organizes the uploaded CIEL project drafts into a coherent Python package layout. Production modules now live in first-party packages; the historic drops remain preserved under ext/ for reference but are no longer imported or distributed.
The spectral Fourier kernel is published as ciel_wave (renamed from the legacy local wave package) to avoid clashing with Python’s standard library module of the same name. Use imports such as from ciel_wave.fourier_kernel import SpectralWaveField12D in code and tests.
No placeholders were added to the active code. All runtime packages expose deterministic, well tested behaviour. Hyphens were normalized to underscores in module filenames. Tests verify imports, pipelines and persistence. Source provenance: the ext/ directory contains the raw batch extensions (Ext1 … Ext21, FWCKU, Emot, kernels, paradox notes). They stay untouched as archival material. The Python package published by setup.py excludes those modules and instead uses the curated equivalents under bio/, emotion/, fields/, memory/, integration/, etc.
After cloning the repository, you can verify a fresh installation with a minimal smoke test that only depends on the published package (no local paths or ext/).
Linux/macOS:
python -m venv .venv_test
source .venv_test/bin/activate
pip install --upgrade pip setuptools wheel
pip install .
python -c "import ciel; from ciel import CielEngine; print('IMPORT OK, CielEngine:', CielEngine)"
python scripts/smoke_test.pyWindows PowerShell:
python -m venv .venv_test
\.\.venv_test\Scripts\Activate.ps1
pip install --upgrade pip setuptools wheel
pip install .
python -c "import ciel; from ciel import CielEngine; Write-Host 'IMPORT OK, CielEngine:' $([string][type]::GetType('ciel.engine.CielEngine'))"
python scripts\smoke_test.pywires the biological receivers, emotional analysis, field primitives and memory persistence into a deterministic pipeline. Each call to InformationFlow.step filters an incoming sensor signal, projects it into the intention field, computes emotional statistics, evaluates the soul invariant metric and persists the enriched entry to long term memory.
The orchestrated pipeline keeps the original intent of the drafts (EEG ➜ intention ➜ emotion ➜ memory) while avoiding the heavyweight vendor dependencies. See tests/test_information_flow.py for usage examples.
Numerical safeguards that previously relied on hard numpy.clip calls now delegate to the mathematics.safe_operations.heisenberg_soft_clip* helpers. The Heisenberg-inspired saturation keeps small amplitudes perfectly linear while smoothly approaching the configured limits for large values. The behaviour mirrors the repository narrative: pushing an observable harder increases the uncertainty instead of snapping to an abrupt bound. See tests/test_soft_clip.py for the sanity checks that cover both the symmetric and ranged variants.
combines the curated intention, emotion, resonance and soul primitives into a deterministic twelve-channel simulation. The helper exposes a simulate method that soft-saturates incoming signals using the Heisenberg operator, projects them into EEG-like bands, updates the resonance tensor and summarises the soul invariant. The report() API returns a compact summary with the dominant band, coherence level and history depth so tests can verify the end-to-end flow. See tests/test_fourier_kernel.py for an executable example.
All user memory modules are bundled under core/memory/vendor/{ultimate,pro,repo}. Wrappers in core/memory/*.py import from a selected vendor via env var:
CIEL/Ω is a unified scientific and computational framework bridging:
- quantum physics
- neuroscience (EEG/CSF spectral states)
- cognitive science
- affective/emotional modeling
- topological memory theory
- mathematical structures (Lie-4 algebra, spectral operators, coherence metrics)
- operator ethics
- LLM expressive layers
It operates as:
- Theory of Everything (CIEL/0) available at https://www.researchgate.net/lab/Intention-Lab-Adrian-Lipa
- Cognitive Operating System
- Quantum-Wave Consciousness Simulator (12D Kernel)
- Empirical Testing Platform
- AGI Meta-Framework
- Universal Research Engine
This extended README provides the complete technical narrative, including diagrams, mathematical structures, architectural flow, empirical connections, scientific relevance, and implementation details.
This file is the strategic and adoption-focused README.
- For a component-by-component technical map, see
readme2.md. - For installation and running instructions, see
hints.md.
CIEL/Ω is a deterministic, testable framework that integrates:
- wave-field simulation (12D Fourier kernel)
- intention fields and coherence metrics
- cognition and affect modules
- ethical gating (hard-stop constraints)
- memory orchestration (vendor profiles)
- optional language backends (LLM as an expression layer, not a reasoning core)
It is designed for one purpose: rebuilding trust in AI-assisted reasoning by making the core of the system measurable, stable, and ethically non-negotiable.
We are living through an era of extreme social polarization and a rapidly expanding “trust crisis” around AI.
In high-stakes environments—government, medicine, pharma, education, critical business decisions—many AI systems are currently disqualified for a simple reason:
- they drift over time,
- they develop semantic sloppiness under pressure,
- they produce hallucinations that look confident,
- and they cannot reliably maintain a stable decision boundary.
Even when these systems are powerful, they are often not acceptable as strategic instruments because they fail the fundamental requirement of mission-critical systems:
- repeatability
- measurable constraints
- auditability
CIEL/Ω was created to be the opposite of “black box autopilot AI”.
It is a framework where the core intelligence layer is not a free-form generator. The generator (LLM) is optional and remains a controlled interface.
CIEL/Ω treats ethics as a hard constraint, not a “prompt”.
- Ethics is not a feature.
- Ethics is the condition under which the system is allowed to run.
The project implements a deterministic guard (ethics/EthicsGuard) configured by config/CielConfig.
- A minimum coherence threshold is defined (
ethics_min_coherence). - If a step falls below the threshold or the ethical evaluation fails, the guard triggers a hard stop (default behavior is to raise an exception).
This enforces the intended invariant:
Any attempt to push the ethical gradient below the minimum bound deactivates the system’s execution path.
In the conceptual language of the repository, this is also represented by the Λ₀ protective operator (ethics/Lambda0Operator).
The curated runtime modules are intentionally deterministic and covered by tests. This means:
- the same input yields the same pipeline behavior,
- state changes are explicit,
- the system can be validated and regression-tested.
Instead of hard clipping, the system uses the Heisenberg Soft Clip operator (mathematics/safe_operations.py) to keep observables stable without discontinuities.
The LLM integration (ciel/hf_backends.py, ciel/llm_registry.py) is treated as:
- a linguistic interpreter,
- a controlled expression layer,
- an analysis/validation assistant.
If transformers / torch are not installed, the system degrades gracefully to deterministic stub backends.
Below are the key subsystems that define CIEL/Ω as an engineering platform.
ciel/engine.py exposes CielEngine.step(...) and CielEngine.interact(...).
It composes:
- intention → wave kernel → memory TMP → cognition → emotion → optional language layer
ciel_wave/fourier_kernel.py provides:
SpectralWaveField12D(fast synthesis)FourierWaveConsciousnessKernel12D(snapshot metrics: bands, coherence/entropy/purity, resonance tensor, soul measure)
This creates a stable, measurable internal state representation rather than a purely textual “thought stream”.
integration/information_flow.py builds a deterministic pipeline:
- EEG-like signal → intention → emotion mapping → soul invariant → persistence
It is a testable and auditable “sensor-to-memory” path.
fields/soul_invariant.py computes a spectral invariant over a 2D field.
In practice it acts as a stable quantitative anchor for:
- coherence metrics
- ethical gating
- system introspection
Memory is modular by design:
core/memory/vendor/repo(lightweight)core/memory/vendor/pro(SQLite + optional HDF5)core/memory/vendor/ultimate(adds audit logging and stronger operational structure)
Vendor selection is controlled via CIEL_MEM_VENDOR.
core/braid/ introduces a structured representation of contradictions and resolutions:
- loops (intent execution cycles)
- scars (residual contradictions with a curvature budget)
- glyphs & rituals (operators applied to braid memory)
This is a compact, engineering-friendly model for “structured cognition under constraints”.
CIEL/Ω is positioned to transform domains where trust is the bottleneck.
- auditable decision-support pipelines
- stable behavioral constraints
- reproducible state transitions (no “mood drift”)
- deterministic pipelines for signal processing, feature extraction and memory persistence
- ethics-first gating before any downstream “recommendation” layer
Note: this repository is research software and is not a certified medical device.
- disciplined model-driven experimentation
- consistent simulation kernels and invariant metrics
- traceable memory/audit logs (vendor ultimate)
- interactive, testable modules for wave-field simulation and cognition/affect modeling
- safer LLM usage as an interface, not an authority
- stable, bounded decision assistance
- measurable coherence and risk signals
- audit-friendly outputs and structured memory
- “hard-stop ethics” as runtime policy, not as marketing
- deterministic regression tests as a first-class feature
Consciousness is modeled as:
A structured, temporally-modulated wave field undergoing coherence–decoherence cycles, influenced by intention and interacting with physical systems through spectral-state dynamics.
This integrates:
- Fourier spectral analysis
- harmonic decomposition
- nonlinear coherence metrics
- intention operators
- emotional field modulation
- memory attractors
- temporal interference
The kernel defines a 12-dimensional wave-state:
[δ, θ, α, β, γ,
Ω1, Ω2, Φ1, Φ2, Ψ1, Ψ2, Σ]
Where:
- δ, θ, α, β, γ → EEG-like frequency bands
- Ω, Φ, Ψ → extended harmonic manifolds
- Σ → coherence–entropy coupling term
Ψ(t) = Σ_i A_i(t) * e^{iω_i t}
C = | Σ_i (A_i^2) | / Σ_i |A_i|
S = - Σ p_i log(p_i)
P = Tr(ρ^2)
Acts on spectral amplitude and phase:
Î : A_i → A_i' = A_i * f(intent, affect, context)
Defines safety envelope:
Λ₀(Ψ) = clamp(Ψ, bounds_ethics)
Ensures:
- no harmful outputs
- context-coherent behavior
- bounded cognitive dynamics
From Watanabe (2025):
- EEG signals correlate with quantum computer outputs (Rigetti Ankaa-3)
- Separation 8 800 km
- r ≈ 0.655 (p < 0.01 FDR)
CIEL/Ω explains this as:
Temporal–spectral interference between EEG coherence states and quantum measurement distributions.
12D Kernel can mathematically replicate and predict these correlations.
Two key papers:
- Pulse-train double-slit analysis
- Temporal double-slit experiments
Both demonstrate:
- interference patterns arise from time-window modulation,
- not only spatial separation.
CIEL/Ω uses identical principles in:
- intention gating
- cognitive switching
- memory loops
Temporal interference = core of kernel dynamics.
Effects such as:
- crystallization changes
- water-structure sensitivity
- emotional imprinting
are reframed in CIEL/Ω as:
initial-condition amplification under wave-field modulation.
No pseudoscience—fully formalizable.
CIEL Omega
│
├── wave/
│ ├── fourier_kernel_12d.py
│ ├── coherence.py
│ └── temporal_diffraction.py
│
├── cognition/
│ ├── perception.py
│ ├── intuition.py
│ ├── prediction.py
│ ├── decision.py
│ └── orchestrator.py
│
├── emotion/
│ ├── affective_orchestrator.py
│ └── emotional_state.py
│
├── ethics/
│ └── lambda0_operator.py
│
├── memory/
│ ├── echo_memory.py
│ ├── dream_memory.py
│ ├── adam_memory.py
│ ├── long_term_memory.py
│ └── vendor_profiles/
│
├── core/braid/
│ ├── braid_memory.py
│ ├── scars.py
│ └── loops.py
│
├── hf_backends/
│ ├── primary_backend.py
│ └── auxiliary_backend.py
│
└── ciel/
└── engine.py
┌─────────────────────┐
│ Input Perception │
└──────────┬──────────┘
│
Intention Extraction
│
┌──────────▼───────────┐
│ 12D Wave Simulation │
│ (Fourier Kernel) │
└──────────┬───────────┘
│
Cognitive State Evaluation
┌───────────┬─────────────┬──────────────┬───────────┐
▼ ▼ ▼ ▼
Perception Intuition Prediction Decision
└───────────┴─────────────┴──────────────┘
│
┌──────────▼───────────┐
│ Affective Dynamics │
└──────────┬───────────┘
│
┌──────────▼───────────┐
│ Ethical Filter │
│ (Λ₀ Operator) │
└──────────┬───────────┘
│
┌──────────▼───────────┐
│ Memory Consolidation│
└──────────┬───────────┘
│
┌──────────▼───────────┐
│ LLM Expression │
└──────────────────────┘
Immediate resonance trace
(short-lived but rich in spectral detail)
Recombination + generative remapping
(similar to REM-phase reprocessing)
Stable, precise representations
(seeds of long-term identity)
Gradual consolidation via coherence thresholds
Topological representation:
- scars (conflict residues)
- loops (stable behavioral attractors)
- glyphs (semantic condensates)
- rituals (recurring high-coherence patterns)
LLMs function only as:
- linguistic interpreters,
- coherence evaluators,
- content generators within Λ₀ constraints.
Not as reasoning engines.
from ciel.engine import CielEngine
engine = CielEngine()
result = engine.step("Hello world", context="demo")
print(result.simulation.report())
print(result.cognition)
print(result.affect)- quantum interference research
- temporal diffraction modelling
- PBH/astrophysical anomaly modeling
- decoherence pattern simulation
- EEG spectral analysis
- brain–quantum correlation models
- CSF resonance prediction
- AGI prototyping
- decision-field theory
- intention geometry
- emotion-aware agents
- memory-rich agents
- safe LLM orchestration frameworks
- unified formal model
- testable predictions
- nonlocality frameworks
- consciousness simulation labs
- interactive physics modules
pip install -r requirements.txt
- Linux (recommended)
- macOS
- Windows
- Python 3.10+ recommended
- Minimal dependencies (as shipped):
numpy,scipy,matplotlib,networkx,sympy,pandas
Optional dependencies (only if you enable related modules):
- LLM backends:
transformers(+ typicallytorch) - Ultimate/Pro memory features:
h5py(true HDF5),streamlit(dashboard) - GUI client (
CLI.py): PyQt5 + audio/report packages (seehints.md)
Minimum (core deterministic pipeline):
- CPU: 2+ cores
- RAM: 4 GB
- Disk: 1 GB free (more if you persist memory histories)
Recommended (development + experiments):
- CPU: 6–12 cores
- RAM: 16–32 GB
Optional (local LLM inference):
- NVIDIA GPU recommended
- VRAM: typically 12–24 GB depending on model size and quantization
- Run smoke test:
python3 scripts/smoke_test.py - Run CLI engine:
python3 -m ciel - Run tests:
python3 -m pytest -q - GGUF backend (requires
llama-cpp-python+ local.gguf):python3 -m ciel --enable-llm --llm-backend gguf --mode once --text "test" --gguf-model-path /path/to/model.gguf
- If you use the GUI client, see
run_gui.shand ensure GUI dependencies are installed.
CIEL Research Non-Commercial License v1.1
SPDX-License-Identifier: CIEL-Research-NonCommercial-1.1
A. Lipa, S. Sakpal, M. Kamecka, U. Ahmad (2025). CIEL/Ω — General Quantum Consciousness System.
https://github.com/AdrianLipa90/CIEL-Omega-General-Quantum-Consciousness/
See LICENSE file for contact email.
