06 — Core vs. Extensions: The Boundary

06 — Core vs. Extensions: The Boundary

Core claim: The inheritance engine factorizes into a single-pass core $F$ and three multi-pass extension operators ${\text{Chain}, \text{Min}, \text{Project}}$. The litmus test: does the computation require solving $F$ more than once?

---

The Litmus Test

Property	Core $F$	Extension
Number of $F$-invocations	Exactly 1	$\ge 2$
Input	One deceased, one heir set $H$	Multiple deceased, scenarios, or proxy mappings
Output	$(\text{muṣaḥḥaḥ}, {(h_i, \text{sahm}_i)})$	Same format, but composed from multiple $F$-outputs
Merge primitive needed?	No	Yes — LCM/GCD ratio comparison

If you can solve the problem with a single call to the 6-phase pipeline, it’s core. If you need to call the pipeline multiple times and merge the results, it’s an extension.

---

What is Core

The single-pass pipeline $F(H)$ handles:

1. Normal cases — ʿaṣaba absorbs remainder. One pass.
2. ʿAwl — $\sum \text{farḍ} > 1$, proportional compression. One pass (Phase 4 formula with $P = \text{all}$, $L = \emptyset$).
3. Radd without spouse — $\sum \text{farḍ} < 1$, proportional expansion. One pass (Phase 4 formula with $P = \text{all}$, $L = \emptyset$; the sum of numerators becomes the new base).
4. Radd with spouse — One pass using the unified formula ($P = \text{blood heirs}$, $L = {\text{spouse}}$, $R = 1 - \text{farḍ(spouse)}$). See proof below.

Radd-with-Spouse is Core: Proof

Classical method (2 tables): The source text (faraid/radd.md) explicitly describes Radd-with-spouse as requiring two sub-problems merged “as in Munāsakhat”:

1. Spousal problem (masʾala zaujiyya).
2. Radd problem (masʾala raddiyya).
3. Compare bases via muwāfaqa/mubāyana → jāmiʿa.

This appears to require multiple passes. But the two-table method is a computational artifact of integer arithmetic. In $\mathbb{Q}$:

$$\text{share}(h) = \begin{cases} \text{farḍ}(h) & \text{if } h = \text{spouse} \[6pt] \dfrac{\text{farḍ}(h)}{\displaystyle\sum_{p \in P} \text{farḍ}(p)} \times \left(1 - \text{farḍ}(\text{spouse})\right) & \text{otherwise} \end{cases}$$

This is a closed-form expression — no iteration, no second $F$-call. The classical two-table method is simply how you compute this formula using pen-and-paper integer arithmetic (you need a common denominator, hence the LCM merge).

Verification: Wife ($\frac{1}{8}$), Mother ($\frac{1}{6}$), Daughter ($\frac{1}{2}$):

$$R = 1 - \frac{1}{8} = \frac{7}{8}, \quad \sum_P = \frac{1}{6} + \frac{1}{2} = \frac{2}{3}$$

$$\text{Mother} = \frac{1/6}{2/3} \times \frac{7}{8} = \frac{7}{32}, \quad \text{Daughter} = \frac{1/2}{2/3} \times \frac{7}{8} = \frac{21}{32}$$

$$\frac{4}{32} + \frac{7}{32} + \frac{21}{32} = 1 ;\checkmark$$

The classical jāmiʿa (32) emerges naturally as the LCM of all denominators.

Conclusion: Radd is core. The two-table classical method is a manual computation strategy, not a structural multi-pass requirement.

---

The Three Extensions

Extension 1: Chain — Munāsakhat (المناسخات)

When: An heir dies before the estate is divided.

Structure: $\text{Chain}(F, H_1, H_2, \ldots, H_n)$

$$F(H_1) \to \text{result}_1 \xrightarrow{\text{merge}} F(H_2) \to \text{result}_2 \xrightarrow{\text{merge}} \cdots$$

Each deceased in the chain triggers a fresh $F$-call. Results are merged via the LCM/GCD ratio comparison to produce a common jāmiʿa.

Three structural cases (from faraid/munasakhat.md):

Case	Condition	Method
1	Heirs of deceased₂ are exactly the remaining heirs of deceased₁ with identical relationships	Collapse — effectively one $F$-call on survivors
2	Heir sets of subsequent deceased are disjoint	Parallel merge — one jāmiʿa for all
3	Heir sets overlap	Sequential merge — each new deceased produces a new jāmiʿa layer

Why it’s an extension: Case 1 collapses to core. Cases 2 and 3 require $\ge 2$ independent $F$-invocations.

Output: Same format $(\text{muṣaḥḥaḥ}_{\text{final}}, {(h_i, \text{sahm}_i)})$. Heirs appearing in multiple problems have their shares summed.

Extension 2: Min — Mafqūd (المفقود)

When: A missing person’s status (alive/dead) is unknown at the time of division.

Structure: $\text{Min}(F, H_{\text{alive}}, H_{\text{dead}})$

$$\text{share}(h) = \min\bigl(F(H_{\text{alive}})(h), ; F(H_{\text{dead}})(h)\bigr)$$

1. Compute $F$ assuming mafqūd alive.
2. Compute $F$ assuming mafqūd dead.
3. For each heir $h \ne \text{mafqūd}$: give $\min$ of the two shares.
4. Surplus = $\text{mawqūf}$ (suspended), held until resolution.

With $n$ missing persons: $2^n$ scenarios. Each heir gets $\min$ across all $2^n$ computed shares.

Why it’s an extension: Requires at minimum 2 $F$-calls (alive vs dead scenarios), merged by the min-envelope operator.

Key property: The mawqūf (suspended amount) is always $\ge 0$ and represents the gap between the conservative allocation and the true allocation under the unknown scenario. This is a minimax strategy — give each known heir their worst-case share.

Extension 3: Project — Dhawī al-Arḥām (ذوي الأرحام)

When: No farḍ or ʿaṣaba heirs exist (except possibly a spouse).

Structure (Ahl al-Tanzīl method): $\text{Project}(\vec{h}) \to \vec{h}’$, then $F(H’)$

1. For each dhū raḥim $h$, identify the mudlā bihi (the standard heir they connect through).
2. Project: Replace each $h$ with their mudlā bihi $h’$ in the heir set.
3. Solve: $F(H’)$ — compute shares for the projected heirs.
4. Sub-distribute: If multiple dhawī al-arḥām project onto the same mudlā bihi, subdivide that heir’s share among them (possibly requiring another $F$-call for the sub-group).

The two paths:

Path	Method	Complexity
Path A (Ḥanafī — Ahl al-Qarāba)	Priority ordering: jiha → daraja → quwwa → connection strength	Simpler — extends the ʿaṣaba priority cascade to non-standard heirs
Path B (Ḥanbalī/Shāfiʿī — Ahl al-Tanzīl)	Graph projection: each heir maps to their connecting wārith	More complex — reuses the farḍ computation engine recursively

Why it’s an extension: The projection step + sub-distribution requires $\ge 2$ $F$-calls (the main projected problem + one per sub-group with multiple claimants).

---

The Merge Primitive

All three extensions share the same merge primitive: the classical four-ratio comparison used to find a common integer base.

Given two problem bases $n_1$ and $n_2$:

Ratio	Condition	Multiplier
Tamāthul (equality)	$n_1 = n_2$	$\times 1$
Tadākhul (nesting)	$n_1 \mid n_2$ or $n_2 \mid n_1$	Use the larger
Tawāfuq (GCD > 1)	$\gcd(n_1, n_2) > 1$	$\frac{n_1 \times n_2}{\gcd(n_1, n_2)}$
Tabāyun (coprime)	$\gcd(n_1, n_2) = 1$	$n_1 \times n_2$

This is simply $\text{lcm}(n_1, n_2)$ expressed as a manual algorithm — optimized for pen-and-paper computation.

---

Output Requirements

All outputs — whether from core $F$ or any extension — must satisfy:

Requirement	Formal	Source
Rational	All shares $\in \mathbb{Q}^+$	Axiom $\gamma$ (conservation)
Pure function	$F(H)$ depends only on $H$; no side effects	Pipeline is stateless
Zero-vectors	Excluded heirs get share = 0, not “undefined”	Phase 2 outputs 0-shares for eliminated heirs
Integer final form	Phase 5 guarantees $\mathbb{Z}^+$ output	Taṣḥīḥ algorithm
Sum = base	$\sum \text{sahm}_i = \text{muṣaḥḥaḥ}$	Axiom $\gamma_1$

These properties are what make the extensions composable — Chain can take Min’s output as input, and Project can feed into Chain (e.g., a dhū raḥim who dies before division → Project then Chain).

---

Architecture Diagram

                ┌──────────────────────┐
                │     CORE  F(H)       │
                │  6-phase pipeline    │
                │  (single-pass)       │
                │                      │
                │  Normal / ʿAwl / Radd│
                └──────────┬───────────┘
                           │
          ┌────────────────┼────────────────┐
          │                │                │
    ┌─────▼─────┐   ┌─────▼─────┐   ┌─────▼─────┐
    │  Chain     │   │    Min    │   │  Project   │
    │ (Munāsakha│   │ (Mafqūd)  │   │ (Dhawī    │
    │  t)        │   │           │   │  al-Arḥām) │
    │            │   │           │   │            │
    │ F(H₁)∘    │   │ min(F(Hₐ) │   │ π(h)→h'   │
    │ F(H₂)∘…   │   │   ,F(Hᵦ)) │   │ then F(H')│
    └───────────┘   └───────────┘   └───────────┘
          │                │                │
          └────────────────┼────────────────┘
                           │
                    ┌──────▼──────┐
                    │ LCM Merge   │
                    │ Primitive   │
                    │ (4 ratios)  │
                    └─────────────┘

---

Summary

Component	Type	Passes	Merge?
Normal	Core	1	No
ʿAwl	Core	1	No
Radd (no spouse)	Core	1	No
Radd (with spouse)	Core	1	No (closed-form)
Munāsakhat	Extension	$\ge 2$	Yes (Chain)
Mafqūd	Extension	$\ge 2$	Yes (Min)
Dhawī al-Arḥām	Extension	$\ge 2$	Yes (Project)
Ḥaml (Jumhūr)	Extension	$k \in {2, 6}$	Yes (Generalized Min, $k$ scenarios)
Ḥaml (Ḥanafī)	Extension	$k = 2$	Yes (Generalized Min, $k=2$)
Khunthā Shāfiʿī	Extension	2	Yes (Generalized Min, component-min)
Khunthā Mālikī	Extension	2	Yes (Generalized Min, component-mean)
Khunthā Ḥanafī	Extension	1 (after pick)	Yes (Generalized Min, single-pick)
Gharqā Ḥanbalī	Extension	$n$ (one per deceased)	Yes (Chain Forest, TILD/ṬARIF)
Gharqā Jumhūr	Extension	$n$ independent	No (parallel core $F$-calls, no merge)

The entire system: $F_{\text{total}} = F \circ {\text{Chain}, \text{Min}, \text{Project}} \circ {\text{Ḥaml}, \text{Khunthā}, \text{Gharqā}}$

All extensions are instances of the unified $(\mathcal{S}, w, \mathcal{A})$ schema — see 16-uncertainty-and-forest-extensions.md.

---

References

• Munāsakhat algorithm: faraid/munasakhat.md, faraid/munasakhat-math.md
• Mafqūd scenarios: faraid/mafqud.md
• Dhawī al-Arḥām projection: faraid/dzawilarham.md
• Radd mechanics: faraid/radd.md
• Taṣḥīḥ (integer output): faraid/tashih.md
• Unified normalization formula: 04-pipeline.md