# -*- coding: utf-8 -*-
"""
jabri_clarifier_v1.2.py — كود إزالة الالتباسات | واحة الجبري | النسخة المعتمدة v1.2
م/ عبدالله محمد ناصر الجبري

مبدأ v1.2 (يُثبّت في واحة الجبري):
الحساب شيء، والتفسير شيء آخر، والبرهان شيء ثالث.
نجاح جميع اختبارات assert يعني أن العلاقات التي اختبرها البرنامج تحققت ضمن شروطه؛
لا يعني أن كل تفسير أو رابط هندسي أو فيزيائي في المشروع قد ثبت.

هذا الكود لا يضيف برهاناً جديداً. وظيفته: فصل السياقات، وفحص كل نتيجة قابلة للفحص.
ترتيب الدوال هنا مطابق تماماً لترتيب أقسام clarifier.html v1.2:
  0) الجذر ≠ mod 9
  1) الثلاثة سياقات (متمم / تطبيع / هندسة)
  2) حساب أبجدي وفق جدول المشروع
  3) 733 ليس فريداً
  4) الزوايا الثلاث
  5) المنحنى الموحد (فرضية مقترحة)
  6) المانجو (إعادة حساب الإحصاءات المعلنة من البيانات الخام — ليست إعادة إنتاج إحصائية كاملة)
  7) ملاحظة 21
  8) Frame 5 (غير مثبت)

تشغيل:  python jabri_clarifier_v1.2.py
"""

import math
import statistics
from dataclasses import dataclass

VERSION = "1.2"
FRAME5_STATUS = "NOT_PROVEN__NEEDS_INDEPENDENT_VERIFICATION"

# ============================================================
# 0) الجذر الرقمي ≠ باقي mod 9
# ============================================================

def digital_root(n: int) -> int:
    n = abs(int(n))
    if n == 0:
        return 0
    return 1 + (n - 1) % 9

def mod9(n: int) -> int:
    """باقي موحّد يعمل للأعداد السالبة أيضاً: ((n % 9) + 9) % 9"""
    return ((int(n) % 9) + 9) % 9

def check_root_vs_mod9():
    print("=" * 60)
    print("0) الجذر الرقمي ≠ باقي mod 9 — يفرقان فقط في مضاعفات 9")
    for n in [753, 262, 1015, 1872, 999, 369, -5]:
        print(f"  {n:6d} : جذر={digital_root(n)}  mod9={mod9(n)}")
    assert digital_root(1872) == 9 and mod9(1872) == 0
    assert mod9(-5) == 4  # -5 ≡ 4 (mod 9) — الباقي الموحد، لا باقي بايثون الخام
    print("  ✓ تمييز صحيح: 1872 جذره 9 وباقيه 0 · mod9(-5)=4")
    print()

# ============================================================
# 1) الثلاثة سياقات — مع فاحص وتر حقيقي للوتر المدخل
# ============================================================

def complement(n: int, k: int) -> int:
    return (10**k - 1) - n

@dataclass
class ComplementContext:
    k: int; C: int; A: int
    @property
    def unit(self): return 10**self.k - 1
    def valid(self): return self.C + self.A == self.unit

@dataclass
class NormalizedContext:
    Z: float; C: float; A: float
    def valid(self): return abs((self.Z + self.C + self.A) - 1.0) < 1e-9

def check_pythagoras(Z, C, A) -> bool:
    """فاحص عام للوتر المدخل: يفصل حساب الوتر عن اختبار القيمة المدخلة،
    ولا يتعطل عند مدخلات غير صالحة (نص، None، غير قابلة للتحويل)."""
    try:
        Z, C, A = float(Z), float(C), float(A)
    except (TypeError, ValueError, OverflowError):
        return False
    if not all(math.isfinite(v) and v > 0 for v in (Z, C, A)):
        return False
    return abs(Z**2 + C**2 - A**2) < 1e-6

def check_three_contexts():
    print("=" * 60)
    print("1) ثلاثة سياقات منفصلة لـ Z,C,A — لا تخلط بينها")
    comp = ComplementContext(k=3, C=124, A=875)
    print(f"  [متمم] C+A = {comp.C}+{comp.A} = {comp.C+comp.A} ، الوحدة={comp.unit} -> {comp.valid()}")
    assert comp.valid()
    print(f"  [متمم] 369 في k=3 متممه = {complement(369,3)} ، وفي k=5 = {complement(369,5)}")
    assert complement(369,3) == 630 and complement(369,5) == 99630
    x = math.sqrt(2) - 1
    norm = NormalizedContext(Z=x, C=x, A=x*x)
    print(f"  [تطبيع] Z=C=x ، A=x² ، Z+C+A = {norm.Z+norm.C+norm.A:.10f} -> {norm.valid()}")
    assert norm.valid()
    # --- هندسة: الوتر المحسوب ينجح، والوتر المقرب يفشل ---
    A_exact = math.hypot(192, 290.74)
    print(f"  [هندسة] A_exact = hypot(192, 290.74) = {A_exact:.5f}")
    print(f"  [هندسة] check_pythagoras(192, 290.74, A_exact) = {check_pythagoras(192, 290.74, A_exact)}")
    assert check_pythagoras(192, 290.74, A_exact)
    residual_rounded = abs(192**2 + 290.74**2 - 348.42**2)  # محسوب، لا مكتوب يدوياً
    print(f"  [هندسة] residual للوتر المقرب = {residual_rounded:.6f}")
    print(f"  [هندسة] check_pythagoras(192, 290.74, 348.42) = {check_pythagoras(192, 290.74, 348.42)} — يجب أن يفشل: الباقي {residual_rounded:.6f} > 1e-6")
    assert not check_pythagoras(192, 290.74, 348.42)
    assert not check_pythagoras(192, 290.74, float('nan'))
    assert not check_pythagoras(-192, 290.74, A_exact)
    assert not check_pythagoras("abc", 290.74, A_exact)
    assert not check_pythagoras(None, 290.74, A_exact)
    assert not check_pythagoras(192, 290.74, float('inf'))
    print("  ✓ كل سياق يُفحص بقانونه المستقل · الوتر المدخل يُختبر فعلاً، لا يُفترض صحته")
    print()

# ============================================================
# 2) حساب أبجدي وفق جدول المشروع (ليس قاعدة لغوية عامة)
# ============================================================

ABJAD_PROJECT = {
    'ا':1,'أ':1,'إ':1,'آ':1,'ء':1,
    'ب':2,'ج':3,'د':4,'ه':5,'و':6,'ؤ':6,'ز':7,
    'ح':8,'ط':9,'ي':10,'ى':10,'ئ':10,
    'ك':20,'ل':30,'م':40,'ن':50,
    'س':60,'ع':70,'ف':80,'ص':90,
    'ق':100,'ر':200,'ش':300,'ت':400,'ة':400,
    'ث':500,'خ':600,'ذ':700,
    'ض':800,'ظ':900,'غ':1000,
}

def abjad_value(word: str) -> int:
    return sum(ABJAD_PROJECT.get(ch, 0) for ch in word)

def check_char_balance():
    print("=" * 60)
    print("2) حساب أبجدي وفق جدول المشروع — char-balance")
    print("  تنبيه: القيم صحيحة وفق جدول الترميز الذي اعتمده المشروع، وليست قاعدة لغوية أو رياضية عامة.")
    z = abjad_value("الذكاء"); a = abjad_value("الاصطناعي"); total = z + a
    print(f"  الذكاء = {z} · الاصطناعي = {a} · المجموع = {total}")
    assert z == 753 and a == 262 and total == 1015
    print(f"  الجسر: 1015 mod9 = {mod9(1015)} ، 124 mod9 = {mod9(124)} -> توافق، مش مساواة")
    assert mod9(1015) == mod9(124) == 7
    print()

# ============================================================
# 3) 733 ليس فريداً — باقي موحد
# ============================================================

def check_733():
    print("=" * 60)
    print("3) مسألة 733 — إزالة وهم الفرادة")
    candidates = [n for n in range(0, 2000) if mod9(n) == 4]
    print(f"  الشرط الحقيقي: n ≡ 4 (mod 9) — بالباقي الموحد، حتى للأعداد السالبة")
    print(f"  أمثلة: {candidates[:8]} ... و 733 واحد منها فقط · mod9(-5) = {mod9(-5)}")
    assert 733 in candidates and mod9(1015+733) == mod9(875)
    print("  ✓ التوصية: أعلن 733 ثابتاً اصطلاحياً أو احذفه واكتفِ بجسر 1015")
    print()

# ============================================================
# 4) الزوايا الثلاث
# ============================================================

def check_angles():
    print("=" * 60)
    print("4) الزوايا الثلاث — لا تخلط بينها")
    t22 = math.tan(math.radians(22.5))
    print(f"  tan(22.5°) = {t22:.8f} = √2-1 -> حالة ذهبية")
    assert abs(t22 - (math.sqrt(2)-1)) < 1e-9
    theta_general = math.degrees(math.atan(290.74/192))
    print(f"  مثال tree2 العام: arctan(290.74/192) = {theta_general:.2f}° -> مثال فقط، ليس زاوية سحرية")
    theta_m = math.degrees(math.acos(1/math.sqrt(3)))
    print(f"  الزاوية السحرية θm = arccos(1/√3) = {theta_m:.7f}° · tan(θm) = {math.tan(math.radians(theta_m)):.8f} = √2")
    assert abs(theta_m - 54.7356103) < 1e-4
    assert abs(math.tan(math.radians(theta_m)) - math.sqrt(2)) < 1e-9  # assert مستقل، لا طباعة فقط
    print("  ✓ tan(θm) = √2 (بـ assert مستقل) · 56.56° ≠ 54.7356°")
    print()

# ============================================================
# 5) المنحنى الموحد — فرضية مقترحة
# ============================================================

def alpha_star(theta_deg: float) -> float:
    t = math.tan(math.radians(theta_deg))
    return t / (t + 2)

def check_unified_curve():
    print("=" * 60)
    print("5) المنحنى الموحد — lab01 : alpha*(θ) = tanθ / (tanθ + 2)")
    cases = [(22.5, 3-2*math.sqrt(2), "Frame 2"),
             (45.0, 1/3, "v0.4"),
             (54.7356103, math.sqrt(2)-1, "الزاوية السحرية")]
    for theta, expected, ctx in cases:
        got = alpha_star(theta)
        print(f"  θ={theta:>10.4f}° : alpha* = {got:.6f} (المتوقع {expected:.6f}) [{ctx}]")
        assert abs(got - expected) < 1e-6
    print("  ✓ القيم الثلاث دقيقة حسابياً")
    print("  ⚠ القرار المعتمد: المنحنى فرضية رياضية مقترحة — تحقق القيم لا يثبت اشتقاقاً من نظرية هندسية موحدة.")
    print()

# ============================================================
# 6) المانجو — إعادة حساب الإحصاءات المعلنة من البيانات الخام
# ============================================================

def t_cdf(t_val: float, df: int) -> float:
    """دالة توزيع t بدون اعتماد خارجي ثقيل: عبر scipy إن توفر، وإلا عبر تكامل عددي بسيط."""
    try:
        from scipy.stats import t as tdist
        return float(tdist.cdf(t_val, df))
    except Exception:
        # بديل: تكامل سيمبسون لدالة كثافة t
        import math as _m
        def pdf(x):
            c = _m.gamma((df+1)/2) / (_m.sqrt(df*_m.pi) * _m.gamma(df/2))
            return c * (1 + x*x/df) ** (-(df+1)/2)
        if t_val == 0:
            return 0.5
        n = 20000; a = 0.0; b = abs(t_val); h = (b-a)/n; s = pdf(a) + pdf(b)
        for i in range(1, n):
            s += (4 if i % 2 == 1 else 2) * pdf(a + i*h)
        area = s * h / 3
        return 0.5 + (area if t_val > 0 else -area)

def check_mango():
    print("=" * 60)
    print("6) المانجو — tree3 : R = (H-h)/H — إعادة حساب الإحصاءات المعلنة من البيانات الخام")
    data = [(7.80,4.50),(8.50,5.00),(7.20,4.20),(9.00,5.40),(7.50,4.40)]
    Rs = [(H-h)/H for H, h in data]
    n = len(Rs); mean = statistics.mean(Rs); sd = statistics.stdev(Rs); se = sd / math.sqrt(n)
    target = math.sqrt(2) - 1
    t_crit_90 = 2.131846  # t(0.95, df=4)
    lo, hi = mean - t_crit_90*se, mean + t_crit_90*se
    delta = 0.03  # هامش التكافؤ المعلن في الملف
    # توثيق منهجي (v1.2): لا يوجد في الملفات ما يثبت أن هامش ±0.03 حُدد قبل الاطلاع على البيانات.
    # إن اختير الهامش بعد رؤية النتائج، فهذا يضعف القيمة الاستدلالية للاختبار.
    TOST_DELTA_PREREGISTERED = False  # غير موثّق كمسجّل مسبقاً — يُعامل كتحليل استكشافي، لا كاختبار تأكيدي
    t_low = (mean - (target - delta)) / se
    t_up = ((target + delta) - mean) / se
    p_tost = max(1 - t_cdf(t_low, n-1), 1 - t_cdf(t_up, n-1))
    print(f"  البيانات الخام (H,h): {data}")
    print(f"  R لكل شجرة: {[round(r,5) for r in Rs]}")
    print(f"  n={n} · المتوسط={mean:.5f} · الانحراف المعياري={sd:.5f} · الخطأ المعياري={se:.5f}")
    print(f"  90% CI المحسوب = [{lo:.5f} , {hi:.5f}] (المعلن [0.40491 , 0.42102])")
    print(f"  TOST بهامش ±{delta}: t_low={t_low:.4f} · t_up={t_up:.4f} · p = {p_tost:.6f} (المعلن 0.000801)")
    assert abs(mean - 0.41297) < 0.001
    assert abs(lo - 0.40491) < 0.001 and abs(hi - 0.42102) < 0.001
    assert abs(p_tost - 0.000801) < 0.0002
    print("  ✓ أُعيد حساب المتوسط وفاصل الثقة واختبار TOST من البيانات الخام.")
    print("  ⚠ نتيجة التكافؤ مشروطة بهامش ±0.03 وافتراضات الاختبار، ولا تثبت قانوناً هندسياً.")
    print("  ⚠ التكافؤ لا يعني أن المتوسط يساوي √2-1، ولا أن النسبة ناتجة عن قانون هندسي.")
    print(f"  ⚠ هامش TOST مسجّل مسبقاً؟ {TOST_DELTA_PREREGISTERED} — غير موثّق، فيُعامل كنتيجة استكشافية.")
    print("  ⚠ حدود v1.2: لا توجد هنا اختبارات للبيانات الخام نفسها، ولا توثيق لمصدر القياسات أو طريقة أخذ العينة أو استقلال الأشجار.")
    print()

# ============================================================
# 7) ملاحظة 21
# ============================================================

def check_21():
    print("=" * 60)
    print("7) ملاحظة 21 — استكشافية فقط")
    print(f"  999999 = 21 × {999999//21} · التحليل الكامل: 3³ × 7 × 11 × 13 × 37 = {3**3*7*11*13*37}")
    print(f"  mod 21 : 1015={1015%21} ، 369={369%21} ، 124={124%21} ، 875={875%21}")
    print("  ✓ توافق صحيح، ليس برهان سببية.")
    print("  لـ mod 9 أساس بنيوي مباشر في النظام العشري: 10 ≡ 1 (mod 9)، ومن ثم العدد ≡ مجموع أرقامه (mod 9).")
    print("  أما mod 21 فلا توجد هذه الخاصية نفسها: 10 ≢ 1 (mod 21)، فيبقى توافقه ملاحظة حسابية استكشافية في هذا السياق.")
    print()

# ============================================================
# 8) Frame 5 — غير مثبت
# ============================================================

def check_frame5_status():
    print("=" * 60)
    print("8) Frame 5 — غير مثبت حتى التحقق المستقل")
    print("  الثوابت المنقولة كما هي: M=2π ، n=4π/21 ≈ 0.598399 ، C₀≈0.0058")
    print("  ⚠ تناقض ظاهري في lab01 §6 : الجدول يقول S<0 ، والتقدير يقول inf S > 0")
    assert FRAME5_STATUS.startswith("NOT_PROVEN"), "Frame 5 must never be marked proven"
    print(f"  حالة Frame 5 في v1.2: {FRAME5_STATUS}")
    print("  قائمة التحقق المعلّقة: [ ] تشغيل frame5.py الأصلي · [ ] مراجعة وحل تناقض S")
    print()

if __name__ == "__main__":
    print(f"\n🌴 واحة الجبري — jabri_clarifier_v{VERSION} — النسخة المعتمدة\n")
    check_root_vs_mod9()
    check_three_contexts()
    check_char_balance()
    check_733()
    check_angles()
    check_unified_curve()
    check_mango()
    check_21()
    check_frame5_status()
    print("=" * 60)
    print("✅ انتهى v1.2: كل نتيجة قابلة للفحص، وكل قسم في مكانه.")
    print("مبدأ v1.2: الحساب شيء، والتفسير شيء آخر، والبرهان شيء ثالث.")
    print("نجاح assert = تحقق العلاقات المختبرة ضمن شروطها، لا إثبات التفسيرات المبنية حولها.")