DGCV 0.1.0__py3-none-any.whl

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/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)}"

DGCV/DGCV_display.py

@@ -0,0 +1,198 @@
+
+"""
+display.py
+
+This module provides functions for customizing font display in Jupyter notebooks.
+The `load_fonts()` function loads web fonts and applies them to the notebook
+environment using HTML and CSS.
+
+Functions
+---------
+- load_fonts: Injects HTML and CSS to load Google Fonts and apply custom fonts to the notebook.
+"""
+import sympy
+from .classesAndVariables import DFClass,VFClass,STFClass,FAClass,DGCVPolyClass,symToHol,symToReal,TFClass,AlgebraElement
+from .RiemannianGeometry import metricClass
+
+from IPython.display import display, HTML, Latex
+
+
+
+from sympy import latex, Basic
+
+def LaTeX(obj,removeBARs=False):
+    """
+    Custom LaTeX function for DGCV.
+    Applies sympy.latex() to the input object, with special handling for lists and tuples.
+    
+    For lists, the elements are LaTeX-processed, stripped of surrounding $ or $$ symbols if present,
+    and wrapped in \left[ ... \right].
+    
+    For tuples, the elements are LaTeX-processed similarly but wrapped in \left( ... \right).
+    
+    Parameters
+    ----------
+    obj : any
+        The object to convert to LaTeX. Can be a SymPy expression, DGCV object, or a list/tuple of such objects.
+    
+    Returns
+    -------
+    str
+        The LaTeX-formatted string.
+    """
+    def filter(term):
+        if removeBARs==True:
+            return latex(term)
+        if isinstance(term,(DFClass,VFClass,STFClass,DGCVPolyClass,TFClass)):
+            if term._varSpace_type == 'real':
+                return latex(symToReal(term))
+            elif term._varSpace_type == 'complex':
+                return latex(symToHol(term))
+            else:
+                return latex(term)
+        elif isinstance(term, FAClass):
+            return _alglabeldisplayclass(term.label)._repr_latex_()
+        elif isinstance(term, AlgebraElement):
+            return _alglabeldisplayclass(term.algebra.label,term)._repr_latex_()
+        else:
+            return latex(symToHol(term))
+        
+    def strip_dollar_signs(latex_str):
+        """Strip leading and trailing $ or $$ signs from a LaTeX string."""
+        # if latex_str == None:
+        #     return ''
+        if latex_str.startswith("$$") and latex_str.endswith("$$"):
+            return latex_str[2:-2]
+        elif latex_str.startswith("$") and latex_str.endswith("$"):
+            return latex_str[1:-1]
+        return latex_str
+
+    if isinstance(obj, list):
+        # Handle lists by applying LaTeX and wrapping with \left[ ... \right]
+        latex_elements = [strip_dollar_signs(filter(elem)) for elem in obj]
+        return r"\left[ " + ", ".join(latex_elements) + r" \right]"
+    
+    elif isinstance(obj, tuple):
+        # Handle tuples by applying LaTeX and wrapping with \left( ... \right)
+        latex_elements = [strip_dollar_signs(filter(elem)) for elem in obj]
+        return r"\left( " + ", ".join(latex_elements) + r" \right)"
+    
+    else:
+        # Apply sympy.latex() for non-list/tuple objects
+        return strip_dollar_signs(filter(obj))
+
+
+def display_DGCV(*args):
+    for j in args:
+        _display_DGCV_single(j)
+
+def _display_DGCV_single(arg):
+    if isinstance(arg,str):
+        display(Latex(arg))
+    elif isinstance(arg,(sympy.Expr,metricClass,DFClass,VFClass,TFClass,STFClass,DGCVPolyClass)):
+        _complexDisplay(arg)
+    elif isinstance(arg,FAClass):
+        _complexDisplay(_alglabeldisplayclass(arg.label))
+    elif isinstance(arg,AlgebraElement):
+        _complexDisplay(_alglabeldisplayclass(arg.algebra.label,ae=arg))
+    else:
+        display(arg)
+
+def _complexDisplay(*args):
+    """
+    Taking DGCV expressions in *args* written in terms of symbolic conjugate variables, displays them with actual complex conjugates
+    """
+    display(*[symToHol(j,simplify_everything=False) for j in args])
+
+
+class _alglabeldisplayclass(Basic):
+
+    def __new__(cls, label, ae = None):
+        obj = Basic.__new__(cls, label)
+        return obj
+
+    def __init__(self, label, ae = None):
+        self.label = str(label)
+        self.ae = ae
+
+    @staticmethod
+    def format_algebra_label(label):
+        """Wrap the algebra label in \mathfrak{} if all characters are lowercase, and subscript any numeric suffix."""
+        if label[-1].isdigit():
+            # Split into text and number parts for subscript formatting
+            label_text = ''.join(filter(str.isalpha, label))
+            label_number = ''.join(filter(str.isdigit, label))
+            if label_text.islower():
+                return rf"\mathfrak{{{label_text}}}_{{{label_number}}}"
+            return rf"{label_text}_{{{label_number}}}"
+        elif label.islower():
+            return rf"\mathfrak{{{label}}}"
+        return label
+    
+    @staticmethod
+    def format_ae(ae):
+        if ae != None:
+            terms = []
+            for coeff, basis_label in zip(ae.coeffs, ae.algebra.basis_labels):
+                if coeff == 0:
+                    continue  # Skip zero terms
+                elif coeff == 1:
+                    terms.append(rf"{basis_label}")  # Suppress 1 as coefficient
+                elif coeff == -1:
+                    terms.append(rf"-{basis_label}")  # Suppress 1 but keep the negative sign
+                else:
+                    # Check if the coefficient has more than one term (e.g., 1 + I)
+                    if isinstance(coeff, sympy.Expr) and len(coeff.args) > 1:
+                        terms.append(rf"({sympy.latex(coeff)}) \cdot {basis_label}")  # Wrap multi-term coefficient in parentheses
+                    else:
+                        terms.append(rf"{sympy.latex(coeff)} \cdot {basis_label}")  # Single-term coefficient
+
+            # Handle special case: all zero coefficients
+            if not terms:
+                return rf"$0 \cdot {ae.algebra.basis_labels[0]}$"
+
+            # Join terms with proper LaTeX sign handling
+            result = " + ".join(terms).replace("+ -", "- ")
+            return rf"{result}"
+    
+    def _repr_latex_(self):
+        if self.ae == None:
+            return _alglabeldisplayclass.format_algebra_label(self.label)
+        else:
+            return _alglabeldisplayclass.format_ae(self.ae)
+    
+    def __str__(self):
+        return self.label
+
+
+def load_fonts():
+    """
+    Load custom web fonts into the Jupyter notebook.
+    
+    This function injects HTML and CSS to load fonts from Google Fonts and sets 
+    the body font to 'Roboto'. It is intended for use in Jupyter notebooks to 
+    customize the appearance of text.
+
+    Fonts Loaded
+    ------------
+    - Orbitron
+    - Press Start 2P
+    - Roboto
+
+    Examples
+    --------
+    >>> load_fonts()
+
+    Notes
+    -----
+    The fonts are applied globally to the notebook interface via CSS.
+    """
+    font_links = """
+    <link href="https://fonts.googleapis.com/css2?family=Orbitron:wght@400;700&family=Press+Start+2P&family=Roboto:wght@400;700&display=swap" rel="stylesheet">
+    <style>
+    body {
+        font-family: 'Roboto', sans-serif;
+    }
+    </style>
+    """
+    display(HTML(font_links))