PlanetCrash/Sweeping_Nets_Saddle_Maps_LLM_Training_Dataset

Sweeping Nets, Saddle Maps, & Complex Analysis — LLM Training Dataset (rev3)

Source work: Sweeping Nets, Saddle Maps, & Complex Analysis, 1st edition, November 2024, The Journal of Liberated Mathematics (DOI 10.5281/zenodo.14033400), with its Python code collection. Author: Parker Emmerson (Yaohushuason), Independent Researcher — ORCID 0009-0007-1288-3292 — Parkeremmerson@icloud.com

All the content of the book and of its code collection, in the training-data formats used for fine-tuning and continued pretraining of language models and of models that read pictures. Every part of the book — headings, prose, reference lists, the contents lists the papers print, formulas, code listings, figure captions — and every cell of every notebook with everything it output occurs inside the answers of the question-and-answer examples, and again in the pretraining records. Nothing is paraphrased, summarized or written in the author's place; only the requests were written for the dataset.

Earlier version: Sweeping_Nets_Saddle_Maps_finetune_dataset (rev1). It is not replaced; the changes are listed below.

Files

Sweeping_Nets_Saddle_Maps.md                            the whole book as one Markdown document (612,664 characters)
Sweeping_Nets_Saddle_Maps_notebooks.md                  the 31 notebooks and the script, every cell with all its outputs
Sweeping_Nets_Saddle_Maps_dataset_manifest.json         record counts and SHA-256 of every file
sft_openai_chat/…_sft_openai_chat.jsonl         {"messages": [system, user, assistant]} (1,245 examples); plus _train / _validation
sft_sharegpt/…_sft_sharegpt.jsonl               {"id", "conversations": [{"from", "value"}, …]}
sft_alpaca/…_sft_alpaca.json                    [{"instruction", "input", "output", "system", "id", "type"}]
sft_prompt_completion/…_sft_prompt_completion.jsonl  {"prompt", "completion"}
Sweeping_Nets_Saddle_Maps_sft_examples_index.jsonl      one row per example: id, type, and where its answer comes from (chapter, notebook, cell, piece k of n)
pretraining/…_pretraining_corpus.jsonl          {"id", "text", "meta"} — the book chapter by chapter and the notebooks one by one, in records of at most about 14,000 characters (141 records); plus _train / _validation
vision_trl/…_vision_trl.jsonl                   picture examples with an "images" list (Hugging Face TRL layout; 697 examples); plus _train / _validation
vision_llava/…_vision_llava.json                the single-picture examples in the LLaVA layout (690); plus _train / _validation
vision_openai_chat/…_vision_openai_chat_{train,validation}.jsonl   the same in OpenAI's vision format (pictures as base64 JPEG, 512 px)
Sweeping_Nets_Saddle_Maps_figures_table.jsonl           one row per picture of the book (rev1's figures table)
Sweeping_Nets_Saddle_Maps_notebooks_table.jsonl         one row per notebook with every cell and its outputs (rev1's notebooks table)
images/book/, images/notebooks/      the 126 pictures of the book and the 191 different plots of the notebooks; images/metadata.jsonl describes each
code/PythonCode-main/                the code collection as it came

The four question-and-answer files hold the same 1,245 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 (1,183 training, 62 validation). The pretraining records and the picture examples are split by the same rule.

The system message in the chat formats is:

You are an assistant trained on Sweeping Nets, Saddle Maps, & Complex Analysis by Parker Emmerson (Yaohushuason), and on the Python code collection that comes with it. Answer with the book's own text, mathematics and code, in the book's notation.

Question-and-answer examples by type

type	examples	request → answer
book_sequence	120	Write out a chapter (or the front matter) of the book: the whole chapter in consecutive pieces of at most 6,000 characters, the first asked for by the chapter's name and each later one by the end of the piece before it — headings, prose, reference lists, contents lists, formulas, code and figure captions.
notebook_sequence	190	Write out a notebook of the code collection: every cell in order with everything it output — text cells, code cells, printed output, returned results, LaTeX and HTML output, error messages with their tracebacks, widgets and the plots it drew — in consecutive chained pieces.
notebook_cell_output	161	Given one code cell, what did it output when the author ran it (all its outputs in order; long outputs in chained pieces).
script_sequence	4	Write out the Python script of the code collection, in chained pieces.
book_qa	185	rev1: a question about an idea, definition, construction, theorem or argument — the passage that answers it.
book_proof	47	rev1: prove a result of the book — the book's proof.
book_section	207	rev1: write a section of a paper — that section (its opening part when long).
book_continue	21	rev1: a paragraph of the book — the passage that follows it.
python_code	267	rev1: a computation or plot described in words — the program.
mathematica_code	1	rev1: the same, for the one Wolfram Language listing.
python_output	42	rev1: a notebook program — what it printed.

Answers of the new types are at most 6,000 characters; rev1's examples are kept as they were (the longest answer, a rev1 section, is 12,796 characters). A block longer than a piece — a long program or a long printed output — is cut at line ends and each part is fenced again. Every request of a later piece quotes the end of the piece before it, so the pieces chain. The source of every answer is in Sweeping_Nets_Saddle_Maps_sft_examples_index.jsonl.

Checks

• Everything is in the answers. The book was split into its units (each heading, paragraph, reference list, contents list, displayed formula, code listing and figure caption) and the notebooks, read again from the .ipynb files, into theirs (each code cell, text cell, printed output, returned result, LaTeX and HTML output, error message, and the script). Every unit was looked for in the answers, spacing ignored: a character counts as present when a run of 24 consecutive characters containing it occurs in an answer, and a unit shorter than that must occur whole. All 1,127,856 characters are present; none is missing. The same holds for the pretraining records.
• Against the printed book. The words of every page of the PDF were looked for in the dataset text in runs of four. Every printed sentence is there; what the check flags is only words split by mathematical symbols that the PDF's text layer drops (as in "the mapping Φ transforms", printed without its Φ).
• Against the LaTeX sources. The prose of every source file was looked for in the same way. Nothing is missing except text that the sources hold after \end{document} (chapter 6: notes left from a conversation with an AI assistant, which LaTeX does not print and the book does not contain).
• Conversion. No LaTeX command is left outside formulas and code (\textbf, \section, \begin, \label, \cite and the like), and every formula of the answers, the pretraining records and both full texts compiles in KaTeX (a program that typesets LaTeX formulas in web pages); notebook code and outputs are fenced with more backticks than they contain, so no code is read as text.
• Files. Every file loads with the Hugging Face datasets library, is listed in the manifest with its SHA-256, and the train and validation files partition each full file.
• Pictures. All 317 pictures are in at least one picture example (6 notebook plots identical to a book picture through that picture). The plots of the notebooks are pictures (PNG) that the notebooks store; they hold no coordinate data of their own.

Changes from rev1

• The whole book is in the answers. rev1's section examples gave a long section's opening only, and its other examples were passages chosen for questions; 8.4% of the book and notebooks (93,916 characters) was in no answer. The missing parts were 36% of the headings, most of the reference lists, the ends of long sections, 56% of the notebooks' printed output, 87% of their text cells and all 15 error messages. Every chapter and every notebook is now also written out whole, in chained pieces, and every code cell with output has an example of what it output.
• A sentence restored. Chapter 18 opens "These fractals are from interpretations of the following pseudo-code for the iterations:" before its pseudo-code; rev1 lost the sentence when it mended the broken $$ markup around the pseudo-code.
• The papers' own contents lists. Eight papers print a contents list of their own (5, 19, 98, 109, 170, 192, 223, 307 are the PDF pages where they begin); rev1 left them out. They are in the text now where they are printed, each entry with its printed page number, the titles written as the paper's headings (so the mathematics in them is the LaTeX of the headings rather than the PDF's text layer): 268 entries, every one matched to its heading.
• Notebook outputs complete. Error messages with their tracebacks, the two HTML outputs, LaTeX output, results returned beside plots and widget texts are in the notebook text and the answers.
• Formats. ShareGPT, prompt/completion, OpenAI vision, a train/validation split, a system message, an index of the examples' sources and a manifest with SHA-256 are added. The pretraining corpus is rebuilt from the full texts in larger records; rev1's corpus stays in rev1.

Sources

• The book, a PDF of 320 pages: cover, dedication, publication details, contents, and the 19 chapters on PDF pages 5 to 320. Every page reference in this dataset is the page's position in the PDF file (pdf_page, the cover being page 1); the printed page numbers restart in every paper.
• The author's LaTeX sources and chapter PDFs for chapters 1 to 14 and 17 to 19, and for the supplementary paper. The text of these chapters was converted from the LaTeX sources (the files the PDF was typeset from), so the mathematics is the author's own LaTeX, not a reading of the page.
• Chapters 15 and 16 (PDF pages 186 to 250) have no source files. They were transcribed from the printed pages into Markdown and LaTeX, formula by formula, and each transcription was checked against the page images. Chapter 15 holds four papers ("Generalization of Set Integration"; "Generalizing Set Integration and Its Connection to Calculus Integration"; "Theory of Group Integration"; "Lie Superalgebras in the Group Theory of Integration") and chapter 16 four more ("On the Relationship between Morphisms, Root Sets, and Interior Products in Mathematical Analysis", two papers titled "Math of Ghosts, Phantoms, and Solving for Morphisms", and "Ghostology 4").
• The code collection (PythonCode-main): 31 notebooks and one script. Three notebooks come in two versions each (Trajectron, Matrix_Method_Analysis_of_String_Theory_2 and Prime_Factorials_for_Euler's_Number, the second copy named with "(1)"); both versions are kept, since they differ. The collection also holds Tessellations.zip, which is the LaTeX source of the supplementary paper again (an older copy whose text and pictures are the same); it is not repeated here. Code of three notebooks is printed in the book: Hypercone (chapter 19), Non_Commutative_Scaler_Fields (chapter 14, which also links to it) and Programs_Tesselogical (the supplementary chapter 20).

How the text was made

Structure. Each chapter starts with a level-1 heading # Chapter N. Title, using the title of the book's contents page; the supplementary paper is # Chapter 20 (supplement, not in the printed book). …. Each paper starts with a level-2 heading carrying its own title, followed by its author and date lines and its abstract (**Abstract.** …). Sections are level 3, subsections level 4, and so on, each with the number printed in the book.

Numbers as printed. Section numbers, theorem numbers (such as Theorem 4.1.), equation numbers and figure numbers are those printed in the book. They were obtained by compiling every LaTeX source with labels added to everything that carries a number and reading the numbers back, and then checked against the printed text: every equation number, numbered theorem and section number of chapters 1 to 19 appears in the printed chapter. (The supplementary paper's own PDF was typeset with errors that swallowed some of its equations; here its equations carry the numbers LaTeX gives the mended source, so some of the later numbers differ from that PDF. Number 9 is skipped in both, because the source ends an aligned block with a line break that LaTeX numbers as an empty line.) Equation numbers stand in the formulas as \tag{n}; references in the text ("by (4)", "Theorem 6.3") show the printed numbers.

Mathematics. Inline formulas are written between $…$, displayed formulas between $$…$$ on lines of their own (a display that belongs to a list item is indented with it). Formulas with several numbered lines use the align environment with a \tag per line; unnumbered multi-line formulas use aligned. The book holds 599 displayed formulas. All 25,588 formulas in all files of this dataset (book, notebooks, corpus, examples, tables) compile in KaTeX (a program that typesets LaTeX formulas in web pages).

Theorems and proofs. Theorem-like statements are paragraphs that start with their bold label (Theorem 4.1., Lemma 1., Corollary 6.4.); proofs start with Proof. and end with $\square$, the box the book prints. Where the author also ended a proof with his own $\blacksquare$, the second box is left out. The book holds 49 labelled statements.

Code. Every program is a fenced code block with its language (python, or mathematica for the one Wolfram Language listing in the supplement); the book holds 71. Code is kept exactly as printed, including the author's bugs and the comments that line-wrapping broke onto their own lines in a few listings.

Pictures. Each picture is a Markdown image line where it stands, labelled Figure N (PDF page P): caption when the book numbers and captions it, and Image (PDF page P) otherwise; pictures of the supplement name their page in the Tessellations PDF. Each of the 92 pictures of chapters 1 to 19 is the author's original file, matched by comparing the images to the picture printed in the PDF, which gives its page. A figure made of several panels (in the supplement) is written as one image line per panel, each with the figure's caption and its panel caption.

Markdown typed into the LaTeX. Many sources contain Markdown that the author pasted into LaTeX: headings written as ### Step 1, lists written as - item or 1. item, bold written as **bold**, inline code between backticks, code fences, and separator lines ---. The printed book shows these characters literally or runs the list items together into one paragraph. Here they are made into real Markdown headings, lists, bold text and code, as the author wrote them; nested items and the paragraphs and formulas indented under an item stay inside their item. The separator lines are left out. The same rule was applied to the transcribed chapters 15 and 16, whose pages print the same literal ** and - characters.

What was repaired in the sources. The LaTeX sources were typeset with errors, and the PDF shows what LaTeX printed while recovering from them. To carry the author's text through, the following markup errors were mended (the wording was never changed): unbalanced dollar signs (the marks that open and close formulas) and formulas typed outside math mode (chapters 1, 14, 18, 20); a reference list that was never closed and a duplicated end of document (chapter 2); environments used without being declared, written here as unnumbered Conjecture. and Theorem. blocks since the book prints no number for them (chapters 3 and 6); a second and third LaTeX preamble pasted into the file (chapter 7); a Markdown passage with two code blocks pasted inside one code listing, which the book prints as code (chapter 9); a redefinition of proof that LaTeX refused (chapter 11); a misspelled \secion, which the book prints as plain text and which is an unnumbered heading here (chapter 19); and, in the supplement, undefined commands (\defeq, written as $\coloneqq$), comment lines inside a formula, and images given without a size key. Chat text pasted before or after a document (outside the printed part) was dropped. The date of chapter 9 is the one printed in the book (the source asks LaTeX for the day it is compiled).

Left out on purpose. Running page numbers, the separator dashes, and one empty reference entry ([4] of the first paper of chapter 2, which has no text). The contents lists that eight papers print for themselves are included (see the changes below).

Kept as written. The author's wording, spelling, punctuation and mathematics are kept, including passages that repeat (several papers repeat whole sections of earlier ones), sentences left from conversations with an AI assistant, and statements a reader may find mistaken. Where the printed text is garbled by a LaTeX error that cannot be mended without guessing, the printed text is kept.

How faithful the text is. Of the 45,101 words of prose outside code in the Markdown, 99.4% appear in the same order in the printed pages (the rest are mostly the labels and headings added here and words of Markdown typed into the sources). An independent check of 42 pages spread over the whole book, page image against Markdown, formula by formula, found one error (a stray control character from a \qed command), which was corrected.

The rev1 examples

Every answer is taken from the book or the code collection as they stand in this dataset; only the requests were written for it, by the method called instruction back-translation: the passage or program is the answer, and the request asks for exactly what it says or does. The examples are grouped by kind (field task):

Lines	Kind	Request	Answer
1–185	book_qa	a question about an idea, definition, construction, theorem or argument of the book	the passage of the book that answers it, word for word
186–232	book_proof	prove a result of the book, stated as in the book (theorem, lemma, corollary, proposition)	the book's proof
233–439	book_section	write a section of a paper, named by its heading (a long section is asked for by subsection)	that section (its opening part where it runs past 3,500 tokens)
440–460	book_continue	a paragraph of the book	the passage that follows it
461–727	python_code	a computation or plot described in words and LaTeX	the program from the book or a notebook
728–728	mathematica_code	the same, for the one Wolfram Language listing	the Mathematica code
729–770	python_output	a notebook program: what does it print?	what it printed when the author ran it

The questions of book_qa were written after reading each chapter in full, about one per 400 words of prose, over every paper; each answer passage was marked by its first and last words and cut from the book automatically, so it is the book's text exactly. The requests of python_code were written by reading each program; they describe what the program actually does, including the libraries, functions, parameters and plots that make it the right answer, and do not mention the program's bugs. Programs that do not parse as Python (13 of the 326 programs of the book and the notebooks: listings broken by line-wrapping, chat text saved in a code cell, an install command), exact repeats, and notebook cells whose saved run ended in an error are not used as python_code answers; they remain in the book and notebook files. python_output uses only cells that run on their own (they use no name defined in an earlier cell), did not end in an error and do not draw random numbers without a seed, and only what the program printed (not the value Jupyter echoes after a cell, and not warnings).

An independent reviewer checked a random sample of 111 examples of all kinds against the book, the notebooks and the pictures, running the programs where needed; the rules above on proofs (each proof ends at the author's end mark), on printed output and on descriptions (only what is visible) come from that review, and the examples it found faulty were corrected.

In rev1 the examples carried no system message; here every example carries the system message given below. All 770 examples come to 523,277 tokens; the longest is 3,668, so a training sequence length of 4,096 holds every example whole.

The examples about pictures

Sweeping_Nets_Saddle_Maps_vision_chat.jsonl holds 697 examples (7 of them show several pictures, the plots one notebook cell draws; the LLaVA file holds the other 690):

Kind (task)	Count	Picture	Request	Answer
figure_describe	126	a picture of the book	describe it (the request names the paper and chapter)	what is plotted against what, axes and ranges, legend, colours that carry meaning, the visible shape
figure_text	107	a picture of the book with printed text	read the text in it	title, axis labels and legend entries, separated by " | "
figure_caption	34	a captioned figure of the book	which figure is this	"Figure N: caption", as printed
plot_describe	185	a plot from a notebook	describe it	as for figure_describe
plot_text	161	a plot from a notebook with printed text	read the text in it	as for figure_text
plot_to_code	84	a plot from a notebook	write the Python code that draws it	the code of the cell that drew it

The descriptions and transcribed text were written for this dataset by looking at each picture, with the book's text around it or the code that drew it at hand to name things correctly; they describe only what is visible. plot_to_code uses only notebook cells, where the saved picture is certainly the output of the cell, whose code imports what it needs and draws the plot itself, and which parse as Python. A notebook plot that is identical to a picture of the book is used once, as the book's. Book pictures are not used for plot_to_code, because in the book the listing printed before a picture does not always draw that picture (the author sometimes printed another variant's output); the figures table still records that listing as listing_before. The text of the vision examples comes to 138,919 tokens, the longest 1,749, before the image tokens that each model's processor adds.

Loading

from datasets import load_dataset
chat = load_dataset("json", data_files={"train": "sft_openai_chat/Sweeping_Nets_Saddle_Maps_sft_openai_chat_train.jsonl",
                                        "validation": "sft_openai_chat/Sweeping_Nets_Saddle_Maps_sft_openai_chat_validation.jsonl"})
pt = load_dataset("json", data_files="pretraining/Sweeping_Nets_Saddle_Maps_pretraining_corpus.jsonl")
pictures = load_dataset("imagefolder", data_dir="images", split="train")

OpenAI fine-tuning: upload sft_openai_chat/…_train.jsonl as the training file and …_validation.jsonl as the validation file. Axolotl: type: sharegpt or type: alpaca; type: completion on the pretraining file (field text). For pictures, paths in the files are relative to this folder.

Author

Parker Emmerson (Yaohushuason), Independent Researcher, ORCID 0009-0007-1288-3292, Parkeremmerson@icloud.com. Sweeping Nets, Saddle Maps, & Complex Analysis, published November 2024 by The Journal of Liberated Mathematics (DOI 10.5281/zenodo.14033400). © Parker Emmerson (Yaohushuason).

Changes from Sweeping_Nets_Saddle_Maps_LLM_Training_Dataset_rev2: every file reachable by the Parquet conversion

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

What was added:

• images configuration: the 317 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.
• notebook_cells configuration: the 31 .ipynb files cell by cell (267 rows), with each cell's source, its printed output and its outputs as JSON (pictures inside outputs as their base64 text).
• source_files configuration: the 1 source files kept in the folder (.py) as rows with their full text.
• documents configuration: the 2 Markdown and text files of the folder (Sweeping_Nets_Saddle_Maps.md, Sweeping_Nets_Saddle_Maps_notebooks.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/Sweeping_Nets_Saddle_Maps_pretraining_corpus.jsonl, sft_alpaca/Sweeping_Nets_Saddle_Maps_sft_alpaca.json, sft_openai_chat/Sweeping_Nets_Saddle_Maps_sft_openai_chat.jsonl, sft_prompt_completion/Sweeping_Nets_Saddle_Maps_sft_prompt_completion.jsonl, sft_sharegpt/Sweeping_Nets_Saddle_Maps_sft_sharegpt.jsonl, vision_llava/Sweeping_Nets_Saddle_Maps_vision_llava.json, vision_trl/Sweeping_Nets_Saddle_Maps_vision_trl.jsonl hold the same rows as their _train and _validation parts together and stay undeclared, so no row is converted twice.
• figures_table configuration: Sweeping_Nets_Saddle_Maps_figures_table.jsonl — present in the previous revision but not declared, so the bot skipped it.
• notebooks_table configuration: Sweeping_Nets_Saddle_Maps_notebooks_table.jsonl — present in the previous revision but not declared, so the bot skipped it.
• sft_examples_index configuration: Sweeping_Nets_Saddle_Maps_sft_examples_index.jsonl — present in the previous revision but not declared, so the bot skipped it.
• vision_openai_chat configuration: vision_openai_chat/Sweeping_Nets_Saddle_Maps_vision_openai_chat_train.jsonl, vision_openai_chat/Sweeping_Nets_Saddle_Maps_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 (317): file name, the vision examples asked about it (questions and answers), and the earlier metadata columns where the folder had them
Sweeping_Nets_Saddle_Maps_notebook_cells.jsonl	every cell of the 31 Jupyter notebooks (267 cells): source, printed output, the outputs as JSON
Sweeping_Nets_Saddle_Maps_source_files.jsonl	the 1 source files (LaTeX, programs, scripts) as rows: path and full text
Sweeping_Nets_Saddle_Maps_documents.jsonl	the 2 text documents of the folder (full texts, reports, audits) as rows
vision_openai_chat/Sweeping_Nets_Saddle_Maps_vision_openai_chat_train.jsonl	the OpenAI-layout vision file rewritten so every message content is a list of parts (1312 string contents converted in 656 rows); the pictures and text are unchanged
vision_openai_chat/Sweeping_Nets_Saddle_Maps_vision_openai_chat_validation.jsonl	the OpenAI-layout vision file rewritten so every message content is a list of parts (68 string contents converted in 34 rows); the pictures and text are unchanged
Sweeping_Nets_Saddle_Maps_LLM_Training_Dataset_rev3_files.jsonl	every file of the revision (380 carried from Sweeping_Nets_Saddle_Maps_LLM_Training_Dataset_rev2, 6 new) with its size and SHA-256, as rows

What the bot still does not read, and why it is no loss: the .ipynb files (their cells are in notebook_cells); the source files (their text is in source_files); 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	317	17
notebook_cells	train	loads	267	7
source_files	train	loads	1	5
documents	train	loads	2	4
figures_table	train	loads	126	19
notebooks_table	train	loads	31	8
sft_examples_index	train	loads	1245	9
vision_openai_chat	train	loads	656	1
vision_openai_chat	validation	loads	34	1
files	train	loads	386	4