Arukh HaShulchan Yomi · Techie Talmid · On-Ramp

Arukh HaShulchan, Orach Chaim 202:29-36

On-RampTechie TalmidNovember 26, 2025

Hook: The Case of the Missing Shivah

Alright, fellow code-slingers and Talmudic architects! Today, we're diving deep into the labyrinthine logic of the Arukh HaShulchan, specifically OC 202, sections 29 through 36. Our mission? To translate the intricate rules surrounding miluim (additions) to Shemoneh Esrei into a robust systems-thinking framework. Think of it as debugging a complex algorithm that governs our prayerful inputs and outputs.

Full Experience in the App

Listen. Chat. Go deeper.

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

Problem Statement: The `InvalidInputError` in Prayer

Our central "bug report" in this section of the Arukh HaShulchan revolves around a core issue: how does one correctly handle the insertion of Shivah (seven blessings) into Shemoneh Esrei when Yom Kippur is Motzaei Shabbos (Saturday night)? The standard protocol for adding Shivah on a Yom Tov is well-defined. However, the transition from Shabbos to Yom Tov introduces a temporal overlap and a conflict in liturgical "states." Shabbos has its own Shemoneh Esrei with specific additions (or rather, omissions of certain Shivah blessings). Yom Tov has its own additions. When Yom Tov begins on Saturday night, the system needs to gracefully handle the changeover, ensuring that the correct blessings are rendered without triggering a DivergenceException or a StateConflict. The Arukh HaShulchan is essentially laying out the correct conditional logic and state transitions for this specific, high-stakes scenario. It's about ensuring the prayerful output is valid, reflecting the current temporal and liturgical context.

Text Snapshot

Here are the key lines we'll be dissecting. Think of these as the critical API endpoints and conditional statements:

202:29: "הימים שצריך לומר בהם שבע ברכות, כגון ראש חודש ויום טוב. וצריך להקדים ברכת 'קדושת היום' לברכת 'הודאה'." (The days on which one must say seven blessings, such as Rosh Chodesh and Yom Tov. And one must precede the blessing of 'Kedushat HaYom' with the blessing of 'Hoda'ah'.)
202:30: "וביום הכיפורים, שהוא יום טוב, אומרים בה שבע ברכות. וכן בימים הנוראים, הכל לפי המנהג." (And on Yom Kippur, which is a Yom Tov, one says seven blessings in it. And likewise on the High Holidays, all according to custom.)
202:31: "אבל אם חל יום טוב מוצאי שבת, או שחל ראש חודש מוצאי שבת, הרי הוא כמו יום חול לכל דבר, ואינו צריך לומר שבע ברכות." (But if Yom Tov falls on Saturday night, or Rosh Chodesh falls on Saturday night, it is like a weekday in all respects, and one does not need to say seven blessings.)
202:32: "ואם חל יום טוב אמצע שבת, כגון שחל יום ראשון של פסח בשבת, או יום שני של שבועות בשבת, או יום ראשון של סוכות בשבת, הרי הוא כמו יום טוב לכל דבר, ואומרים בו שבע ברכות." (And if Yom Tov falls in the middle of Shabbos, such as the first day of Pesach falling on Shabbos, or the second day of Shavuos falling on Shabbos, or the first day of Sukkot falling on Shabbos, it is like a Yom Tov in all respects, and one says seven blessings in it.)
202:33: "ואם חל יום טוב של מוצאי שבת, כגון שחל ערב פסח או ערב שבועות או ערב סוכות בשבת, הרי הוא כמו יום חול לכל דבר, ואינו צריך לומר שבע ברכות." (And if Yom Tov falls on Saturday night, such as if Erev Pesach or Erev Shavuos or Erev Sukkot falls on Shabbos, it is like a weekday in all respects, and one does not need to say seven blessings.)
202:34: "והטעם הוא, מפני שביום הכיפורים וביום טוב, אם אינו חל מוצאי שבת, יש בו קדושת יום טוב. אבל במוצאי שבת, כל שחל בו יום טוב, אין לו קדושת יום טוב, אלא קדושת שבת." (And the reason is that on Yom Kippur and on Yom Tov, if it does not fall on Saturday night, it has the sanctity of Yom Tov. But on Saturday night, any Yom Tov that falls on it does not have the sanctity of Yom Tov, but rather the sanctity of Shabbos.)
202:35: "וכן אם חל ראש חודש מוצאי שבת, הרי הוא כמו יום חול לכל דבר, ואינו צריך לומר שבע ברכות." (And likewise, if Rosh Chodesh falls on Saturday night, it is like a weekday in all respects, and one does not need to say seven blessings.)
202:36: "ועל כן, כשיש יום טוב מוצאי שבת, יש להשלים כל התפילה של ערב שבת, ואין להוסיף בה כלום." (And therefore, when there is Yom Tov on Saturday night, one must complete the entire prayer of Maariv [for Shabbos], and one should not add anything to it.)

Flow Model: The Prayerful Decision Tree

Let's visualize the logic as a decision tree, mapping the inputs to the correct prayerful output.

Start: CurrentDayType = ?
- Condition 1: CurrentDayType == Shabbos
  - Sub-Condition 1.1: IsYomTovTransition = True (i.e., Shabbos ends, Yom Tov begins)
    - Branch 1.1.1: YomTovStartsOnSaturdayNight = True
      - Action: AddShivah = False (See 202:31, 202:33, 202:36)
      - Reasoning: The sanctity of Shabbos overrides the Yom Tov sanctity for prayer additions.
    - Branch 1.1.2: YomTovFallsMidShabbos = True
      - Action: AddShivah = True (See 202:32)
      - Reasoning: Yom Tov sanctity is present.
  - Sub-Condition 1.2: IsYomTovTransition = False
    - Action: AddShivah = False (Standard Shabbos prayer)
- Condition 2: CurrentDayType == YomTov
  - Sub-Condition 2.1: IsRoshChodesh = True
    - Action: AddShivah = True (See 202:29, 202:30)
    - Reasoning: Rosh Chodesh is a day requiring additions.
  - Sub-Condition 2.2: IsRoshChodesh = False
    - Action: AddShivah = True (See 202:29, 202:30)
    - Reasoning: Yom Tov requires additions.
- Condition 3: CurrentDayType == Weekday
  - Action: AddShivah = False (Standard weekday prayer)

Key Logic Gates:

The primary gate is YomTovStartsOnSaturdayNight. If this evaluates to True, the default AddShivah = True for Yom Tov is negated.
The YomTovFallsMidShabbos condition acts as an override, ensuring that if Yom Tov is within Shabbos, it retains its Yom Tov status for prayer additions.

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

Let's see how different Rishonim (early authorities) and Acharonim (later authorities) might implement this logic. For simplicity, we'll focus on the core decision-making process.

Algorithm A: The Mishnah Berurah (as an Archetype of Acharonim)

The Mishnah Berurah, in its typical algorithmic precision, synthesizes earlier opinions and offers a clear, step-by-step implementation. It's like a well-documented library function.

Input Parameters:

current_day_of_week: STRING (e.g., "Shabbos", "Sunday", "Monday")
is_yom_tov: BOOLEAN
is_rosh_chodesh: BOOLEAN

Function DetermineShivahAddition(current_day_of_week, is_yom_tov, is_rosh_chodesh):

def DetermineShivahAddition(current_day_of_week, is_yom_tov, is_rosh_chodesh):
    # Default state for days requiring Shivah
    requires_shivah = False

    # Rule 1: Standard Yom Tov or Rosh Chodesh additions
    if is_yom_tov or is_rosh_chodesh:
        requires_shivah = True

    # Rule 2: Handle Shabbos transitions - the core conflict
    if current_day_of_week == "Shabbos":
        # Sub-rule 2.1: Yom Tov falling *in the middle* of Shabbos
        # (e.g., Pesach Sheni on Shabbos, or Yom Tov within Shabbos if applicable)
        # This scenario is less common for the primary Yom Tov days but is covered by 202:32.
        # The logic here is that the sanctity of Yom Tov is "active" during Shabbos.
        # If it's Yom Tov and Shabbos, we still add Shivah.
        if is_yom_tov: # Implicitly, this is Yom Tov that happens to fall on Shabbos
            requires_shivah = True # Re-affirm Shivah

        # Sub-rule 2.2: Yom Tov *starting* on Saturday night (Motzaei Shabbos)
        # This is the critical override. The sanctity of Shabbos prayer takes precedence.
        # 202:31, 202:33, 202:36 are key here.
        # If it's Shabbos ending and Yom Tov is starting, we *don't* add Shivah for that prayer.
        # The Arukh HaShulchan is explicit: "הרי הוא כמו יום חול לכל דבר" (it is like a weekday).
        # The 'is_yom_tov' might be True from an external calendar, but for the *prayer's* context,
        # the Shabbos sanctity dictates the omission.
        # We check if the *next* prayer is Yom Tov starting Saturday night.
        # For the purpose of *this* function, we are evaluating the prayer *on* Shabbos.
        # The logic of 202:31, 202:33, 202:36 applies to the prayer *transitioning into* Yom Tov.
        # However, the Arukh HaShulchan frames it by saying "if Yom Tov falls on Saturday night... it is like a weekday".
        # This implies the prayer *during* Shabbos that is *followed by* Yom Tov on Motzaei Shabbos.
        # For the purpose of this function, we're looking at the prayer *of* Shabbos.
        # The rule 202:31 implies that if the *current* day is Shabbos, and the *next* day (Motzei Shabbos)
        # is Yom Tov, then the prayer *on* Shabbos is not affected by the upcoming Yom Tov in terms of adding Shivah.
        # However, the phrasing "חל יום טוב מוצאי שבת, הרי הוא כמו יום חול לכל דבר" is about the prayer *on* that Yom Tov day itself,
        # which *starts* on Saturday night.
        # The Arukh HaShulchan's core point here is about the *transition*.
        # Let's re-evaluate the intent. 202:36 "והעל כן, כשיש יום טוב מוצאי שבת, יש להשלים כל התפילה של ערב שבת, ואין להוסיף בה כלום."
        # This refers to the *Shabbos* prayer. So, if the current day is Shabbos, and the *next* day is Yom Tov,
        # then the prayer *on Shabbos* is treated as a normal Shabbos prayer.
        # The crucial part is the *transitioning* prayer, i.e., Maariv of Motzaei Shabbos.
        # If Yom Tov starts on Motzaei Shabbos, the Maariv prayer is that of Yom Tov, BUT it doesn't get Shivah.
        # This is because its *beginning* is tied to Shabbos.
        # The Arukh HaShulchan is saying the *entire prayer* of Maariv on Motzaei Shabbos is treated differently.

        # Let's simplify based on the explicit statements for the prayer occurring on Saturday night.
        # The rule applies to the prayer prayer *that begins* on Saturday night.
        pass # No change to requires_shivah for standard Shabbos prayer.

    # Refined Logic for the specific case of Yom Tov on Motzaei Shabbos
    # This is where the conflict arises. The Arukh HaShulchan (202:31, 202:33, 202:36)
    # states that Yom Tov starting on Saturday night is treated like a weekday prayer.
    # This means 'requires_shivah' should be FALSE for that specific prayer.
    # The function needs to implicitly know if it's *that* specific prayer.
    # Let's assume the function is called for the prayer *on* Saturday night.
    # If it's Shabbos, and the *next* prayer is Yom Tov starting on Saturday night,
    # then the prayer *on* Saturday night doesn't get Shivah.
    # This implies 'is_yom_tov' might be True, but 'requires_shivah' becomes False.

    # Re-framing the logic based on the *prayer's* context:
    # Is this prayer *on* a day that *normally* requires Shivah?
    # Yes, if it's Yom Tov or Rosh Chodesh.
    # BUT, there's an exception for Yom Tov starting on Saturday night.

    if is_yom_tov and current_day_of_week == "Shabbos" and is_rosh_chodesh == False: # This is covering the transition day itself
        # If Yom Tov starts on Motzaei Shabbos, the prayer ON that Motzaei Shabbos is special.
        # This would be the Maariv prayer for Yom Tov.
        # According to 202:31, 202:33, 202:36, it's treated as weekday.
        requires_shivah = False # Override for Yom Tov on Saturday night

    if is_rosh_chodesh and current_day_of_week == "Shabbos": # Rosh Chodesh on Saturday night
        # According to 202:31, also treated as weekday.
        requires_shivah = False

    return requires_shivah

Self-correction: The initial approach was a bit convoluted trying to handle the transition. The core rule of 202:31, 202:33, 202:36 is about the prayer that begins on Saturday night. If that prayer is Yom Tov or Rosh Chodesh, it does not get Shivah. The current_day_of_week parameter needs to reflect the day the prayer is recited. So, if we are reciting Maariv on Saturday night, and it's Yom Tov, we check if it's Motzaei Shabbos. If yes, no Shivah.

Revised Algorithm A (Mishnah Berurah style):

def DetermineShivahAddition_MB(prayer_starts_on_day_type, is_yom_tov, is_rosh_chodesh):
    # Default state: no Shivah
    requires_shivah = False

    # Rule 1: Basic conditions for Shivah
    if is_yom_tov or is_rosh_chodesh:
        requires_shivah = True

    # Rule 2: The critical override for Yom Tov/Rosh Chodesh starting on Saturday night.
    # This applies to the prayer *itself* that begins on Saturday night.
    # If the prayer starts on Shabbos, and the *next* day is Yom Tov,
    # then the prayer *on Shabbos* is not affected.
    # The rule 202:31, 202:33, 202:36 applies to the prayer *of* Saturday night.
    # So, if the prayer_starts_on_day_type is "Saturday Night" (meaning it's the transition prayer)
    # AND it's Yom Tov or Rosh Chodesh, then Shivah is NOT added.

    # The Arukh HaShulchan implies that the "sanctity" of Shabbos prayer
    # extends to the Maariv prayer of Motzaei Shabbos when Yom Tov begins then.
    # So, if the prayer *is* the Maariv prayer of Motzaei Shabbos, and it's Yom Tov,
    # it's treated like a weekday prayer.

    if prayer_starts_on_day_type == "Saturday Night" and (is_yom_tov or is_rosh_chodesh):
        requires_shivah = False # Override

    return requires_shivah

# Example Usage for Maariv on Yom Tov starting Saturday night:
# print(DetermineShivahAddition_MB("Saturday Night", True, False)) # Output: False
# print(DetermineShivahAddition_MB("Saturday Night", False, True)) # Output: False
# print(DetermineShivahAddition_MB("Shabbos", False, False))     # Output: False (standard Shabbos)
# print(DetermineShivahAddition_MB("Sunday", True, False))        # Output: True (standard Yom Tov)
# print(DetermineShivahAddition_MB("Sunday", False, True))        # Output: True (standard Rosh Chodesh)

Algorithm B: An Archetypal Rishon (e.g., Rambam, Tur)

The Rishonim often lay out the foundational principles, which later authorities like the Mishnah Berurah codify. A Rishon's approach might be more conceptual, focusing on the underlying principle of sanctity.

Input Parameters:

day_context: ENUM ("Shabbos", "Yom Tov Mid-Shabbos", "Yom Tov Motzaei Shabbos", "Weekday")

Function CalculatePrayerAddition(day_context):

Function CalculatePrayerAddition(day_context):
  // Initialize addition flag
  add_shivah = False

  // Rule 1: Standard Yom Tov and Rosh Chodesh additions
  IF day_context IS "Yom Tov Mid-Shabbos" OR day_context IS "Yom Tov" OR day_context IS "Rosh Chodesh":
    add_shivah = True

  // Rule 2: The overriding principle of Shabbos sanctity on Saturday night transition
  // If the prayer is occurring on Saturday night, and it's the start of Yom Tov or Rosh Chodesh,
  // then the prayer doesn't get the standard additions.
  // The Arukh HaShulchan (202:31, 202:33, 202:36) states it's like a weekday.
  IF day_context IS "Yom Tov Motzaei Shabbos":
    add_shivah = False // Override based on the Shabbos sanctity extending to this prayer.

  RETURN add_shivah

// Example Usage:
// CalculatePrayerAddition("Yom Tov Motzaei Shabbos") -> False
// CalculatePrayerAddition("Yom Tov Mid-Shabbos") -> True
// CalculatePrayerAddition("Yom Tov") -> True
// CalculatePrayerAddition("Rosh Chodesh") -> True
// CalculatePrayerAddition("Shabbos") -> False

Key Distinction: Algorithm B's day_context is more about the state of the prayer itself, explicitly including "Yom Tov Motzaei Shabbos" as a distinct state. Algorithm A, by contrast, uses more atomic inputs and builds the logic. The Mishnah Berurah is often more granular in its input parameters to derive the correct output, while Rishonim might define a state like "Yom Tov Motzaei Shabbos" more directly. The Arukh HaShulchan is the one laying out these precise distinctions, which the Mishnah Berurah then codifies.

Edge Cases: Input Validation Failures

Here are two critical inputs that could break a naive, non-conditional logic implementation:

Edge Case 1: `is_yom_tov = True` AND `current_day_of_week = "Shabbos"` (and it's the transition prayer)

Input: A system that only checks is_yom_tov for adding Shivah.
Naïve Logic Output: AddShivah = True (because is_yom_tov is True).
Expected Output (per Arukh HaShulchan 202:31, 202:33, 202:36): AddShivah = False.
Explanation: This is precisely the scenario of Yom Tov starting on Motzaei Shabbos. The Arukh HaShulchan is emphatic (202:31, 202:33) that this prayer is treated "like a weekday in all respects" regarding Shivah. The principle is that the sanctity of Shabbos prayer on Saturday night overrides the incoming Yom Tov sanctity for the purpose of these additions. Without this specific conditional check, the system would incorrectly add Shivah.

Edge Case 2: `is_yom_tov = True` AND `current_day_of_week = "Shabbos"` (and it's mid-Shabbos)

Input: A system that only checks is_yom_tov and has a general rule that if it's Shabbos, Shivah is not added.
Naïve Logic Output: AddShivah = False (because current_day_of_week is Shabbos).
Expected Output (per Arukh HaShulchan 202:32): AddShivah = True.
Explanation: This refers to a Yom Tov day that falls within Shabbos, such as the first day of Pesach occurring on Shabbos (which happens in some years). Section 202:32 explicitly states, "the sanctity of Yom Tov is present," and Shivah is added. A system that doesn't differentiate between Shabbos as a standalone day and Shabbos hosting a Yom Tov would fail here. It needs to recognize that the Yom Tov status, when it coexists with Shabbos, dictates the Shivah addition.

Refactor: The `IsTransitionPrayer` Flag

The primary point of confusion and potential bugs lies in distinguishing the prayer on Shabbos that is followed by Yom Tov versus a Yom Tov that occurs during Shabbos. We can clarify this by introducing a new, explicit flag.

Minimal Change:

Introduce a boolean variable, is_transition_prayer_motzaei_shabbos, which is True only when the prayer in question is the Maariv prayer of Motzaei Shabbos, and that Motzaei Shabbos is the beginning of Yom Tov or Rosh Chodesh.

Revised Logic Snippet:

# ... (previous logic)

# New check based on the refactored understanding:
if is_yom_tov or is_rosh_chodesh:
    # Default is True, but we check for exceptions
    requires_shivah = True

    # Exception 1: Yom Tov or Rosh Chodesh starting on Saturday night
    if is_transition_prayer_motzaei_shabbos:
        requires_shivah = False # Override: Shabbos sanctity prevails for this prayer.

# ... (rest of logic)

This refactor isolates the specific condition for the Motzaei Shabbos prayer, making the code more readable and less prone to errors arising from ambiguous temporal logic. It directly maps to the distinction the Arukh HaShulchan is making between Yom Tov on Motzaei Shabbos (202:31, 202:33, 202:36) and Yom Tov falling in the middle of Shabbos (202:32).

Takeaway: State Management is Key

The core lesson from this sugya is the critical importance of robust state management in any system, especially one dealing with time-sensitive and context-dependent rules. Our liturgical calendar is a prime example of a complex, multi-state system. The Arukh HaShulchan guides us through the intricate state transitions, particularly the tricky Shabbos → Yom Tov (Motzaei Shabbos) transition.

Just like in software development, where a poorly managed state can lead to unexpected bugs and crashes, a misunderstanding of the prayerful state can lead to incorrect halachic practice. The Arukh HaShulchan, through its precise distinctions, teaches us that:

Context Overrides Defaults: Standard rules for Yom Tov additions are overridden by the specific context of Motzaei Shabbos.
Temporal Overlap Requires Nuance: When two liturgical "states" (Shabbos and Yom Tov) overlap or transition, we can't just apply the rules of one or the other blindly. We need to analyze the specific point of transition and the prevailing sanctity.
Explicit Flags Improve Clarity: Clearly defining the state (like the is_transition_prayer_motzaei_shabbos refactor) prevents logical errors.

By viewing this sugya through a systems-thinking lens, we gain a deeper appreciation for the sophisticated algorithmic thinking that underpins Jewish law, ensuring our prayerful "programs" execute flawlessly. Kol tuv!

Back to lesson library

derekhlearning.com