Directed radii

Browse immutable directed-radius records, inspect provenance, recompute supported values, and replay or audit the evidence attached to a released row.

Released radius data

The released dataset covers 28 catalog keys: 756 possible non-diagonal key directions, 702 stored records, and 54 missing key pairs. These are alias-inclusive counts, not counts of distinct mathematical classes or independent radius problems. In particular, janowski_A0_B-1 and order_0.5 both define the exact same generator \(1/(1-z)\); their two directed records between each other are identity/containment rows, not distinct-class radius problems. The 54 missing key pairs are all incoming directions to the nephroid and three_leaf targets from other keys.

Identifying only that proven alias (without filling any missing rows) gives 27 distinct generator expressions, 702 original records mapping to 651 canonical ordered cells: one diagonal identity cell and 650 distinct non-diagonal directed cells. Of those 650, 133 are stored trivial-containment rows and 517 are nontrivial under the discovery input's trivial == false predicate. This quotient is an audit view, not a replacement for the released snapshot or a certification of those 517 radii. The package APIs continue to expose the original keys, directions, statuses, and provenance.

Direction matters. For example, sine→sigmoid has the exact value \(\arcsin((e-1)/(e+1))\) with a local certificate, while sigmoid→sine has radius \(1\) by full containment.

The radius_atlas.py example exports all rows and columns as JSON and SVG for data inspection. It is a view of the stored records, not a substitute for the proof of any individual radius.

geometric_function_atlas.radii

Directed inclusion-radius records and exact certificate replay.

The website stores a large radius snapshot with deliberately different evidence levels. This module exposes that snapshot without flattening the levels and replays eight reviewed certificate lanes and two symbolic paper lanes. The paper lanes leave global-containment reasoning unmechanized. Replay does not import the research repository or execute a serialized Python expression.

RADIUS_SNAPSHOT_ID = 'gft-radius-snapshot:2026.09.27-paper-review' module-attribute

RADIUS_SCHEMA_VERSION = '1.0.0' module-attribute

MAX_CANDIDATE_LENGTH = 4096 module-attribute

MAX_REPLAY_STEPS = 128 module-attribute

MAX_REPLAY_DPS = 200 module-attribute

MAX_IDENTIFICATION_CHARS = 4096 module-attribute

RADIUS_STATUS_LABELS = {RadiusStatus.PAPER_PROVED_EXACT: 'sharp exact radius in a written paper theorem; local certificate replay only where separately bundled', RadiusStatus.TOUCH_PROVEN_EXACT: 'touch equation proven exact (symbolic); global-max-over-theta validated numerically (8192-point) + monotone-in-r (max principle) — not yet discharged', RadiusStatus.CLOSED_FORM_CONFIRMED: 'closed form confirmed to approximately 100 digits; touch not symbolically proven (interior)', RadiusStatus.TRIVIAL_CONTAINMENT: 'trivial containment phi1(D) subset phi2(D), r = 1', RadiusStatus.UNIDENTIFIED: 'high-precision radius (60 digits), no closed form identified (open)', RadiusStatus.AUDIT_REQUIRED: 'symbolic touch check FAILED — quarantined, not a result'} module-attribute

RECONCILABLE_STATUSES = frozenset({RadiusStatus.PAPER_PROVED_EXACT, RadiusStatus.TOUCH_PROVEN_EXACT, RadiusStatus.CLOSED_FORM_CONFIRMED, RadiusStatus.TRIVIAL_CONTAINMENT}) module-attribute

replay_radius = verify_radius_certificate module-attribute

__all__ = ['RADIUS_STATUS_LABELS', 'RECONCILABLE_STATUSES', 'RadiusCertificate', 'RadiusProvenance', 'RadiusRecord', 'RadiusReplayResult', 'RadiusStatus', 'ReplayStep', 'audit_radius', 'identify_radius', 'list_radii', 'radius', 'recompute_radius', 'replay_radius', 'replay_radius_certificate', 'verify_radius_attainment', 'verify_radius_certificate'] module-attribute

RadiusStatus

The five non-overlapping statuses used by the website radius store.

TOUCH_PROVEN_EXACT = 'touch_proven_exact' class-attribute instance-attribute

CLOSED_FORM_CONFIRMED = 'closed_form_confirmed' class-attribute instance-attribute

TRIVIAL_CONTAINMENT = 'trivial_containment' class-attribute instance-attribute

UNIDENTIFIED = 'unidentified' class-attribute instance-attribute

AUDIT_REQUIRED = 'audit_required' class-attribute instance-attribute

PAPER_PROVED_EXACT = 'paper_proved_exact' class-attribute instance-attribute

RadiusProvenance dataclass

Stable source identity for a radius row, free of checkout paths.

source_snapshot_commit: str instance-attribute

crosswalk_commit: str instance-attribute

fixture_sha256: str instance-attribute

fixture_id: str instance-attribute

source_locator: tuple[tuple[str, str], ...] instance-attribute

source_references: tuple[str, ...] property

__init__(source_snapshot_commit: str, crosswalk_commit: str, fixture_sha256: str, fixture_id: str, source_locator: tuple[tuple[str, str], ...]) -> None

to_dict() -> dict[str, Any]

ReplayStep dataclass

One independently checked mathematical step in a replay.

name: str instance-attribute

verified: bool instance-attribute

scope: str = 'exact symbolic replay' class-attribute instance-attribute

failure_reason: str | None = None class-attribute instance-attribute

__init__(name: str, verified: bool, scope: str = 'exact symbolic replay', failure_reason: str | None = None) -> None

to_dict() -> dict[str, Any]

RadiusCertificate dataclass

Reviewed exact-chain metadata attached to a directed radius.

lane_id: str instance-attribute

source_class: str instance-attribute

target_class: str instance-attribute

baked_status: str instance-attribute

exact_candidate: str instance-attribute

decimal: str instance-attribute

reconciliation_status: str instance-attribute

claim_label: str instance-attribute

assumptions: tuple[str, ...] instance-attribute

inverse_branch_and_domain: str instance-attribute

global_containment_route: str instance-attribute

contact_and_attainment: str instance-attribute

sharpness_status: str instance-attribute

source_locator: tuple[tuple[str, str], ...] instance-attribute

machine_status: str instance-attribute

machine_steps: tuple[str, ...] instance-attribute

__init__(lane_id: str, source_class: str, target_class: str, baked_status: str, exact_candidate: str, decimal: str, reconciliation_status: str, claim_label: str, assumptions: tuple[str, ...], inverse_branch_and_domain: str, global_containment_route: str, contact_and_attainment: str, sharpness_status: str, source_locator: tuple[tuple[str, str], ...], machine_status: str, machine_steps: tuple[str, ...]) -> None

RadiusRecord dataclass

Typed read-only row from the directed radius snapshot.

source_class: str instance-attribute

target_class: str instance-attribute

value_exact: str | None instance-attribute

value_decimal: str | None instance-attribute

value_float: float | None instance-attribute

touch_angle: float | None instance-attribute

mode: str | None instance-attribute

status: RadiusStatus instance-attribute

global_touch_validated: bool | None instance-attribute

symbolic_touch: str | None instance-attribute

status_label: str instance-attribute

reconcilable: bool instance-attribute

assumptions: tuple[str, ...] instance-attribute

inverse_branch_and_domain: str instance-attribute

global_containment_route: str instance-attribute

contact_and_attainment: str instance-attribute

sharpness_status: str instance-attribute

reconciliation_status: str | None instance-attribute

claim_label: str instance-attribute

provenance: RadiusProvenance instance-attribute

certificate: RadiusCertificate | None = None class-attribute instance-attribute

paper_theorem: str | None = None class-attribute instance-attribute

axis_equation: str | None = None class-attribute instance-attribute

direction: str property

inner: str property

Compatibility alias for the website's radius-store vocabulary.

target: str property

__init__(source_class: str, target_class: str, value_exact: str | None, value_decimal: str | None, value_float: float | None, touch_angle: float | None, mode: str | None, status: RadiusStatus, global_touch_validated: bool | None, symbolic_touch: str | None, status_label: str, reconcilable: bool, assumptions: tuple[str, ...], inverse_branch_and_domain: str, global_containment_route: str, contact_and_attainment: str, sharpness_status: str, reconciliation_status: str | None, claim_label: str, provenance: RadiusProvenance, certificate: RadiusCertificate | None = None, paper_theorem: str | None = None, axis_equation: str | None = None) -> None

to_dict() -> dict[str, Any]

Return deterministic JSON data without executable expression strings.

RadiusReplayResult dataclass

Fail-closed result of an exact radius certificate replay.

status is proven for a reviewed certificate chain, and symbolic_replay_only for a paper lane whose global reasoning is written but not mechanized (certified=False). not_replayable applies when the unchanged trusted snapshot row has no bundled certificate (unsupported), candidate_mismatch for a wrong candidate, unresolved for a failed chain, invalid_input for malformed input, and corrupt_artifact for a malformed record or any record that is not identical to its trusted snapshot row, including a reviewed row whose bundled certificate was removed.

source_class: str instance-attribute

target_class: str instance-attribute

candidate: str | None instance-attribute

expected_candidate: str | None instance-attribute

status: str instance-attribute

certified: bool instance-attribute

steps: tuple[ReplayStep, ...] = () class-attribute instance-attribute

failure_state: FailureState | None = None class-attribute instance-attribute

error: str | None = None class-attribute instance-attribute

method: str = 'bounded_exact_radius_certificate_replay' class-attribute instance-attribute

global_containment_check: str property

Describe the route actually replayed, never the manuscript proof.

direction: str property

__init__(source_class: str, target_class: str, candidate: str | None, expected_candidate: str | None, status: str, certified: bool, steps: tuple[ReplayStep, ...] = (), failure_state: FailureState | None = None, error: str | None = None, method: str = 'bounded_exact_radius_certificate_replay') -> None

to_dict() -> dict[str, Any]

__getitem__(key: str) -> Any

Permit source-verifier-style result["status"] access.

list_radii(*, source: str | None = None, target: str | None = None, status: RadiusStatus | str | None = None) -> tuple[RadiusRecord, ...]

List immutable directed radius rows with optional exact filters.

radius(source: str, target: str) -> RadiusRecord

Return one directed radius; reversing the arguments is a new problem.

recognize_axis_radius(source: str, target: str) -> float

Numerically recognize the first real-axis contact; NOT a containment proof.

Bounded bisection on each side of the catalog's normalized generators. A non-crossing side is omitted. This route is diagnostic and never changes a row's proof status or creates a replayable certificate.

replay_radius_certificate(record: RadiusRecord | Mapping[str, Any], *, candidate: str | None = None, dps: int = 50, max_steps: int = MAX_REPLAY_STEPS) -> RadiusReplayResult

Replay one reviewed exact chain and fail closed on every mutation.

A mathematically wrong but syntactically valid candidate is reported as candidate_mismatch. Malformed input and resource exhaustion use the package's explicit failure states. The unchanged trusted snapshot row is reported as not_replayable with the unsupported failure state when it has no bundled replay certificate; it is not a damaged artifact. corrupt_artifact is reserved for malformed records and for any record that differs from its trusted snapshot row — including a reviewed row whose bundled certificate was removed. A non-reviewed snapshot row is never promoted merely because its decimal or expression looks plausible.

verify_radius_certificate(source: str, target: str, *, candidate: str | None = None, dps: int = 50, max_steps: int = MAX_REPLAY_STEPS) -> RadiusReplayResult

Look up and replay a directed radius without swapping its composition.

recompute_radius(source: str, target: str, *, candidate: str | None = None, dps: int = 50, max_steps: int = MAX_REPLAY_STEPS) -> RadiusReplayResult

Recompute a reviewed lane by replaying its bundled exact certificate.

This is deliberately bounded certificate recomputation, not an open-ended radius search. Unreviewed rows remain unresolved rather than being promoted by a numerical coincidence.

verify_radius_attainment(source: str, target: str, *, dps: int = 50, max_steps: int = MAX_REPLAY_STEPS) -> RadiusReplayResult

Verify the stored contact/attainment chain for one reviewed radius.

identify_radius(value: str | float, *, tolerance: float = 1e-12, limit: int = 100) -> tuple[RadiusRecord, ...]

Identify snapshot rows matching an exact expression or decimal value.

Matching is restricted to the bundled radius snapshot. It does not infer a closed form from arbitrary decimal input and returns an empty tuple when no stored row matches.

audit_radius(source: str, target: str, *, candidate: str | None = None, dps: int = 50, max_steps: int = MAX_REPLAY_STEPS) -> dict[str, Any]

Return a bounded audit record without upgrading literature status.