Anim. 1 Ambiguity in the Autoglyphs

Start by importing a list of seeds from this list of addresses (sunseted)

txdat=StringSplit[Import["https://0x0.st/-hgJ.txt"],"\n"];
SameQ[ImportByteArray[BlockchainTransactionData[
txdat[[#]],"InputData",BlockchainBase->"Ethereum"],"UnsignedInteger8"],
ImportByteArray[BlockchainTransactionData[
txdat[[#]],"InputData",BlockchainBase->"Ethereum"]]]&/@{1,2,3,4,5}
Out[] = T,F,T,T,T . . . 

Be careful to set "UnsignedInteger8" or the conversion will fail anomalously.

seedInt[tx_]:=Dot[Reverse[ImportByteArray[BlockchainTransactionData[
tx,"InputData",BlockchainBase->"Ethereum"],"UnsignedInteger8"
]][[1;;32]],256^Range[0,31]]
seedIntData=seedInt[txdat[[#]] ]&/@Range[512]

Notice non-homogeneity, we will return to this shortly. Once the seeds are known, the hidden values must also be known:

aVals = ToExpression[StringSplit[
    Import["~/mathfun/AutoGlyphs/hiddenVals.txt"], "\n"]];

In retrospect to the original creators, I am not revealing these $512$ uint values today. The more code is needed to identify schemes and then project different ways for view comparison or empty set verification:

AutoGlyphM[aVal_] := With[{mod = Mod[aVal, 11] + 5},
  Outer[v[x[#2, aVal], y[#1, aVal], mod] &,
   Range[0, SIZE - 1], Range[0, SIZE - 1], 1]]

AbsoluteTiming[  NumGlyphCompute = AutoGlyphM /@ aVals; ]
Out[]=1/2min

AbsoluteTiming[ RawGlyphData = Characters[StringSplit[Import[
        "~/mathfun/AutoGlyphs/RawData/g" <>
         StringPadLeft[ToString[#], 4, "0"] <> ".txt"],
       " "]] & /@ Range[1, 2^9];]
Out[]=3s

divs = Range[#[[1]], #[[2]] - 1] & /@ 
   Partition[{0, 20, 35, 48, 59, 68, 73, 77, 80, 82, 83}, 2, 1];
schemes = Position[divs, Mod[#, 83]][[1, 1]] & /@ aVals;

Lex = Characters[{" X/\\ ", " +-| " , " /\\  ", " \\|-/", " O|- ", 
    " \\\\  ", " #|-+", " OO  ", " #   ", " #O  "}];
RRtoChar =   MapIndexed[(#2[[1]] - 1) -> StringReplace[#1, " " -> "."] &, #] & /@Lex;
RRtoAmb =   MapThread[ Append, {Map[
     MapIndexed[#1 -> #2[[1]] &, Flatten@Position[#, " "] - 1] &, Lex],
    Map[Alternatives @@ 
        Complement[Range[5] - 1, Flatten@Position[#, " "] - 1] -> 0 &,
      Lex]}];

NumToChar[numGlyph_, scheme_] :=  ReplaceAll[numGlyph, RRtoChar[[scheme]]]
ProjAmbiguous[numGlyph_, scheme_] :=  ReplaceAll[numGlyph, RRtoAmb[[scheme]]]

The main objectif of this mission is to print a value indicating empty set. Here we go:

QAdat = SameQ[NumToChar[NumGlyphCompute[[#]], schemes[[#]]],
     RawGlyphData[[#]]] & /@ Range[512];
Flatten[Position[QAdat, False]]
Out[]={}

The proof is complete. The source code has been taken for $512\times$.

While all of this was happening, some of you may have noticed an extra layer in the crypto having to do with byte counting length of unsigned integers, or in computable:

seedData = StringSplit[Import["https://0x0.st/-hg3.txt"], "\n"];
Flatten[With[{lens = StringLength /@ seedData},
  Position[lens, #] & /@ Select[lens, # < 44 &]]]
seedData[[%]]

Out[]= {198, 337}
Out[]={200, 1123581321}

Thus what is next for this analysis? Should we discuss the inherent symmetry of multiplication tables plus or minus a few extra symbols? Of course, the ansers is "Yes", but first, a commercial shout out to the predecessors.

The test functions are written as follows:

TestVSym[glyph_] :=  SameQ[Union[Flatten[glyph - Reverse[glyph]]], {0}]
TestHSym[glyph_] :=  SameQ[Union[Flatten[glyph - Map[Reverse, glyph]]], {0}]
TestDSym[glyph_] :=  SameQ[Union[Flatten[glyph - Transpose[glyph]]], {0}]

Then we must restrict

HSyms = Position[Map[TestHSym, NumGlyphCompute], True][[All, 1]];
VSyms = Position[Map[TestVSym, NumGlyphCompute], True][[All, 1]];
DSyms = Position[Map[TestDSym, NumGlyphCompute], True][[All, 1]];

StrictHSyms = Complement[HSyms, VSyms];
StrictVSyms = Complement[VSyms, HSyms];
StrictDSyms = Complement[DSyms, Join[HSyms, VSyms]];
StrictHVSyms = Intersection[HSyms, VSyms];

symClasses = {StrictHSyms, StrictVSyms, StrictDSyms, StrictHVSyms};

Penultimate finally, here is an interesting proof:

Outer[Length[Intersection[#1, #2]] &, symClasses, symClasses, 1] // MatrixForm
Length /@ {StrictHSyms, StrictVSyms, StrictDSyms, StrictHVSyms}
Total[%]

which says that all glyphs must have one of four types of symmetry ending with square dihedral in $110$ cases, the most symmetric.

Of course, if there is a penultimate, there must be a final ultimate, "ultima magic", so to speak. Here you go no charges whatsoever:

modClasses = With[{modData = {Mod[#, 2], Mod[#, 3]} & /@ aVals},
   Position[modData, #][[All, 1]] & /@ Union[modData]];
Outer[Length[Intersection[#1, #2]] &, symClasses, modClasses, 
  1] // MatrixForm

Your homework is to interpret this matrix and take the analysis to one level deeper to prove a priori from the source code why it must exist.

Now here is the last issue in this PoC with the metadata located at this address. It must be compared to the state of the art for on-chain computation, meaning that the following code:

function draw(uint id) public view returns (string) . . . 

from etherscan.io, as far as I know, does not exist in a MWK living on the Cardano blockchain.