Final v17a compact - 1,528,592 weight bytes; experiment finished

Final archive: v17a compact — experiment finished

Analytically constructed weights — no training. Useful, open-ended chat
was not achieved under the experiment's constraints. The research is finished;
this release publishes a compact representation of the same final checkpoint.

The packed weights occupy exactly 1,528,592 bytes, storing 995,905 nonzero
coefficients. The loader reconstructs individual tensors when needed and
retains 12,952,916 bytes of weight tensors after inference. Temporary tensors,
activations and runtime overhead require additional RAM/VRAM. The architecture
and compute dimensions remain unchanged.

Every float32 bit reconstructs exactly, including six negative-zero entries.
There is no quantization, coefficient update, training, new grammar or added
capability. The original dense model and earlier failed candidates remain in
the historical releases.

The attached direct-weight-chat-v17a-compact.zip contains the compact model,
matching PyTorch runtime, frozen compiler source and local chat UI. Extract it
to a new directory and run with PyTorch already installed:

python -m chat1gb_autoregressive.compact_chat --model-dir compact --device auto

/reset clears context; /quit exits. The model supports narrow fact/correction
grammar, bounded signed addition/subtraction and short ground-rule chains. It
does not support useful general chat, creative writing, code generation,
general mathematics or searching alternative proofs. The alternative-proof
baseline remains 29/104, with all failures preserved.

Verification preserves all text, token IDs and EOS decisions in 6,371 CUDA
cases and 788 CPU cases, including the existing failures. Independent archive
reconstruction matches the frozen original weight hash exactly.

The compact verification guide
links exact size, round-trip hash, CPU/CUDA response parity and memory evidence.
Every historical version's results
and the construction claim audit
remain public.

The same compact weights and matching source are available on
Hugging Face.
This is a custom offline PyTorch runtime, not a Transformers AutoModel or GGUF
checkpoint. Checksums are attached as SHA256SUMS.txt.

v0.9 experiment: stable rule phases across long contexts

v0.9 experiment: stable rule phases across long contexts

v17a repairs measured CPU failures in conditional-rule retrieval. Small errors
in a nominally Boolean phase flag previously outweighed literal recency in
sharp attention. A shared two-ReLU saturation primitive gives the rule-phase
flags flat zero/one regions before ranking. It adds two ReLU units and 24
nonzero parameters; the ordinary transformer runtime and layout are unchanged.

The checkpoint has exactly 250,000,000 float32 parameters / 1,000,000,000
bytes, including 995,905 nonzero parameters (0.398362%). All parameters
belong to named model tensors. Construction uses no training, optimization,
pretrained weights, downloaded data or internet. Inference uses tensor
operations without a host rule engine, completed-response bank or weight update.
GitHub is used only to publish source and evidence.

Check	v16c	v17a
Rule positions, CPU	154/162	160/162
Rule positions, CUDA	160/162	160/162
Long conversation, CPU	28/31	31/31
Long conversation, CUDA	31/31	31/31
Phase perturbations, each device	164/220	220/220
Ground conditionals, each device	269/293	269/293
Scope/dialogue guards, each device	29/36	29/36

All 36 matched CUDA suites have identical outputs to v16c: 5,959/6,105,
zero regressions. Four matched CPU suites gain nine passes with zero regressions.
Historical suites repeat structures; their totals are not counts of independent
reasoning problems. Exact prompts, outputs, expected answers, timings and
hashes remain in the version table,
CPU comparison
and CUDA comparison.

Tests and frozen baselines preceded the change. A targeted CPU intervention
restoring only the old context gate changes a repaired answer from Yes. back
to I do not know.. The saved checkpoint is unchanged. Both devices pass 27
existing integrity check groups and eight conditional interventions. Rebuilding
from the archived compiler reproduces exact raw/config hashes.

After freeze commit 83a2f03afa98075286e7ec82b3e5c53f29cd4ceb, fresh seed
2165866013 scores 160/162 on CPU and CUDA. The two failures require
a fourth rule link or an older alternative proof. These are new combinations
and offsets under a known generator, with repeated fixed structures. They do
not establish independent language generalization. No frozen parameters were
retuned after observing these results.

Useful general conversation remains unachieved. The model still follows
one latest matching rule at each step. It cannot search earlier alternatives,
bind variables, evaluate compound premises or generate open answers from rules.
Creative writing, code generation, broader mathematics and unrestricted English
remain unsupported. Some paraphrases still produce false assertions. Passing
these numerical tests does not prove reliability on every possible prompt.

The next capability baseline scores 29/104 on CPU and CUDA across
alternative rules, mixed branches, ordering and corrections. These tests were
authored after v17a froze, before any proof-search implementation. They are
development evidence for the next experiment; all 75 failures remain recorded.

Download autoregressive-v17a.zip, verify SHA256SUMS.txt, and extract into
the repository root. The compressed size reflects sparse/repetitive weights;
the raw parameter file is exactly 1 GB. With PyTorch already installed:

python -m chat1gb_autoregressive.chat --device auto

NumPy is also required to rebuild from source. No dependencies or model data
are downloaded by construction or inference. All previous releases, failed
candidates and their original evidence remain available.

Raw weight SHA-256:
5cc52f3793a1546c620195c110a7d1c3a2f8d3417cb72f193003589b16e8e0d2.

Fresh-download validation verifies the public archive/checksum digests,
decompressed raw/config hashes, ZIP CRC and frozen source against a clean
tagged checkout. CPU and CUDA each pass the 31/31 conversation replay,
matching every local output, plus 27 integrity check groups, eight conditional
interventions and 220 phase-perturbation checks. Restoring the old context gate
again recreates the CPU failure. All saved weights remain unchanged.
Publication evidence
records the downloaded-byte checks and measured outputs. Broader capability
failures remain in their separate reports; the research objective stays active.

v0.8 experiment: ground conditional reasoning inside the weights

v0.8 experiment: ground conditional reasoning inside the weights

v16c adds signed ground implications to the analytically compiled decoder.
Rules supplied during a conversation can connect unfamiliar subjects through
up to three links. Neural attention retrieves a rule by its conclusion, checks
the premise against current signed facts, and propagates proof through the
existing truth/query circuit. Missing or false premises remain unknown.

The checkpoint remains exactly 250,000,000 float32 parameters / 1,000,000,000
bytes, with no padding. It uses 995,881 nonzero parameters (0.3983524%).
Construction uses no training, optimization, pretrained weights, downloaded
data or internet. Inference uses the unchanged generic transformer runtime;
there is no host rule engine, answer fallback, completed-response bank or
weight update. GitHub is used to publish the experiment and evidence.

CUDA development check	v15a	v16a	v16b	v16c
Ground conditionals	152/293	269/293	269/293	269/293
Additional scope/dialogue guards	19/36	27/36	29/36	29/36
Original narrow cases	185/185	182/185	185/185	185/185
Coordinated assertions and stress	382/390	368/390	383/390	383/390
Object-specific truth	236/239	229/239	235/239	236/239

All 33 matched CUDA suites retain every v15a pass: 5,499/5,619 cases,
130 improvements and zero regressions. Historical suites repeat some cases
and structures. The new conditional suite was committed before compiler
changes; the guard suite is explicitly author-designed development evidence.
CPU matches the conditional 269/293 and guard 29/36 scores. Exact prompts,
outputs, expected answers, timings and hashes are in the
version table
and comparison.

The failed v16a/v16b sources, weights and measurements are retained. v16a
allowed proof state to interfere with ordinary open answers. v16b repaired
that isolation but could treat an atomic fact bit as a rule coordinate,
creating a false rule at an entity token. v16c adds a type penalty derived
from the maximum possible coordinate spillover. Read-only activation traces
and a penalty-removal intervention preserve evidence of the cause and fix.

Eight conditional interventions pass on CPU and CUDA, covering rule links, premise
evidence, record validity, object identity, polarity and the typed-record
guard. The initial object-matching intervention was ineffective because it
also removed the positive match score; its failed report remains public.
The corrected diagnostic retains that reward while removing identity
dependence. All interventions use temporary tensor copies and restore them;
the saved model is unchanged. Archived source rebuilds reproduce the exact
raw/config hashes. Both devices pass the existing integrity/intervention suite.
A 31-turn conversation after long declarative distractors scores 31/31 CUDA
and 28/31 CPU. CPU misses three later conditional conclusions while retaining
all 23 earlier turns. This device/long-context difference is unresolved and is
the next numerical investigation. It is not hidden by the matching short-suite
scores or presented as a passed conversation test.

After source freeze commit 9c84c6ad4c4202764358ab0c48d4d2a4d7cc25e7,
seed 1711846539 scores 269/293 on CPU and CUDA, including 98/98
positive/signed applications and all tested chains through three links.
These are fresh combinations from the known generator; fixed structures and
boundaries repeat. They are not independent general-language evidence. No
frozen source or parameters were retuned after this evaluation.

Useful open-ended conversation remains unachieved. This is a bounded
single-path proof circuit. It fails chains longer than three rules and misses
older successful alternatives when a newer rule has no proof. Variables,
compound rule premises and open answers from rules are unsupported. Some
paraphrases, including implies and whenever, can be mistaken for assertions.
Creative writing, code generation, unrestricted English and broader arithmetic
remain failures. The experimental goal stays active.

Download autoregressive-v16c.zip, verify SHA256SUMS.txt, and extract it into
the repository root. The smaller archive reflects sparse/repetitive weights;
the decompressed parameter file is exactly 1 GB. NumPy/PyTorch must already be
installed; the project downloads no dependencies or model data.

python -m chat1gb_autoregressive.chat --device auto

The v16a/v16b archives extract to their historical version directories.
Every earlier release remains available. v16c raw SHA-256:
385dff256910dec6eba802d3930452c2963e85223bbaa54251d2931b9b86b1dc.

Fresh-download validation verifies all three published archive sizes/digests,
the checksum file, decompressed raw/config hashes, ZIP CRC and frozen compiler
source against a clean tagged clone. CPU and CUDA each pass integrity and all
eight conditional interventions from that checkout. Its conversation replay
reproduces 31/31 CUDA and 28/31 CPU, with the same three CPU failures.
Publication evidence
records those failures explicitly. No source or saved weights were retuned.

v0.7 experiment: preserve subjects across long contexts

v0.7 experiment: preserve subjects across long contexts

The v15a checkpoint fixes demonstrated CPU subject-binding failures through a
shared neural retrieval primitive. It still has exactly 250,000,000 float32
parameters and 1,000,000,000 raw weight bytes, with no padding, training,
pretrained parameters or downloaded data. Construction and inference remain
offline; the ordinary transformer runtime is unchanged.

An activation trace found that two copies of one clause coordinate differed by
about 0.0000038. The previous attention coefficient amplified this into a
64-point bias, overpowering the newer subject's 40-point recency advantage.
The second object could then be stored under the first subject, causing both
missed facts and false positive answers about the wrong subject.

v15a retrieves the latest valid event using a modest recency score, then checks
clause membership through the following neural gates. The same primitive handles
lexical predicates and subject frames; it adds no prompt-specific answer rule.

Check	v14b	v15a
Subject binding, CPU	133/136	136/136
Subject binding, CUDA	136/136	136/136
Previously published context set, CPU	125/126	126/126
Previously published context set, CUDA	126/126	126/126
Previous long 20-turn conversation, CPU	19/20	20/20
Previous long 20-turn conversation, CUDA	20/20	20/20

All 29 existing CUDA suites were rerun, with no regressions against v14b. Two
matched CPU suites and the separately compared long conversation retain their
old passes. The original source tests, exact outputs, timings, traces, regressions
and model hashes are in the version history.
The old post-freeze cases are explicitly regression evidence for this version.

After freeze commit a583d2b49325d3ec66c937c32f06c43fa0b19ac4, binding seed
192095465 scores 136/136 on both CPU and CUDA. It varies unfamiliar names,
combinations and eight random offsets from a known generator; fixed offsets and
structures repeat. This is not independently designed generalization evidence.
No frozen model source or weights were retuned after these results.

CPU and CUDA integrity checks pass, including causal/cache parity, offline
guard, exact layout/size, finite weights and all neural interventions. The local
address audit retains zero errors out of 45,432 on each device. Rebuilding from
the frozen v15a source reproduces the exact raw and config hashes.
A local 23-turn CUDA publication smoke passes after 3,000 tokens of declarative
distractors, including new three-subject binding, isolation and correction checks.

Fresh-download verification confirms the published archive size/digest, checksum
entry, raw/config hashes, ZIP CRC and frozen-source manifest. From the clean
tagged checkout, CPU and CUDA each pass all integrity/intervention checks and
23/23 long-conversation turns. The saved checkpoint remains unchanged. Exact
outputs and timings are in the publication evidence.

The initial two-subject recency intervention left its answer unchanged. That
ineffective probe and the stopped integrity attempt remain documented. Additional
three-subject controls expose missed facts and false cross-subject assertions
when recency is removed. No model source or saved weights changed in response
to that diagnostic outcome.

Useful open-ended conversation remains unachieved. This release repairs
numerical binding within the existing controlled grammar. Conditional rules,
disjunctive assertions, mixed query precedence, multiple class parents, repeated
negation, open multi-value answers, creative writing and code generation remain
unsupported. v15a uses 961,697 nonzero parameters (0.3846788%); most connections
remain zero. Restricted tests do not establish broad language understanding.

Extract autoregressive-v15a.zip into the repository root and run:

python -m chat1gb_autoregressive.chat --device auto

Verify the ZIP hash against SHA256SUMS.txt and raw/config hashes against the
included manifest. The small archive reflects sparse and repetitive weights;
the extracted checkpoint is exactly 1 GB. NumPy and PyTorch must already be
installed. Every previous release, including failed candidates, remains public.

v0.6 experiment: stable local attention and fact magnitudes

v0.6 experiment: stable local attention and fact magnitudes

Two analytically compiled checkpoints are preserved: failed v14a and current
v14b. Each contains exactly 250,000,000 float32 parameters and 1,000,000,000 raw
weight bytes. Construction and inference remain offline, with no training,
pretrained tensors, downloaded knowledge, response bank or host answer logic.
The generic transformer runtime is unchanged.

Two bounded sinusoidal phases replace quadratic local attention addresses.
The new representation avoids large common score terms that lost precision at
long positions. v14b also saturates fact coordinates before proposition lookup,
preventing small magnitude differences from overriding a later correction.

Development check	v13d baseline	Failed v14a	v14b
Context positions and generation, CUDA	61/126	126/126	126/126
Assertion boundary audit, CUDA	65/76	76/76	76/76
Coordinated assertions, CUDA	382/390	366/390	382/390
Incorrect local addresses /45,432, CUDA	15,900	0	0
Incorrect local addresses /45,432, CPU	7,491	0	0

The address audit checks nine heads at all 5,048 context positions. Context
tests move existing generation, arithmetic, facts, correction, negation, binding
and inheritance through the window, with six requests near capacity. These
checks add numerical evidence; they do not add general language understanding.

All 26 existing matched suites were rerun. v14b has no regressions against
v13d. It retains legacy 185/185, graph 75/79, arithmetic 115/120, polarity 230/233,
signed operands 153/159, truth 236/239, query scope 265/269, composition 398/404
and request modifiers 78/81. Failed v14a loses sixteen assertion corrections
in each of three reports. Its checkpoint, exact failures and diagnostic trace
are retained in the version history.

After freezing v14b at b3b6e1bd76a7e007262d6cf16c27dd3ed4cc1c04, fresh
context seed 2063643282 scores 126/126 on CUDA and 125/126 on CPU. CPU case
context-086, with a 4,720-token prefix, loses an unfamiliar subject's second
coordinated object and answers I do not know. instead of Yes.. This remains
a failed test. No frozen weights were retuned. These are fresh combinations
from known structures and generators, not independent generalization evidence.

Integrity, finite/layout/hash, causal-prefix, cache and offline-guard checks
pass on the local CUDA run. Phase-removal interventions change the associated
response. A controlled fact-magnitude perturbation preserves a correction with
saturation; removing saturation makes the earlier assertion win. All earlier
graph/arithmetic/truth/composition/assertion interventions also pass. Frozen
v14b source reproduces exact raw and config hashes. A separate local 20-turn
publication smoke passes after 3,000 initial tokens of declarative distractors.

Fresh-download verification confirms both published archive digests, sizes,
raw/config hashes, ZIP CRC and frozen-source manifests. All integrity checks
and interventions pass on CPU and CUDA from the clean tagged checkout. The long
20-turn conversation scores 20/20 on CUDA and 19/20 on CPU. At turn 2, with
a 3,036-token prefix, CPU loses a changed subject's second object and says
I do not know. instead of Yes.. This corroborates the separate fresh context
failure. Exact results remain in the publication evidence.

The model still cannot provide useful open-ended chat. Conditional rules,
disjunctive assertions, mixed query precedence, multiple class parents, repeated
negation and open multi-value answers remain unsupported. Creative writing and
code generation remain unachieved. The remaining CPU binding failure prevents
a claim of semantic reliability throughout the context window. v14b has 960,705
nonzero parameters (0.384282%); most connections remain unused.

Extract autoregressive-v14b.zip into the repository root and run:

python -m chat1gb_autoregressive.chat --device auto

The failed v14a archive extracts to versions/autoregressive_v14a/model; use
--model-dir to inspect it. Verify ZIP hashes against SHA256SUMS.txt and
raw/config hashes against each manifest. ZIPs are small because these weights
are sparse and repetitive; every extracted checkpoint contains exactly 1 GB
of float32 parameters. NumPy and PyTorch must already be installed.

v0.5 experiment: coordinated assertions and deferred binding

v0.5 experiment: coordinated assertions and deferred binding

Four analytically compiled 1 GB checkpoints are preserved: v13a, failed v13b,
intermediate v13c and current v13d. Each has exactly 250,000,000 float32 parameters
and 1,000,000,000 raw weight bytes. Construction and inference remain offline,
with no training, pretrained parameters or downloaded knowledge. The generic
transformer runtime is unchanged.

The new circuits bind shared assertion objects to clause-local subjects,
predicates and polarity. Deferred commitment waits for a following boundary
before storing an ambiguous coordinated object. Question/directive clauses are
excluded from the observed false memories. A numerical correction preserves
clause-coordinate precision when reusing a residual field.

Suite	v12b baseline	v13a	v13b	v13c	v13d
Coordinated assertions	158/390	382/390	184/390	382/390	382/390
Assertion boundary audit, CUDA	Not run	41/76	41/76	61/76	65/76
Proposition composition	397/404	398/404	397/404	398/404	398/404

v13d passes all 381 targeted assertion cases and all 48 short boundary controls.
It retains legacy 185/185, graph 75/79, arithmetic 115/120, polarity 230/233,
signed operands 153/159, truth 236/239, query scope 265/269 and modifiers 78/81.
All prior suites were rerun. The failed candidates, exact outputs, timings,
regressions, activation diagnostic and source/model hashes remain public in the
version table.

v13b loses valid sentence-final objects through mismatched clause coordinates.
v13c repairs that but has four subject-binding regressions caused by float32
cancellation. v13d fixes the coordinate scale and has no regressions against
v13a across 22 matched reports. A conditional-stress regression against v12b
remains: the old Yes also occurred without the premise and did not demonstrate
conditional-rule application.

After freezing v13d at 4382108, seed 3178044486 reproduces 382/390 assertions
on CPU and CUDA. Boundary seed 3284145273 scores 65/76 CUDA and 64/76 CPU;
all 48 short cases pass on both. These use known generators and structures,
not independently designed evidence of broad intelligence. Frozen weights were
not retuned after those results.

Integrity, finite/layout/hash, causal-prefix, cache and offline-guard checks pass.
Neural interventions remove predicate/frame binding, question exclusion,
continuation validity or following-token validation and change the corresponding
behavior. The earlier graph/arithmetic/truth/composition interventions still pass.
Frozen v13d source reproduces exact raw and config hashes. The local 20-turn
publication smoke conversation passes.

Limits remain substantial. Some cases fail from 2,048 padding tokens onward;
the 5,048-token storage window is not a demonstrated accuracy window. CPU/CUDA
can diverge at long positions, including incomplete output. Disjunctions,
conditional rules, multiple class parents, mixed query precedence, repeated
negation and open multi-value answers remain unsupported. Useful open-ended chat,
creative writing and code generation are unachieved. v13d has 929,381 nonzero
parameters (0.3717524%); most connections remain unused.

Extract autoregressive-v13d.zip into the repository root and run:

python -m chat1gb_autoregressive.chat --device auto

The other archives extract to versions/autoregressive_VERSION/model; choose
that directory with --model-dir. Verify ZIP hashes using SHA256SUMS.txt and
raw/config hashes using each manifest. Small ZIPs reflect sparse/repetitive
weights; every extracted checkpoint is exactly 1 GB. NumPy and PyTorch must
already be installed; these commands do not download dependencies.

v0.4: Proposition composition and active request scope

v0.4 experiment: proposition composition and active request scope

Two new analytically compiled 1 GB checkpoints are preserved: v12a and corrected
v12b. Each contains exactly 250,000,000 float32 parameters / 1,000,000,000 raw
weight bytes. No training, pretrained parameters or downloaded knowledge is used;
construction and inference remain offline.

v12 compiles proposition events, evaluates each one neurally, and reduces true,
false and unknown values with homogeneous AND/OR. It supports the tested shared
and distinct subjects/predicates, inheritance and corrections. Clause IDs isolate
the active request. The generic transformer inference runtime is unchanged.

Development suite	v11a	v12a	v12b
Legacy	185/185	185/185	185/185
Graph	75/79	75/79	75/79
Arithmetic	115/120	88/120	115/120
Polarity	229/233	230/233	230/233
Signed operands	153/159	121/159	153/159
Object-specific truth	234/239	236/239	236/239
Query scope	262/269	265/269	265/269
Proposition composition	243/404	398/404	397/404
Request modifiers	Not run	17/81	78/81

v12a rejects Please calculate because its request-head filter is too strict.
v12b uses a bounded transparent-modifier grammar, repairing all 106 arithmetic
regressions across four reports. It also exposes an unsupported paraphrase that
v12a had rejected. The failed candidate and every failing case remain archived.
Three composition regressions against v11a remain recorded; its earlier partial-
answer passes did not establish support for those structures.

After freezing v12b, fresh seeds reproduced 397/404 composition and 78/81 modifier
scores on CPU and CUDA. These are known-generator combinations, not independently
designed general-intelligence tests. Source hashes, raw model hashes, exact
outputs, timings and regression comparisons are in results/.

Integrity, causal-prefix and cached/full decoding checks pass. Changing AND to
OR, removing unknown evidence or removing clause IDs changes the corresponding
answer. Earlier graph, arithmetic, polarity and truth ablations still work.
Rebuilding from the frozen v12b source reproduces raw weights and config exactly.

Remaining limits: mixed-operator precedence, compound assertions, incomplete
connectives, repeated negation, general pronouns, longer framing and partial-
question instructions fail. The open wh-question multiple-action bug remains.
Open-ended conversation, creative writing and code generation are unachieved.
v12b has 873,633 nonzero parameters (0.3494532%); most connections remain unused.

Extract autoregressive-v12b.zip into the repository root and run:

python -m chat1gb_autoregressive.chat --device auto

The v12a archive uses versions/autoregressive_v12a/model; select it explicitly
with --model-dir. Compare archive hashes with SHA256SUMS.txt, and raw/config
hashes with the included manifest. Small compressed archives reflect sparse,
repetitive weights; each extracted checkpoint is exactly 1 GB. NumPy/PyTorch
must already be installed; the build and runtime do not download dependencies.

v0.3: Object-specific truth and query negation

v0.3 experiment: object-specific truth and query negation

Two new analytically compiled checkpoints, v10a and v11a, extend the existing
offline transformer. Each contains exactly 250,000,000 float32 parameters and
1,000,000,000 raw weight bytes. No training, pretrained weights, downloaded
knowledge or runtime answer generator is used.

• v10a: exact subject/predicate/object retrieval, three-valued truth,
  per-object corrections and separation of questions from assertions.
• v11a (current): all seven existing predicates, copular and auxiliary
  inversion, and a separate query-negation bit. Missing evidence stays unknown.

Development suite	v9a	v10a	v11a
Legacy	185/185	185/185	185/185
Graph	75/79	75/79	75/79
Arithmetic	115/120	115/120	115/120
Polarity	227/233	229/233	229/233
Signed operands	153/159	153/159	153/159
Object-specific truth	45/239	229/239	234/239
Query scope	Not run	80/269	262/269

Seeds selected after freezing reproduce v10a truth 229/239 and v11a query scope
262/269 on both CPU and CUDA. These are fresh combinations under known grammar,
not independent general-intelligence tests. Exact outputs, timings, source
commits, hashes, failures and 22 matched-suite comparisons are in results/.

The runtime is unchanged. Causal-prefix, cached/full decoding, file-integrity,
offline-guard and neural ablation checks pass. Removing proposition retrieval,
object identity or query negation changes the associated answers. The archived
v11a compiler reproduces raw weight and config hashes exactly.

Still an experiment: most parameters are zero (v11a has 744,215 nonzero
parameters). Open-ended conversation, creative writing and code generation remain
unachieved. Conjunction, general pronouns, repeated negation and instruction scope
fail. v10a adds one later-instruction regression; v11a adds none across the matched
suites. The earlier open-question multiple-action regression is still present.
No failing case was removed and no broad research milestone is declared complete.

Extract autoregressive-v11a.zip into the repository root and run:

python -m chat1gb_autoregressive.chat --device auto

It supplies the default model directory. The v10a archive uses
versions/autoregressive_v10a/model; select that path with --model-dir.
Check archive hashes against SHA256SUMS.txt, then raw/config hashes against
the included manifest. The small ZIPs reflect sparse/repetitive weights; every
unpacked checkpoint is exactly 1 GB. NumPy/PyTorch must already be installed;
construction and inference perform no downloads.

Direct-weight chat: negative facts and signed operands

Negative facts and signed operands

Current checkpoint: v9a. This release adds three archived versions to the
initial release: v8a, v8b and v9a. Every model still has exactly 250,000,000
float32 parameters / 1,000,000,000 weight bytes, analytically constructed without
training, pretrained weights or online construction/inference.

Version	Legacy /185	Graph /79	Arithmetic /120	Polarity /233	Signed /159
v8a	185	75	114	226	not run
v8b	185	75	114	227	46
v9a	185	75	115	227	153

The polarity baseline was v7a at 53/233. A fresh seed after freezing v8b
reproduced 227/233 on CPU and CUDA. A fresh signed-operand seed after freezing
v9a reproduced 153/159 on both, including 120 new random combinations. The
generators and grammatical structures were known: this is restricted
compositional evidence, not an independent general-language benchmark.

Negative facts, contractions, corrections and inherited denials are represented
inside neural fact slots. Negative class assertions do not license positive
inheritance. Signed addition/subtraction accepts two operands in [-999,999].
Unary signs are distinguished from binary operators; a neural count check
rejects tested expressions with too many or too few operands.

Retained limits and regression

One multiple-action case regresses from v7a: after X can fly. X cannot swim.,
the open question selects the last denied action. The current answer retrieval
selects one object per predicate. Yes/no questions, query/instruction scope,
double negation, longer graph chains, creative writing, coding and useful
open-ended conversation remain unresolved.

Malformed expressions such as 5 + * 3 still produce numbers. The count check
is not a full parser. Multiplication, division, parentheses and multi-step
mathematical answers still fail. Old expected answers were not changed to hide
these failures; separate abstention tests measure a different requirement.

Artifacts and checks

Extract autoregressive-v9a.zip in the source repository root, then use an
existing offline environment with PyTorch:

python -m chat1gb_autoregressive.chat --device auto

Rebuild from the frozen compiler in an environment already containing NumPy:

python -m tools.build_version v9a --output build/reproduced

A separate rebuild reproduced the exact raw weight and config hashes. All
three archives passed decompressed SHA-256 and CRC checks. The v8a/v8b archives
extract under versions/autoregressive_VERSION/model; select them using
--model-dir. Earlier checkpoints remain in the v0.1.0 experimental release.

v9a contains 720,343 nonzero parameters (0.2881372%); most connections remain
zero. Small ZIP sizes reflect sparsity. It is a limited compiled neural system,
not a general-purpose language model.

v9a raw weight SHA-256:
397b76ee15d876d6d28d4f30ce59dd4d40069029018887133a173a4a67a74f53.

• Version results and exact outputs
• Architecture
• Ablations and integrity
• Regression evidence
• Research log

Direct-weight chat: versioned offline research

Direct-weight chat: initial public research release

Ten preserved checkpoints, including failed candidates. Each extracts to exactly
250,000,000 float32 parameters / 1,000,000,000 weight bytes. No training,
pretrained tensors, downloaded datasets or internet access were used during
construction/inference. GitHub access is used to publish this experiment.

Current model: v7a. This is a sparse, explicitly compiled causal transformer,
not a useful general-purpose conversational model.

Version	Legacy /185	Graph /79	Arithmetic /120
v1	131	not run	not run
v2	177	not run	not run
v3	182	not run	not run
v4	182	not run	not run
v5	185	12	not run
v6a, failed scratch allocation	1	8	not run
v6b, partial graph candidate	182	68	not run
v6c, bounded graph traversal	185	74	22
v7a, signed subtraction	185	74	114

Fresh combinations generated after candidate freeze reproduced graph 74/79 and
arithmetic 114/120 on CUDA and CPU. The generators and grammar were already
known; this is not an independent general-intelligence benchmark. Every failed
stress case is retained. The original selector v0 uses canned responses and is
included only as a rejected historical prototype, with its separate test evidence.

v7a follows up to three unfamiliar class links for tested property questions and
adds/subtracts two nonnegative integers at most 999, emitting signed results.
It still fails open-ended conversation, code generation, creative writing,
negation, longer graph chains and general mathematics. Negative operands and
chained expressions can produce incorrect numbers. Only 717,554 parameters
(0.287%) are nonzero; small ZIP sizes reflect this sparsity, not 1 GB of knowledge.

Use

Download the source and autoregressive-v7a.zip; extract both into the same
repository directory. Use an existing offline Python environment with PyTorch:

python -m chat1gb_autoregressive.chat --device auto

To rebuild without downloads in an environment already containing NumPy:

python -m tools.build_version v7a --output build/reproduced

The archived v7a compiler was rebuilt and reproduced the exact weight and config
hashes. SHA256SUMS.txt verifies each ZIP; each model manifest verifies the raw
weights. All ten ZIPs were streamed through CRC and decompressed SHA-256 checks.
Historical archives extract under versions/autoregressive_VERSION/model and
can be selected with --model-dir. The selector archive uses chat1gb/model.

• Full version results and exact outputs
• Research log
• Capabilities and limitations
• Circuit architecture

Current raw weight SHA-256:
85a6b709cead89d261a1b1d412ad8e64bac19d4e12b9f9ec6bc947fff1869c2d.

Code and experiment artifacts are MIT licensed. This is an experimental prerelease.