Snapkitty/ironic-mirror

Ironic Mirror

Sovereign Compute Research System

Mirror the algo. Reflect the loop. Zero novelty. 100% irony.

Ironic Mirror is a sovereign-compute research repository exploring what happens when the machinery normally used to optimize attention, recommendation, and autonomous computation is turned back onto itself.

The repository brings together five experimental systems spanning:

• quantum computation
• formal verification
• GPU attention kernels
• self-modifying computation
• hardware-aware runtime monitoring
• invariant-driven systems design

The common question is simple:

What happens when the system is no longer optimized for engagement, prediction, or external control, but instead has to account for its own computational behavior?

---

The Core Idea

Recommendation systems optimize signals.

Attention systems concentrate signals.

Agents transform signals.

Ironic Mirror studies the point where those mechanisms begin to observe and modify themselves.

The central invariant is:

INPUT
  ↓
COMPUTATION
  ↓
OBSERVATION
  ↓
TRANSFORMATION
  ↓
VERIFICATION
  ↓
COMPUTATION

The loop is not treated as an abstraction.

It is treated as something that can be implemented, measured, verified, and eventually constrained.

---

Repository Architecture

ironic-mirror/
│
├── python/
│   └── xrex_unified/
│       └── Mosaic attention kernels
│
├── qsharp/
│   └── Black Hole Engine
│
├── formal/
│   └── XREX invariant verification
│
├── lean4/
│   └── Ironic Mirror Core
│
├── haskell/
│   └── Functional systems research
│
├── docs/
│   └── Research documentation
│
└── LICENSE

Companion Repositories

Repository	Purpose
marlborg-worm	Self-modifying agent with hardware cognitive strain monitoring
xrex-unified-attention	Triton mosaic attention kernels
black-hole-engine	Multi-backend quantum phase estimation
xrex-invariants-formal	Formal verification of kernel behavior

The repository is intentionally polyglot.

Different layers of the system require different computational models.

---

1. Marlborg-WORM

Self-modifying agent with hardware-aware cognitive strain monitoring.

Marlborg-WORM explores agents that can modify their own computational state while maintaining an observable boundary around that modification process.

The system combines multiple languages and hardware-description layers:

Common Lisp
Janet
Lean
Q#
Circom
Clash
SystemVerilog
Rust
C

The hardware monitoring concept is particularly important.

The system does not merely ask whether an operation is logically valid.

It also asks whether the computational workload associated with a transformation remains within an acceptable operating envelope.

Conceptually:

RULE CHANGE
    ↓
REWRITE
    ↓
EXECUTION LOAD
    ↓
STRAIN OBSERVATION
    ↓
VALIDATION
    ↓
ACCEPT / REJECT

This creates a research direction where computational behavior itself becomes part of the verification surface.

---

2. XREX Unified Attention

Triton-based mosaic attention kernel research.

XREX Unified Attention explores alternative implementations of attention computation at the GPU kernel level.

Primary technologies:

Python
Triton
CUDA

The objective is not simply to reproduce a conventional attention implementation.

The repository investigates how attention can be decomposed, rearranged, fused, and analyzed at the kernel level.

The relevant boundary is:

MODEL
  ↓
ATTENTION
  ↓
KERNEL
  ↓
GPU EXECUTION

Rather than treating the attention mechanism as a black box, XREX treats the kernel itself as a research object.

---

3. Black Hole Engine

Multi-backend quantum phase-estimation research.

The Black Hole Engine explores quantum computation through phase-estimation workflows targeting multiple quantum-computing backends.

The Q# layer provides the primary quantum abstraction.

The research direction includes compatibility with different execution environments, including:

IBM
IonQ
Quantinuum

The conceptual pipeline is:

QUANTUM STATE
     ↓
CIRCUIT
     ↓
PHASE ESTIMATION
     ↓
BACKEND
     ↓
MEASUREMENT
     ↓
VERIFICATION

The purpose is to investigate quantum computation as another execution substrate inside the broader sovereign-compute architecture.

---

4. XREX Invariants

Formal verification of computational kernel behavior.

XREX Invariants moves the project from implementation into proof.

The verification layer spans:

Agda
Scala
Starlark
Haskell

The fundamental question is:

Does the implementation preserve the property
that the specification says must remain invariant?

That distinction matters.

A kernel can execute successfully while still violating the property it was supposed to preserve.

XREX therefore treats correctness as a mathematical object rather than simply a successful program exit.

---

5. Ironic Mirror Core

The invariant itself.

The Ironic Mirror Core contains the deepest formal layer of the project.

Primary technologies:

Agda
Lean 4

The goal is to express the central invariant independently from the implementation language.

The architecture therefore becomes:

SPECIFICATION
     ↓
INVARIANT
     ↓
FORMAL PROOF
     ↓
IMPLEMENTATION
     ↓
RUNTIME
     ↓
OBSERVATION

The implementation can change.

The invariant is what should remain stable.

---

The Mirror

The name Ironic Mirror comes from a simple observation.

When a recommendation algorithm learns enough about a user, it eventually begins reflecting the user's own behavioral signal back to them.

The system becomes a mirror.

That creates a fixed point:

USER SIGNAL
    ↓
RECOMMENDER
    ↓
RECOMMENDATION
    ↓
USER RESPONSE
    ↓
MORE SIGNAL
    ↓
RECOMMENDER

The output becomes increasingly dominated by the signal that the system has already observed.

Ironic Mirror turns that concept into a systems question:

Can the computational loop observe itself?

Can the loop verify itself?

Can the loop detect when its own transformation
violates an invariant?

Can the loop constrain its own execution?

That is the research problem.

---

Sovereign Compute

The project uses the term sovereign compute to describe systems where computational authority is kept close to the operator rather than delegated entirely to an external optimization service.

That means emphasizing:

• local execution
• inspectable computation
• formal specifications
• reproducible experiments
• hardware-aware execution
• explicit invariants
• auditable transformations
• deterministic components where practical
• separation between specification and implementation

The objective is not to claim that every component is already formally verified.

The objective is to build the architecture where verification can become an explicit layer of the system.

---

Polyglot by Design

Ironic Mirror deliberately avoids forcing every problem into one programming language.

Different layers have different requirements.

Layer	Technologies
Systems	Rust, C
Functional research	Haskell
Formal verification	Lean 4, Agda
Quantum	Q#
GPU computation	Triton, CUDA
Hardware description	SystemVerilog, Clash
Symbolic / agent experiments	Common Lisp, Janet
Data / orchestration	Python, Scala, Starlark
Circuit verification	Circom

The language boundary is part of the research.

---

Research Philosophy

Ironic Mirror is built around several principles.

1. The implementation is not the invariant

Code can change.

The property being preserved should not silently change with it.

2. Execution is evidence, not proof

A successful execution demonstrates that something ran.

It does not automatically demonstrate that the implementation satisfies its intended mathematical specification.

3. Hardware is part of the computation

GPU kernels, circuits, memory behavior, and hardware execution are not treated as invisible implementation details.

4. Self-modification requires observation

If a system can alter its own rules, the transformation itself becomes part of the attack and verification surface.

5. The mirror should be inspectable

A system that observes itself should expose enough information for another system or operator to independently examine that observation.

---

Experimental Status

This repository is a research environment.

Not every component represents a production-ready system.

Not every research hypothesis is established fact.

Individual directories may contain:

• experimental implementations
• proofs
• proof scaffolding
• benchmarks
• hardware descriptions
• simulation code
• exploratory kernels
• incomplete research
• cross-language prototypes

The repository should therefore be read as a computational laboratory rather than a single finished product.

---

Getting Started

Clone the repository:

git clone https://github.com/SNAPKITTYWEST/ironic-mirror.git
cd ironic-mirror

Inspect the major research areas:

ls

Then enter the subsystem corresponding to the experiment you want to investigate.

For example:

marlborg-worm/
python/xrex_unified/
qsharp/
formal/
lean4/

Each subsystem may have its own build requirements and execution model.

Check the local documentation before running experimental components.

---

Verification Philosophy

Where formal verification is present, the preferred workflow is:

SOURCE
  ↓
SPECIFICATION
  ↓
INVARIANT
  ↓
PROOF
  ↓
IMPLEMENTATION
  ↓
TEST
  ↓
RUNTIME OBSERVATION

The order matters.

Testing should not be confused with proof.

Proof should not be confused with hardware execution.

Hardware execution should not be confused with system-level correctness.

Ironic Mirror keeps these layers separate so they can be examined independently.

---

What This Repository Is Exploring

The five projects converge on one larger question:

Can computational systems become observable
to themselves without surrendering control
of their own execution?

Quantum circuits explore the computation substrate.

Attention kernels explore signal transformation.

Self-modifying agents explore computational autonomy.

Hardware monitoring explores physical execution.

Formal methods explore mathematical correctness.

The mirror connects them.

---

Status

Research / Experimental

The repository is actively organized as a sovereign-compute research corpus.

Expect unfinished experiments, unusual languages, formal artifacts, kernel prototypes, hardware descriptions, and ideas that are still being tested.

That is intentional.

---

Copyright

Copyright BEL ESPRIT D ACCORD TRUST HOLDINGS INC.

See LICENSE for the governing terms.

---

Repository

SNAPKITTYWEST/ironic-mirror

Ironic Mirror

mirror the algo.
reflect the loop.
verify the invariant.
own the compute.