---
license: cc-by-4.0
task_categories:
- other
language:
- he
tags:
- hebrew
- judaism
- jewish-studies
- structured-data
- talmud
- tanakh
- halakha
- rambam
- mishna
pretty_name: "Jewish Texts Structure Dataset"
size_categories:
- n<1K
---

# Jewish Texts Structure Dataset

## Summary

This dataset provides a structured, machine-readable catalog summarizing the divisions and lengths of fundamental Jewish texts. It is designed to be a foundational resource for developers and researchers building applications, tools, or conducting analyses related to Jewish studies.

The dataset contains over 200 records, with each record representing a book (e.g., Genesis), a tractate (e.g., Berakhot), or a major section (e.g., Shulchan Aruch Orach Chayim), summarizing its total number of chapters, pages, or sections.

The following corpora are included:
*   **Tanakh (תנ"ך)**: The Hebrew Bible, divided by Perek (chapter).
*   **Mishna (משנה)**: The six orders of the Mishna, divided by Perek (chapter).
*   **Talmud Bavli (תלמוד בבלי)**: The Babylonian Talmud, divided by Daf (folio).
*   **Talmud Yerushalmi (תלמוד ירושלמי)**: The Jerusalem Talmud, divided by Daf (folio).
*   **Rambam (רמב"ם)**: Maimonides' Mishneh Torah, divided by Sefer (book), Hilkhot (laws), and Perek (chapter).
*   **Halakha (הלכה)**: Major Halakhic codes, including:
    *   Arba'ah Turim (ארבע טורים)
    *   Shulchan Aruch (שולחן ערוך)
    *   Mishnah Berurah (משנה ברורה)
    *   Biur Halakha (ביאור הלכה)

## Potential Use Cases

This dataset is not intended for training a model directly but serves as a structured knowledge base providing the parameters for generating detailed study cycles. Potential applications include:
*   **Study Trackers:** Powering applications for tracking daily study cycles. For example, a "Daf Yomi" app would read the record for a given tractate to know its total number of pages.
*   **API Development:** Creating a REST API to query the structure of Jewish texts (e.g., `GET /api/shas/berakhot` to retrieve the total page count).
*   **Data Visualization:** Generating visualizations to compare the lengths and structures of different books and sections.
*   **Educational Tools:** Building backends for educational software that require knowledge of text boundaries and divisions.
*   **Project Planning:** Scoping projects that involve processing or annotating these texts by providing clear counts of units.

## Languages

The data itself is structural, but all names for categories, books, and units are in **Hebrew (he)**.

## Dataset Structure

### Data Instances

Each record is a JSON object summarizing a single book or a major textual division.

**Example from `ש"ס` (a simple structure):**
This record shows that Tractate Shabbat in the Babylonian Talmud has 156 folios (Dapim).

```json
{
  "source_file": "shas.json",
  "main_category": "תלמוד בבלי",
  "subcategory": "סדר מועד",
  "book": "שבת",
  "content_type": "דף",
  "count": 156.0
}
```

**Example from `הלכה` with exclusions:**
This shows that Tur Yoreh De'ah has 403 sections (Simanim), but Siman 169 is excluded from the standard count.

```json
{
  "source_file": "halakha.json",
  "main_category": "הלכה",
  "subcategory": "ארבע טורים",
  "book": "טור יורה דעה",
  "content_type": "סימן",
  "count": 403,
  "excluded_units": [169]
}
```

**Example from `רמב"ם` (with structured parts):**
This shows that Rambam's `ספר המדע` has a total of 46 chapters, and it preserves the detailed internal breakdown of the laws (`הלכות`) within the `parts` array.

```json
{
  "source_file": "rambam.json",
  "main_category": "רמב\"ם",
  "subcategory": "משנה תורה",
  "book": "ספר המדע",
  "content_type": "פרק",
  "count": 46,
  "parts": [
    {"name": "הלכות דעות", "start": 1, "end": 7},
    {"name": "הלכות יסודי התורה", "start": 1, "end": 10},
    {"name": "הלכות עבודה זרה וחוקות הגויים", "start": 1, "end": 12},
    {"name": "הלכות תלמוד תורה", "start": 1, "end": 7},
    {"name": "הלכות תשובה", "start": 1, "end": 10}
  ]
}
```

### Data Fields

*   `source_file` (string): The name of the source JSON file from which the record was generated (e.g., "shas.json", "rambam.json").
*   `main_category` (string): The highest-level collection, e.g., "תלמוד בבלי", "רמב\"ם", "הלכה".
*   `subcategory` (string): A major section within a category, e.g., "סדר מועד", "משנה תורה", "שולחן ערוך".
*   `book` (string): The name of the specific book, tractate, or section being summarized, e.g., "בראשית", "שבת", "ספר המדע".
*   `content_type` (string): The name of the unit being counted, e.g., "דף", "פרק", "סימן".
*   `count` (int | float): The total number of units in the book or section. For Talmud, this can be a float to account for half pages.
*   `parts` (array | optional): An array of objects present only for complex texts like Rambam or Mishnah Berurah. It preserves the internal subdivisions, with each object containing a `name`, `start`, and `end` unit number.
*   `excluded_units` (array | optional): An array of integers present only for texts where specific units are traditionally skipped in the count (e.g., Tur).

### Data Splits

The dataset consists of a single split: `train`.

## Dataset Creation

### Curation Rationale

The dataset was programmatically generated from a set of JSON configuration files that define the structure of each corpus. This approach was chosen to ensure consistency, accuracy, and easy maintainability. The source files are based on the canonical, standard print editions of these texts.

### Source Data

The data was generated from a collection of hand-curated JSON files that describe the hierarchical structure of each text. The generation script parses these files and creates a summary record for each book:

*   **Simple Range**: For texts like `בראשית`, the source `{ "pages": 50 }` is parsed to a single record with `"count": 50`.
*   **Range with Exclusions**: For `טור יורה דעה`, the source `{ "pages": 403, "exclude": [169] }` is parsed to a record with `"count": 403` and an `"excluded_units": [169]` field.
*   **Structured Parts**: For complex texts like **Rambam**, the script processes the `"parts"` array, calculates the total `count` of all units, and includes the original `parts` array in the final record for detailed context.
*   **Structured Parts with Exclusions**: For texts like **Biur Halakha**, the script processes each part, accounts for any exclusions within it, calculates a total `count`, and stores the structured `parts` array.

This structured, declarative approach allows for a precise and verifiable representation of each text's canonical structure.

### Annotations

The dataset is not annotated. It is a structured summary of the canonical divisions of the texts, generated automatically from the source files.

### Personal and Sensitive Information

This dataset contains no personal or sensitive information. It exclusively catalogs the structure of religious texts.

## Additional Information

### Dataset Curators

This dataset was curated and prepared by **NHLOCAL**.

### Licensing Information

The dataset is released under the **cc-by-4.0 License**.

### Citation Information

If you use this dataset in your work, please consider citing it as follows:

```bibtex
@dataset{nhlocal_judaic_texts_structure,
  author       = {NHLOCAL},
  title        = {judaic Texts Structure Dataset},
  year         = {2025},
  publisher    = {Hugging Face},
  version      = {2.0.0},
  url          = {https://huggingface.co/datasets/NHLOCAL/judaic-texts-structure}
}
```