kececinumbers 0.6.3__py3-none-any.whl → 0.6.5__py3-none-any.whl

kececinumbers/__init__.py

@@ -22,7 +22,7 @@ import warnings
     # importlib.reload(kececinumbers) # F821 undefined name 'kececinumbers'
 
 # Paket sürüm numarası
-__version__ = "0.6.3"
+__version__ = "0.6.5"
 __author__ = "Mehmet Keçeci"
 __email__ = "mkececi@yaani.com"
 
@@ -42,6 +42,14 @@ __all__ = [
     '_get_integer_representation',
     '_parse_quaternion_from_csv',
     'generate_kececi_vectorial',
+    '_plot_comparison',
+    '_find_kececi_zeta_zeros',
+    '_compute_gue_similarity',
+    '_load_zeta_zeros',
+    'analyze_all_types',
+    'analyze_pair_correlation',
+    '_gue_pair_correlation',
+    '_pair_correlation',
 
     # --- Core Generation and Analysis ---
     'unified_generator',
@@ -95,6 +103,15 @@ try:
         find_kececi_prime_number,
         plot_numbers,
         print_detailed_report,
+        _plot_comparison,
+        _find_kececi_zeta_zeros,
+        _compute_gue_similarity,
+        _load_zeta_zeros,
+        analyze_all_types,
+        analyze_pair_correlation,
+        _gue_pair_correlation,
+        _pair_correlation,
+        
     
         # Constants
         TYPE_POSITIVE_REAL,

kececinumbers/_version.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 # _version.py
 
-__version__ = "0.6.3"
+__version__ = "0.6.5"
 __license__ = "MIT"
 __description__ = "Keçeci Numbers: An Exploration of a Dynamic Sequence Across Diverse Number Sets."
 __author__ = "Mehmet Keçeci"

kececinumbers/kececinumbers.py

@@ -39,6 +39,9 @@ import numpy as np
 import quaternion
 import random
 import re
+from scipy.fft import fft, fftfreq
+from scipy.signal import find_peaks
+from scipy.stats import ks_2samp
 import sympy
 from typing import Any, Dict, List, Optional, Tuple
 
@@ -544,6 +547,448 @@ def _parse_quaternion_from_csv(s: str) -> np.quaternion:
     except (ValueError, IndexError) as e:
         raise ValueError(f"Geçersiz virgülle ayrılmış kuaterniyon formatı: '{s}'.") from e
 
+def _load_zeta_zeros(filename="zeta.txt"):
+    """
+    Loads Riemann zeta zeros from a text file.
+    Each line should contain one floating-point number representing the imaginary part of a zeta zero.
+    Lines that are empty or start with '#' are ignored.
+    Returns:
+        numpy.ndarray: Array of zeta zeros, or empty array if file not found.
+    """
+    try:
+        with open(filename, 'r', encoding='utf-8') as file:
+            lines = file.readlines()
+        zeta_zeros = []
+        for line in lines:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            try:
+                zeta_zeros.append(float(line))
+            except ValueError:
+                print(f"Invalid line skipped: {line}")
+        print(f"{len(zeta_zeros)} zeta zeros loaded.")
+        return np.array(zeta_zeros)
+    except FileNotFoundError:
+        print(f"'{filename}' not found.")
+        return np.array([])
+
+
+def _compute_gue_similarity(sequence, tolerance=0.5):
+    """
+    Measures how closely the frequency spectrum of a Keçeci sequence matches the GUE (Gaussian Unitary Ensemble) statistics.
+    Uses Kolmogorov-Smirnov test against Wigner-Dyson distribution.
+    Args:
+        sequence (list): The Keçeci number sequence.
+        tolerance (float): Not used here; kept for interface consistency.
+    Returns:
+        tuple: (similarity_score, p_value)
+    """
+    from . import _get_integer_representation
+
+    values = [val for z in sequence if (val := _get_integer_representation(z)) is not None]
+    if len(values) < 10:
+        return 0.0, 0.0
+
+    values = np.array(values) - np.mean(values)
+    N = len(values)
+    powers = np.abs(fft(values))**2
+    freqs = fftfreq(N)
+
+    mask = (freqs > 0)
+    freqs_pos = freqs[mask]
+    powers_pos = powers[mask]
+
+    if len(powers_pos) == 0:
+        return 0.0, 0.0
+
+    peaks, _ = find_peaks(powers_pos, height=np.max(powers_pos)*1e-7)
+    strong_freqs = freqs_pos[peaks]
+
+    if len(strong_freqs) < 2:
+        return 0.0, 0.0
+
+    # Scale so the strongest peak aligns with the first Riemann zeta zero
+    peak_freq = strong_freqs[np.argmax(powers_pos[peaks])]
+    scale_factor = 14.134725 / peak_freq
+    scaled_freqs = np.sort(strong_freqs * scale_factor)
+
+    # Compute level spacings
+    if len(scaled_freqs) < 2:
+        return 0.0, 0.0
+    diffs = np.diff(scaled_freqs)
+    if np.mean(diffs) == 0:
+        return 0.0, 0.0
+    diffs_norm = diffs / np.mean(diffs)
+
+    # Generate GUE sample using Wigner-Dyson distribution
+    def wigner_dyson(s):
+        return (32 / np.pi) * s**2 * np.exp(-4 * s**2 / np.pi)
+
+    s_gue = np.linspace(0.01, 3.0, 1000)
+    p_gue = wigner_dyson(s_gue)
+    p_gue = p_gue / np.sum(p_gue)
+    sample_gue = np.random.choice(s_gue, size=1000, p=p_gue)
+
+    # Perform KS test
+    ks_stat, ks_p = ks_2samp(diffs_norm, sample_gue)
+    similarity_score = 1.0 - ks_stat
+
+    return similarity_score, ks_p
+
+
+def _find_kececi_zeta_zeros(sequence, tolerance=0.5):
+    """
+    Estimates the zeros of the Keçeci Zeta Function from the spectral peaks of the sequence.
+    Compares them to known Riemann zeta zeros.
+    Args:
+        sequence (list): The Keçeci number sequence.
+        tolerance (float): Maximum distance for a match between Keçeci and Riemann zeros.
+    Returns:
+        tuple: (list of Keçeci zeta zeros, matching score)
+    """
+    from . import _get_integer_representation
+
+    values = [val for z in sequence if (val := _get_integer_representation(z)) is not None]
+    if len(values) < 10:
+        return [], 0.0
+
+    values = np.array(values) - np.mean(values)
+    N = len(values)
+    powers = np.abs(fft(values))**2
+    freqs = fftfreq(N)
+
+    mask = (freqs > 0)
+    freqs_pos = freqs[mask]
+    powers_pos = powers[mask]
+
+    if len(powers_pos) == 0:
+        return [], 0.0
+
+    peaks, _ = find_peaks(powers_pos, height=np.max(powers_pos)*1e-7)
+    strong_freqs = freqs_pos[peaks]
+
+    if len(strong_freqs) < 2:
+        return [], 0.0
+
+    # Scale so the strongest peak aligns with the first Riemann zeta zero
+    peak_freq = strong_freqs[np.argmax(powers_pos[peaks])]
+    scale_factor = 14.134725 / peak_freq
+    scaled_freqs = np.sort(strong_freqs * scale_factor)
+
+    # Find candidate zeros by analyzing the Keçeci Zeta Function
+    t_vals = np.linspace(0, 650, 10000)
+    zeta_vals = np.array([sum((scaled_freqs + 1e-10)**(- (0.5 + 1j * t))) for t in t_vals])
+    minima, _ = find_peaks(-np.abs(zeta_vals), height=-0.5*np.max(np.abs(zeta_vals)), distance=5)
+    kececi_zeta_zeros = t_vals[minima]
+
+    # Load Riemann zeta zeros for comparison
+    zeta_zeros_imag = _load_zeta_zeros("zeta.txt")
+    if len(zeta_zeros_imag) == 0:
+        return kececi_zeta_zeros, 0.0
+
+    # Calculate matching score
+    close_matches = [kz for kz in kececi_zeta_zeros if min(abs(kz - zeta_zeros_imag)) < tolerance]
+    score = len(close_matches) / len(kececi_zeta_zeros) if kececi_zeta_zeros.size > 0 else 0.0
+
+    return kececi_zeta_zeros, score
+
+
+def analyze_all_types(iterations=120):
+    """
+    Performs automated analysis on all 11 Keçeci number types.
+    For each type, it tests multiple parameter sets, computes similarity to Riemann zeta zeros and GUE statistics,
+    then reports and plots the results.
+    Args:
+        iterations (int): Number of Keçeci steps to generate for each sequence.
+    Returns:
+        tuple: (sorted_by_zeta, sorted_by_gue) - Lists of results sorted by performance.
+    """
+    from . import (
+        get_with_params,
+        TYPE_POSITIVE_REAL,
+        TYPE_NEGATIVE_REAL,
+        TYPE_COMPLEX,
+        TYPE_FLOAT,
+        TYPE_RATIONAL,
+        TYPE_QUATERNION,
+        TYPE_NEUTROSOPHIC,
+        TYPE_NEUTROSOPHIC_COMPLEX,
+        TYPE_HYPERREAL,
+        TYPE_BICOMPLEX,
+        TYPE_NEUTROSOPHIC_BICOMPLEX
+    )
+
+    print("Automated Analysis for 11 Keçeci Types")
+    print("=" * 80)
+
+    include_intermediate = True
+    results = []
+
+    # Parameter sets to test
+    param_sets = [
+        ('0.0', '9.0'),
+        ('1.0', '7.0'),
+        ('2.0', '5.0'),
+        ('3.0', '11.0'),
+        ('1+1j', '9.0'),
+        ('0.0001412', '0.037')
+    ]
+
+    type_names = {
+        1: "Positive Real",
+        2: "Negative Real",
+        3: "Complex",
+        4: "Float",
+        5: "Rational",
+        6: "Quaternion",
+        7: "Neutrosophic",
+        8: "Neutro-Complex",
+        9: "Hyperreal",
+        10: "Bicomplex",
+        11: "Neutro-Bicomplex"
+    }
+
+    for kececi_type in range(1, 12):
+        name = type_names[kececi_type]
+        best_zeta_score = 0.0
+        best_gue_score = 0.0
+        best_params = None
+
+        print(f"Analyzing type {kececi_type} ({name})...")
+
+        for start, add in param_sets:
+            try:
+                # Special formatting for complex types
+                if kececi_type == 3 and '+' not in start:
+                    start = f"{start}+{start}j"
+                if kececi_type == 10 and '+' not in start:
+                    start = f"{start}+{start}j"
+
+                sequence = get_with_params(
+                    kececi_type_choice=kececi_type,
+                    iterations=iterations,
+                    start_value_raw=start,
+                    add_value_raw=add,
+                    include_intermediate_steps=include_intermediate
+                )
+
+                if not sequence or len(sequence) < 50:
+                    continue
+
+                _, zeta_score = _find_kececi_zeta_zeros(sequence, tolerance=0.5)
+                _, gue_score = _compute_gue_similarity(sequence)
+
+                if zeta_score > best_zeta_score:
+                    best_zeta_score = zeta_score
+                    best_gue_score = gue_score
+                    best_params = (start, add)
+
+            except Exception as e:
+                continue
+
+        if best_params:
+            results.append({
+                'type': kececi_type,
+                'name': name,
+                'start': best_params[0],
+                'add': best_params[1],
+                'zeta_score': best_zeta_score,
+                'gue_score': best_gue_score
+            })
+
+    # Sort results
+    sorted_by_zeta = sorted(results, key=lambda x: x['zeta_score'], reverse=True)
+    sorted_by_gue = sorted(results, key=lambda x: x['gue_score'], reverse=True)
+
+    print("\n" + "=" * 100)
+    print("HIGHEST RIEMANN ZETA MATCHING SCORES (TOP 11)")
+    print("=" * 100)
+    print(f"{'Type':<20} {'Score':<8} {'Start':<12} {'Increment':<12}")
+    print("-" * 100)
+    for r in sorted_by_zeta:
+        print(f"{r['name']:<20} {r['zeta_score']:<8.3f} {r['start']:<12} {r['add']:<12}")
+
+    print("\n" + "=" * 100)
+    print("HIGHEST GUE SIMILARITY SCORES (TOP 11)")
+    print("=" * 100)
+    print(f"{'Type':<20} {'Score':<8} {'Start':<12} {'Increment':<12}")
+    print("-" * 100)
+    for r in sorted_by_gue:
+        print(f"{r['name']:<20} {r['gue_score']:<8.3f} {r['start']:<12} {r['add']:<12}")
+
+    # Plot results
+    _plot_comparison(sorted_by_zeta, sorted_by_gue)
+
+    return sorted_by_zeta, sorted_by_gue
+
+
+def _plot_comparison(zeta_results, gue_results):
+    """
+    Creates bar charts comparing the performance of Keçeci types in matching Riemann zeta zeros and GUE statistics.
+    Args:
+        zeta_results (list): Results sorted by zeta matching score.
+        gue_results (list): Results sorted by GUE similarity score.
+    """
+    # Riemann Zeta Matching Plot
+    plt.figure(figsize=(14, 7))
+    types = [r['name'] for r in zeta_results]
+    scores = [r['zeta_score'] for r in zeta_results]
+    colors = ['skyblue'] * len(scores)
+    if scores:
+        colors[0] = 'red'
+    bars = plt.bar(types, scores, color=colors, edgecolor='black', alpha=0.8)
+    plt.xticks(rotation=45, ha='right')
+    plt.ylabel("Riemann Zeta Matching Score")
+    plt.title("Keçeci Types vs Riemann Zeta Zeros")
+    plt.grid(True, alpha=0.3)
+    if bars:
+        bars[0].set_edgecolor('darkred')
+        bars[0].set_linewidth(1.5)
+    plt.tight_layout()
+    plt.show()
+
+    # GUE Similarity Plot
+    plt.figure(figsize=(14, 7))
+    types = [r['name'] for r in gue_results]
+    scores = [r['gue_score'] for r in gue_results]
+    colors = ['skyblue'] * len(scores)
+    if scores:
+        colors[0] = 'red'
+    bars = plt.bar(types, scores, color=colors, edgecolor='black', alpha=0.8)
+    plt.xticks(rotation=45, ha='right')
+    plt.ylabel("GUE Similarity Score")
+    plt.title("Keçeci Types vs GUE Statistics")
+    plt.grid(True, alpha=0.3)
+    if bars:
+        bars[0].set_edgecolor('darkred')
+        bars[0].set_linewidth(1.5)
+    plt.tight_layout()
+    plt.show()
+
+def _pair_correlation(ordered_zeros, max_gap=3.0, bin_size=0.1):
+    """
+    Computes the pair correlation of a list of ordered zeros.
+    This function calculates the normalized spacings between all pairs of zeros
+    and returns a histogram of their distribution.
+    Args:
+        ordered_zeros (numpy.ndarray): Sorted array of zero locations (e.g., Keçeci or Riemann zeta zeros).
+        max_gap (float): Maximum normalized gap to consider.
+        bin_size (float): Size of bins for the histogram.
+    Returns:
+        tuple: (bin_centers, histogram) - The centers of the bins and the normalized histogram values.
+    """
+    n = len(ordered_zeros)
+    if n < 2:
+        return np.array([]), np.array([])
+
+    # Compute average spacing for normalization
+    avg_spacing = np.mean(np.diff(ordered_zeros))
+    normalized_zeros = ordered_zeros / avg_spacing
+
+    # Compute all pairwise gaps within max_gap
+    gaps = []
+    for i in range(n):
+        for j in range(i + 1, n):
+            gap = abs(normalized_zeros[j] - normalized_zeros[i])
+            if gap <= max_gap:
+                gaps.append(gap)
+
+    # Create histogram
+    bins = np.arange(0, max_gap + bin_size, bin_size)
+    hist, _ = np.histogram(gaps, bins=bins, density=True)
+    bin_centers = (bins[:-1] + bins[1:]) / 2
+
+    return bin_centers, hist
+
+
+def _gue_pair_correlation(s):
+    """
+    Theoretical pair correlation function for the Gaussian Unitary Ensemble (GUE).
+    This function is used as a reference for comparing the statistical distribution
+    of eigenvalues (or zeta zeros) in quantum chaotic systems.
+    Args:
+        s (numpy.ndarray or float): Normalized spacing(s).
+    Returns:
+        numpy.ndarray or float: The GUE pair correlation value(s) at s.
+    """
+    return 1 - np.sinc(s)**2
+
+
+def analyze_pair_correlation(sequence, title="Pair Correlation of Keçeci Zeta Zeros"):
+    """
+    Analyzes and plots the pair correlation of Keçeci Zeta zeros derived from a Keçeci sequence.
+    Compares the empirical pair correlation to the theoretical GUE prediction.
+    Performs a Kolmogorov-Smirnov test to quantify the similarity.
+    Args:
+        sequence (list): A Keçeci number sequence.
+        title (str): Title for the resulting plot.
+    """
+    from . import _get_integer_representation
+
+    # Extract integer representations and remove DC component
+    values = [val for z in sequence if (val := _get_integer_representation(z)) is not None]
+    if len(values) < 10:
+        print("Insufficient data.")
+        return
+
+    values = np.array(values) - np.mean(values)
+    N = len(values)
+    powers = np.abs(fft(values))**2
+    freqs = fftfreq(N)
+
+    # Filter positive frequencies
+    mask = (freqs > 0)
+    freqs_pos = freqs[mask]
+    powers_pos = powers[mask]
+
+    if len(powers_pos) == 0:
+        print("No positive frequencies found.")
+        return
+
+    # Find spectral peaks
+    peaks, _ = find_peaks(powers_pos, height=np.max(powers_pos)*1e-7)
+    strong_freqs = freqs_pos[peaks]
+
+    if len(strong_freqs) < 2:
+        print("Insufficient frequency peaks.")
+        return
+
+    # Scale frequencies so the strongest peak aligns with the first Riemann zeta zero
+    peak_freq = strong_freqs[np.argmax(powers_pos[peaks])]
+    scale_factor = 14.134725 / peak_freq
+    scaled_freqs = np.sort(strong_freqs * scale_factor)
+
+    # Estimate Keçeci Zeta zeros by finding minima of |ζ_Kececi(0.5 + it)|
+    t_vals = np.linspace(0, 650, 10000)
+    zeta_vals = np.array([sum((scaled_freqs + 1e-10)**(- (0.5 + 1j * t))) for t in t_vals])
+    minima, _ = find_peaks(-np.abs(zeta_vals), height=-0.5*np.max(np.abs(zeta_vals)), distance=5)
+    kececi_zeta_zeros = t_vals[minima]
+
+    if len(kececi_zeta_zeros) < 2:
+        print("Insufficient Keçeci zeta zeros found.")
+        return
+
+    # Compute pair correlation
+    bin_centers, hist = _pair_correlation(kececi_zeta_zeros, max_gap=3.0, bin_size=0.1)
+    gue_corr = _gue_pair_correlation(bin_centers)
+
+    # Plot results
+    plt.figure(figsize=(12, 6))
+    plt.plot(bin_centers, hist, 'o-', label="Keçeci Zeta Zeros", linewidth=2)
+    plt.plot(bin_centers, gue_corr, 'r-', label="GUE (Theoretical)", linewidth=2)
+    plt.title(title)
+    plt.xlabel("Normalized Spacing (s)")
+    plt.ylabel("Pair Correlation Density")
+    plt.legend()
+    plt.grid(True, alpha=0.3)
+    plt.tight_layout()
+    plt.show()
+
+    # Perform Kolmogorov-Smirnov test
+    ks_stat, ks_p = ks_2samp(hist, gue_corr)
+    print(f"Pair Correlation KS Test: Statistic={ks_stat:.4f}, p-value={ks_p:.4f}")
+
 # ==============================================================================
 # --- CORE GENERATOR ---
 # ==============================================================================

{kececinumbers-0.6.3.dist-info → kececinumbers-0.6.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kececinumbers
-Version: 0.6.3
+Version: 0.6.5
 Summary: Keçeci Numbers: An Exploration of a Dynamic Sequence Across Diverse Number Sets
 Home-page: https://github.com/WhiteSymmetry/kececinumbers
 Author: Mehmet Keçeci
@@ -42,6 +42,7 @@ License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: matplotlib
 Requires-Dist: numpy-quaternion
+Requires-Dist: scipy
 Requires-Dist: sympy
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
@@ -51,6 +52,7 @@ Requires-Dist: ruff; extra == "test"
 Requires-Dist: numpy; extra == "test"
 Requires-Dist: matplotlib; extra == "test"
 Requires-Dist: numpy-quaternion; extra == "test"
+Requires-Dist: scipy; extra == "test"
 Requires-Dist: sympy; extra == "test"
 Dynamic: author
 Dynamic: home-page
@@ -209,7 +211,7 @@ import kececinumbers as kn
 sequence = kn.get_with_params(
     kececi_type_choice=kn.TYPE_POSITIVE_REAL,
     iterations=30,
-    start_value_raw="0",
+    start_value_raw="0.0",
     add_value_raw="9.0",
     include_intermediate_steps=True
 )

kececinumbers-0.6.5.dist-info/RECORD

@@ -0,0 +1,10 @@
+docs/conf.py,sha256=jkpH_TchRJcC_EspKeY1E_rml2ODmIWhWoqvyCPu_ok,1116
+kececinumbers/__init__.py,sha256=s2_zWrTMEhl--tBf2xp981CSG6Perq4-lUs4zYlaAYY,4225
+kececinumbers/_version.py,sha256=pzo7Vd3ivKiGiCuF1pOxJt2NbhNXjLrSr8afRu5Wr7o,453
+kececinumbers/kececinumbers.py,sha256=n7o4NDZlzneIfCTa9j-aXQTX5f_8OpQfMlWprgmnPdk,59763
+kececinumbers-0.6.5.dist-info/licenses/LICENSE,sha256=NJZsJEbQuKzxn1mWPWCbRx8jRUqGS22thl8wwuRQJ9c,1071
+tests/test_sample.py,sha256=qMWUBGQtlF1gZHZ_e6Gye1vHtyNnUWH7iXK72a1y6VQ,9728
+kececinumbers-0.6.5.dist-info/METADATA,sha256=qc2oK-7YzshCBJ64nOL76LKtmWcIF7fK_LDRzTJsLdM,33720
+kececinumbers-0.6.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kececinumbers-0.6.5.dist-info/top_level.txt,sha256=ABQEKRH9iYb4sWnFdx7gIx7Hg899YktRkQpbRlSSqwU,25
+kececinumbers-0.6.5.dist-info/RECORD,,

kececinumbers-0.6.3.dist-info/RECORD

@@ -1,10 +0,0 @@
-docs/conf.py,sha256=jkpH_TchRJcC_EspKeY1E_rml2ODmIWhWoqvyCPu_ok,1116
-kececinumbers/__init__.py,sha256=BppueKxmKzWlPR0VUdq-0RiJyJOvEH3mbGqClov0mjw,3758
-kececinumbers/_version.py,sha256=mXoGDVZCtP2YgLFmkRSkSIWnem5vexg9IHGcMAOgmDM,453
-kececinumbers/kececinumbers.py,sha256=jf0z5I-mJ2speU6Dyqd9GTIS9Phk5GVItjY2Eaaphis,44569
-kececinumbers-0.6.3.dist-info/licenses/LICENSE,sha256=NJZsJEbQuKzxn1mWPWCbRx8jRUqGS22thl8wwuRQJ9c,1071
-tests/test_sample.py,sha256=qMWUBGQtlF1gZHZ_e6Gye1vHtyNnUWH7iXK72a1y6VQ,9728
-kececinumbers-0.6.3.dist-info/METADATA,sha256=CUsBABtdWjq40sYHfJSdbVZbzwQUvL-7Tx9SyzPFFJI,33659
-kececinumbers-0.6.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kececinumbers-0.6.3.dist-info/top_level.txt,sha256=ABQEKRH9iYb4sWnFdx7gIx7Hg899YktRkQpbRlSSqwU,25
-kececinumbers-0.6.3.dist-info/RECORD,,