explore_sum.py

import json
import logging
import argparse
import sys
import os
import re
import math
from gematria import calculate_gematria, HEBREW_GEMATRIA_VALUES

# --- Konfiguration ---
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
BOOK_RANGE = range(1, 40)
INDICES_DIR = "indices_by_book"

# --- Neue Kernfunktionen ---

def xor_with_highest_power(total_sum, query_value):
    """
    Ihre neue XOR-Logik.
    """
    if total_sum <= 0 or query_value <= 1:
        logging.error("Summen und Anfrage-Wert müssen positiv und > 1 sein.")
        return None

    if query_value > total_sum:
        # Wenn der Query-Wert größer als die Summe ist, ist die höchste Potenz 1 (query^0)
        power = 1
    else:
        # Finde die höchste Potenz
        exponent = math.floor(math.log(total_sum, query_value))
        power = query_value ** exponent

    xor_result = total_sum ^ power
    logging.info(f"Kanon-Summe: {total_sum}, Anfrage-Wert: {query_value}")
    logging.info(f"Höchste Potenz von {query_value} <= {total_sum} ist {query_value}^{exponent} = {power}")
    logging.info(f"XOR-Ergebnis: {total_sum} ^ {power} = {xor_result}")
    return xor_result

def prepare_phrase_inventory(all_indices):
    """
    Erstellt eine flache Liste aller einzigartigen Phrasen aus allen Büchern,
    zusammen mit ihrem Gematria-Wert und ihrem Netzwerk-Score.
    """
    logging.info("Erstelle ein Inventar aller Phrasen aus 39 Büchern...")
    inventory = []
    seen_phrases = set()
    for book_num, index in all_indices.items():
        for gematria_val_str, data in index.items():
            gematria_val = int(gematria_val_str)
            pagerank = data.get('pagerank', 0)
            for phrase_data in data.get('phrases', []):
                phrase_text = phrase_data['text']
                if phrase_text not in seen_phrases:
                    count = phrase_data.get('count', 1)
                    # Definiere den "Bedeutungs-Score" (network)
                    score = pagerank / count if count > 0 else 0
                    inventory.append({
                        "text": phrase_text,
                        "gematria": gematria_val,
                        "score": score,
                        "source_book": book_num
                    })
                    seen_phrases.add(phrase_text)

    # Sortiere das Inventar, um Phrasen mit hohem Score und kleinem Wert zu bevorzugen
    inventory.sort(key=lambda x: (-x['score'], x['gematria']))
    logging.info(f"{len(inventory)} einzigartige Phrasen im Inventar gefunden.")
    return inventory

def find_phrase_combination(target_sum, inventory):
    """
    Findet eine Kombination von Phrasen, die die Ziel-Summe ergibt,
    indem es die Phrasen mit dem höchsten Score bevorzugt (Greedy-Algorithmus).
    """
    logging.info(f"Suche nach einer bedeutungsvollen Phrasen-Kombination für die Ziel-Summe: {target_sum}...")

    combination = []
    current_sum = 0

    # Gehe durch das nach Bedeutung sortierte Inventar
    for item in inventory:
        # Wenn die Phrase passt, ohne die Summe zu überschreiten, füge sie hinzu
        if current_sum + item['gematria'] <= target_sum:
            combination.append(item)
            current_sum += item['gematria']
            logging.debug(f"  + Phrase '{item['text']}' (G:{item['gematria']}) hinzugefügt. Aktuelle Summe: {current_sum}")

    logging.info(f"Kombination gefunden. Erreichte Summe: {current_sum} (Differenz zur Ziel-Summe: {target_sum - current_sum})")
    return combination

# --- Hauptprogramm ---

def main(args):
    # Lade alle Indizes
    all_indices = {}
    for i in BOOK_RANGE:
        index_path = os.path.join(INDICES_DIR, f"book_{i:02}_index.json")
        if os.path.exists(index_path):
            with open(index_path, 'r', encoding='utf-8') as f:
                all_indices[i] = json.load(f)
    if not all_indices:
        sys.exit("Keine Index-Dateien gefunden. Bitte 'build_indices.py' ausführen.")

    # 1. Berechne die Gematria-Summe jedes Buches und die Kanon-Summe
    logging.info("Berechne Gematria-Summen für jedes Buch...")
    kanon_sum = 0
    for i in BOOK_RANGE:
        book_sum = 0
        try:
            with open(f"texts/torah/{i:02}.json", 'r', encoding='utf-8') as file:
                data = json.load(file)
                full_text = ' '.join([' '.join(block) for block in data.get("text", [])])
                clean_text = re.sub(r"[^\u05D0-\u05EA]+", "", re.sub(r"\[.*?\]", "", full_text, flags=re.DOTALL))
                book_sum = calculate_gematria(clean_text)
                logging.debug(f"Buch {i:02}: Summe = {book_sum}")
                kanon_sum += book_sum
        except FileNotFoundError:
            continue
    logging.info(f"Gesamte Kanon-Summe berechnet: {kanon_sum}")

    # 2. Berechne den Gematria-Wert der Anfrage
    query_value = calculate_gematria(args.query)
    if query_value <= 1:
        sys.exit(f"Anfrage '{args.query}' hat einen ungültigen Gematria-Wert ({query_value}). Wert muss > 1 sein.")

    # 3. Wende die neue XOR-Operation an
    target_sum = xor_with_highest_power(kanon_sum, query_value)
    if target_sum is None:
        sys.exit("Fehler bei der XOR-Berechnung.")

    # 4. Bereite das Phrasen-Inventar vor
    phrase_inventory = prepare_phrase_inventory(all_indices)

    # 5. Finde die Phrasen-Kombination
    result_combination = find_phrase_combination(target_sum, phrase_inventory)

    # 6. Gib das Ergebnis aus
    print("\n" + "="*15 + " ERGEBNIS DER KONSEPTIONELLEN SUMMEN-ANALYSE " + "="*15)
    print(f"Anfrage: '{args.query}' (Gematria: {query_value})")
    print(f"Kanon-Summe: {kanon_sum}")
    print(f"Ziel-Summe nach XOR: {target_sum}")
    print("-" * 50)

    final_sum = 0
    if result_combination:
        print("Gefundene Phrasen-Kombination (geordnet nach Bedeutung):")
        for item in result_combination:
            final_sum += item['gematria']
            print(f"- {item['text']:<25} (G: {item['gematria']:<5} | Score: {item['score']:.4f} | Quelle: B{item['source_book']:02d})")
        print("-" * 50)
        print(f"Gesamtsumme der gefundenen Phrasen: {final_sum}")
        print(f"Differenz zum Ziel: {target_sum - final_sum} (Dieser Rest konnte nicht mit hoch-relevanten Phrasen gefüllt werden)")
    else:
        print("Keine passende Phrasen-Kombination gefunden.")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Conceptual Sum Gematria Engine.")
    parser.add_argument("query", type=str, help="Die Abfragephrase (z.B. 'יהוה').")
    args = parser.parse_args()
    main(args)