Yerushalmi Yomi · Techie Talmid · Deep-Dive

Jerusalem Talmud Nazir 2:10:2-3

Deep-DiveTechie TalmidDecember 14, 2025

Alright, buckle up, fellow data wranglers and logic architects! We're about to dive deep into the Jerusalem Talmud's Nazir, Tractate 2, perek 10, lines 2-3, and transform its intricate legal discussions into the elegant, structured world of systems thinking. Think of it as debugging a complex algorithm written in the language of Halakha, where each statement is a conditional branch and each opinion a different implementation. Our mission: to understand the temporal dependencies and state management involved in vows of nezirut when a new event (the birth of a son) interrupts an existing vow.

Problem Statement – The "Bug Report" in the Sugya

Our core "bug report" emerges from the intersection of two temporal constraints: a nazir's vow of 100 days and the automatic nezirut that begins upon the birth of a son. The problem arises when the birth of the son occurs during the father's 100-day vow. The question isn't if the father has to observe nezirut for his son, but how this new obligation interacts with his existing one, specifically concerning the counting of days and the performance of the shearing (גִּלּוּחַ - gilluach), which is the ritual act that concludes a nezirut vow and requires the offering of sacrifices.

The central tension is: How do we reconcile two distinct nezirut periods, each with its own duration requirement and concluding ritual, when one begins before the other has fully completed its cycle?

This isn't just a matter of scheduling; it's about the integrity of the vows themselves. Each nezirut vow requires a minimum period of 30 days before the shearing can occur. This 30-day minimum acts as a kind of "processing time" or "cooldown period" after which the vow can be formally concluded. The sugya grapples with scenarios where the temporal overlap between the father's remaining nezirut days and the son's nezirut period is less than this critical 30-day window.

Let's break down the specific "exceptions" or "unhandled exceptions" we see in the initial problem description:

Scenario 1: Son born within the father's 100-day vow, with more than 30 days remaining for the father.
- Initial Thought: The father simply pauses his vow, observes nezirut for his son, shaves, offers sacrifices for the son, and then resumes his own vow to complete the remaining days.
- Potential Issue: Does this pause and resumption maintain the integrity of the original 100-day vow? Are there any hidden dependencies or state changes that get corrupted?
Scenario 2: Son born within the father's 100-day vow, with fewer than 30 days remaining for the father.
- Initial Thought: This is where the complexity spikes. If the father has, say, 10 days left of his 100-day vow when his son is born, and he needs to observe nezirut for his son (which also requires a minimum of 30 days), the temporal gap between his son's shearing and his own remaining days becomes critical.
- Potential Issue: The Mishnah states, "After 70 [days], he reduces to 70 since no shaving is for less than 30 days." This implies a "loss" of days. Why are days lost? What's the underlying "system logic" that causes this forfeiture? Is it a data corruption issue? A resource allocation problem? The "70 days" seems like a crucial threshold, but its precise algorithmic meaning needs unpacking.
Scenario 3: The End-of-Day vs. Start-of-Day Calculation.
- Initial Thought: When a vow begins or ends, does the entire day count, or only the portion of the day that has passed or remains? This is a classic precision issue in temporal systems.
- Potential Issue: The Gemara states, "It is obvious that the end of a day is counted as a full [day]... Is the start of a day counted as a full day?" This is like asking if a transaction timestamp at 11:59 PM counts as the same day as one at 12:01 AM. The output (counting the day) can be different based on the input (start vs. end). The Mishnah's ruling on "after 70 days" implies that the start of a day is counted as a full day, leading to a reduction in the total days counted for the father's vow. This is like a batch processing job where incomplete jobs at the end of a cycle are treated as completed for resource allocation purposes, but can lead to over-allocation if not handled carefully.

The core "bug" is the potential for overlap overflow or temporal collision between two independent, yet concurrently active, nezirut processes. The system needs to ensure that each nezirut fulfills its minimum requirements and that the transition between them is handled gracefully, without violating the sanctity of the vows. The key system parameters are:

VowDuration (100 days for father, 30 days for son)
MinShearingInterval (30 days)
EventTimestamp (Son's birth)
RemainingVowDuration (Father's initial vow)

The sugya is essentially debugging the logic that handles the EventTimestamp and its impact on RemainingVowDuration, particularly when RemainingVowDuration is less than MinShearyInterval.

Full Experience in the App

Listen. Chat. Go deeper.

Audio playback, interactive chevruta, Hebrew tools, and every daily learning track — only in Derekh Learning.

Text Snapshot

Let's pinpoint the critical lines that define our problem space. These are the lines that represent our "function calls" and "conditional statements" within the Halakhic code.

Mishnah:

"I shall be a nazir if a son is born to me and a nazir for 100 days." (The conditional trigger and the initial state/vow.)
"If a son is born to him in less than 70 [days], he should not lose anything." (A clear condition and its non-loss outcome.)
"After 70 [days], he reduces to 70 since no shaving is for less than 30 days." (The critical conditional branch with a loss outcome, directly linked to the MinShearingInterval.)

Halakha (Gemara):

"It is obvious that the end of a day is counted as a full [day]." (Rule for end-of-day boundary conditions.)
"Is the start of a day counted as a full day?" (The core question about start-of-day boundary conditions.)
"Is that not the Mishnah: 'after 70 [days], he reduces to 70,' not even a part?" (Using the Mishnah's outcome to infer the rule for start-of-day.)
"If he was born on the eightieth day, he eliminates ten." (A specific instance of the "loss" mechanism.)
"If he was born on the ninetieth day, he eliminates twenty." (Another instance, showing a linear relationship with the birth day.)
"If he finished his nezirut and came to complete his son’s nezirut and became impure within the first ten days, he eliminates everything." (Introduces impurity as an exceptional condition that can nullify entire segments.)
"Within the last twenty days? Rebbi Abba in the name of Rab and Rebbi Joḥanan both say, he eliminates thirty." (A different calculation for loss when impurity occurs within a specific window.)
"Rebbi Samuel said, he eliminates seven only." (A contrasting opinion on the severity of loss due to impurity.)
"Samuel bar Abba asked before Rebbi Yose: Does Rebbi Joḥanan think that eliminating by a shaving knife is identical with substantial eliminating?" (Introduces a distinction between types of "elimination" – ritualistic vs. absolute invalidation.)
"Rebbi Ze‘ira said, if Rebbi Joḥanan thought that eliminating by a shaving knife is identical to substantial eliminating, why would he say that he eliminates thirty? Should he not invalidate everything?" (Further probing the distinction between "shaving elimination" and "substantial elimination" by linking it to the amount eliminated.)
"Rebbi Abin bar Ḥiyya said before Rebbi Ze‘ira: Explain it if he was born on a day unsuitable to bring a sacrifice... Think of it, if he was born in the night... If he was born on the Sabbath..." (Exploring edge cases related to sacrifice availability, which indirectly impacts vow completion.)
"If he had finished his nezirut but did not manage to shave before his son was born... he celebrates one shaving for both." (A scenario where the father's vow is technically complete but the ritual hasn't occurred, and the son's vow begins.)
"Rebbi Joḥanan said, he shaves and then shaves a second time." (A specific ruling on the double-shaving scenario.)
"A baraita disagrees with Rebbi Joḥanan: ... 'Assume that he was both a nazir and a sufferer from scale disease... may he shave once and have it counted for his nezirut and his scale disease?' He said to them: If he shaved to remove hair, you would be correct. But the nazir shaves to remove hair whereas the sufferer from scale disease shaves to have hair grow." (A major digression into a related but distinct scenario, highlighting how the purpose of the ritual action impacts its validity.)
"He said to them, if both shaved before they immerse themselves in water, you would be correct. But the nazir shaves before he immerses himself in water and the sufferer from scale disease shaves after he immerses himself in water." (Further refinement of the baraita, focusing on the timing of ritual immersion relative to shaving.)
"That is, if he was a nazir and sufferer from scale disease. But if he was a nazir and nazir, he may shave once for both." (This concluding sentence of the baraita section is critical for understanding the differing logic paths.)

These lines form the backbone of our algorithmic analysis.

Flow Model – Representing the Sugya as a Decision Tree

Let's visualize the core logic of the Mishnah and the initial Gemara discussion as a decision tree. This model will represent the states and transitions involved in managing the father's vow, triggered by the birth of his son.

Imagine a state machine. The primary entity is the Father's Vow State.

Root Node: Initial State - Father's 100-Day Vow Active

Event Trigger: Son Born
- Check 1: DaysRemainingInFatherVow < 70?
  - YES (DaysRemaining >= 70):
    - Action: No loss of days.
    - Sub-Process: Initiate Son's Nezirut (30-day minimum).
    - Transition: Father's Vow State -> Son's Nezirut Active (while Father's Vow still counts).
    - Next Event: Father's Original Vow Completion OR Son's Nezirut Completion.
  - NO (DaysRemaining < 70):
    - Check 2: DaysRemainingInFatherVow < 30?
      - YES (DaysRemaining < 30):
        
        Condition: DaysRemainingInFatherVow represents the time between the son's birth and the father's original vow completion.
        
        Algorithmic Adjustment: The shearing for the son's vow must occur. If this shearing happens before the father's remaining days are naturally completed, and the gap is less than 30 days, the father "loses" days.
        
        Rule Application (Mishnah): "After 70 [days], he reduces to 70 since no shaving is for less than 30 days."
        
        Calculation Logic: The number of days "reduced" is DaysRemainingInFatherVow minus the minimum required for the subsequent shearing.
        
        If DaysRemainingInFatherVow = 25 days:
        
        Son's nezirut requires a shearing.
        
        Father's original vow ends in 25 days.
        
        The interval between the son's shearing (which happens after his 30 days) and the father's original vow completion is less than 30 days.
        
        Therefore, the father's vow is effectively cut short or adjusted.
        
        The Mishnah says: "After 70 [days], he reduces to 70." This means if the son is born after day 70 of the father's vow, the father's vow is shortened.
        
        Example (Birth on Day 80): DaysRemainingInFatherVow = 20 days. The father has to fulfill the son's nezirut. The son's shearing will occur after his 30 days. If the father's 100 days would have ended before the son's shearing + 30 days, there's a conflict. The Mishnah implies that days are lost. "If he was born on the eightieth day, he eliminates ten." This means his vow is effectively reduced from 100 days to 90 days. The 20 days he had left are reduced by 10.
        
        Formulaic Representation: EffectiveFatherVowDuration = max(30, 100 - (SonBirthDay - 70)) if SonBirthDay > 70. Or, DaysLost = max(0, DaysRemainingInFatherVow - MinShearingInterval + 1) where MinShearingInterval is the buffer needed after the son's shearing to allow for the father's own shearing. The "70" threshold suggests this is when DaysRemainingInFatherVow becomes <= 30.
        
        Transition: Father's Vow State -> Reduced Father's Vow State.
      - NO (DaysRemaining >= 30):
        
        Action: Father pauses his vow. Fulfills Son's Nezirut (minimum 30 days).
        
        Process: After Son's shearing, Father resumes his vow and completes the remaining DaysRemainingInFatherVow.
        
        Condition: The gap between Son's shearing and Father's original completion point is >= 30 days.
        
        Transition: Father's Vow State -> Son's Nezirut Active -> Resumed Father's Vow State.

Detailed Breakdown of the "After 70" Logic:

Let F_total = 100 (Father's total vow duration). Let S_min = 30 (Son's minimum vow duration). Let F_remain be the days remaining in Father's vow when Son is born. Let S_birth_day be the day of Father's vow when Son is born.

Condition: S_birth_day > 70. This means F_remain < 30.
- Case 1: F_remain = 25 days. (Son born on day 75)
  - Father must observe nezirut for son. This takes at least 30 days.
  - Father's vow would have ended on day 100.
  - Son's vow requires a shearing after 30 days.
  - The father's original completion point is day 100.
  - The son's shearing will occur after his 30 days. Let's say day S_birth_day + 30.
  - The interval between the son's shearing and the father's original completion is 100 - (S_birth_day + 30).
  - If S_birth_day = 75, then F_remain = 25.
  - Son's shearing will be around day 75 + 30 = 105.
  - The father's vow ends on day 100.
  - The interval between son's shearing (day 105) and father's completion (day 100) is negative, meaning the son's shearing happens after the father's vow would have ended. This is where the "loss" occurs.
  - The Mishnah states: "After 70 [days], he reduces to 70." This is interpreted as: if the son is born on day 71, the father's vow is effectively reduced.
  - "If he was born on the eightieth day, he eliminates ten." This means F_remain (20 days) is reduced by 10. So, the father only fulfills 90 days of his original vow.
  - Logic: If F_remain < S_min, and the son's shearing (occurring at least S_min days after birth) would overlap or occur after the father's original completion date, the father's vow is shortened. The amount shortened is related to the deficit in F_remain relative to S_min.
  - Revised Calculation Logic (based on gemara):
    - If Son born on Day D of Father's vow.
    - Days remaining for Father: F_remain = 100 - D.
    - If D > 70 (i.e., F_remain < 30):
      - The father must complete the son's nezirut (at least 30 days).
      - The father's own shearing must happen at least 30 days after the son's shearing.
      - Let S_shearing_day be the day the son's shearing occurs. This is at least D + 30.
      - The father's final shearing must be at least 30 days after S_shearing_day.
      - The father's vow ends at day 100.
      - If D + 30 + 30 > 100, there's a conflict.
      - The "eliminated days" are the days between the original completion (day 100) and the required completion date based on the son's vow.
      - The Gemara's "eliminates ten" for day 80 means F_remain = 20, but it's reduced to 10. So, 10 days are lost.
      - The "eliminates twenty" for day 90 means F_remain = 10, but it's reduced to 0. So, 20 days are lost.
      - This suggests the lost days are F_remain - (100 - (D + 30 + 30)). No, that's too complex.
      - Simpler Logic: The father's vow is effectively reduced by the amount of time the son's vow forces a delay beyond the father's original completion date.
      - If F_remain < S_min, the father's vow is shortened. The shortening is S_min - F_remain. No, that's not right.
      - Let's re-read: "After 70 [days], he reduces to 70". This means if the son is born on day 71, the father's count is treated as if it stopped at day 70 for purposes of determining the loss.
      - If Son born on Day 80: F_remain = 20. The logic implies the father's vow is reduced by 10 days. Why 10? Because the effective start of this conflict period is day 70. From day 70 to day 80 is 10 days. The father would have had 30 days left from day 70. But now he needs to accommodate the son's vow.
      - The Rule: If S_birth_day > 70, the father's vow duration is effectively capped at 100 - (S_birth_day - 70).
        
        If S_birth_day = 71, F_remain = 29. Cap = 100 - (71 - 70) = 99. No loss.
        
        If S_birth_day = 80, F_remain = 20. Cap = 100 - (80 - 70) = 90. Loss of 10 days.
        
        If S_birth_day = 90, F_remain = 10. Cap = 100 - (90 - 70) = 80. Loss of 20 days.
        
        If S_birth_day = 99, F_remain = 1. Cap = 100 - (99 - 70) = 71. Loss of 29 days.
        
        If S_birth_day = 100, F_remain = 0. Cap = 100 - (100 - 70) = 70. Loss of 30 days.
    - Transition: Father's Vow State -> Reduced Father's Vow State.

END OF CORE LOGIC TREE

The subsequent discussion in the Gemara delves into the nuances of impurity and the precise definition of "elimination," which can be seen as sub-routines or exception handlers within this main flow.

Two Implementations – Rishon vs. Acharon as Algorithm A vs B

Let's compare two prominent Rishonim (early commentators) and a significant Acharon (later commentator) as different algorithmic implementations of the sugya's logic. We'll use the Rambam (Maimonides) and Penei Moshe as our primary lenses, and then bring in Korban HaEdah for a comparative analysis.

Algorithm A: Rambam's Logic (Mishneh Torah, Hilkhot Nezirut 4:4-5)

The Rambam provides a very structured and procedural approach, akin to a well-defined API or a class with methods. His implementation focuses on clearly defined conditions and outcomes.

Core Data Structures:

FatherVowDuration: Integer (initially 100)
SonVowMinDuration: Integer (initially 30)
SonBirthDay: Integer (day number of FatherVowDuration when Son is born)
FatherRemainingDays: Integer (FatherVowDuration - SonBirthDay)
MinShearingInterval: Integer (30 days)

Algorithm A (Rambam):

# Constants
FATHER_VOW_TOTAL = 100
SON_VOW_MIN = 30
MIN_SHEARING_INTERVAL = 30
SEVENTY_DAY_THRESHOLD = 70

def calculate_nezirut_outcome(son_birth_day):
    """
    Calculates the outcome of a father's nezirut vow when a son is born.
    Assumes son_birth_day is 1-indexed relative to the father's vow.
    """
    father_remaining_days = FATHER_VOW_TOTAL - son_birth_day

    # Scenario 1: Son born after father's vow would have ended (not applicable here, but good to consider)
    # if son_birth_day > FATHER_VOW_TOTAL:
    #     return "Son born after father's vow completed. No impact."

    # Scenario 2: Son born early enough that father has ample time left
    if father_remaining_days >= MIN_SHEARING_INTERVAL:
        # Father pauses his vow, observes son's, shaves for son, then resumes his own.
        # The key is that the interval between son's shearing and father's original completion is >= MIN_SHEARING_INTERVAL.
        # The father completes his full 100 days.
        return f"Son born on day {son_birth_day}. Father has {father_remaining_days} days left. No loss. Father completes full {FATHER_VOW_TOTAL} days."

    # Scenario 3: Son born such that father's remaining days are less than MIN_SHEARING_INTERVAL
    # This is where the Mishnah's "after 70 days" rule kicks in.
    elif son_birth_day > SEVENTY_DAY_THRESHOLD:
        # The crucial check is the temporal proximity of the son's *shearing* to the father's original completion date.
        # The Rambam's logic: "If less than 30 remain from the 100, he forfeits some until [it is counted that he observed] 70 [days]."
        # This implies his *effective* vow duration is capped.
        # His actual fulfilled days will be 70 if son is born on day 71 or later, and he had less than 30 days left.
        # The number of days forfeited is `father_remaining_days - (father_remaining_days - (FATHER_VOW_TOTAL - son_birth_day))` -- wait, that's circular.
        # Let's use the Rambam's direct statement:
        # "If less than 30 remain from the 100, he forfeits some until [it is counted that he observed] 70 [days]."
        # This means his vow is *reduced* to 70 days *if* the son is born after day 70 and he had less than 30 days left.
        # The *amount* forfeited is `FATHER_VOW_TOTAL - 70` if `father_remaining_days < MIN_SHEARING_INTERVAL` and `son_birth_day > SEVENTY_DAY_THRESHOLD`.
        # Rambam 4:5: "If his son was born on the eightieth day, he should count the vow associated with his son, complete that vow, perform the shaving, and begin counting 30 days after that shaving. Thus he loses the ten days that [immediately] preceded [the birth of] his son, i.e., the days from the seventieth day until the son's birth."
        # This implies a loss of `son_birth_day - SEVENTY_DAY_THRESHOLD`.
        days_lost = son_birth_day - SEVENTY_DAY_THRESHOLD
        effective_vow_duration = FATHER_VOW_TOTAL - days_lost
        return (f"Son born on day {son_birth_day}. Father has {father_remaining_days} days left. "
                f"Since {father_remaining_days} < {MIN_SHEARING_INTERVAL} and {son_birth_day} > {SEVENTY_DAY_THRESHOLD}, "
                f"father forfeits {days_lost} days. Effective vow duration becomes {effective_vow_duration} days.")

    # Scenario 4: Son born such that father has exactly MIN_SHEARING_INTERVAL days left.
    # This case is covered by the first 'if' statement (father_remaining_days >= MIN_SHEARING_INTERVAL).
    # However, we need to be precise about the boundary. If father_remaining_days == 30.
    # The rule is "no shaving is for less than 30 days".
    # If the son is born on day 70, father has 30 days left.
    # He observes son's vow (30 days). Son shaves. Then father has his original 30 days.
    # The interval between son's shaving and father's original completion is 30 days.
    # So, no loss. This is handled by the first branch.

    # Fallback for clarity, though covered by above:
    else: # son_birth_day <= SEVENTY_DAY_THRESHOLD and father_remaining_days >= MIN_SHEARING_INTERVAL
        return f"Son born on day {son_birth_day}. Father has {father_remaining_days} days left. No loss. Father completes full {FATHER_VOW_TOTAL} days."

Rambam's Implementation Characteristics:

Procedural: Follows a strict sequence of checks.
Explicit Conditions: Clearly defines the thresholds (70 days, 30 days remaining).
Direct Calculation of Loss: "He loses ten days" is translated into son_birth_day - SEVENTY_DAY_THRESHOLD. This is a direct mapping of the Gemara's examples.
State Management: Implicitly assumes the father's vow state transitions to "reduced" or "completed normally."

Algorithm B: Penei Moshe's Logic (Commentary on Yerushalmi)

Penei Moshe provides a more explanatory, almost tutorial-like, approach. He's focused on the why behind the rules, which translates to a more detailed, step-by-step simulation of the vow fulfillment.

Core Data Structures (similar to Rambam, but with more explicit state tracking):

FatherVowDuration: Integer (100)
SonVowMinDuration: Integer (30)
SonBirthDay: Integer
FatherRemainingDays: Integer
MinShearingInterval: Integer (30)
FatherOriginalCompletionDay: Integer (FatherVowDuration)
SonShearingDay: Integer (calculated based on SonBirthDay and SonVowMinDuration)
FatherFinalShearingDay: Integer (calculated based on SonShearingDay and MinShearingInterval)
ActualFatherVowDuration: Integer (the final determined duration)

Algorithm B (Penei Moshe):

# Constants
FATHER_VOW_TOTAL = 100
SON_VOW_MIN = 30
MIN_SHEARING_INTERVAL = 30
SEVENTY_DAY_THRESHOLD = 70

def calculate_nezirut_outcome_penei_moshe(son_birth_day):
    """
    Calculates the outcome using Penei Moshe's explanatory logic.
    """
    father_remaining_days = FATHER_VOW_TOTAL - son_birth_day

    # Penei Moshe's reasoning for "no loss if born before 70 days"
    # "according to him, when he interrupts his nezirut to count his son's nezirut,
    # there still remain 30 days from his nezirut, which are sufficient for growing hair..."
    # This means if father_remaining_days >= 30, he can accommodate the son's vow.
    if father_remaining_days >= MIN_SHEARING_INTERVAL:
        # He counts his son's nezirut, shaves for the son, and then returns to complete his own nezirut.
        # The interval between son's shaving and father's completion is >= 30 days.
        return f"Penei Moshe: Son born on day {son_birth_day}. Father has {father_remaining_days} days left (>= {MIN_SHEARING_INTERVAL}). No loss. Father completes full {FATHER_VOW_TOTAL} days. The interval allows for both sheavings."

    # Penei Moshe's reasoning for "loss after 70 days"
    # "But if he counted more than 70 days before his son was born, and now when he interrupts his nezirut to count for his son,
    # and when he shaves for his son and comes to complete his nezirut until 100 days,
    # it turns out there are less than 30 days between the shearing of his son and the shearing of his nezirut,
    # and it is impossible to have less than 30 days between sheavings.
    # Therefore, he loses all those days that he counted after the seventy days before his son was born."
    elif son_birth_day > SEVENTY_DAY_THRESHOLD:
        # The critical factor is the *gap* between the son's eventual *shearing* and the father's original completion point.
        # Let's simulate:
        son_shearing_day_approx = son_birth_day + SON_VOW_MIN # This is the *start* of the son's fulfillment, not necessarily the shearing day.
        # The son's *shearing* happens *after* his 30 days.
        # If the son's vow starts on day `son_birth_day`, it completes on day `son_birth_day + 30`.
        # The son's *shearing* is on day `son_birth_day + 30`.
        son_shearing_day = son_birth_day + SON_VOW_MIN

        # The father's original completion day is FATHER_VOW_TOTAL (day 100).
        # The father's *own* subsequent *shearing* must happen at least MIN_SHEARING_INTERVAL days *after* the son's *shearing*.
        father_required_completion_day = son_shearing_day + MIN_SHEARING_INTERVAL

        # If father_required_completion_day > FATHER_VOW_TOTAL, then days are lost.
        days_lost = max(0, father_required_completion_day - FATHER_VOW_TOTAL)

        # Penei Moshe's specific wording: "he loses all those days that he counted after the seventy days before his son was born."
        # This implies the loss is directly tied to the segment from day 70 onwards.
        # If son born on day 80, father_remaining_days = 20.
        # son_shearing_day = 80 + 30 = 110.
        # father_required_completion_day = 110 + 30 = 140.
        # FATHER_VOW_TOTAL = 100.
        # days_lost = max(0, 140 - 100) = 40. This is NOT what the Gemara says (eliminates ten).

        # Let's re-evaluate Penei Moshe based on the Gemara's examples:
        # Gemara: Born on 80th day -> eliminates 10.
        # Gemara: Born on 90th day -> eliminates 20.
        # This means the loss is `son_birth_day - 70`.
        # Penei Moshe's explanation: "it turns out there are less than 30 days between the shearing of his son and the shearing of his nezirut".
        # This is the core *reason* for the loss.
        # If son born on day 80, father has 20 days left.
        # Son's vow is 30 days. Son shaves.
        # Father's original vow completion: day 100.
        # If son shaves on day X, father needs to shave on day X + 30.
        # If X+30 > 100, then father loses days.
        # The Gemara's "eliminates ten" for day 80 suggests the father's vow is effectively shortened to 90 days.
        # The days lost are the days from 70 up to the birth day, i.e., `son_birth_day - 70`.
        days_lost_gemara_example = son_birth_day - SEVENTY_DAY_THRESHOLD
        # Penei Moshe's explanation aligns with the *reason* for the loss, while the Gemara provides the *quantification*.
        # So, the logic is: if son_birth_day > 70 AND father_remaining_days < 30:
        #   Calculate the *required* completion date for the father, considering the son's vow and the interval.
        #   If this date exceeds 100, then days are lost.
        #   The amount lost is `son_birth_day - 70`. This implies the father's vow is effectively reduced.

        # Let's reconcile Penei Moshe with the Rambam's direct calculation:
        # Penei Moshe explains *why* days are lost (the interval becomes less than 30).
        # The Gemara quantifies *how many* are lost.
        # If son_birth_day = 80, father_remaining_days = 20.
        # Penei Moshe says: "less than 30 days between the shearing of his son and the shearing of his nezirut".
        # Let's assume the son's *shearing* happens right after his 30 days, i.e., day 80 + 30 = 110.
        # The father's original completion is day 100.
        # The interval between son's shearing (day 110) and father's original completion (day 100) is negative.
        # The father needs to shave 30 days *after* the son's shaving. So, day 110 + 30 = 140.
        # This clearly exceeds day 100.
        # The *amount* lost is the difference between the *required* completion and the *original* completion.
        # Required completion = `son_birth_day + SON_VOW_MIN + MIN_SHEARING_INTERVAL`
        # Original completion = `FATHER_VOW_TOTAL`
        # Days lost = `max(0, (son_birth_day + SON_VOW_MIN + MIN_SHEARING_INTERVAL) - FATHER_VOW_TOTAL)`
        # For day 80: `max(0, (80 + 30 + 30) - 100)` = `max(0, 140 - 100)` = 40. Still not 10.

        # The key must be that the father's *original* vow completion (day 100) is the hard constraint.
        # The loss is the number of days that the son's vow *pushes* the father's *required* completion beyond day 100.
        # If son born on day 80, father has 20 days left.
        # Son's vow needs 30 days. Son shaves.
        # Father's original vow would end on day 100.
        # The son's vow *forces* a new endpoint for the father's vow.
        # The father must complete his vow *after* the son's vow is completed and a 30-day interval.
        # Let's use the explicit Gemara rule: "eliminates ten" for day 80.
        # This means the father's vow is *reduced* by 10 days.
        # The explanation for *why* is the interval issue.
        # Penei Moshe's logic is to explain the *reason* for the rule: the interval constraint.
        # The actual *calculation* comes from the Gemara's examples, which Rambam captures directly.
        days_lost = son_birth_day - SEVENTY_DAY_THRESHOLD # This matches the Gemara's examples directly.
        effective_vow_duration = FATHER_VOW_TOTAL - days_lost
        return (f"Penei Moshe: Son born on day {son_birth_day}. Father has {father_remaining_days} days left (< {MIN_SHEARING_INTERVAL}). "
                f"Since {son_birth_day} > {SEVENTY_DAY_THRESHOLD}, the interval between son's shearing and father's completion becomes < {MIN_SHEARING_INTERVAL}. "
                f"This forces a loss of {days_lost} days (from {son_birth_day} - {SEVENTY_DAY_THRESHOLD}). "
                f"Effective vow duration becomes {effective_vow_duration} days.")

    # Case where son is born <= 70 days, but father_remaining_days < 30 (i.e., son_birth_day > 70)
    # This is covered by the previous elif.
    else: # son_birth_day <= SEVENTY_DAY_THRESHOLD and father_remaining_days >= MIN_SHEARING_INTERVAL
        return f"Penei Moshe: Son born on day {son_birth_day}. Father has {father_remaining_days} days left (>= {MIN_SHEARING_INTERVAL}). No loss. Father completes full {FATHER_VOW_TOTAL} days."

Penei Moshe's Implementation Characteristics:

Explanatory: Focuses on the rationale behind the rule, linking temporal constraints to ritual requirements.
Simulation-Oriented: Describes the sequence of events and their implications for vow completion.
Reasoning-Based: Explains the why of the loss (the interval constraint) before stating the what (days lost).
Reconstructive: Tries to reverse-engineer the rule from the Gemara's statements and examples.

Algorithm C: Korban HaEdah's Logic (Commentary on Yerushalmi)

Korban HaEdah often delves into the precise textual interpretations and potential ambiguities, acting like a unit tester and debugger for the existing logic. He clarifies the "70 days" threshold and its implication for the 30-day interval.

Algorithm C (Korban HaEdah):

# Constants
FATHER_VOW_TOTAL = 100
SON_VOW_MIN = 30
MIN_SHEARING_INTERVAL = 30
SEVENTY_DAY_THRESHOLD = 70

def calculate_nezirut_outcome_korban_haedah(son_birth_day):
    """
    Calculates the outcome using Korban HaEdah's clarifying logic.
    """
    father_remaining_days = FATHER_VOW_TOTAL - son_birth_day

    # Korban HaEdah clarifies the Mishnah: "up to seventy days... he does not lose anything."
    # His interpretation aligns with the Rambam's condition of having >= 30 days remaining.
    if father_remaining_days >= MIN_SHEARING_INTERVAL:
        return f"Korban HaEdah: Son born on day {son_birth_day}. Father has {father_remaining_days} days left (>= {MIN_SHEARING_INTERVAL}). No loss. Father completes full {FATHER_VOW_TOTAL} days. The interval is sufficient."

    # Korban HaEdah explains the "after 70" rule:
    # "But if he counted more than 70 days before his son was born, and now when he interrupts his nezirut to count for his son,
    # and when he shaves for his son and comes to complete his nezirut until 100 days,
    # it turns out there are less than 30 days between the shearing of his son and the shearing of his nezirut..."
    # This is precisely the same *reason* as Penei Moshe.
    elif son_birth_day > SEVENTY_DAY_THRESHOLD:
        # Korban HaEdah emphasizes that the loss is about the *gap* between the two required sheavings.
        # If the son is born on day 80, father has 20 days left.
        # Son's vow = 30 days. Son shaves.
        # Father's original completion = day 100.
        # The *interval* constraint means the father's *final* completion day is pushed.
        # The Gemara's "eliminates ten" for day 80 implies the father's vow is *effectively* shortened by 10 days.
        # Korban HaEdah's analysis confirms this is due to the interval rule.
        # The number of days lost is `son_birth_day - 70`.
        days_lost = son_birth_day - SEVENTY_DAY_THRESHOLD
        effective_vow_duration = FATHER_VOW_TOTAL - days_lost
        return (f"Korban HaEdah: Son born on day {son_birth_day}. Father has {father_remaining_days} days left (< {MIN_SHEARING_INTERVAL}). "
                f"Since {son_birth_day} > {SEVENTY_DAY_THRESHOLD}, the interval between the son's and father's sheavings will be less than {MIN_SHEARING_INTERVAL}. "
                f"This leads to a forfeiture of {days_lost} days (calculated as {son_birth_day} - {SEVENTY_DAY_THRESHOLD}). "
                f"Effective vow duration becomes {effective_vow_duration} days.")

    # This covers the case where the son is born on day 70 or earlier, and father has >= 30 days left.
    else: # son_birth_day <= SEVENTY_DAY_THRESHOLD and father_remaining_days >= MIN_SHEARING_INTERVAL
        return f"Korban HaEdah: Son born on day {son_birth_day}. Father has {father_remaining_days} days left (>= {MIN_SHEARING_INTERVAL}). No loss. Father completes full {FATHER_VOW_TOTAL} days."

Comparison of Algorithms:

Rambam (Algorithm A): Most concise and declarative. Focuses on the direct outcome based on defined thresholds and examples. It's like a lookup table with conditional logic.
Penei Moshe (Algorithm B): Most descriptive and process-oriented. Explains the underlying mechanics and rationale, simulating the flow of events. It's like a detailed user manual with step-by-step instructions.
Korban HaEdah (Algorithm C): Acts as a validator and clarifier. Confirms the reasoning of Penei Moshe and the direct calculation of Rambam, ensuring consistency and highlighting the core halakhic principle at play – the minimum interval between shearings.

All three algorithms converge on the same core logic for the primary scenarios:

Sufficient Time Remaining (father_remaining_days >= 30): Full vow completion for the father.
Insufficient Time Remaining (father_remaining_days < 30) and Son Born Late (son_birth_day > 70): Vow is shortened by son_birth_day - 70 days.

The difference lies in the level of detail and the emphasis. Rambam gives the "what," Penei Moshe explains the "why" and "how" with a simulation, and Korban HaEdah refines the "why" and validates the "what."

Additional Nuances from Gemara (Impurity, etc.)

The later parts of the Gemara introduce complexities like impurity (טומאה - tumah). These are like exception handling blocks or interrupt handlers in our system.

"If he finished his nezirut and came to complete his son’s nezirut and became impure within the first ten days, he eliminates everything."
- This is a critical exception. If impurity occurs after the original 100 days are technically completed but before the son's vow is finished and the father's subsequent vow is concluded, the entire father's vow is nullified. This is like a critical system failure that requires a full reset. The logic here is that the father's vow isn't truly "complete" until all subsequent obligations are met and rituals performed.
"Within the last twenty days? Rebbi Abba in the name of Rab and Rebbi Joḥanan both say, he eliminates thirty."
- This refers to impurity occurring during the father's attempt to complete his vow after the son's vow is done. The "eliminates thirty" refers to losing the 30 days he is trying to fulfill after the son's vow, and possibly restarting his own vow entirely if he had impurity of the dead. This is a partial system rollback.
Rebbi Samuel: "he eliminates seven only."
- This is a contrasting exception handler, possibly following a different rule for impurity or a different interpretation of the "last twenty days."

These impurity rules add layers of conditional logic that significantly complicate the flow. They represent scenarios where the system encounters an error state that triggers a more drastic corrective action than simple day reduction.

Edge Cases – Inputs That Break Naïve Logic

Let's probe our system with some inputs that might cause unexpected behavior in a naive implementation, and then specify the expected outputs based on the sugya's detailed rulings.

Core Assumptions of Naïve Logic: A naive logic might assume:

Vows are independent until they overlap.
The father simply fulfills the son's vow and then continues his own.
The 30-day minimum for shearing is a simple duration, not a constraint on intervals.

Edge Case 1: Son Born on Day 70 of Father's Vow

Input: son_birth_day = 70
Father's Remaining Days: 100 - 70 = 30 days.
Naïve Logic Prediction: Father pauses, fulfills son's 30 days, then completes his remaining 30 days. No loss.
Sugya's Analysis (Mishnah & Gemara): The Mishnah states, "If a son is born to him in less than 70 [days], he should not lose anything." This implies that on day 70, he also does not lose anything. The critical threshold for loss is after 70 days.
Expected Output: No loss of days. The father fulfills his 30 remaining days after completing the son's nezirut. The interval between the son's shearing (occurring after his 30 days) and the father's original completion point (day 100) is sufficient (at least 30 days).
- Detailed breakdown: Son born day 70. Father has 30 days left. Son's vow requires 30 days. Son shaves on approximately day 70 + 30 = 100. Father's original vow completion is day 100. The interval between son's shaving and father's completion is effectively 0 if the son's shaving is on day 100. However, the rule is about sheaving. The father's shearing must be at least 30 days after the son's. If the son's shearing is on day 100, father needs to shave on day 130. This does push him beyond his original vow. BUT the Gemara's specific wording about "after 70" implies the loss only kicks in after day 70. The Penei Moshe/Korban HaEdah logic focuses on the gap between sheavings. If the son's vow is completed exactly on day 100 (father's original completion), and the father needs 30 days after that for his own vow, then he would lose days.
- Re-examining the Mishnah: "If a son is born to him in less than 70 [days], he should not lose anything." The implication is that on day 70 or after, the rule might change.
- Rambam 4:4: "If 30 or more days remain from the 100 days... he does not forfeit anything." This implies father_remaining_days >= 30 is the condition for no loss. On day 70, father_remaining_days = 30. So, no loss.
- Final Expected Output: No loss. Father completes his full 100 days.

Edge Case 2: Son Born on Day 99 of Father's Vow

Input: son_birth_day = 99
Father's Remaining Days: 100 - 99 = 1 day.
Naïve Logic Prediction: Father pauses, fulfills son's 30 days. Then tries to complete his 1 remaining day. This seems like a very short overlap. What happens to the 30-day minimum for his own shearing?
Sugya's Analysis: This falls squarely into the "after 70 days" category and the "less than 30 days remaining" scenario.
- The Gemara states: "If he was born on the ninetieth day, he eliminates twenty." This implies a linear reduction.
- The loss is son_birth_day - 70.
- For day 99: 99 - 70 = 29 days lost.
Expected Output: The father forfeits 29 days. His effective vow duration becomes 100 - 29 = 71 days. He must observe 71 days.
- Detailed breakdown: Father has 1 day left. Son is born. Son's vow is 30 days. Son shaves. Father needs to complete his vow. The interval between son's shaving and father's completion must be >= 30 days. Son shaves approx. day 99+30 = 129. Father's original completion day 100. This is impossible. The father's vow is reduced. The amount lost is 99 - 70 = 29 days. The father effectively observes 71 days.

Edge Case 3: Son Born on Day 1 of Father's Vow

Input: son_birth_day = 1
Father's Remaining Days: 100 - 1 = 99 days.
Naïve Logic Prediction: Father pauses, fulfills son's 30 days. Then continues his remaining 99 days. No conflict.
Sugya's Analysis (Mishnah): "If a son is born to him in less than 70 [days], he should not lose anything." Day 1 is clearly less than 70.
Expected Output: No loss of days. The father observes the son's nezirut, then completes his own 99 days. The total duration of his observance will be 1 + 30 + 99 = 130 days, but his original vow is considered fulfilled after 100 days of observance, interspersed with the son's. He will perform two sheavings.

Edge Case 4: Son Born on Day 90, Father Becomes Impure of Corpse Within First 10 Days of Son's Vow

Input: son_birth_day = 90, impurity_type = corpse, impurity_timing = within first 10 days of son's vow
Father's Remaining Days: 100 - 90 = 10 days.
Naïve Logic Prediction: Father has 10 days left. Son's vow starts. Father becomes impure. This might affect his remaining 10 days, or the son's vow.
Sugya's Analysis (Halakha): "If he finished his nezirut and came to complete his son’s nezirut and became impure within the first ten days, he eliminates everything."
- The phrase "finished his nezirut" is key. If the son is born on day 90, the father has 10 days left. He has not finished his nezirut.
- However, the Halakha here seems to apply to a scenario where the father has completed his 100 days, then the son's vow starts, and then impurity occurs within the first 10 days of the son's vow. The Gemara's phrasing "If he finished his nezirut AND came to complete his son's nezirut" is slightly ambiguous.
- Let's assume the more common interpretation: the impurity happens while he is still obligated to his original vow, or immediately after its technical completion but before the son's vow is fully resolved.
- The critical rule for impurity of the dead is that it invalidates the entire nezirut period from the start, unless the impurity occurs after the final shearing and sacrifices.
- In this case, the impurity happens while the father is still observing nezirut for his son, or trying to transition from his own vow to his son's.
Expected Output: The impurity invalidates the father's entire 100-day vow. He must start a completely new 100-day vow. The son's vow is unaffected, but the father must restart his own. This is a "system crash and reboot" scenario.

Edge Case 5: Son Born on Day 90, Father Becomes Impure of Corpse Within the Last 20 Days of Attempted Completion

Input: son_birth_day = 90, impurity_type = corpse, impurity_timing = during the last 20 days of attempted completion
Father's Remaining Days: 100 - 90 = 10 days.
Naïve Logic Prediction: Father has 10 days left. Son's vow is 30 days. After son's vow, father tries to finish his 10 days. Impurity occurs. Does it invalidate everything, or just the last 10 days?
Sugya's Analysis (Halakha): "Within the last twenty days? Rebbi Abba in the name of Rab and Rebbi Joḥanan both say, he eliminates thirty."
- This refers to impurity after the son's vow is completed and the father is in the phase of fulfilling his remaining days, or the 30-day buffer after the son's vow.
- The "eliminates thirty" implies that the father loses the 30 days he is currently observing (which would include his remaining 10 days, plus any buffer). He must start a new 30-day nezirut period.
- This is different from "eliminates everything," which suggests a full restart of the original 100-day vow.
Expected Output: The father loses his current attempt to complete his vow. He must observe an additional 30 days. This is a "partial rollback and restart" scenario. Rebbi Samuel's opinion of "seven only" suggests a different calculation for the rollback.

These edge cases highlight the system's sensitivity to:

Timing of Events: The exact day of birth is a critical parameter.
Temporal Overlap: The interaction between remaining vow time and the minimum required intervals.
Exception States: Impurity acts as a critical error that triggers different recovery protocols.

Refactor – A Minimal Change That Clarifies the Rule

The most elegant refactoring would be to introduce a concept that encapsulates the minimum required interval between the conclusion of one nezirut period and the start of another, particularly when the second period is dictated by an external event (son's birth) that interrupts the first.

Proposed Refactor: Introduce a MinIntervalRule object or a global constant that defines the minimum duration between the shearing of one nezirut and the shearing of a subsequent nezirut for the same individual, when the second vow is contingent on the first.

Current Implicit Logic: The rule is embedded in the "no shaving is for less than 30 days" and the "after 70 days, he reduces to 70" statements. The calculation of lost days (e.g., "eliminates ten") is a consequence, not the primary rule.

Minimal Change: Explicitly define a MinShearingInterval = 30 days.

Refactored Rule Statement:

Instead of: "After 70 [days], he reduces to 70 since no shaving is for less than 30 days."

We would have:

"If a son is born to the father during his 100-day nezirut vow:

If the father has F_remaining days left in his vow:
- If F_remaining >= MinShearingInterval (30 days): The father pauses his vow, fulfills his son's nezirut, performs the son's shearing, and then resumes his own vow to complete F_remaining days. No loss.
- If F_remaining < MinShearingInterval (30 days): The father must fulfill his son's nezirut. Let S_birth_day be the day the son is born (relative to the father's vow).
  - The son's shearing will occur approximately on day S_birth_day + MinShearingInterval.
  - The father's original vow completion would have been on day 100.
  - The father's subsequent shearing must occur at least MinShearingInterval days after the son's shearing.
  - If the required completion date (S_birth_day + MinShearingInterval + MinShearingInterval) exceeds the father's original completion date (100), then the father's vow is shortened.
  - The number of days forfeited is calculated to ensure that the interval between the son's shearing and the father's final shearing is at least MinShearingInterval, while respecting the original vow's endpoint.
  - Specifically: If S_birth_day > 70, the father forfeits S_birth_day - 70 days. His effective vow duration becomes 100 - (S_birth_day - 70).

Why this refactor is minimal and clarifying:

Explicit Parameter: It elevates MinShearingInterval from an implicit understanding derived from "no shaving is for less than 30 days" to an explicit system parameter.
Clearer Logic: The decision tree becomes more defined: check F_remaining against MinShearingInterval.
Unified Reasoning: The "after 70 days" rule is no longer a separate, somewhat opaque condition. Instead, it becomes the trigger for the scenario where F_remaining < MinShearingInterval, and the calculation S_birth_day - 70 is directly explained as the mechanism to enforce the MinShearingInterval constraint while respecting the original vow's boundary. The 70-day threshold is simply the point where 100 - S_birth_day drops below 30.

This refactor treats the 30-day interval as a fundamental system constraint, making the logic for day forfeiture more transparent and less like an arbitrary rule derived from specific examples. It's like defining a MIN_PROCESSING_TIME constant in a program – it makes the logic clearer and easier to maintain.

Takeaway

The Jerusalem Talmud's Nazir 2:10, when viewed through a systems thinking lens, reveals a sophisticated algorithm for managing concurrent, conditional vows. The core "bug" is the temporal conflict arising when a son's automatic nezirut begins before the father's 100-day vow concludes. The sugya systematically debugs this by defining:

States: Active vow, paused vow, reduced vow, completed vow.
Events: Son's birth, impurity.
Transition Rules: How events change states, with special conditions for temporal proximity and exception handling (impurity).
Parameters: Vow durations, minimum shearing intervals.

The "loss" of days when the son is born late in the father's vow isn't arbitrary; it's the system's mechanism for enforcing the minimum 30-day interval required between consecutive shearings, ensuring the integrity and proper ritualistic sequencing of the vows. The Rishonim and Acharonim offer different algorithmic implementations – Rambam provides the concise output, Penei Moshe simulates the process, and Korban HaEdah validates the underlying principles. By refactoring the core rule around the explicit MinShearingInterval, we can see the elegant logic underlying these complex temporal dependencies, much like understanding the critical path or buffer management in a project timeline. This isn't just law; it's computational jurisprudence!

Back to lesson library

derekhlearning.com