
    Wi\                     .   d Z ddlZddlmZ ddlmZmZmZ  G d d      Z G d dej                        Z
 G d d	      Zd
 Zd Zd Zd Zedk(  rE ed        ed        e         e         e         e         ed        ed        ed       yy)a  
Flux Algebra for PyTorch - Matrix/Tensor Implementation
========================================================
Extends the FluxNumber system to work with PyTorch tensors for ML iterations.

Key Features:
- Batched Flux operations on tensors
- GPU-compatible flux algebra operators
- Integration with PyTorch autograd for gradient-based learning
- Support for neural network weight updates with uncertainty tracking

Based on: Flux Algebra Book (Conditional Collapse Theory)
    N)TupleOptionalUnionc                   n   e Zd ZdZ	 	 d-dej
                  deej
                     deej
                     fdZdej                  dd fd	Z	d.d
Z
d.dZd.dZd.dZed        Zed        ZdefdZded ej
                  ef   dd fdZdeej
                  ef   dd fdZded ej
                  ef   dd fdZdeej
                  ef   dd fdZded ej
                  f   dd fdZdeeej
                  f   dd fdZd/dededd fdZ	 	 	 d0dej
                  dedededd f
dZ	 	 	 	 	 d1dej
                  ded ed!ed"ed#edd fd$Zd2d%ej
                  dedej
                  fd&Zd3d%ej
                  d'edej
                  fd(Z dej
                  fd)Z!dej
                  fd*Z"dej
                  fd+Z#d, Z$y)4
FluxTensoru4  
    Flux Tensor: Z = ⟨V, Σ, Τ⟩
    
    Extends FluxNumber to work with PyTorch tensors/matrices.
    
    Attributes:
        v (torch.Tensor): Value tensor (stationary component)
        s (torch.Tensor): Entropy tensor (uncertainty, >= 0)
        t (torch.Tensor): Flux tensor (rate of change)
    Nvstc                    |j                         j                         j                         | _        |%t	        j
                  | j                        | _        nW|j                         j                         j                         | _        t	        j                  | j                  d      | _        |%t	        j
                  | j                        | _        n1|j                         j                         j                         | _        | j                  j                  | j                  j                  k7  r8| j                  j                  | j                        j                         | _        | j                  j                  | j                  j                  k7  r9| j                  j                  | j                        j                         | _        yy)a  
        Initialize a FluxTensor.
        
        Args:
            v: Value tensor (any shape)
            s: Entropy tensor (same shape as v, or scalar, defaults to zeros)
            t: Flux tensor (same shape as v, or scalar, defaults to zeros)
        N        min)clonedetachfloatr   torch
zeros_liker	   clampr
   shape	expand_as)selfr   r	   r
   s       //home/per/Documents/flux algebra/flux_tensor.py__init__zFluxTensor.__init__    s*    !!#))+9%%dff-DFWWY%%'--/DF[[S1DF9%%dff-DFWWY%%'--/DF 66<<466<<'VV%%dff-335DF66<<466<<'VV%%dff-335DF (    devicereturnc                     | j                   j                  |      | _         | j                  j                  |      | _        | j                  j                  |      | _        | S )z(Move all components to specified device.)r   tor	   r
   )r   r   s     r   r   zFluxTensor.toB   sC    6"6"6"r   c                 J    | j                  t        j                  d            S )zMove to GPU.cudar   r   r   r   s    r   r    zFluxTensor.cudaI   s    wwu||F+,,r   c                 J    | j                  t        j                  d            S )zMove to CPU.cpur!   r"   s    r   r$   zFluxTensor.cpuM   s    wwu||E*++r   c                     t        | j                  j                         | j                  j                         | j                  j                               S )z-Detach all components from computation graph.)r   r   r   r	   r
   r"   s    r   r   zFluxTensor.detachQ   s/    $&&--/466==?DFFMMOLLr   c                     t        | j                  j                         | j                  j                         | j                  j                               S )zCreate a deep copy.)r   r   r   r	   r
   r"   s    r   r   zFluxTensor.cloneU   s/    $&&,,.$&&,,.$&&,,.IIr   c                 .    | j                   j                  S )z%Return the shape of the value tensor.)r   r   r"   s    r   r   zFluxTensor.shapeY   s     vv||r   c                 .    | j                   j                  S )zReturn the device.)r   r   r"   s    r   r   zFluxTensor.device^   s     vv}}r   c           	         d| j                    d| j                  j                         j                         dd| j                  j                         j                         dd| j
                  j                         j                         dd	S )NzFluxTensor(shape=z	, v_mean=.4fz	, s_mean=z	, t_mean=))r   r   meanitemr	   r
   r"   s    r   __repr__zFluxTensor.__repr__c   sy    #DJJ< 0&&++-,,.s3 4&&++-,,.s3 4&&++-,,.s316 	7r   otherc                    t        |t        j                  t        t        f      rjt        |t        t        f      r!t        j
                  || j                        }t        |t        j                  |      t        j                  |            }| j                  |j                  z   }t        j                  | j                  dz  |j                  dz  z         }| j                  |j                  z   }t        |||      S )u   
        Flux Addition (⊕): Merging two trajectories.
        
        z₁ ⊕ z₂ = ⟨v₁ + v₂, √(σ₁² + σ₂²), τ₁ + τ₂⟩
        r      
isinstancer   Tensorr   inttensorr   r   r   r   sqrtr	   r
   r   r/   new_vnew_snew_ts        r   __add__zFluxTensor.__add__k   s     eellE378%%.U4;;?ue&6&6u&=u?O?OPU?VWE 

46619uwwz12 %..r   c                 $    | j                  |      S )z.Right addition for scalar/tensor + FluxTensor.)r=   r   r/   s     r   __radd__zFluxTensor.__radd__{       ||E""r   c                 j   t        |t        j                  t        t        f      rjt        |t        t        f      r!t        j
                  || j                        }t        |t        j                  |      t        j                  |            }| j                  |j                  z  }t        j                  | j                  |j                  z  dz  |j                  | j                  z  dz  z         }| j                  |j                  z  |j                  | j                  z  z   }t        |||      S )u   
        Flux Multiplication (⊗): Scaling of complexity.
        
        z₁ ⊗ z₂ = ⟨v₁·v₂, √((v₁·σ₂)² + (v₂·σ₁)²), v₁·τ₂ + v₂·τ₁⟩
        r1   r2   r3   r9   s        r   __mul__zFluxTensor.__mul__   s     eellE378%%.U4;;?ue&6&6u&=u?O?OPU?VWE 

DFFUWW,q0EGGdff4Dq3HHI 577TVV#33%..r   c                 $    | j                  |      S )z4Right multiplication for scalar/tensor * FluxTensor.)rC   r?   s     r   __rmul__zFluxTensor.__rmul__   rA   r   c                 L   t        |t        j                        r3t        |t        j                  |      t        j                  |            }| j
                  |j
                  z  }| j                  dz  }|j                  dz  }t        j                  |      |j
                  j                         z  | j
                  j                         t        j                  |      z  z   }| j
                  |j                  z  |j
                  | j                  z  z   }t        |||      S )z
        Flux Matrix Multiplication.
        
        Extends flux algebra to matrix operations with uncertainty propagation.
        r2   )
r4   r   r5   r   r   r   r	   r8   absr
   )r   r/   r:   s_1_sqs_2_sqr;   r<   s          r   
__matmul__zFluxTensor.__matmul__   s     eU\\*ue&6&6u&=u?O?OPU?VWE  
 ! F#eggkkm3

6 223  577TVV#33%..r   workc                     t        |t        t        f      r!t        j                  || j
                        }t        j                  | j                  |z
  d      }t        | j                  || j                        S )u   
        Collapse Operator (𝒞): Reduce entropy by paying work.
        
        𝒞(z, W) = ⟨v, max(0, σ - W), τ⟩
        
        Args:
            work: Work budget (scalar or tensor matching shape)
        r1   r   r   )r4   r   r6   r   r7   r   r   r	   r   r   r
   )r   rK   r;   s      r   collapsezFluxTensor.collapse   sU     dUCL)<<T[[9DDFFTMs3$&&%00r   dtentropy_decayc                     | j                   | j                  |z  z   }| j                  d|z
  z  }| j                  }t        |||      S )z
        Time evolution / derivative step.
        
        Updates value by flux * dt, optionally decays entropy.
        
        Args:
            dt: Time step
            entropy_decay: Decay factor (0 = no decay, 1 = full decay)
              ?)r   r
   r	   r   )r   rN   rO   r:   r;   r<   s         r   evolvezFluxTensor.evolve   sE     "$#-.%..r   losslrcreate_graphc                    | j                   j                         j                  d      }| j                   j                  | j                   j                  }n/t        j
                  j                  || j                   d      d   }| |z  }| j                  |z   }| j                   |z   }	| j                  t	        j                  |      |z  z   }
|dkD  rt	        j                  |
|z
  d      }
t        |	|
|      S )u  
        Perform a gradient descent step with flux algebra.
        
        Implements learning as entropy collapse:
        θ_{t+1} = θ_t ⊕ (-lr · ∇L) then collapse with work
        
        Args:
            loss: Loss tensor (scalar)
            lr: Learning rate (becomes flux component)
            work: Work budget for collapse
            create_graph: Whether to maintain computation graph
        
        Returns:
            Updated FluxTensor
        Tretain_graphr   r   r   )r   r   requires_grad_gradr   autogradr
   r	   rG   r   r   )r   rS   rT   rK   rU   v_with_gradgradsdelta_vr<   r:   r;   s              r   gradient_stepzFluxTensor.gradient_step   s    . fflln33D9 66;;"FFKKE NN''dff4'HKE #+     5)B.. !8KK#6E%..r   beta1beta2epsstepc           	         t         j                  j                  || j                  d      d   }|| j                  z  d|z
  |z  z   }|| j
                  z  d|z
  |dz  z  z   }	|d||z  z
  z  }
|	d||z  z
  z  }| j                  ||
z  t        j                  |      |z   z  z
  }t        |t        j                  t        j                  |d            |      S )z
        Adam optimizer step with flux tracking.
        
        Integrates Adam's adaptive learning with flux algebra's uncertainty.
        TrW   r      r2   r   )	r   r[   rZ   r   r
   r	   r8   r   r   )r   rS   rT   r`   ra   rb   rc   rZ   r<   r;   t_correcteds_correctedr:   s                r   	adam_stepzFluxTensor.adam_step  s     ~~""4d"CAF !e)t!33!e)tQw!66 q5$;/q5$;/ k)UZZ-Ds-JKK%EKK,K!LeTTr   prev_sc                 &    | j                   |z
  |z  S )u   
        Compute entropy velocity (σ̇).
        
        σ̇ < 0: System is collapsing (learning/stabilizing)
        σ̇ > 0: System is expanding (hallucinating/diverging)
        )r	   )r   ri   rN   s      r   entropy_velocityzFluxTensor.entropy_velocity&  s     2%%r   	thresholdc                 *    | j                  |      |k  S )z*Check if entropy is collapsing (learning).)rk   )r   ri   rl   s      r   is_collapsingzFluxTensor.is_collapsing/  s    $$V,y88r   c                 6    | j                   j                         S )z*Get total entropy (sum over all elements).)r	   sumr"   s    r   total_entropyzFluxTensor.total_entropy3  s    vvzz|r   c                 @    t        j                  | j                        S )zGet L2 norm of entropy.)r   normr	   r"   s    r   entropy_normzFluxTensor.entropy_norm7  s    zz$&&!!r   c                     | j                   S )zExtract value tensor.)r   r"   s    r   	to_tensorzFluxTensor.to_tensor;  s    vvr   c                     | j                   j                         dk7  rt        d      | j                   j                         S )z+Get single value (only for scalar tensors).re   z*Can only call .item() on scalar FluxTensor)r   numel
ValueErrorr-   r"   s    r   r-   zFluxTensor.item?  s0    66<<>QIJJvv{{}r   )NN)r   r   )rQ   r   ){Gz?r   F)MbP?g?g+?g:0yE>re   )rQ   )r   )%__name__
__module____qualname____doc__r   r5   r   r   r   r   r    r$   r   r   propertyr   strr.   r   r   r=   r@   rC   rE   rJ   rM   rR   boolr_   r6   rh   rk   rn   rq   rt   rv   r-    r   r   r   r      s   	 %)$(	 6<< 6 ELL! 6 ELL!	 6D , -,MJ    7# 7/U<u#DE /, / #eELL%$78 #\ #/U<u#DE /, / #eELL%$78 #\ #/lELL&@ A /l /:1U5%,,#67 1L 1/ /U /\ /( "5/ll5/ 5/ 	5/
 5/ 
5/t UllU U 	U
 U U U 
U>&u|| & & &9ELL 9U 9U\\ 9u|| "ell "5<< r   r   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d	ej                  d
e
de
fdZde
fdZdefdZ xZS )
FluxLinearzv
    Linear layer with Flux Algebra tracking.
    
    Wraps nn.Linear to track weight uncertainty and evolution.
    in_featuresout_featuresbiasc                    t         |           t        j                  |||      | _        t        | j                  j                  j                  t        j                  | j                  j                  j                        dz  t        j                  | j                  j                  j                              | _        |rt        | j                  j                  j                  t        j                  | j                  j                  j                        dz  t        j                  | j                  j                  j                              | _        y y )N)r   皙?r	   r
   )superr   nnLinearlinearr   weightdatar   	ones_liker   weight_fluxr   	bias_flux)r   r   r   r   	__class__s       r   r   zFluxLinear.__init__O  s    ii\E &KK##oodkk00556<t{{11667
 '  %%//$++"2"2"7"783>""4;;#3#3#8#89DN r   xr   c                     ddl mc m} |j                  || j                  j
                  | j                  j                  | j                  j
                        }|S d      }|S )z)Forward pass using current weight values.r   N)torch.nn.functionalr   
functionalr   r   r   r   r   )r   r   Fresults       r   forwardzFluxLinear.forwarda  sW     	('!T--//T[[EUEUEa1A1Al hllr   rS   rT   rK   c                    t        j                         5  | j                  j                  j                  }|9t         j
                  j	                  || j                  j                  d      d   }| |z  }| j                  j                  |z   }| j                  j                  |z   }| j                  j                  t        j                  |      z   }|dkD  rt        j                  ||z
  d      }t        |||      | _        || j                  j                  _        | j                  j                  | j                  j                  j                  }	|	9t         j
                  j	                  || j                  j                  d      d   }	| |	z  }
| j                  j                  |
z   }| j                  j                  |
z   }| j                  j                  t        j                  |
      z   }|dkD  rt        j                  ||z
  d      }t        |||      | _        || j                  j                  _        ddd       y# 1 sw Y   yxY w)z
        Update flux state after computing loss.
        
        Args:
            loss: Loss tensor
            lr: Learning rate
            work: Work budget for collapse
        NTrW   r   r   r   )r   no_gradr   r   rZ   r[   r
   r	   rG   r   r   r   r   r   r   r   )r   rS   rT   rK   rZ   deltar:   r<   r;   	grad_bias
delta_bias
new_v_bias
new_t_bias
new_s_biass                 r   flux_updatezFluxLinear.flux_updateh  s    ]]_ #	3##%%**D|~~**41A1A1C1CRV*WXYZC$JE$$&&.E$$&&.E$$&&5)99E axEDLc:  *%>D&+DKK# {{+ NN,,11	$ % 3 3D$..:J:JY] 3 ^_` aI S9_
!^^--
:
!^^--
:
!^^--		*0EE
!8!&Z$->C!HJ!+J
J!O(2  %G#	3 #	3 #	3s   H.IIc                     | j                   j                  |      | _         | j                  j                  !| j                  j                  |      | _        yy)z(Collapse entropy for weights and biases.N)r   rM   r   r   r   )r   rK   s     r   rM   zFluxLinear.collapse  sF    ++44T:;;'!^^44T:DN (r   c                    | j                   j                  j                         j                         | j                   j	                         j                         d}| j
                  j                  `| j                  j                  j                         j                         |d<   | j                  j	                         j                         |d<   |S )zReport current entropy levels.)weight_entropy_meanweight_entropy_totalbias_entropy_meanbias_entropy_total)r   r	   r,   r-   rq   r   r   r   )r   reports     r   entropy_reportzFluxLinear.entropy_report  s     $(#3#3#5#5#:#:#<#A#A#C$($4$4$B$B$D$I$I$K
 ;;'*...*:*:*?*?*A*F*F*HF&'+/>>+G+G+I+N+N+PF'(r   )T)rz   r   )r|   r}   r~   r   r6   r   r   r   r5   r   r   r   rM   dictr   __classcell__)r   s   @r   r   r   H  st    C s $ $ %,, -3 -3% -3e -3^;U ;	 	r   r   c                       e Zd ZdZddej
                  j                  dee   fdZ	ddeej                     fdZdefd	Zd
efdZy)FluxOptimizerz
    Optimizer wrapper that applies flux algebra to standard PyTorch optimizers.
    
    Tracks uncertainty and applies collapse operators during training.
    N	optimizerwork_schedulec           	      R   || _         |xs d | _        d| _        i | _        |j                  D ]w  }|d   D ]m  }t        |j                  t        j                  |j                        dz  t        j                  |j                              | j                  t        |      <   o y y)z
        Initialize Flux Optimizer.
        
        Args:
            optimizer: PyTorch optimizer
            work_schedule: Function(step) -> work_budget (optional)
        c                      y)Nrz   r   rc   s    r   <lambda>z(FluxOptimizer.__init__.<locals>.<lambda>  s    r   r   paramsr   r   N)r   r   
step_countflux_statesparam_groupsr   r   r   r   r   id)r   r   r   groupparams        r   r   zFluxOptimizer.__init__  s     #*A/@ ++ 	Ex .8JJooejj1C7&&uzz2/  E+	r   rS   c                    | xj                   dz  c_         | j                  | j                         }||j                          | j                  j	                          | j                  j                          | j                  j                  D ]  }|d   D ]  }t        |      }| j                  |   }|j                  |j                  z
  }|j                  |z   }|j                  t        j                  |      z   }	t        j                  |	|z
  d      }	t!        |j                  j#                         |	|      | j                  |<     y)z
        Perform optimization step with flux tracking.
        
        Args:
            loss: Loss tensor (if None, uses standard optimizer step)
        re   Nr   r   r   )r   r   backwardr   rc   	zero_gradr   r   r   r   r   r
   r	   r   rG   r   r   r   )
r   rS   rK   r   r   param_idold_fluxr   r<   r;   s
             r   rc   zFluxOptimizer.step  s    	1!!$//2 MMO  " ^^00 	Ex e9++H5 

XZZ/ 

U* 

UYYu%55 EDLc:-7JJ$$&.  *	r   r   c                 8   d}d}d}| j                   j                         D ]]  \  }}||j                         j                         z  }t	        ||j
                  j	                         j                               }|dz  }_ |||dkD  r||z  nd| j                  dS )z!Get aggregate entropy statistics.r   re   )rq   max_entropyavg_entropyrc   )r   itemsrq   r-   maxr	   r   )r   rq   r   countr   fluxs         r   get_entropy_statszFluxOptimizer.get_entropy_stats  s    "..446 	NHdT//16688Mk466::<+<+<+>?KQJE	 +&49AI=501OO	
 	
r   rK   c                     | j                   j                         D ]#  \  }}|j                  |      | j                   |<   % y)z)Apply collapse to all tracked parameters.N)r   r   rM   )r   rK   r   r   s       r   collapse_allzFluxOptimizer.collapse_all  s=    "..446 	=NHd)-t)<DX&	=r   )N)r|   r}   r~   r   r   optim	Optimizerr   callabler   r5   rc   r   r   r   r   r   r   r   r   r     sX    %++"7"7 QYHZ ,#%,,/ #J
4 
$= =r   r   c                     t        d       t        d       t        d       t        t        j                  g d      t        j                  g d      t        j                  g d            } t        t        j                  g d      t        j                  g d	      t        j                  g d
            }t        d|         t        d|        | |z   }t        d|        | |z  }t        d|        | j	                  d      }t        d|        | j                  dd      }t        d|        y)z'Basic example of FluxTensor operations.=
============================================================z&Example 1: Basic FluxTensor Operations<============================================================)       @      @      @)      ?333333?皙?)r   r   333333?r   r	   r
   )rQ   r   r   )r   g?r   )皙?r   r   zz1 = zz2 = u   z1 ⊕ z2 = u   z1 ⊗ z2 = r   )rK   u   𝒞(z1, W=0.2) = r   rz   )rN   rO   zEvolve(z1, dt=0.5) = N)printr   r   r7   rM   rR   )z1z2z_addz_mulz_collapsed	z_evolveds         r   example_basic_flux_tensorr     s   	-	
23	&M 

,,
'
,,
'
,,'
(
B 

,,
'
,,
'
,,'
(
B 
E",	E", GE	L
 ! GE	L
 ! ++3+'K	{m
,- 		S	5I	!)
-.r   c            	         t        d       t        d       t        d       t        t        j                  ddgddgg      t        j                  dd	gd
dgg      t        j                  ddgddgg            } t        t        j                  ddgddgg      t        j                  ddgd	d
gg      t        j                  ddgddgg            }t        d|         t        d|        | |z  }t        d|        y)zExample with matrix operations.r   zExample 2: Matrix Operationsr   rQ   r   r   r   r   r   r   r   g{Gz?gQ?r   r   gQ?g
ףp=
?zA = zB = zA @ B = N)r   r   r   r7   )ABCs      r   example_matrix_operationsr   .  s    	-	
()	&M 	
,,c
S#J/
0
,,c
T3K0
1
,,sdD\2
3	A 	
,,c
S#J/
0
,,sc4[1
2
,,ddD\2
3	A 
D*	D* 	
AA	HQC.r   c            
      b   t        d       t        d       t        d       t        j                  d       t        j                  dd      } t        | j                  j                  j                         t        j                  | j                  j                        dz  t        j                  | j                  j                              }t        | j                  j                  j                         t        j                  | j                  j                        dz  t        j                  | j                  j                              }t        j                  d	d      }t        j                  d	d      }t        d
       t        d      D ]  } | |      }||z
  dz  j                         }|j                          t        j                          5  d}d}	| j                  j"                  }
| |
z  }t        | j                  |z   |j$                  t        j&                  |      z   |j(                  |z         j+                  |	      }|j,                  | j                  _        | j                  j"                  }| |z  }t        | j                  |z   |j$                  t        j&                  |      z   |j(                  |z         j+                  |	      }|j,                  | j                  _        ddd       | j/                          t        d|dz    d|j1                         dd|j$                  j                         j1                         d        |j+                  d      }t        d|j$                  j                         j1                         d       y# 1 sw Y   xY w)z-Example of using flux algebra in ML training.r   z(Example 3: ML Training with Flux Algebrar   *   
      r   r       z
Training with flux tracking...r2   rz   r   NEpoch re   : Loss=r*   z, Weight Entropy=r   z 
After collapse: Weight Entropy=)r   r   manual_seedr   r   r   r   r   r   r   r   r   randnranger,   r   r   rZ   r	   rG   r
   rM   r   r   r-   )layerr   r   r   yepochpredrS   rT   rK   grad_wdelta_wgrad_bdelta_bs                 r   example_ml_trainingr   I  s   	-	
45	&M 
b IIb!E !
//%,,++
,s
2


5<<,,
-K
 


//%**//
*S
0


5::??
+I 	BABA 

,-q &CQxA##% 	 ]]_ 	*BD \\&&FcFlG$w&		' 22' htn	 
 !,ELL ZZ__FcFlG"

W$eii00g% htn	 
 (kkEJJO-	*2 	 	uQwiwtyy{3&7 8  + 2 2 4 9 9 ;C@B 	CK&CR &&s+K	-kmm.@.@.B.G.G.I#-N
OPC	* 	*s   DN%%N.	c            
         t        d       t        d       t        d       t        j                  t        j                  dd      t        j                         t        j                  dd            } t
        j                  j                  | j                         d      }t        |d	 
      }t        j                  dd      }t        j                  dd      }t        d       t        d      D ]k  } | |      }||z
  dz  j                         }|j                  |       |j                         }t        d|dz    d|j                         dd|d   d       m y)z)Example using FluxOptimizer with PyTorch.r   zExample 4: FluxOptimizerr   r      r   r{   )rT   c                     dd| dz  z   z  S )Nrz   re   r   r   r   s    r   r   z(example_flux_optimizer.<locals>.<lambda>  s    41tcz>#: r   )r   @   z
Training with FluxOptimizer...r2   r   re   r   r*   z, Total Entropy=rq   N)r   r   
Sequentialr   ReLUr   r   Adam
parametersr   r   r   r,   rc   r   r-   )	modelbase_optimizerr   r   r   r   r   rS   statss	            r   example_flux_optimizerr    s2   	-	
$%	&M MM
		"b
	
		"aE [[%%e&6&6&8U%CN:I 	BABA	
,-q =QxA##%t++-uQwiwtyy{3&7 8$_5c:< 	==r   __main__z7Flux Algebra for PyTorch - Matrix/Tensor Implementationz;Based on: The Algebra of Flux (Conditional Collapse Theory)r   z$All examples completed successfully!r   )r   r   torch.nnr   typingr   r   r   r   Moduler   r   r   r   r   r  r|   r   r   r   r   <module>r     s      ) )o oh	^ ^FW= W=x$/N6HQV!=H z	
CD	
GH 	-	
01	&M r   