Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
146 changes: 146 additions & 0 deletions research/mixed-rechart-closure/PROOF.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,146 @@
# Mixed line/hyperplane rechart closure

This scoped written proof was produced by Nick Petalas. New work is Apache-2.0.
The maximum-closure/min-cut equivalence and distributive-lattice methods are
classical. The new step is the explicit mixed rechart representation and its
linear-price optimization consequence.

## Contract and theorem

Let V be a finite-dimensional vector space over any field. Fix a hyperplane H
and a line L with L not contained in H. At each vertex v of a finite directed
graph, an original subspace U_v is given. Every edge u -> v obeys U_u subset U_v.
An allowed replacement at v is any distinct member of

A_v = U_v intersect H,
U_v,
P_v = A_v + L,
B_v = U_v + L.

Require replacement subspaces to remain nested on every edge. Any vertices
may be pinned to named allowed options. Zero edge rank gaps are permitted.
The objective is any rational linear combination of vertex dimensions and
edge rank gaps, where the gap is dim(V_v)-dim(V_u). Prices may have either sign.

**Theorem.** This exact optimization problem reduces to maximum-weight closure
on at most 2N Boolean nodes, at most 4E nesting implications, and at most 2N
fixed Boolean values. It has an exact polynomial-time algorithm, including
infeasibility detection for incompatible pins. No assumption on field
characteristic or on the signs of the prices is needed.

This is a dimension-linear optimization theorem. It is neither a computation
of the nonlinear P104 power invoice nor a proof of native realization.

## 1. The local options are Boolean lattices

If U subset H, the options reduce to A=U and B=U+L, with a single Boolean
choice. If L subset U, they reduce to A=U intersect H and B=U=A+L, again a
single Boolean choice. These two cases cannot overlap because L is transverse.

Otherwise dim A=dim U-1, P=A+L has dimension dim U, and B=U+L has dimension
dim U+1. U and P are distinct: equality would put L in U. Their intersection
is A and their sum is B. Thus the four options form a Boolean diamond, with
atoms U and P above A. Label these atoms J_1,J_2. A subset S of the two atoms
represents the sum of A and the selected atoms, and

dim V(S) = dim A + |S|.

The single-choice case has one atom J_1=B and the same formula. Each local
lattice is therefore represented by one or two independent bits. Inclusion
within this lattice is exactly subset inclusion of those bit sets.

## 2. Nesting becomes implications

For an original nested edge u -> v, A_u subset A_v and B_u subset B_v. For
an atom J_a at u, consider the allowed options at v that contain J_a. This
set is nonempty because B_v contains J_a. It is closed under intersection,
so has a unique least member, represented by some bit set R(a).

Require x_(u,a) <= x_(v,b) for each b in R(a). There are at most four such
implications per edge. Equivalently, b lies in R(a) exactly when J_a is not
contained in the option at v with every bit except b set. This gives an
explicit construction using only subspace containment tests.

These implications are necessary for V_u subset V_v. They are sufficient
because A_u subset A_v, and V_u is spanned by A_u and its selected atoms.
Every selected atom then lies in V_v. This proves exact equivalence, including
edges with equal endpoints. Pinning an option fixes its one or two bits.

## 3. The objective and cut construction

Collect all vertex and edge coefficients into rational numbers alpha_v and
a constant C. In particular, an edge coefficient beta adds beta to alpha_v
and subtracts beta from alpha_u. The objective becomes

C + sum_v alpha_v dim A_v + sum_(v,a) alpha_v x_(v,a).

Hence it is a maximum-weight closed-set problem. Multiply by a common positive
denominator for an integer network. For a bit of positive weight w, add a
source arc of capacity w. For a bit of negative weight, add a sink arc of
capacity -w. Each implication gets capacity M, where M=1+sum |w|. Forced-one
bits get source arcs of capacity M and forced-zero bits get sink arcs of
capacity M. The source side of a cut is the selected bit set.

First propagate forced-one bits along implication paths. Reaching a forced-zero
bit certifies infeasibility. Otherwise the propagated set itself is feasible.
A feasible cut has capacity at most sum |w|. Thus every minimum cut avoids
all M-capacity arcs. If W_plus is the sum of positive weights, its weight is
W_plus minus the cut capacity. Restoring the constant gives the exact optimum.
Standard exact max-flow algorithms give polynomial time; rational denominator
clearing has polynomial bit length in the encoded input size. Subspace basis
and containment operations have their usual field-arithmetic cost. This is
not an assertion of polynomial bit cost over an unspecified encoded field.

## 4. Mixed choices can strictly improve both one-sided optima

Over F_2^3 let H=<e1,e2>, L=<e3>, U=<e1+e3> and W=<e1+e3,e2>.
There is one nesting edge U -> W. Maximize dim(W')-dim(U').
The original value is 1. Growth-only choices U or U+L, and W or W+L, have
maximum 2. Shrink-only choices U or U intersect H, and W or W intersect H,
also have maximum 2. The mixed choices U'=0 and W'=V give 3. Thus separate
one-sided optima do not bound this mixed family, even on a single nested edge.
This illustrates the optimization distinction; it is not a supplier invoice.

## 5. Two explicit limits on extension

**Positive rank need not define a closure family.** In F_2^3 take H=<e1,e2>,
L=<e3>, U=<e1> and W=<e1,e2+e3>.
The strict-nesting choices (U,W) and (U,U+L) are both allowed. Their componentwise
intersection is (U,U), which has zero gap. Every family of implication-closed
bit assignments, including auxiliary bits and pins, is closed under intersection
and union, and projection preserves these operations. Consequently exact strict
gap feasibility in this representation cannot always be expressed by implications,
even after adding auxiliary Boolean variables. This does not exclude richer
optimization methods or another encoding that does not preserve these operations.

**A power price is not dimension-linear.** For 0<t<1, h(r)=r^t satisfies
h(0)+h(2)<2h(1). Use the same U,W,H,L as the strict-gap example. At the lower
vertex choose U or U+L. At the upper vertex choose U+L or W+L. These are
allowed options; all four pairs are nested, with gaps 1,2,0,1 in that order.
The lower choice varies its one bit. The upper choice fixes the projected
atom and varies its other bit. A linear bit objective must have zero mixed
difference. This table instead has 2h(1)-h(0)-h(2)>0. Thus the linear reduction
cannot silently substitute the nonlinear power invoice.

## Sources, scope and obligations

ToikY PR #7459 at 4f3dc4a40e2a3bee5fc0d6d5dfd7e4e95614fc22 poses mixed growth
and demotion as an untested direction after its common-hyperplane screen.
Its one-sided numerical bound and its #7456/#7454/#7334/#7113 lineage are
credited premises about that work, not replayed or used to prove this theorem.
This proof uses no predecessor executable, invoice, construction or receipt.
David Ganz / Dugongue's merged PR #556 already optimizes binary U/P(U)
frame choices for one oblique projection over F_2, with monotone nonlinear
paid edge prices. It is background on earlier frame cuts. That option family
is different from this four-option lattice and is not generalized here to
nonlinear signed prices. No part of its numerical search is replayed.
The maximum-closure reduction is classical; no literature-wide priority is
claimed. The explicit local lattice and scope examples are the contribution.

The theorem fixes one transverse line/hyperplane pair, a nesting graph and
linear rank prices. It does not cover arbitrary independent recharts, strict
gap constraints, nonlinear recursive powers or physical execution. A P104
application still needs a current complete edge inventory, scalar/native
legality, positive productive ranks, endpoint contracts, ownership, dirty
restoration, precision, stock and full fees. No new kappa, admitted supplier,
selected-frontier change or complete multiplication theorem is claimed.
123 changes: 123 additions & 0 deletions research/mixed-rechart-closure/README.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,123 @@
# Exact mixed rechart optimization with linear rank prices

This contribution was produced by Nick Petalas. It is a scoped written proof
with exact finite corroboration. For one common hyperplane H and transverse line L, each helper's
allowed subspaces

```text
U intersect H, U, (U intersect H)+L, U+L
```

form a Boolean lattice with one or two bits. On any original nesting graph,
all replacement nesting constraints become at most four implications per edge.
Arbitrary rational dimension-linear signed invoices and fixed endpoint options
therefore reduce exactly to maximum-weight closure on at most two nodes per
helper. The result holds over every field. [PROOF.md](PROOF.md) gives the
representation, objective, min-cut construction and infeasible-pin criterion.

A sharp small example has original rank gap 1, one-sided growth optimum 2,
one-sided shrinkage optimum 2 and mixed optimum 3. Separate one-sided screens
therefore do not bound the mixed family. Two additional examples explain the
scope: positive productive gaps need not define an implication-closed family,
and nonlinear power prices do not become unary linear bit weights. The latter
does not exclude richer cut constructions with pairwise terms.

## Evidence and reproduction

From the repository root with CPython 3.12 and the standard library:

```sh
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/mixed-rechart-closure/verify.py
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -O -B research/mixed-rechart-closure/verify.py
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/mixed-rechart-closure
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/mixed-rechart-closure --check-source-history --check-modes
```

Other installations may substitute their CPython 3.12 path. Each registered
command has a 120-second limit. Direct replay prints a generated
`PASS_MIXED_RECHART_CLOSURE` JSON receipt bound by SHA256 to all six package
files. It writes no files and also works in a Git-free export.

The exhaustive checker generates every subspace of F_2^n for n=2,3,4 and
checks every hyperplane/transverse-line pair and every originally nested edge.
It covers 154 flags, 8,518 local lattices, 63,480 nested edges and 552,408 option
pairs. Direct subspace containment agrees with the compiled implications in
every case. A separate direct enumeration of physical subspace options checks
the min-cut objective on 1,950 signed integer price cases, 548 rational-price
fixed-option cases and 83 graph/cycle cases. Eight invalid-domain controls
require the exact rejection reason. The written proof supplies the universal
claim; these finite computations are corroboration, not proof-kernel acceptance.

## Sources and overlap

ToikY [PR #7459](https://github.com/CrocSwap/integer-mult-bounds/pull/7459),
head `4f3dc4a40e2a3bee5fc0d6d5dfd7e4e95614fc22`, leaves mixed growth/demotion
open after its common-hyperplane screen. It supplies the source question and
one-sided motivation. Its #7456/#7454/#7334/#7113 lineage keeps its credit.
No predecessor scientific program, numerical bound or receipt is replayed,
imported or relied on to prove this result. The proof is self-contained.
David Ganz / Dugongue's merged [PR #556](https://github.com/CrocSwap/integer-mult-bounds/pull/556)
already gives a binary frame/projection cut theorem, including monotone
nonlinear paid tariffs. Its two options are U and its oblique projection;
the present four options, mixed growth/demotion and signed linear objective
are different. The new claim is the explicit two-bit representation, rather
than the use of cuts in frame search. Its theorem is pinned as background.
Maximum closure/min-cut and distributive lattices are classical methods;
no literature-wide priority is claimed for them. New work is Apache-2.0.

The `p104-side-correction` card changes scope to an abstract optimization
interface. [TASK.json](TASK.json) preserves the original card and declares
this side result. [SOURCES.json](SOURCES.json) pins the selected record,
catalogue and prior projection theorem as historical provenance. None is a
scientific runtime input.
Base canonical main is `e54523517d0f03e58352e647c403a5af3e525a57`, priority
revision 8, with selected #7000 unchanged. The contextual picker reports that
the catalogue's older #5599 assessment differs from that selected record.
The source-binding orientation command passed; it is not a selected replay.

Live open PRs, recent own PRs, handoff claims, local reservations, merged
searches and distinctive main-tree terms were checked. The cached overlap
search had complete remote pagination but omitted 9,979 sparse local notes;
main-tree Git searches supplement that omission. No claim of complete novelty
coverage follows from absence of matches. Related one-sided open work includes
#7459, #7456 and #7454. #7458 tests a different two-plane growth family.

## Limitations

This is an enabling scoped proof with no new kappa, physical word, supplier
admission, selected-frontier change or complete multiplication theorem. All
five selected framework assumptions remain. No selected scientific cold replay,
predecessor suite, Lean or Docker run was performed. Independent human and
formal proof-kernel review are unclaimed.

## Open next questions

- Can the actual nonlinear signed power invoice be optimized on this mixed
lattice? Start with its paid/productive edge mixed differences. Positive
productive-rank constraints and complete charges remain blockers.
- Does a current P104 public-component inventory have a useful mixed rechart?
First bind the exact word, eligible components, endpoint contracts and every
incident edge. Scalar/native legality, ownership, dirty restoration,
precision and stock must be priced before claiming a supplier improvement.

Structured next questions are in [TASK.json](TASK.json). The first proved
reduction is the deliverable; no larger construction search is included.

## Verifier constraints

All functions are below 60 lines. The checker has no recursion, network,
subprocess, dynamic code loading or output file creation. Subspace domains
stop at dimension four. Graphs have at most eight vertices, sixteen bits,
64 edges and sixteen pins; brute-force assignments are at most 4^8. BFS scans
at most eighteen vertices. Edmonds-Karp uses an explicit vertex/arc-derived
augmentation cap and fails on exhaustion. Mathematical guards use explicit
exceptions and remain enabled under optimization. Normal/optimized warning-strict
replay and source compilation supply the available Python diagnostics.

Power-of-ten rule 3 deviation: CPython allocates managed integers, Fractions,
containers and queue nodes during this one-shot check. Fixed fixture domains,
sequential processing and the bounds above limit live collections. Package
reads are limited to 128 KiB per file. No fixed-allocation claim is made; a
fixed-allocation runtime would need a separate representation. Rule 9 deviation:
eight local rejection callbacks have fixed targets and exact expected reasons;
all propagate unexpected exceptions. No general callback input is accepted.
24 changes: 24 additions & 0 deletions research/mixed-rechart-closure/SOURCES.json
Original file line number Diff line number Diff line change
@@ -0,0 +1,24 @@
{
"schema_version": 1,
"base_commit": "e54523517d0f03e58352e647c403a5af3e525a57",
"files": [
{
"path": "certificates/selected-result.json",
"usage": "provenance",
"git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8",
"sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1"
},
{
"path": "docs/research/agent-task-catalog.json",
"usage": "provenance",
"git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
"sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
},
{
"path": "research/projection-cut-toolkit/PROJECTION-CUT-THEOREM.md",
"usage": "provenance",
"git_blob": "2e1e3d129399026a804ddf23c0ec7fc48a99d939",
"sha256": "bf647c60a16d8331368f2839224d8036ddc052ea19d4ce35cac9656702c48eab"
}
]
}
Loading
Loading