On this page
Byte-view literal packaging and build-cost benchmark
Edition: 9 October 2026 Australia/Brisbane. Decision: Prototype a bounded artifact comparison; defer a source-guaranteed packaging backend. Commercial confidence is low. No buyer demand or profitability is established.
Research finding
Family 128 claims a deterministic polynomial-time two-approximation for shortest common superstring on explicitly encoded ordinary strings, with ratio measured in symbols against unrestricted optimum. The guarantee belongs to its forced-count, periodic-layer, request/link, cycle-opening and Euler-output construction. It does not confer factor two on classical maximum-overlap greedy.
All seven principal argument files were read: introduction 31 lines, counts 107, layers 117, connections 131, group processing 147, cycle opening 68 and algorithm/output 26, totaling 627 lines. Figures, bibliography/driver, imported formal proof closure and independent mathematical acceptance remain uncompleted. The selected 15-line scope, 43-line Comparator, 14-line config and 65-line solution entry point were read; no checker, source execution or extraction ran. Comparator challenge placeholders are its intended proof interface, not evidence of solution failure.
The count recursion gives m(s) no larger than the occurrence count of s in any common superstring, with W equal to the sum of one-letter counts. Its base graph has W up and W down edges. Periodic rules restore repeated-letter cost that extension inequalities alone miss. The full source connects this graph within a further W budget and spells an output of length at most 2W. Pinned count rules, source output/cost argument.
Problem and buyer
A build or embedded-resource team with an immutable length-aware literal API may want a smaller blob containing all required byte strings at indexed offsets. A compact shared representation can preserve repeated IDs, contained literals and binary zero. It does not preserve original pointer identity or provide independent mutable storage.
The prospective recurring task is a build-time comparison on a large, genuinely overlapping literal corpus where bytes matter and an offset/length interface already fits. There is no evidence of such a customer here. Many deployed workflows already use linker pooling, general compression or tiny string tables, weakening a standalone product case.
What the finding could enable
A source-specific packer could provide a new worst-case symbol-length guarantee after its full construction and implementation correspondence are accepted. The bounded prototype currently supplies a distinct, conventional capability: emit immutable indexed artifacts, verify original-ID byte reconstruction, compare raw and compressed sizes across baselines, and calibrate tiny optima. A separate count-stage module implements the paper's forced-count/base-graph formulas, with explicit caps and proof status.
Potential integrations are an embedded/resource build plugin, a length-aware static literal-pool generator, or a regression framework comparing packaging objectives. None is a drop-in C-string linker replacement. Conventional greedy/tiny DP and the count stage are not the full source two-approximation.
Technical and commercial limits
The source explicitly enumerates O(L^2) substring vertices and periodic/blocking rules on encoded labels. Its final graph has at most 4L edges, but that small edge bound does not make substring/rule enumeration small. A suffix-index optimization or a restricted rule set needs its own equivalence/completeness and cost review. No practical runtime/memory result or extracted source program exists here.
The packaging reference caps 128 input records, 4,096 bytes per literal and 16,384 total literal bytes. Exact overlap DP accepts at most 12 maximal distinct nonempty strings. A common two-million budget counts overlap-candidate tests and DP transitions, excluding native substring preprocessing, per-character comparisons/slicing, compression cost and Python objects. Exhausted methods return no exact optimum or factor claim. The count stage caps reduced length 128, 512 distinct substrings including empty and two million conservative character/rule/lookup charges. Exhaustion yields no W, counts or graph.
Our byte alphabet has fixed eight-bit symbols. General source symbol length and input bit length remain different measures. Unicode normalization, terminators, alignment, relocations, pointer identity, mutability and application lookup costs require separate decisions. A shorter raw blob is not necessarily a smaller compressed complete artifact. Whole-artifact gzip/zlib/XZ comparisons require decompression and say nothing about random-access latency or resident memory.
Minimal architecture
Explicit stable IDs and exact hex bytes -> preserve original records -> remove duplicates/contained strings only for packing computation -> conventional proposal or reviewed source backend -> original-ID containment/offset-length check -> serialized ID/index/blob artifact -> whole-artifact compression and round-trip check -> actual target-objective comparison -> build regression report. Preserve the incumbent representation for comparison and require an explicit API bridge before integration.
The implemented SSP1 format includes a 12-byte header, every original ASCII ID with length, two 32-bit offset/length fields per record and the immutable blob. Empty and duplicate literals retain their distinct IDs. It has no required string terminator. The emitted .ssp files reconstruct every original byte string; they are useful reviewable artifacts, not firmware deployment or a standard linker format.
Existing alternatives and differentiation
GCC already attempts to merge identical constants during optimized compilation when its assembler/linker support that operation. GNU assembler documentation explicitly describes zero-terminated mergeable strings and suffix sharing. These are primary documented incumbent capabilities; no linker execution was performed here. GCC options, GNU section/string semantics.
Arbitrary substring sharing in a length-aware byte view can use interior offsets that a zero-terminated C-string API cannot always accept. For example, packing abc and bcd into abcd preserves the length-three view abc, but strlen at that pointer would read abcd. This model difference is a potential integration requirement, not evidence that existing tools are deficient.
Potential differentiation is reviewed source-specific worst-case packing and objective-aware build integration, after real workload and API evidence. The existing conventional packer/count-stage modules currently establish no algorithmic novelty, customer moat or superior complete-object performance.
Monetization hypothesis
Hypothesis: AUD 4,000 for a scoped literal-pool/build comparison within a specialist integration engagement. At 20 assumed specialist hours at AUD 180/hour, only AUD 400 remains before sales/support/overhead; 30 hours cost AUD 5,400. This weak illustrative margin reinforces low commercial confidence. A supported library or build plugin requires material recurring savings and low support costs; no quote, fee, customer, license revenue or willingness to pay is demonstrated.
Validation experiment
1,445 finite controls compare all 469 subsets of one through three of the fourteen binary literals of lengths one through three. The independent oracle enumerates all binary output words through length nine. Exact DP matches their minimum lengths. Paper-derived counts are no larger than actual occurrence counts in every common output within that finite domain. Artifact decoding/byte reconstruction, zero/empty/duplicate/UTF8 inputs, invalid models/hex/IDs, budgets and typed caps are also checked.
The single a^16 fixture restores W=16 and m(a^k)=17-k. The generated greedy-gap fixture [aaaa,aaab,abaa,abab] produces ten raw bytes with our deterministic maximum-overlap tie rule versus exact optimum nine. This finite gap does not establish a worst-case approximation ratio or the source algorithm's behavior.
Seven saved comparisons include synthetic overlap/periodic/binary cases, the current Python keyword list, pinned repository discipline names and its first 48 family titles. All 31 emitted indexed artifacts round-trip. No customer corpus, linker run, runtime-access benchmark, source full algorithm or independent proof acceptance was completed.
In the 48-title public sample, greedy shrinks the blob from 2,535 to 2,507 bytes and SSP1 from 3,113 to 3,085 bytes. Gzip remains 1,685 bytes; XZ grows from 1,616 to 1,648. In the synthetic periodic sample, raw SSP1 drops from 308 to 228 bytes and gzip from 163 to 138. That favorable overlap case already uses conventional greedy. Target objective and complete bytes determine the practical result, not a blob-only percentage or formal symbol bound.
Conditions to reject or defer
Reject a general storage-savings product if linker pooling/compression already suffices, literal data is a small part of the build, integration/API costs outweigh bytes saved, or compressed artifacts grow. Reject source-factor-two labels for greedy, tiny DP or counts alone. Defer a theorem backend until the layer/request/cycle construction is implemented, independently reviewed and practical on an appropriate corpus. Biological assembly, noisy/wildcard strings and identity-sensitive/mutable literals require separate models.
Next concrete action
On an authorized representative length-aware corpus, compare the actual incumbent serialized/build artifact and access requirements with emitted candidates, measuring build preparation, bytes, lookup/decompression cost and support burden. Explore literal source construction or a proven compact substring representation separately; preserve all source quantifiers and implementation/proof obligations. Current documentary registry, selected-section ledger.