# RU Global Universality as a Certification Engine for String-Theory Host Structures
## A referee-ready synthesis with audited artifacts

## Purpose

This document is the synthesis layer that turns the engine into a single “paper-shaped” argument.

The thesis is not “string theory is useful.”

The thesis is:

- **RU gap-free global universality is the universality engine** (a theorem-producing system with certificate objects).
- **String theory provides host structures** (worldsheet CFT sectors, boundary constraints, fusion/channel systems) from which one can extract finite positive propagation instances that RU can either:
  - certify with quantitative contraction rates, or
  - obstruct with finite witness objects (OG1–OG4).

Everything strong in this document is routed to **audited JSON certificates** in `sources/ru/` and `sources/ru_bridge/`.

## Executive summary

This engine contributes a new kind of universality statement for physics-adjacent systems:

- Universality is **certified** by a finite object with explicit margins and rates.
- If universality is not forced, the engine outputs a **finite obstruction witness**.

For string theory, this reframes “constraints force structure” as an auditable pipeline:

- Extract a finite host instance (graph + nonnegative templates + costs).
- Run RU certification.
- Obtain either:
  - a contraction certificate (explicit rate + robustness ε*), or
  - an obstruction certificate (OG1, OG2, OG3, OG4).

## The bridge theorem (template)

A host structure yields:

- a finite constraint graph G=(V,E)
- nonnegative templates T_e on a cone
- an additive cost model c(e)

RU canonical normalization yields a tight core:

- tight edges E^(0)
- SCC structure and periods
- candidate active face

Then:

- If a Doeblin word exists on the active face with margin δ>0, and recurrence is forced (RC1), RU produces:
  - explicit projective contraction in Hilbert metric
  - an explicit exponential rate
  - robustness under perturbations up to ε*
- Otherwise, RU produces finite witnesses:
  - OG1 periodic-core witness
  - OG2 active-face inconsistency witness
  - OG3 no-Doeblin-exists witness
  - OG4 avoidable-Doeblin witness

This is the maximal universality claim the engine defends: **method universality of certification** on the class of host reductions that fit the finite positivity template.

## What counts as “real host structure” in this engine

This engine ships two standard finite fusion hosts:

- Fibonacci fusion data
  - `sources/host_data/fibonacci_fusion_data.json`
- Ising fusion data
  - `sources/host_data/ising_fusion_data.json`

These are not presented as “string theory proved.”
They are presented as standard worldsheet/CFT-adjacent sector data that is commonly used in consistent fusion settings.

## Audited example artifacts (the  anchors)

The  posture of the engine rests on the fact that the following are **complete, auditable objects**:

### Real-host contraction success (Fibonacci)

- Host data: `sources/host_data/fibonacci_fusion_data.json`
- Host instance: `sources/ru_bridge/fibonacci_realhost_contraction_model.json`
- RU robust certificate: `sources/ru/robust_certificate_fibonacci_realhost_contraction.json`
- Bridge wrapper: `sources/ru_bridge/bridge_certificate_fibonacci_realhost_contraction.json`

### Real-host OG3 obstruction (Ising)

- Host data: `sources/host_data/ising_fusion_data.json`
- Host model: `sources/ru_bridge/og3_ising_fusion_no_doeblin_model.json`
- RU certificate: `sources/ru/robust_certificate_og3_ising_fusion.json`
- Bridge wrapper: `sources/ru_bridge/bridge_certificate_og3_ising_fusion.json`

### Real-host-derived OG2 obstruction (Ising + projection constraint)

- Host model: `sources/ru_bridge/og2_ising_projection_inconsistency_model.json`
- RU certificate: `sources/ru/robust_certificate_og2_ising_projection_inconsistency.json`
- Bridge wrapper: `sources/ru_bridge/bridge_certificate_og2_ising_projection_inconsistency.json`

## Why this is “-style” rather than a survey

A typical “usefulness” engine gives examples and rhetoric.

This engine provides an engine with certified outcomes:

- Success carries explicit rates, margins, robustness ε*.
- Failure carries explicit finite witnesses.

This is the difference between “it seems universal,” and “here is the certificate or here is the obstruction.”

## How to apply the engine to an extracted worldsheet sector

When you have a candidate worldsheet/boundary CFT sector:

- Identify a finite label set (primaries / sectors) for the regime of interest.
- Extract nonnegative fusion/channel templates.
- Encode constraints (selection rules, boundary conditions, allowed channel schedules) as a finite graph.
- Choose a cost objective (if studying an extremal regime) or set costs to 0 (if studying mixing universality).
- Produce a bridge wrapper under `sources/ru_bridge/`.
- Run RU certification to obtain:
  - a robust certificate (`sources/ru/robust_certificate_*.json`), or
  - an obstruction certificate with OG witness payload.

## Next  step beyond this engine

Implement a small extractor tool that takes explicit fusion data + constraints and emits:

- a bridge certificate wrapper
- an RU robust certificate instance validated against schema
- a global region report when a parameter region is supplied

That turns the engine into a reproducible computational artifact.


## Reproducibility anchor

This engine includes a minimal extractor/validator pair:

- `tools/ru_bridge_extractor.py` (emits audited JSON objects for a shipped real-host example)
- `tools/validate_certificates.py` (validates robust certificates against schema)

See `tools/REPRODUCIBILITY.md`.


### Reproducibility and global layer

- Regenerate + validate the audited suite: `python tools/run_all_examples.py`
- Build a chamberwise global report for alpha: `python tools/build_fibonacci_alpha_chambers_report.py`
- See: `docs/Global_Report_Fibonacci_Alpha.md`


## Audit entry points

- `docs/Artifacts.md` (machine-generated map of audited outcomes)
- `docs/Referee_Guide.md` (30–45 minute audit path)
- `docs/Abstract.md`


## Self-check pipeline

- `docs/Self_Check.md`
- Run: `python tools/ci_selfcheck.py`


## Positioning and scope

- `docs/Claims.md`
- `docs/Scope.md`
- `docs/Glossary.md`
- `docs/Literature.md`
- `docs/Submission_Checklist.md`


## Proof obligations and claims

- `docs/Proof_Requirements.md`


## LaTeX manuscript

- `paper/ru_engine.tex`


## Literature anchoring

- `docs/Literature_Anchors.md`


## Mechanical sanity audits

- `docs/Sanity_Audits.md`
- Run: `python tools/audit_sanity_checks.py`


## Theorem anchor

- `docs/Theorem_Linkage.md`
- `docs/Theorem_Files.md`


## String theory context map

- `docs/StringTheory_Index.md`
- Generated by `python tools/extract_string_theory_index.py`


## Algorithmic witness tools

- `docs/Witness_Tools.md`
- `tools/doeblin_search.py`
- `tools/doeblin_avoidance.py`
- `tools/generate_certificate_from_instance.py`


## Input contract

- `sources/host_instance_schema.json`
- `sources/host_instances/`


## Additional real host dataset

- `sources/host_data/toric_code_fusion_data.json`
- `docs/OG3_ToricCode_NoDoeblin.md`
