# Bounded Holomorphic Completion

Date: 2026-10-29. Status: scoped implementation gates passed; uncommitted and not deployed.

| Gate | State |
| --- | --- |
| Specification before implementation | Complete |
| Initial mathematical red run | 10 behavioral failures recorded |
| Restored mathematical gates | 13 passing, including rounded-unit red/green |
| HTTP boundary | 5 passing, including integer-rounding red/green |
| Mechanism-removal trials | Pick feasibility and query radius each failed as required; restored |
| Real data | 17 fields, 408 held-out queries; all controls pass |
| Default and kahler suites | Pass, including separate example targets; pre-existing exclusions disclosed |

## Purpose and scope

Given finite complex observations inside the unit disk and a positive magnitude
bound, determine compatibility with a bounded holomorphic function and return
the admissible values at requested points. The real and imaginary parts of the
constructed function are harmonic. This is not a claim that arbitrary records,
embeddings, or physical processes are holomorphic.

V1 is a read-only, `kahler`-gated library and HTTP primitive. It supports one
complex variable on the open unit disk, scalar complex outputs, and exact
interpolation interpreted through disclosed floating-point diagnostics. It does
not silently fit noisy data, rescale observations to pass, clip inconsistent
values, or claim general-manifold/annulus support. Noise-aware feasibility,
chart gluing, unit-aware covariance, and statistical calibration are separate
future gates. No GQL syntax or Marcella code changes in this scope.

## Mathematical contract

Let `z_i` ("z sub i") be input coordinates, `w_i` ("w sub i") observed outputs,
and `M` ("em") the positive bound. Normalize `y_i = w_i / M` ("y sub i equals
w sub i divided by em"). Seek a holomorphic `f` ("eff") with `|f(z)| <= M`
("modulus of eff of z is at most em") throughout the disk, interpolating all
observations. Holomorphic means satisfying the Cauchy-Riemann equations, not just
having small graph-Laplacian energy. A finite sample bound alone is insufficient.

The Nevanlinna-Pick matrix is

`P_ij = (1 - y_i conjugate(y_j)) / (1 - z_i conjugate(z_j))`.

Read: "P sub i j equals one minus y sub i times the conjugate of y sub j,
divided by one minus z sub i times the conjugate of z sub j."

For distinct interior nodes, a solution exists exactly when this Hermitian
matrix is positive semidefinite. Singular feasible problems have a unique
solution; positive definite problems have a family of solutions. V1 uses a
Schur recursion to construct that family and a separate Pick-spectrum diagnostic
to cross-check it. Borderline arithmetic returns `numerically_unresolved`, not
an assertion of feasibility or exact symbolic uniqueness.

At each reduction use `phi_a(z) = (z-a)/(1-conjugate(a)z)` ("phi sub a of z"),
and `g(z) = (y(z)-b)/(1-conjugate(b)y(z)) / phi_a(z)` ("gee of z").
Reverse with `y(z) = (b + phi_a(z)g(z))/(1+conjugate(b)phi_a(z)g(z))`.
Interior Schur parameters and a contractive free terminal function produce a
holomorphic bounded function by construction, with no poles inside the disk.
The returned representative chooses the free terminal function identically zero;
it is not an asserted recovery of the unknown original function.

For each query, compose these fractional linear maps into `(A t+B)/(C t+D)`
("A t plus B over C t plus D"). The image of the unit disk has center
`(B conjugate(D)-A conjugate(C))/(|D|^2-|C|^2)` and radius
`|A D-B C|/(|D|^2-|C|^2)`, then scale by M. These are admissible-value sets,
not probabilistic confidence intervals. Sets at different queries are marginal:
arbitrary choices from them need not belong to one common function.

Bounded entire functions are constant (Liouville); bounded real harmonic
functions need not have bounded harmonic conjugates. V1 avoids both traps by
specifying the domain and bounding the full complex function.

References: [Pick theorem](https://www.math.wustl.edu/~mccarthy/public_papers/KernelsandPick.pdf),
[bounded analytic interpolation](https://www.math.ucsd.edu/~helton/M241/tibi241ClassCut12.pdf),
[Liouville](https://math.mit.edu/classes/18.785/2016fa/LectureNotes16.pdf).

## Numerical policy

- Maximum 64 observations and 256 queries; no silent sampling.
- Input/query modulus must be <= 1-1e-8. Boundary observations are unsupported.
- Finite positive bound; finite coordinates; at least one observation.
- Exact repeated coordinates with equal outputs are deduplicated. Conflicting
  duplicates are infeasible. Very close distinct nodes are unresolved.
- Deterministic ordering, no dependence on hash iteration or insertion order.
- Pick tolerance: 1e-10 times max(1, spectral radius). No ridge correction.
- Schur boundary uncertainty band: 1e-10; exactly axis-aligned terminal unit
  parameters with consistent remaining values can identify numerical uniqueness.
  A norm rounded to one (for example the stored 0.6, 0.8 pair) does not qualify. Near-unit
  ambiguous parameters are unresolved. All uniqueness claims remain numerical,
  not formal exact-arithmetic certificates.
- Independently re-evaluate all original observations. Maximum normalized
  interpolation error must be <= 1e-8. Unsafe denominators/nonfinite results
  return unresolved. Never publish a partial set of query answers as a success.
- Responses carry tolerances, minimum Pick eigenvalue, interpolation error,
  representation, and an explicit `floating_point_not_formal_proof` disclosure.

## HTTP contract

`POST /v1/bundles/{name}/brain/holomorphic` (kahler required):

```json
{
  "input_fields": ["z_re", "z_im"],
  "value_fields": ["w_re", "w_im"],
  "bound": 1.0,
  "queries": [[0.25, 0.1], [0.5, -0.2]]
}
```

Unknown request keys are refused. All four fields must be distinct numeric
unencrypted fiber fields; no zero-fill, null skipping, base-key inference, or
decryption. Integers must be exactly representable as binary64; timestamps are
not numeric observations even if a numeric schema was assigned to them.
Read all live records from one locked bundle snapshot. Include
source keys/coordinates/values, revision, process-local bundle lifetime, and
record count in the response. No result cache in v1: edits/deletes/recreates
must be visible immediately. Existing heap/mmap access patterns are reused.

200 results have status `feasible_family`, `feasible_unique`, `infeasible`, or
`numerically_unresolved`; the last two contain an actionable reason and no
representation/query values. 422 denotes malformed/unsupported measurement
inputs; 404 denotes a missing bundle. JSON and DHOOM negotiation must agree.
Document the new route and full request/response contract in OpenAPI.

## Strict gates

1. Write executable tests against an intentionally failing implementation.
   Record behavioral failure, not merely missing symbols or compilation errors.
2. Mathematical positives: identity uniqueness, constant boundary uniqueness,
   nonunique zero observation with exact query radius, nonunit bound, complex
   rotation, higher-order bounded polynomial, and order invariance.
3. Mathematical negatives: conflicting duplicates, out-of-domain/nonfinite
   inputs, near-singular ambiguity, and individually bounded but incompatible
   observations. Include conjugation data: harmonic does not imply holomorphic.
4. Check representation interpolation, boundedness, numerical Cauchy-Riemann
   residuals, and value-disk containment against independent matrix algebra.
5. HTTP: refusal details, missing fields, unknown keys, encryption, provenance,
   mutation/recreate/restart freshness, JSON/DHOOM equality, route catalog.
6. Remove feasibility enforcement and replace value radii with unconstrained
   bounds in separate mutation trials. Each corresponding test must fail;
   restore mechanisms and rerun. Never weaken an assertion to obtain green.
7. All-target `cargo test` and `cargo test --features kahler`; freshly relinked
   isolated live engine on 127.0.0.1 with scratch data, not a user's engine.

## Real data usefulness gate

Reuse the public UCI Wine Quality (6,497 observations) and Combined Cycle Power
Plant (9,568 original first-sheet observations) sources and verified SHA-256
digests from `STATISTICAL_SUMMARIES_RESULTS.md`. Use the same schema-driven code
on all numeric fields, without dataset-specific mathematics or solver branches.

For each measured field build a declared fixed-bin empirical distribution.
Its probability generating function is `F(z)=sum_k p_k z^k` ("eff of z equals
the sum over k of p sub k times z to the k"). Nonnegative bin probabilities
sum to one, so its magnitude is <=1 on the disk. This construction is exactly
bounded analytic; it does not assert that wine chemistry or turbine physics is
holomorphic. Binning is lossy and its bounds/counts/provenance must be retained.

Store a small set of interior function evaluations as ordinary GIGI records.
Ask the generic endpoint for unseen evaluations. An independent Python oracle
uses the full empirical polynomial and a Pick-matrix Schur-complement derivation
of admissible query disks (not a port of the production Schur recursion).

Predeclared go/no-go requirements: every accepted query contains the full-data
oracle value within 1e-7; representative interpolates within 1e-8; all usable
fields in both datasets run the same code; median radius over held-out queries
is <=0.5 of the unconstrained unit-disk radius. Report worst radius, failures,
unresolved cases, input/output sizes and runtime, without discarding hard cases.
Withheld exact answers need not equal the selected representative. A deliberately
incompatible edit must become infeasible, restoration must recover the original
answer, and a same-size source change/restart must update provenance and results.

This demonstrates bounded completion of distribution fingerprints from sparse
evaluations. It does not demonstrate lossless database compression, arbitrary
fact recovery, calibrated physical predictions, or universal AI capability.

## Release boundary

No gate closure, commit, or deployment until the mathematical, transport,
mechanism-removal, all-target, and real-data gates pass. Preserve prior work.
Results and exact commands belong in BOUNDED_HOLOMORPHIC_RESULTS.md.
