--- pretty_name: The Cone of Perception — LLM Training Dataset (rev5) language: - en license: other license_name: author-controlled license_details: Text, notebooks and pictures of The Cone of Perception, © Parker Emmerson. Terms of use for training are set by the author. task_categories: - text-generation - question-answering - image-to-text - visual-question-answering tags: - mathematics - geometry - philosophy-of-perception - phenomenology - wolfram-language - mathematica - fine-tuning - continued-pretraining - plot-data size_categories: - 100K 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: ```text 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 — ]` 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.25`20.`) 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}]`): ```text 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/_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. ```python 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 ```python 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 ```bibtex @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 |