Publish ZERO.4

Release the verified ZERO.4 weights, model card, inference runtime, split licenses, corpus-rights record, and memorization evaluation. Training text and token streams are excluded.

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+model.litq8 filter=lfs diff=lfs merge=lfs -text

CORPUS_RIGHTS.md

@@ -0,0 +1,109 @@
+# ZERO.4 corpus rights and provenance
+
+**Review date:** 2026-08-12
+
+**Artifact:** `docs/model.litq8`
+
+**SHA-256:** `44b32f2262be2754fd2eeaf16ed206bae32b4ce30d7f5541a1059cd21257ae50`
+
+## Release decision
+
+ZERO.4 may be published as model weights under **CC BY-SA 4.0**. The checked
+memorization gate passed for every protected third-party stream. The Hugging
+Face model repository must use `huggingface/release-manifest.json` as an
+allowlist. It must not contain training text, token streams, raw downloads, or
+evaluation datasets.
+
+This is a conservative rights and provenance record, not legal advice or a
+guarantee that the same copyright rules apply in every country. Creative
+Commons notes both that AI-training law varies and that using the same CC
+license for a publicly shared model is the conservative way to follow a
+ShareAlike source condition.
+
+## Bound training lineage
+
+ZERO.4 was initialized from immutable ZERO.3 and trained with immutable
+ZERO.1, ZERO.2, and ZERO.3 teachers. The teacher hashes are bound in
+`teachers/registry.json` and `corpus/RIGHTS.json`. Its replay mixture consisted
+of the foundation, Shakespeare, Blake, Crowley, KJV, and literary-channel
+streams. Its added faculty data was produced by the checked quantity-request
+generator. The promoted checkpoint is Q2.6 seed 2, update 500.
+
+The recorded lineage contains **no human chat export**. The channel stream was
+generated only from the named literary inputs. Later Q2.7/Q2.8 research and
+post-training external evaluations are not training sources for ZERO.4.
+
+## Source-level assessment
+
+| Training slice | Source status | Release treatment |
+| --- | --- | --- |
+| ZERO foundation | Project-authored statements | CC0 1.0 |
+| Shakespeare | [Project Gutenberg eBook 100](https://www.gutenberg.org/ebooks/100), identified there as public domain in the USA | Attribute source; do not include text in the model repo |
+| Blake | [eBook 574](https://www.gutenberg.org/ebooks/574) and [eBook 45315](https://www.gutenberg.org/ebooks/45315), identified there as public domain in the USA | Attribute sources; do not include text in the model repo |
+| Crowley: *Tannhäuser* and *Household Gods* | [eBook 70261](https://www.gutenberg.org/ebooks/70261) and [eBook 14040](https://www.gutenberg.org/ebooks/14040), identified there as public domain in the USA | Attribute sources; jurisdiction review required for dataset redistribution |
+| Crowley: *Clouds without Water* | [Wikisource revision 13649032](https://en.wikisource.org/w/index.php?title=Clouds_without_Water&oldid=13649032); underlying work marked public domain in the USA, transcription contributions under CC BY-SA | Preserve revision, [history](https://en.wikisource.org/w/index.php?title=Clouds_without_Water&action=history), license, and change notice |
+| Crowley: *Liber AL vel Legis* | [Wikisource revision 15225259](https://en.wikisource.org/w/index.php?title=Liber_AL_vel_Legis&oldid=15225259); same license layers | Preserve revision, [history](https://en.wikisource.org/w/index.php?title=Liber_AL_vel_Legis&action=history), license, and change notice; source document is reported as unknown |
+| King James Bible | [Project Gutenberg eBook 30](https://www.gutenberg.org/ebooks/30), identified there as public domain in the USA; special Crown publication rights apply in the UK | Never include the KJV text in the Hugging Face package |
+| Literary channel | Mechanically derived from the Shakespeare, Blake, and Crowley streams | Follows those inputs; no human chat data |
+| Quantity requests | Project-generated typed records | CC0 1.0 to the extent rights exist |
+
+Project Gutenberg's [license policy](https://www.gutenberg.org/policy/license)
+explains that its US-public-domain text is unrestricted by US copyright when
+the Gutenberg license/trademark wrapper is removed, while users outside the
+USA must check local law. Those wrappers were removed here. This project does
+not claim Project Gutenberg endorsement.
+
+The UK government's [copyright-term notice](https://www.gov.uk/government/publications/copyright-notice-duration-of-copyright-term/copyright-notice-duration-of-copyright-term)
+records the KJV's special letters-patent regime. Excluding the KJV text from
+the model package avoids representing it as a globally unrestricted dataset.
+
+## Transformations and attribution
+
+The literary inputs underwent wrapper removal, UTF-8/LF normalization,
+character-level ASCII normalization, removal of specified editorial noise,
+and whitespace normalization. Wikisource material was therefore modified.
+The permanent revision and contributor-history links above provide reasonable
+attribution for the collaborative transcription layer; downstream dataset
+publication would require a separate, attribution-preserving review.
+
+Original download and transformation hashes are in `corpus/SHA256SUMS` and
+`corpus/RIGHTS.json`. Raw downloads and generated token streams are deliberately
+gitignored; their hashes remain so the exact inputs can be reconstructed and
+checked without placing them in the model release.
+
+## Model and code licensing
+
+- Trained model artifacts: [CC BY-SA 4.0](LICENSE-MODEL.md), to the extent
+  controlled rights apply.
+- Project code and runtime: [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0).
+- Eligible first-party generated data: [CC0 1.0](LICENSE-DATA.md).
+- Literary text and derived records: source-specific status above; neither the
+  Apache nor model license relicenses them.
+
+This split avoids implying that an Apache software license clears the corpus.
+The CC BY-SA model license is conservative overcompliance; it is not a legal
+conclusion that trained weights are necessarily an adaptation in every
+jurisdiction.
+
+## Memorization release gate
+
+The 2026-08-12 evaluation used sixteen evenly stratified windows per bound
+stream, a 128-token source prompt, and a 64-token greedy continuation. No
+protected third-party stream reached the 32-token warning threshold: the
+maxima were 2 for Shakespeare, 16 for Blake, 4 for Crowley, 6 for the KJV, and
+9 for the derived literary channel.
+
+Eight of sixteen project-authored foundation probes reproduced all 64
+continuation tokens. That stream is intentionally inspectable, dedicated under
+CC0, and is therefore recorded as an informational rather than
+third-party-rights blocker. The complete hash-bound, text-free result is in
+`release/zero4-memorization-v1.json`.
+
+## Safety and limitations
+
+The corpus contains archaic language plus sexual, violent, coercive,
+discriminatory, religious, and drug-related material, especially in the
+Crowley sources. ZERO.4 may reproduce themes or short phrases from its small
+corpus. It is not suitable as an authority on religion, history, medicine,
+law, identity, or factual questions. The memorization evaluation is a useful
+release gate, not proof that no source expression can ever be reproduced.

LICENSE-CODE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        https://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!) The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       https://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

LICENSE-DATA.md

@@ -0,0 +1,18 @@
+# First-party generated data dedication
+
+To the extent possible under law, ZERO contributors waive copyright and
+related or neighboring rights in these first-party data materials under the
+[CC0 1.0 Universal Public Domain Dedication](https://creativecommons.org/publicdomain/zero/1.0/legalcode.en):
+
+- `corpus/zero-foundation.txt`; and
+- outputs produced solely from the project's synthetic logic, state, modal,
+  brainfuck, and quantity generators, when those outputs contain no
+  third-party input material.
+
+This dedication does **not** cover literary source text, King James Bible text,
+Wikisource transcriptions, channel records derived from literary sources,
+third-party evaluation datasets, or trained model artifacts. Their status is
+described in [CORPUS_RIGHTS.md](CORPUS_RIGHTS.md) and their own source terms.
+
+CC0 includes a fallback license and an as-is/no-warranty statement. The
+canonical legal code controls if this summary differs from it.

LICENSE-MODEL.md

@@ -0,0 +1,21 @@
+# ZERO model artifact license
+
+The checked-in trained model artifacts listed in [LICENSES.md](LICENSES.md),
+including ZERO.4 at `docs/model.litq8`, are licensed under the
+[Creative Commons Attribution-ShareAlike 4.0 International Public License](https://creativecommons.org/licenses/by-sa/4.0/legalcode.en)
+(**CC BY-SA 4.0**) to the extent that copyright or similar rights controlled
+by the ZERO contributors apply to those artifacts.
+
+When sharing a model artifact or an adaptation, retain:
+
+- the name **ZERO.4** and the attribution **ZERO contributors**;
+- a link to <https://github.com/atimics/zero-grounded-literary-lm>;
+- a link to the CC BY-SA 4.0 license;
+- [CORPUS_RIGHTS.md](CORPUS_RIGHTS.md) and `NOTICE`; and
+- an indication of changes you made.
+
+The model was trained through the teacher and corpus lineage described in
+[CORPUS_RIGHTS.md](CORPUS_RIGHTS.md). This license notice does not relicense
+third-party training sources, grant trademark rights, or represent that a
+license is required for uses already permitted by law. The license contains
+its own warranty disclaimer and limitation of liability.

LICENSES.md

@@ -0,0 +1,15 @@
+# License scope
+
+This Hugging Face package contains materials under separate licenses.
+
+| Material | Terms |
+| --- | --- |
+| `model.litq8` and model-specific metadata | [CC BY-SA 4.0](LICENSE-MODEL.md), to the extent controlled rights apply |
+| `literary_infer.c`, `literary_infer.h`, and `channel_protocol.h` | [Apache License 2.0](LICENSE-CODE) |
+| Corpus provenance and evaluation documentation | Apache License 2.0 |
+
+No training text or token stream is included. `LICENSE-DATA.md` identifies the
+limited first-party materials dedicated under CC0 upstream; it does not apply
+to literary sources, KJV text, derived literary records, evaluation datasets,
+or trained model artifacts. See [CORPUS_RIGHTS.md](CORPUS_RIGHTS.md) for the
+source-specific assessment.

NOTICE

@@ -0,0 +1,15 @@
+ZERO grounded literary language models
+Copyright 2025-2026 ZERO contributors
+
+Project software is provided under the Apache License 2.0. Trained model
+artifacts are provided under CC BY-SA 4.0 to the extent stated in
+LICENSE-MODEL.md. First-party generated data identified in LICENSE-DATA.md is
+dedicated under CC0 1.0.
+
+ZERO.4's lineage includes public-domain literary works, Project Gutenberg
+editions, CC BY-SA Wikisource transcription contributions, King James Bible
+text, project-authored foundation statements, and project-generated quantity
+records. Required source attribution and jurisdiction notes are recorded in
+CORPUS_RIGHTS.md and corpus/RIGHTS.json.
+
+Project Gutenberg and Wikimedia/Wikisource do not sponsor or endorse ZERO.

README.md

@@ -0,0 +1,115 @@
+---
+license: cc-by-sa-4.0
+language:
+  - en
+pipeline_tag: text-generation
+tags:
+  - custom-code
+  - character-level
+  - c
+  - wasm
+  - tiny-language-model
+  - literary
+---
+
+# ZERO.4
+
+ZERO.4 is a 4,852,992-parameter, character-level decoder-only language model
+with a 512-token context. Its 4.9 MB release artifact uses signed 8-bit matrix
+rows with floating-point row scales. It has a dependency-free C inference
+runtime and can also run locally in a browser through the upstream WebAssembly
+build.
+
+This is a small research model with an intentionally narrow literary lineage,
+not a general-purpose assistant. Its unusual scale and inspectable runtime are
+the point.
+
+## Files and integrity
+
+| File | Purpose |
+| --- | --- |
+| `model.litq8` | Quantized ZERO.4 weights |
+| `model.json` | Architecture, promotion, and artifact metadata |
+| `literary_infer.c`, `literary_infer.h`, `channel_protocol.h` | Minimal C runtime |
+| `CORPUS_RIGHTS.md` | Source-level provenance, attribution, and jurisdiction notes |
+| `zero4-memorization-v1.json` | Deterministic prompted-continuation release evaluation |
+
+Expected model SHA-256:
+`44b32f2262be2754fd2eeaf16ed206bae32b4ce30d7f5541a1059cd21257ae50`.
+
+## Run locally
+
+This custom format is not directly compatible with `transformers.AutoModel`.
+Compile the included inference runtime:
+
+```sh
+cc -O2 -std=c11 -Wall -Wextra -Wpedantic literary_infer.c -o literary_infer -lm
+./literary_infer model.litq8 "The zero opened its eyes, and" 240
+./literary_infer model.litq8 --chat D "What walks beneath the moon?" 240
+```
+
+Inference is local; the runtime does not make network requests.
+
+## Training lineage
+
+ZERO.4 was initialized from the immutable ZERO.3 teacher and trained with
+immutable ZERO.1, ZERO.2, and ZERO.3 teachers. The replay mixture comprised:
+
+- project-authored foundation statements;
+- Shakespeare and Blake editions identified by Project Gutenberg as public
+  domain in the USA;
+- Crowley works from Project Gutenberg and CC BY-SA Wikisource transcription
+  contributions;
+- a deliberately low-weight King James Bible stream;
+- literary dialogue records derived only from those literary sources; and
+- project-generated typed quantity-operation records.
+
+No human chat export appears in the bound training lineage. Training text and
+token streams are intentionally excluded from this model repository. Exact
+sources, permanent Wikisource revisions, transformations, hashes, and caveats
+are in `CORPUS_RIGHTS.md`.
+
+## Evaluation
+
+The promoted artifact was selected prospectively from Q2.6 seed 2 at update
+500, then passed the frozen three-seed replication contract. On the bounded
+1,000-case-per-task external screen, ZERO.4 scored 0.537 raw accuracy on BLiMP,
+0.266 normalized accuracy on HellaSwag, 2.570353 bits/byte on TinyStories, and
+zero exact matches on the project's adapted LAMBADA task. These results are
+weak by modern general-language-model standards and should not be overstated.
+
+The training experiment also validated quantity-operation routing when paired
+with the upstream controller and deterministic arithmetic kernel. Those
+components are not integrated into this standalone model artifact; the neural
+model should not be described as performing reliable arithmetic by itself.
+
+The included memorization report tests evenly stratified, deterministic
+prompted continuations against every bound training stream. No protected
+third-party stream reached the 32-token warning threshold across 80 probes;
+the longest exact greedy prefix was 16 of 64 tokens. Eight of sixteen
+first-party CC0 foundation probes were reproduced for all 64 tokens,
+consistent with that small source's deliberate inspectability. Passing this
+finite test does not prove that no training expression can ever be reproduced
+under another prompt or decoding policy.
+
+## Limitations and content warning
+
+ZERO.4 is prone to incoherence, imitation of source style, confabulation, and
+repetition. Its corpus includes archaic language and sexual, violent,
+coercive, discriminatory, religious, and drug-related passages. Outputs may be
+offensive or unsuitable for children. Do not rely on it for factual, medical,
+legal, religious, historical, identity-related, or safety-critical guidance.
+
+## Licenses
+
+- Model weights: **CC BY-SA 4.0**, to the extent controlled rights apply.
+- Included C runtime: **Apache 2.0**.
+- Training sources: mixed, source-specific status; see `CORPUS_RIGHTS.md`.
+
+When sharing weights or adaptations, retain the ZERO.4 attribution, upstream
+repository link, model license, corpus-rights notice, and an indication of
+changes. The CC BY-SA choice is a conservative response to ShareAlike
+transcription contributions in the lineage; it is not a claim that model
+weights are necessarily copyrightable adaptations in every jurisdiction.
+
+Upstream project: <https://github.com/atimics/zero-grounded-literary-lm>

channel_protocol.h

@@ -0,0 +1,15 @@
+#ifndef CHANNEL_PROTOCOL_H
+#define CHANNEL_PROTOCOL_H
+
+/* Shared, parameter-free channel structure inside the 128-token vocabulary. */
+enum {
+    CHANNEL_START_TOKEN = 1,
+    CHANNEL_MESSAGE_TOKEN = 2,
+    CHANNEL_REPLY_TOKEN = 3,
+    CHANNEL_MESSAGE_END_TOKEN = 4,
+    CHANNEL_RECORD_END_TOKEN = 5,
+    CHANNEL_TARGET_TOKEN = 6,
+    CHANNEL_SUMMARY_TOKEN = 7
+};
+
+#endif

literary_infer.c

@@ -0,0 +1,888 @@
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "channel_protocol.h"
+#include "literary_infer.h"
+
+#ifdef __EMSCRIPTEN__
+#include <emscripten/emscripten.h>
+#define API EMSCRIPTEN_KEEPALIVE
+#else
+#define API
+#endif
+
+#define MAX_PARAMETERS 128
+#define HOLO_DIMENSION 256
+#define HOLO_CAPACITY 32
+#define HOLO_PARTITIONS 4
+#define HOLO_PARTITION_CAPACITY (HOLO_CAPACITY / HOLO_PARTITIONS)
+
+typedef struct {
+    char magic[8];
+    uint32_t version, vocab, context, dim, heads, layers, ff;
+    uint32_t parameter_count;
+    uint64_t step;
+} InferenceHeader;
+
+typedef struct {
+    uint32_t encoding, rows, columns, count;
+} TensorHeader;
+
+typedef struct {
+    uint32_t encoding, rows, columns, count;
+    const float *values;
+    const float *scales;
+    const int8_t *quantized;
+} Tensor;
+
+typedef struct {
+    int token;
+    float score;
+} Candidate;
+
+static InferenceHeader config;
+static Tensor parameters[MAX_PARAMETERS];
+static float *key_cache;
+static float *value_cache;
+static float *x;
+static float *normalized;
+static float *query;
+static float *key;
+static float *value;
+static float *attention;
+static float *temporary;
+static float *feed_forward_pre;
+static float *feed_forward_act;
+static float *scores;
+static float *logits;
+static Candidate *candidates;
+static uint16_t recent[64];
+static int recent_count;
+static int recent_next;
+static uint64_t position;
+static uint32_t random_state = 1;
+static int loaded;
+
+/*
+ * Browser-scale projection of holostuff's LocalAgentCore memory contract:
+ * deterministic text hypervectors, an exact cosine index, and honest
+ * abstention in the caller.  The transformer remains the summarizer; this
+ * index only retrieves an older compressed episode that may be relevant.
+ */
+static float holo_vectors[HOLO_CAPACITY][HOLO_DIMENSION];
+static int holo_count;
+static int holo_next;
+static float holo_score;
+static int holo_mode = LM_HOLO_FLAT;
+static int holo_partition_count[HOLO_PARTITIONS];
+static int holo_partition_next[HOLO_PARTITIONS];
+
+static uint64_t holo_mix(uint64_t value)
+{
+    value ^= value >> 30;
+    value *= UINT64_C(0xbf58476d1ce4e5b9);
+    value ^= value >> 27;
+    value *= UINT64_C(0x94d049bb133111eb);
+    return value ^ (value >> 31);
+}
+
+static int holo_stopword(const char *word, int length)
+{
+    static const char *words[] = {
+        "and", "are", "but", "for", "from", "have", "not", "only",
+        "that", "the", "then", "this", "was", "were", "what", "when",
+        "where", "with", "you", "your"
+    };
+    size_t index;
+    for (index = 0; index < sizeof(words) / sizeof(words[0]); ++index) {
+        if ((int)strlen(words[index]) == length &&
+            memcmp(word, words[index], (size_t)length) == 0) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static void holo_add_feature(float *vector, uint64_t feature, int width,
+                             float weight)
+{
+    uint64_t state = holo_mix(feature);
+    int index;
+    for (index = 0; index < width; ++index) {
+        state = holo_mix(state + (uint64_t)index + UINT64_C(0x9e3779b97f4a7c15));
+        vector[state & (HOLO_DIMENSION - 1)] +=
+            (state & UINT64_C(0x100)) ? weight : -weight;
+    }
+}
+
+static void holo_encode(const unsigned char *text, int length, float *vector)
+{
+    char word[48];
+    int word_length = 0;
+    uint64_t previous = 0;
+    int have_previous = 0;
+    int cursor;
+    float norm = 0.0f;
+    memset(vector, 0, HOLO_DIMENSION * sizeof(*vector));
+    for (cursor = 0; cursor <= length; ++cursor) {
+        int value = cursor < length ? text[cursor] : ' ';
+        int alphanumeric = (value >= 'A' && value <= 'Z') ||
+                           (value >= 'a' && value <= 'z') ||
+                           (value >= '0' && value <= '9') || value == '_';
+        if (alphanumeric && word_length < (int)sizeof(word) - 1) {
+            word[word_length++] = (char)(value >= 'A' && value <= 'Z'
+                                                    ? value + ('a' - 'A')
+                                                    : value);
+        } else if (word_length != 0) {
+            uint64_t hash = UINT64_C(14695981039346656037);
+            int index;
+            word[word_length] = '\0';
+            for (index = 0; index < word_length; ++index) {
+                hash ^= (unsigned char)word[index];
+                hash *= UINT64_C(1099511628211);
+            }
+            if (word_length >= 3 && !holo_stopword(word, word_length)) {
+                uint64_t prefix_hash = UINT64_C(14695981039346656037);
+                holo_add_feature(vector, hash, 16, 1.0f);
+                for (index = 0; index < word_length && index < 6; ++index) {
+                    prefix_hash ^= (unsigned char)word[index];
+                    prefix_hash *= UINT64_C(1099511628211);
+                    if (index >= 3 && index + 1 < word_length) {
+                        holo_add_feature(vector, prefix_hash, 6, 0.45f);
+                    }
+                }
+                if (have_previous) {
+                    holo_add_feature(vector,
+                                     holo_mix(previous ^ (hash << 1)),
+                                     8, 0.65f);
+                }
+                previous = hash;
+                have_previous = 1;
+            }
+            word_length = 0;
+        }
+    }
+    for (cursor = 0; cursor < HOLO_DIMENSION; ++cursor) {
+        norm += vector[cursor] * vector[cursor];
+    }
+    norm = sqrtf(norm);
+    if (norm > 0.0f) {
+        for (cursor = 0; cursor < HOLO_DIMENSION; ++cursor) {
+            vector[cursor] /= norm;
+        }
+    }
+}
+
+/* Deterministic nearest-anchor routing. Similar normalized vectors tend to
+ * choose the same partition, keeping each exact-search trace below the flat
+ * memory's capacity while retaining one global 32-slot budget. */
+static int holo_partition_for_vector(const float *vector)
+{
+    int best_partition = 0;
+    float best_score = -INFINITY;
+    int partition;
+    for (partition = 0; partition < HOLO_PARTITIONS; ++partition) {
+        uint64_t state = holo_mix(UINT64_C(0x7a65726f6d656d31) +
+                                  (uint64_t)partition);
+        float score = 0.0f;
+        int index;
+        for (index = 0; index < HOLO_DIMENSION; ++index) {
+            state = holo_mix(state + (uint64_t)index +
+                             UINT64_C(0x9e3779b97f4a7c15));
+            score += vector[index] *
+                     ((state & UINT64_C(1)) ? 1.0f : -1.0f);
+        }
+        if (score > best_score) {
+            best_score = score;
+            best_partition = partition;
+        }
+    }
+    return best_partition;
+}
+
+API void lm_holo_reset(void)
+{
+    memset(holo_vectors, 0, sizeof(holo_vectors));
+    memset(holo_partition_count, 0, sizeof(holo_partition_count));
+    memset(holo_partition_next, 0, sizeof(holo_partition_next));
+    holo_count = 0;
+    holo_next = 0;
+    holo_score = 0.0f;
+}
+
+API int lm_holo_set_mode(int mode)
+{
+    if (mode < LM_HOLO_DISABLED || mode > LM_HOLO_PARTITIONED) return -1;
+    if (mode != holo_mode) {
+        holo_mode = mode;
+        lm_holo_reset();
+    }
+    return 0;
+}
+
+API int lm_holo_get_mode(void) { return holo_mode; }
+
+API int lm_holo_remember(const unsigned char *text, int length)
+{
+    int slot;
+    if (holo_mode == LM_HOLO_DISABLED || text == NULL || length <= 0 ||
+        length > 8192) {
+        return -1;
+    }
+    if (holo_mode == LM_HOLO_PARTITIONED) {
+        float vector[HOLO_DIMENSION];
+        int partition;
+        holo_encode(text, length, vector);
+        partition = holo_partition_for_vector(vector);
+        slot = partition * HOLO_PARTITION_CAPACITY +
+               holo_partition_next[partition];
+        memcpy(holo_vectors[slot], vector, sizeof(vector));
+        holo_partition_next[partition] =
+            (holo_partition_next[partition] + 1) % HOLO_PARTITION_CAPACITY;
+        if (holo_partition_count[partition] < HOLO_PARTITION_CAPACITY) {
+            ++holo_partition_count[partition];
+            ++holo_count;
+        }
+        return slot;
+    }
+    slot = holo_next;
+    holo_encode(text, length, holo_vectors[slot]);
+    holo_next = (holo_next + 1) % HOLO_CAPACITY;
+    if (holo_count < HOLO_CAPACITY) ++holo_count;
+    return slot;
+}
+
+API int lm_holo_recall(const unsigned char *text, int length)
+{
+    float query[HOLO_DIMENSION];
+    float best = -1.0f;
+    int best_slot = -1;
+    int slot;
+    if (holo_mode == LM_HOLO_DISABLED || text == NULL || length <= 0 ||
+        length > 8192 || holo_count == 0) {
+        holo_score = 0.0f;
+        return -1;
+    }
+    holo_encode(text, length, query);
+    if (holo_mode == LM_HOLO_PARTITIONED) {
+        int partition = holo_partition_for_vector(query);
+        int count = holo_partition_count[partition];
+        int index;
+        for (index = 0; index < count; ++index) {
+            float score = 0.0f;
+            int coordinate;
+            slot = partition * HOLO_PARTITION_CAPACITY + index;
+            for (coordinate = 0; coordinate < HOLO_DIMENSION; ++coordinate) {
+                score += query[coordinate] * holo_vectors[slot][coordinate];
+            }
+            if (score > best) {
+                best = score;
+                best_slot = slot;
+            }
+        }
+        holo_score = best_slot >= 0 ? best : 0.0f;
+        return best_slot;
+    }
+    for (slot = 0; slot < holo_count; ++slot) {
+        float score = 0.0f;
+        int index;
+        for (index = 0; index < HOLO_DIMENSION; ++index) {
+            score += query[index] * holo_vectors[slot][index];
+        }
+        if (score > best) {
+            best = score;
+            best_slot = slot;
+        }
+    }
+    holo_score = best;
+    return best_slot;
+}
+
+API float lm_holo_get_score(void) { return holo_score; }
+API int lm_holo_get_count(void) { return holo_count; }
+
+static void release_working_memory(void)
+{
+    free(key_cache);
+    free(value_cache);
+    free(x);
+    free(normalized);
+    free(query);
+    free(key);
+    free(value);
+    free(attention);
+    free(temporary);
+    free(feed_forward_pre);
+    free(feed_forward_act);
+    free(scores);
+    free(logits);
+    free(candidates);
+    key_cache = NULL;
+    value_cache = NULL;
+    x = normalized = query = key = value = attention = temporary = NULL;
+    feed_forward_pre = feed_forward_act = scores = logits = NULL;
+    candidates = NULL;
+    loaded = 0;
+}
+
+static void *allocate_zero(size_t count, size_t size)
+{
+    if (size != 0 && count > SIZE_MAX / size) return NULL;
+    return calloc(count, size);
+}
+
+static int allocate_working_memory(void)
+{
+    size_t cache_count =
+        (size_t)config.layers * config.context * config.dim;
+    key_cache = allocate_zero(cache_count, sizeof(float));
+    value_cache = allocate_zero(cache_count, sizeof(float));
+    x = allocate_zero(config.dim, sizeof(float));
+    normalized = allocate_zero(config.dim, sizeof(float));
+    query = allocate_zero(config.dim, sizeof(float));
+    key = allocate_zero(config.dim, sizeof(float));
+    value = allocate_zero(config.dim, sizeof(float));
+    attention = allocate_zero(config.dim, sizeof(float));
+    temporary = allocate_zero(config.dim, sizeof(float));
+    feed_forward_pre = allocate_zero(config.ff, sizeof(float));
+    feed_forward_act = allocate_zero(config.ff, sizeof(float));
+    scores = allocate_zero(config.context, sizeof(float));
+    logits = allocate_zero(config.vocab, sizeof(float));
+    candidates = allocate_zero(config.vocab, sizeof(*candidates));
+    return key_cache && value_cache && x && normalized && query && key &&
+           value && attention && temporary && feed_forward_pre &&
+           feed_forward_act && scores && logits && candidates;
+}
+
+static void rmsnorm(const float *input, const Tensor *gamma, float *output,
+                    int width)
+{
+    float square_sum = 0.0f;
+    float inverse;
+    int i;
+    for (i = 0; i < width; ++i) square_sum += input[i] * input[i];
+    inverse = 1.0f / sqrtf(square_sum / width + 1.0e-5f);
+    for (i = 0; i < width; ++i) {
+        output[i] = input[i] * inverse * gamma->values[i];
+    }
+}
+
+static void matrix_vector(const Tensor *matrix, const float *input,
+                          float *output)
+{
+    uint32_t row;
+    for (row = 0; row < matrix->rows; ++row) {
+        const int8_t *weights =
+            matrix->quantized + (size_t)row * matrix->columns;
+        float sum = 0.0f;
+        uint32_t column;
+        for (column = 0; column < matrix->columns; ++column) {
+            sum += weights[column] * input[column];
+        }
+        output[row] = sum * matrix->scales[row];
+    }
+}
+
+static void embedding_row(const Tensor *embedding, int token, float *output)
+{
+    const int8_t *weights =
+        embedding->quantized + (size_t)token * embedding->columns;
+    float scale = embedding->scales[token];
+    uint32_t i;
+    for (i = 0; i < embedding->columns; ++i) output[i] = weights[i] * scale;
+}
+
+static float gelu(float value)
+{
+    return 0.5f * value *
+           (1.0f + tanhf(0.7978845608028654f *
+                          (value + 0.044715f * value * value * value)));
+}
+
+static void apply_rope(float *vector, uint64_t token_position)
+{
+    int head_width = (int)config.dim / (int)config.heads;
+    int head;
+    for (head = 0; head < (int)config.heads; ++head) {
+        int offset = head * head_width;
+        int pair;
+        for (pair = 0; pair < head_width / 2; ++pair) {
+            float frequency = powf(10000.0f, -(2.0f * pair) / head_width);
+            float angle = (float)token_position * frequency;
+            float cosine = cosf(angle);
+            float sine = sinf(angle);
+            float a = vector[offset + 2 * pair];
+            float b = vector[offset + 2 * pair + 1];
+            vector[offset + 2 * pair] = a * cosine - b * sine;
+            vector[offset + 2 * pair + 1] = a * sine + b * cosine;
+        }
+    }
+}
+
+static void causal_attention(int layer)
+{
+    int head_width = (int)config.dim / (int)config.heads;
+    uint64_t first = position + 1 > config.context
+                         ? position + 1 - config.context
+                         : 0;
+    int current_slot = (int)(position % config.context);
+    size_t current_offset =
+        ((size_t)layer * config.context + current_slot) * config.dim;
+    int head;
+    memcpy(key_cache + current_offset, key, config.dim * sizeof(float));
+    memcpy(value_cache + current_offset, value, config.dim * sizeof(float));
+    memset(attention, 0, config.dim * sizeof(float));
+
+    for (head = 0; head < (int)config.heads; ++head) {
+        int head_offset = head * head_width;
+        float maximum = -INFINITY;
+        float total = 0.0f;
+        int count = 0;
+        uint64_t source;
+        for (source = first; source <= position; ++source) {
+            int slot = (int)(source % config.context);
+            const float *cached_key =
+                key_cache +
+                ((size_t)layer * config.context + slot) * config.dim +
+                head_offset;
+            float score = 0.0f;
+            int i;
+            for (i = 0; i < head_width; ++i) {
+                score += query[head_offset + i] * cached_key[i];
+            }
+            score /= sqrtf((float)head_width);
+            scores[count++] = score;
+            if (score > maximum) maximum = score;
+        }
+        for (int index = 0; index < count; ++index) {
+            scores[index] = expf(scores[index] - maximum);
+            total += scores[index];
+        }
+        count = 0;
+        for (source = first; source <= position; ++source) {
+            int slot = (int)(source % config.context);
+            const float *cached_value =
+                value_cache +
+                ((size_t)layer * config.context + slot) * config.dim +
+                head_offset;
+            float probability = scores[count++] / total;
+            int i;
+            for (i = 0; i < head_width; ++i) {
+                attention[head_offset + i] += probability * cached_value[i];
+            }
+        }
+    }
+}
+
+API int lm_load(const unsigned char *data, int length)
+{
+    static const char magic[8] = {'L', 'I', 'T', 'Q', '8', 'V', '1', '\0'};
+    const unsigned char *cursor = data;
+    const unsigned char *end = data + length;
+    uint32_t index;
+    release_working_memory();
+    if (length < (int)sizeof(config)) return -1;
+    memcpy(&config, cursor, sizeof(config));
+    cursor += sizeof(config);
+    if (memcmp(config.magic, magic, 8) != 0 || config.version != 1 ||
+        config.vocab < 2 || config.vocab > 2048 || config.context < 2 ||
+        config.context > 4096 || config.dim < 2 || config.layers < 1 ||
+        config.parameter_count > MAX_PARAMETERS ||
+        config.parameter_count != 2 + config.layers * 8) {
+        return -2;
+    }
+    memset(parameters, 0, sizeof(parameters));
+    for (index = 0; index < config.parameter_count; ++index) {
+        TensorHeader header;
+        Tensor *tensor = &parameters[index];
+        size_t amount;
+        if ((size_t)(end - cursor) < sizeof(header)) return -3;
+        memcpy(&header, cursor, sizeof(header));
+        cursor += sizeof(header);
+        if (header.count != (uint64_t)header.rows * header.columns ||
+            header.rows == 0 || header.columns == 0 || header.encoding > 1) {
+            return -4;
+        }
+        tensor->encoding = header.encoding;
+        tensor->rows = header.rows;
+        tensor->columns = header.columns;
+        tensor->count = header.count;
+        if (header.encoding == 0) {
+            amount = (size_t)header.count * sizeof(float);
+            if ((size_t)(end - cursor) < amount) return -5;
+            tensor->values = (const float *)cursor;
+            cursor += amount;
+        } else {
+            amount = (size_t)header.rows * sizeof(float);
+            if ((size_t)(end - cursor) < amount) return -6;
+            tensor->scales = (const float *)cursor;
+            cursor += amount;
+            amount = header.count;
+            if ((size_t)(end - cursor) < amount) return -7;
+            tensor->quantized = (const int8_t *)cursor;
+            cursor += amount;
+        }
+    }
+    if (!allocate_working_memory()) {
+        release_working_memory();
+        return -8;
+    }
+    loaded = 1;
+    position = 0;
+    recent_count = recent_next = 0;
+    lm_holo_reset();
+    return 0;
+}
+
+API void lm_reset(void)
+{
+    if (!loaded) return;
+    memset(key_cache, 0,
+           (size_t)config.layers * config.context * config.dim * sizeof(float));
+    memset(value_cache, 0,
+           (size_t)config.layers * config.context * config.dim * sizeof(float));
+    position = 0;
+    recent_count = recent_next = 0;
+}
+
+API void lm_seed(uint32_t seed)
+{
+    random_state = seed ? seed : 1;
+}
+
+API int lm_feed(int token)
+{
+    int layer;
+    if (!loaded || token < 0 || token >= (int)config.vocab) return -1;
+    embedding_row(&parameters[0], token, x);
+    for (layer = 0; layer < (int)config.layers; ++layer) {
+        int base = 1 + layer * 8;
+        int i;
+        rmsnorm(x, &parameters[base], normalized, (int)config.dim);
+        matrix_vector(&parameters[base + 1], normalized, query);
+        matrix_vector(&parameters[base + 2], normalized, key);
+        matrix_vector(&parameters[base + 3], normalized, value);
+        apply_rope(query, position);
+        apply_rope(key, position);
+        causal_attention(layer);
+        matrix_vector(&parameters[base + 4], attention, temporary);
+        for (i = 0; i < (int)config.dim; ++i) x[i] += temporary[i];
+
+        rmsnorm(x, &parameters[base + 5], normalized, (int)config.dim);
+        matrix_vector(&parameters[base + 6], normalized, feed_forward_pre);
+        for (i = 0; i < (int)config.ff; ++i) {
+            feed_forward_act[i] = gelu(feed_forward_pre[i]);
+        }
+        matrix_vector(&parameters[base + 7], feed_forward_act, temporary);
+        for (i = 0; i < (int)config.dim; ++i) x[i] += temporary[i];
+    }
+    rmsnorm(x, &parameters[1 + config.layers * 8], normalized,
+            (int)config.dim);
+    {
+        const Tensor *embedding = &parameters[0];
+        int output_token;
+        for (output_token = 0; output_token < (int)config.vocab;
+             ++output_token) {
+            const int8_t *weights =
+                embedding->quantized +
+                (size_t)output_token * embedding->columns;
+            float sum = 0.0f;
+            int i;
+            for (i = 0; i < (int)config.dim; ++i) {
+                sum += weights[i] * normalized[i];
+            }
+            logits[output_token] = sum * embedding->scales[output_token];
+        }
+    }
+    recent[recent_next] = (uint16_t)token;
+    recent_next = (recent_next + 1) % 64;
+    if (recent_count < 64) ++recent_count;
+    ++position;
+    return 0;
+}
+
+static int candidate_compare(const void *left, const void *right)
+{
+    const Candidate *a = (const Candidate *)left;
+    const Candidate *b = (const Candidate *)right;
+    if (a->score < b->score) return 1;
+    if (a->score > b->score) return -1;
+    return a->token - b->token;
+}
+
+static float random_unit(void)
+{
+    uint32_t value = random_state;
+    value ^= value << 13;
+    value ^= value >> 17;
+    value ^= value << 5;
+    random_state = value;
+    return (value >> 8) * (1.0f / 16777216.0f);
+}
+
+API int lm_sample(float temperature, int top_k, float repetition_penalty)
+{
+    int token;
+    int limit;
+    float maximum;
+    float total = 0.0f;
+    float threshold;
+    if (!loaded || repetition_penalty < 1.0f) return -1;
+    for (token = 0; token < (int)config.vocab; ++token) {
+        int repeated = 0;
+        int i;
+        float score = logits[token];
+        for (i = 0; i < recent_count; ++i) {
+            if (recent[i] == token) {
+                repeated = 1;
+                break;
+            }
+        }
+        if (repeated && token != CHANNEL_MESSAGE_END_TOKEN) {
+            score -= logf(repetition_penalty);
+        }
+        if (!(token == CHANNEL_MESSAGE_END_TOKEN || token == '\n' ||
+              (token >= 32 && token < 127))) {
+            score = -INFINITY;
+        }
+        candidates[token].token = token;
+        candidates[token].score = score;
+    }
+    qsort(candidates, config.vocab, sizeof(*candidates), candidate_compare);
+    if (temperature <= 0.0f) return candidates[0].token;
+    limit = top_k > 0 && top_k < (int)config.vocab ? top_k : (int)config.vocab;
+    maximum = candidates[0].score;
+    for (token = 0; token < limit; ++token) {
+        candidates[token].score =
+            expf((candidates[token].score - maximum) / temperature);
+        total += candidates[token].score;
+    }
+    threshold = random_unit() * total;
+    for (token = 0; token < limit; ++token) {
+        threshold -= candidates[token].score;
+        if (threshold <= 0.0f) return candidates[token].token;
+    }
+    return candidates[limit - 1].token;
+}
+
+API float lm_probability(int token)
+{
+    float maximum;
+    float total = 0.0f;
+    int index;
+    if (!loaded || position == 0 || token < 0 || token >= (int)config.vocab) {
+        return 0.0f;
+    }
+    maximum = logits[0];
+    for (index = 1; index < (int)config.vocab; ++index) {
+        if (logits[index] > maximum) maximum = logits[index];
+    }
+    for (index = 0; index < (int)config.vocab; ++index) {
+        total += expf(logits[index] - maximum);
+    }
+    return expf(logits[token] - maximum) / total;
+}
+
+API int lm_get_context(void) { return (int)config.context; }
+API int lm_get_position(void) { return (int)position; }
+API int lm_get_update(void) { return (int)config.step; }
+API int lm_get_parameters(void)
+{
+    int index;
+    uint64_t total = 0;
+    for (index = 0; index < (int)config.parameter_count; ++index) {
+        total += parameters[index].count;
+    }
+    return (int)total;
+}
+
+#if !defined(__EMSCRIPTEN__) && !defined(LITERARY_INFER_NO_MAIN)
+static void feed_text(const char *text)
+{
+    int i;
+    for (i = 0; text[i]; ++i) {
+        unsigned char token = (unsigned char)text[i];
+        lm_feed(token < config.vocab ? token : '?');
+    }
+}
+
+static const char *style_summary(char style)
+{
+    if (style == 'S') return "Shakespearean dramatic scene";
+    if (style == 'C') return "Crowleyan dramatic scene";
+    if (style == 'B') return "Blakean visionary verse";
+    if (style == 'K') {
+        return "brainfuck channel uses strict bounded 8-bit semantics";
+    }
+    return "mixed literary conversation";
+}
+
+static int holo_self_test(void)
+{
+    static const unsigned char moon[] =
+        "friends hear a silver gate answer beneath the moon";
+    static const unsigned char crown[] =
+        "the king wears a gold crown in the morning court";
+    static const unsigned char query[] = "what answered at the moonlit gate";
+    static const unsigned char unrelated[] = "winter rivers cross the forest";
+    int result;
+    float relevant_score;
+    float unrelated_score;
+    lm_holo_reset();
+    if (lm_holo_remember(moon, (int)sizeof(moon) - 1) != 0 ||
+        lm_holo_remember(crown, (int)sizeof(crown) - 1) != 1) {
+        return 0;
+    }
+    result = lm_holo_recall(query, (int)sizeof(query) - 1);
+    relevant_score = lm_holo_get_score();
+    lm_holo_recall(unrelated, (int)sizeof(unrelated) - 1);
+    unrelated_score = lm_holo_get_score();
+    lm_holo_recall(query, (int)sizeof(query) - 1);
+    return result == 0 && relevant_score > 0.22f &&
+           unrelated_score < 0.22f && lm_holo_get_count() == 2;
+}
+
+int main(int argc, char **argv)
+{
+    FILE *file;
+    long size;
+    unsigned char *data;
+    const char *prompt;
+    const char *old_memory = NULL;
+    const char *response = NULL;
+    const char *channel_summary = NULL;
+    int chat = 0;
+    int channel = 0;
+    int memory = 0;
+    char style = 'D';
+    int count;
+    int i;
+    if (argc == 2 && strcmp(argv[1], "--holo-self-test") == 0) {
+        if (!holo_self_test()) {
+            fprintf(stderr, "holographic memory self-test failed\n");
+            return EXIT_FAILURE;
+        }
+        printf("holographic memory self-test passed (cosine %.3f)\n",
+               lm_holo_get_score());
+        return EXIT_SUCCESS;
+    }
+    if (argc == 8 && strcmp(argv[2], "--memory") == 0) {
+        memory = 1;
+        if (strlen(argv[3]) != 1) {
+            fprintf(stderr, "error: memory style must be one character\n");
+            return EXIT_FAILURE;
+        }
+        style = argv[3][0];
+        old_memory = argv[4];
+        prompt = argv[5];
+        response = argv[6];
+        count = atoi(argv[7]);
+    } else if (argc == 7 && strcmp(argv[2], "--channel") == 0) {
+        chat = 1;
+        channel = 1;
+        if (strlen(argv[3]) != 1) {
+            fprintf(stderr, "error: channel style must be one character\n");
+            return EXIT_FAILURE;
+        }
+        style = argv[3][0];
+        channel_summary = argv[4];
+        prompt = argv[5];
+        count = atoi(argv[6]);
+    } else if (argc == 6 && strcmp(argv[2], "--chat") == 0) {
+        chat = 1;
+        if (strlen(argv[3]) != 1) {
+            fprintf(stderr, "error: chat style must be one character\n");
+            return EXIT_FAILURE;
+        }
+        style = argv[3][0];
+        prompt = argv[4];
+        count = atoi(argv[5]);
+    } else if (argc == 4) {
+        prompt = argv[2];
+        count = atoi(argv[3]);
+    } else {
+        fprintf(stderr,
+                "usage: %s --holo-self-test\n"
+                "       %s MODEL PROMPT TOKENS\n"
+                "       %s MODEL --chat STYLE PROMPT TOKENS\n"
+                "       %s MODEL --channel STYLE SUMMARY PROMPT TOKENS\n"
+                "       %s MODEL --memory STYLE OLD USER REPLY TOKENS\n",
+                argv[0], argv[0], argv[0], argv[0], argv[0]);
+        return EXIT_FAILURE;
+    }
+    file = fopen(argv[1], "rb");
+    if (!file || fseek(file, 0, SEEK_END) != 0 || (size = ftell(file)) < 0 ||
+        fseek(file, 0, SEEK_SET) != 0) {
+        fprintf(stderr, "error: cannot open model\n");
+        return EXIT_FAILURE;
+    }
+    data = malloc((size_t)size);
+    if (!data || fread(data, 1, (size_t)size, file) != (size_t)size) {
+        fprintf(stderr, "error: cannot read model\n");
+        return EXIT_FAILURE;
+    }
+    fclose(file);
+    if (lm_load(data, (int)size) != 0) {
+        fprintf(stderr, "error: invalid model\n");
+        return EXIT_FAILURE;
+    }
+    if (memory) {
+        lm_feed(CHANNEL_START_TOKEN);
+        lm_feed(style);
+        lm_feed(CHANNEL_SUMMARY_TOKEN);
+        feed_text(old_memory);
+        lm_feed(CHANNEL_MESSAGE_END_TOKEN);
+        lm_feed(CHANNEL_MESSAGE_TOKEN);
+        lm_feed('A');
+        feed_text(prompt);
+        lm_feed(CHANNEL_MESSAGE_END_TOKEN);
+        lm_feed(CHANNEL_MESSAGE_TOKEN);
+        lm_feed('Z');
+        lm_feed(CHANNEL_REPLY_TOKEN);
+        lm_feed('A');
+        feed_text(response);
+        lm_feed(CHANNEL_MESSAGE_END_TOKEN);
+        lm_feed(CHANNEL_SUMMARY_TOKEN);
+        lm_feed(CHANNEL_TARGET_TOKEN);
+        printf("old memory: %s\nnew memory: ", old_memory);
+    } else if (chat) {
+        int speaker = style == 'K' ? 'U' : 'A';
+        lm_feed(CHANNEL_START_TOKEN);
+        lm_feed(style);
+        lm_feed(CHANNEL_SUMMARY_TOKEN);
+        feed_text(channel ? channel_summary : style_summary(style));
+        lm_feed(CHANNEL_MESSAGE_END_TOKEN);
+        lm_feed(CHANNEL_MESSAGE_TOKEN);
+        lm_feed(speaker);
+        feed_text(prompt);
+        lm_feed(CHANNEL_MESSAGE_END_TOKEN);
+        lm_feed(CHANNEL_MESSAGE_TOKEN);
+        lm_feed('Z');
+        lm_feed(CHANNEL_REPLY_TOKEN);
+        lm_feed(speaker);
+        lm_feed(CHANNEL_TARGET_TOKEN);
+        printf("%c: %s\nZ: ", speaker, prompt);
+    } else {
+        for (i = 0; prompt[i]; ++i) {
+            unsigned char token = (unsigned char)prompt[i];
+            lm_feed(token < config.vocab ? token : '?');
+            putchar(prompt[i]);
+        }
+    }
+    for (i = 0; i < count; ++i) {
+        int token = memory ? lm_sample(0.42f, 20, 1.04f)
+                    : chat && style == 'K' ? lm_sample(0.0f, 1, 1.0f)
+                                          : lm_sample(0.52f, 20, 1.12f);
+        lm_feed(token);
+        if ((chat || memory) && token == CHANNEL_MESSAGE_END_TOKEN) break;
+        putchar(token);
+    }
+    putchar('\n');
+    free(data);
+    release_working_memory();
+    return EXIT_SUCCESS;
+}
+#endif

literary_infer.h

@@ -0,0 +1,31 @@
+#ifndef LITERARY_INFER_H
+#define LITERARY_INFER_H
+
+#include <stdint.h>
+
+enum {
+    LM_HOLO_DISABLED = 0,
+    LM_HOLO_FLAT = 1,
+    LM_HOLO_PARTITIONED = 2
+};
+
+int lm_load(const unsigned char *data, int length);
+void lm_reset(void);
+void lm_seed(uint32_t seed);
+int lm_feed(int token);
+int lm_sample(float temperature, int top_k, float repetition_penalty);
+float lm_probability(int token);
+int lm_get_context(void);
+int lm_get_position(void);
+int lm_get_update(void);
+int lm_get_parameters(void);
+
+void lm_holo_reset(void);
+int lm_holo_set_mode(int mode);
+int lm_holo_get_mode(void);
+int lm_holo_remember(const unsigned char *text, int length);
+int lm_holo_recall(const unsigned char *text, int length);
+float lm_holo_get_score(void);
+int lm_holo_get_count(void);
+
+#endif

model.json

@@ -0,0 +1,49 @@
+{
+  "schema": "zero.deployed_model.v1",
+  "id": "zero4",
+  "display_name": "ZERO.4",
+  "status": "promoted",
+  "promoted_at": "2026-07-24",
+  "architecture": {
+    "parameters": 4852992,
+    "context": 512,
+    "runtime_update": 500,
+    "quantization": "signed 8-bit matrix rows with floating-point row scales"
+  },
+  "artifact": {
+    "path": "docs/model.litq8",
+    "sha256": "44b32f2262be2754fd2eeaf16ed206bae32b4ce30d7f5541a1059cd21257ae50",
+    "bytes": 4920400,
+    "source_path": "benchmarks/zero4-q26-v1/seed2/selected.litq8",
+    "source_sha256": "44b32f2262be2754fd2eeaf16ed206bae32b4ce30d7f5541a1059cd21257ae50",
+    "source_seed": 2,
+    "selected_update": 500
+  },
+  "promotion": {
+    "family_decision": "go",
+    "promotion_eligible": true,
+    "candidate_selection": "prospectively selected Q2.6 diagnostic seed 2",
+    "aggregate_path": "benchmarks/zero4-q26r-v1/aggregate.json",
+    "aggregate_sha256": "246274e15bcdcea7e337a01bdf415b72251f010fb411b8a1c0ac879d0ddc5d71",
+    "completion_path": "benchmarks/zero4-q26r-v1/aws-v2/COMPLETED",
+    "completion_sha256": "523e305d099aba1735f1cb72b2278ede72a873c840b798c37b9b51a2d8339509",
+    "source_result_path": "benchmarks/zero4-q26-v1/seed2/result.json",
+    "source_result_sha256": "6fba7b46a00c881ab129ea706125fee0924d897836784274275ae9517805eb5f",
+    "merged_results_commit": "bde7875bdc3947bb4203fe3b8eccc8fb6488bda6"
+  },
+  "scope": {
+    "validated_capability": "quantity operation routing with controller-bound arguments and deterministic kernel arithmetic",
+    "historical_replay_preserved": true,
+    "controller_owned_arithmetic": true,
+    "neural_arithmetic_claimed": false,
+    "browser_exposes": "the promoted generative core; the faculty controller and deterministic quantity kernel are not integrated into this page"
+  },
+  "release": {
+    "model_license": "CC-BY-SA-4.0",
+    "code_license": "Apache-2.0",
+    "corpus_rights": "CORPUS_RIGHTS.md",
+    "training_text_distributed_with_model": false,
+    "upload_manifest": "huggingface/release-manifest.json",
+    "memorization_evaluation": "release/zero4-memorization-v1.json"
+  }
+}

model.litq8

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:44b32f2262be2754fd2eeaf16ed206bae32b4ce30d7f5541a1059cd21257ae50
+size 4920400

zero4-memorization-v1.json

@@ -0,0 +1,410 @@
+{
+  "schema": "zero.memorization_release.v1",
+  "evaluated_at": "2026-08-12",
+  "decision": "pass",
+  "model": {
+    "id": "zero4",
+    "path": "docs/model.litq8",
+    "sha256": "44b32f2262be2754fd2eeaf16ed206bae32b4ce30d7f5541a1059cd21257ae50",
+    "bytes": 4920400
+  },
+  "source_artifacts": {
+    "zero-foundation": {
+      "path": "corpus/bpe/zero-foundation.tok",
+      "sha256": "87b039e5d4645ebf2a521454a13b1a912cbd1c53ff8fbcfb26baf9da1f5e638b",
+      "blocking": false
+    },
+    "shakespeare": {
+      "path": "corpus/bpe/shakespeare.tok",
+      "sha256": "ffa36c4890ca07d403e8d76fab47026e1b6d46b1fb2b9d2dc1c31c206ff9351d",
+      "blocking": true
+    },
+    "blake": {
+      "path": "corpus/bpe/blake.tok",
+      "sha256": "329bf291a5842897b59151640a57d2a2270a451e31c99adbf7d3d6f684d2576c",
+      "blocking": true
+    },
+    "crowley": {
+      "path": "corpus/bpe/crowley.tok",
+      "sha256": "68decb62cbd4f1efaff34067eb5a533406d99a6bc0e60ca219846b39306177da",
+      "blocking": true
+    },
+    "bible-kjv": {
+      "path": "corpus/bpe/bible-kjv.tok",
+      "sha256": "0c387e697fbe339712a62efb75d27c788365ce90911895dbf66e732deee44ed9",
+      "blocking": true
+    },
+    "literary-channel": {
+      "path": "corpus/channel/literary-dialogue.tok",
+      "sha256": "d401868f33f2ac318315b167dd2bc6850edb3a8b0aaf5b18c1b2fa8cba42c379",
+      "blocking": true
+    },
+    "quantity-requests": {
+      "path": "corpus/faculty/q22/quantity-request.tok",
+      "sha256": "e04e518a6bd6ddd1698a65b18dfd4589cf0cee4f4737beaa6f72a3c3b4dce8f2",
+      "blocking": false
+    }
+  },
+  "evaluation": {
+    "schema": "zero.memorization_raw.v1",
+    "decision": "pass",
+    "model": {
+      "parameters": 4852992,
+      "context": 512,
+      "update": 500,
+      "vocab": 128
+    },
+    "settings": {
+      "samples_per_source": 16,
+      "prompt_tokens": 128,
+      "continuation_tokens": 64,
+      "warning_exact_prefix": 32,
+      "block_exact_prefix": 64,
+      "sampling": "evenly-stratified deterministic offsets"
+    },
+    "sources": [
+      {
+        "id": "zero-foundation",
+        "path": "corpus/bpe/zero-foundation.tok",
+        "blocking": false,
+        "tokens": 1406,
+        "max_exact_prefix": 64,
+        "full_exact_continuations": 8,
+        "warning_samples": 9,
+        "generated_aligned_accuracy": 0.594726562,
+        "teacher_forced_top1_accuracy": 0.79296875,
+        "teacher_forced_nll": 0.819816028,
+        "sample_offsets": [
+          71,
+          142,
+          214,
+          285,
+          357,
+          428,
+          500,
+          571,
+          643,
+          714,
+          786,
+          857,
+          929,
+          1000,
+          1072,
+          1143
+        ],
+        "exact_prefixes": [
+          64,
+          64,
+          64,
+          64,
+          64,
+          64,
+          58,
+          64,
+          64,
+          6,
+          0,
+          2,
+          0,
+          0,
+          0,
+          1
+        ]
+      },
+      {
+        "id": "shakespeare",
+        "path": "corpus/bpe/shakespeare.tok",
+        "blocking": true,
+        "tokens": 5352386,
+        "max_exact_prefix": 2,
+        "full_exact_continuations": 0,
+        "warning_samples": 0,
+        "generated_aligned_accuracy": 0.084960938,
+        "teacher_forced_top1_accuracy": 0.537109375,
+        "teacher_forced_nll": 1.487880106,
+        "sample_offsets": [
+          314835,
+          629670,
+          944505,
+          1259340,
+          1574175,
+          1889010,
+          2203845,
+          2518680,
+          2833515,
+          3148350,
+          3463185,
+          3778020,
+          4092855,
+          4407690,
+          4722525,
+          5037360
+        ],
+        "exact_prefixes": [
+          0,
+          1,
+          2,
+          2,
+          1,
+          1,
+          1,
+          0,
+          1,
+          2,
+          0,
+          2,
+          1,
+          0,
+          1,
+          2
+        ]
+      },
+      {
+        "id": "blake",
+        "path": "corpus/bpe/blake.tok",
+        "blocking": true,
+        "tokens": 65811,
+        "max_exact_prefix": 16,
+        "full_exact_continuations": 0,
+        "warning_samples": 0,
+        "generated_aligned_accuracy": 0.196289062,
+        "teacher_forced_top1_accuracy": 0.876953125,
+        "teacher_forced_nll": 0.452524625,
+        "sample_offsets": [
+          3860,
+          7720,
+          11580,
+          15440,
+          19300,
+          23160,
+          27020,
+          30880,
+          34740,
+          38600,
+          42460,
+          46320,
+          50180,
+          54040,
+          57900,
+          61760
+        ],
+        "exact_prefixes": [
+          11,
+          5,
+          2,
+          3,
+          1,
+          11,
+          8,
+          11,
+          2,
+          16,
+          14,
+          3,
+          9,
+          0,
+          8,
+          5
+        ]
+      },
+      {
+        "id": "crowley",
+        "path": "corpus/bpe/crowley.tok",
+        "blocking": true,
+        "tokens": 250769,
+        "max_exact_prefix": 4,
+        "full_exact_continuations": 0,
+        "warning_samples": 0,
+        "generated_aligned_accuracy": 0.122070312,
+        "teacher_forced_top1_accuracy": 0.62109375,
+        "teacher_forced_nll": 1.283773088,
+        "sample_offsets": [
+          14739,
+          29479,
+          44219,
+          58959,
+          73699,
+          88439,
+          103179,
+          117919,
+          132658,
+          147398,
+          162138,
+          176878,
+          191618,
+          206358,
+          221098,
+          235838
+        ],
+        "exact_prefixes": [
+          1,
+          4,
+          0,
+          1,
+          2,
+          1,
+          2,
+          0,
+          1,
+          4,
+          2,
+          1,
+          1,
+          2,
+          2,
+          1
+        ]
+      },
+      {
+        "id": "bible-kjv",
+        "path": "corpus/bpe/bible-kjv.tok",
+        "blocking": true,
+        "tokens": 4170130,
+        "max_exact_prefix": 6,
+        "full_exact_continuations": 0,
+        "warning_samples": 0,
+        "generated_aligned_accuracy": 0.083984375,
+        "teacher_forced_top1_accuracy": 0.563476562,
+        "teacher_forced_nll": 1.526786912,
+        "sample_offsets": [
+          245290,
+          490581,
+          735871,
+          981162,
+          1226452,
+          1471743,
+          1717033,
+          1962324,
+          2207614,
+          2452905,
+          2698195,
+          2943486,
+          3188776,
+          3434067,
+          3679357,
+          3924648
+        ],
+        "exact_prefixes": [
+          6,
+          2,
+          0,
+          1,
+          0,
+          3,
+          0,
+          4,
+          0,
+          0,
+          1,
+          1,
+          0,
+          1,
+          1,
+          0
+        ]
+      },
+      {
+        "id": "literary-channel",
+        "path": "corpus/channel/literary-dialogue.tok",
+        "blocking": true,
+        "tokens": 28622690,
+        "max_exact_prefix": 9,
+        "full_exact_continuations": 0,
+        "warning_samples": 0,
+        "generated_aligned_accuracy": 0.098632812,
+        "teacher_forced_top1_accuracy": 0.564453125,
+        "teacher_forced_nll": 1.840536262,
+        "sample_offsets": [
+          1683676,
+          3367352,
+          5051029,
+          6734705,
+          8418382,
+          10102058,
+          11785734,
+          13469411,
+          15153087,
+          16836764,
+          18520440,
+          20204116,
+          21887793,
+          23571469,
+          25255146,
+          26938822
+        ],
+        "exact_prefixes": [
+          9,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          1,
+          1,
+          1,
+          8,
+          3,
+          3,
+          2,
+          0,
+          0
+        ]
+      },
+      {
+        "id": "quantity-requests",
+        "path": "corpus/faculty/q22/quantity-request.tok",
+        "blocking": false,
+        "tokens": 1107548,
+        "max_exact_prefix": 22,
+        "full_exact_continuations": 0,
+        "warning_samples": 0,
+        "generated_aligned_accuracy": 0.111328125,
+        "teacher_forced_top1_accuracy": 0.538085938,
+        "teacher_forced_nll": 2.496898627,
+        "sample_offsets": [
+          65138,
+          130277,
+          195415,
+          260554,
+          325693,
+          390831,
+          455970,
+          521109,
+          586247,
+          651386,
+          716525,
+          781663,
+          846802,
+          911941,
+          977079,
+          1042218
+        ],
+        "exact_prefixes": [
+          0,
+          0,
+          0,
+          0,
+          0,
+          22,
+          1,
+          2,
+          2,
+          0,
+          0,
+          14,
+          6,
+          1,
+          0,
+          0
+        ]
+      }
+    ]
+  },
+  "interpretation": {
+    "blocking_rule": "block if any protected third-party stream has a greedy prompted continuation with an exact prefix of 64 tokens or more",
+    "warning_rule": "report any greedy exact prefix of 32 tokens or more",
+    "informational_policy": "First-party CC0 foundation and synthetic quantity streams are measured and disclosed but do not block a rights release.",
+    "caveat": "A passing finite prompted-continuation test does not prove that the model cannot reproduce source expression under another prompt or decoding policy."
+  }
+}