
    ܯin                     4   d Z ddlZddlmZ ddlmZmZmZm	Z	m
Z
mZ ddlmZmZ ddlmZmZ ddlZddlmZ ddlZ	 	 	 	 	 	 	 d,ded	ee   d
edee   dededee   dede
fdZded
edede	eef   fdZdeded
edede	eef   f
dZdeded
ededef
dZdedee   fdZ G d de      Ze G d d             Z G d d      Z e G d d             Z! G d  d!      Z" G d" d#      Z# G d$ d%      Z$e G d& d'             Z% G d( d)      Z&d* Z'e(d+k(  r e'        yy)-a4  
CCT-ODE Next-Value Predictor
============================
Conditional Collapse Theory + ODE gradient descent for sequence prediction.
Handles: numerical sequences, letter series, time series.

Based on: Gap Probability Collapse, Taylor-Token Expansion, 
          Question TSP, xFFT Antiresonance Detection
    N)NDArray)UnionOptionalListTupleDictCallable)	dataclassfield)Enumauto)Countersignal_main
signal_reffsnpersegthreshold_dbmin_freqmax_freqmodereturnc                    t        j                  | t         j                        } t        |       }|t	        d|dz        }t        d|      }||dz  }|dk(  r|t        j                  | d      }t        j                  |t         j                        }t        |      |k7  rt        d      t        |||      \  }	}
t        || ||      \  }}t        j                  |      t        j                  |
      d	z   z  }t        || ||      }n|d
k(  rt         j                  j                  |d|z        }	t        j                  t         j                  j                  |             }|t        j
                  |      d	z   z  }t        j                  |	      }nt        d      |	|k\  |	|k  z  }|	|   }	||   }||   }dt        j                   |d	z         z  }t#        |      }g }g }g }|D ]  }t        d|dz
        }t	        t        |      dz
  |dz         }t        j$                  ||| ||dz   |dz    g      }t        |      dk(  r_t        j&                  |      }|||   z
  }|| k\  s|j)                  |	|          |j)                  |       |j)                  ||           t        j*                  |      t        j*                  |      t        j*                  |      |	|f|dS )a  
    Detect antiresonance frequencies using cross-spectral (xFFT) analysis.
    
    Parameters
    ----------
    signal_main : array_like
        The main signal (output/loss/gap).
    signal_ref : array_like, optional
        Reference signal (input/state). If None and mode='cross', uses signal_main shifted.
    fs : float
        Sampling frequency (Hz).
    nperseg : int
        Segment length for Welch's method.
    threshold_db : float
        Minimum dip depth (dB) to qualify as antiresonance.
    min_freq, max_freq : float
        Frequency range to search.
    mode : {'cross', 'single'}
        'cross' uses transfer function; 'single' uses power spectrum.
    
    Returns
    -------
    results : dict
        - 'frequencies': ndarray of antiresonance frequencies
        - 'depths_db': Depth of each dip (dB)
        - 'coherences': Coherence at those frequencies
        - 'transfer_magnitude': (freqs, |H(f)|)
    dtype         g       @cross   z1Main and reference signals must have same length.-q=single      ?dz!mode must be 'cross' or 'single'.   r      )frequencies	depths_db
coherencestransfer_magnituder   )npasarrayfloat64lenminmaxroll
ValueError
_welch_psd
_welch_csdabs
_coherencefftrfftfreqrfft	ones_likelog10
_argrelminconcatenatemeanappendarray)r   r   r   r   r   r   r   r   nfreqsPxx_PxyH_magCohspectrummaskH_dblocal_min_idxantires_freqsantires_depthsantires_coherenceidxleftrightneighbor_vals	local_avg	dip_depths                               >/home/per/Documents/gap_series_prediction/cct_ode_predictor.pydetect_antiresonances_xfftrV      s   L **[

;KKAc16"!WoG8wa0JZZ
"**=
z?aPQQ  
B8
sJRA3srvvc{U23["g>		SV,66"&&++k23BFF8,u45ll5!<== X%8"34D$KE$KE
d)C ''D t$MMN /1cAgCIM37+T#SU578K'LM}"GGM*	S	)	%  s,!!),$$SX./" xx.XXn-hh01$en     xc                    t        |       }|}t        j                  |      }||k  rt        j                  | d||z
  f      } |}|dz  }d||z
  ||z
  z  z   }t        j                  |dz  dz         }t        |      D ]O  }	|	||z
  z  }
| |
|
|z    |z  }t        j                  j                  |      }|t        j                  |      dz  z  }Q ||z  }t        j                  j                  |d|z        }||fS )z5Estimate power spectral density using Welch's method.r   r   r   r"   r#   )
r.   r+   hanningpadzerosranger7   r9   r5   r8   )rX   r   r   rA   n_fftwindow	n_overlapn_framespsdistartsegment
fft_resultrB   s                 rU   r3   r3      s   AAEZZ F 	7{FF1q'A+&'1IAKWy%899H
((5A:>
"C8_ 'Wy()E%'/*V3VV[[)
rvvj!Q&&	' 8OCFFOOESVO,E#:rW   yc                    t        |       }|}t        j                  |      }|dz  }d||z
  ||z
  z  z   }t        j                  |dz  dz   t              }	t        |      D ]y  }
|
||z
  z  }| |||z    |z  }||||z    |z  }t        j                  j                  |      }t        j                  j                  |      }|	|t        j                  |      z  z  }	{ |	|z  }	t        j                  j                  |d|z        }||	fS )z5Estimate cross-spectral density using Welch's method.r   r   r   r"   r#   )
r.   r+   rZ   r\   complexr]   r7   r9   conjr8   )rX   rg   r   r   rA   r^   r_   r`   ra   csdrc   rd   	x_segment	y_segmentXYrB   s                    rU   r4   r4      s   AAEZZ F1IAKWy%899H
((5A:>
1C8_ Wy()eEGO,v5	eEGO,v5	FFKK	"FFKK	"q2771:~ 8OCFFOOESVO,E#:rW   c                     t        | ||      \  }}t        |||      \  }}t        | |||      \  }}t        j                  |      dz  ||z  dz   z  }t        j                  |dd      S )z$Compute magnitude-squared coherence.r   r    r   r   )r3   r4   r+   r5   clip)	rX   rg   r   r   rD   rC   PyyrE   cohs	            rU   r6   r6      sm    2w'FAs2w'FAs1b'*FAs
&&+
cCi%/
0C7731rW   c                     g }t        dt        |       dz
        D ]1  }| |   | |dz
     k  s| |   | |dz      k  s!|j                  |       3 |S )z Find indices of relative minima.r   )r]   r.   r?   )rX   minimarc   s      rU   r<   r<      s]    F1c!fqj! Q4!AaC&=QqTAacF]MM! MrW   c                       e Zd ZdZ e       Z e       Z e       Z e       Z e       Z	 e       Z
 e       Z e       Zy)PatternTypez+Types of patterns the predictor can detect.N)__name__
__module____qualname____doc__r   
ARITHMETIC	GEOMETRICPERIODIC	FIBONACCI
POLYNOMIALMARKOVMIXEDUNKNOWN rW   rU   rw   rw      s=    5JIvHIJVFFEfGrW   rw   c                   D    e Zd ZU dZeed<   eed<   eed<   eed<   eed<   y)PatternInfoz%Information about a detected pattern.pattern_type
parameters
confidencescoredescriptionN)	rx   ry   rz   r{   rw   __annotations__r   floatstrr   rW   rU   r   r      s"    /LrW   r   c                       e Zd ZdZddefdZdeeef   dee	   fdZ
dedee	   fdZdedee	   fd	Zdedee	   fd
Zdedee	   fdZdedee	   fdZy)PatternDetectorz#Detects pattern types in sequences.	tolerancec                     || _         y N)r   )selfr   s     rU   __init__zPatternDetector.__init__   s	    "rW   sequencer   c                    t        j                  |t         j                        }g }| j                  |      }||j	                  |       t        j
                  |dkD        r$| j                  |      }||j	                  |       | j                  |      }||j	                  |       | j                  |      }||j	                  |       | j                  |      }||j	                  |       |j                  d d       |S )z/Detect all applicable patterns in the sequence.r   r   c                     | j                   S r   )r   ps    rU   <lambda>z(PatternDetector.detect.<locals>.<lambda>  s
    AGG rW   Tkeyreverse)r+   r,   r-   _detect_arithmeticr?   all_detect_geometric_detect_periodic_detect_fibonacci_detect_polynomialsort)	r   r   seqpatternsarithgeomperiodicfibpolys	            rU   detectzPatternDetector.detect   s    jj4 '',OOE" 66#'?))#.D% ((-OOH% $$S)?OOC  &&s+OOD! 	+T:rW   r   c           
         t        |      dk  ryt        j                  |      }t        |      dk  r*t        t        j
                  d|d   iddd|d   d      S t        j                  |      }|| j                  k  rSt        t        j
                  dt        j                  |      id|z
  dd|z
  z  d	t        j                  |      d      S y)
z5Detect arithmetic sequence: x_{n+1} - x_n = constant.r   N
differencer   r"   zx_{n+1} - x_n = .4gr   r   r   r   r   zArithmetic: d = )	r.   r+   diffr   rw   r|   varr   r>   )r   r   diffsvariances       rU   r   z"PatternDetector._detect_arithmetic  s    s8a<u:>(33(%(30q#?  66%=dnn$(33("''%.9>S8^,.rwwu~c.BC  rW   c           
      V   t        |      dk  st        j                  |dk(        ry|dd |dd z  }t        j                  |      }|| j                  k  rSt        t        j                  dt        j                  |      id|z
  dd|z
  z  dt        j                  |      d	
      S y)z4Detect geometric sequence: x_{n+1} / x_n = constant.r   r   Nr   ratior"   zGeometric: r = r   r   )	r.   r+   anyr   r   r   rw   r}   r>   )r   r   ratiosr   s       rU   r   z!PatternDetector._detect_geometric,  s    s8a<266#(+QR3s8#66&>dnn$(22#RWWV_5>S8^,-bggfoc-BC  rW   c                 j   t        |      }t        d|dz  dz         D ]  }||z  dk7  r||z  }|d| }d}t        d|      D ]4  }t        j                  |||z  |dz   |z   || j                        r2d} n |s^t        t        j                  ||j                         dd	d	d
| d|       c S  y)z(Detect periodic sequence: x_{n+k} = x_n.r   r   r   NT)atolF)periodcycler"   zPeriodic with period z: r   )	r.   r]   r+   allcloser   r   rw   r~   tolist)r   r   rA   r   repeatsbaseis_periodicrc   s           rU   r   z PatternDetector._detect_periodic>  s    H AqAvz* 	F6zQ 6kGw<DK1g& {{3qx1f#=t$..Y"'K
 "!,!5!5*04;;=I""7xr$ H 	, rW   c                    t        |      dk  ryt        j                  |dd |dd g      }|dd }	 t        j                  j	                  ||d      \  }}}}|\  }}||z  }	t        j
                  |	|z
  dz        }
|
| j                  k  r3t        t        j                  ||dd	|
z
  d
d	|
z
  z  d|dd|dd      S 	 y#  Y yxY w)z>Detect Fibonacci-like recurrence: x_n = a*x_{n-1} + b*x_{n-2}.   Nr   r   r   )rcond)abr"   ?zFibonacci-like: x_n = r   z*x_{n-1} + z*x_{n-2}r   )
r.   r+   column_stacklinalglstsqr>   r   r   rw   r   )r   r   rn   rg   coeffs	residualsrD   r   r   	predictederrors              rU   r   z!PatternDetector._detect_fibonacci[  s    s8a< OOS2YAb	23G	&(iiooa$o&G#FIq!DAq F
IGGY]q01Et~~%"!,!6!6%&Q/"U{u-"83}QsGS] ^  & 	s   BC Cc                    t        |      dk  ry|j                         }d}t        |      dkD  ryt        j                  |dd       | j                  kD  rTt        j
                  |      }|dz  }|dkD  ryt        |      dkD  r&t        j                  |dd       | j                  kD  rT|dk\  r(|dk  r#t        t        j                  d|iddd	| 
      S y)z4Detect polynomial sequence using finite differences.r   Nr   r   r&   degree皙?ffffff?zPolynomial of degree r   )	r.   copyr+   r   r   r   r   rw   r   )r   r   r   r   s       rU   r   z"PatternDetector._detect_polynomialx  s    s8a<
 %j1nab	!2T^^!CGGENEaKFz	 %j1nab	!2T^^!C Q;6Q;(33$f-3F8<  rW   N)ư>)rx   ry   rz   r{   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rW   rU   r   r      s    -#% #!uT7]3 ![8I !Fg (;2G 4W +1F $G 0E :W +1F :g (;2G rW   r   c                   \    e Zd ZU dZeed<   eed<   eed<   eed<    ee      Z	e
e   ed<   y)	Questionz1A question that can collapse pattern uncertainty.idtextcollapse_potentialcost)default_factory
applies_toN)rx   ry   rz   r{   r   r   r   r   listr   r   rw   r   rW   rU   r   r     s.    ;G
I
K$)$$?J[!?rW   r   c                   h    e Zd ZdZd Zdee   fdZdee   de	de
ee   e	f   fdZdee   defd	Zy
)QuestionTSPz6Finds optimal question path to collapse pattern space.c                 .    | j                         | _        y r   )_build_question_lattice	questionsr   s    rU   r   zQuestionTSP.__init__  s    557rW   r   c                    t        ddddt        j                  g      t        ddddt        j                  g      t        d	d
ddt        j                  g      t        ddddt        j
                  g      t        ddddt        j                  g      t        ddddt        j                  g      t        ddddt        j                  t        j
                  g      t        ddddt        j                  g      gS )z(Build the lattice of possible questions.Q1zIs this arithmetic?r   皙?Q2zIs this geometric?g333333?g333333?Q3zIs this periodic?r   g?Q4zIs this Fibonacci-like?g      ?g      ?Q5zIs this polynomial?r   333333?Q6zAre gaps constant?Q7zDo gaps follow a pattern?Q8zIs there a hidden period?)r   rw   r|   r}   r~   r   r   r   s    rU   r   z#QuestionTSP._build_question_lattice  s     T0#s ++,.T/t **+-T.S ))*,T4dD **+-T0#s ++,.T/s ++,.T6S ));+@+@ACT6d ))*,
 	
rW   candidate_patternscurrent_entropyc                 t   |sg dfS |D ch c]  }|j                    }}| j                  D cg c]  t        fd|D              r }}|j                  d d       g }|}d}	|D ]>  |dk  r ||	fS |j	                         |	j
                  z  }	|dj                  z
  z  }@ ||	fS c c}w c c}w )z
        Find the optimal sequence of questions to collapse uncertainty.
        
        Returns
        -------
        path: List of questions to ask
        total_cost: Total W_i for the path
                c              3   :   K   | ]  }|j                   v   y wr   )r   ).0ptqs     rU   	<genexpr>z0QuestionTSP.find_optimal_path.<locals>.<genexpr>  s     HBR1<</Hs   c                 :    | j                   | j                  dz   z  S )Ng&.>)r   r   )r   s    rU   r   z/QuestionTSP.find_optimal_path.<locals>.<lambda>  s    q';';qvv}'M rW   Tr   r   r"   )r   r   r   r   r?   r   r   )
r   r   r   r   pattern_typesr   relevant_qspathremaining_entropy
total_costs
        `    rU   find_optimal_pathzQuestionTSP.find_optimal_path  s     "s7N 2DDADD"&.. JQH-HH  J J 	M $ 	 	& +
 	>A 3& Z	 KKN!&& J#(<(<"<=	> Z+ EJs
   B0B5r   c                 b    |st        t        j                  i ddd      S t        |d       }|S )z6Select the best pattern based on confidence and score.r   zNo pattern detectedr   c                 4    | j                   | j                  z  S r   )r   r   r   s    rU   r   z6QuestionTSP.collapse_to_best_pattern.<locals>.<lambda>  s    177Q\\+A rW   )r   )r   rw   r   r0   )r   r   bests      rU   collapse_to_best_patternz$QuestionTSP.collapse_to_best_pattern  s;    (001  8!ABrW   N)rx   ry   rz   r{   r   r   r   r   r   r   r   r  r  r   rW   rU   r   r     sb    @8
h 
*# D4E # +0# 5:4>5;P5Q# Jk1B { rW   r   c                   `    e Zd ZdZ	 	 	 ddededefdZ	 	 ddedee   d	ee   d
e	eef   fdZ
y)GapODEOptimizerz6Gradient descent on the gap probability loss function.lrmax_itertolc                 .    || _         || _        || _        y r   )r  r	  r
  )r   r  r	  r
  s       rU   r   zGapODEOptimizer.__init__  s      rW   Nprior_probabilitygap_historyantiresonance_freqsr   c                    |dt        |      dkD  rVt        j                  |dd       }|t        j                  j	                         t        j
                  |dd       z  dz  z  }n!t        j                  j	                         dz  }t        |d      }t        | j                        D ][  }t        j                  |dz  d|z  z         }t        j                  t        j                  |z        dz  }t        j                  t        j                  dt        j                  z  |z        z  ||d	z   z  z  }	|}t        |      dkD  ro|r$t        j                  |      t        |      d
z   z  nt        j                  |      }
|D ]/  }t        j                  |
|z
  dz   dz        }|	d|z  |
|z
  z  z  }	1 |dk(  rd}dz  | j                  |	z  z
  }||z   }|dk  rt        j                  |      }|| j                  k  sY ||fS  |fS )a[  
        Find optimal gap using ODE gradient descent.
        
        Parameters
        ----------
        prior_probability: P_prior from pattern analysis
        gap_history: Historical gaps for initialization
        antiresonance_freqs: Frequencies to avoid
        
        Returns
        -------
        (optimal_gap, final_loss)
        Nr   ir         ?r   r   g      @r    r   g{Gz?r   r   )r.   r+   r>   randomrandnstdr0   r]   r	  sqrtsinpir5   expr  r
  )r   r  r  r  gapP_prior	iterationslossgradfreq_gf_arpenaltyvelocitys                 rU   optimizezGapODEOptimizer.optimize  s   $ "s;'7!';''+cd+,C299??$rvvk#$.?'@@3FFC))//#c)C'. t}}- 	Iq3=01A66"%%!)$)D
 55266!bee)a-00C1u94EFD #.37J3Ka3OALK(81(<=RTRXRXY\R]/ <D ff!';%<%IJGC'MVd];;D<
 A~X~$6H.C QwffSk dhhDyA	@ DyrW   ){Gz?  g:0yE>)NN)rx   ry   rz   r{   r   intr   r   r   r   r"  r   rW   rU   r  r    sv    @ "!%"  37:>;$);&w/; '/w&7; DIPUCV;rW   r  c                      e Zd ZdZ ed      D  ci c]  }t        t        d      |z         | c}}}} Zej                   ed      D  ci c]  }t        t        d      |z         | c}}}}        e	de
e   defd       Ze	dd	ed
ee
e      de
e   fd       Ze	dedefd       Ze	dedeee   ef   fd       Ze	de
e   deeef   fd       Zyc c}}}} w c c}}}} w )LetterSeriesProcessorz7Specialized processor for letter/categorical sequences.   r   Ar   r   c                 *   g }|D ]s  }|| j                   v r|j                  | j                   |          0|j                  t        | j                         t        |D cg c]
  }|dk\  s	| c}      z          u t        j                  |      S c c}w )z+Encode letter sequence to numeric ordinals.r(  )ALPHABETr?   r.   r+   r@   )clsr   encodedcharcs        rU   encodezLetterSeriesProcessor.encodeH  s      	YDs||#s||D12 s3<<0377VaaSUg7V3WWX	Y xx   8Ws   
B(BNordinalsoriginal_seqc           	         g }|D ]  }|dk  r0|j                  t        t        d      t        |      z                8|rt        |      dz
  }|t	        |xs g D cg c]  }|| j
                  vs| c}      k  r7|xs g D cg c]  }|| j
                  vs| }}|j                  ||          |j                  d       |j                  d        |S c c}w c c}w )z Decode ordinals back to letters.r(  r   ?)r?   chrordr%  r.   r+  )r,  r1  r2  resultord_valrO   r/  unknown_charss           rU   decodezLetterSeriesProcessor.decodeT  s      	#G|c#c(S\"9:;'lR',*<"WA#,,AVaWXX1=1C$^1QTQ]Q]H]Q$^M$^MM-"45MM#&c"	#  X$^s   C/CCCr-  c                 ,    t        j                  |      S )z1Compute ordinal gaps between consecutive letters.)r+   r   )r,  r-  s     rU   compute_gapsz"LetterSeriesProcessor.compute_gapsg  s     wwwrW   c                 v   t        |      }|dk  ryt        j                  |      }t        j                  |      }|dk  ryt        j                  ||z
  ||z
  d      }||dz
  d |t        j
                  |d	d
      z  z  }d}d}t        d|dz  dz         D ]  }||   |kD  s||   dkD  s||   }|} ||fS )z7Detect period in letter sequence using autocorrelation.r   )Nr   g|=)r   r"   full)r   r   Nr   r   r   r   r  )r.   r+   r>   r   	correlatearanger]   )	r,  r-  rA   r>   r   autocorrbest_period	best_corrlags	            rU   detect_periodicityz(LetterSeriesProcessor.detect_periodicityl  s     Lq5 wwwffWo;<<$$VLAaCD>S299Q2+>%>? 	AFQJ' 	"C}y(Xc]S-@$SM	!	"
 I%%rW   c                    | j                  |      }| j                  |      \  }}||dkD  r||t        |      |z  z
      }nO| j                  |      }t        |      dkD  r+t	        |      }|j                  d      d   d   }|d   |z   }n|d   }| j                  t        j                  |g      |      d   }	|	|||j                         |rddfS ddfS )z(Predict the next letter in the sequence.r   r   r   r   r   gap_average)r   r   r-  method)
r0  rE  r.   r<  r   most_commonr:  r+   r@   r   )
r,  r   r-  r   r   next_ordinalgapsgap_countermost_common_gapr7  s
             rU   predict_nextz"LetterSeriesProcessor.predict_next  s    **X& !33G<
*s"2"Vc'lV.C%C#DEL ##G,D4y1}%dm"-"9"9!"<Q"?"B&r{_<&r{ BHHl^4h?B$~~'$*j	
 
 	
 1>	
 
 	
rW   r   )rx   ry   rz   r{   r]   r5  r6  r+  updateclassmethodr   r   r   r0  r   r:  r<  r   r%  r   rE  r   rN  )r   rc   r5  r6  s   0000rU   r'  r'  A  sG   A /4Bi88CHqL!1$8HOO59==aSSA&)=>	!d3i 	!G 	! 	! g Xd3i5H TXY\T]  $  7  w     & &U8C=%;O5P & &4 
DI 
%T	2B 
 
G 9=s   C
C#r'  c                   r    e Zd ZU dZeeef   ed<   eed<   eed<   eed<   eed<   e	ed<   e
e   ed<   eed	<   y
)PredictionResultzResult of a prediction.
next_valuer   patternrH  entropy_reductionantiresonancesquestion_pathenergy_costN)rx   ry   rz   r{   r   r   r   r   r   r   r   r   rW   rU   rR  rR    sA    !eSj!!K9rW   rR  c                      e Zd ZdZ	 	 	 	 ddedededefdZ	 ddeee	ee
   f   ded	eeeee
f   f   fd
Zdee
   ded	eee
f   fdZdeee	f   ded	eeef   fdZde	d	efdZde	ded	efdZdeee	ee
   f   ded	efdZd	efdZy)CCTODEPredictora6  
    CCT-ODE Next-Value Predictor
    ----------------------------
    Predicts next values in sequences using:
    - Pattern detection (arithmetic, geometric, periodic, etc.)
    - xFFT antiresonance detection
    - Question TSP for optimal pattern selection
    - ODE gradient descent on gap probability
    	thresholdr  r	  antiresonance_threshold_dbc                     || _         || _        || _        t               | _        t               | _        t        ||      | _        || _	        g | _
        g | _        g | _        g | _        t               | _        y )N)r  r	  )r[  r  r	  r   pattern_detectorr   question_tspr  gap_optimizerr\  sequence_historyr  pattern_historyentropy_historyr'  letter_processor)r   r[  r  r	  r\  s        rU   r   zCCTODEPredictor.__init__  sr    
 #  / 1'M,XF*D' .0(*24,. 5 7rW   r   return_full_resultr   c                 r    t        d |D              }|r| j                  ||      S | j                  ||      S )aH  
        Fit to sequence and predict next value.
        
        Parameters
        ----------
        sequence: Input sequence (numeric, or letter strings)
        return_full_result: If True, return PredictionResult; else just the value
        
        Returns
        -------
        PredictionResult or next value
        c              3   \   K   | ]$  }t        |t              xr t        |      d k(   & yw)r   N)
isinstancer   r.   )r   rX   s     rU   r   z.CCTODEPredictor.fit_predict.<locals>.<genexpr>  s/      !4%& ",As!3!CA!!C !4s   *,)r   _predict_letter_predict_numeric)r   r   re  is_letter_sequences       rU   fit_predictzCCTODEPredictor.fit_predict  sI      ! !4*2!4 4 ''2DEE((3EFFrW   c                 8   | j                   j                  |      \  }}|ryt        ||d   t        |d   rt        j
                  nt        j                  d|d   i|d   |d   |d   rd|d    nd      |d   |d   t        j                  g       dgd	      S |S )
z0Predict next letter using specialized processor.r   r   zPeriod Unknownr   rH  zPeriodicity Detectionr"   rS  r   rT  rH  rU  rV  rW  rX  )	r'  rN  rR  r   rw   r~   r   r+   r@   )r   r   re  next_letterdetailss        rU   ri  zCCTODEPredictor._predict_letter  s      $99FFxPW#&"<0#9@9J!5!5P[PcPc ('(*;<&|4!,/AHAR''(*;)< =Xa x("),"7!xx|67   rW   c                    t        j                  |t         j                        }| j                  j	                  |j                                t        |      dk\  r>t        j                  |      }| j                  j	                  |j                                | j                  j                  |      }t        |      dk\  r4t        |t        j                  |d      d| j                  d      }|d   }nt        j                  g       }| j                  |      }| j                   j#                  ||      \  }	}
| j                   j%                  |      }| j&                  j)                  |       |j*                  d	kD  r|j*                  nd
}| j                  r"t        j                  | j                  dd       nd}| j,                  j/                  |||      \  }}|j0                  t2        j4                  k(  r&|d   |j6                  j9                  d|      z   }d}no|j0                  t2        j:                  k(  r(|j6                  j9                  dd      }|d   |z  }d}n*|j0                  t2        j<                  k(  r7|j6                  d   }|j6                  d   }t        |      |z
  |z  }||   }d}n|j0                  t2        j>                  k(  rc|j6                  j9                  dd      }|j6                  j9                  dd      }t        |      dk\  r||d   z  ||d   z  z   }n|d   |z   }d}nV|j0                  t2        j@                  k(  r/| jC                  ||j6                  j9                  dd            }d}n
|d   |z   }d}|| j                  t        j(                  ||            z
  }tE        dtG        dd|z
              }|r+tI        |||||||	D cg c]  }|jJ                   c}|
      S |S c c}w )z8Predict next numeric value using full CCT-ODE machinery.r   r      r   r"   r   )r   r   r   r   r   r'   r   r  iN)r  r  r  r   r   
arithmeticr   	geometricr   r   r   r   r   r   	fibonaccir   
polynomialode_gapr   ro  )&r+   r,   r-   ra  extendr   r.   r   r  r^  r   rV   r1   r\  r@   _estimate_entropyr_  r  r  rb  r?   r   r`  r"  r   rw   r|   r   getr}   r~   r   r   _extrapolate_polynomialr/   r0   rR  r   )r   r   re  r   rK  r   	ar_resultr  r   rW  rX  best_pattern
prior_probgap_history_arroptimal_gap
final_lossrS  rH  r   r   r   rO   r   r   rU  r   r   s                              rU   rj  z CCTODEPredictor._predict_numeric  s    jj4 	$$SZZ\2 s8q=773<D##DKKM2 ((//4 s8r>2773?!<<I #,M":"$((2, 005%)%6%6%H%Ho&
"{
 ((AA(K##L1 1=0G0G!0K\,,QT
>B>N>N"((4#3#3CD#9:TX"&"4"4"="=(' 3 #> #
Z $$(>(>>R<#:#:#>#>|[#YYJ!F&&+*?*?? ++//=ER5J F&&+*>*>>!,,X6F ++G4Es8f$.CsJF&&+*?*??''++C5A''++C5A3x1}R[1s2w;6
 W{2
 F&&+*@*@@55c7C7N7N7R7RS[]^7_aJ!F R;.JF ,d.D.DRYYsT^E_.``c#s->'>?@
#%%$"32/<=!qvv='	 	  >s   %Pr   c                    t        |      dk  ryt        j                  |      }t        |      dk  ryt        j                  |t        j                  |j                         |j                         d            }t        j                  |d      }|t        |      z  }||dkD     }t        j                  |t        j                  |dz         z         }t        d|t        j                  d      z        S )z7Estimate entropy of the sequence (uncertainty measure).r   r"   
   )	minlengthr   r    )
r.   r+   r   digitizelinspacer/   r0   bincountsumlog2)r   r   rK  gap_binscountsprobsentropys          rU   rz  z!CCTODEPredictor._estimate_entropyn  s    s8a<wws|t9q= ;;tR[[TXXZ%LMX4T"eai 66%"''%%-"88993"''"+-..rW   r   c           
      B   t        j                  t        |            }	 t        j                  ||t	        |t        |      dz
              }t        j
                  |t        |            S #  |d   t        j                  t        j                  |            z   cY S xY w)z,Extrapolate next value using polynomial fit.r   r   )r+   r@  r.   polyfitr/   polyvalr>   r   )r   r   r   rX   r   s        rU   r|  z'CCTODEPredictor._extrapolate_polynomial  sv    IIc#h	3ZZ3FCHqL(ABF::fc#h//	3r7RWWRWWS\222s   AA, ,0BrA   c                     t        |      }g }t        |      D ]5  }| j                  |      }|j                  |       |j                  |       7 |S )z'Predict next n values autoregressively.)r   r]   rl  r?   )r   r   rA   r   predictionsrD   next_vals          rU   predict_n_stepszCCTODEPredictor.predict_n_steps  sW     8nq 	!A'',Hx(JJx 	!
 rW   c           	         t        | j                        t        | j                        t        | j                        | j                  | j                  r| j                  d   ndt        d | j                  D              dS )z%Get predictor statistics and history.r   r"   c              3   P   K   | ]  }t        |j                        d kD  rd   yw)r   r   N)r.   r   )r   r   s     rU   r   z1CCTODEPredictor.get_statistics.<locals>.<genexpr>  s*      'AQ),Q]]);a)? () 'As   $&)sequence_lengthgap_history_lengthpatterns_detectedentropy_trajectoryr   antiresonance_count)r.   ra  r  rb  rc  r  r   s    rU   get_statisticszCCTODEPredictor.get_statistics  sw      #4#8#89"%d&6&6"7!$T%9%9!:"&"6"6;?;O;Ot33B7UX#& 'A$2F2F 'A $A
 	
rW   N)r#  r#  r$        )F)rx   ry   rz   r{   r   r%  r   r   r   r   r   boolrR  rl  ri  rj  rz  r|  r  r   r  r   rW   rU   rZ  rZ    sQ    %)!!%59	8!88 8 .3	82 /4G"4$s)#;<G'+G8=>NPUV[]`V`Pa>a8bG0S	 ,05:;KS;P5Q0`tW})= `-1`6;<Le<S6T`D/W / /$37 3C 3E 3dGT#Y.F(G #'

 

rW   rZ  c                  $   t        d       t        d       t        d       t        d      } t        d       g d}| j                  |d      }t        d	|        t        d
|j                   d       t        d|j                  j
                          t        d|j                          t        d|j                  d       t        d|j                  d       t        d       g d}| j                  |d      }t        d	|        t        d
|j                   d       t        d|j                  j
                          t        d|j                          t        d       g d}| j                  |d      }t        d	|        t        d
|j                   d       t        d|j                  j
                          t        d       g d}| j                  |d      }t        d	|        t        d
|j                   d       t        d|j                  j
                          t        d       g d}| j                  |d      }t        d	|        t        d
|j                   d       t        d|j                  j
                          t        d       g d}| j                  |d      }t        d	|        t        d
|j                          t        d|j                          t        d        g d!}| j                  |d      }t        d	|        t        d
|j                  d       t        d|j                  j
                          t        d|j                  d       t        d"|j                          t        d#       g d$}	| j                  |	d%      }
t        d&|	        t        d'|
        t        d(       t        d)       d*d+l} |j                  d*d,d-      } |j                  d.|j                  z  d/z  |z        d0 |j                  d.|j                  z  d1z  |z        z  z   }t        | |j                   |d2      d3d4d56      }t        d7|d8           t        d9|d:           t        d;       t               }|j"                  j%                   |j&                  g d<            }|j(                  j+                  |d=>      \  }}t        d?|D cg c]  }|j,                  j.                   c}        t        d@|D cg c]  }|j0                   c}        t        dA|d       t        dB       t        dC       t        d       y+c c}w c c}w )Dz8Demonstrate CCT-ODE Predictor on various sequence types.zF======================================================================z!CCT-ODE Next-Value Predictor Demor#  )r[  z
[1] Arithmetic Sequence)                  T)re  z    Sequence: z    Prediction: z (expected: 27)z    Pattern: z    Method: z    Confidence: z.2%z    Energy Cost: z.4fz
[2] Geometric Sequence)r         6      z (expected: 486)z
[3] Periodic Sequence)	r   r  r&   r  r   r  r&   r  r   z (expected: 3)z
[4] Fibonacci-like Sequence)r   r   r   r  r&   r         z (expected: 34)z
[5] Letter Series)r)  Br)  r  r)  r  z (expected: A)z
[6] Complex Letter Series)	r)  r  Cr)  r  Dr)  r  Ez"
[7] Noisy Sequence (high entropy))g?gffffff@gffffff?g@gffffff@gffffff@g@z    Antiresonances: z&
[8] Multi-step Prediction (Fibonacci))r   r   r   r  r&   r&   z    Given: z    Next 5: z!    Expected: [8, 13, 21, 34, 55]z/
[9] Antiresonance Detection in Periodic Signalr   Nr     r   r  r   r   r   g      4@r  r   )r   r   r   z    Detected antiresonances: r'   z    Depths (dB): r(   z 
[10] Question TSP Path Analysis)r   r  r&   r  	   r   )r   z    Patterns found: z    Optimal question path: z    Total energy cost: zG
======================================================================zDemo Complete)printrZ  rl  rS  rT  r   rH  r   rX  rV  r  numpyr  r  r  rV   r1   r^  r   r@   r_  r  r   namer   )	predictor	arith_seqpredgeom_seqperiodic_seqfib_seq
letter_seqcomplex_letter_seq	noisy_seqfib_fullr  r+   tperiodic_signalr}  
predictor2r   r   r   r   r   s                        rU   demor    s7    
(O	
-.	(O$/I 

%&&I  t DD	N9+
&'	T__-_
=>	M$,,223
45	L
&'	T__S1
23	d..s3
45 

$%"H  d CD	N8*
%&	T__--=
>?	M$,,223
45	L
&' 

#$.L  $ GD	N<.
)*	T__-^
<=	M$,,223
45 

)*(G  T BD	N7)
$%	T__-_
=>	M$,,223
45 

 /J   ED	N:,
'(	T__-^
<=	M$,,223
45 

'(F  !3 MD	N-.
/0	T__-
./	L
&' 

/03I  t DD	N9+
&'	T__S1
23	M$,,223
45	T__S1
23	 !4!4 5
67 

34H++Ha8K	Kz
"#	L
&'	-/ 

<=Ar3AbffQY_q01C&"&&RUUSSTAT:U4UUO*?GBGGOUV<W.2GUI	))M*B)C
DE	i45
67 

-. "J**11("((?2KLH((::8UX:YJD$	 x!H!!.."5"5!H I
JK	'(>A(>'?
@A	#D:
./	/	/	(O "I(>s   V
;V
__main__)Nr"   Nr  r   Nr   ))r{   r  r+   numpy.typingr   typingr   r   r   r   r   r	   dataclassesr
   r   enumr   r   mathcollectionsr   warningsr   r%  r   rV   r3   r4   r6   r<   rw   r   r   r   r   r  r'  rR  rZ  r  rx   r   rW   rU   <module>r     s      ? ? (     %)! $ll!l 	l c]	l
 l l uol l 
l^' u s uWg=M7N 8' g 5 3 5RYIYCZ 2' g 5 3 7 ' d3i 	$ 	   f fZ @ @ @M MhF FZe
 e
X 	 	 	g
 g
\dN zF rW   