better query calc

analyze_verses_universal.py

@@ -9,68 +9,93 @@ from deep_translator import GoogleTranslator
 from gematria import calculate_gematria
 from collections import defaultdict
 
-# --- Konfiguration ---
+# --- Configuration ---
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 BOOK_RANGE = range(1, 40)
 CACHE_FILE = "tanakh_phrasedict.cache"
 
-# --- Kernfunktionen ---
+# --- Core Functions ---
+
 def get_power_result(total_sum, query_value):
-    """Berechnet das Potenz-Ergebnis basierend auf dem höchsten möglichen Exponenten."""
+    """
+    Calculates the power or root result.
+    - If query_value <= total_sum, it finds the highest power of query_value that is <= total_sum.
+    - If query_value > total_sum, it finds the smallest n-th root of query_value whose result is <= total_sum.
+    """
     if total_sum <= 0 or query_value <= 1:
         return 1
-    elif query_value > total_sum:
-        return math.ceil(math.sqrt(query_value))
 
-    try:
-        exponent = int(math.floor(math.log(total_sum, query_value)))
-        return query_value ** exponent
-    except (ValueError, OverflowError):
+    # Normal case: "Power Mode"
+    if query_value <= total_sum:
+        try:
+            exponent = int(math.floor(math.log(total_sum, query_value)))
+            return query_value ** exponent
+        except (ValueError, OverflowError):
+            return 1
+
+    # Special case: "Root Mode"
+    else:  # query_value > total_sum
+        # Find the smallest integer root 'n' (starting from 2)
+        # that reduces query_value to a number <= total_sum.
+        for n in range(2, 65):  # Limit the search to a reasonable range (up to the 64th root)
+            try:
+                root_result = query_value ** (1.0 / n)
+                if root_result <= total_sum:
+                    # We found the smallest root exponent n.
+                    # Round up and return as an integer.
+                    return math.ceil(root_result)
+            except (ValueError, OverflowError):
+                # Catches math errors with extreme numbers
+                return 1
+
+        # If even the 64th root is too large, which only happens with
+        # extreme number ratios, return a default value.
         return 1
 
 def load_phrase_dictionary():
     if not os.path.exists(CACHE_FILE):
-        sys.exit(f"FEHLER: Cache-Datei '{CACHE_FILE}' nicht gefunden. Bitte 'build_indices.py' ausführen.")
-    logging.info(f"Lade Phrasen-Wörterbuch aus Cache: {CACHE_FILE}")
+        sys.exit(f"ERROR: Cache file '{CACHE_FILE}' not found. Please run 'build_indices.py' first to create the index.")
+    logging.info(f"Loading phrase dictionary from cache: {CACHE_FILE}")
     try:
         with open(CACHE_FILE, 'rb') as f:
             return pickle.load(f)
     except Exception as e:
-        sys.exit(f"FEHLER: Cache-Datei ist korrupt. Bitte löschen und 'build_indices.py' erneut ausführen. Fehler: {e}")
+        sys.exit(f"ERROR: Cache file '{CACHE_FILE}' is corrupt. Please delete it and run 'build_indices.py' again. Error: {e}")
 
 def find_all_matching_phrases(target_sum, phrase_dictionary):
-    return phrase_dictionary.get(target_sum, [])
+    return phrase_dictionary.get(int(target_sum), [])
 
-# --- Hauptprogramm ---
+# --- Main Program ---
 def main(args):
     phrase_dictionary = load_phrase_dictionary()
     query_value = calculate_gematria(args.query)
     if query_value <= 1:
-        sys.exit(f"Anfrage '{args.query}' hat einen ungültigen Gematria-Wert ({query_value}).")
+        sys.exit(f"ERROR: Query '{args.query}' has an invalid Gematria value ({query_value}).")
 
     translator = None
     if args.translate:
         try:
+            # The correct code for Hebrew is 'iw'
             translator = GoogleTranslator(source='iw', target='en')
         except Exception as e:
-            logging.error(f"Konnte Übersetzer nicht initialisieren: {e}")
+            logging.error(f"Could not initialize translator: {e}")
 
-    logging.info(f"Starte Orakel-Analyse für '{args.query}' (G:{query_value}) mit Bitplane-Variationstiefe {args.xor_depth}...")
-    print("\n" + "="*20 + f" ORAKEL-ANTWORTEN FÜR '{args.query}' " + "="*20)
+    logging.info(f"Starting oracle analysis for '{args.query}' (G:{query_value}) with bitplane variation depth {args.xor_depth}...")
+    print("\n" + "="*20 + f" ORACLE ANSWERS FOR '{args.query}' " + "="*20)
 
     verses_processed = 0
     resonance_count = 0
 
     for book_num in BOOK_RANGE:
         if args.process_verses and verses_processed >= args.process_verses: break
-        
+
         filepath = f"texts/torah/{book_num:02}.json"
         try:
             with open(filepath, 'r', encoding='utf-8') as file:
                 data = json.load(file)
                 for chap_idx, chapter in enumerate(data.get("text", []), start=1):
                     if args.process_verses and verses_processed >= args.process_verses: break
-                    
+
                     for verse_idx, verse_text in enumerate(chapter, start=1):
                         if args.process_verses and verses_processed >= args.process_verses: break
                         verses_processed += 1
@@ -79,69 +104,72 @@ def main(args):
                         if verse_sum <= 1: continue
 
                         power_result = get_power_result(verse_sum, query_value)
-                        
-                        # Zuerst das Haupt-Ergebnis berechnen
+
+                        # Calculate the main result first
                         main_target_sum = verse_sum ^ power_result
                         main_matches = find_all_matching_phrases(main_target_sum, phrase_dictionary)
 
-                        # Nur fortfahren, wenn die Haupt-Resonanz existiert
+                        # Only proceed if a main resonance exists
                         if not main_matches:
                             continue
 
                         resonance_count += 1
-                        verse_ref = f"B{book_num:02d}, K{chap_idx}, V{verse_idx}"
-                        print(f"\n--- Resonanz #{resonance_count} in [{verse_ref}] (G_sum:{verse_sum}) ---")
-                        print(f"Originalvers: {verse_text.strip()}")
-                        
+                        verse_ref = f"B{book_num:02d}, C{chap_idx}, V{verse_idx}"
+                        print(f"\n--- Resonance #{resonance_count} in [{verse_ref}] (G_sum:{verse_sum}) ---")
+                        print(f"Original Verse: {verse_text.strip()}")
+
                         def print_matches(matches, title, calculation_str):
                             if not matches: return
-                            
+
                             matches.sort(key=lambda p: (p.get('freq', 0) / p.get('words', 99)), reverse=True)
                             matches_to_show = matches[:args.results_per_verse]
 
                             print(f"  ↳ {title}: {calculation_str}")
-                            
+
                             for match in matches_to_show:
                                 translation_str = ""
                                 if translator:
-                                    try: translation_str = translator.translate(match['text'])
-                                    except Exception: translation_str = "[Übersetzung fehlgeschlagen]"
+                                    try:
+                                        translation_str = translator.translate(match['text'])
+                                    except Exception:
+                                        translation_str = "[Translation failed]"
 
                                 score = (match.get('freq', 0) / match.get('words', 99))
-                                info = f"(Wörter: {match.get('words', 'N/A')}, Freq: {match.get('freq', 'N/A')}, Score: {score:.2f})"
+                                info = f"(Words: {match.get('words', 'N/A')}, Freq: {match.get('freq', 'N/A')}, Score: {score:.2f})"
                                 print(f"     - {match['text']} {info}")
                                 if translation_str:
                                     print(f"       ↳ Interpretation: \"{translation_str}\"")
 
-                        # 1. Die Haupt-Resonanz anzeigen
-                        calc_str = f"[{verse_sum}] ^ [{power_result}] → [G_ziel:{main_target_sum}]"
-                        print_matches(main_matches, "Haupt-Resonanz", calc_str)
-                        
-                        # 2. Die Bitplane-Variationen des ERGEBNISSES anzeigen
+                        # 1. Display the main resonance
+                        calc_str = f"[{verse_sum}] ^ [{power_result}] → [G_target:{main_target_sum}]"
+                        print_matches(main_matches, "Main Resonance", calc_str)
+
+                        # 2. Display the bitplane variations of the RESULT
                         if args.xor_depth > 0:
-                            print(f"   [INFO] Bitplane-Variationen des Ergebnisses ({main_target_sum}):")
+                            print(f"   [INFO] Bitplane Variations of the Result ({main_target_sum}):")
                             for depth in range(args.xor_depth):
                                 bit_flip = 1 << depth
-                                
-                                # Flippe das Bit 'd' im Hauptergebnis
+
+                                # Flip the 'd'-th bit in the main result
                                 target_sum = main_target_sum ^ bit_flip
-                                
+
                                 bitplane_matches = find_all_matching_phrases(target_sum, phrase_dictionary)
-                                
+
                                 if bitplane_matches:
-                                    bitplane_calc_str = f"[{main_target_sum}] ^ [Bit {depth}] → [G_ziel:{target_sum}]"
-                                    print_matches(bitplane_matches, f"Variation (Tiefe {depth})", bitplane_calc_str)
-                            
+                                    # FIX: The label is now depth + 1 for human readability
+                                    bitplane_calc_str = f"[{main_target_sum}] ^ [Bit {depth+1}] → [G_target:{target_sum}]"
+                                    print_matches(bitplane_matches, f"Variation (Depth {depth + 1})", bitplane_calc_str)
+
         except FileNotFoundError: continue
 
-    logging.info(f"Analyse abgeschlossen. {resonance_count} Resonanz-Verse in {verses_processed} analysierten Versen gefunden.")
+    logging.info(f"Analysis complete. Found {resonance_count} resonance groups in {verses_processed} analyzed verses.")
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Tanakh Universal Resonance Analyzer mit Bitplane-Variationen.")
-    parser.add_argument("query", type=str, help="Die Abfragephrase (z.B. 'יהוה').")
-    parser.add_argument("--translate", action="store_true", help="Aktiviert die automatische Übersetzung.")
-    parser.add_argument("--process-verses", type=int, default=10, help="Maximale Anzahl der zu analysierenden Start-Verse.")
-    parser.add_argument("--results-per-verse", type=int, default=3, help="Maximale Orakel-Antworten pro Resonanz-Typ (Standard: 3).")
-    parser.add_argument("--xor-depth", type=int, default=16, help="Maximale Tiefe für Bitplane-Variationen des Ergebnisses (0-15) (Standard: 16).")
+    parser = argparse.ArgumentParser(description="Tanakh Universal Resonance Analyzer with Bitplane Variations.")
+    parser.add_argument("query", type=str, help="The query phrase (e.g., 'יהוה').")
+    parser.add_argument("--translate", action="store_true", default=True, help="Enable automatic translation of results to English.")
+    parser.add_argument("--process-verses", type=int, default=10, help="Maximum number of starting verses to analyze.")
+    parser.add_argument("--results-per-verse", type=int, default=1, help="Maximum oracle answers to show per resonance type (default: 3).")
+    parser.add_argument("--xor-depth", type=int, default=2, help="Maximum depth for bitplane variations of the result (0-15) (default: 16).")
     args = parser.parse_args()
     main(args)