Datasets:

PlanetCrash
/

The_Math_of_Liberation_LLM_Training_Dataset

pretty_name: The Math of Liberation — LLM Training Dataset (rev5)
language:
  - en
license: other
license_name: author-controlled
license_details: >-
  Text of The Math of Liberation, © Parker Emmerson (Yaohushuason). Terms of use
  for training are set by the author.
task_categories:
  - text-generation
  - question-answering
  - image-to-text
  - visual-question-answering
tags:
  - mathematics
  - mathematical-physics
  - wolfram-language
  - mathematica
  - 3d-plots
  - stl
  - fine-tuning
  - instruction-tuning
  - continued-pretraining
size_categories:
  - 10K<n<100K
configs:
  - config_name: sft_openai_chat
    data_files:
      - split: train
        path: sft_openai_chat/The_Math_of_Liberation_sft_openai_chat_train.jsonl
      - split: validation
        path: >-
          sft_openai_chat/The_Math_of_Liberation_sft_openai_chat_validation.jsonl
  - config_name: sft_sharegpt
    data_files:
      - split: train
        path: sft_sharegpt/The_Math_of_Liberation_sft_sharegpt_train.jsonl
      - split: validation
        path: sft_sharegpt/The_Math_of_Liberation_sft_sharegpt_validation.jsonl
  - config_name: sft_alpaca
    data_files:
      - split: train
        path: sft_alpaca/The_Math_of_Liberation_sft_alpaca_train.json
      - split: validation
        path: sft_alpaca/The_Math_of_Liberation_sft_alpaca_validation.json
  - config_name: sft_prompt_completion
    data_files:
      - split: train
        path: >-
          sft_prompt_completion/The_Math_of_Liberation_sft_prompt_completion_train.jsonl
      - split: validation
        path: >-
          sft_prompt_completion/The_Math_of_Liberation_sft_prompt_completion_validation.jsonl
  - config_name: vision_llava
    data_files:
      - split: train
        path: vision_llava/The_Math_of_Liberation_vision_llava_train.json
      - split: validation
        path: vision_llava/The_Math_of_Liberation_vision_llava_validation.json
  - config_name: plot_index
    data_files:
      - split: train
        path: The_Math_of_Liberation_plot_index.jsonl
  - config_name: pretraining
    default: true
    data_files:
      - split: train
        path: pretraining/The_Math_of_Liberation_pretraining_corpus_train.jsonl
      - split: validation
        path: pretraining/The_Math_of_Liberation_pretraining_corpus_validation.jsonl
  - config_name: plot_data_sft_openai_chat
    data_files:
      - split: train
        path: >-
          plot_data/The_Math_of_Liberation_plot_data_sft_openai_chat_train_*.jsonl.gz
      - split: validation
        path: >-
          plot_data/The_Math_of_Liberation_plot_data_sft_openai_chat_validation_*.jsonl.gz
  - config_name: plot_data_pretraining
    data_files:
      - split: train
        path: >-
          plot_data/The_Math_of_Liberation_plot_data_pretraining_train_*.jsonl.gz
      - split: validation
        path: >-
          plot_data/The_Math_of_Liberation_plot_data_pretraining_validation_*.jsonl.gz
  - config_name: images
    data_files:
      - split: train
        path: images/**
  - config_name: coordinates
    data_files:
      - split: train
        path: coordinates/The_Math_of_Liberation_coordinates.jsonl.gz
  - config_name: documents
    data_files:
      - split: train
        path: The_Math_of_Liberation_documents.jsonl
  - config_name: vision_openai_chat
    data_files:
      - split: train
        path: >-
          vision_openai_chat/The_Math_of_Liberation_vision_openai_chat_train.jsonl
      - split: validation
        path: >-
          vision_openai_chat/The_Math_of_Liberation_vision_openai_chat_validation.jsonl
  - config_name: files
    data_files:
      - split: train
        path: The_Math_of_Liberation_LLM_Training_Dataset_rev5_files.jsonl

The Math of Liberation — LLM Training Dataset (rev5)

Source work: The Math of Liberation — volume three of the collected works. 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 notebook records, and every number the notebooks store for its plots. The supervised responses are of three kinds. Most are the book's own text: its prose, its formulas, its headings and statement labels as written, and its 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 chapter the material comes from. Nothing has been paraphrased, summarized, or written in the author's place.

Earlier versions: Math_of_Liberation_finetune_dataset (v1), The_Math_of_Liberation_LLM_Training_Dataset_rev2 and The_Math_of_Liberation_LLM_Training_Dataset_rev3. They are not replaced; the changes are listed below. Its question-style chat examples, 3D model files (.glb/.obj) and mesh examples remain there; this revision is the Cone of Perception rev3 treatment applied to the Math of Liberation, with the plot data recovered exactly and the Dark Matter chapter taken from its own notebook.

Contents of the book, as represented here

Converted from the Mathematica notebook "The_Math_of_Liberation.nb" (680 cells), the companion notebook "Theory_of_Phenomenological_Acceleartion_AKA_Dark_Matter.nb" (58 cells; the closing chapter), and the printed book (PDF, 1,135 pages, made of six notebook printouts): the introduction and chapters 1–13 of the main notebook, then the Theory of Phenomenological Dark Matter, preceded by the printed table of contents.

#	Heading in the text
1	Table of Contents
2	Introduction:
3	Chapter 1 : The Premise of an Algebraic - Geometric Linguistic Notation
4	Chapter 2 : The Theory of Notating Equilibrium through Balance of Symbolic Forms of Infinite Dimensionality
5	Chapter 3 : A Liberated Fermat Expression
6	Chapter 4 : The Potential For Creating Computational Reference Frames as a Means to Establish a Being.
7	Chapter 5: Sub-Sets Yield Intra-Dimensional Algebraic Dimensions of V-Curvature (quasi-velocity).
8	Chapter 6: The Undecidability of Reality from Symbolic Notation
9	Chapter 7: Arc Length Difference Algebra and the Implicit, Embedded Dimensionality of V - Curvature; Phenomenological Velocity : Manifold Warping with Scientific Method
10	Chapter 8: Height-Acceleration Pairing: Integration Yields Velocity Paired to Curvature
11	Chapter 9: Phenomenological Curvature Velocity (Liberated Arc Length Difference Expression) Equals Geometric Mean Velocity and Mean Velocity. Angular Averages Are Used For Angular Time Allocations.
12	Chapter 10: Infinity of Flow Forms - Perceptual Affects of Flow Assignments
13	Chapter 11: Conditional Integral of Phenomenological Velocity
14	Chapter 12: Real Analysis of Phenomenological Velocity
15	Chapter 13: Novel, Symbolic, Differential Spaces of Light
16	Theory of Phenomenological Dark Matter

Mathematics is written in Wolfram Language notation exactly as the notebook holds it (Sqrt[...], Sin[β], {{v → ...}}), with Greek letters and other named characters as Unicode. 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 notebook has them (229 in all). The notebook's own title cell and any byline are kept where they stand; headings and statement labels (Axiom 1:, Theorem 3 Continued) are written exactly as the author typed them. Each graphic appears in the text as Output: [Graphics mol-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_Math_of_Liberation_full_text.md                     the whole book as one Markdown document (3,443,758 characters)
The_Math_of_Liberation_dataset_manifest.json            record counts, approximate token counts and SHA-256 of every file
pretraining/The_Math_of_Liberation_pretraining_corpus.jsonl
                                        {"id", "text", "meta"} — one record per chapter or section (split at ~14,000 characters), plus one record per graphic (378 records); plus _train / _validation
sft_openai_chat/The_Math_of_Liberation_sft_openai_chat.jsonl
                                        {"messages": [system, user, assistant]} — OpenAI / Together / Fireworks chat format (286 examples); plus _train / _validation
sft_sharegpt/The_Math_of_Liberation_sft_sharegpt.jsonl  {"id", "conversations": [{"from", "value"}, ...]} — ShareGPT (Axolotl, LLaMA-Factory, FastChat)
sft_alpaca/The_Math_of_Liberation_sft_alpaca.json       [{"instruction", "input", "output", "system", "id", "type"}] — Alpaca (JSON array)
sft_prompt_completion/The_Math_of_Liberation_sft_prompt_completion.jsonl
                                        {"prompt", "completion"} — plain prompt/completion (TRL SFTTrainer, Bedrock)
plot_data/The_Math_of_Liberation_plot_data_sft_openai_chat_{train,validation}_NNN.jsonl.gz
                                        every number the notebook stores for the plots, as chat examples (77,181 examples; gzip-compressed JSON lines)
plot_data/The_Math_of_Liberation_plot_data_pretraining_{train,validation}_NNN.jsonl.gz
                                        the same numbers as pretraining records (32,981 records)
The_Math_of_Liberation_plot_index.jsonl                 one record per graphic (67): chapter, command, relation to it, image, coordinates file, printed page, description, sample points
plot_coordinates/mol-plot-NNNN.npz    the full data stored for each graphic (28 files, 34,974,184 numbers, exact float64 / int32)
plot_stl/mol-plot-NNNN.stl            each 3D surface as a binary STL 3D-object file (23 files for 28 surfaces; exact copies share one)
images/mol-plot-NNNN.jpg|png          an image of each graphic (63)
vision_llava/The_Math_of_Liberation_vision_llava.json   [{"id", "image", "conversations": [human "<image>\n…", gpt …]}] — LLaVA / LLaMA-Factory / Axolotl (44 examples); plus _train / _validation
vision_openai_chat/The_Math_of_Liberation_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 286 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 (267 training, 19 validation; a type with a single example stays in training). The same rule splits the pretraining records (378 in all) and the vision examples (42 training, 2 validation).

The system message in the chat formats is:

You are an assistant trained on The Math of Liberation by Parker Emmerson (Yaohushuason). Answer with the book's own text, Wolfram Language computations and results, in the book's notation.

Supervised examples by type

type	examples	task
`section_continuation`	126	Continue a chapter from a quoted passage — sequential pieces covering long chapters.
`wolfram_eval`	115	Evaluate a Wolfram Language (Mathematica) input from the book — the response is the output the notebook records.
`passage_continuation`	13	Complete a long paragraph from its first twelve words.
`section_opening`	10	Give the opening of a long chapter.
`section_exposition`	6	Present a whole chapter, or a whole section of a long chapter.
`state_theorem`	4	State a numbered axiom or theorem of a chapter — the response is the statement as written.
`graph_description`	3	Given a plotting command from the book, describe the graph — every number computed from the coordinates the notebook stores for it.
`graph_samples`	3	Given a plotting command, list a thinned selection of the points Mathematica actually stored for it.
`graph_to_command`	3	The reverse direction: from a graph's computed properties and stored points, give the command that drew it.
`essay_section`	1	Give the printed table of contents (front matter that exists only in the print).
`theorem_proof`	1	Prove a stated theorem — the response is the material the book gives after the statement (prose, formulas, Wolfram Language evaluations), up to the next statement or heading.
`wolfram_plot`	1	Given the expression the author has just written, give the Wolfram Language command he plots it with (plots directly under their command only).

Every character of the book's text — prose, headings, statement labels, Wolfram Language inputs, outputs and messages, and the notebook's title cell — 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. Responses are at most 12,000 characters; prompts are not shortened, because a prompt carries the book's own input whole.

Plot data as training text

Every number the notebook stores for its plots is also written out as text, so that a model trained on this dataset sees the numbers themselves and not only descriptions of them: 3,034,549 points, 2,982,418 faces, 66,527 mesh lines, 3,034,549 normals (21 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;
outlines — for pictures of typeset mathematics stored as shapes: each outline's segments {code, new points, degree} and its control points;
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 notebook — the surfaces of Manipulate panels computed at their saved slider settings — are not written as text; they stay in plot_coordinates/. These files hold 222 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

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). Inside the .nb file these are packed into compressed blocks. All of them were decoded exactly — 34,974,184 numbers in all — and checked against a second, independent decoding of the notebook (points, normals, faces, mesh lines and every sample point match exactly).

67 graphics in all: 21 3D plots with stored coordinates, 41 interactive Manipulate panels, and 5 pictures.

Pairing with commands. In a Mathematica notebook an input puts its results in the Output cells right below it, one for each statement that returns something; the k-th Output cell under an input belongs to its k-th such statement, which is the graphic's command (command_match says how the match was made), relation: "output" (3 of the 3D plots: 3 ContourPlot3D). A command counts only if it can have drawn the graphic. A graphic pasted into an Input, Text or other cell — usually the same surface turned to another viewpoint — 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). Only output pairs are used for the command-to-graph and graph-to-command examples; pasted graphics are described from their coordinates alone. 5 3D graphics hold coordinates identical to an earlier one and carry same_data_as.
Equation test of every pairing (command_check). 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, and compared with what the plotting function draws there (the distance from the origin at the point's angle for SphericalPlot3D, the height at the point's distance from the axis for RevolutionPlot3D, lhs − rhs = 0 or a few levels for ContourPlot3D, the height for Plot3D). 0 are verified (at least half the stored points satisfy the command to within 10⁻⁶ of the plot's extent, or nine in ten are accounted for, counting the points Mathematica puts on the faces of its plot box where it cuts a surface off and those within 1% where the expression stops being real), 0 partly matched, 0 not matched (left out of the command-to-graph and graph-to-command examples), 3 not checkable (the reason is given).
STL files (plot_stl/). Each 3D surface as a binary STL file — the format 3D viewers, design programs and 3D printers open: 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 (so a surface reaching beyond its plot box looks larger in a 3D viewer than in the picture; the exact float64 coordinates are in the .npz file).
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 ContourPlot3D the points lie where the expression is at a contour level); 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; 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; 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. 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 with stored data 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. The 41 Manipulate panels hold no plotted points in the notebook, only their slider settings. 30 of them are printed as pictures, which are used as their images (one of the two panels saved in cell 328 is printed; the printed slider settings identify it as the second). The other 11 do not appear in the PDF (the printouts skip them, and the printout of chapter 13 stops inside the long output just before the last one); for 7 of these the surface the panel shows at its saved setting is computed here from its command and kept like a stored surface — coordinates, STL file and picture — marked coordinates_origin: "computed here …" (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). The remaining 4 have no image, for the reason given in computed_surface_not_made: mol-plot-0045, mol-plot-0047, mol-plot-0052, mol-plot-0065. One pasted 3D plot (mol-plot-0037, chapter 10) is not printed either; its image is drawn from its coordinates like the others. Five graphics are embedded images: the typeset formula of chapter 2 (transcribed into the book text; not printed in the PDF) and four screenshots of a 3D plot in chapter 3 (captioned with what is drawn, including the text of Mathematica's message box). Embedded pictures are kept exactly as stored (not flipped); some have transparent backgrounds, so composite them onto white when converting to RGB (the OpenAI vision files already are).
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). Typeset-formula pictures carry outline_points, outline_point_counts, outline_segments (Mathematica segment codes: 0 = line, 1 = cubic Bézier, with the number of new points and the degree), outline_segment_counts and shape_outline_counts.
Printed counterparts. Each index record's printed field gives the PDF page(s) and embedded-picture number where the graphic is printed, or not printed.

import numpy as np
z = np.load("plot_coordinates/mol-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 chapter or section, prefixed with the book, chapter and section it belongs to:

The Math of Liberation by Parker Emmerson (Yaohushuason)
Chapter: Introduction:

…

Chapters 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. One very long output dominates the book: the output of notebook cell 510 in chapter 10 is 2,765,508 characters (it fills most of the 845-page printout of that chapter). It is kept whole in the full text; in the pretraining records and the supervised examples it is cut into consecutive pieces, each tied to its input. The longest record is 16,859 characters; no record has to be dropped or cut for length. The plot 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_Math_of_Liberation_sft_openai_chat_train.jsonl",
                                      "validation": "sft_openai_chat/The_Math_of_Liberation_sft_openai_chat_validation.jsonl"})
pt = load_dataset("json", data_files="pretraining/The_Math_of_Liberation_pretraining_corpus.jsonl")
numbers = load_dataset("json", data_files="plot_data/The_Math_of_Liberation_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 rev3

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

Mathematica's messages. The 229 messages the notebook records (kernel Message cells) were left out of rev3; they are now in the text after their input, as Message: … lines, and in the evaluation examples.
Title and labels as written. The notebook's title cell ("The Math of Liberation", and the byline "by Parker Emmerson" under the title of chapter 12) is in the text and the examples, headings and statement labels keep the author's punctuation (rev3 wrote Axiom 1: as Axiom 1. and Preface: as Preface), and chapter headings now also open the chapter's own examples, so they are in the answers as well as in the requests.
Two cells repaired. In two LaTeX formulas typed into text cells, an escaped backslash was read together with the letter after it, so that \neq, \tan and \theta lost their first letter to a line break or a tab. The string decoding now reads escapes left to right in one pass, and the formulas are as written.
Plot numbers as text. Every number the notebook stores for its plots is written out in plot_data/ (above).

Changes in rev3 (from rev2)

Every part of the book is in the supervised examples. In rev2, inputs and outputs too long for a single example (12,000 characters), and the pieces of chapters around them, were in no supervised response. 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 repeat its input, and no record is flagged for dropping.
Named characters. Fourteen characters of twelve kinds — ∛, Å, ⋮, ⋯, ⋰, ⏜, ⏝, ⊐, ø, ◆, ♣, Ϟ — were left in their Wolfram Language form (such as [CubeRoot]) in rev2; they are now Unicode.
Numbers. Numbers written with a power of ten (1.2*^-5) are read to the nearest 64-bit value; rev2 multiplied the parts, which could be off in the last binary digit (one saved slider value of the Dark Matter panel were; no coordinates were affected).
Pairing and its test. Graphics are paired with the statement that produced them, and every pairing is tested against the stored points (command_check).
STL files. Each 3D surface is also an STL 3D-object file.

How the conversion was made

The notebook was parsed as an expression tree: cell styles give the structure (chapter, section and subsection headings; text, items, formulas; Input and Output cells); box forms (RowBox, FractionBox, SqrtBox, SuperscriptBox, …) were converted to linear Wolfram Language (a bar or hat over letters as OverBar[…] or OverHat[…]); named characters to Unicode (the few that exist only in Mathematica's own font stay in their Wolfram Language form); 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). 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.
Two parts of the print are not in the main notebook. The table of contents (PDF page 2) was taken from the PDF's text layer. The closing chapter, "Theory of Phenomenological Dark Matter" (PDF pages 1118–1135), is printed from a separate notebook; that notebook was supplied and converted like the main one. Its long symbolic output (the fourth mixed derivative, 11,410 characters, printed on PDF pages 1119–1123) was checked against the print: all 253 printed coefficients (11 distinct values, such as 1.79751 × 10^17 and 8.98755 × 10^16) agree with the notebook's numbers rounded to the printed six digits. Chapters 10–13 have headings in the notebook that the print shows only as running heads; the notebook headings are used. Every PDF page has a usable text layer (no OCR was needed).
The compressed blocks hold packed arrays of types e (64-bit reals), n (32-bit integers) and b (bytes); some embedded images are stored as RawArray["UnsignedInteger8", …] instead, decoded as well. No legacy GraphicsData["PDF"] figures occur (the GraphicsData blocks in the notebook are Mathematica's own cached bitmaps of plots whose coordinates are stored).
Approximate token counts in the manifest are character-based (about 3.3 characters per token for this mixed prose and code).

Citation

@book{emmerson_mol,
  author = {Emmerson, Parker (Yaohushuason)},
  title  = {The Math of Liberation},
  note   = {Independent Researcher. ORCID 0009-0007-1288-3292}
}

Changes from The_Math_of_Liberation_LLM_Training_Dataset_rev4: every file reachable by the Parquet conversion

The_Math_of_Liberation_LLM_Training_Dataset_rev5 is The_Math_of_Liberation_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_Math_of_Liberation_LLM_Training_Dataset_rev4 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_Math_of_Liberation_LLM_Training_Dataset_rev4 and this folder into the same repository; this README replaces the previous one.

What was added:

images configuration: the 63 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 28 .npz coordinate files (34,974,184 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_Math_of_Liberation_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_Math_of_Liberation_pretraining_corpus.jsonl, sft_alpaca/The_Math_of_Liberation_sft_alpaca.json, sft_openai_chat/The_Math_of_Liberation_sft_openai_chat.jsonl, sft_prompt_completion/The_Math_of_Liberation_sft_prompt_completion.jsonl, sft_sharegpt/The_Math_of_Liberation_sft_sharegpt.jsonl, vision_llava/The_Math_of_Liberation_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_Math_of_Liberation_vision_openai_chat_train.jsonl, vision_openai_chat/The_Math_of_Liberation_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 (63): file name, the vision examples asked about it (questions and answers), and the earlier metadata columns where the folder had them
`coordinates/The_Math_of_Liberation_coordinates.jsonl.gz`	28 graphics, every stored array as JSON lists (0.47 GB of text)
`The_Math_of_Liberation_documents.jsonl`	the 1 text documents of the folder (full texts, reports, audits) as rows
`vision_openai_chat/The_Math_of_Liberation_vision_openai_chat_train.jsonl`	the OpenAI-layout vision file rewritten so every message `content` is a list of parts (84 string contents converted in 42 rows); the pictures and text are unchanged
`vision_openai_chat/The_Math_of_Liberation_vision_openai_chat_validation.jsonl`	the OpenAI-layout vision file rewritten so every message `content` is a list of parts (4 string contents converted in 2 rows); the pictures and text are unchanged
`The_Math_of_Liberation_LLM_Training_Dataset_rev5_files.jsonl`	every file of the revision (140 carried from The_Math_of_Liberation_LLM_Training_Dataset_rev4, 5 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	63	5
`coordinates`	train	loads	28	3
`documents`	train	loads	1	4
`vision_openai_chat`	train	loads	42	1
`vision_openai_chat`	validation	loads	2	1
`files`	train	loads	145	4