RedTail clamp modification trials¶

5 October 2026. Follow-up to the initial research record. These experiments make the proposed modifications concrete on small, completely enumerated domains. They do not implement a new cryptographic hash or claim to reproduce Michael’s intended clamp.

Direction and interpretation¶

Michael’s instruction:

Correct! in Universe(E)=0 ie: Today and Here, Binary can not have a -1. So we ASB_Value it. Take that out, let’s modify it if it makes sense. Propose a list of trail modifications. One is Ternary and how it behaves. Then put it back to Zero or Control state and then let’s break the clamp and cause collisions.

Universe(E)=0 is preserved as the proposed reference-state notation. No physical or mathematical law is inferred from it. For this lab, C0 names an explicit, repeatable control. Returning to control means restoring the same mapping and inputs, rather than replacing every input with the number zero.

Latest direction: Michael asked to forget ABS(x) for now and work on collisions. ABS is deferred and is not part of the active script or current results. Trial identifiers T1 and T2 are retired so that the remaining trial identifiers stay stable. Their earlier observations are historical only and do not define the proposed construction.

Clarification to the earlier discussion: binary storage can encode -1, for example with signed integer representations. A bit itself is restricted to two values. The equality of -1 and +1 in GF(256) concerns field arithmetic. It does not force an ABS operation on signed integers. The initial note has been revised to make this distinction and to permit ternary exploration through an explicit encoding layer.

Control and execution¶

The main domain is all 81 four-trit vectors over {-1,0,+1}. C0 maps each trit t to the distinct byte label t+1, then retains original length and all six systematic/parity shares. Its encoder is a small reference model using the project’s custom parity rows [1,1,1,1] and [1,2,3,4] over GF(256). It is not the production library matrix or the production Rust executable.

All mappings are stateless. After every trial the complete list of 81 C0 outputs was recomputed and compared with the original control. All control checks passed. The lab ends in C0. Existing DarkRock implementation files were not changed.

Run the experiments with:

python3 '/Users/premise/Documents/ChatGPT/Ciphers and Chains/clamp_trials.py'

The script writes clamp-trial-results.json, including collision examples and counts of unordered distinct-input pairs that share an output.

Trial modifications and measured results¶

The order below is the execution order; C0 was checked again between each row.

Trial	Modification	Inputs	Distinct outputs	Colliding pairs
C0	Preserve three labels, length, and full codeword	81	81	0
T3	Evaluate four signed digits in base three over integers	81	81	0
T4	Evaluate the same signed digits in base two	81	31	94
T5	Expand input to integers -6 through +6; saturate to [-1,+1]	13	3	30
T6	Keep the saturated value and signed escape residual	13	13	0
T7	Move to a new three-value window; keep window index and local value	13	13	0
T8	Discard the window index from T7	13	3	22
T9	Keep original length for zero-byte messages of lengths 1 through 4	4	4	0
T10	Drop original length from those padded codewords	4	1	6
T11	Keep only two parity outputs for all four-byte vectors over {0,1,2,3}	256	64	384

Zero collisions means zero in that declared finite domain. For the simple reversible mappings below, inversion additionally explains the result. These are not cryptographic strength estimates.

Ternary behavior¶

Define an integer polynomial evaluation with positions retained:

P_b(a) = a0 + b*a1 + b^2*a2 + b^3*a3

At b=3 the 81 vectors produce every integer from -40 through +40 once. At b=2 there are only 31 possible values, -15 through +15, and multiple signed-digit representations merge. For example:

(1, 0, 0, 0) -> 1
(-1, 1, 0, 0) -> -1 + 2 = 1

This collision comes from combining a three-symbol signed alphabet with base-two positional evaluation. It is not a failure of binary storage itself.

The active experiment leaves signed symbols intact. It makes no assumption about an ASB_Value operation.

Escaping the clamp and modifying the tail¶

The illustrative clamp is C(x)=min(1,max(-1,x)). It is deliberately simple and is not the entropy logarithm guard in DarkRock.

Inside {-1,0,+1}, C is the identity. Extending the domain without preserving escape information creates collisions, for example C(1)=C(2)=C(6)=1. Define a signed residual tail:

r = x - C(x)
representation = (C(x), r)
x = C(x) + r

This restores exact recovery. It also gives a concrete interpretation of changing the tail on escape: x=1 gives (1,0), x=2 gives (1,1), and x=3 gives (1,2). Discard the residual and the collisions return.

A second proposal changes the local window:

q = floor((x+1)/3)
r = (x+1) mod 3 - 1
x = 3q + r

Here r always lies in {-1,0,+1}, while q identifies the escaped-to window. For x=1,2,3 the pairs (q,r) are (0,1), (1,-1), and (1,0). Dropping q makes -1,2,5 collide at r=-1. Keeping it preserves the tested inputs and is algebraically reversible for every integer.

Both constructions are encodings. Their tails can grow with input magnitude. Neither is a new cipher: there is no key or hard inversion problem, and the inverse is explicit. They provide concrete starting points for defining the intended escape rule.

Removing the actual entropy guard¶

The script also isolates p=0 in the entropy term. Python’s naive evaluation of -p*log2(p) raises a logarithm domain error. The production-style log guard returns zero. Explicitly defining the zero term as zero also returns zero, without the clamp.

Thus removing this particular guard unsafely causes a numerical failure; it does not demonstrate a hash collision. Removing it safely with the correct boundary definition preserves this entropy calculation. The runtime behavior of the naive expression may differ between Python and floating-point implementations that return NaN.

Further modifications to propose¶

Exact escape predicate: replace the illustrative [-1,+1] interval with Michael’s intended state space and bounds. State what Universe(E) measures and how a state enters or leaves the permitted region.
Field choice: compare explicit trit labels carried by the existing byte code with a separately designed code over an appropriate GF(3^m). Do not assume signed integer arithmetic and finite-field arithmetic coincide.
Nonlinear transition: define a deterministic transition on escape, including its inverse if encryption is intended. An arbitrary nonlinear rule is not automatically secure.
Bounded tail: cap the residual or window index and exhaustively test exactly where information is lost, rejected, or passed to a further escape record.
Digest projection: specify which pieces become the public fixed-length hash. Test the projection separately from the reversible full representation; omitting tail information can reintroduce the collisions already demonstrated.
Entropy measurement: measure the distribution before and after each mapping under a declared input distribution. Keep uncertainty measurements separate from collision and inversion tests.

The first open dependency is a precise clamp definition. These results support exploring escape information explicitly; they do not establish that an existing clamp prevents all collisions or that crossing it creates cryptographic security.