README.md

---
pretty_name: The Sphere of Realization (2nd Edition) — LLM Training Dataset (rev6)
language:
- en
license: other
license_name: author-controlled
license_details: Text of The Sphere of Realization, © 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_Sphere_of_Realization_sft_openai_chat_train.jsonl
  - split: validation
    path: sft_openai_chat/The_Sphere_of_Realization_sft_openai_chat_validation.jsonl
- config_name: sft_sharegpt
  data_files:
  - split: train
    path: sft_sharegpt/The_Sphere_of_Realization_sft_sharegpt_train.jsonl
  - split: validation
    path: sft_sharegpt/The_Sphere_of_Realization_sft_sharegpt_validation.jsonl
- config_name: sft_alpaca
  data_files:
  - split: train
    path: sft_alpaca/The_Sphere_of_Realization_sft_alpaca_train.json
  - split: validation
    path: sft_alpaca/The_Sphere_of_Realization_sft_alpaca_validation.json
- config_name: sft_prompt_completion
  data_files:
  - split: train
    path: sft_prompt_completion/The_Sphere_of_Realization_sft_prompt_completion_train.jsonl
  - split: validation
    path: sft_prompt_completion/The_Sphere_of_Realization_sft_prompt_completion_validation.jsonl
- config_name: vision_llava
  data_files:
  - split: train
    path: vision_llava/The_Sphere_of_Realization_vision_llava_train.json
  - split: validation
    path: vision_llava/The_Sphere_of_Realization_vision_llava_validation.json
- config_name: plot_index
  data_files:
  - split: train
    path: The_Sphere_of_Realization_plot_index.jsonl
- config_name: pretraining
  default: true
  data_files:
  - split: train
    path: pretraining/The_Sphere_of_Realization_pretraining_corpus_train.jsonl
  - split: validation
    path: pretraining/The_Sphere_of_Realization_pretraining_corpus_validation.jsonl
- config_name: plot_data_sft_openai_chat
  data_files:
  - split: train
    path: plot_data/The_Sphere_of_Realization_plot_data_sft_openai_chat_train_*.jsonl.gz
  - split: validation
    path: plot_data/The_Sphere_of_Realization_plot_data_sft_openai_chat_validation_*.jsonl.gz
- config_name: plot_data_pretraining
  data_files:
  - split: train
    path: plot_data/The_Sphere_of_Realization_plot_data_pretraining_train_*.jsonl.gz
  - split: validation
    path: plot_data/The_Sphere_of_Realization_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_Sphere_of_Realization_coordinates.jsonl.gz
- config_name: documents
  data_files:
  - split: train
    path: The_Sphere_of_Realization_documents.jsonl
- config_name: vision_openai_chat
  data_files:
  - split: train
    path: vision_openai_chat/The_Sphere_of_Realization_vision_openai_chat_train.jsonl
  - split: validation
    path: vision_openai_chat/The_Sphere_of_Realization_vision_openai_chat_validation.jsonl
- config_name: files
  data_files:
  - split: train
    path: The_Sphere_of_Realization_LLM_Training_Dataset_rev6_files.jsonl
---

# The Sphere of Realization (2nd Edition) — LLM Training Dataset (rev6)

**Source work:** *The Sphere of Realization: The Mathematical Path of Harmonious Being*, 2nd Edition — volume two 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: `Sphere_of_Realization_finetune_dataset` (v1), `Sphere_of_Realization_finetune_dataset_v2`, `The_Sphere_of_Realization_LLM_Training_Dataset_rev3` and `The_Sphere_of_Realization_LLM_Training_Dataset_rev4`. They are not replaced; the changes are listed below. Their question-style chat examples, 3D model files (.glb/.obj) and mesh examples remain in those versions; this revision is the Cone of Perception rev3 treatment applied to the Sphere of Realization, with the plot data recovered exactly.

## Contents of the book, as represented here

Converted from the Mathematica notebook "Collected Notebook- The Sphere of Realization.nb" (342 cells), and the printed 2nd edition (PDF, 280 pages): the ten chapters of the notebook, preceded by the table of contents of the 2nd edition.

| # | Heading in the text |
|---|---|
| 1 | Table of Contents |
| 2 | 1. Step-by-step Solutions to the Phenomenological Velocity (V-Curvature) Equation and Discourse on the V-Curvature Method and Energy As Boundaries |
| 3 | 2. Map of Equations: Differential Combinations and Methods |
| 4 | 3. New Statements on Philosophy |
| 5 | 4. Difference between Surface Areas of Two Spheres |
| 6 | 5. Difference between Volumes of Two Spheres: Imaginary 4-D realms. |
| 7 | 6. Locales of Infinity : The Place of Imagination and the Missing Components |
| 8 | 7. Discussions on the Nature of Acceleration and Non-Commutation: Constrained Models and Generalized Propositions for Light Speed |
| 9 | 8. Liberation: Liberating Constraints on the Difference Equation and the Resulting Equalities with V-Curvature (Components for Worm Holes) and Methods for Solving Non-Elementary Integrals |
| 10 | 9. Warp Variable Nature |
| 11 | 10. The Nature of Mass - Matter as Multi-Dimensional Resonant Frequency in a Broader Equation - The Coefficients Are the Path |

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 (51 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 sor-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_Sphere_of_Realization_full_text.md                     the whole book as one Markdown document (569,702 characters)
The_Sphere_of_Realization_dataset_manifest.json            record counts, approximate token counts and SHA-256 of every file
pretraining/The_Sphere_of_Realization_pretraining_corpus.jsonl
                                        {"id", "text", "meta"} — one record per chapter or section (split at ~14,000 characters), plus one record per graphic (102 records); plus _train / _validation
sft_openai_chat/The_Sphere_of_Realization_sft_openai_chat.jsonl
                                        {"messages": [system, user, assistant]} — OpenAI / Together / Fireworks chat format (184 examples); plus _train / _validation
sft_sharegpt/The_Sphere_of_Realization_sft_sharegpt.jsonl  {"id", "conversations": [{"from", "value"}, ...]} — ShareGPT (Axolotl, LLaMA-Factory, FastChat)
sft_alpaca/The_Sphere_of_Realization_sft_alpaca.json       [{"instruction", "input", "output", "system", "id", "type"}] — Alpaca (JSON array)
sft_prompt_completion/The_Sphere_of_Realization_sft_prompt_completion.jsonl
                                        {"prompt", "completion"} — plain prompt/completion (TRL SFTTrainer, Bedrock)
plot_data/The_Sphere_of_Realization_plot_data_sft_openai_chat_{train,validation}_NNN.jsonl.gz
                                        every number the notebook stores for the plots, as chat examples (57,190 examples; gzip-compressed JSON lines)
plot_data/The_Sphere_of_Realization_plot_data_pretraining_{train,validation}_NNN.jsonl.gz
                                        the same numbers as pretraining records (24,432 records)
The_Sphere_of_Realization_plot_index.jsonl                 one record per graphic (41): chapter, command, relation to it, image, coordinates file, printed page, description, sample points
plot_coordinates/sor-plot-NNNN.npz    the full data stored for each graphic (31 files, 26,399,936 numbers, exact float64 / int32)
plot_stl/sor-plot-NNNN.stl            each 3D surface as a binary STL 3D-object file (18 files for 29 surfaces; exact copies share one)
images/sor-plot-NNNN.jpg|png          an image of each graphic (41)
vision_llava/The_Sphere_of_Realization_vision_llava.json   [{"id", "image", "conversations": [human "<image>\n…", gpt …]}] — LLaVA / LLaMA-Factory / Axolotl (35 examples); plus _train / _validation
vision_openai_chat/The_Sphere_of_Realization_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 184 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 (171 training, 13 validation; a type with a single example stays in training). The same rule splits the pretraining records (102 in all) and the vision examples (33 training, 2 validation).

The system message in the chat formats is:

> You are an assistant trained on The Sphere of Realization: The Mathematical Path of Harmonious Being (2nd Edition) 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 |
|---|---|---|
| `wolfram_eval` | 63 | Evaluate a Wolfram Language (Mathematica) input from the book — the response is the output the notebook records. |
| `section_continuation` | 61 | Continue a chapter from a quoted passage — sequential pieces covering long chapters. |
| `passage_continuation` | 13 | Complete a long paragraph from its first twelve words. |
| `graph_description` | 10 | Given a plotting command from the book, describe the graph — every number computed from the coordinates the notebook stores for it. |
| `graph_samples` | 10 | Given a plotting command, list a thinned selection of the points Mathematica actually stored for it. |
| `graph_to_command` | 10 | The reverse direction: from a graph's computed properties and stored points, give the command that drew it. |
| `section_exposition` | 8 | Present a whole chapter, or a whole section of a long chapter. |
| `section_opening` | 6 | Give the opening of a long chapter. |
| `wolfram_plot` | 2 | Given the expression the author has just written, give the Wolfram Language command he plots it with (plots directly under their command only). |
| `essay_section` | 1 | Give the printed table of contents (front matter that exists only in the print). |

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: 66,124 lines of outline data (the shapes typeset formulas are drawn with), 2,200,412 points, 2,617,869 faces, 14,103 mesh lines, 2,200,412 normals (31 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 161 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 — 26,399,936 numbers in all — and checked against a second, independent decoding of the notebook (points, normals, faces, mesh lines and every sample point match exactly).

41 graphics in all: 29 3D plots with stored coordinates, 5 interactive Manipulate panels, and 7 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"` (10 of the 3D plots: 7 ContourPlot3D, 2 SphericalPlot3D, 1 RevolutionPlot3D). 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. 11 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). 7 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 five Manipulate panels hold no plotted points in the notebook, only their slider settings. Four are printed as pictures, which are used as their images; the fifth (chapter 4, PDF page 13) is printed as an empty panel drawn in vector art and was cropped from the page. Seven graphics are pictures rather than plots. Two are pictures of typeset mathematics stored as character outlines (Mathematica FilledCurve shapes): the step-by-step solution of chapter 1, printed as one picture across PDF pages 3–7, and the limit of chapter 1 (PDF page 7). Their outline control points are in `plot_coordinates/`, their images are drawn from those outlines, and the text in them is transcribed into the book text right after the graphic. Five are embedded images: a WolframAlpha result (transcribed; PDF page 8), the equation map of chapter 2 (transcribed; this picture is in the notebook but not in the 2nd edition), and three sphere diagrams of chapter 4 (captioned with what is drawn; the third is a pixel-for-pixel copy of the first). 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`.

```python
import numpy as np
z = np.load("plot_coordinates/sor-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 Sphere of Realization (2nd Edition) by Parker Emmerson (Yaohushuason)
Chapter: 1. Step-by-step Solutions to the Phenomenological Velocity (V-Curvature) Equation and Discourse on the V-Curvature Method and Energy As Boundaries

…
```

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.  The longest record is 14,799 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

```python
from datasets import load_dataset
ds = load_dataset("json", data_files={"train": "sft_openai_chat/The_Sphere_of_Realization_sft_openai_chat_train.jsonl",
                                      "validation": "sft_openai_chat/The_Sphere_of_Realization_sft_openai_chat_validation.jsonl"})
pt = load_dataset("json", data_files="pretraining/The_Sphere_of_Realization_pretraining_corpus.jsonl")
numbers = load_dataset("json", data_files="plot_data/The_Sphere_of_Realization_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 rev4

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

* **Mathematica's messages.** The 51 messages the notebook records (kernel Message cells) were left out of rev4; 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 Sphere of Realization : The Mathematical Path of Harmonious Being") is in the text and the examples, the subtitle is in the system message and every pretraining record, and chapter headings now also open the chapter's own examples, so they are in the answers as well as in the requests.
* **Three cells repaired.** Text the author put in quotation marks with formatted mathematics inside came out as fragments in three cells: the formula (√(−r²α² + r²δ² + 2rzαθ − z²θ²))/δ quoted in the sentence beginning "Since … can be likened to acceleration", the exponent ∞ of "π *10^∞", and the name "Non-Commutative, Algebraic Dimensionality (Transformational V-Curvature in the System)" (left with Mathematica's bold-formatting code in it). They are now converted like the rest of the cell.
* **Plot numbers as text.** Every number the notebook stores for its plots is written out in `plot_data/` (above).

## Changes in rev4 (from rev3)

* **Every part of the book is in the supervised examples.** In rev3, 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.** Two right-angle signs (∟) in the numbered list of chapter 6 were left as \[RightAngle] in rev3; they are now Unicode.
* **Numbers.** Numbers written with a power of ten (1.2*^-5) are read to the nearest 64-bit value; rev3 multiplied the parts, which could be off in the last binary digit (four plot-range numbers of three graphics 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.
* The only page of the 2nd edition that is not in the notebook is the table of contents (PDF page 2). It was taken from the PDF's text layer; the formula in entry 6 is copied from the notebook's heading of section 6.2 rather than retyped. All chapter text is in the notebook, so it was taken from there; 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

```bibtex
@book{emmerson_sor,
  author = {Emmerson, Parker (Yaohushuason)},
  title  = {The Sphere of Realization: The Mathematical Path of Harmonious Being},
  edition = {2},
  note   = {Independent Researcher. ORCID 0009-0007-1288-3292}
}
```

## Changes from The_Sphere_of_Realization_LLM_Training_Dataset_rev5: every file reachable by the Parquet conversion

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

What was added:

* `images` configuration: the 41 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 31 `.npz` coordinate files (26,399,936 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_Sphere_of_Realization_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_Sphere_of_Realization_pretraining_corpus.jsonl`, `sft_alpaca/The_Sphere_of_Realization_sft_alpaca.json`, `sft_openai_chat/The_Sphere_of_Realization_sft_openai_chat.jsonl`, `sft_prompt_completion/The_Sphere_of_Realization_sft_prompt_completion.jsonl`, `sft_sharegpt/The_Sphere_of_Realization_sft_sharegpt.jsonl`, `vision_llava/The_Sphere_of_Realization_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_Sphere_of_Realization_vision_openai_chat_train.jsonl`, `vision_openai_chat/The_Sphere_of_Realization_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 (41): file name, the vision examples asked about it (questions and answers), and the earlier metadata columns where the folder had them |
| `coordinates/The_Sphere_of_Realization_coordinates.jsonl.gz` | 31 graphics, every stored array as JSON lists (0.34 GB of text) |
| `The_Sphere_of_Realization_documents.jsonl` | the 1 text documents of the folder (full texts, reports, audits) as rows |
| `vision_openai_chat/The_Sphere_of_Realization_vision_openai_chat_train.jsonl` | the OpenAI-layout vision file rewritten so every message `content` is a list of parts (66 string contents converted in 33 rows); the pictures and text are unchanged |
| `vision_openai_chat/The_Sphere_of_Realization_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_Sphere_of_Realization_LLM_Training_Dataset_rev6_files.jsonl` | every file of the revision (118 carried from The_Sphere_of_Realization_LLM_Training_Dataset_rev5, 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 | 41 | 5 |
| `coordinates` | train | loads | 31 | 3 |
| `documents` | train | loads | 1 | 4 |
| `vision_openai_chat` | train | loads | 33 | 1 |
| `vision_openai_chat` | validation | loads | 2 | 1 |
| `files` | train | loads | 123 | 4 |