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
     try:
         exponent = int(math.floor(math.log(total_sum, query_value)))
         return query_value ** exponent
@@ -52,7 +52,7 @@ def main(args):
         except Exception as e:
             logging.error(f"Konnte Übersetzer nicht initialisieren: {e}")
 
-    logging.info(f"Starte Orakel-Analyse für '{args.query}' (G:{query_value}) mit Bitplane-Tiefe {args.xor_depth}...")
+    logging.info(f"Starte Orakel-Analyse für '{args.query}' (G:{query_value}) mit isolierter Bitplane-Tiefe {args.xor_depth}...")
     print("\n" + "="*20 + f" ORAKEL-ANTWORTEN FÜR '{args.query}' " + "="*20)
 
     verses_processed = 0
@@ -88,7 +88,7 @@ def main(args):
                                 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}")
+                                print(f"   [INFO] X={verse_sum}, Y={power_result}")
                                 header_printed = True
                             
                             matches.sort(key=lambda p: (p.get('freq', 0) / p.get('words', 99)), reverse=True)
@@ -108,31 +108,39 @@ def main(args):
                                 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}]")
+                        # 1. Die normale, vollständige XOR-Operation als Referenz
+                        main_target_sum = verse_sum ^ power_result
+                        main_matches = find_all_matching_phrases(main_target_sum, phrase_dictionary)
+                        calc_str = f"[X:{verse_sum}] ^ [Y:{power_result}] → [G_ziel:{main_target_sum}]"
+                        print_matches(main_matches, "Gesamt-Resonanz", calc_str)
                         
-                        # 2. Die Bitplane-Analyse
-                        for depth in range(args.xor_depth):
-                            bit_mask = 1 << depth
-                            bitplane_value = power_result & bit_mask
-                            if bitplane_value == 0: continue
-
-                            target_sum = verse_sum ^ bitplane_value
-                            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}]")
+                        # 2. Die isolierte Bitplane-Analyse
+                        if args.xor_depth > 0 and header_printed:
+                            for depth in range(args.xor_depth):
+                                bit_mask = 1 << depth
+                                
+                                bitplane_x = verse_sum & bit_mask
+                                bitplane_y = power_result & bit_mask
+                                
+                                target_sum = bitplane_x ^ bitplane_y
+                                
+                                # Wir suchen nur nach Phrasen, wenn das Ergebnis > 0 ist,
+                                # da Gematria 0 nicht aussagekräftig ist.
+                                if target_sum > 0:
+                                    bitplane_matches = find_all_matching_phrases(target_sum, phrase_dictionary)
+                                    bitplane_calc_str = f"Bitplane[{depth}](X:{bitplane_x}) ^ Bitplane[{depth}](Y:{bitplane_y}) → [G_ziel:{target_sum}]"
+                                    print_matches(bitplane_matches, f"Bitplane-Tiefe {depth}", bitplane_calc_str)
                             
         except FileNotFoundError: continue
 
     logging.info(f"Analyse abgeschlossen. {resonance_count} Resonanz-Verse in {verses_processed} analysierten Versen gefunden.")
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Tanakh Universal Resonance Analyzer mit Bitplane-Tiefe.")
+    parser = argparse.ArgumentParser(description="Tanakh Universal Resonance Analyzer mit isolierter Bitplane-Analyse.")
     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, 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="Anzahl der *einzelnen* Bit-Ebenen (0-15), die *nach* der Haupt-Resonanz geprüft werden (Standard: 16).")
+    parser.add_argument("--xor-depth", type=int, default=16, help="Maximale zu prüfende Bit-Ebene (0-15) (Standard: 16).")
     args = parser.parse_args()
     main(args)