Update analyze_verses_universal.py

analyze_verses_universal.py

@@ -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 isolierter Bitplane-Tiefe {args.xor_depth}...")
+    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)
 
     verses_processed = 0
@@ -77,20 +77,22 @@ def main(args):
 
                         power_result = get_power_result(verse_sum, query_value)
                         
-                        header_printed = False
+                        # Zuerst das Haupt-Ergebnis berechnen
+                        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
+                        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()}")
+                        
                         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] X={verse_sum}, Y={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]
 
@@ -108,39 +110,35 @@ def main(args):
                                 if translation_str:
                                     print(f"       ↳ Interpretation: \"{translation_str}\"")
 
-                        # 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)
+                        # 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 isolierte Bitplane-Analyse
-                        if args.xor_depth > 0 and header_printed:
+                        # 2. Die Bitplane-Variationen des ERGEBNISSES anzeigen
+                        if args.xor_depth > 0:
+                            print(f"   [INFO] Bitplane-Variationen des Ergebnisses ({main_target_sum}):")
                             for depth in range(args.xor_depth):
-                                bit_mask = 1 << depth
+                                bit_flip = 1 << depth
                                 
-                                bitplane_x = verse_sum & bit_mask
-                                bitplane_y = power_result & bit_mask
+                                # Flippe das Bit 'd' im Hauptergebnis
+                                target_sum = main_target_sum ^ bit_flip
                                 
-                                target_sum = bitplane_x ^ bitplane_y
+                                bitplane_matches = find_all_matching_phrases(target_sum, phrase_dictionary)
                                 
-                                # 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)
+                                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)
                             
         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 isolierter Bitplane-Analyse.")
+    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, 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 Bit-Ebene (0-15) (Standard: 16).")
+    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).")
     args = parser.parse_args()
     main(args)