PlanetCrash/The_Scraps_of_Imagination_LLM_Training_Dataset

The Scraps of Imagination — LLM Training Dataset (rev4)

Source work: The Scraps of Imagination: A Catalog of Spatio Angular Aberations and Anomalies — three Mathematica notebooks. Author: Parker Emmerson (Yaohushuason), Independent Researcher — ORCID 0009-0007-1288-3292 — Parkeremmerson@icloud.com

All the content of the book, converted into the training-data formats used for fine-tuning and continued pretraining of language models: its text, its Wolfram Language inputs with every output and message the notebooks record, every figure, and every number the notebooks store for its plots and sounds — every 3D surface as exact coordinates, as a picture and as an STL 3D-object file, every 2D curve as exact coordinates and a picture, every sound as its samples and a WAV file. The supervised responses are of three kinds. Most are the book's own text: its prose, theorems and proofs, formulas, headings and labels as written, and Wolfram Language inputs with the outputs and messages the notebook records. Others describe the book's plots, and every number in those descriptions is computed from the coordinates Mathematica stored for the plot. The third kind, in plot_data/, lists those stored numbers themselves, exactly, tied to the command that made each plot. The prompts are templated instructions that name the paper the material comes from. Nothing has been paraphrased, summarized, or written in the author's place.

Contents of the book, as represented here

The book is three notebook files, kept in order as three parts; each part is a series of papers (36 paper headings in all). The book's title and subtitle are the first cell of part 1.2. There is no printed edition, so everything comes from the notebooks.

Part	Papers
Part 1.1	"Conic" Relativity: Expositions of Relativity through Difference in Circumferences of Two Circles "Conic" Relativity: Expositions of Relativity through Difference in Circumferences of Two Circles Perceptual Space Applied to the Uncertainty Model of Physics The Geometric Pattern of Perception Theorems A Notational Language for Describing the Geometry of Space-Time A Notational Language for Describing the Geometry of Space-Time The Four Noble Truths of θ, The Hologram of Vision The Four Noble Truths of θ, The Hologram of Vision
Part 1.2	3 D plots of f(r1)=f(r)=θ 11 Dimensional A Unifying Theory Addendum No. 1 Addendum No. 1 Addendum No. 2 Addendum No. 3 Addendum No. 5 Addendum No. 6 Solutions for the Speed of Light Addendum No. 2
Part 2	The Geometric Pattern of Perception of the Moon from beneath the Legs. The Difference in Velocity (Average - Instantaneous) is equal to the phenomenal velocity at the position where the height of the cone has folded all the way up! Information and Layout A Notational Language for the Light-Sensitive Psychophysics A Notational Language for the Light-Sensitive Psychophysics The Mathematics of the 8 Fold Path ∞ℼ[ConstantC]ghmtθ Math to Art The Geometric Patterns of Perception No Time, only True Three Principles of Acceleration in a Space Defined by Light On Formulations of Pythagorean Theorem Univocal Radius Solutions Continued Parker' s Commentary on Fermat' s Last Theorem Algebraic, Geometric Interpretations of the Uncertainty Principle The Paradox of Time and Cyclicality On the Processing of Tachyon Emulsion from a Photon' s Energy Theory on the Process of Tachyon Emulsion

6 papers appear twice in the notebooks ("Conic" Relativity: Expositions of Relativity through Difference in Circumferences of Two Circles; A Notational Language for Describing the Geometry of Space-Time; The Four Noble Truths of θ, The Hologram of Vision; Addendum No. 1; Addendum No. 2; A Notational Language for the Light-Sensitive Psychophysics); both copies are kept as the notebooks hold them, and their plots that are exact copies are marked same_data_as.

Mathematics is written in Wolfram Language notation exactly as the notebooks hold it (Sqrt[...], Sin[β], {{θ → ...}}), with Greek letters and other named characters as Unicode; 3 characters that exist only in Mathematica's own font and have no Unicode equivalent are kept in their Wolfram Language form (\[ConditionType], \[ConstantC], \[Plain]). Inputs and the outputs the notebook records are kept together, in fenced ```wolfram blocks; the messages Mathematica printed for an input (such as Power::infy: Infinite expression 1/0 encountered.) follow it as Message: … lines, in the order the notebooks have them (597 in all). The book's title cell and the bylines under the papers (11 lines "by Parker Emmerson") are kept where they stand; headings and statement labels (Theorem 4:, Theorem 3 Continued, Preface:) are written exactly as the author typed them. Each graphic appears in the text as Output: [Graphics soi-plot-NNNN — summary] (or [Figure …] for pictures), where the summary is computed from its stored data and the id leads to its full record in the plot index.

Files

The_Scraps_of_Imagination_full_text.md                     the whole book as one Markdown document (3,798,436 characters)
The_Scraps_of_Imagination_dataset_manifest.json            record counts, approximate token counts and SHA-256 of every file
pretraining/The_Scraps_of_Imagination_pretraining_corpus.jsonl
                                        {"id", "text", "meta"} — one record per paper or section (split at ~14,000 characters), plus one record per graphic (2,461 records); plus _train / _validation
sft_openai_chat/The_Scraps_of_Imagination_sft_openai_chat.jsonl
                                        {"messages": [system, user, assistant]} — OpenAI / Together / Fireworks chat format (6,005 examples); plus _train / _validation
sft_sharegpt/The_Scraps_of_Imagination_sft_sharegpt.jsonl  {"id", "conversations": [{"from", "value"}, ...]} — ShareGPT (Axolotl, LLaMA-Factory, FastChat)
sft_alpaca/The_Scraps_of_Imagination_sft_alpaca.json       [{"instruction", "input", "output", "system", "id", "type"}] — Alpaca (JSON array)
sft_prompt_completion/The_Scraps_of_Imagination_sft_prompt_completion.jsonl
                                        {"prompt", "completion"} — plain prompt/completion (TRL SFTTrainer, Bedrock)
plot_data/The_Scraps_of_Imagination_plot_data_sft_openai_chat_{train,validation}_NNN.jsonl.gz
                                        every number the notebooks store for the plots and sounds, as chat examples (407,612 examples; gzip-compressed JSON lines)
plot_data/The_Scraps_of_Imagination_plot_data_pretraining_{train,validation}_NNN.jsonl.gz
                                        the same numbers as pretraining records (180,080 records)
plot_pdf/soi-plot-1814.pdf            the figure the notebook stores as a PDF, decoded
The_Scraps_of_Imagination_plot_index.jsonl                 one record per graphic (2,080): part, paper, command, relation to it, image, coordinates, STL and WAV files, description, sample points
plot_coordinates/soi-plot-NNNN.npz    the full data stored for each graphic (1,985 files, 187,653,108 numbers, exact float64 / int32)
plot_stl/soi-plot-NNNN.stl            each 3D surface as a binary STL 3D-object file (1,169 files; exact copies share one)
sounds/soi-plot-NNNN.wav|mid          each sound as a WAV audio file (46 files), and the two notes as MIDI files (2)
images/soi-plot-NNNN.jpg|png          an image of each graphic (2,073)
vision_llava/The_Scraps_of_Imagination_vision_llava.json   [{"id", "image", "conversations": [human "<image>\n…", gpt …]}] — LLaVA / LLaMA-Factory / Axolotl (3,441 examples); plus _train / _validation
vision_openai_chat/The_Scraps_of_Imagination_vision_openai_chat_train.jsonl
                                        {"messages": [system, user [text, image_url (base64 JPEG, 512 px)], assistant]} — OpenAI vision fine-tuning; plus _validation

The four supervised files hold the same 6,005 examples serialized four ways. The train/validation split is deterministic and stratified by example type: about 5% of each type goes to validation, chosen by SHA-256 of the example id (5,704 training, 301 validation; a type with a single example stays in training). The same rule splits the pretraining records and the vision examples (3,269 training, 172 validation).

The system message in the chat formats is:

You are an assistant trained on The Scraps of Imagination: A Catalog of Spatio Angular Aberations and Anomalies by Parker Emmerson (Yaohushuason). Answer with the book's own text, Wolfram Language computations and results, in the book's notation.

Responses are at most 12,000 characters; prompts are not shortened, because a prompt carries the book's own input or command whole (the longest, a Wolfram Language input to evaluate, is 75,582 characters).

Supervised examples by type

type	examples	task
graph_description	1432	Given a plotting command from the book, describe the graph — every number computed from the coordinates the notebook stores for it.
graph_samples	1378	Given a plotting command, list a thinned selection of the points Mathematica actually stored for it.
graph_to_command	1372	The reverse direction: from a graph's computed properties and stored points, give the command that drew it.
wolfram_eval	770	Evaluate a Wolfram Language (Mathematica) input from the book — the response is the output the notebook records.
section_continuation	489	Continue a paper from a quoted passage — sequential pieces covering long papers.
wolfram_plot	412	Given the expression the author has just written, give the Wolfram Language command he plots it with (plots directly under their command only).
section_exposition	59	Present a whole paper, or a whole section of a long paper.
section_opening	33	Give the opening of a long paper.
passage_continuation	29	Complete a long paragraph from its first twelve words.
theorem_proof	17	Prove a stated theorem or lemma — the response is the material the book gives after the statement (prose, formulas, Wolfram Language evaluations), up to the next statement or heading.
state_theorem	14	State a numbered theorem or lemma of a paper — the response is the statement as written.

Every character of the book's text — prose, headings, statement labels, bylines, Wolfram Language inputs, outputs and messages, the title cell and the text of the figures — occurs inside at least one supervised response. An input, output or paragraph longer than 6,000 characters is cut into consecutive pieces at clean places — after a comma, or before a plus or minus sign, at the outermost bracket level available (after a sentence, in prose) — and the pieces are chained: a long result is asked for first ("give its beginning"), and each later piece is asked for with the input and the end of the piece before it, so every piece stays tied to the input it belongs to. Put back together, the pieces are the book's text exactly.

Plot data as training text

Every number the notebooks store for the plots and sounds is also written out as text, so that a model trained on this dataset sees the numbers themselves and not only descriptions of them: 14,812,847 points, 16,445,947 faces, 313,577 mesh lines, 14,812,847 normals, 661,334 2D curve points, 1,533,074 sound samples (1,930 graphics). For each graphic:

• points — the (x, y, z) points Mathematica computed, one {x, y, z} per line, in the order stored;
• faces — one line per face, giving the points that bound it by their numbers in the point list, counted from 1 as Mathematica numbers them;
• mesh lines — one line per mesh line, the point numbers it passes through;
• normals — the surface normal stored for each point, in point order;
• curve points — for 2D plots, the {x, y} points of each curve in the order Mathematica draws them;
• samples — for the 26 sounds whose samples the notebook stores, every sample in time order (complex samples as a + b I, ComplexInfinity where the notebook has it, and values beyond the 64-bit range exactly as written);
• plot settings — the stored plot range, viewpoint and box ratios.

Every number is written with the shortest decimal that reads back to the same 64-bit value, in Wolfram Language notation (1.5*^-7, 2.); reading the text back gives the stored arrays exactly. A long list is cut into consecutive pieces of at most 6,000 characters (14,000 in the pretraining records), at line ends; the first piece is asked for with the graphic's command, each later piece with the command's opening and the end of the piece before it, and every request carries a tag [graphic id; list; piece k of n; range]. Numbers computed here rather than stored in the notebooks — the samples of the 18 sounds computed from their stored functions, the surfaces of Manipulate panels computed at their saved slider settings, waveform lines and spectrograms — are not written as text; they stay in plot_coordinates/. These files hold 1,254 MB compressed; they are kept apart from the book text so a trainer can include them, weight them or leave them out. 5% of the graphics (chosen by SHA-256 of the id) are in the validation files.

The graphics

2,080 graphics in all: 1,532 3D plots and 431 2D plots with stored coordinates (55 of the 3D plots and 4 of the 2D plots are empty boxes: in the plotted range Mathematica found nothing to draw, so they hold no coordinates), 46 sounds, 42 interactive Manipulate panels, 29 embedded pictures (one of them stored as a PDF in Mathematica's legacy form).

The notebook stores each plot as numbers: the (x, y, z) points Mathematica computed on the surface, the faces that join them, the mesh lines drawn over it, and the surface normals (the direction perpendicular to the surface at each point, used for shading); a 2D plot stores the points of its curves. Inside the .nb files these are packed into compressed blocks. All of them were decoded exactly — 187,653,108 numbers in all — and checked against a second, independent decoding of the notebooks (points, normals, faces, mesh lines, every sample point, every STL triangle and every sound sample match exactly).

• Pairing with commands. In a Mathematica notebook an input puts its results in the Output cells right below it, one Output cell for each statement that returns something (a statement ended by a semicolon, a definition made with :=, Clear[...] and Print[...] return nothing). The pairing follows that rule: the k-th Output cell under an input belongs to the input's k-th statement that returns something, and that statement is the graphic's command (with the whole input in command_cell_text when it holds more statements), relation: "output"; command_match says how the match was made. 1,863 graphics were matched this way. When an input has more Output cells below it than statements (Mathematica keeps outputs of earlier versions of a command when the command is edited), the input's plotting statement is used, and the equation test below shows which of those outputs its points actually satisfy. A command counts only if it can have drawn the graphic (a 3D plotting function for a 3D graphic, a 2D one for a 2D graphic, Play or Sound for a sound); a function the author defined, Graphics[...] and Show[...] fit any graphic. A graphic pasted into an Input, Text or other cell is placed_after, with the nearest plotting command within the six cells before it in the same section (kernel message cells are not counted); with no plotting command nearby it is figure, or unattributed for an Output cell (39 of these are Output cells with no input above them at all: the notebook keeps the picture without the command that made it, as in the paper "Math to Art"). 426 graphics hold coordinates identical to an earlier one and carry same_data_as.
• Equation test of every pairing (command_check in the index). For each graphic paired with its command, the command's expression was evaluated at the stored points — with the values the notebook gave its symbols before the plot (x = …, x := …, removed by Clear[...]) — and compared with what the plotting function draws there: the height for Plot and Plot3D, the distance from the origin at the point's angle for PolarPlot and SphericalPlot3D, the height at the point's distance from the axis (and angle of rotation) for RevolutionPlot3D, lhs − rhs = 0 or a few constant levels for ContourPlot3D, the boundary of the region for RegionPlot3D. 1,401 graphics are verified (at least half of the stored points satisfy the command to within 10⁻⁶ of the plot's extent, or nine in ten points are accounted for, counting the points Mathematica places on the faces of its plot box when it cuts a surface off and the points within 1% that it places where the expression stops being real); 113 are partly matched; 17 are not matched (their points do not satisfy the command as evaluated here — a different notebook state when the plot was made, or an output kept from an earlier version of the command; these are left out of the command-to-graph and graph-to-command examples); 239 are not checkable, with the reason given (a symbol the notebook defines only through other plots or nowhere, a ParametricPlot, values beyond the range of 64-bit numbers, a curve that changes with the angle of rotation). Mathematica reads RevolutionPlot3D[{r(t), z(t)}, …] — a pair of expressions — as one curve turned about the axis, with r(t) its distance from the axis and z(t) its height; the 87 plots written that way are described and tested as such.
• Descriptions computed from the coordinates. What the stored coordinates mean for the plotting function (for SphericalPlot3D the distance of each point from the origin is the absolute value of the expression; for RevolutionPlot3D the height is the expression and the distance from the axis is the first variable; for ContourPlot3D the points lie where the expression is at a contour level; for Plot the height of the curve is the value); point, face and mesh-line counts; the extent along each axis, and whether the box Mathematica displays (the stored PlotRange) cuts the surface off; the highest and lowest values and where they occur; for Plot3D how much of the variable rectangle the surface covers, with a character map of where it exists; the share of near-vertical walls; how many separate pieces the surface has after coincident points are merged and whether each is open (with how many edge loops) or closed; for Plot curves the stretches where the curve exists and where it crosses zero; and the reflections that map the points onto themselves.
• Sample points are actual stored points: one per cell of a 4 × 4 × 4 grid over the surface's extent (at most 48), or the nearest stored point to each node of a 7 × 7 grid for Plot3D; at most 24 along a 2D curve. SphericalPlot3D and RevolutionPlot3D rows add the point's distance from the origin or the axis. In written tables a value below 10⁻⁹ of its column's largest value is shown as 0; the index keeps the exact numbers.
• Images. Plots are drawn from their own coordinates, with the stored viewpoint, plot range and box ratios, and the surface cut at the plot box as Mathematica does. Embedded pictures are kept exactly as stored (not flipped); 10 are construction diagrams of the circle folded into a cone, captioned with what is drawn (4 of them are pixel-for-pixel copies of an earlier one), and 19 are screenshots of animation and Manipulate panels. The 42 Manipulate and Animate panels hold no plotted points in the notebook, only the slider settings they were saved with. For 37 of them the surface the panel shows at that setting is computed here from its command, with the values the notebook gave its other symbols before the panel, and kept like a stored surface — coordinates, STL file and picture — marked coordinates_origin: "computed here …" and described as computed (Mathematica samples adaptively and may cut the range differently; for a ContourPlot3D without an equation, the three levels are put at a quarter, half and three quarters of the range of the values on the grid, as Mathematica places its default levels over the values it samples). For the other 5 the surface cannot be computed, for the reason given in computed_surface_not_made (a range that is not a number; r (defined in terms of itself); the expression has no real values in the plotted range at those settings). 7 graphics have no image: those 5 panels and 2 sounds stored only as a note (SoundNote).
• STL files (plot_stl/). Each 3D surface (1,514 graphics; 1,169 files, since a surface identical to an earlier one points to that one's file) as a binary STL file: every stored face, split into triangles from its first point, with the stored coordinates as 32-bit floats and nothing cut off at the plot box. A surface whose points reach far outside its plot box therefore looks larger in a 3D viewer than in the picture; the exact float64 coordinates are in the .npz file.
• Sounds. 46 outputs of Play and Sound are sounds. Mathematica stores a sound made by Play as the function that computes its samples (Play's compiled sample function, which the notebook also writes out in Wolfram Language), and stores the samples themselves only after the sound has been played in the notebook. For 26 sounds the notebook stores every sample; for 18 it stores only the function, and the samples here are that function evaluated for samples 1 to n exactly as written, operation by operation. The same evaluation reproduces the 26 stored sounds to within 6e-09 of their largest value, so the computed samples are the ones Mathematica plays; a second, independent evaluation of the stored functions (with sympy, which orders the arithmetic its own way) agrees with them to within 10⁻⁴ of their largest value — below the 16-bit resolution of the WAV files — except for the rounding-error sound described next. 3 sounds (soi-plot-1898, soi-plot-1900, soi-plot-1901) are an exception: in exact arithmetic their function is a fixed value (it contains 16π³/(4π − θ)² − 4π²/(4π − θ) − 4π²θ/(4π − θ)², which is 0), so the sound is the rounding error of the computer arithmetic, scaled up by Play; computed again with about 19 significant digits instead of 16 their samples change completely, and each says so in its description. samples_from tells which samples are stored and which are computed; sound_function holds the function as stored. Play rescales a real-valued sound — its function ends by adding an offset and multiplying by a factor, which puts the values between −1 and 1 — and does not rescale a complex-valued one (it adds 0 and multiplies by 1). The WAV files follow that: a real sound is written at Play's own scale, −1 to 1 being full volume, with the few values beyond it (near a point where the function divides by zero) clipped at full volume; a complex sound (10 of them) is a stereo file, its real part in the left channel and its imaginary part in the right, on one scale with full volume at the 99.9th percentile of the sizes of the parts (the larger samples, near a point where the function grows without bound, are clipped). Samples the notebook stores as ComplexInfinity (DirectedInfinity[], where the function divides by zero; 2 sounds have them) are marked in complex_infinity, stored as infinity, and sound at full volume. Values the notebook writes beyond the range of 64-bit numbers (1 sound, up to 10^2421) are kept exactly as written in beyond_double_real_text / beyond_double_imag_text, and the WAV scale is computed from them exactly. The 2 sounds made by SoundNote (a note, its length and its instrument, with no samples) are MIDI files, which play through any synthesizer, plus a WAV of a plain tone at the note's pitch and length. The .npz file of a sound holds sample_real and sample_imag, the waveform line and the spectrogram picture the player displays (waveform_points, spectrogram); the image of a sound is its stored waveform line.
• The PDF figure. One figure, in part 2 (paper "Parker' s Commentary on Fermat' s Last Theorem", section "Form and Formality"), is stored inside a text cell in Mathematica's old GraphicsData["PDF"] form: a whole PDF file written in Mathematica's 6-bit text encoding (each character stands for six bits, counted from the character 0, with / standing for the backslash). It was decoded to the PDF itself (plot_pdf/soi-plot-1814.pdf, one page, made in 2010) and rendered at 200 dpi for its image. It is the diagram the text introduces as the one Gibson referred to: Figure 28 of James J. Gibson's The Perception of the Visual World (1950), "A Picture-Gradient, its Retinal Gradient, and the Longitudinal Surface Corresponding to Both"; its caption and labels are transcribed into the book text after it.
• Coordinates files (plot_coordinates/*.npz, NumPy): points (N × 3), face_sizes and face_indices (faces as runs of 0-based point indices), mesh_line_sizes and mesh_line_indices, normals (N × 3); 2D curves carry curve_points and curve_stroke_sizes (and region_points/region_polygon_sizes for filled regions).

import numpy as np
z = np.load("plot_coordinates/soi-plot-NNNN.npz")
pts, sizes, idx = z["points"], z["face_sizes"], z["face_indices"]
faces = np.split(idx, np.cumsum(sizes)[:-1])      # each face as an array of point indices

Pretraining corpus

Each text record is one paper or section, prefixed with the book, part, paper and section it belongs to:

The Scraps of Imagination by Parker Emmerson (Yaohushuason)
Part 1.1
Paper: "Conic" Relativity: Expositions of Relativity through Difference in Circumferences of Two Circles

…

Papers longer than about 14,000 characters are split into records numbered "(part k of n)". An input and its output stay in one record when they fit; an output too long for one record is cut into pieces, and a record that begins inside an output first repeats the input it belongs to (quoted by its opening and its end when the input itself is longer than 3,000 characters, which the record says), so every piece of a long result is tied to its input. The longest record is 17,765 characters; no record has to be dropped or cut for length. The plot and sound numbers have their own pretraining records in plot_data/ (see above).

Loading

from datasets import load_dataset
ds = load_dataset("json", data_files={"train": "sft_openai_chat/The_Scraps_of_Imagination_sft_openai_chat_train.jsonl",
                                      "validation": "sft_openai_chat/The_Scraps_of_Imagination_sft_openai_chat_validation.jsonl"})
pt = load_dataset("json", data_files="pretraining/The_Scraps_of_Imagination_pretraining_corpus.jsonl")
numbers = load_dataset("json", data_files="plot_data/The_Scraps_of_Imagination_plot_data_sft_openai_chat_train_*.jsonl.gz")

OpenAI fine-tuning: upload sft_openai_chat/…_train.jsonl as the training file and …_validation.jsonl as the validation file. Axolotl: type: sharegpt on the ShareGPT file, or type: alpaca on the Alpaca file; type: completion on the pretraining file (field text). LLaMA-Factory: register the Alpaca file with columns instruction, input, output, system; for images, register vision_llava/…_train.json as a ShareGPT-style dataset with images from the image field (paths are relative to the dataset root).

Changes from rev2

rev2 is not replaced; this revision adds everything the book holds that rev2 left out of the training examples.

• Mathematica's messages. The 597 messages the notebooks record (kernel Message cells) were left out of rev2; they are now in the text after their input, as Message: … lines, and in the evaluation examples. Messages are shown as Mathematica shows them, Symbol::tag: text, with the expressions inside them converted like the rest of the text (Power::infy: Infinite expression 1/(0. + 0. i) encountered.).
• Title, bylines and labels as written. The book's title cell ("The Scraps of Imagination: A Catalog of Spatio Angular Aberations and Anomalies", the first cell of part 1.2) and the 11 bylines under the papers were left out of rev2 as being carried by the dataset itself; they are now in the text where they stand. The subtitle is in the system message and in every pretraining record. Headings and statement labels keep the author's punctuation (rev2 wrote Theorem 4: as Theorem 4., Preface: as Preface and Theorem 3 Continued as Theorem 3 (continued).), and paper headings now also open the paper's own examples, so they are in the answers as well as in the requests.
• The PDF figure. The figure stored as a PDF (above) was a placeholder in rev2; it is decoded, has an image and vision examples, and its caption is in the text.
• Plot and sound numbers as text. Every number the notebooks store for the plots and sounds is written out in plot_data/ (above).

Changes in rev2 (from rev1)

• Every part of the book is in the supervised examples. In rev1, inputs and outputs too long for a single example (12,000 characters), and the pieces of papers around them, were in no supervised response — 42% of the text by characters. They are now cut into chained pieces as described above, and every character of the text is covered. Pretraining records that begin inside a long output now repeat its input; rev1 had 32 records over 21,000 characters flagged for dropping, and this revision has none.
• Sounds. rev1 kept samples only for the 26 sounds whose samples the notebook stores, wrote the WAV from the real part alone (four complex sounds whose real part is constant came out silent), stored ComplexInfinity samples as NaN and wrote them silent, and lost the values beyond the 64-bit range. Now the other 18 sounds are computed from their stored functions, complex sounds are stereo, ComplexInfinity is marked and sounds at full volume, the large values are kept exactly, real sounds use Play's own scale, and the two notes are MIDI files.
• Pairing. Graphics are now paired with the statement that produced them (Mathematica's rule of one Output cell per statement that returns a result), commands inside assignments (hypocycloid = ParametricPlot[...]), inside a product, in Animate[...], Graphics[...] and functions the author defined are recognized, and a command must be able to draw the graphic. Every pairing is tested against the stored points. RevolutionPlot3D pairs {r(t), z(t)} are read as Mathematica reads them, a curve turned about the axis (rev1 described 87 of them as two surfaces).
• Panels. The Manipulate and Animate panels had no picture in rev1; 37 now have the surface they show at their saved setting, computed from their command and marked as computed.
• Text. Bars and hats over letters are written as OverBar[AB] and OverHat[r] (rev1 wrote AB^{_} and r^), and numbers written with a power of ten (1.2*^-5) are read to the nearest 64-bit value (rev1 could be off in the last binary digit).

How the conversion was made

• The notebooks were parsed as expression trees: cell styles give the structure (paper titles, sections, subsections, theorem, lemma and proof cells, text, formulas, Input and Output cells); box forms (RowBox, FractionBox, SqrtBox, SuperscriptBox, …) were converted to linear Wolfram Language (a bar or hat set over letters, as in the segment notation AB with a bar, is written OverBar[AB] or OverHat[r], as Mathematica writes it in InputForm); named characters to Unicode; a backslash at the end of a line outside a string was read as a line continuation. Input cells in which the author typed sentences are kept as text. Kernel message cells are kept and shown as Mathematica shows them (Symbol::tag: text), and so are the bylines. Strings are decoded left to right in one pass (an escaped backslash stays a backslash), and formatted mathematics kept inside a string — Mathematica's linear syntax \!\(\*…\), also inside a quoted string within a string, as messages have it — is converted to text like the rest of the cell.
• The three files are the parts "Part 1.1", "Part 1.2" and "Part 2", named after the files; within each, every Title cell begins a paper. Material in part 1.2 before its first Title cell stands under the part's own heading.
• The compressed blocks hold packed arrays of types e (64-bit reals), n (32-bit integers) and b (bytes); all were decoded. Numbers written out in the notebook text instead (some curves, plot ranges and sound samples) were read as decimal numbers, each to the nearest 64-bit value, exactly as Python's own float() reads them.
• Approximate token counts in the manifest are character-based (about 3.3 characters per token for this mixed prose and code).

Citation

@book{emmerson_scraps_of_imagination,
  author = {Emmerson, Parker (Yaohushuason)},
  title  = {The Scraps of Imagination: A Catalog of Spatio Angular Aberations and Anomalies},
  note   = {Independent Researcher. ORCID 0009-0007-1288-3292}
}

Changes from The_Scraps_of_Imagination_LLM_Training_Dataset_rev3: every file reachable by the Parquet conversion

The_Scraps_of_Imagination_LLM_Training_Dataset_rev4 is The_Scraps_of_Imagination_LLM_Training_Dataset_rev3 with files added and the card's configs extended, so that the Hugging Face Parquet converter (the "parquet-converter" bot, which builds the dataset viewer and the refs/convert/parquet branch from the configurations a card declares) reaches every piece of content in the repository. No file of The_Scraps_of_Imagination_LLM_Training_Dataset_rev3 was removed or changed except the OpenAI-layout vision files named below, which were rewritten in place with the same content. Upload the folder of The_Scraps_of_Imagination_LLM_Training_Dataset_rev3 and this folder into the same repository; this README replaces the previous one.

What was added:

• images configuration: the 2073 pictures under images/ are now an image dataset (the pictures themselves become an image column in the Parquet conversion), with images/metadata.jsonl giving each picture's vision questions and answers.
• sounds configuration: the 46 WAV files under sounds/ are now an audio dataset, with sounds/metadata.jsonl giving each sound's command and description.
• midi_notes configuration: the 2 MIDI files as rows with their bytes base64-encoded.
• coordinates configurations: the arrays of all 1985 .npz coordinate files (187,984,263 numbers) as rows of JSON lists — one row per graphic, one entry per array (name, dtype, shape, values as numbers — integers exactly, as the dtype column records — and text_values_json, a JSON list, for the few arrays of strings) — so the exact coordinates are in the Parquet conversion as numbers, not only as the text of the plot-number files. The .npz and STL files stay as they were.
• documents configuration: the 1 Markdown and text files of the folder (The_Scraps_of_Imagination_full_text.md) as rows with their full text. A document longer than the viewer's cell limit is still complete in the Parquet file.
• The undivided files pretraining/The_Scraps_of_Imagination_pretraining_corpus.jsonl, sft_alpaca/The_Scraps_of_Imagination_sft_alpaca.json, sft_openai_chat/The_Scraps_of_Imagination_sft_openai_chat.jsonl, sft_prompt_completion/The_Scraps_of_Imagination_sft_prompt_completion.jsonl, sft_sharegpt/The_Scraps_of_Imagination_sft_sharegpt.jsonl, vision_llava/The_Scraps_of_Imagination_vision_llava.json hold the same rows as their _train and _validation parts together and stay undeclared, so no row is converted twice.
• vision_openai_chat configuration: vision_openai_chat/The_Scraps_of_Imagination_vision_openai_chat_train.jsonl, vision_openai_chat/The_Scraps_of_Imagination_vision_openai_chat_validation.jsonl — rewritten so that every message content is a list of parts, which the Parquet conversion requires of one column.
• files configuration: the manifest as a table — every file of the revision with its size and SHA-256.

New files:

File	What it holds
images/metadata.jsonl	one row per picture (2073): file name, the vision examples asked about it (questions and answers), and the earlier metadata columns where the folder had them
sounds/metadata.jsonl	one row per sound file (46): file name, the graphic it belongs to, its command and description from the plot index
The_Scraps_of_Imagination_midi_notes.jsonl	the 2 MIDI note files as rows (command, description, the MIDI bytes base64-encoded)
coordinates/The_Scraps_of_Imagination_coordinates_part01.jsonl.gz	1205 graphics, every stored array as JSON lists (1.47 GB of text)
coordinates/The_Scraps_of_Imagination_coordinates_part02.jsonl.gz	780 graphics, every stored array as JSON lists (0.99 GB of text)
The_Scraps_of_Imagination_documents.jsonl	the 1 text documents of the folder (full texts, reports, audits) as rows
vision_openai_chat/The_Scraps_of_Imagination_vision_openai_chat_train.jsonl	the OpenAI-layout vision file rewritten so every message content is a list of parts (6538 string contents converted in 3269 rows); the pictures and text are unchanged
vision_openai_chat/The_Scraps_of_Imagination_vision_openai_chat_validation.jsonl	the OpenAI-layout vision file rewritten so every message content is a list of parts (344 string contents converted in 172 rows); the pictures and text are unchanged
The_Scraps_of_Imagination_LLM_Training_Dataset_rev4_files.jsonl	every file of the revision (5307 carried from The_Scraps_of_Imagination_LLM_Training_Dataset_rev3, 8 new) with its size and SHA-256, as rows

What the bot still does not read, and why it is no loss: the .npz coordinate files and the STL files (their numbers are in coordinates); the Markdown and text files (their text is in documents); the manifest (its rows are in files). The pictures and sounds are converted through the images and sounds configurations.

Built 2026-10-30; every new configuration was loaded with the Hugging Face datasets library before this card was written (see the check table).

Loading check of the new configurations

Configuration	Split	Result	Rows	Columns
images	train	loads	2073	5
sounds	train	loads	46	7
midi_notes	train	loads	2	5
coordinates_part01	train	loads	1205	3
coordinates_part02	train	loads	780	3
documents	train	loads	1	4
vision_openai_chat	train	loads	3269	1
vision_openai_chat	validation	loads	172	1
files	train	loads	5315	4