# A Certified x^0.90 Lower Bound for Collatz Predecessor Sets

Canonical publication and immutable source snapshots:
[proofatlas.ai/sources/collatz-predecessor-090](https://proofatlas.ai/sources/collatz-predecessor-090/).
Any future GitHub repository is an optional mirror and should link back to the
Proof Atlas source page.

This repository contains a standalone Lean 4/mathlib proof of a quantitative
theorem about predecessors under the accelerated Collatz map

```text
T(n) = n / 2          if n is even,
T(n) = (3n + 1) / 2  if n is odd.
```

For a positive target `a`, let `pi_a(x)` count positive integers
`n <= floor(x)` whose forward orbit under `T` reaches `a`. The main theorem is:

> For every positive `a` not divisible by `3`, `pi_a(x) >= x^(9/10)` for all
> sufficiently large real `x`.

The checked development proves the stronger intermediate statement
`pi_a(x) >= C_a x^(901/1000)` for some target-dependent constant `C_a > 0`.
The exponent reserve from `0.901` to `0.90` absorbs that constant. A
natural-cutoff version is proved as well.

## Trusted Statement

Read [`Challenge.lean`](Challenge.lean) first. It imports only `Mathlib`,
defines the exact map, reachability relation, and predecessor counts, and
states the three target theorems. Its `sorry` placeholders are intentional
statement-only inputs.

[`Solution.lean`](Solution.lean) imports the proved declarations.
[`ComparatorChallenge.lean`](ComparatorChallenge.lean) is the native-axiom
harness described in [`AUDIT.md`](AUDIT.md). The concise public API is
[`CollatzPredecessor090.lean`](CollatzPredecessor090.lean):

- `CollatzPredecessor090.predecessor_count_lower_bound_090`
- `CollatzPredecessor090.predecessor_count_lower_bound_090_nat`
- `CollatzPredecessor090.predecessor_count_lower_bound_0901`

## What Changed From 0.88

The earlier Proof Atlas release used a level-15 certificate to prove exponent
`0.88`. This release uses a level-18 certificate and a new adaptive
least-potential fallback for the elimination argument. Lean proves the generic
adaptive termination and transport mechanism; finite certificates supply the
level-18 weights and bounded potential.

The complete finite evidence comprises:

- `129,140,163` exact level-18 LP inequalities;
- `215,233,605` adaptive-potential inequalities;
- `344,373,768` inequalities in total, with zero failures; and
- a mutation test rejected by the independent C++ potential verifier.

## Proof Architecture

1. The exact level-18 LP certificate establishes the exponent `901/1000`.
2. The adaptive potential certifies a terminating least-potential fallback.
3. The Lean elimination and retarded-growth modules turn those finite facts
   into exponential growth of every level-18 principal envelope.
4. Target reduction transports the envelope bound to every positive target
   not divisible by `3`.
5. A generic exponent-reserve lemma yields the unit-coefficient exponent
   `9/10`.

The extracted source depends only on the pinned mathlib revision. It does not
import `FormalConjectures` or any Collatz-conjecture axiom.

## Checking

The project pins Lean `4.30.0-rc2` and mathlib through `lean-toolchain` and
`lake-manifest.json`.

```bash
lake exe cache get
make build
make challenge solution
make axiom-audit
make audit
make verify-python verify-cpp
```

The 20 tracked hexadecimal chunks are the exact inputs embedded by Lean.
`make payloads` reconstructs the ignored binary forms and checks their
aggregate SHA-256 values before the external verifiers use them.

## Trust Boundary

This is a **native-assisted** formal theorem. The public dependency cone has no
`sorryAx` or Collatz-conjecture axiom, but it contains two explicitly named
`native_decide` axioms for the finite LP and adaptive-potential checks.
Independent exact Python and C++ implementations replay all finite
inequalities. Those replays strengthen the audit evidence but do not remove
the native compiler from the trust boundary. See [`ASSUMPTIONS.md`](ASSUMPTIONS.md).

## Scope

This is not a proof of the Collatz conjecture. It does not establish that every
integer reaches `1`, positive density of any predecessor set, an explicit
eventual cutoff, or optimality of exponent `0.90`.

Generative AI systems assisted extensively with mathematical exploration,
formal proof development, verification code, and drafting. Lech Mazur directed
and curated the project and is responsible for the released artifact. The
Lean checks and independently replayable certificates are the public evidence.