PlanetCrash/The_Cone_of_Perception_LLM_Training_Dataset

The Cone of Perception — LLM Training Dataset (rev5)

Author: Parker Emmerson (Yaohushuason), Independent Researcher, ORCID 0009-0007-1288-3292, Parkeremmerson@icloud.com

Book: The Cone of Perception, 4th Edition: The Geometric Pattern of Perception Theorems: Visualization, Surfaces, and Geometry, with the front-matter essays and the three essays at the back.

This folder holds the whole book as training data for language models. Training data here means text in the file layouts that fine-tuning and pretraining tools read. Everything comes from the book's own sources: the Mathematica notebook of the book, the companion notebook The Large Printout Theta Solution, and the two PDF files of the printed edition. Nothing is summarized, paraphrased or written in the author's place. The only words that are not the book's own are the questions put to the model, short marker lines that say where a picture or graphic stands, and the transcriptions of the text inside pictures.

What is in it:

• every paragraph, footnote, bibliography entry, caption, title, subtitle, byline and heading, as written;
• every formula, every Mathematica input and every output in full, however long, and every Mathematica message (a message is the warning text Mathematica prints under an input, such as Solve::ifun: …), placed right after its input;
• the text inside every picture, transcribed, and the picture files themselves;
• every number stored in the book's 476 graphics: 72,725,380 numbers in 34,868 arrays, plus 1,080,330 numbers that stand inside the graphics' box expressions themselves (short lists, such as the shorter mesh lines, and settings such as plot range, viewpoint and box ratios), each written so that it reads back to exactly the stored value.

Where each part of the book comes from

Part of the book	Units	Source
Front matter	2	printed edition, first PDF: the cover picture and the table of contents
Introduction to the 4th Edition	8	printed edition, first PDF (text layer)
The Meaning of Now	29	printed edition, first PDF (text layer)
The Geometric Pattern of Perception Theorems: Visualization, Surfaces, and Geometry	2,121	the book's Mathematica notebook, cell by cell
The Geometric Pattern of Perception Theorems: Visualization, Surfaces, and Geometry (printed edition only)	94	printed edition: the pages at the end of the mathematics that the notebook does not hold
The Large Printout Theta Solution (companion notebook), cells not in the printed edition	36	the companion notebook
Mathematical Analysis in Ecological Optics: Mathematical, Theoretical Applications to The Work of James J. Gibson	207	printed edition, second PDF (text layer, with its font maps repaired)
Theories of Perceptual Philosophy and their Correlations	233	printed edition, second PDF (text layer, with its font maps repaired)
Theory of Consciousness, Perception and Visionary Experience	66	printed edition, second PDF (text layer, with its font maps repaired)

A unit is one piece of the book in reading order: one notebook cell, or one printed paragraph, heading, footnote, quotation, caption or bibliography entry. The book has 2,796 units; The_Cone_of_Perception_book_units.jsonl lists them all, and every training file is built from them.

Files

Every file name starts with the book's name. Each training file comes as a full file and as its two parts, _train and _validation.

Folder or file	What it holds	Records (full file)
sft_openai_chat/	supervised examples in the OpenAI chat layout: {"messages": [system, user, assistant]}	3,576
sft_sharegpt/	the same examples in the ShareGPT layout: {"id", "conversations": [system, human, gpt]}	3,576
sft_alpaca/	the same examples in the Alpaca layout, a JSON array of {"id", "instruction", "input", "output"}	3,576
sft_prompt_completion/	the same examples as {"id", "prompt", "completion"}	3,576
The_Cone_of_Perception_sft_metadata.jsonl	one line per supervised example: id, split, task, the unit it comes from, piece number	3,576
pretraining/	the book as plain-text records of at most 14,000 characters, {"id", "text", "meta"}	101
plot_numbers/The_Cone_of_Perception_plot_numbers_chat*.jsonl.gz	every stored number of every graphic, as chained chat examples (gzip-compressed JSON lines)	188,440
plot_numbers/The_Cone_of_Perception_plot_numbers_pretraining*.jsonl.gz	the same numbers as pretraining records	84,551
plot_numbers/The_Cone_of_Perception_plot_index.jsonl	one record per graphic: where it stands, the input that made it, its arrays, counts, and its picture files	476
plot_coordinates/	one NumPy .npz file per graphic with its stored arrays, exact	476 files
images/printed/	pictures of the printed edition, and page crops of graphics printed as line drawings	573 files
images/notebook/	pictures stored in the notebooks	25 files
images/drawn/	drawings computed from each graphic's stored numbers — not pictures from the book	459 files
vision_llava/	vision examples in the LLaVA layout (picture paths relative to this folder)	1,106
vision_openai_chat/	the same vision examples in the OpenAI layout, picture inline as base64 JPEG (longest side 1,024 pixels)	1,106
The_Cone_of_Perception_book_units.jsonl	the whole book as 2,796 units in reading order	2,796
The_Cone_of_Perception_full_text.txt	the whole book as one text file	—
The_Cone_of_Perception_dataset_manifest.json	every other file with its size, SHA-256 and record count	—

The supervised examples

The system message of every chat example is:

You reproduce The Cone of Perception by Parker Emmerson exactly as written: its prose, statements, proofs, Mathematica inputs and outputs, and the numbers stored in its graphics.

Task	Training examples	Validation examples	What the model is asked
book_sequence	2,818	0	to give the next unit of the book; the prompt names the part, the section and the source page or cell
input_to_output	653	0	given a Mathematica input from the book, to give the output and messages the book records
statement	74	0	to state a named theorem, lemma or definition word for word
book_sequence_shifted	0	31	to continue the book from a point partway through a unit (a copy of text that is also in the training examples)

Long texts are cut into chained pieces. No answer is longer than about 6,000 characters (the longest is 5,992). A longer unit is cut into pieces at clean places: Mathematica text after a comma or before a + or - at the outermost bracket level, prose at the end of a sentence, number lists at the end of a line. Piece 1 is asked for like any unit; each later piece is asked for with the last few hundred characters of the piece before it, so the model learns to continue. Joining the pieces in order gives the unit back exactly. A later piece is asked for like this:

The Cone of Perception by Parker Emmerson. The Geometric Pattern of Perception Theorems: Visualization, Surfaces, and Geometry › The Geometric Pattern of Perception Theorems › XV. Woven Velocity Patterns. Source: Mathematica notebook, cell 1062.

This text is long, so it is given in 5 consecutive pieces; give piece 2. Piece 1 ended with:
…qrt[3] √(- 256 π^3 r^6 v^6 θ^3 + 192 π^2 r^6 v^6 θ^4 + 432 π^2 r^4 v^8 θ^4 - 48 π r^6 v^6 θ^5 - 216 π r^4 v^8 θ^5 + 4 r^6 v^6 θ^6 + 27 r^4 v^8 θ^6)))^(1 / 3))},

Picture and graphic markers. Where a picture stands in the book, the text has a line [Picture <file> — <where>] followed by Text in the picture: and its transcription. Where a graphic stored as numbers stands, the text has [Graphic cone-plot-NNNN — a Graphics3DBox stored as numbers in the notebook; every stored number is in the plot-number files under cone-plot-NNNN], then how the printed edition shows it (its picture file and the text in it, or, for graphics the printed edition draws as lines, the tick labels read from the page).

The pretraining corpus

pretraining/ holds the book in reading order as 98 training records of at most 14,000 characters (the longest is 13,999). Units are never cut, except the few that are longer than a record; those are cut into pieces as above, and a piece that starts partway through an output first repeats the input that made it. The 3 validation records are copies of windows of training records, each starting at the beginning of a unit.

How the split into training and validation is made

The split is deterministic: the same files always give the same split. All of the book's content is in the training part. The validation part holds copies: a fixed sample of units, chosen by the SHA-1 hash of the unit's id (one in twenty), asked for from a point partway through, and for the graphics, a window of the training pieces of one graphic in twenty. The full file is exactly the training part plus the validation part (checked, see below).

The numbers stored in the graphics

Mathematica stores each graphic of the notebook as numbers: the points of a surface, the faces that join them, the mesh lines drawn on it, the surface normals (the direction perpendicular to the surface at each point, used for shading), colours, curve points, and the graphic's settings. All of them are written out, for every graphic, in plot_numbers/.

Each graphic is written as one text:

1. the box expression — the graphic as the notebook stores it, with every option — where each stored array is replaced by a placeholder ‹A1›, ‹A2›, …;
2. then every array in full, under a heading that names it and says what it holds, one row per line (long rows and flat lists are broken every 12 numbers).

Putting the arrays back in place of the placeholders gives the complete graphic. Faces and mesh lines are lists of point numbers counted from 1, as Mathematica stores them. Each number is written as the shortest decimal that reads back to exactly the stored 64-bit value, in Mathematica's notation (1.5*^-7 for 1.5×10⁻⁷, 2. for the real number 2, -0. for negative zero); integers are written as integers; a number stored with an explicit precision (such as 1.2520.) is kept as written. The notebook's own line wrapping is undone; everything else in the box expression stands as the notebook stores it (for example PlotRange->NCache[{{Rational[-1, 2] Pi, Rational[1, 2] Pi}, …}]`). Picture pixels are not written as numbers: the placeholder names the picture file that holds them.

In the chat files, piece 1 of a graphic is asked for with the input that made it; each later piece is asked for with the end of the piece before it; no piece is longer than 6,000 characters. In the pretraining files each record starts with a heading line and the input that made the graphic, and is at most 14,000 characters. The 476 graphics come to 1,123,790,954 characters of text.

Numbers by what they hold: faces (point numbers counted from 1): 27,897,308; points (vertex coordinates): 20,950,608; surface normals: 20,946,876; mesh lines (point numbers counted from 1): 2,825,741; 2D curve points: 89,994; vertex colors: 14,853.

Here is the start and the end of piece 1 of graphic cone-plot-0071 (the plot of Plot[(4 / 3)π(r)^ 3, {r, - 1, 1}, AxesLabel → {radius, volume}]):

Graphic cone-plot-0071 as stored in the notebook. Box expression (each ‹An› stands for array An, written out in full below):
GraphicsBox[{{}, {}, {Hue[0.67, 0.6, 0.6], LineBox[‹A1›]}}, AspectRatio->NCache[GoldenRatio^(-1), 0.6180339887498948], Axes->True, AxesLabel->{FormBox["radius", TraditionalForm], FormBox["volume", TraditionalForm]}, AxesOrigin->{0, 0}, PlotRange->{{-1, 1}, {-4.188789691873325, 4.188789691873325}}, PlotRangeClipping->True, PlotRangePadding->{Scaled[0.02], Scaled[0.02]}]

‹A1› 2D curve points, 446 rows of 2 numbers:
{{-0.9999999591836735, -4.188789691873325},
{-0.9993865641588807, -4.181086270461458},
…
{-0.11682893111580926, -0.006679436403336131},
{-0.11192720107977672, -0.005873480622515732},

plot_coordinates/<book>_cone-plot-NNNN.npz holds the same arrays as NumPy arrays named A1, A2, … (64-bit reals, or integers). An array that is a literal list in the notebook also has An__rows (the length of each row); numbers stored with an explicit precision are in An__text as written.

import numpy as np
z = np.load("plot_coordinates/The_Cone_of_Perception_cone-plot-0071.npz")
print({k: z[k].shape for k in z.files})

Pictures

• images/printed/: the pictures of the printed edition. Where the PDF stores the picture as a JPEG or PNG and shows it as stored, the stored bytes are kept; where the PDF shows it flipped or with a transparency mask, the picture is written as a PNG of what the page shows. 31 graphics are printed not as pictures but as drawings made of lines and text; for those the folder has a crop of the page, rendered at 150 dots per inch, and their tick labels were read from the PDF's text layer.
• images/notebook/: the pictures stored in the notebooks, with their exact pixels.
• images/drawn/: 459 drawings computed from the stored numbers of a graphic. They are not in the book; they were made to pair each graphic's numbers with a picture, and the vision examples that use them say so.

The vision files hold 566 examples for the book's pictures, 32 for the page crops of printed drawings and 459 for the computed drawings (1,057 training examples, 49 validation copies). Each asks which graphic or figure the picture is, what input made it, and what text is in it.

Loading

from datasets import load_dataset
sft = load_dataset("PlanetCrash/The_Cone_of_Perception_LLM_Training_Dataset", "sft_openai_chat")
pt = load_dataset("PlanetCrash/The_Cone_of_Perception_LLM_Training_Dataset", "pretraining")
plots = load_dataset("PlanetCrash/The_Cone_of_Perception_LLM_Training_Dataset", "plot_numbers_chat")
# or from this folder:
sft = load_dataset("json", data_files={"train": "sft_openai_chat/The_Cone_of_Perception_sft_openai_chat_train.jsonl",
                                       "validation": "sft_openai_chat/The_Cone_of_Perception_sft_openai_chat_validation.jsonl"})

OpenAI fine-tuning: upload sft_openai_chat/…_train.jsonl as the training file and …_validation.jsonl as the validation file (the plot-number chat files and the vision chat files use the same layout). Axolotl: type: sharegpt on the ShareGPT files, type: alpaca on the Alpaca files, type: completion (field text) on the pretraining files. LLaMA-Factory: register the Alpaca files with columns instruction, input, output; for pictures, register vision_llava/…_train.json with images taken from the image field.

Checks that were run, and their results

Check	Result
1. Every character of every unit occurs in some training answer, tested with a window of 24 characters	949,078 characters tested; 0 left out
Chained pieces joined in order give each unit back exactly	2,784 of 2,784 units
Longest training answer / longest pretraining record	5,992 / 13,999 characters; no record marked long
Leftover notebook codes (\!, \*, RowBox, StyleBox, TemplateBox, private-use characters, …)	none
2. The plot numbers read back from the chat files and from the pretraining files equal the coordinate files, bit for bit	chat: 476 of 476 graphics; pretraining: 476 of 476; 72,725,380 numbers
2. A deliberately changed digit is caught	3 of 3 changes caught
3. A second decoder, sharing no code with the first, read the notebooks again; its arrays equal the coordinate files	book notebook: 466 graphics, 33,118 arrays, 0 differences; companion: 10 graphics, 1,750 arrays, 0 differences
3. Picture pixels in the notebooks equal the picture files	17 pictures, 18,612,750 pixel values, 0 differences
3b. Every number of every graphic, settings included, in order, equals the notebook file	73,805,710 numbers in 476 graphics; 0 graphics differ
3c. Every graphic's box expression equals the notebook text, apart from whitespace, the spelling of numbers and the arrays	0 of 476 differ
4. The Hugging Face datasets library loads every data file	30 of 30 files
4. Training and validation parts together are exactly the full file	9 of 9 files
4. The manifest lists every file with its SHA-256	written last; every file listed

What is not in the training text, and why

These are left out of the training text on purpose:

• The printed edition's running headers, page numbers and the footer line "Printed by Mathematica for Students": page layout, not text of the book.
• The pixels of pictures, as numbers: each picture is given as a file, and the text inside it is transcribed.
• Faint mirror-image text that shows through from the back of the page in four scanned figures reproduced from other books (three in the essays, one stored in the notebook): it cannot be read, and it is the other book's text, not this book's.
• The notebooks' bookkeeping — window settings, cell change times, fonts and similar formatting options of cells: not text of the book. Every option inside a graphic is kept.

These are in the training text exactly as the sources have them, and are named here so that they are not mistaken for conversion errors:

• Four places where the author typed a line break inside a numbered formula, and one tab inside an input, are kept as typed; in the text of inputs and outputs, numbers that carry Mathematica's trailing backtick (its mark for a machine-precision number), such as 1.`, are kept as stored.
• The book's own text names places in a few spots — publishers in its bibliographies and footnotes, and the life of a philosopher in one essay. That text is kept as written. No file gives any location for the author.

Changes from The_Cone_of_Perception_LLM_Training_Dataset_rev3

An audit of rev3 against the same yardstick — the book's text plus the text inside its pictures — found that rev3's answers left out 183,831 of 822,852 characters. rev4 leaves out 0.

Part of the book	Whole book (characters)	Characters left out of every answer in rev3	Share left out in rev3	Characters left out in rev4
Essays at the back (Gibson essay, Theories of Perceptual Philosophy, consciousness essay)	264,112	9,363	3.5%	0
Mathematica outputs	228,694	98,602	43.1%	0
Mathematica inputs	166,302	3,476	2.1%	0
Text inside pictures	64,204	62,176	96.8%	0
Prose, statements and proofs (notebook)	61,134	1,993	3.3%	0
Front matter essays (Introduction, The Meaning of Now)	14,305	366	2.6%	0
Formulas	11,553	465	4.0%	0
Headings, titles, bylines	6,076	1,210	19.9%	0
Mathematica messages	4,452	4,452	100.0%	0
Cover and table of contents	2,020	1,728	85.5%	0

What changed:

• Mathematica outputs are given in full, however long; rev3 left outputs over 12,000 characters out of its answers. Long texts are now cut into chained pieces of at most about 6,000 characters instead.
• Mathematica messages are placed right after their inputs; rev3 dropped them.
• The text inside every picture is transcribed (the cover, the essays' figures, the printed-only pages, every printed plot); rev3 had captions for ten diagrams only.
• The essays at the back are taken from the PDF's own text layer after repairing its font maps, instead of OCR; footnotes stand where they are referenced, and the bibliographies are included.
• Titles, subtitles, bylines and headings are kept exactly as typed; the cover and the table of contents are included.
• The graphics: rev3 gave computed descriptions and thinned sample points; rev4 gives every stored number exactly, and no number computed by a tool is in any training answer. Drawings computed from the numbers are kept apart in images/drawn/ and marked as computed.
• Graphics that the printed edition draws as lines and text (31 of them) have their tick labels transcribed, with a crop of the page.
• No pretraining record is longer than 14,000 characters; rev3 had one of 97,764.
• Vision examples in the OpenAI layout give every message's content as a list of parts, so that the files load with the datasets library.
• Every file is named after the book; rev3 had picture and coordinate files named only by graphic number.

Citation

@book{emmerson_cone_of_perception,
  author  = {Emmerson, Parker (Yaohushuason)},
  title   = {The Cone of Perception: The Geometric Pattern of Perception Theorems: Visualization, Surfaces, and Geometry},
  edition = {4},
  note    = {Parker Emmerson (Yaohushuason), Independent Researcher, ORCID 0009-0007-1288-3292, Parkeremmerson@icloud.com}
}

Changes from The_Cone_of_Perception_LLM_Training_Dataset_rev4: every file reachable by the Parquet conversion

The_Cone_of_Perception_LLM_Training_Dataset_rev5 is The_Cone_of_Perception_LLM_Training_Dataset_rev4 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_Cone_of_Perception_LLM_Training_Dataset_rev4 was removed or changed. Upload the folder of The_Cone_of_Perception_LLM_Training_Dataset_rev4 and this folder into the same repository; this README replaces the previous one.

What was added:

• images configuration: the 1057 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.
• coordinates configuration: the arrays of all 476 .npz coordinate files (73,553,422 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_Cone_of_Perception_full_text.txt) 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 plot_numbers/The_Cone_of_Perception_plot_numbers_chat.jsonl.gz, plot_numbers/The_Cone_of_Perception_plot_numbers_pretraining.jsonl.gz, pretraining/The_Cone_of_Perception_pretraining_corpus.jsonl, sft_alpaca/The_Cone_of_Perception_sft_alpaca.json, sft_openai_chat/The_Cone_of_Perception_sft_openai_chat.jsonl, sft_prompt_completion/The_Cone_of_Perception_sft_prompt_completion.jsonl, sft_sharegpt/The_Cone_of_Perception_sft_sharegpt.jsonl, vision_llava/The_Cone_of_Perception_vision_llava.json, vision_openai_chat/The_Cone_of_Perception_vision_openai_chat.jsonl hold the same rows as their _train and _validation parts together and stay undeclared, so no row is converted twice.
• sft_metadata configuration: The_Cone_of_Perception_sft_metadata.jsonl — present in the previous revision but not declared, so the bot skipped it.
• 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 (1057): file name, the vision examples asked about it (questions and answers), and the earlier metadata columns where the folder had them
coordinates/The_Cone_of_Perception_coordinates.jsonl.gz	476 graphics, every stored array as JSON lists (1.06 GB of text)
The_Cone_of_Perception_documents.jsonl	the 1 text documents of the folder (full texts, reports, audits) as rows
The_Cone_of_Perception_LLM_Training_Dataset_rev5_files.jsonl	every file of the revision (1566 carried from The_Cone_of_Perception_LLM_Training_Dataset_rev4, 3 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 are converted through the images configuration.

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	1057	5
coordinates	train	loads	476	3
documents	train	loads	1	4
sft_metadata	train	loads	3576	12
files	train	loads	1569	4