Mishnah Arakhin 1:1-2

This is going to be epic! We're diving into Mishnah Arakhin, which is all about valuing people and their vows. Think of it like mapping out a complex financial system with a bunch of conditional logic. Let's fire up the debugger!

Problem Statement – The "Bug Report" in the Sugya

Our core "bug report" in Arakhin 1:1-2 is about entity validation and action attribution for vows of valuation. Essentially, we have a system where individuals can either make vows to donate a person's valuation to the Temple treasury, or be the subject of such a vow (meaning someone else vows to donate their valuation). The problem arises when we encounter entities with ambiguous or incomplete attributes (like a tumtum or a minor) or entities outside the primary user base (like a gentile). The system needs to determine, for each entity, which actions (making a vow, being valuated) are valid, and under what conditions. The Mishnah presents a series of cases that seem to have conflicting outputs or require fine-grained attribute checks, leading to potential exceptions or invalid operations. We need a robust logic engine that can handle these edge cases and ensure correct attribution.

Text Snapshot

Let's grab the relevant lines from the Mishnah, with anchors for our critical debugging points:

• Everyone takes vows of valuation and is thereby obligated to donate to the Temple treasury the value fixed by the Torah (see Leviticus 27:3–7) for the age and sex of the person valuated.
• And similarly, everyone is valuated, and therefore one who vowed to donate his fixed value is obligated to pay.
• Likewise, everyone vows to donate to the Temple treasury the assessment of a person, based on his market value to be sold as a slave, and is thereby obligated to pay; and everyone is the object of a vow if others vowed to donate his assessment.
• This includes priests, Levites and Israelites, women, and Canaanite slaves.
• A tumtum, whose sexual organs are concealed, and a hermaphrodite [androginos], vow, and are the object of a vow, and take vows of valuation, but they are not valuated.
• Consequently, if one says, with regard to a tumtum: The valuation of so-and-so is incumbent upon me to donate to the Temple treasury, he is not obligated to pay anything, as only a definite male or a definite female are valuated.
• A deaf-mute, an imbecile, and a minor are the object of a vow and are valuated, but neither vow to donate the assessment of a person nor take a vow of valuation, because they lack the presumed mental competence to make a commitment.
• A child less than one month old is the object of a vow if others vowed to donate his assessment, but is not valuated if one vowed to donate his fixed value, as the Torah did not establish a value for anyone less than a month old.
• With regard to a gentile, Rabbi Meir says: He is valuated in a case where a Jew says: It is incumbent upon me to donate the fixed value of this gentile. But a gentile does not take a vow of valuation to donate his fixed value or the value of others.
• Rabbi Yehuda says: He takes a vow of valuation, but is not valuated. And both this tanna, Rabbi Meir, and that tanna, Rabbi Yehuda, agree that gentiles vow to donate the assessment of another and are the object of vows, whereby one donates the assessment of a gentile.
• One who is moribund and one who is taken to be executed after being sentenced by the court is neither the object of a vow nor valuated.

Flow Model – The Decision Tree Architecture

Let's visualize this as a series of conditional checks and state transitions. Our primary entities are "Person" (with various attributes) and "VowAction" (either "VowToDonateValuation" or "BeValuated").

[START]
  |
  V
[INPUT: Person, VowAction]
  |
  V
[Check Person.Type]
  |
  +-- If Person.Type == "Moribund/Executed":
  |     |
  |     V
  |     [OUTPUT: NOT (VowToDonateValuation or BeValuated)]
  |
  +-- If Person.Type == "Gentile":
  |     |
  |     +-- IF VowAction == "VowToDonateValuation":
  |     |     |
  |     |     V
  |     |     [Check Rabbi Meir vs. Rabbi Yehuda]
  |     |       |
  |     |       +-- Rabbi Meir: [OUTPUT: NOT VowToDonateValuation]
  |     |       +-- Rabbi Yehuda: [OUTPUT: VowToDonateValuation]
  |     |
  |     +-- IF VowAction == "BeValuated":
  |     |     |
  |     |     V
  |     |     [Check Rabbi Meir vs. Rabbi Yehuda]
  |     |       |
  |     |       +-- Rabbi Meir: [OUTPUT: BeValuated]
  |     |       +-- Rabbi Yehuda: [OUTPUT: NOT BeValuated]
  |     |
  |     +-- IF VowAction == "VowToDonateAssessmentOfAnother":
  |     |     |
  |     |     V
  |     |     [OUTPUT: VowToDonateAssessmentOfAnother] (Both agree)
  |     |
  |     +-- IF VowAction == "BeObjectOfVow":
  |     |     |
  |     |     V
  |     |     [OUTPUT: BeObjectOfVow] (Both agree)
  |
  +-- If Person.Type == "Deaf-Mute/Imbecile/Minor":
  |     |
  |     V
  |     [Check Mental Competence]
  |       |
  |       +-- Low Competence:
  |       |     |
  |       |     V
  |       |     [OUTPUT: BeValuated, BeObjectOfVow]
  |       |     [OUTPUT: NOT (VowToDonateValuation or VowToDonateAssessmentOfAnother)]
  |       |
  |       +-- Sufficient Competence (Minor >= 13):
  |             |
  |             V
  |             [Process as regular entity]
  |
  +-- If Person.Type == "Child < 1 Month":
  |     |
  |     V
  |     [Check Torah Value Constraint]
  |       |
  |       +-- For VowToDonateValuation: [OUTPUT: NOT VowToDonateValuation] (No established value)
  |       +-- For BeObjectOfVow: [OUTPUT: BeObjectOfVow]
  |
  +-- If Person.Type == "Tumtum/Androginos":
  |     |
  |     V
  |     [Check Definite Sex Attribute]
  |       |
  |       +-- Indefinite Sex:
  |       |     |
  |       |     V
  |       |     [OUTPUT: VowToDonateValuation, BeObjectOfVow, VowToDonateAssessmentOfAnother]
  |       |     [OUTPUT: NOT BeValuated]
  |       |
  |       +-- Definite Sex (Implicitly handled by other branches):
  |             |
  |             V
  |             [Process as regular entity]
  |
  +-- If Person.Type == "Priest/Levite/Israelite/Woman/Canaanite Slave":
        |
        V
        [Standard Processing - All actions generally valid]
        |
        V
        [OUTPUT: VowToDonateValuation, BeValuated, VowToDonateAssessmentOfAnother, BeObjectOfVow]

[END]

Two Implementations – Algorithm A (Rishon) vs. Algorithm B (Acharon)

Let's look at how early commentators (Rishonim) and later ones (Acharonim) might parse this logic, akin to different algorithmic approaches.

Algorithm A: The Rishonim's Modular Approach (Focus on Textual Derivation)

The Rishonim, like Rambam and Tosafot, often approach these sugyot by meticulously dissecting the Mishna's phrasing and deriving rules from specific words and phrases. Their "code" is more like a series of if-then-else statements, often with explicit Gzera Shava (inference from similar linguistic constructions) or Binyan Av (drawing a general principle from a specific case).

Rambam's Logic (based on his commentary):

Rambam often provides a structured breakdown, and we can infer his algorithmic approach from his clear definitions and categorizations.

• Valuation (ערך - Erech): Defined as "ערכי עלי" (my valuation upon me) or "ערך פלוני עלי" (the valuation of so-and-so upon me). This requires a fixed value according to Torah law, based on age and sex.

  • Valuated (נערך - Ne'erach): An entity can be valuated if it has a definite sex and age for which the Torah assigns a value.
    • This explicitly excludes tumtum and androginos because they lack definite sex ("זכר ונקבה אמורים בפרשת ערכין עד שיהא זכר ודאי" - Rambam).
    • It includes priests, Levites, Israelites, women, and even Canaanite slaves (as they have a defined market value, even if their release has specific conditions).
    • Mishnah 1:1-2 also specifies:
      • Deaf-mutes, imbeciles, and minors are valuated (implies they have a definite sex/age, but their ability to make vows is limited).
      • Children less than one month old are not valuated because the Torah didn't establish a value for them ("התורה לא פסקה ... פחות מבן חדש" - Rambam).
      • Moribund or executed individuals are not valuated.
      • Gentiles: Rabbi Meir says they are valuated if a Jew vows their value. Rabbi Yehuda disagrees.

• Vow (נדר - Nedar): Defined as "דמי עלי" (my price upon me) or "דמי פלוני עלי" (the price of so-and-so upon me). This refers to the market value an individual would fetch if sold as a slave.

  • Vows (נודר - Noder): An entity can make a vow if they have the mental capacity and legal standing to commit.
    • This excludes deaf-mutes, imbeciles, and minors because they lack mental competence ("חסרי דעת" - Rambam).
    • It includes priests, Levites, Israelites, women, and Canaanite slaves.
    • Tumtum and androginos can make vows.
    • Children less than one month old can be the object of a vow but the Mishnah doesn't explicitly state they can make vows, but the general "everyone vows" implies they might, if capable. Rambam clarifies that "less than one month old... is the object of a vow" (נדר - referring to being vowed, not making a vow).
    • Moribund or executed individuals are not the object of a vow (implies they can't make them either, as their status overrides general rules).
    • Gentiles: Rabbi Meir says they do not take vows of valuation. Rabbi Yehuda says they do. Both agree they can be the object of a vow or vow to donate another's assessment.

Rambam's Algorithm Outline:

1. Input: Entity, Action (e.g., VowToDonateValuation, BeValuated)
2. Pre-check: If Entity.Status == "MoribundOrExecuted", return False for all actions.
3. Entity Type Branching:
   • If Entity.Type == "TumtumOrAndroginos":
     • If Action == BeValuated: Return False (lacks definite sex).
     • If Action == VowToDonateValuation: Return True.
     • If Action == BeObjectOfVow: Return True.
   • If Entity.Type == "DeafMuteOrImbecileOrMinor":
     • If Action == VowToDonateValuation or Action == VowToDonateAssessmentOfAnother: Return False (lack of competence).
     • If Action == BeValuated: Return True.
     • If Action == BeObjectOfVow: Return True.
   • If Entity.Type == "ChildLessThanOneMonth":
     • If Action == VowToDonateValuation: Return False (no Torah value).
     • If Action == BeObjectOfVow: Return True.
   • If Entity.Type == "Gentile":
     • If Action == VowToDonateValuation: Return RabbiYehuda's opinion (True).
     • If Action == BeValuated: Return Rabbi Meir's opinion (True, if vowed by Jew).
     • If Action == VowToDonateAssessmentOfAnother or Action == BeObjectOfVow: Return True (both agree).
   • Else (Default - Priest, Levite, Israelite, Woman, Slave):
     • Return True for all actions.

Algorithm B: The Acharonim's Integrated System (Focus on Functional Logic and Refinement)

The Acharonim, like the Tosafot Yom Tov, often build upon the Rishonim, but their commentary can feel more like refining existing code, adding specific checks, or optimizing for clarity. They might introduce more explicit function calls or structured data representations.

Tosafot Yom Tov's Logic (integrating previous layers):

Tosafot Yom Tov's commentary often clarifies ambiguities and synthesizes earlier discussions. We can see this as adding more nuanced checks or handling specific overrides.

• General Principle Expansion: "הכל מעריכין ונערכין נודרין ונידרים" (Everyone takes vows of valuation and is valuated, vows and is vowed) is the baseline.
• Clarifications on "Everyone":
  • Priests/Levites: Explicitly included in both valuation and vows, contrasting with laws of Pidyon Haben (redemption of firstborn son). "כהנים ולוים כדי שלא תחשוב שאינן חייבין בערכין" (TYT).
  • Women/Slaves: Included. TYT notes the potential complication for a woman (her vow depending on her husband/father) and a slave (his release), suggesting they might be vowed even if their masters/husbands have rights, or vows are made "on condition that the master or husband has no right in them." This implies conditional logic within the vow action.
  • Deaf-mute, Imbecile, Minor: TYT notes that the age for vows being "checked" is 12 years and one day, not 13. "בן י"ב שנה ויום אחד נדריו נבדקין" (TYT). This is a crucial parameter for the "minor" check.
  • Tumtum/Androginos: The core issue is "definite male or definite female" for valuation. They vow and are vowed. TYT highlights the disagreement about why they aren't valuated – it's because the Torah's verses for valuation specify definite male/female.
  • Child < 1 Month: TYT reiterates the Rambam's point: can be object of a vow, but not valuated.
  • Gentile: TYT summarizes the R' Meir/R' Yehuda dispute regarding taking vows and being valuated.
  • Moribund/Executed: Not valuated and not the object of a vow. This status acts as a hard exclusion.
• Refined Valuated Logic: For someone to be valuated, they need a definite sex attribute. This is why tumtum and androginos are excluded from being valuated.
• Refined Vows Logic: For someone to make a vow, they need mental competence. This excludes deaf-mutes, imbeciles, and minors (under 12 years and a day).

Tosafot Yom Tov's Integrated Algorithm Outline:

1. Input: Entity, Action

2. Global Exclusion Check: If Entity.Status == "MoribundOrExecuted": Return False for VowToDonateValuation and BeValuated.

3. Entity Attribute Extraction:

   • Entity.Age
   • Entity.SexDefiniteness (DefiniteMale, DefiniteFemale, Indefinite)
   • Entity.MentalCompetence (High, Low)
   • Entity.IsGentile (Boolean)
   • Entity.IsPriestLevite (Boolean)
   • Entity.IsSlave (Boolean)
   • Entity.IsWoman (Boolean)

4. Action-Specific Logic:

   • BeValuated Function:

     • If Entity.Status == "MoribundOrExecuted": Return False.
     • If Entity.SexDefiniteness == Indefinite: Return False (e.g., tumtum, androginos).
     • If Entity.Age < 1_month: Return False (no Torah value).
     • If Entity.IsGentile: Return Rabbi Meir's opinion (True, if vowed by Jew).
     • Else: Return True.

   • VowToDonateValuation Function:

     • If Entity.Status == "MoribundOrExecuted": Return False.
     • If Entity.MentalCompetence == Low (e.g., deaf-mute, imbecile, minor < 12y 1d): Return False.
     • If Entity.IsGentile: Return Rabbi Yehuda's opinion (True).
     • Else: Return True.

   • BeObjectOfVow Function:

     • If Entity.Status == "MoribundOrExecuted": Return False.
     • Else: Return True. (This is the broadest category; even those with low competence or indefinite sex can be vowed).

   • VowToDonateAssessmentOfAnother Function:

     • If Entity.Status == "MoribundOrExecuted": Return False.
     • If Entity.MentalCompetence == Low: Return False.
     • If Entity.IsGentile: Return True (both agree).
     • Else: Return True.

Key Difference: Algorithm A (Rishon) tends to be more explicit about deriving rules from the text's structure and word choices. Algorithm B (Acharon) integrates these rules into a more functional, layered system, clarifying parameters (like minor's age) and handling interactions more programmatically.

Edge Cases – Inputs That Break Naïve Logic

Let's test our system with some tricky inputs that would cause a simple if-then chain to fail.

Edge Case 1: The "Vowed" Tumtum

• Input:
  • Entity: Tumtum (Indefinite Sex)
  • Action: BeValuated
• Naïve Logic: A tumtum is a "person," and "everyone" is valuated. So, they should be valuated.
• Problem: The Mishnah explicitly states, "...but they are not valuated. Consequently, if one says... he is not obligated to pay anything, as only a definite male or a definite female are valuated." The naïve logic misses the specific attribute check for valuation.
• Expected Output: False (The tumtum cannot be valuated).

Edge Case 2: The Vowing Minor

• Input:
  • Entity: Minor, aged 10 years.
  • Action: VowToDonateValuation
• Naïve Logic: A minor is a person, and "everyone takes vows of valuation." So, they should be able to make this vow.
• Problem: The Mishnah states that minors "...neither vow to donate the assessment of a person nor take a vow of valuation, because they lack the presumed mental competence to make a commitment." The naïve logic ignores the critical dependency on mental capacity for making vows, even if they can be valuated.
• Expected Output: False (The minor cannot make this vow).

Refactor – One Minimal Change to Clarify the Rule

Our goal is to make the logic as clear and robust as possible. The most significant point of potential confusion is the distinction between making a vow and being the subject of a vow, and the specific attribute requirements for each.

Refactor: Introduce an explicit VowActionType enum/parameter for clarity.

Instead of passing a generic Action string, we can define distinct action types:

class VowActionType:
    VOW_TO_DONATE_VALUATION = "VOW_TO_DONATE_VALUATION" # "ערכי עלי" - requires mental competence, definite sex for the subject
    BE_VALUATED = "BE_VALUATED"                        # "ערך פלוני עלי" - requires definite sex for the subject
    VOW_TO_DONATE_ASSESSMENT_OF_ANOTHER = "VOW_TO_DONATE_ASSESSMENT_OF_ANOTHER" # "דמי פלוני עלי" - requires mental competence
    BE_OBJECT_OF_VOW = "BE_OBJECT_OF_VOW"              # "דמי עלי" - generally applies to all statuses, even those with limitations on other actions.

Impact of Refactor:

This change doesn't alter the underlying logic's outcome but vastly improves its readability and maintainability. It clearly separates the conceptual actions involved. For instance, when we see BeObjectOfVow, we immediately know it's the broadest category, often applying even when other actions are prohibited. Conversely, VowToDonateValuation clearly signals the need for mental competence from the vow-maker and definite sex for the subject being valued. This explicit typing acts like adding type hints in code, preventing subtle bugs where similar-sounding actions might be conflated.

Takeaway

The sugya of Arakhin 1:1-2 is a masterclass in attribute-based conditional logic. It teaches us that when evaluating entities and their potential actions within a system (like making or being subject to vows), we can't rely on a single, flat set of rules. Instead, we need a layered architecture with distinct validation functions for each action type:

• BeValuated requires a "definite sex" attribute and a value defined by Torah law (age > 1 month).
• VowToDonateValuation requires mental competence from the actor and is limited to those with definite sex for the subject.
• BeObjectOfVow is the most permissive, generally applying to all, even those with disabilities or unclear status, provided they aren't in a terminal state.
• VowToDonateAssessmentOfAnother requires mental competence from the actor.

The disputes between Rabbis (Meir vs. Yehuda on gentiles) are like configuration parameters that can be toggled, affecting the output of specific action-entity combinations. This intricate system, with its specific exclusions (moribund, tumtum for valuation, minors for vowing) and inclusions, demonstrates the power of precise attribute checking in complex rule engines. It's a beautiful example of how Halakha builds robust, nuanced systems by defining properties and permissions for every possible agent and action. We've successfully mapped Arakhin's logic into a systems thinking framework!