
    H8iv                        d Z ddlZddlmZ ddlmZ ddlmc mZ ddl	Z	ddl
mZ ddlZddlZddlZddlmZmZmZmZ ddlmZmZ ddlmZ e G d d             Z G d d	ej6                        Z G d
 dej6                        Z G d dej6                        Z G d d      Ze G d d             Z dddddejB                  jE                         rdndfde#de#de$de$de$de%de fd Z&dddejB                  jE                         rdndfde#de#de$de%fd!Z'd" Z(d# Z)e*d$k(  r;ddl+Z+ e,e+jZ                        d%kD  re+jZ                  d%   d&k(  r e)        y e(        yy)'u  
Circle Hypothesis Universal (CHU) - PyTorch Implementation
==========================================================
Applies Circle Hypothesis theory to neural network training on CIFAR-10.

Core Concepts:
- State as Phase: θ(t) = θ₀ + ωt
- Deviation Detection: ε = ||x - circle|| 
- O(1) Updates: Rotate instead of compute
- Collapse: When deviation < δ, theory is solved

Author: Circle Hypothesis Framework
    N)TupleListDictOptional)	dataclassfield)dequec                       e Zd ZU dZej
                  ed<   ej
                  ed<   eed<   ej
                  ed<   ej
                  ed<   eddej
                  dedd fd	       Z	y
)CircleStateu@  Represents a computational circle: C = (c, r, ω, θ, ε)
    
    - c: Center (stationary component / bias)
    - r: Radius (amplitude / weight magnitude)
    - ω: Angular frequency (learning rate / update speed)
    - θ: Phase (current state / parameter value)
    - ε: Deviation (error / distance from circle)
    centerradiusomegaphase	deviationparamreturnc           	          t        | j                         j                         dz  t        j                  d      || j                         j                         t        j
                  |             S )z.Create a circle state from a parameter tensor.?皙?)r   r   r   r   r   )r   clonedetachtorchtensor
zeros_like)r   r   s     ./home/per/Documents/circle computation/ex01.pyfrom_parameterszCircleState.from_parameters1   sW     ;;='')C/<<$++-&&(&&u-
 	
    N{Gz?)
__name__
__module____qualname____doc__r   Tensor__annotations__floatstaticmethodr    r   r   r   r   !   sa     LLLLL<<||
u|| 
E 
] 
 
r   r   c                        e Zd ZdZ	 	 ddededededef
 fdZdej                  d	ej                  fd
Z
defdZ xZS )CircleLayeru   A neural network layer where weights are represented as circles.
    
    Instead of: y = Wx + b
    We compute:  y = Rotate(W, θ) @ x + c
    
    The "computation" becomes a rotation on the circle.
    in_featuresout_featuresbiasr   deviation_thresholdc                    t         |           || _        || _        || _        || _        t        j                  t        j                  ||      dz        | _
        |r.t        j                  t        j                  |            | _        n| j                  dd        t        j                  | j                  j                         j                               | _        t        j                  t        j"                  | j                        dz        | _        | j'                  dt        j(                  | j                               t+        d      | _        d| _        d| _        d| _        y )	Nr   r-   circle_phased   )maxlenFr         ?)super__init__r+   r,   r   deltann	Parameterr   randnweightzerosr-   register_parameterr   r   circle_center	ones_likecircle_radiusregister_bufferr   r	   deviation_historyis_on_circlecollapse_countcompute_cost)selfr+   r,   r-   r   r.   	__class__s         r   r5   zCircleLayer.__init__F   s   &(
(
 ll5;;|[#ID#PQU[[%>?DI##FD1  \\$++*<*<*>*D*D*FG\\%//$++*F*MN^U-=-=dkk-JK "'c!2!r   xr   c           	         | j                   | j                  t        j                  | j                  | j                  j                  d      z        z  z   }| j                  |z
  j                         | _        | j                  j                         j                         }| j                  j                  |       || j                  k  r$d| _        | xj                  dz  c_        d| _        nd| _        d|dz  z   | _        | j                  rG| j                   | j                  t        j"                  | j                  | j$                  z         z  z   }n| j                  }|j'                         dk(  rIt)        j*                  ||j-                  | j.                  | j0                  dd      | j2                        }|S t)        j4                  ||| j2                        }|S )	z&Forward pass using circle computation.r   )minT   r3   F
      )r=   r?   r   tanhr0   clampr:   absr   meanitemrA   appendr6   rB   rC   rD   sinr   dimFconv2dviewr,   r+   r-   linear)rE   rG   expectedmean_devactive_weightoutputs         r   forwardzCircleLayer.forward`   s   
 %%(:(:UZZHYHY\`\n\n\t\ty}\t\~H~=(++0557 >>&&(--/%%h/ djj  $D1$ #D %D #hm 3D
  !..1C1Ceii!!DJJ.G 2 M
 !KKM557a<XXa!3!3D4E4EtGWGWYZ\]!^`d`i`ijF  XXa		:Fr   loss_deviationc                 d   t        j                         5  | j                  s| j                  xj                  | j
                  | j                  j                  | j                  j                  z
  z  |z  z  c_        | xj                  | j
                  t        j                  | j                  j                  | j                  j                  z
        z  z  c_        t        j                  | j                  d| j
                  z  z   dd      | j                  _        ddd       y# 1 sw Y   yxY w)zUpdate circle parameters based on loss deviation.
        
        The key insight: We don't compute gradients. We rotate toward the loss.
        MbP?r3   )rI   maxN)r   no_gradrB   r=   datar   r:   r0   signrN   r?   )rE   r^   s     r   update_circlezCircleLayer.update_circle   s    
 ]]_ 	 $$""''4::9I9IDL^L^LcLc9c+dgu+uu' !!TZZ%**T[[=M=MPTPbPbPgPg=g2h%hh! +0++&&);;+""'	 	 	s   DD&&D/)Tr   r   )r    r!   r"   r#   intboolr&   r5   r   r$   r]   re   __classcell__rF   s   @r   r*   r*   =   sd     JNCF C  s  $   ;@ 4( (%,, (TE r   r*   c                   f     e Zd ZdZddedef fdZdej                  dej                  fdZ	 xZ
S )	CircleBatchNorm2dz>BatchNorm where running statistics are represented as circles.num_featuresr   c                    t         |           || _        || _        d| _        t        j                  t        j                  |            | _	        t        j                  t        j                  |            | _        | j                  dt        j                  |             | j                  dt        j                  |             | j                  dt        j                  |             | j                  dt        j                  |             | j                  dt        j                  |             | j                  dt        j                  |             d| _        | j                  d	t        j                  d
             y )Nr   running_meanrunning_varrunning_mean_circlerunning_std_circlerunning_phase_meanrunning_phase_std皙?num_batches_trackedr   )r4   r5   rl   r   momentumr7   r8   r   onesr:   r;   r-   r@   r.   r   )rE   rl   r   rF   s      r   r5   zCircleBatchNorm2d.__init__   s   (
ll5::l#;<LL\!:;	 	^U[[-FG]EJJ|,DE2EKK4MN15::l3KL15;;|3LM0%++l2KL#' 2ELLODr   rG   r   c           	      (   |j                  g d      }|j                  g dd      }| j                  rt        j                         5  | xj
                  dz  c_        | j                  j                  d| j                  z
        j                  || j                         | j                  j                  d| j                  z
        j                  || j                         || j                  z
  }| xj                  | j                  |z  z  c_        | j                  j                  d| j                  z
        j                  || j                         t        j                  |dz         | j                  z
  }| xj                   | j                  |z  z  c_        | j                  j                  d| j                  z
        j                  t        j                  |dz         | j                         d d d        |}|}||j#                  dddd      z
  t        j                  |j#                  dddd      dz         z  }| j$                  j#                  dddd      |z  | j&                  j#                  dddd      z   S # 1 sw Y   xY w)N)r         F)unbiasedrJ   )alphagh㈵>)rP   vartrainingr   rb   ru   rn   mul_rv   add_ro   rp   rr   r   sqrtrq   rs   rW   r:   r-   )rE   rG   
batch_mean	batch_var
mean_delta	std_deltarP   r~   s           r   r]   zCircleBatchNorm2d.forward   s   VVI&
EE)eE4	== x((A-(!!&&q4=='89>>zQUQ^Q^>_  %%a$--&78==it}}=] ($*B*BB
''4::
+BB'((--a$--.?@EEjX\XeXeEf "JJy4'784;R;RR	&&$**y*@@&'',,Q->?DDUZZPY\`P`EaimivivDwx" 1b!Q''5::chhq"a6Kd6R+SS{{2q!,q0499>>!RA3NNN+x xs   
F0JJr   )r    r!   r"   r#   rf   r&   r5   r   r$   r]   rh   ri   s   @r   rk   rk      s:    HES E E(O O%,, Or   rk   c                        e Zd ZdZddededef fdZdej                  dej                  fdZ	de
fd	Zd
ej                  fdZ xZS )	CircleNetzA CNN for CIFAR-10 using Circle Hypothesis layers.
    
    The network represents weights as computational circles.
    Training becomes phase evolution on circles.
    num_classesr   r6   c                    t         |           || _        || _        t	        ddd||      | _        t        d|      | _        t	        ddd||      | _        t        d|      | _	        t	        ddd||      | _
        t        d|      | _        t	        dd	d||      | _        t	        d	|d||      | _        t        j                  d
d
      | _        t        j"                  d      | _        g | _        g | _        y )Nrz       T)r-   r   r.   )r   @            ry   333333?)r4   r5   r   r6   r*   conv1rk   bn1conv2bn2conv3bn3fc1fc2r7   	MaxPool2dpoolDropoutdropouttheory_entropycollapse_progress)rE   r   r   r6   rF   s       r   r5   zCircleNet.__init__   s    

 !BTTYZ
$Ru5 Rd%UZ[
$Ru5 St5V[\
$S6 {Cd%]bcsKd%]bcLLA&	zz# !!#r   rG   r   c                    | j                  |      }| j                  |      }t        j                  |      }| j	                  |      }| j                  |      }| j                  |      }t        j                  |      }| j	                  |      }| j                  |      }| j                  |      }t        j                  |      }| j	                  |      }|j                  |j                  d      d      }| j                  |      }| j                  |      }t        j                  |      }| j                  |      }| j                  |      }|S Nr   r}   )r   r   r   relur   r   r   r   r   rW   sizer   r   r   rE   rG   s     r   r]   zCircleNet.forward   s   JJqMHHQKJJqMIIaL JJqMHHQKJJqMIIaL JJqMHHQKJJqMIIaL FF166!9b!LLOHHQKJJqMLLOHHQKr   c                    d}d}| j                   | j                  | j                  | j                  | j                  g}|D ]L  }t        |d      r+||j                  j                         j                         z  }t        |dd      sH|dz  }N |t        |      z  }|t        |      z  dz  }||t        d |D              t        |      z  || j                  k  dS )	z2Get current state of the Circle Hypothesis theory.r   r   rB   FrJ   r1   c              3   4   K   | ]  }|j                     y w)N)rD   ).0ls     r   	<genexpr>z-CircleNet.get_theory_state.<locals>.<genexpr>+  s     ?1?s   )entropycollapse_percentrD   is_converged)r   r   r   r   r   hasattrr   rP   rQ   getattrlensumr6   )rE   	total_devlayers_on_circlelayerslayerr   collapse_pcts          r   get_theory_statezCircleNet.get_theory_state  s     	**djj$**dhhI 	&Euk*U__11388::	une4 A% 		& c&k)(3v;6#=  ,???#f+M#djj0	
 	
r   lossc                    |j                         }| j                  | j                  | j                  | j                  | j
                  fD ]   }t        |d      s|j                  |       " | j                  j                  | j                         d          | j                  j                  | j                         d          y)z+Update all circle parameters based on loss.re   r   r   N)rQ   r   r   r   r   r   r   re   r   rR   r   r   )rE   r   loss_valr   s       r   update_circleszCircleNet.update_circles/  s    99;jj$**djj$((DHHM 	.Euo.##H-	. 	""4#8#8#:9#EF%%d&;&;&=>P&QRr   )rK   r   r   )r    r!   r"   r#   rf   r&   r5   r   r$   r]   r   r   r   rh   ri   s   @r   r   r      s[    $C $U $% $4 %,, :
$ 
.	S5<< 	Sr   r   c                       e Zd ZdZddej
                  dedefdZdej                  fdZ
dej                  fdZd	efd
Zy)CircleOptimizeru   Optimizer based on Circle Hypothesis.
    
    Instead of gradient descent: θ(t+1) = θ(t) - η∇L
    
    We use: Deviation-based rotation
    - If deviation < δ: O(1) rotation
    - If deviation > δ: Compute correction, then rotate
    modellrr6   c                     || _         || _        || _        t        j                  |j                         |      | _        d| _        g | _        y )Nr   r   )	r   r   r6   optimAdam
parametersstandard_opt
step_countcompute_history)rE   r   r   r6   s       r   r5   zCircleOptimizer.__init__I  sF    

 "JJu'7'7'9bA !r   r   c                    t        j                          }| j                  j                          |j                          | j                  j	                          | j
                  j                         }| j
                  j                  |       | xj                  dz  c_        t        j                          |z
  }| j                  j                  | j                  |d   ||d   d       y)z6Perform one optimization step using Circle Hypothesis.rJ   r   r   )stepr   compute_timeis_collapsedN)timer   	zero_gradbackwardr   r   r   r   r   r   rR   )rE   r   
start_timetheory_stater   s        r   step_circlezCircleOptimizer.step_circleU  s    YY[
 	##%  zz224 	

!!$'1yy{Z/##OO#I.((8	%
 	r   c                     | j                   j                          |j                          | j                   j                          y)z"Standard Adam step for comparison.N)r   r   r   r   )rE   r   s     r   step_standardzCircleOptimizer.step_standardm  s/    ##% r   r   c                     t        | j                        dk  ryt        d | j                  D              }t        | j                        }||z  dz  S )z:Calculate how efficiently the Circle theory is being used.rK           c              3   ,   K   | ]  }|d    s	d  yw)r   rJ   Nr(   )r   hs     r   r   z7CircleOptimizer.get_efficiency_score.<locals>.<genexpr>x  s     SA>ARaSs   
r1   )r   r   r   )rE   collapsed_stepstotal_stepss      r   get_efficiency_scorez$CircleOptimizer.get_efficiency_scores  sN    t##$r)S)=)=SS$../+-44r   N)r   r   )r    r!   r"   r#   r7   Moduler&   r5   r   r$   r   r   r   r(   r   r   r   r   ?  sQ    
"bii 
"U 
"% 
" 0!%,, !5e 5r   r   c                   z    e Zd ZU dZeed<   ee   ed<   ee   ed<   ee   ed<   eed<   eed<   eed<   eed	<   d
 Zy)TrainingResultz(Results from Circle Hypothesis training.model_statetrain_accuracytest_accuracyentropy_historycompute_efficiencycircle_collapse_percent
total_timespeedup_vs_standardc                    t        d       t        d       t        d       t        d| j                  d   dd       t        d| j                  d   dd       t        d	| j                  d   d
       t        d| j                  dd       t        d| j
                  dd       t        d| j                  dd       t        d| j                  dd       t        d       y )Nz=
============================================================z"CIRCLE HYPOTHESIS TRAINING RESULTS<============================================================zFinal Train Accuracy: r}   .2f%zFinal Test Accuracy:  zFinal Entropy:        .6fzCircle Collapse:      .1fzCompute Efficiency:   zTotal Time:           szSpeedup vs Standard:  rG   )printr   r   r   r   r   r   r   )rE   s    r   print_summaryzTrainingResult.print_summary  s    m23f&t':':2'>s&C1EF&t'9'9"'=c&B!DE&t';';B'?&DEF&t'C'CC&HJK&t'>'>s&C1EF&ts&;1=>&t'?'?&DAFGfr   N)	r    r!   r"   r#   r   r%   r   r&   r   r(   r   r   r   r     sF    2K;%[ ""r   r   2   r   r`   r   r   cudacpuepochs
batch_sizer   r   r6   devicer   c                 	   t        d       t        d|        t        d|  d| d| d|        t        d       t        j                  t        j                  dd	
      t        j                         t        j
                         t        j                  dd      g      }t        j                  t        j
                         t        j                  dd      g      }t        j                  j                  ddd|      }t        j                  j                  ddd|      }	t        j                  j                  j                  ||dd      }
t        j                  j                  j                  |	|dd      }d}t        d||      j                  |      }t!        |||      }t#        j$                         }g }g }g }t'        j&                         }t'        j&                         }t        d       t        d       t)        |       D ]_  }|j+                          d}d}d}t-        |
      D ]  \  }\  }}|j                  |      |j                  |      }} ||      } |||      }|j/                  |       ||j1                         z  }|j3                  d      \  }}||j5                  d      z  }||j7                  |      j9                         j1                         z  }|dz  dk(  s|j;                         } t        d|dz    d|  d |dz  d!d"d#|z  |z  d$d%| d&   d!d'| d(   d)d*       d}
 d#|z  |z  }!|j=                          d}d}t        j>                         5  |D ]  \  }}|j                  |      |j                  |      }} ||      }|j3                  d      \  }}||j5                  d      z  }||j7                  |      j9                         j1                         z  } 	 d+d+d+       d#|z  |z  }"|jA                  |!       |jA                  |"       |j;                         } |jA                  | d&          t        d,|dz    d-|"d$d.| d&   d/       b t'        j&                         |z
  }#|jC                         }$|j;                         d(   }%|%d0kD  rd1nd2}&tE        |jG                         ||||$|%|#|&3      }'|'jI                          |'S # 1 sw Y   xY w)4an  
    Train CIFAR-10 using Circle Hypothesis.
    
    Args:
        epochs: Number of training epochs
        batch_size: Batch size
        lr: Learning rate  
        omega: Circle angular frequency (update speed)
        delta: Deviation threshold (collapse criterion)
        device: Training device
    
    Returns:
        TrainingResult with all metrics
    u)   
🔵 CIRCLE HYPOTHESIS CIFAR-10 TRAINING   Device: z   Epochs: z	, Batch: u   , ω: u   , δ: r   r   rL   paddinggHPs?gec]?g~jt?gۊe?ggDio?g|?5^?z../dataTroottraindownload	transformFry   r   shufflenum_workers)
planecarbirdcatdeerdogfroghorseshiptruckrK   )r   r   r6   )r   r6   u,   
📊 Starting Circle Hypothesis Training...z<------------------------------------------------------------r   r   rJ   r1   c   z	  Epoch: /z	 | Loss: z.4fz | Acc:       Y@r   u   % | H(ε): r   z | Collapsed: r   r   r   N
   ✓ Epoch : Test Acc = z%, Entropy = r   r   g333333?r   )r   r   r   r   r   r   r   r   )%r   
transformsCompose
RandomCropRandomHorizontalFlipToTensor	NormalizetorchvisiondatasetsCIFAR10r   utilsrc   
DataLoaderr   tor   r7   CrossEntropyLossr   ranger   	enumerater   rQ   ra   r   eqr   r   evalrb   rR   r   r   
state_dictr   )(r   r   r   r   r6   r   transform_traintransform_testtrainsettestsettrainloader
testloaderclassesr   	optimizer	criteriontrain_acc_historytest_acc_historyr   r   standard_startepochcorrecttotalrunning_loss	batch_idxinputstargetsoutputsr   _	predictedtheory	train_acctest_accr   
efficiencyr   speedupresults(                                           r   train_cifar10_circler>    s   , 
68	Kx
 !	KxyF5'w
OP	&M !((b!,'')57OP	* O  ''57OP) N
 ##++$59_ , VH""**	48N + TG ++""--h:6: . KK!!,,W5: - KJ8G "E?BB6JE"E:I##%I OJ YY[N 

9:	(Ov 6e,5k,B 	#(I($ii/F1CGF FmGWg.D !!$' DIIK'L";;q>LAyW\\!_$Ey||G,0027799G 3"$//1	%'!F8 4+C/4 5"7l505 6  &y 1#6 7$$*+=$>s#C1	F G
  #1	#4 7NU*	 	

]]_ 	>#- >"())F"3WZZ5G-&{{1~9a(9<<0446;;==>	> '>E)  +)'')vi01
57)=#mFS\L]^aKbcdm6ep z)J //1J))+,>?L "B&cCG$$&(&'% ,#	F MS	> 	>s   /BS((S1	c                    t        d       t        d|        t        j                  t        j                         t        j                  dd      g      }t
        j                  j                  ddd|      }t        j                  j                  j                  ||dd	      }t
        j                  j                  dd
d|      }t        j                  j                  j                  ||d
d	      } G d dt        j                        }	 |	       j                  |      }
t        j                   |
j#                         |      }t        j$                         }t'        j&                         }g }t        d       t)        |       D ]y  }|
j+                          t-        |      D ]k  \  }\  }}|j                  |      |j                  |      }}|j/                           |
|      } |||      }|j1                          |j3                          m |
j5                          d}d}t        j6                         5  |D ]  \  }}|j                  |      |j                  |      }} |
|      }|j9                  d      \  }}||j;                  d      z  }||j=                  |      j?                         jA                         z  } 	 ddd       d|z  |z  }|jC                  |       t        d|dz    d|dd       | t'        j&                         |z
  }t        d|dd       t        d|d   dd       ||fS # 1 sw Y   yxY w)z4
    Standard CIFAR-10 training for comparison.
    u+   
🔴 STANDARD CIFAR-10 TRAINING (Baseline)r   r   r   z./dataTr   ry   r   Fc                   $     e Zd Z fdZd Z xZS )+train_cifar10_standard.<locals>.StandardNetc                 H   t         |           t        j                  dddd      | _        t        j
                  d      | _        t        j                  dddd      | _        t        j
                  d      | _        t        j                  dddd      | _	        t        j
                  d      | _
        t        j                  dd      | _        t        j                  dd	      | _        t        j                  d
d
      | _        t        j                   d      | _        y )Nrz   r   rJ   r   r   r   r   r   rK   ry   r   )r4   r5   r7   Conv2dr   BatchNorm2dr   r   r   r   r   Linearr   r   r   r   r   r   )rE   rF   s    r   r5   z4train_cifar10_standard.<locals>.StandardNet.__init__S  s    G1b!Q7DJ~~b)DH2r1a8DJ~~b)DH2sAq9DJ~~c*DHyyc2DHyyb)DHQ*DI::c?DLr   c           	         | j                  t        j                  | j                  | j	                  |                        }| j                  t        j                  | j                  | j                  |                        }| j                  t        j                  | j                  | j                  |                        }|j                  |j                  d      d      }| j                  |      }t        j                  | j                  |            }| j                  |      }| j                  |      }|S r   )r   r   r   r   r   r   r   r   r   rW   r   r   r   r   r   s     r   r]   z3train_cifar10_standard.<locals>.StandardNet.forward`  s    		%**TXXdjjm%<=>A		%**TXXdjjm%<=>A		%**TXXdjjm%<=>Aqvvay"%AQA

488A;'AQAAHr   )r    r!   r"   r5   r]   rh   ri   s   @r   StandardNetrA  R  s    	+		r   rG  r   u#   
📊 Starting Standard Training...r   rJ   Nr  r  r  r   r   u"   
🔴 Standard Training Complete: r   z   Final Accuracy: r}   )"r   r  r  r  r  r  r  r  r   r  rc   r  r7   r   r  r   r   r   r  r   r  r   r  r   r   r   r   rb   ra   r   r  r   rQ   rR   )r   r   r   r   r   r$  r&  r%  r'  rG  r   r)  r*  r   
accuraciesr.  r2  r3  r4  r5  r   r/  r0  r6  r7  r:  r   s                              r   train_cifar10_standardrI  5  s    
8:	Kx
 ! ""57OP$ I
 ##++59Y , PH++""--h:6: . KK ""**48I + OG!!,,W5: - KJbii 2 MV$E

5++-"5I##%IJJ	
01v B,5k,B 	(I($ii/F1CGF!FmGWg.DMMONN	 	

]]_ 	>#- >"())F"3WZZ5G-&{{1~9a(9<<0446;;==>	> '>E)(#
57)=#a@A1B4 z)J	/
3/?q
AB	
2s31
56z!!#	> 	>s    BMM	c            
      r   t        d       t        d       t        d       t        j                  j                         rdnd} t        d       t	        ddd	d
d|       }t        d       t        ddd	|       \  }}t        d       t        d       t        d       t        ddddddddd       t        d       t        ddd|j                  d   ddddd|d   dd       t        ddd|j                  ddddd|dd       t        d dd|j                  d!ddddd"d       t        d#dd|j                  d!ddddd"d       t        d$dd|j                  d   d%dddd"d       |j                  d&kD  r||j                  z  nd&}t        dd'dd|dd(       t        d)dd|j                  d   |d   z
  d*d       t        d       t        d+       t        d       |j                  dkD  xr |j                  d   d,k  xr |d-k\  }|rCt        d.       t        d/|j                  d!d0       t        d1|j                  d   d%d2       nBt        d3       t        d4|j                  d!d5       t        d6|j                  d   d%d7       t        d       ||fS )8z5Run both Circle and Standard training for comparison.G
======================================================================u.   🔬 CIRCLE HYPOTHESIS COMPREHENSIVE BENCHMARKF======================================================================r   r   u+   
📦 Running Circle Hypothesis Training...   r   r`   r   g333333?r   r   r   r   r6   r   u-   
📦 Running Standard Training (Baseline)...)r   r   r   r   u   📊 BENCHMARK COMPARISON
Metricz<30 zCircle Hypothesisz<20StandardzF----------------------------------------------------------------------zFinal Accuracyr}   r   r    z>10z
Total Timer   zCompute Efficiencyr   zN/AzCircle Collapseu   Final Entropy H(ε)r   r   zTime SpeeduprG   zAccuracy Deltaz+.2fu!   🔮 CIRCLE HYPOTHESIS VALIDATION皙?g?uW   ✅ THEORY VALIDATED: Circle Hypothesis successfully applied to neural network trainingz   - z,% of computations collapsed to O(1) rotationz   - Final entropy z indicates convergenceuL   ⚠️  PARTIAL VALIDATION: Circle Hypothesis shows promise but needs tuningz   - Collapse rate: z% (target: >50%)z   - Entropy: z (target: <0.1))r   r   r   is_availabler>  rI  r   r   r   r   r   )r   circle_resultstandard_accstandard_timetime_speedupis_valids         r   run_comprehensive_benchmarkr[    sE    
-	
:;	&Mzz..0VeF 

89(M 

:;"8	#L- 
-	
%&	&M	BxnA1#6a
37G
HI	&M	c"!M$?$?$CC#H"SQRS_`bScdgRhhi
jk	\#a 8 8=Qr#haVYGZZ[
\]	!#&a(H(H'MQrRUhVWX]^aWb
cd	s#1]%J%J3$OqQSTWPXXYZ_`cYd
ef	"3'q)F)Fr)J3(OPRSVxWXY^_bXc
de?L?W?WZ[?[==#;#;;abL	B~c"!L#5Q
78	c"!M$?$?$ClSUFV$VW[#\\]
^_ 
-	
-.	&M 	((2- 	%%b)C/	  ghm;;C@@lmn#M$A$A"$Ec#JJ`ab\]$]%J%J3$OO_`a}<<R@E_UV	&M,&&r   c                      t        d       t        d       t        d       t        j                  j                         rdnd} t        d|         t	        ddd	d
d|       }|S )z&Quick demonstration with fewer epochs.rK  u.   🚀 QUICK DEMO: Circle Hypothesis on CIFAR-10rL  r   r   z
Using device: rK   r   r`   rt   rT  rN  )r   r   r   rU  r>  )r   r=  s     r   
quick_demor]    se    	-	
:;	&Mzz..0VeF	VH
%& "F Mr   __main__rJ   z--quick).r#   r   torch.nnr7   torch.optimr   torch.nn.functional
functionalrU   r  torchvision.transformsr  numpynpr   mathtypingr   r   r   r   dataclassesr   r   collectionsr	   r   r   r*   rk   r   r   r   r   rU  rf   r&   strr>  rI  r[  r]  r    sysr   argvr(   r   r   <module>rm     s         +    . . (  
 
 
6a")) aH2O		 2Or^S		 ^SJ<5 <5F   4 !JJ335&5VVV 	V 	V
 V V Vt !JJ335&5	^"^"^" 	^" 	^"JD'N, z
388}qSXXa[I5#% r   