DGCV 0.2.2__tar.gz → 0.2.3__tar.gz

dgcv-0.2.3/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.1
+Name: DGCV
+Version: 0.2.3
+Summary: Differential Geometry with Complex Variables
+Author: David Sykes
+Author-email: David Sykes <david@realandimaginary.com>
+License: MIT
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: sympy>=1.9
+Requires-Dist: pandas>=1.0
+Requires-Dist: ipython>=7.0
+
+DGCV is an open-source Python package for differential geometry with complex variables. It provides symbolic representations of standard DG objects like vector fields and differential forms in complex coordinate systems. DGCV tracks natural relationships between complex geometric objects constructed from complex variables. This uniform integration allows smooth switching between real and holomorphic coordinate representations. DGCV classes dynamically manage format switching, so complex variables formulas work without conversion. For example, expressions like $\frac{\partial}{\partial x_j}|z_j|^2$ or $d z_j \wedge d \overline{z_j} \left( \frac{\partial}{\partial z_j}, \frac{\partial}{\partial y_j} \right)$ are parsed correctly. Retrieving complex structure-related attributes, like the holomorphic part of a vector field or pluriharmonic terms from a polynomial, is straightforward. Complexified cotangent bundles and their exterior algebras can be decomposed into components from the Dolbeault complex and Dolbeault operators applied to functions and k-forms in either coordinate format.
+
+DGCV, developed with Python 3.12, integrates SymPy objects within its data structures and subclasses from SymPy.Basic, inheriting much of SymPy’s functionality. It supports symbolic representations of vector fields, differential forms, and tensor fields. DGCV objects dynamically manage coordinate transformations between real and holomorphic coordinates during computation. It also has dedicated classes for representing common differential geometric structures like Riemannian metrics and Kahler structures. Custom LaTeX rendering provides a clean visual representation of mathematical objects, ideal for sharing ideas in Jupyter notebooks.
+
+Install DGCV directly from PyPI with pip:
+```bash
+pip install DGCV
+```
+
+Note that on macOS/Linux, use `python3` before `pip`, while on Windows, use `py`.
+
+For more information, visit the DGCV documentation.
+
+Two Jupyter Notebook tutorials are available to help with DGCV:
+
+- **DGCV Introduction:** An introduction to key concepts and setup. [View Tutorial](https://www.realandimaginary.com/dgcv/tutorials/DGCV_introduction/)
+- **DGCV in Action:** A quick tour through examples from the library’s functions. [View Tutorial](https://www.realandimaginary.com/dgcv/tutorials/DGCV_in_action/)
+
+To run the tutorials locally, clone the DGCV GitHub repository and navigate to the tutorials folder. Use Jupyter to open the corresponding notebooks. Alternatively, download the tutorials from the repository.
+
+DGCV documentation is hosted at [https://www.realandimaginary.com/dgcv/](https://www.realandimaginary.com/dgcv/), with documentation for each library function. Full documentation is under development, so refer to the docstrings for more information.
+
+DGCV is licensed under the MIT License. See the `LICENSE.txt` file for details.
+
+David Sykes created and maintains DGCV.
+The current (0.x.x) version of DGCV serves as a foundation for future updates. Planned additions include:
+
+- Extending complex variable handling and dynamic coordinate-type conversion automations. This aims to fully automate handling of complex variable formats, allowing input with any coordinate type and control over formatting. The current API meets this goal for core classes but not ancillary classes, such as differential forms and general tensor fields.
+- Expanding libraries for specialized areas of differential geometry, including Symplect/Contact Hamiltonian formalism, CR structures, Riemannian and Kahler, Sasakian, etc.
+
+Contributions and feedback are welcome.
+Stay tuned for more updates!

dgcv-0.2.3/README.md

@@ -0,0 +1,32 @@
+DGCV is an open-source Python package for differential geometry with complex variables. It provides symbolic representations of standard DG objects like vector fields and differential forms in complex coordinate systems. DGCV tracks natural relationships between complex geometric objects constructed from complex variables. This uniform integration allows smooth switching between real and holomorphic coordinate representations. DGCV classes dynamically manage format switching, so complex variables formulas work without conversion. For example, expressions like $\frac{\partial}{\partial x_j}|z_j|^2$ or $d z_j \wedge d \overline{z_j} \left( \frac{\partial}{\partial z_j}, \frac{\partial}{\partial y_j} \right)$ are parsed correctly. Retrieving complex structure-related attributes, like the holomorphic part of a vector field or pluriharmonic terms from a polynomial, is straightforward. Complexified cotangent bundles and their exterior algebras can be decomposed into components from the Dolbeault complex and Dolbeault operators applied to functions and k-forms in either coordinate format.
+
+DGCV, developed with Python 3.12, integrates SymPy objects within its data structures and subclasses from SymPy.Basic, inheriting much of SymPy’s functionality. It supports symbolic representations of vector fields, differential forms, and tensor fields. DGCV objects dynamically manage coordinate transformations between real and holomorphic coordinates during computation. It also has dedicated classes for representing common differential geometric structures like Riemannian metrics and Kahler structures. Custom LaTeX rendering provides a clean visual representation of mathematical objects, ideal for sharing ideas in Jupyter notebooks.
+
+Install DGCV directly from PyPI with pip:
+```bash
+pip install DGCV
+```
+
+Note that on macOS/Linux, use `python3` before `pip`, while on Windows, use `py`.
+
+For more information, visit the DGCV documentation.
+
+Two Jupyter Notebook tutorials are available to help with DGCV:
+
+- **DGCV Introduction:** An introduction to key concepts and setup. [View Tutorial](https://www.realandimaginary.com/dgcv/tutorials/DGCV_introduction/)
+- **DGCV in Action:** A quick tour through examples from the library’s functions. [View Tutorial](https://www.realandimaginary.com/dgcv/tutorials/DGCV_in_action/)
+
+To run the tutorials locally, clone the DGCV GitHub repository and navigate to the tutorials folder. Use Jupyter to open the corresponding notebooks. Alternatively, download the tutorials from the repository.
+
+DGCV documentation is hosted at [https://www.realandimaginary.com/dgcv/](https://www.realandimaginary.com/dgcv/), with documentation for each library function. Full documentation is under development, so refer to the docstrings for more information.
+
+DGCV is licensed under the MIT License. See the `LICENSE.txt` file for details.
+
+David Sykes created and maintains DGCV.
+The current (0.x.x) version of DGCV serves as a foundation for future updates. Planned additions include:
+
+- Extending complex variable handling and dynamic coordinate-type conversion automations. This aims to fully automate handling of complex variable formats, allowing input with any coordinate type and control over formatting. The current API meets this goal for core classes but not ancillary classes, such as differential forms and general tensor fields.
+- Expanding libraries for specialized areas of differential geometry, including Symplect/Contact Hamiltonian formalism, CR structures, Riemannian and Kahler, Sasakian, etc.
+
+Contributions and feedback are welcome.
+Stay tuned for more updates!

{dgcv-0.2.2 → dgcv-0.2.3}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 requires-python = ">=3.6"
 name = "DGCV"
-version = "0.2.2"
+version = "0.2.3"
 description = "Differential Geometry with Complex Variables"
 authors = [{ name = "David Sykes", email = "david@realandimaginary.com" }]
 license = { text = "MIT" }
@@ -15,3 +15,22 @@ dependencies = [
     "ipython>=7.0"
 ]
 readme = "README.md"
+
+[tool.black]
+line-length = 88
+skip-string-normalization = true
+include = '\.pyi?$'  # Include both Python (.py) and type hint stub (.pyi) files
+exclude = '''
+/(
+    \.git
+  | \.hg
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | _build
+  | buck-out
+  | build
+  | dist
+)/
+'''
+target-version = ["py36"]  # Use Python 3.6+ compatible syntax

{dgcv-0.2.2 → dgcv-0.2.3}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = DGCV
-version = 0.2.2
+version = 0.2.3
 description = A package for Differential Geometry with Complex Variables
 author = David Sykes
 author_email = david@realandimaginary.com

{dgcv-0.2.2 → dgcv-0.2.3}/setup.py

@@ -15,20 +15,16 @@ To get started, check out the Jupyter Notebook tutorials:
 
 setup(
     name="DGCV",
-    version="0.2.2",
+    version="0.2.3",
     description="Differential Geometry with Complex Variables",
     long_description=long_description,  # This shows up on PyPI
-    long_description_content_type='text/markdown',
+    long_description_content_type="text/markdown",
     package_dir={"": "src"},  # This tells setuptools that packages are under src/
     packages=find_packages(where="src"),
     package_data={
-        'DGCV': ['assets/fonts/*.ttf', 'assets/fonts/fonts.css'],  # Include font files
+        "DGCV": ["assets/fonts/*.ttf", "assets/fonts/fonts.css"],  # Include font files
     },
     include_package_data=True,
-    python_requires='>=3.6',
-    install_requires=[
-        'sympy>=1.9',
-        'pandas>=1.0',
-        'ipython>=7.0'
-    ],
+    python_requires=">=3.6",
+    install_requires=["sympy>=1.9", "pandas>=1.0", "ipython>=7.0"],
 )

{dgcv-0.2.2 → dgcv-0.2.3}/src/DGCV/CRGeometry.py

@@ -23,14 +23,12 @@ License:
     MIT License
 """
 
-
-
 ############## dependencies
 from sympy import eye, expand, Matrix, numer, poly_from_expr, solve, Transpose, Symbol
 from functools import reduce
 from .config import _cached_caller_globals
 from .combinatorics import *
-from .classesAndVariables import *
+from .DGCore import *
 from .vectorFieldsAndDifferentialForms import *
 from .polynomials import *
 from ._safeguards import retrieve_passkey
@@ -38,14 +36,15 @@ from ._safeguards import retrieve_passkey
 
 ############## CR geometry
 
-def tangencyObstruction(arg1,arg2,arg3,*args):
+
+def tangencyObstruction(arg1, arg2, arg3, *args):
     """
     Computes the tangency obstruction for a holomorphic vector field with respect to a CR hypersurface.
-    
-    This function computes the Lie derivative of the real part of a holomorphic vector field applied 
+
+    This function computes the Lie derivative of the real part of a holomorphic vector field applied
     to the defining equation of a CR hypersurface and then substitutes the defining equation into the result.
     The output is zero (up to simplification) if and only if the vector field is a symmetry of the hypersurface.
-    
+
     Parameters:
     -----------
     arg1 : VFClass
@@ -54,34 +53,43 @@ def tangencyObstruction(arg1,arg2,arg3,*args):
         The defining function of the CR hypersurface, expressed in holomorphic or real variables.
     arg3 : sympy symbol
         The real variable whose value is set equal to the defining function to define the hypersurface.
-    
+
     Returns:
     --------
     sympy expression
         The tangency obstruction.
-    
+
     Raises:
     -------
     TypeError
         If the first argument is not a VFClass instance with DGCVType='complex'.
     """
-    if isinstance(arg1,VFClass):
-        if arg1.DGCVType == 'standard':
-            raise TypeError('`tangencyObstruction` requires its first argument `vf` to be VFClass with vf.DGCVType=\'complex\'')
+    if isinstance(arg1, VFClass):
+        if arg1.DGCVType == "standard":
+            raise TypeError(
+                "`tangencyObstruction` requires its first argument `vf` to be VFClass with vf.DGCVType='complex'"
+            )
     else:
-        raise TypeError('`tangencyObstruction` requires its first argument `vf` to be VFClass with vf.DGCVType=\'complex\'')
-    arg1=allToReal(arg1)
-    evaluationLoc=allToReal(realPartOfVF(arg1)(holToReal(arg3-arg2))).subs(holToReal(symToReal(arg3)),symToReal(arg2))
+        raise TypeError(
+            "`tangencyObstruction` requires its first argument `vf` to be VFClass with vf.DGCVType='complex'"
+        )
+    arg1 = allToReal(arg1)
+    evaluationLoc = allToReal(realPartOfVF(arg1)(holToReal(arg3 - arg2))).subs(
+        holToReal(symToReal(arg3)), symToReal(arg2)
+    )
     return simplify(symToReal(evaluationLoc))
 
-def weightedHomogeneousVF(arg1,arg2,arg3,arg4,degreeCap=0,_tempVar=None,assumeReal=None):
+
+def weightedHomogeneousVF(
+    arg1, arg2, arg3, arg4, degreeCap=0, _tempVar=None, assumeReal=None
+):
     """
     Creates a weighted homogeneous vector field in a given coordinate space.
-    
-    This function generates a general weighted homogeneous vector field in the space of variables provided 
-    in *arg1*, with weights specified in *arg3*. The polynomial degree of variables with zero weight can 
+
+    This function generates a general weighted homogeneous vector field in the space of variables provided
+    in *arg1*, with weights specified in *arg3*. The polynomial degree of variables with zero weight can
     be bounded by *degreeCap*.
-    
+
     Parameters:
     -----------
     arg1 : tuple or list
@@ -98,28 +106,57 @@ def weightedHomogeneousVF(arg1,arg2,arg3,arg4,degreeCap=0,_tempVar=None,assumeRe
         Internal key.
     assumeReal : bool, optional
         Whether to assume the variables are real (default is False).
-    
+
     Returns:
     --------
     VFClass
         A weighted homogeneous vector field.
-    
+
     Raises:
     -------
     NA
     """
-    pListLoc=[]
+    pListLoc = []
     for j in range(len(arg3)):
-        pListLoc.append(createPolynomial(arg4+'_'+str(j)+'_',arg2+arg3[j],arg1,degreeCap=degreeCap,weightedHomogeneity=arg3,_tempVar=_tempVar,assumeReal=assumeReal))
-    return reduce(addVF,[scaleVF(pListLoc[j],eval('D_'+str(arg1[j]),_cached_caller_globals)) for j in range(len(arg1))])
-def findWeightedCRSymmetries(arg1,arg2,arg3,arg4,arg5,arg6,degreeCap=0,returnVectorFieldBasis=False,applyNumer=False,simplifyingFactor=None):
+        pListLoc.append(
+            createPolynomial(
+                arg4 + "_" + str(j) + "_",
+                arg2 + arg3[j],
+                arg1,
+                degreeCap=degreeCap,
+                weightedHomogeneity=arg3,
+                _tempVar=_tempVar,
+                assumeReal=assumeReal,
+            )
+        )
+    return reduce(
+        addVF,
+        [
+            scaleVF(pListLoc[j], eval("D_" + str(arg1[j]), _cached_caller_globals))
+            for j in range(len(arg1))
+        ],
+    )
+
+
+def findWeightedCRSymmetries(
+    arg1,
+    arg2,
+    arg3,
+    arg4,
+    arg5,
+    arg6,
+    degreeCap=0,
+    returnVectorFieldBasis=False,
+    applyNumer=False,
+    simplifyingFactor=None,
+):
     """
     ***This function's algorithm will be revised in future updates***
 
     Attempts to find all infinitesimal symmetries of a rigid CR hypersurface given by setting one variable *arg5* equal to a defining function *arg1* in the variable space *arg2* with weighted homogeneity *arg3* w.r.t. to non-negative integer weights in *arg4*. Variables in the returned vector field's coefficients are labeled by *arg6*.
 
     Only polynomial vector fields are searched for, so if a variable is assigned weight zero, the function cannot search across general symmetries. In such cases, it rather searches all possible symmetries with polynomial degree in the zero-weighted variables up to the specified bound *degreeCap*. If *degreeCap* is not specified, then it defaults to zero.
-    
+
     The algorithm is most succesful when the function *arg1* must be a polynomial.
 
     The function *arg1* should not depend on the variable *arg5* (i.e., the algorithm is not intended for implicit defining equations). If there is such dependence *findWeightedCRSymmetries* may still find some but not all symmetries.
@@ -134,68 +171,106 @@ def findWeightedCRSymmetries(arg1,arg2,arg3,arg4,arg5,arg6,degreeCap=0,returnVec
         arg6: str
         degreeCap: (optional keyword) set this keyword argument equal to any positive integer. If not specified, it defaults to zero.
         applyNumer: (optional keyword) True or False. Set equal to true if defining equation is rational but not polynomial. It can help the internal solvers.
-    
+
     Returns:
         coefficient list for a holomorphic vector field containing variables, and any set real value for these variables defines an infinitesimal symmetry. **Note, indeed only real values for the variables define actual symmetries**
-    
+
     Raises:
         NA
     """
+
     def extractRIVar(arg1):
-        return sum([list(holToReal(j).atoms(Symbol)) for j in arg1],[])
-    VFLoc=addVF(weightedHomogeneousVF(arg2,arg4,arg3,'ALoc',_tempVar=retrieve_passkey(),degreeCap=degreeCap,assumeReal=True),scaleVF(I,weightedHomogeneousVF(arg2,arg4,arg3,'BLoc',_tempVar=retrieve_passkey(),degreeCap=degreeCap,assumeReal=True)))
-    tOLoc=tangencyObstruction(VFLoc,arg1,arg5,arg2)
-    varLoc=tOLoc.atoms(Symbol)
-    varLoc1={j for j in varLoc}
-    varComp=set(extractRIVar(arg2))
+        return sum([list(holToReal(j).atoms(Symbol)) for j in arg1], [])
+
+    VFLoc = addVF(
+        weightedHomogeneousVF(
+            arg2,
+            arg4,
+            arg3,
+            "ALoc",
+            _tempVar=retrieve_passkey(),
+            degreeCap=degreeCap,
+            assumeReal=True,
+        ),
+        scaleVF(
+            I,
+            weightedHomogeneousVF(
+                arg2,
+                arg4,
+                arg3,
+                "BLoc",
+                _tempVar=retrieve_passkey(),
+                degreeCap=degreeCap,
+                assumeReal=True,
+            ),
+        ),
+    )
+    tOLoc = tangencyObstruction(VFLoc, arg1, arg5, arg2)
+    varLoc = tOLoc.atoms(Symbol)
+    varLoc1 = {j for j in varLoc}
+    varComp = set(extractRIVar(arg2))
     varLoc.difference_update(varComp)
     varLoc1.difference_update(varLoc)
     varComp.difference_update(varLoc1)
-    variableProcedure(arg6,len(varLoc),assumeReal=True)
-    if applyNumer==True:
-        if varLoc1==set():
-            varLoc1=set(arg2)
-        coefListLoc=poly_from_expr(expand(numer(tOLoc)),*varLoc1)[0].coeffs()
-        solLoc=solve(coefListLoc,varLoc)
-    elif simplifyingFactor==None:
-        if varLoc1==set():
-            varLoc1=set(arg2)
-        coefListLoc=poly_from_expr(expand(tOLoc),*varLoc1)[0].coeffs()
-        solLoc=solve(coefListLoc,varLoc)
+    variableProcedure(arg6, len(varLoc), assumeReal=True)
+    if applyNumer == True:
+        if varLoc1 == set():
+            varLoc1 = set(arg2)
+        coefListLoc = poly_from_expr(expand(numer(tOLoc)), *varLoc1)[0].coeffs()
+        solLoc = solve(coefListLoc, varLoc)
+    elif simplifyingFactor == None:
+        if varLoc1 == set():
+            varLoc1 = set(arg2)
+        coefListLoc = poly_from_expr(expand(tOLoc), *varLoc1)[0].coeffs()
+        solLoc = solve(coefListLoc, varLoc)
     else:
-        if varLoc1==set():
-            varLoc1=set(arg2)
-        coefListLoc=poly_from_expr(expand(simplify(symToReal(simplifyingFactor)*tOLoc)),*varLoc1)[0].coeffs()
-        solLoc=solve(coefListLoc,varLoc)
-    if solLoc==[]:
-        clearVar(*listVar(temporary_only=True),report=False)
-        return 'no solution'
-    elif type(solLoc)==dict:
-        VFCLoc=[j.subs(solLoc) for j in holVF_coeffs(VFLoc,arg2)]
-        subVar=sum(VFCLoc).atoms(Symbol)
+        if varLoc1 == set():
+            varLoc1 = set(arg2)
+        coefListLoc = poly_from_expr(
+            expand(simplify(symToReal(simplifyingFactor) * tOLoc)), *varLoc1
+        )[0].coeffs()
+        solLoc = solve(coefListLoc, varLoc)
+    if solLoc == []:
+        clearVar(*listVar(temporary_only=True), report=False)
+        return "no solution"
+    elif type(solLoc) == dict:
+        VFCLoc = [j.subs(solLoc) for j in holVF_coeffs(VFLoc, arg2)]
+        subVar = sum(VFCLoc).atoms(Symbol)
         subVar.difference_update(set(arg2))
-        variableProcedure(arg6,len(subVar),assumeReal=True)
-        VFCLoc=[j.subs(dict(zip(subVar,eval(arg6,_cached_caller_globals)))) for j in VFCLoc]
-        clearVar(*listVar(temporary_only=True),report=False)
-        if returnVectorFieldBasis==True:
-            VFListLoc=[]
-            for j in eval(arg6,_cached_caller_globals):
-                VFCLocTemp=[k.subs(j,1).subs([(l,0) for l in eval(arg6,_cached_caller_globals)]) for k in VFCLoc]
-                VFListLoc.append(assembleFromHolVFC(VFCLocTemp,arg2))
-            clearVar(arg6,report=False)
+        variableProcedure(arg6, len(subVar), assumeReal=True)
+        VFCLoc = [
+            j.subs(dict(zip(subVar, eval(arg6, _cached_caller_globals))))
+            for j in VFCLoc
+        ]
+        clearVar(*listVar(temporary_only=True), report=False)
+        if returnVectorFieldBasis == True:
+            VFListLoc = []
+            for j in eval(arg6, _cached_caller_globals):
+                VFCLocTemp = [
+                    k.subs(j, 1).subs(
+                        [(l, 0) for l in eval(arg6, _cached_caller_globals)]
+                    )
+                    for k in VFCLoc
+                ]
+                VFListLoc.append(assembleFromHolVFC(VFCLocTemp, arg2))
+            clearVar(arg6, report=False)
             return VFListLoc, VFCLoc
         else:
             return VFCLoc
-    else: 
-        VFCLoc=holVF_coeffs(VFLoc,arg2)
-        subVar=sum(VFCLoc).atoms(Symbol)
+    else:
+        VFCLoc = holVF_coeffs(VFLoc, arg2)
+        subVar = sum(VFCLoc).atoms(Symbol)
         subVar.difference_update(set(arg2))
-        variableProcedure(arg6,len(subVar),assumeReal=True)
-        VFCLoc=[j.subs(dict(zip(subVar,eval(arg6,_cached_caller_globals)))) for j in VFCLoc]
-        clearVar(*listVar(temporary_only=True),report=False)
-        return VFCLoc,solLoc
+        variableProcedure(arg6, len(subVar), assumeReal=True)
+        VFCLoc = [
+            j.subs(dict(zip(subVar, eval(arg6, _cached_caller_globals))))
+            for j in VFCLoc
+        ]
+        clearVar(*listVar(temporary_only=True), report=False)
+        return VFCLoc, solLoc
+
 
-def model2Nondegenerate(arg1,arg2,arg3,arg4, return_matrices = False):
+def model2Nondegenerate(arg1, arg2, arg3, arg4, return_matrices=False):
     """
     Builds the defining equation for a 2-nondegnerate model hypersurface using the general formula from the arXiv preprint arXiv:2404.06525.
 
@@ -204,23 +279,57 @@ def model2Nondegenerate(arg1,arg2,arg3,arg4, return_matrices = False):
         arg2: s-by-s symmetric matrix valued function of some complex variables whose differential at zero is injective, and whose value at zero is zero.
         arg3: a length s tuple of complex variables, different from those appearing in *arg2*
         arg4: a single complex variable, different from those appearing in *arg2* and *arg3*
-    
+
     Returns:
         A sympy expression. Setting this expression equal to zero defines the 2-nondegenerate model.
-    
+
     Raises:
         NA
     """
-    BARSLoc=conjugate(arg2)
-    zVecLoc=Matrix(arg3)
-    bzVecLoc=Matrix([conjugate(j) for j in arg3])
-    sizeLoc=arg1.shape[0]
-    hFun=(Rational(1,2))*((arg1*(eye(sizeLoc)-(BARSLoc*Transpose(arg1)*arg2*arg1))**(-1))+((eye(sizeLoc)-(arg1*BARSLoc*Transpose(arg1)*arg2))**(-1)*arg1))
-    sFun=arg1*((eye(sizeLoc)-(BARSLoc*Transpose(arg1)*arg2*arg1))**(-1))*BARSLoc*Transpose(arg1)
-    bsFun=Transpose(arg1)*((eye(sizeLoc)-(arg2*arg1*BARSLoc*Transpose(arg1)))**(-1))*arg2*arg1
+    BARSLoc = conjugate(arg2)
+    zVecLoc = Matrix(arg3)
+    bzVecLoc = Matrix([conjugate(j) for j in arg3])
+    sizeLoc = arg1.shape[0]
+    hFun = (Rational(1, 2)) * (
+        (arg1 * (eye(sizeLoc) - (BARSLoc * Transpose(arg1) * arg2 * arg1)) ** (-1))
+        + ((eye(sizeLoc) - (arg1 * BARSLoc * Transpose(arg1) * arg2)) ** (-1) * arg1)
+    )
+    sFun = (
+        arg1
+        * ((eye(sizeLoc) - (BARSLoc * Transpose(arg1) * arg2 * arg1)) ** (-1))
+        * BARSLoc
+        * Transpose(arg1)
+    )
+    bsFun = (
+        Transpose(arg1)
+        * ((eye(sizeLoc) - (arg2 * arg1 * BARSLoc * Transpose(arg1))) ** (-1))
+        * arg2
+        * arg1
+    )
     if return_matrices == True:
-        return simplify((Transpose(zVecLoc)*hFun*bzVecLoc+(Rational(1,2))*(Transpose(zVecLoc)*sFun*zVecLoc+Transpose(bzVecLoc)*bsFun*bzVecLoc))[0])-im(arg4),hFun,sFun
+        return (
+            simplify(
+                (
+                    Transpose(zVecLoc) * hFun * bzVecLoc
+                    + (Rational(1, 2))
+                    * (
+                        Transpose(zVecLoc) * sFun * zVecLoc
+                        + Transpose(bzVecLoc) * bsFun * bzVecLoc
+                    )
+                )[0]
+            )
+            - im(arg4),
+            hFun,
+            sFun,
+        )
     else:
-        return simplify((Transpose(zVecLoc)*hFun*bzVecLoc+(Rational(1,2))*(Transpose(zVecLoc)*sFun*zVecLoc+Transpose(bzVecLoc)*bsFun*bzVecLoc))[0])-im(arg4)
-
-
+        return simplify(
+            (
+                Transpose(zVecLoc) * hFun * bzVecLoc
+                + (Rational(1, 2))
+                * (
+                    Transpose(zVecLoc) * sFun * zVecLoc
+                    + Transpose(bzVecLoc) * bsFun * bzVecLoc
+                )
+            )[0]
+        ) - im(arg4)