,iG ddlZGddZd2dZdZdZGddZed k(rfed ed ed ed ejd dddZ ejd dddZ ede ede e e zZ ede e je ZedeedejddddZedej!ddZedD]3Zej)eZededzdej!d5ed ed!d"Zej,j/d#d!Zej3e\ZZed$ej8ed%ej8ed&ej;ded'ej=ded(ed!D]Zej,j/d!ddzZej,j/ddd)zZ ejCee d)d*+ed,zdk(s_ed-ed.ejDj!dd/ej=ded0ed1ed yy)3NceZdZdZddZedZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZddZddZddZeddZed dZd!dZdZdZdZdZdZdZy)" FluxMatrixa A matrix in Flux Algebra where each element is a Flux Number. The matrix is represented as three aligned matrices: - V: Value matrix (the current "mean" state) - S: Entropy matrix (uncertainty/spread of each element) - T: Flux matrix (rate of change/velocity of each element) This enables tracking uncertainty and evolution in ML weights, gradients, and activations. NcHtj|tj|_|%tj|j|_n*tj|tj|_|%tj|j|_n*tj|tj|_|jj|j jcxk(r|j jk(sJdJdy)z Initialize a FluxMatrix. Args: V: Value matrix (numpy array or scalar) S: Entropy matrix (same shape as V, default: zeros) T: Flux matrix (same shape as V, default: zeros) dtypeNz V, S, T must have the same shape)nparrayfloat64V zeros_likeSTshape)selfr r rs //home/per/Documents/flux algebra/flux_matrix.py__init__zFluxMatrix.__init__s!2::. 9]]466*DFXXarzz2DF 9]]466*DFXXarzz2DFvv||tvv||;tvv||; / . /; / . /;c.|jjSN)r rrs rrzFluxMatrix.shape'svv||rcrd|jd|jjdd|jjdd|jjdd|jjdd|j jdd|j jddS)NzFluxMatrix(shape=z , V_range=[z.3fz, z ], S_range=[z ], T_range=[z]))rr minmaxr rrs r__repr__zFluxMatrix.__repr__+s#DJJ<0 FFJJL-R S/AB FFJJL-R S/AB FFJJL-R S/AE Frct|ttfrJt|j|z|j j |jj St|trq|j|jz}tj|j dz|j dzz}|j|jz}t|||Stdt|)u Flux Addition (⊕): Merging of two trajectories. z1 ⊕ z2 = ⟨v1 + v2, √(σ1² + σ2²), τ1 + τ2⟩ zCannot add FluxMatrix and isinstanceintfloatrr r copyrrsqrt TypeErrortyperothernew_Vnew_Snew_Ts r__add__zFluxMatrix.__add__5s ec5\ *    z *FFUWW$EGGDFFAI 23EFFUWW$EeUE2 28e FG Grc$|j|Sr)r*rr&s r__radd__zFluxMatrix.__radd__Is||E""rct|ttfrJt|j|z |j j |jj St|trq|j|jz }tj|j dz|j dzz}|j|jz }t|||Stdt|d)zFlux Subtraction.rzCannot subtract z from FluxMatrixrr%s r__sub__zFluxMatrix.__sub__Ls ec5\ *    z *FFUWW$EGGDFFAI 23EFFUWW$EeUE2 2.tE{m;KLM Mrct|ttfrC|j|z}|jt |z}|j |z}t|||Stdt|)u\ Scalar Multiplication. α ⊗ z = ⟨αv, |α|σ, ατ⟩ zCannot multiply FluxMatrix by ) rrr r r absrrr#r$)rscalarr'r(r)s r__mul__zFluxMatrix.__mul__\sd fsEl +FFVOEFFS[(EFFVOEeUE2 2>rc|j|j|zz}|jdz}t|||jj S)u Flux Derivative / ODE step. d/dt ⟨v, σ, τ⟩ = ⟨τ, σ̇, τ̇⟩ For discrete evolution: - v_new = v + τ * dt - σ_new = σ * decay (natural entropy decay) - τ stays constant (unless specified otherwise) Args: dt: Time step Returns: New evolved FluxMatrix gGz?)r rr rr!)rdtr'r(s revolvezFluxMatrix.evolves@""$ % 66rc |j|z S)u Compute entropy velocity (σ̇). σ̇ = (σ_t - σ_{t-1}) / dt Returns: Matrix of entropy velocities )r )rrJs rentropy_velocityzFluxMatrix.entropy_velocitysvv{rc(|j|kS)z Check if the system is collapsing (learning/stabilizing). Returns: Boolean matrix where True indicates collapsing elements rMr thresholds r is_collapsingzFluxMatrix.is_collapsing$$&22rc(|j|kDS)z Check if the system is expanding (hallucinating/diverging). Returns: Boolean matrix where True indicates expanding elements rOrPs r is_expandingzFluxMatrix.is_expandingrSrctjj||z}tj||z}tjj||z}||||S)ab Create a random FluxMatrix for initializing ML weights. Args: shape: Tuple specifying matrix shape v_scale: Scale for value initialization (Xavier-like) s_init: Initial entropy t_scale: Scale for flux initialization Returns: Random FluxMatrix )rrandomrandnones)clsrv_scales_initt_scaler r rs r from_randomzFluxMatrix.from_randomsR IIOOU #g - GGENV # IIOOU #g -1a|rctj|tj}tj||z}tj||z}||||S)aD Create a FluxMatrix from a standard numpy array. Args: array: numpy array of values entropy: Initial entropy for all elements flux: Initial flux for all elements Returns: FluxMatrix with given values and uniform entropy/flux r)rr r ones_like)rZr entropyfluxr r rs r from_arrayzFluxMatrix.from_arraysJ HHU"** - LLOg % LLOd "1a|rct|tr|| z}nY| |z}tj|}t |dr|j ntj |}t|||}||z}|j|S)u Perform a gradient descent step in Flux Algebra. This is the Flux Algebra equivalent of: θ_new = θ_old - lr * gradient Implemented as: θ_{t+1} = θ_t ⊕ (-lr * gradient) Then collapse to reduce uncertainty. Args: gradient: FluxMatrix or standard matrix of gradients learning_rate: Learning rate (scalar) work_budget: Work to pay for collapse Returns: Updated FluxMatrix r!)rrrr hasattrr!r rH) rgradient learning_rate work_budgetdeltadelta_Vdelta_Sdelta_Tnew_selfs r gradient_stepzFluxMatrix.gradient_steps& h +/E%nx/GmmG,G)06)BhmmoQYHZGw9E%<  --rct|tr||z}|j|jfSt j |}||jz}t j |dz|jdzz}||fS)a- Make predictions with uncertainty propagation. For y = X @ W: Returns both prediction and uncertainty. Args: X: Input FluxMatrix or standard matrix Returns: Tuple of (prediction, uncertainty) matrices r)rrr r rr r")rXresultX_arrresult_Vresult_Ss rpredictzFluxMatrix.predict9sp a $XF88VXX% %HHQKEtvv~Hwwq46619 46HX% %rcVtjj|jdS)z6Get total entropy of the matrix (Frobenius norm of S).fro)rlinalgnormr rs r total_entropyzFluxMatrix.total_entropyPyy~~dffe,,rcVtjj|jdS)z/Get total flux magnitude (Frobenius norm of T).rw)rrxryrrs r total_fluxzFluxMatrix.total_fluxTr{rc|j}|dk(rytjtjd|j }d||z z S)z Compute stability score: ratio of collapsed entropy to total. Higher score = more stable/certain system. r?)rzrsumrFrM)rtotal collapseds rstability_scorezFluxMatrix.stability_scoreXsQ ""$ A:FF2::a$*?*?*A)ABC i%'((rc6|jjS)z/Extract just the value matrix as a numpy array.)r r!rs rto_arrayzFluxMatrix.to_arraydsvv{{}rct|jj|jj|jjS)z&Create a deep copy of this FluxMatrix.)rr r!r rrs rr!zFluxMatrix.copyhs/$&&++- FFr)NN)r)r:)皙?{Gz?MbP?)rr:rr)__name__ __module__ __qualname____doc__rpropertyrrr*r-r/r3r5r7rBrDrHrKrMrRrU classmethodr^rcrnrurzr}rrr!rrrrs /,FH(#N M$M #/J"?$7* 33$" .D&.-- )Grrcttj|tj||f|ztj||f|zS)z$Create a FluxMatrix identity matrix.)rreyer;)nsts rflux_eyerqs= bffQi1a&!1A!5rxxA7G!7K LLrc>ttj|S)zCreate a FluxMatrix of zeros.)rrr;rs r flux_zerosrvs bhhuo &&rc>ttj|S)zCreate a FluxMatrix of ones.)rrrYrs r flux_onesr{s bggen %%rc,eZdZdZddZdZddZdZy) FluxLinearLayeru A linear layer using Flux Algebra for uncertainty-aware learning. This tracks not just the weights, but their uncertainty and evolution over time—enabling automatic confidence estimation. ctjd|z }tj||f|||dz|_tjd|fd|d|_y)Ng@rr[r\r]r9r:r)rr"rr^weightsbias)r in_features out_features init_entropyscales rrzFluxLinearLayer.__init__skk)*!-- , 'DL .  **   +  rc||jjz|jjz}tj|dz|jj dzz|jj dzz}||fS)z Forward pass with uncertainty propagation. Args: X: Input matrix (standard numpy array) Returns: Tuple of (output_value, output_entropy) r)rr rrr"r )rrpout_Vout_Ss rforwardzFluxLinearLayer.forwardsbDLLNN"TYY[[0A  11TYY[[!^CDe|rc|jj||||_|jj||||_y)a Update weights using gradient descent with entropy collapse. Args: grad_weights: Gradient for weights grad_bias: Gradient for bias lr: Learning rate work: Work budget for collapse N)rrnr)r grad_weights grad_biaslrworks rupdatezFluxLinearLayer.updates8||11,DI II++Ir4@ rcb|jj}tj| S)zs Get confidence in this layer's weights. 1.0 = fully confident, 0.0 = maximum uncertainty. )rrzrexp)rrzs r confidencezFluxLinearLayer.confidences'  224 vv}n%%rN)rr)rrrrrrrrrrrrrs  A&rr__main__z<============================================================z-FLUX ALGEBRA FOR MATRICES - ML Iteration Demoz$ --- Example 1: Basic Operations ---)rrg?rrg333333?g?zA = zB = u A ⊕ B = uA ⊗ B (matmul) = z0 --- Example 2: Learning as Entropy Collapse ---)rzInitial total entropy: z.4fzEpoch r9z : entropy = z- --- Example 3: Flux Neural Network Layer --- )rr z Input shape: zOutput shape: zOutput uncertainty (mean): zLayer confidence: z Training simulation:rg{Gzt?)rrrz Epoch z: weight_entropy=z , confidence=z= ============================================================z5Flux Algebra enables uncertainty-aware ML iterations!)r:r:)#numpyrrrrrrrprintr^ABCrBDmodelrzrhr<epochrHlayerrWrXrproutput uncertaintyrmeanrgrad_Wgrad_brrrrrrsfGfGZ M ' &;&;&D z (O 9: (O 12vs3LAvs3MA D* D* AA Jqc   A s #$ =>  " "63sC " PE #E$7$7$9##> ?@KqI{+ uQwi|E,?,?,A#+FGHI  :;  ;E BA--*FK M!'' #$ N6<<. )* ' (8(8(:3'? @A u//1#6 78 "#r:Q'#-A&- VV5 9 19> HUG#4U]]5P5P5RSV4WX % 0 0 2379 : : / AB (Okr