
    sg<                        d dl mZmZ d dlmZ d dlmZmZmZ d dl	m
Z
mZ d dlmZmZ d dlmZ d dlmZ d dlmZmZmZmZmZmZmZ d d	lmZ d d
lmZ d dlm Z  d dl!m"Z# ddl$m%Z% ddl&m'Z' ddl(m)Z) ddl*m*Z* ddl+m,Z, ddl-m.Z.m/Z/m0Z0m1Z1  G d de'e      Z2 e
jf                  ee2fe2       d Z4d Z5d Z6d Z7d Z8d Z9d Z:d Z;d Z<e<e5e7e;e9e ed       e6e8ee:fZ= e ee2 ee= i            Z>d  Z?d! Z@e@ed<   y")#    )askQ)handlers_dict)BasicsympifyS)mulMul)NumberIntegerDummy)adjoint)rm_idunpacktypedflattenexhaustdo_onenew)NonInvertibleMatrixError)
MatrixBase)sympy_deprecation_warning)validate_matmul_integer   )Inverse)
MatrixExpr)MatPow)	transpose)PermutationMatrix)
ZeroMatrixIdentityGenericIdentity	OneMatrixc                        e Zd ZdZdZ e       ZdddddZed        Z	e
d        Zdd	Zd
 Zd Z fdZd Zd Zd Zd Zd Zd ZddZd Z xZS )MatMula  
    A product of matrix expressions

    Examples
    ========

    >>> from sympy import MatMul, MatrixSymbol
    >>> A = MatrixSymbol('A', 5, 4)
    >>> B = MatrixSymbol('B', 4, 3)
    >>> C = MatrixSymbol('C', 3, 6)
    >>> MatMul(A, B, C)
    A*B*C
    TFN)evaluatecheck_sympifyc                B    |s j                   S t        t         fd|            }|rt        t        t        |            }t        j                   g| }|j                         \  }}|t        ddd       |durt        |  |s|S |r j                  |      S |S )Nc                 "    j                   | k7  S N)identity)iclss    T/var/www/html/venv/lib/python3.12/site-packages/sympy/matrices/expressions/matmul.py<lambda>z MatMul.__new__.<locals>.<lambda>0   s    S\\Q%6     zaPassing check to MatMul is deprecated and the check argument will be removed in a future version.z1.11z,remove-check-argument-from-matrix-operations)deprecated_since_versionactive_deprecations_targetF)r-   listfiltermapr   r   __new__as_coeff_matricesr   validate	_evaluate)r/   r'   r(   r)   argsobjfactormatricess   `       r0   r8   zMatMul.__new__*   s    << F6=>GT*+DmmC'$'002%s)/+Y[
 h M==%%
r2   c                     t        |      S r,   )canonicalize)r/   exprs     r0   r;   zMatMul._evaluateJ   s    D!!r2   c                     | j                   D cg c]  }|j                  s| }}|d   j                  |d   j                  fS c c}w )Nr   )r<   	is_Matrixrowscols)selfargr?   s      r0   shapezMatMul.shapeN   sC    #'99>CC>>  (2,"3"344 ?s
   AAc                    ddl m} ddlm | j	                         \  }}t        |      dk(  r||d   ||f   z  S d gt        |      dz   z  }d gt        |      dz
  z  }	||d<   ||d<   d }
|j                  d |
             }t        dt        |            D ]  }t        |      ||<    t        |d d       D ]  \  }}|j                  d   dz
  |	|<    t        |      D cg c]"  \  }}|j                  ||   ||dz      |      $ }}}t        j                  |      }t        fd	|D              rd
}| ||gt        |dd dgt        |	      z  |	       z  }t        d |	D              sd}|r|j!                         S |S c c}}w )Nr   )Sum)ImmutableMatrixr   rD   c               3   <   K   d} 	 t        d| z         | dz  } w)Nr   zi_%ir   )counters    r0   fzMatMul._entry.<locals>.fb   s,     GFW,--1    dummy_generator)rR   c              3   @   K   | ]  }|j                          y wr,   )has).0vrM   s     r0   	<genexpr>z MatMul._entry.<locals>.<genexpr>q   s     8!quu_%8s   Tc              3   H   K   | ]  }t        |t        t        f        y wr,   )
isinstancer   int)rU   rV   s     r0   rW   z MatMul._entry.<locals>.<genexpr>y   s     EQ:a'30Es    "F)sympy.concrete.summationsrL   sympy.matrices.immutablerM   r9   lengetrangenext	enumeraterJ   _entryr
   fromiteranyzipdoit)rH   r.   jexpandkwargsrL   coeffr?   indices
ind_rangesrP   rR   rI   expr_in_sumresultrM   s                  @r0   rb   zMatMul._entryS   s   1<002xx=A8A;q!t,,,&#h-!+,VS]Q./

	 !**%6<q#h-( 	/Ao.GAJ	/  ". 	-FAsIIaL1,JqM	-hqrzh{|^d^_adCJJwqz71Q3<JY||ll8,8x88FsWQr]QCJ$7D  E*EEF &v{{}2F2 }s   %'F	c                     | j                   D cg c]  }|j                  r| }}| j                   D cg c]  }|j                  s| }}t        | }|j                  du rt	        d      ||fS c c}w c c}w )NFz3noncommutative scalars in MatMul are not supported.)r<   rE   r
   is_commutativeNotImplementedError)rH   xscalarsr?   rj   s        r0   r9   zMatMul.as_coeff_matrices}   sq    "ii;q{{1;;#yy8!AKKA88W5(%&[\\h <8s   A2A2A7A7c                 <    | j                         \  }}|t        | fS r,   )r9   r&   )rH   rj   r?   s      r0   as_coeff_mmulzMatMul.as_coeff_mmul   s$    002xfh'''r2   c                 L    t        t        | 
  di |}| j                  |      S N )superr&   rh   r;   )rH   ri   expanded	__class__s      r0   rh   zMatMul.expand   s&    -77~~h''r2   c           	          | j                         \  }}t        |g|ddd   D cg c]  }t        |       c} j                         S c c}w )a  Transposition of matrix multiplication.

        Notes
        =====

        The following rules are applied.

        Transposition for matrix multiplied with another matrix:
        `\left(A B\right)^{T} = B^{T} A^{T}`

        Transposition for matrix multiplied with scalar:
        `\left(c A\right)^{T} = c A^{T}`

        References
        ==========

        .. [1] https://en.wikipedia.org/wiki/Transpose
        NrD   )r9   r&   r   rf   )rH   rj   r?   rI   s       r0   _eval_transposezMatMul._eval_transpose   sR    & 002x@/7"~>Ys^>@@D	G>s   A
c                     t        | j                  d d d   D cg c]  }t        |       c} j                         S c c}w )NrD   )r&   r<   r   rf   )rH   rI   s     r0   _eval_adjointzMatMul._eval_adjoint   s4    		$B$@@AFFHH@s   >c                 r    | j                         \  }}|dk7  rddlm} | ||j                               z  S y )Nr   )trace)ru   r   rf   )rH   r>   mmulr   s       r0   _eval_tracezMatMul._eval_trace   s9    ))+Q;$E$))+... r2   c           	          ddl m} | j                         \  }}t        | }|| j                  z  t        t        t        ||             z  S )Nr   )Determinant)&sympy.matrices.expressions.determinantr   r9   only_squaresrF   r
   r5   r7   )rH   r   r>   r?   square_matricess        r0   _eval_determinantzMatMul._eval_determinant   sG    F113&1tyy 3So-N(O#PPPr2   c                     t        d | j                  D              r-t        d | j                  d d d   D         j                         S t	        |       S )Nc              3   V   K   | ]!  }t        |t              s|j                   # y wr,   )rY   r   	is_squarerU   rI   s     r0   rW   z'MatMul._eval_inverse.<locals>.<genexpr>   s     QZZ5Ps}}Qs   ))c              3   f   K   | ])  }t        |t              r|j                         n|d z   + yw)rD   N)rY   r   inverser   s     r0   rW   z'MatMul._eval_inverse.<locals>.<genexpr>   s0       ",C!<#r'Is   /1rD   )allr<   r&   rf   r   )rH   s    r0   _eval_inversezMatMul._eval_inverse   sO    Q		QQ #yy2  df	
 t}r2   c                     j                  dd      }|rt        fd| j                  D              }n| j                  }t        t	        |       }|S )NdeepTc              3   B   K   | ]  } |j                   di   y wrw   )rf   )rU   rI   hintss     r0   rW   zMatMul.doit.<locals>.<genexpr>   s     @s*E*@s   )r^   tupler<   rA   r&   )rH   r   r   r<   rB   s    `   r0   rf   zMatMul.doit   sH    yy&@dii@@D99D FDM*r2   c           	         | j                   D cg c]  }|j                  s| }}| j                   D cg c]  }|j                  r| }}|rlt        |      }t        |      }|rT|rRt        |      |k7  rDt	        d|D cg c],  }t        | j                         j                  |      dkD  s+|. c}z        ||gS c c}w c c}w c c}w )Nz"repeated commutative arguments: %sr   )r<   rp   r]   set
ValueErrorr5   count)	rH   csetwarnri   rr   coeff_ccoeff_ncclencis	            r0   args_cnczMatMul.args_cnc   s    "ii<1+;+;1<<#yyA!0@0@AAAw<D'lGW!5 !E/6!X$tyy/:O:OPR:SVW:W"!X"Y Z Z"" =A "Ys!   B?B?CC,C	
.C	
c           	         ddl m} t        | j                        D cg c]  \  }}|j	                  |      s| }}}g }|D ]  }| j                  d | }| j                  |dz   d  }	|	rt
        j                  |	      }
nt        | j                  d         }
|rOt
        j                  t        |      D cg c]&  }|j                  r ||      j                         n|( c}      }nt        | j                  d         }| j                  |   j                  |      }|D ]5  }|j                  |       |j                  |
       |j                  |       7  |S c c}}w c c}w )Nr   )	Transposer   )r   r   ra   r<   rT   r&   rc   r"   rJ   reversedrE   rf   _eval_derivative_matrix_linesappend_firstappend_secondappend)rH   rr   r   r.   rI   
with_x_indlinesind	left_args
right_args	right_matleft_revds                r0   r   z$MatMul._eval_derivative_matrix_lines   s5   (&/		&:IFAscggajaI
I 	 C		$3I3q56*J"OOJ7	$TZZ]3	!??_ghq_r+sZ[1;;IaL,=,=,?TU,U+st#DJJqM2		#<<Q?A  x(	*Q 	 & + J ,ts   EE7+E%
)T)FT)__name__
__module____qualname____doc__	is_MatMulr#   r-   r8   classmethodr;   propertyrJ   rb   r9   ru   rh   r}   r   r   r   r   rf   r   r   __classcell__)r{   s   @r0   r&   r&      s     I H%*$ @ " " 5 5(3T((G.I/Q		#r2   r&   c                  <    | d   dk(  r| dd  } t        t        g|  S )Nr   r   )r   r&   )r<   s    r0   newmulr      s(    Aw!|ABxvr2   c                     t        d | j                  D              rL| j                  D cg c]  }|j                  s| }}t        |d   j                  |d   j
                        S | S c c}w )Nc              3   l   K   | ],  }|j                   xs |j                  xr |j                   . y wr,   )is_zerorE   is_ZeroMatrixr   s     r0   rW   zany_zeros.<locals>.<genexpr>   s3      , ;;?3==>S->->? ,s   24r   rD   )rd   r<   rE   r!   rF   rG   )r	   rI   r?   s      r0   	any_zerosr      sc    
 ,"%((, ,#&88=Cs}}C==(1+**HRL,=,=>>J >s
   A+A+c                 D   t        d | j                  D              s| S g }| j                  d   }| j                  dd D ]G  }t        |t        t        f      rt        |t        t        f      r||z  }5|j                  |       |}I |j                  |       t        | S )a   Merge explicit MatrixBase arguments

    >>> from sympy import MatrixSymbol, Matrix, MatMul, pprint
    >>> from sympy.matrices.expressions.matmul import merge_explicit
    >>> A = MatrixSymbol('A', 2, 2)
    >>> B = Matrix([[1, 1], [1, 1]])
    >>> C = Matrix([[1, 2], [3, 4]])
    >>> X = MatMul(A, B, C)
    >>> pprint(X)
      [1  1] [1  2]
    A*[    ]*[    ]
      [1  1] [3  4]
    >>> pprint(merge_explicit(X))
      [4  6]
    A*[    ]
      [4  6]

    >>> X = MatMul(B, A, C)
    >>> pprint(X)
    [1  1]   [1  2]
    [    ]*A*[    ]
    [1  1]   [3  4]
    >>> pprint(merge_explicit(X))
    [1  1]   [1  2]
    [    ]*A*[    ]
    [1  1]   [3  4]
    c              3   <   K   | ]  }t        |t                y wr,   )rY   r   r   s     r0   rW   z!merge_explicit.<locals>.<genexpr>  s     Bsz#z*BrQ   r   r   N)rd   r<   rY   r   r   r   r&   )matmulnewargslastrI   s       r0   merge_explicitr      s    8 BfkkBBG;;q>D{{12 cJ/0ZzSYFZ5[#:DNN4 D NN47r2   c                      | j                          \  }} t        d       |      }||k7  rt        |g|j                   S | S )z Remove Identities from a MatMul

    This is a modified version of sympy.strategies.rm_id.
    This is necesssary because MatMul may contain both MatrixExprs and Exprs
    as args.

    See Also
    ========

    sympy.strategies.rm_id
    c                     | j                   du S )NT)is_Identityrr   s    r0   r1   zremove_ids.<locals>.<lambda>6  s    Q]]d2 r2   )ru   r   r   r<   )r	   r>   r   rn   s       r0   
remove_idsr   '  sJ     %3$$&LFD3U23D9F~f+v{{++
r2   c                 P     | j                          \  }}|dk7  rt        |g| S | S Nr   )r9   r   )r	   r>   r?   s      r0   factor_in_frontr   <  s3    ,s,,.FH{f(x((Jr2   c                 $    | j                          \  }}|d   g}t        dt        |            D ]A  }|d   }||   }t        |t              rnt        |j
                  t              rT|j
                  j                  }t        |      }t        |      || d k(  r!|d|  t        |j                  d         gz   }t        |t              rt        |j
                  t              rm|j
                  j                  }	t        |	      }t        |	      ||||z    k(  r8t        |j                  d         }
|
|d<   t        |||z         D ]  }|
||<   	 #|j                  dk(  s|j                  dk(  r|j                  |       Tt        |t              r|j                  \  }}n|t        j                  }}t        |t              r|j                  \  }}n|t        j                  }}||k(  r&||z   }t        ||      j!                  d      |d<   t        |t"              s>	 |j%                         }|+||k(  r&||z
  }t        ||      j!                  d      |d<   1|j                  |       D t)        |g| S # t&        $ r d}Y Zw xY w)a  Combine consecutive powers with the same base into one, e.g.
    $$A \times A^2 \Rightarrow A^3$$

    This also cancels out the possible matrix inverses using the
    knowledgebase of :class:`~.Inverse`, e.g.,
    $$ Y \times X \times X^{-1} \Rightarrow Y $$
    r   r   rD   NF)r   )r9   r_   r]   rY   r   rI   r&   r<   r5   r"   rJ   r   r   r   r   Onerf   r   r   r   r   )r	   r>   r<   new_argsr.   ABBargslAargsr-   rg   A_baseA_expB_baseB_expnew_exp
B_base_invs                     r0   combine_powersr   B  sb    )3((*LFDQyH1c$i  0RLGa!j&?EEJJEE
AE{hrsm+#CaR=HQWWQZ,@+AAa!j&?EEJJEE
AE{d1QqSk)#AGGAJ/'q!A# 'A&DG';;%1;;%#7OOAa FFMFEquuEFa FFMFEquuEFVemG!&'277U7CHRLFJ/"#^^-
 %&J*>%-%fg6;;;Ga0d &$8$$ , "!
"s   $JJJc                 R   | j                   }t        |      }|dk  r| S |d   g}t        d|      D ]m  }|d   }||   }t        |t              r@t        |t              r0|j                   d   }|j                   d   }t	        ||z        |d<   ]|j                  |       o t        | S )zGRefine products of permutation matrices as the products of cycles.
       r   r   rD   )r<   r]   r_   rY   r    r   r&   )	r	   r<   r   rn   r.   r   r   cycle_1cycle_2s	            r0   combine_permutationsr     s     88DD	A1u
1gYF1a[ 	2JGa*+q+,ffQiGffQiG*7W+<=F2JMM!	 6?r2   c                 ~    | j                          \  }}|d   g}|dd D ]  }|d   }t        |t              rt        |t              s|j                  |       :|j	                          |j                  t        |j
                  d   |j
                  d                ||j
                  d   z  } t        |g| S )zj
    Combine products of OneMatrix

    e.g. OneMatrix(2, 3) * OneMatrix(3, 4) -> 3 * OneMatrix(2, 4)
    r   r   NrD   )r9   rY   r$   r   poprJ   r   )r	   r>   r<   r   r   r   s         r0   combine_one_matricesr     s     )3((*LFDQyH!"X RL!Y'z!Y/GOOA	!''!*aggaj9:!''!* &$8$$r2   c           
         | j                   }t        |      dk(  rddlm} |d   j                  rJ|d   j
                  r; ||d   j                   D cg c]  }t        ||d         j                         ! c} S |d   j                  rJ|d   j
                  r; ||d   j                   D cg c]  }t        |d   |      j                         ! c} S | S c c}w c c}w )zr
    Simplify MatMul expressions but distributing
    rational term to MatMul.

    e.g. 2*(A+B) -> 2*A + 2*B
    r   r   )MatAddr   )r<   r]   mataddr   	is_MatAddis_Rationalr&   rf   )r	   r<   r   mats       r0   distribute_monomr     s     88D
4yA~"7a!4!447<<PCF3Q0557PQQ7a!4!447<<PCF47C0557PQQJ QPs   $C+$Cc                     | dk(  S r   rx   r   s    r0   r1   r1     s    klpqkq r2   c            	      "   | d   j                   | d   j                  k7  rt        d      g }d}t        |       D ]R  \  }}|j                  | |   j                   k(  s#|j	                  t        | ||dz     j                                |dz   }T |S )z'factor matrices only if they are squarer   rD   z!Invalid matrices being multipliedr   )rF   rG   RuntimeErrorra   r   r&   rf   )r?   outstartr.   Ms        r0   r   r     s    {8B<,,,>??
CE(# 166Xe_)))JJvxac2388:;aCE Jr2   c                 $   g }g }| j                   D ]1  }|j                  r|j                  |       !|j                  |       3 |d   }|dd D ]  }||j                  k(  r8t	        t        j                  |      |      rt        |j                  d         }J||j                         k(  r8t	        t        j                  |      |      rt        |j                  d         }|j                  |       |} |j                  |       t        | S )z
    >>> from sympy import MatrixSymbol, Q, assuming, refine
    >>> X = MatrixSymbol('X', 2, 2)
    >>> expr = X * X.T
    >>> print(expr)
    X*X.T
    >>> with assuming(Q.orthogonal(X)):
    ...     print(refine(expr))
    I
    r   r   N)r<   rE   r   Tr   r   
orthogonalr"   rJ   	conjugateunitaryr&   )rB   assumptionsr   exprargsr<   r   rI   s          r0   refine_MatMulr     s     GH		 !>>OOD!NN4 	! A;D| $&&=Sc!2K@CIIaL)DDNN$$QYYs^[)ICIIaL)DNN4 D NN47r2   N)Asympy.assumptions.askr   r   sympy.assumptions.refiner   
sympy.corer   r   r   sympy.core.mulr	   r
   sympy.core.numbersr   r   sympy.core.symbolr   sympy.functionsr   sympy.strategiesr   r   r   r   r   r   r   sympy.matrices.exceptionsr   sympy.matrices.matrixbaser   sympy.utilities.exceptionsr   !sympy.matrices.expressions._shaper   r:   r   r   matexprr   matpowr   r   permutationr    specialr!   r"   r#   r$   r&   register_handlerclassr   r   r   r   r   r   r   r   r   rulesrA   r   r   rx   r2   r0   <module>r     s   ( 2 ( ( # . # #   > 0 @ Q      * E ESZ Sj   3- 0
(T*=%~,%(" i-A>SY[`aq[rOW.B	D uffen567
D (h r2   