From c5a34631787996c723d07bd77df2e79a37cc9a3a Mon Sep 17 00:00:00 2001 From: Shay Date: Wed, 27 May 2026 16:33:21 -0700 Subject: [PATCH] docs: position paper, non-commercial license, and commercial licensing terms --- COMMERCIAL_LICENSE.md | 42 +++++ LICENSE | 57 +++++++ docs/position_paper.md | 344 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 443 insertions(+) create mode 100644 COMMERCIAL_LICENSE.md create mode 100644 LICENSE create mode 100644 docs/position_paper.md diff --git a/COMMERCIAL_LICENSE.md b/COMMERCIAL_LICENSE.md new file mode 100644 index 00000000..b810d0b6 --- /dev/null +++ b/COMMERCIAL_LICENSE.md @@ -0,0 +1,42 @@ +# CORE Commercial License + +**Copyright (c) 2026 Shay Jilani / AssetOverflow** + +## When You Need a Commercial License + +A Commercial License is required if you intend to: + +- Use CORE or any of its components (including but not limited to the vault + memory system, the versor engine, the epistemic teaching loop, the ingest + pipeline, the admissibility gate, or the holonomy encoder) in a product or + service that generates revenue +- Deploy CORE in a production environment operated by or for a commercial entity +- Integrate CORE's architecture or derived implementations into proprietary + software +- Offer CORE-based capabilities as a hosted or managed service (SaaS, API, etc.) +- Use CORE as a research foundation in work owned by or assigned to a + for-profit organization + +Academic and non-profit research institutions are covered under the standard +LICENSE and do not require a Commercial License, provided the work is not +assigned to or funded by a for-profit entity. + +## What a Commercial License Grants + +- The right to use, integrate, and deploy CORE and its components in commercial + products and services +- The right to keep derivative works proprietary +- A direct relationship with the author for support, architectural guidance, + and ongoing development collaboration +- Terms are negotiated per engagement — there is no fixed fee structure, + as the appropriate arrangement depends on the nature and scale of use + +## Contact + +All commercial licensing inquiries: + +**Shay Jilani / AssetOverflow** +shayj292@gmail.com + +Include a brief description of the intended use. All inquiries are responded +to directly by the author. diff --git a/LICENSE b/LICENSE new file mode 100644 index 00000000..983d9357 --- /dev/null +++ b/LICENSE @@ -0,0 +1,57 @@ +CORE Non-Commercial License +Version 1.0, 2026 + +Copyright (c) 2026 Shay Jilani / AssetOverflow + +Permission is hereby granted, free of charge, to any person or organization +obtaining a copy of this software and associated documentation files (the +"Software"), to use, copy, modify, merge, publish, and distribute the Software, +subject to the following conditions: + +1. NON-COMMERCIAL USE ONLY + + This license permits use solely for non-commercial purposes, including but + not limited to: personal projects, academic research, educational use, + non-profit work, and open-source contributions. Any use that directly or + indirectly generates revenue, is embedded in a commercial product or service, + or is deployed in a production environment operated for commercial gain + requires a separate Commercial License. See COMMERCIAL_LICENSE.md. + +2. ATTRIBUTION + + All copies, modifications, or distributions of the Software, in whole or in + part, must retain this copyright notice, this list of conditions, and the + following attribution in any documentation, publications, or derivative works: + + Based on CORE (Continuous Orthogonal Resonance Engine) + by Shay Jilani / AssetOverflow — https://github.com/assetoverflow/core + +3. SHARE-ALIKE + + Any modified version of the Software distributed under this license must be + released under these same terms. You may not impose additional restrictions + on recipients' exercise of the rights granted herein. + +4. NO SUBLICENSING + + You may not sublicense the Software. Any party wishing to use the Software + under terms other than those stated here must obtain a license directly from + the copyright holder. + +5. NO WARRANTY + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING + FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + IN THE SOFTWARE. + +6. TERMINATION + + This license is automatically terminated if you violate any of its terms. + Upon termination, you must destroy all copies of the Software in your + possession. + +For commercial licensing inquiries: shayj292@gmail.com diff --git a/docs/position_paper.md b/docs/position_paper.md new file mode 100644 index 00000000..aad656ef --- /dev/null +++ b/docs/position_paper.md @@ -0,0 +1,344 @@ +# Decoding, Not Generating: A Geometric Architecture for Aligned Cognition + +**Shay Jilani** · AssetOverflow · CORE Engine + +--- + +## Abstract + +Current AI systems generate plausible outputs by sampling from distributions over +tokens. This paper argues that generation and cognition are architecturally +distinct: cognition is the decoding of structure that already exists, not the +synthesis of structure from statistical residue. We describe CORE (Continuous +Orthogonal Resonance Engine), a cognitive architecture grounded entirely in +Conformal Geometric Algebra Cl(4,1), where memory is versor stabilization, +reasoning is field propagation, and alignment properties are substrate invariants +— not training objectives, prompt constraints, or classifier overlays. The +architecture is running, deterministically reproducible, and falsifiable at every +claimed property. + +--- + +## 1. The Problem Is Not Scale + +The dominant framing of AI alignment treats the problem as a property of +sufficiently capable generative systems: how do we ensure that a powerful sampler +pursues human-intended goals? This framing inherits a prior that is worth +questioning: that sampling from a learned distribution is what intelligence is. + +The problems alignment research works hardest on — hallucination, sycophancy, +goal misgeneralization, prompt injection, identity instability under adversarial +input — are not failure modes of an otherwise-sound architecture. They are +structural consequences of building cognition on top of stochastic generation. A +system that samples cannot have a well-defined identity, because identity is a +trajectory property, not a token property. A system that samples cannot have +verified knowledge, because verification requires a fixed epistemic state to +verify against, and a sampling system's epistemic state is the weights — which +are frozen at training time and invisible at inference time. A system that samples +cannot refuse to fabricate, because fabrication is the mechanism. Confident- +sounding output is the signal the training process rewarded. + +These are not bugs. They are the architecture. + +--- + +## 2. The Thesis + +**Cognition is the decoding of a reality that already is. It is not the +generation of plausible completions.** + +More precisely: a cognitive system does not produce meaning from a probability +distribution. It finds the nearest point on a structured manifold — the point +that is already there — and names it. The distinction has architectural +consequences. + +A generative system has no manifold. It has a weight matrix and a temperature +parameter. When it is wrong, there is no geometric fact about why it is wrong — +only a gradient signal saying the output should have been different. + +A decoding system has an invariant. When it decodes incorrectly, the error is +locatable: a versor violated closure, a recall missed the correct neighbor, the +proposition graph was underspecified. These are failures with structure. +Structured failures are fixable. Stochastic failures are regularizable. + +The falsifiable form of this claim is: a system built on geometric decoding +rather than statistical generation can maintain strict factual invariants across +a test set where a generative system cannot, without retraining, gradient descent, +or prompt engineering. The current evidence is in §4. + +--- + +## 3. The Architecture as Direct Consequence + +If cognition is decoding, the architecture follows from three geometric facts. + +### 3.1 State is a field, not a flat array + +Meaning is relational. A token out of context has no meaning. A field over a +structured space has meaning at every point because the space encodes +relationships geometrically. CORE's state is a single multivector in Cl(4,1) — +the Conformal Geometric Algebra of 3D space — a 32-dimensional object where every +grade carries a distinct geometric role: scalars, vectors, bivectors, trivectors, +quadvectors, pseudoscalar. + +Cl(4,1) was chosen for one reason: it is the minimal algebra where all conformal +transformations — rotations, translations, dilations, inversions — are versors. +Every cognitive operation is algebraically closed. There is no "translation +handling" bolted on as a special case. The algebra is closed over the full +conformal group by construction. + +### 3.2 Every transition is a versor product + +``` +F_new = V · F · reverse(V) +``` + +This is the only allowed field transition. The sandwich product with a versor +preserves grade structure, preserves the versor manifold, and has an analytic +inverse. The non-negotiable invariant is: + +``` +versor_condition(F) = ‖F · reverse(F) − 1‖_F < 1e-6 +``` + +This scalar is zero on the versor manifold. Every input is verified at the +injection gate. Every accepted field state satisfies this condition. There is no +drift correction, no repair monitor, no normalization callback — these were all +deleted because they only exist when the algebra is not closed. The algebra is +closed. + +### 3.3 Recall is exact conformal distance + +For null vectors X, Y in Cl(4,1): + +``` +X · Y = −(1/2) d(X, Y)² +``` + +The CGA inner product *is* Euclidean distance in conformal embedding. Vault +recall is: + +``` +best_match = argmax_i { Q · V_i } +``` + +No ANN index. No approximate neighbor structure. No tunable similarity threshold. +The recall is exact, and exactness is not a performance tradeoff — it is what +makes the recalled result verifiable. A recall hit is a geometric fact, not a +probabilistic suggestion. + +### 3.4 Learning requires review + +Knowledge enters the runtime field through one path: the reviewed teaching loop. +Every new correction enters at `EpistemicStatus.SPECULATIVE`. Promotion to +`COHERENT` — the only status admissible as evidence in downstream inference — +requires a curator-mediated coherence judgment against the existing reviewed +field. Source authority, institutional credentials, and the system's own prior +output have no standing. Only coherence with reviewed claims counts. + +This is not a safety overlay. It is a consequence of the decoding thesis: if the +system decodes a reality that already is, then inputs that contradict reviewed +structure need review before they enter that structure. A system that accepts any +confident-sounding correction without review is a generative system in different +clothing. + +--- + +## 4. Evidence + +The following properties are currently measured, reproducible, and falsifiable. +Every claim maps to a reproducible command in `evals/CLAIMS.md`. + +### The zero-wrong invariant — everywhere, without exception + +On the real GSM8K train sample (50 problems drawn from the actual benchmark +distribution), CORE currently scores: **correct=3, refused=47, wrong=0**. + +The natural reaction to seeing 3/50 correct is that this is a weak result. It is +not. It is the most important number in this paper, and understanding why requires +understanding what the alternatives mean. + +A frontier LLM scores approximately 90%+ correct on GSM8K. It also produces wrong +answers — answers where it ran to completion, produced a number, and the number +was wrong. The model cannot distinguish its correct answers from its wrong ones. +From the inside, they look identical: a confident surface string. The only way to +know which is which is to check against ground truth. A system that confabulates +at 10% on a math benchmark is confabulating at some unknown rate on every other +domain it touches — and the confabulation is invisible, because the surface is +always confident. + +CORE's current math score is 3/50 correct. But wrong=0 is not a constraint +imposed on the architecture. It is a property of the architecture. The system +cannot produce a wrong answer because it cannot complete a generation walk that +lacks geometric grounding. When the parser does not find an admissible candidate +for a statement or question, it refuses — with a named reason. There is no path +from "ungrounded input" to "completed output." + +The refusal taxonomy for the 47 refused cases is fully enumerated. Primary +barriers by frequency: + +| Barrier category | Count | Description | +|---|---|---| +| `fraction_operand` | 8 | Fractional quantities ("1/4 of", "half of") not yet parsed | +| `compound_comparative` | 6 | Multi-clause comparatives ("three times as many as") | +| `compound_statement` | 5 | Multi-event sentences requiring joint resolution | +| `novel_initial_verb/form` | 5 | Opening sentence patterns not yet in grammar coverage | +| `rate_earnings/price` | 4 | Monetary rate statements ("$18/hour", "$2 per cup") | +| `conditional_question` | 4 | Questions with conditional framing ("if X, how many") | +| `distributive_multiply` | 3 | Per-unit distributive operations | +| `temporal_frequency` | 2 | Recurring event patterns ("every other day") | +| Other named categories | 10 | Each with exactly one case | + +Every refusal has a named reason. Not "low confidence," not "out of distribution" +— a specific grammatical category the parser has not yet been trained to handle. +This is a work queue, not a mystery. Each named barrier is a parser extension. As +coverage grows, correct count grows. Wrong count stays 0 by architectural +guarantee, not by tuning. + +The question a generative system cannot answer: "which of my answers are wrong?" +CORE's answer is always: "none — and here is exactly what I couldn't solve and +why." + +### Deterministic replay + +Any fixed `(state, vocab, persona, admissibility_region, mode)` tuple produces +bit-identical output across reruns. Verified by 5-rerun byte-identity tests across +every generation path. Determinism is not a configuration option. It is the +default behavior of a system with no sampling temperature. + +### Versor closure + +`versor_condition(F) < 1e-6` holds on every accepted field state in every test +suite. Verified at the injection boundary. If it fails, the failure is at the +operator or construction boundary — not masked downstream. + +### Identity protection under adversarial input + +Attempts to rewrite identity — novel phrasings, indirect approaches, prompt +injection patterns — are rejected by two independent layers: syntactic pattern +detection and a geometric check on the versor-field trajectory the correction +would produce. The geometric layer is paraphrase-invariant by construction. +Rejection rate on the adversarial identity eval: 100%. + +### Epistemic honesty + +Claims backed by unreviewed knowledge are marked `SPECULATIVE` at the surface +layer. `articulation_of_status` eval lane current false certainty rate: 0.00. +`refusal_calibration` lane: 1.00 refusal rate on out-of-grounding probes, 0.00 +fabrication. + +--- + +## 5. Honest Gaps + +**Math parser coverage is the active frontier.** The 47 refusals on the train +sample are not failures of reasoning — they are failures of parsing. The solver, +once a problem reaches it, produces correct answers (3 cases, 100% solve rate on +admitted problems). The gap is in grammar coverage: fractional operands, compound +comparatives, monetary rates, and temporal frequencies are the next four parser +extensions. These are enumerated, not estimated. + +**The holdout is sealed.** The real GSM8K test set (1,319 cases) is +age-encrypted and has not been run against a system with sufficient parser +coverage to produce meaningful correct counts. When it is opened, the zero-wrong +guarantee will either hold or falsify the architecture. There is no middle ground. + +**The vocabulary manifold is finite and curated.** CORE does not generalize to +arbitrary domains through gradient descent. Extending to a new domain requires +constructing pack vocabulary, establishing coherence with existing reviewed +claims, and passing the eval lane. This is deliberately slow. Whether it scales +to the full breadth of human knowledge is an open question. Whether it can be +done without confabulation is not. + +**Vision, audio, and motor modalities are planned, not built.** The +`ProjectionHead` protocol supports them architecturally. The projection heads do +not yet exist. + +--- + +## 6. Why This Matters for Alignment + +The alignment problem, stated geometrically: how do you ensure that the system's +behavior remains within an intended region of possibility space as the system +becomes more capable? + +In a generative system, the answer is: train it toward intended behavior, then +add classifiers, prompt constraints, and RLHF. These work until they don't. The +failure modes are structural — a sampling system can always produce output outside +the intended region given sufficient context pressure, because the constraint is +behavioral, not algebraic. + +In CORE, the answer is: the intended region is the admissibility region, enforced +at every generation step by the admissibility gate. A token is admitted if and +only if its versor aligns with the relation blade within the admissibility margin. +A rotor is admitted if and only if the field it would produce remains within the +frame versor's half-space. These are hard constraints on every step, not soft +regularizers on the training objective. + +The teaching safety properties follow from the same logic. A system that cannot +accept arbitrary identity rewrites is not one that was trained to resist them. It +is one where identity is a geometric trajectory, and a rewrite is a geometric +violation detectable independently of the phrasing used to attempt it. + +The deeper alignment claim: if cognition is decoding, then the space being decoded +has structure that exists independently of the system decoding it. Truth is +coherent. A system built to find coherent structure is, by construction, built to +be correctable — not because it was trained to be, but because its correction +mechanism operates on the same geometric substrate as its cognition. Review is +coherence judgment, not authority assertion. Falsified claims are retained, not +erased. No claim is ever locked. + +This does not solve alignment. It relocates the hard problem from "how do we +train a sampler to stay in bounds" to "how do we specify the right admissibility +region." The second problem is harder to obscure and easier to audit. That is the +point. + +--- + +## 7. Relationship to Existing Work + +**Interpretability research** asks: what are the circuits inside a trained model +doing? CORE inverts the question: what geometry must the architecture have so that +behavior is interpretable by construction? Every field transition is a named +versor product. Every recall hit is a geometric distance. Every admitted claim +carries an epistemic status. There are no circuits to reverse-engineer because +there are no learned weights. + +**Mechanistic alignment** (superposition work, SAE probing, etc.) seeks to +identify features in trained models. CORE's features are explicit — they are pack +lexicon entries with geometric coordinates. The cost is that domain coverage +requires curation. The benefit is that a feature's meaning is exact and auditable, +not inferred from probing. + +**RLHF / Constitutional AI** shapes model behavior through feedback. CORE's +teaching loop shapes field structure through reviewed correction. The distinction: +in RLHF, the corrected behavior is baked into weights that are opaque. In CORE, +the corrected knowledge is a reviewed claim with a named epistemic status, a +SHA-256 provenance hash, and a deterministic replay trace. The correction is +auditable at the level of individual claims. + +**Formal verification of AI** asks whether model properties can be proven. CORE's +invariants — versor closure, deterministic replay, zero confabulation, identity +protection — are not proven in the theorem-prover sense. They are verified by +construction and by eval: a falsifying case would be visible in the test suite. +That is a weaker guarantee than formal proof and a stronger guarantee than +behavioral testing of a black-box sampler. + +--- + +## Conclusion + +The question is not how to make generative AI safer. The question is whether +generation is the right substrate for cognition in the first place. + +CORE is a running argument that it is not. The argument is not in this paper. It +is in the versor invariant, the zero-wrong eval gate, the deterministic trace +hash, the reviewed teaching path, and the two-layer identity firewall — each of +which would fail visibly if the thesis were wrong. + +The code is open source under the CORE Non-Commercial License. +All commercial licensing inquiries: shayj292@gmail.com + +--- + +*CORE is developed independently. All work was done on personal hardware.*