[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","root",{"_26":27,"_28":29,"_30":12,"_31":12,"_32":12,"_33":12,"_34":12,"_35":12,"_36":37},"routes/canvas.shared.$sharedTextdocId",{"_9":10,"_11":12},"sharedTextdoc",{"_13":14,"_15":-7,"_16":17,"_18":19,"_20":21,"_22":23,"_24":12,"_25":12},"isAuthenticated",false,"sharedTextdocId","6932b87fc41481918c7d43a54f743278","versionInt","title","Zoda Tensor Vs Hadamard — Interactive Calculator","type","code/react","content","import React, { useMemo, useState } from \"react\";\nimport {\n BarChart,\n Bar,\n XAxis,\n YAxis,\n CartesianGrid,\n Tooltip,\n ResponsiveContainer,\n ReferenceLine,\n LineChart,\n Line,\n Legend,\n} from \"recharts\";\n\n// --- helpers ---\nfunction formatBytes(bytes: number) {\n if (!Number.isFinite(bytes) || bytes <= 0) return \"0 B\";\n const units = [\"B\", \"KiB\", \"MiB\", \"GiB\", \"TiB\"];\n let i = 0;\n let v = bytes;\n while (v >= 1024 && i < units.length - 1) {\n v /= 1024;\n i++;\n }\n return `${v.toFixed(2)} ${units[i]}`;\n}\n\n// Always show Merkle proof sizes in KiB\nfunction formatKiB(bytes: number) {\n if (!Number.isFinite(bytes) || bytes <= 0) return \"0 KiB\";\n const kib = bytes / 1024;\n return `${kib.toFixed(2)} KiB`;\n}\n\nfunction clamp(v: number, a: number, b: number) {\n return Math.max(a, Math.min(b, v));\n}\n\nexport default function App() {\n // --- Inputs ---\n const [blobMiB, setBlobMiB] = useState(4); // blob size D (MiB)\n const [subnets, setSubnets] = useState(512); // n\n // Hadamard requires a user-chosen chunk size (one matrix entry) in BYTES\n const [hadChunkBytes, setHadChunkBytes] = useState(64); // e.g., 64 B field element (k = 512)\n\n const blobBytes = useMemo(() => blobMiB * 1024 * 1024, [blobMiB]);\n\n // --- Tensor ZODA (2D RS; total expansion 4d) ---\n const tensor = useMemo(() => {\n const n = Math.max(1, Math.floor(subnets));\n const totalBytes = 4 * blobBytes; // 2x rows * 2x cols\n const chunkBytes = Math.ceil(totalBytes / (n * n)); // one entry per matrix cell (rounded up to whole bytes)\n const kBits = 8 * chunkBytes; // F_{2^k}, chunk == one field element\n const kMinBits = Math.ceil(50 + Math.log2(n)); // minimum k to satisfy 2^k / n >= 2^50\n const secBits = kBits > 0 ? kBits - Math.log2(n) : -Infinity; // since condition is 2^k / n >= 2^50\n const warn = secBits < 50; // alert if below 2^50\n\n // Row/Column sizes (bytes) — equal in square matrix\n const rowBytes = n * chunkBytes;\n const colBytes = rowBytes;\n\n // Merkle parameters over n leaves (rows/cols)\n const merkleDepth = n > 1 ? Math.ceil(Math.log2(n)) : 0; // e.g., n=2048 -> 11\n const hashSize = 32; // bytes\n const rowProofBytes = hashSize * merkleDepth;\n const colProofBytes = hashSize * merkleDepth;\n const commitmentBytes = 64; // two roots (row + column)\n\n return {\n n,\n totalBytes,\n chunkBytes,\n kBits,\n kMinBits,\n secBits,\n warn,\n rowBytes,\n colBytes,\n merkleDepth,\n rowProofBytes,\n colProofBytes,\n commitmentBytes,\n };\n }, [blobBytes, subnets]);\n\n // --- Hadamard ZODA (1D RS; total expansion 2d) ---\n const had = useMemo(() => {\n const n = Math.max(1, Math.floor(subnets)); // number of columns == number of subnetworks\n const totalBytes = 2 * blobBytes; // 1D extension\n const perColBytes = totalBytes / n; // size of one column\n const chunkBytes = Math.max(1, Math.floor(hadChunkBytes)); // user-chosen entry size\n const kBits = 8 * chunkBytes; // field size F_{2^k}\n const kMinBits = Math.ceil(50 + Math.log2(n)); // minimum k to satisfy 2^k / n >= 2^50\n const rows = Math.ceil(perColBytes / chunkBytes); // r = ceil((2·d)/(n·s))\n const secBits = kBits > 0 ? kBits - Math.log2(n) : -Infinity; // requirement 2^k / n >= 2^50\n const warn = secBits < 50; // alert if below threshold\n\n // Row/Column sizes (bytes)\n const rowBytes = n * chunkBytes; // one row spans n columns\n const colBytes = perColBytes; // equals rows * chunkBytes\n\n // Merkle parameters (Hadamard: only column tree)\n const merkleDepth = n > 1 ? Math.ceil(Math.log2(n)) : 0;\n const hashSize = 32;\n const colProofBytes = hashSize * merkleDepth; // column proof only\n const commitmentBytes = 32; // single root (columns)\n\n return {\n n,\n totalBytes,\n perColBytes: colBytes,\n chunkBytes,\n kBits,\n kMinBits,\n rows,\n secBits,\n warn,\n rowBytes,\n colBytes,\n merkleDepth,\n colProofBytes,\n commitmentBytes,\n };\n }, [blobBytes, subnets, hadChunkBytes]);\n\n const tensorChartData = [\n { name: \"Chunk Size (bytes)\", value: tensor.chunkBytes },\n { name: \"k (bits)\", value: tensor.kBits },\n { name: \"secBits = k - log2(n)\", value: tensor.secBits },\n ];\n\n const hadChartData = [\n { name: \"Per-Column Size (bytes)\", value: had.perColBytes },\n { name: \"Chunk Size (bytes)\", value: had.chunkBytes },\n { name: \"Rows (r)\", value: had.rows },\n { name: \"k (bits)\", value: had.kBits },\n { name: \"secBits = k - log2(n)\", value: had.secBits },\n ];\n\n // sweep chart across a range of n to visualize sensitivity (bonus)\n const sweepN = useMemo(() => {\n const min = 64;\n const max = 4096;\n const step = 64;\n const arr: { n: number; tensorChunk: number; hadRows: number; hadSecBits: number; tensorSecBits: number }[] = [];\n for (let nn = min; nn <= max; nn += step) {\n const tChunk = (4 * blobBytes) / (nn * nn);\n const tSec = 8 * tChunk - Math.log2(nn);\n const hadPerCol = (2 * blobBytes) / nn;\n const rows = Math.ceil(hadPerCol / hadChunkBytes);\n const hSec = 8 * hadChunkBytes - Math.log2(nn);\n arr.push({ n: nn, tensorChunk: tChunk, hadRows: rows, hadSecBits: hSec, tensorSecBits: tSec });\n }\n return arr;\n }, [blobBytes, hadChunkBytes]);\n\n // --- lightweight runtime tests (in-UI assertions) ---\n const tests = useMemo(() => {\n const approxEq = (a: number, b: number) => Math.abs(a - b) <= 1; // 1 byte tolerance\n return [\n {\n name: \"Tensor rowBytes == colBytes (square)\",\n pass: tensor.rowBytes === tensor.colBytes,\n },\n {\n name: \"Hadamard rowBytes == n * chunkBytes\",\n pass: had.rowBytes === had.n * had.chunkBytes,\n },\n {\n name: \"Hadamard perCol ≈ rows * chunkBytes\",\n pass: approxEq(had.colBytes, had.rows * had.chunkBytes),\n },\n ];\n }, [tensor.rowBytes, tensor.colBytes, had.rowBytes, had.n, had.chunkBytes, had.colBytes, had.rows]);\n\n return (\n

ZODA Tensor vs Hadamard — Interactive Calculator

\n Model: Tensor extends data via RS in two directions (total 4·d bytes) and splits it into n×n cells; each cell is a single field element (F_2^k). Hadamard extends data in one direction (total 2·d bytes); the number of columns is n (subnetworks), per‑column size is 2·d / n; with a user‑chosen s-byte cell, the row count is r = ⌈(2·d)/(n·s)⌉. Security warning triggers when 2^k / n < 2^50 ⇔ k − log2(n) < 50.\n

\n\n {/* Controls */}\n

\n Blob size (MiB)\n setBlobMiB(clamp(parseFloat(e.target.value) || 0, 0.125, 1048576))}\n className=\"mt-2 w-full border rounded px-3 py-2\"\n />\n

{formatBytes(blobBytes)}

\n\n

\n Number of subnetworks (n)\n setSubnets(clamp(parseInt(e.target.value) || 1, 1, 16384))}\n className=\"mt-2 w-full border rounded px-3 py-2\"\n />\n

Matrix size: n×n for Tensor; number of columns n for Hadamard

\n\n

\n Hadamard cell/chunk size s (bytes)\n setHadChunkBytes(clamp(parseInt(e.target.value) || 1, 1, 1 << 20))}\n className=\"mt-2 w-full border rounded px-3 py-2\"\n />\n

k = 8·s bits, F_2^k

\n\n {/* Tensor card */}\n

ZODA — Tensor (2D RS)

\n \n {tensor.warn ? \"Warning: 2^k / n < 2^50\" : \"Security ≥ 2^50\"}\n \n

Total extended data: 4·d = {formatBytes(tensor.totalBytes)}
Column size: {formatBytes(tensor.colBytes)}
Row size: {formatBytes(tensor.rowBytes)}
Cell/chunk size s = total/(n²): {formatBytes(tensor.chunkBytes)}
Matrix dimension: {tensor.n} × {tensor.n}
Merkle depth over n leaves: {tensor.merkleDepth}
Merkle proof size — Row: 32×depth = {formatKiB(tensor.rowProofBytes)}
Merkle proof size — Column: 32×depth = {formatKiB(tensor.colProofBytes)}
Merkle commitment size (two roots): {formatBytes(tensor.commitmentBytes)}
k (bits): {tensor.kBits.toFixed(0)}
Min k for 2^50 target: {tensor.kMinBits} bits
Security (k − log2 n): {tensor.secBits.toFixed(2)} bit

\n \n \n \n \n \n (typeof v === \"number\" ? v.toFixed(2) : String(v))} />\n \n \n \n \n

\n\n {/* Hadamard card */}\n

ZODA — Hadamard (1D RS)

\n \n {had.warn ? \"Warning: 2^k / n < 2^50\" : \"Security ≥ 2^50\"}\n \n

Total extended data: 2·d = {formatBytes(had.totalBytes)}
Column size: {formatBytes(had.colBytes)}
Chosen cell/chunk size s: {formatBytes(had.chunkBytes)}
Row size: {formatBytes(had.rowBytes)}
Row count r = ⌈(2·d)/(n·s)⌉: {had.rows}
Merkle depth over n column leaves: {had.merkleDepth}
Merkle proof size — Column only: 32×depth = {formatKiB(had.colProofBytes)}
Merkle commitment size (column root): {formatBytes(had.commitmentBytes)}
k (bits): {had.kBits.toFixed(0)}
Min k for 2^50 target: {had.kMinBits} bits
Security (k − log2 n): {had.secBits.toFixed(2)} bit

\n \n \n \n \n \n (typeof v === \"number\" ? v.toFixed(2) : String(v))} />\n \n \n \n \n

\n\n {/* Sweep charts (optional visibility) */}\n

n sweep (sensitivity):

Trends for n=64..4096 with fixed blob and Hadamard cell size.

\n \n \n \n \n \n (typeof v === \"number\" ? v.toFixed(2) : String(v))} />\n \n \n \n \n \n \n \n \n

\n\n {/* Inline test results */}\n

Self-checks

\n {t.pass ? \"✔\" : \"✖\"} {t.name}\n

\n\n

\n Note: The security threshold condition is 2^k / n ≥ 2^50 (i.e., k − log2 n ≥ 50). Therefore a warning is shown only when\n k − log2 n < 50. The earlier inverted inequality was not aligned with the practical security target.\n

\n );\n}\n","access","public","isModerationBlocked","isAnonifyApiKeyDetected","dd",{"_38":39,"_40":41},"disablePrefetch",true,"shouldPrefetchAccount","shouldPrefetchUser","shouldPrefetchSystemHints","promoteCss","disableSSR","stripModulepreloadImports","statsigGateEvaluationsPromise",["P",37],"traceId","8384832099991196334","traceTime",1779236509070]