DGCV 0.1.0__tar.gz

dgcv-0.1.0/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dgcv-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include assets/fonts/*.ttf
+include assets/fonts/*.css
+recursive-include assets/fonts *.ttf

dgcv-0.1.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.1
+Name: DGCV
+Version: 0.1.0
+Summary: Differential Geometry with Complex Variables
+Author: David Sykes
+Author-email: sykes@ibs.re.kr
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+
+
+# DGCV - Differential Geometry with Complex Variables
+
+DGCV integrates basic tools for differential geometry with systematic handling of with complex variabless-related structures.
+
+## Tutorials
+
+To get started, check out the Jupyter Notebook tutorials:
+
+- **[DGCV Introduction](https://github.com/YikesItsSykes/DGCV/blob/main/tutorials/DGCV_introduction.ipynb)**: A beginner's guide to setting up and using DGCV.
+- **[DGCV in Action](https://github.com/YikesItsSykes/DGCV/blob/main/tutorials/DGCV_in_action.ipynb)**: An advanced tutorial demonstrating DGCV in action.
+

dgcv-0.1.0/README.md

@@ -0,0 +1,70 @@
+# DGCV: Differential Geometry with Complex Variables
+###### ----by David Sykes----
+
+DGCV is an open-source Python package providing basic tools for differential geometry integrated with systematic organization of structures accompanying complex variables, in short, Differential Geometry with Complex Variables.
+
+At its core are fully featured symbolic representations of standard DG objects such as vector fields and differential forms, defined relative to standard or complex coordinate systems. As systems of differential geometric objects constructed from complex variables inherit natural relationships from the underlying complex structure, DGCV tracks these relationships across the constructions. Immediate advantages of the uniform integration are seen in smooth switching between real and holomorphic coordinate representations of mathematical objects. In computations, DGCV classes dynamically manage this format switching on their own so that typical complex variables formulas can be written plainly and will simply work. Some examples of this: In coordinates $z_j = x_j + iy_j$, expressions such as $\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 correctly parsed without needing to convert everything to a uniform variable format. Retrieving objects' 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 are easily decomposed into components from the Dolbeault complex and Dolbeault operators themselves can be applied to functions and k-forms in either coordinate format.
+
+DGCV was developed using Python 3.12, with dependencies on the SymPy and Pandas libraries in addition to base Python. Its classes integrate SymPy objects within their data structures and subclass from SymPy.Basic, thereby inheriting much of SymPy’s functionality. For instance, one can apply sympy.simplify() directly to most DGCV class objects. Developing complete compatibility with SymPy is a goal still in progress. Pandas is used to format and display data in a more readable manner.
+
+## Features
+- Fully featured symbolic representations of vector fields, differential forms, and tensor fields
+- Intuitive interactions with complex structures from holomorphic coordinate systems: DGCV objects dynamically manage coordinate transformations between real and holomorphic coordinates during computation as necessary, so objects can be represented in and freely switch between either coordinate format at any time. 
+- Dedicated python classes for representing common differential geometric structures including Riemannian metrics, Kahler structures, and more
+- Custom LaTeX Rendering: Integrated LaTeX support for clean visual representation of mathematical objects.
+
+## Installation
+
+You can install DGCV directly from PyPI with pip:
+
+```bash
+pip install DGCV
+```
+
+Alternatively, if you want to install DGCV locally (e.g., for development):
+
+```bash
+git clone https://github.com/YikesItsSykes/DGCV.git
+cd DGCV
+pip install .
+```
+
+## Tutorials
+
+Two Jupyter Notebook tutorials are available to help getting started with DGCV:
+
+1. **DGCV Introduction**: A basic introduction to the key concepts and setup.
+   - [View DGCV Introduction Tutorial](tutorials/DGCV_introduction.ipynb)
+
+2. **DGCV in Action**: A quick tour through examples of some of DGCV's more advanced functions
+   - [View DGCV in Action Tutorial](tutorials/DGCV_in_action.ipynb)
+
+### Running the Tutorials Locally
+
+If you have cloned this repository, you can run the tutorials locally with Jupyter:
+
+```bash
+git clone https://github.com/YikesItsSykes/DGCV.git
+cd DGCV/tutorials
+jupyter notebook DGCV_introduction.ipynb
+jupyter notebook DGCV_in_action.ipynb
+```
+
+## Documentation
+Full documentation is under development. For now, refer to the docstrings within the code for more information on available methods and functionality.
+
+## License
+DGCV is licensed under the MIT License. See the `LICENSE.txt` file for more information.
+
+## Author
+DGCV was created and is maintained by [David Sykes](https://github.com/YikesItsSykes).
+
+---
+
+### Future Development
+The current (0.x.x) version of DGCV is a stable scafolding, as it were, upon which a lot more can be built. Many additions for future updates are currently planned. Current plans include:
+- Expanding libraries dedicated to specialized areas of differential geometry including, Symplect/Contact Hamiltonian formalism, CR structures, Riemannian and Kahler, Sasakian, etc.
+- A more comprehensive API for complex variable handling and dynamic coordinate-type conversions. The simple goal is to fully automate handling of complex variable formats, allowing users to work freely with any coordinate type. The current system meets this goal for the for interactions with DGCV's core classes, but it is not fully extended to some ancillary classes.
+
+Contributions and feedback from anyone interested are warmly welcomed.
+Stay tuned for more updates!

dgcv-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"

dgcv-0.1.0/setup.cfg

@@ -0,0 +1,21 @@
+[metadata]
+name = DGCV
+version = 0.1.0
+description = A package for Differential Geometry with Complex Variables
+author = David Sykes
+author_email = sykes@ibs.re.kr
+
+[options]
+package_dir = 
+	= src
+packages = find:
+include_package_data = True
+python_requires = >=3.6
+
+[options.package_data]
+DGCV = assets/fonts/*.ttf, assets/fonts/fonts.css
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

dgcv-0.1.0/setup.py

@@ -0,0 +1,31 @@
+from setuptools import setup, find_packages
+
+long_description = """
+# DGCV - Differential Geometry with Complex Variables
+
+DGCV integrates basic tools for differential geometry with systematic handling of with complex variabless-related structures.
+
+## Tutorials
+
+To get started, check out the Jupyter Notebook tutorials:
+
+- **[DGCV Introduction](https://github.com/YikesItsSykes/DGCV/blob/main/tutorials/DGCV_introduction.ipynb)**: A beginner's guide to setting up and using DGCV.
+- **[DGCV in Action](https://github.com/YikesItsSykes/DGCV/blob/main/tutorials/DGCV_in_action.ipynb)**: An advanced tutorial demonstrating DGCV in action.
+
+"""
+
+setup(
+    name="DGCV",
+    version="0.1.0",
+    description="Differential Geometry with Complex Variables",
+    long_description=long_description,  # This shows up on PyPI
+    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
+    },
+    include_package_data=True
+)
+
+

dgcv-0.1.0/src/DGCV/CRGeometry.py

@@ -0,0 +1,175 @@
+############## 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 .vectorFieldsAndDifferentialForms import *
+from .polynomials import *
+from ._safeguards import retrieve_passkey
+
+
+############## CR geometry
+
+def tangencyObstruction(arg1,arg2,arg3,*args):
+    """
+    Computes the Lie derivative of a holomorphic vector field's real part applied to a graph defining a CR hypersurface, then substitutes the defining equation into the result.
+
+    Returns 0 (up to simplification) if and only if the vector field is a symmetry of the hypersurface.
+
+    Arguments must be expressions w.r.t. a complex coordinate system initialized by *complexVarProc*
+
+    Args:
+        arg1: VFClass class instance in the form of a holomorphic vector field (for example, a VF initialized by *assembleFromHolVFC*)
+        arg2: Defining function of CR hypersurface in holomorphic or real variables format (i.e., a real-valued function of the complex parameter space depending on some but not all of the real and imaginaray parts of the complex variables)
+        arg3: The real variable that when set equal to the defining function defines the CR hypersurface.
+    
+    Returns:
+        A sympy expression.
+    
+    Raises:
+        NA
+    """
+    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))
+    return simplify(symToReal(evaluationLoc))
+
+def weightedHomogeneousVF(arg1,arg2,arg3,arg4,degreeCap=0,_tempVar=None,assumeReal=None):
+    """
+    Creates a general weighted homogeneous vector field (i.e., VFClass instance) in the coordinate space of variables in *arg1* of weight *arg2* w.r.t. weights in *arg3*. Variables for the coefficients in the vector field are created with the label *arg4*.
+
+    If variable weights assigned are nonzero then the returned vector field is truly general. Otherwise the returned vector field is the general one with polynomial degree in the zero-weight variables bounded by *degreeCap* which can be set to any integer. If *degreeCap* is not specified then it defaults to zero.
+
+    Args:
+        arg1: a tuple/list of variables initialized by either *varWithVF* or *complexVarProc*
+        arg2: int
+        arg3: list of non-negative integer weights corresponding to the variables in *arg1* (must have the same length as *arg1*). If 0 is among the weights, then then proceedure will only test polynomial vector fields with polynomial degree in the weight zero variables up to the weight specified in *degreeCap*. By default, degreeCap=0, and can be set to any positive integer.
+        arg4: str
+        _tempVar: (optional keyword) internal key
+        assumeReal: (optional keyword) True or False
+        degreeCap: (optional keyword) set this keyword argument equal to any positive integer. If not specified, it defaults to zero.
+
+    
+    Returns:
+        A vector field (i.e., VFClass instance)
+    
+    Raises:
+        NA
+    """
+    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):
+    """
+    ***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.
+
+
+    Args:
+        arg1: Defining function of a rigid CR hypersurface.
+        arg2: a tuple or list of complex variables parameterizing the space that the above CR hypersurface is defined in (not including the transverse direction symmetry).
+        arg3: list of non-negative integer weights corresponding to the variables in *arg1* (must have the same length as *arg1*). If 0 is among the weights, then then proceedure will only test polynomial vector fields with polynomial degree in the weight zero variables up to the weight specified in *degreeCap*. By default, degreeCap=0, and can be set to any positive integer.
+        arg4: int
+        arg5: The real variable that when set equal to the defining function defines the CR hypersurface.
+        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))
+    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)
+    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)
+        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)
+            return VFListLoc, VFCLoc
+        else:
+            return VFCLoc
+    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
+
+def model2Nondegenerate(arg1,arg2,arg3,arg4):
+    """
+    Builds the defining equation for a 2-nondegnerate model hypersurface using the general formula from the arXiv preprint arXiv:2404.06525.
+
+    Args:
+        arg1: nondegenerate s-by-s hermitian matrix
+        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
+    return simplify((Transpose(zVecLoc)*hFun*bzVecLoc+(Rational(1,2))*(Transpose(zVecLoc)*sFun*zVecLoc+Transpose(bzVecLoc)*bsFun*bzVecLoc))[0])-im(arg4)
+

dgcv-0.1.0/src/DGCV/DGCVFormatter.py

@@ -0,0 +1,215 @@
+import re
+from pandas import DataFrame, MultiIndex
+from .config import get_variable_registry, greek_letters
+from .styles import get_style
+
+
+# Modular function to collect data for complex, standard, and algebra variables
+def collect_variable_data(variable_registry, use_latex):
+    data = [['Number of Var.', 'Real Part', 'Imaginary Part', 'Vector Fields', 'Differential Forms']]
+    index = []
+
+    complex_vars = sorted(variable_registry.get('complex_variable_systems', {}).keys())
+    standard_vars = sorted(variable_registry.get('standard_variable_systems', {}).keys())
+    finite_algebra_vars = sorted(variable_registry.get('finite_algebra_systems', {}).keys())
+
+    # Process complex variables
+    for var_name in complex_vars:
+        process_variable(var_name, 'complex', variable_registry, data, index, use_latex)
+
+    # Process standard variables
+    for var_name in standard_vars:
+        process_variable(var_name, 'standard', variable_registry, data, index, use_latex)
+
+    # Process finite algebra systems
+    for var_name in finite_algebra_vars:
+        process_algebra(var_name, variable_registry, data, index, use_latex)
+
+    return data, index
+
+
+# Function to process complex and standard variables
+def process_variable(var_name, system_type, variable_registry, data, index, use_latex):
+    # Common logic for both standard and complex variable systems
+    family_type = variable_registry[f'{system_type}_variable_systems'][var_name].get('family_type', 'single')
+    family_names = variable_registry[f'{system_type}_variable_systems'][var_name]['family_names']
+    initial_index = variable_registry[f'{system_type}_variable_systems'][var_name].get('initial_index', 1)
+    
+    # Logic to process tuple or single variables and append to data
+    tuple_len = len(family_names)
+    real_part, imaginary_part, vf_str, df_str = format_variable_details(var_name, family_names, initial_index, tuple_len, system_type, use_latex)
+    
+    # Append to data
+    data.append([
+        tuple_len,
+        real_part,
+        imaginary_part,
+        vf_str,
+        df_str
+    ])
+
+    # Update the index
+    formatted_name = format_variable_name(var_name, system_type, use_latex)
+    index.append((formatted_name, ''))
+
+
+# Function to process algebra systems
+def process_algebra(var_name, variable_registry, data, index, use_latex):
+    system_data = variable_registry['finite_algebra_systems'][var_name]
+    algebra_family_names = system_data.get('family_names', [])
+    
+    # Format algebra label and basis
+    formatted_str = format_algebra_name(var_name, algebra_family_names, use_latex)
+    
+    # Append to data
+    data.append([len(algebra_family_names), '----', '----', '----', '----'])
+    
+    # Update the index
+    index.append((formatted_str, ''))
+
+
+# Function to build the table
+def build_table(data, index, style):
+    # Build and return the final styled table
+    columns = MultiIndex.from_product([['Initialized Coordinate Systems and Algebras'], ['', '', '', '', '']])
+    table = DataFrame(data=data, index=index, columns=columns)
+
+    # Apply styles and return the table
+    table_styles = get_style(style)
+    return table.style.set_table_styles(table_styles)
+
+# Helper function to format variable details (real part, imaginary part, vector fields, differential forms)
+def format_variable_details(var_name, family_names, initial_index, tuple_len, system_type, use_latex):
+    if system_type == 'complex':
+        variable_registry=get_variable_registry()
+        # Access the real and imaginary parts (assuming they are the 3rd and 4th elements in family_names)
+        family_houses = variable_registry['complex_variable_systems'][var_name]['family_houses']
+        family_names = variable_registry['complex_variable_systems'][var_name]['family_names']
+
+        if len(family_names[2]) > 1:
+            real_part = f"{family_houses[2]} = ({family_names[2][0]}, ..., {family_names[2][-1]})"
+        else:
+            real_part = f"{family_houses[2]} = ({family_names[2][0]})"
+
+        if len(family_names[3]) > 1:
+            imaginary_part = f"{family_houses[3]} = ({family_names[3][0]}, ..., {family_names[3][-1]})"
+        else:
+            imaginary_part = f"{family_houses[3]} = ({family_names[3][0]})"
+
+        vf_str = build_object_string_for_complex('D', family_houses, family_names, initial_index, use_latex)
+        df_str = build_object_string_for_complex('d', family_houses, family_names, initial_index, use_latex)
+        
+    else:  # Standard variables
+        real_part = '----'  # Real part not applicable for standard variables
+        imaginary_part = '----'  # Imaginary part not applicable for standard variables
+        vf_str = build_object_string('D', var_name, initial_index, tuple_len, system_type, use_latex)
+        df_str = build_object_string('d', var_name, initial_index, tuple_len, system_type, use_latex)
+
+    return real_part, imaginary_part, vf_str, df_str
+
+def format_variable_name(var_name, system_type, use_latex=False):
+    variable_registry=get_variable_registry()
+    if system_type == 'standard':
+        family_type = variable_registry['standard_variable_systems'][var_name].get('family_type', 'single')
+        family_names = variable_registry['standard_variable_systems'][var_name]['family_names']
+        initial_index = variable_registry['standard_variable_systems'][var_name].get('initial_index', 1)
+    else:  # system_type == 'complex'
+        family_type = variable_registry['complex_variable_systems'][var_name].get('family_type', 'single')
+        family_names = variable_registry['complex_variable_systems'][var_name]['family_names'][0]  # First tuple entry
+        initial_index = variable_registry['complex_variable_systems'][var_name].get('initial_index', 1)
+
+    # Handle tuple or single variable cases
+    if family_type == 'tuple':
+        first_index = initial_index
+        last_index = initial_index + len(family_names) - 1
+        if use_latex:
+            content = f"{convert_to_greek(var_name)} = \\left( {convert_to_greek(var_name)}_{{{first_index}}}, \\ldots, {convert_to_greek(var_name)}_{{{last_index}}} \\right)"
+        else:
+            content = f"{var_name} = ({family_names[0]}, ..., {family_names[-1]})"
+    else:
+        content = convert_to_greek(var_name) if use_latex else var_name
+
+    return wrap_in_dollars(content) if use_latex else content
+
+def format_algebra_name(var_name, algebra_family_names, use_latex=False):
+    if use_latex:
+        match = re.match(r'(.*?)(\d+)?$', var_name)
+        algebra_name = match.group(1) if match else var_name
+        algebra_number = match.group(2) if match else None
+
+        # Format the algebra name in LaTeX
+        algebra_label = f"\\mathfrak{{{convert_to_greek(algebra_name)}}}" if re.fullmatch(r'[a-z]+', algebra_name) else algebra_name
+        if algebra_number:
+            algebra_label += f"_{{{algebra_number}}}"
+
+        # Format the basis string
+        if len(algebra_family_names) > 1:
+            first_basis_label = process_basis_label(algebra_family_names[0])
+            last_basis_label = process_basis_label(algebra_family_names[-1])
+            basis_str = f"{first_basis_label}, \\ldots, {last_basis_label}"
+        else:
+            basis_str = process_basis_label(algebra_family_names[0]) if algebra_family_names else ""
+        return f"Algebra: {wrap_in_dollars(algebra_label)} \\\\ Basis: {wrap_in_dollars(basis_str)}"
+    else:
+        algebra_label = var_name
+        if len(algebra_family_names) > 1:
+            basis_str = f"{algebra_family_names[0]}, ..., {algebra_family_names[-1]}"
+        else:
+            basis_str = algebra_family_names[0] if algebra_family_names else ""
+        return f"Algebra: {algebra_label}<br>Basis: {basis_str}"
+    
+def build_object_string_for_complex(obj_type, part_names, family_names, start_index, use_latex=False):
+    parts = []
+    for part_name, part in zip(part_names, family_names):
+        if use_latex:
+            base_var = convert_to_greek(part_name.replace('BAR', '', 1)) if part_name.startswith('BAR') else convert_to_greek(part_name)
+            if len(part) > 1:
+                part_str = f"\\overline{{{base_var}_{{{start_index}}}}}, \\ldots, \\overline{{{base_var}_{{{start_index + len(part) - 1}}}}}"
+            else:
+                part_str = f"\\overline{{{base_var}}}" if part_name.startswith('BAR') else base_var
+            parts.append(f"d {part_str}" if obj_type == 'd' else f"\\frac{{\\partial}}{{\\partial {part_str}}}")
+        else:
+            part_str = f"{obj_type}_{convert_to_greek(part_name)}{start_index},...,{convert_to_greek(part_name)}{start_index + len(part) - 1}" if len(part) > 1 else f"{obj_type}_{convert_to_greek(part_name)}"
+            parts.append(part_str)
+    return ', '.join(parts)
+
+def build_object_string(obj_type, var_name, start_index, tuple_len, system_type, use_latex=False):
+    if tuple_len == 1:
+        if use_latex:
+            content = f"d {convert_to_greek(var_name)}" if obj_type == 'd' else f"\\frac{{\\partial}}{{\\partial {convert_to_greek(var_name)}}}"
+        else:
+            content = f"{obj_type}_{var_name}"
+    else:
+        if use_latex:
+            content = f"d {convert_to_greek(var_name)}_{{{start_index}}}, \\ldots, d {convert_to_greek(var_name)}_{{{start_index + tuple_len - 1}}}" if obj_type == 'd' else f"\\frac{{\\partial}}{{\\partial {convert_to_greek(var_name)}_{{{start_index}}}}}, \\ldots, \\frac{{\\partial}}{{\\partial {convert_to_greek(var_name)}_{{{start_index + tuple_len - 1}}}}}"
+        else:
+            content = f"{obj_type}_{var_name}{start_index},...,{obj_type}_{var_name}{start_index + tuple_len - 1}"
+    return wrap_in_dollars(content) if use_latex else content
+
+# Helper function to convert variable names to Greek letters (if applicable)
+def convert_to_greek(var_name):    
+    # Replace variable names with their corresponding Greek letters
+    for name, greek in greek_letters.items():
+        if var_name == name:
+            return greek
+    return var_name
+
+# Helper function to wrap content in LaTeX dollar signs for rendering
+def wrap_in_dollars(content):
+    return f"${content}$"
+
+# Helper function to process basis labels (e.g., e1 -> e_{1})
+def process_basis_label(label):
+    # Use regex to split the name and numeric suffix
+    match = re.match(r'(.*?)(\d+)?$', label)
+    basis_elem_name = match.group(1)  # Alphabetic part
+    basis_elem_number = match.group(2)  # Numeric part, if any
+    
+    # Remove trailing underscores from the name
+    basis_elem_name = basis_elem_name.rstrip('_')
+    
+    # Build the LaTeX string
+    if basis_elem_number:
+        return f"{convert_to_greek(basis_elem_name)}_{{{basis_elem_number}}}"
+    else:
+        return f"{convert_to_greek(basis_elem_name)}"