Update analyze_verses_universal.py

analyze_verses_universal.py

@@ -18,7 +18,7 @@ CACHE_FILE = "tanakh_phrasedict.cache"
 def get_power_result(total_sum, query_value):
     """Berechnet das Potenz-Ergebnis basierend auf dem höchsten möglichen Exponenten."""
     if total_sum <= 0 or query_value <= 1 or query_value > total_sum:
-        return 1 # Fallback auf Potenz 1 (query_value^0)
+        return 1  # Fallback auf Potenz 1 (query_value^0)
     try:
         exponent = int(math.floor(math.log(total_sum, query_value)))
         return query_value ** exponent
@@ -48,7 +48,6 @@ def main(args):
     translator = None
     if args.translate:
         try:
-            # FIX: Der korrekte Code für Hebräisch ist 'iw'
             translator = GoogleTranslator(source='iw', target='en')
         except Exception as e:
             logging.error(f"Konnte Übersetzer nicht initialisieren: {e}")
@@ -61,14 +60,14 @@ def main(args):
 
     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
@@ -76,49 +75,54 @@ def main(args):
                         verse_sum = calculate_gematria(verse_text)
                         if verse_sum <= 1: continue
 
-                        # *** FINALE LOGIK: Bitplane-Tiefe der Potenz ***
                         power_result = get_power_result(verse_sum, query_value)
-
+                        
                         header_printed = False
 
-                        # Iteriere durch die Bit-Ebenen von 0 bis zur angegebenen Tiefe
+                        def print_matches(matches, title, calculation_str):
+                            nonlocal header_printed, resonance_count
+                            if not matches: return
+                            
+                            if not header_printed:
+                                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()}")
+                                print(f"   [INFO] Potenzergebnis des Queries: {power_result}")
+                                header_printed = True
+                            
+                            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]"
+
+                                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})"
+                                print(f"     - {match['text']} {info}")
+                                if translation_str:
+                                    print(f"       ↳ Interpretation: \"{translation_str}\"")
+
+                        # 1. Die normale, vollständige XOR-Operation
+                        normal_target_sum = verse_sum ^ power_result
+                        normal_matches = find_all_matching_phrases(normal_target_sum, phrase_dictionary)
+                        print_matches(normal_matches, "Gesamt-Resonanz (Tiefe 0)", f"[G_sum:{verse_sum}] ^ {power_result} → [G_ziel:{normal_target_sum}]")
+                        
+                        # 2. Die Bitplane-Analyse
                         for depth in range(args.xor_depth):
                             bit_mask = 1 << depth
-
-                            # Wir prüfen nur Ebenen, bei denen das Bit im Potenzergebnis auch gesetzt ist
                             bitplane_value = power_result & bit_mask
-                            if bitplane_value == 0:
-                                continue
+                            if bitplane_value == 0: continue
 
                             target_sum = verse_sum ^ bitplane_value
-
-                            all_matches = find_all_matching_phrases(target_sum, phrase_dictionary)
-
-                            if all_matches:
-                                if not header_printed:
-                                    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()}")
-                                    print(f"   [INFO] Potenzergebnis des Queries: {power_result}")
-                                    header_printed = True
-
-                                all_matches.sort(key=lambda p: (p.get('freq', 0) / p.get('words', 99)), reverse=True)
-                                matches_to_show = all_matches[:args.results_per_verse]
-
-                                print(f"  ↳ Bitplane-Tiefe {depth}: [G_sum:{verse_sum}] ^ (Bit {depth} von {power_result}) → [G_ziel:{target_sum}]")
-
-                                for match in matches_to_show:
-                                    translation = ""
-                                    if translator:
-                                        try: translation = translator.translate(match['text'])
-                                        except Exception: translation = "[Übersetzung fehlgeschlagen]"
-
-                                    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})"
-                                    print(f"     - {match['text']} {info}")
-                                    if translation:
-                                        print(f"       ↳ Interpretation: \"{translation}\"")
+                            bitplane_matches = find_all_matching_phrases(target_sum, phrase_dictionary)
+                            print_matches(bitplane_matches, f"Bitplane-Tiefe {depth + 1} (Bit {depth})", f"[G_sum:{verse_sum}] ^ {bitplane_value} → [G_ziel:{target_sum}]")
+                            
         except FileNotFoundError: continue
 
     logging.info(f"Analyse abgeschlossen. {resonance_count} Resonanz-Verse in {verses_processed} analysierten Versen gefunden.")
@@ -129,6 +133,6 @@ if __name__ == "__main__":
     parser.add_argument("--translate", action="store_true", help="Aktiviert die automatische Übersetzung.")
     parser.add_argument("--process-verses", type=int, help="Maximale Anzahl der zu analysierenden Start-Verse.")
     parser.add_argument("--results-per-verse", type=int, default=3, help="Maximale Orakel-Antworten pro gefundener Resonanz (Standard: 3).")
-    parser.add_argument("--xor-depth", type=int, default=16, help="Maximale zu prüfende Bitplane-Tiefe (z.B. 16 für 16-Bit Zahlen, Standard: 16).")
+    parser.add_argument("--xor-depth", type=int, default=16, help="Anzahl der *einzelnen* Bit-Ebenen (0-15), die *nach* der Haupt-Resonanz geprüft werden (Standard: 16).")
     args = parser.parse_args()
-    main(args)
+    main(args)