o 3Ih(@sLdZddlmZmZmZmZddlmZddZddZ dd Z d d Z d S) z%Module for differentiation using CSE.)cseMatrix Derivative MatrixBase)iterablecsNfddddt|fdd|D}fdd|D}||fS)a This function is designed to postprocess the output of a common subexpression elimination (CSE) operation. Specifically, it removes any CSE replacement symbols from the arguments of ``Derivative`` terms in the expression. This is necessary to ensure that the forward Jacobian function correctly handles derivative terms. Parameters ========== replacements : list of (Symbol, expression) pairs Replacement symbols and relative common subexpressions that have been replaced during a CSE operation. reduced_expressions : list of SymPy expressions The reduced expressions with all the replacements from the replacements list above. Returns ======= processed_replacements : list of (Symbol, expression) pairs Processed replacement list, in the same format of the ``replacements`` input list. processed_reduced : list of SymPy expressions Processed reduced list, in the same format of the ``reduced_expressions`` input list. cs>t|tr |S|js|Sfdd|jD}|j|S)Ncg|]}|qSr).0arg repl_dicttraverserX/home/air/sanwanet/gpt-api/venv/lib/python3.10/site-packages/sympy/simplify/_cse_diff.py +zA_remove_cse_from_derivative..traverse..) isinstancerargsfunc)noder new_args) replace_allr r rr &s   z-_remove_cse_from_derivative..traversecs4|} |j}fdd|D}|s |S||}q)NTcsi|] }|vr||qSrr)r krrr 2szD_remove_cse_from_derivative..replace_all..) free_symbolsxreplace)rr resultr symbols_dictrrrr.s z0_remove_cse_from_derivative..replace_allcsg|] \}}||fqSrr)r rep_symsub_expr rrr9s z/_remove_cse_from_derivative..cs&g|]}|fdd|DqS)crrr)r expr rrr>rz:_remove_cse_from_derivative...) __class__)r red_expr rrr=s)dict) replacementsreduced_expressionsprocessed_replacementsprocessed_reducedr)r rr r_remove_cse_from_derivatives  r(c sHt|dts td|djddks!|djddks!tdts)tdtts2tjddksDjddksDtdt||\}}|rWttt|\n tgtgt t t |d}}}|dj ||fddt |dD}|sg|ggfSt ||fd dt d d |dDD}t fd d Dt d|fd dt D}td|D]Et dfddtdD} t d|fddt D} | jr| || } t|| }qt|| }q|||} |d | g} || fS)a| Core function to compute the Jacobian of an input Matrix of expressions through forward accumulation. Takes directly the output of a CSE operation (replacements and reduced_expr), and an iterable of variables (wrt) with respect to which to differentiate the reduced expression and returns the reduced Jacobian matrix and the ``replacements`` list. The function also returns a list of precomputed free symbols for each subexpression, which are useful in the substitution process. Parameters ========== replacements : list of (Symbol, expression) pairs Replacement symbols and relative common subexpressions that have been replaced during a CSE operation. reduced_expr : list of SymPy expressions The reduced expressions with all the replacements from the replacements list above. wrt : iterable Iterable of expressions with respect to which to compute the Jacobian matrix. Returns ======= replacements : list of (Symbol, expression) pairs Replacement symbols and relative common subexpressions that have been replaced during a CSE operation. Compared to the input replacement list, the output one doesn't contain replacement symbols inside ``Derivative``'s arguments. jacobian : list of SymPy expressions The list only contains one element, which is the Jacobian matrix with elements in reduced form (replacement symbols are present). precomputed_fs: list List of sets, which store the free symbols present in each sub-expression. Useful in the substitution process. rz``expr`` must be of matrix typez)``expr`` must be a row or a column matrixz(``wrt`` must be an iterable of variablesz(``wrt`` must be a row or a column matrixcs>i|]\}}tD]\}}||dkr ||fq qSr enumeratediff)r irjw) diff_valuewrtrrrsz)_forward_jacobian_cse..csJi|]!\}\}}tD]\}}||vr ||dkr ||fq qSr*r+)r r.r/fsr0s)r2rrrrs cSsg|]}||jfqSrr)r r/rrrrrz)_forward_jacobian_cse..csg|]}|j@qSrr6)r r5) rep_sym_setrrrrcs0i|]\}}d|dkrd|fqSr*r-r r0r1)r2sub_exprrrr cs@i|]}|vr|dkrd|fqSr*r8r r0)r2r.precomputed_fsrr:rrrs cs0i|]\}}|dkrd|fqSr*r8r9)r2r.r:rrrr;)rr TypeErrorshaperrr(mapziplenr!from_dokr,setrange_repnnzmultiplyaddvstack) r$ reduced_exprr3l_subl_wrtl_redf1f2c_matrix bi_matrix ai_matrix ci_matrixjacobianr)r2r.r=rr7r:r3r_forward_jacobian_cseEs\,$          rVcCs(t|\}}t|||\}}}|||fS)au Function to compute the Jacobian of an input Matrix of expressions through forward accumulation. Takes a sympy Matrix of expressions (expr) as input and an iterable of variables (wrt) with respect to which to compute the Jacobian matrix. The matrix is returned in reduced form (containing replacement symbols) along with the ``replacements`` list. The function also returns a list of precomputed free symbols for each subexpression, which are useful in the substitution process. Parameters ========== expr : Matrix The vector to be differentiated. wrt : iterable The vector with respect to which to perform the differentiation. Can be a matrix or an iterable of variables. Returns ======= replacements : list of (Symbol, expression) pairs Replacement symbols and relative common subexpressions that have been replaced during a CSE operation. The output replacement list doesn't contain replacement symbols inside ``Derivative``'s arguments. jacobian : list of SymPy expressions The list only contains one element, which is the Jacobian matrix with elements in reduced form (replacement symbols are present). precomputed_fs: list List of sets, which store the free symbols present in each sub-expression. Useful in the substitution process. )rrV)exprr3r$rKrUr=rrr!_forward_jacobian_norm_in_cse_outs & rXc st|\}}|rttt|\}}ntg}t|||\}}}|s%|dSt|t|D]\}} fdd| D} ||| ||<q-|dS)a2 Function to compute the Jacobian of an input Matrix of expressions through forward accumulation. Takes a sympy Matrix of expressions (expr) as input and an iterable of variables (wrt) with respect to which to compute the Jacobian matrix. Explanation =========== Expressions often contain repeated subexpressions. Using a tree structure, these subexpressions are duplicated and differentiated multiple times, leading to inefficiency. Instead, if a data structure called a directed acyclic graph (DAG) is used then each of these repeated subexpressions will only exist a single time. This function uses a combination of representing the expression as a DAG and a forward accumulation algorithm (repeated application of the chain rule symbolically) to more efficiently calculate the Jacobian matrix of a target expression ``expr`` with respect to an expression or set of expressions ``wrt``. Note that this function is intended to improve performance when differentiating large expressions that contain many common subexpressions. For small and simple expressions it is likely less performant than using SymPy's standard differentiation functions and methods. Parameters ========== expr : Matrix The vector to be differentiated. wrt : iterable The vector with respect to which to do the differentiation. Can be a matrix or an iterable of variables. See Also ======== Direct Acyclic Graph : https://en.wikipedia.org/wiki/Directed_acyclic_graph rcsi|]}||qSrrr<sub_reprrr rz%_forward_jacobian..)rr@rrArVr#r,r) rWr3r$rKr_rUr=r.iksub_dictrrYr_forward_jacobians + r^N) __doc__sympyrrrrsympy.utilities.iterablesrr(rVrXr^rrrrs >w ,