continuous.hinge

hinge

Módulo del Operador de Bisagra Continuo (IOB Continuo).

Implementa la axiomatización del Paper I para variedades euclidianas. Cuantifica la pérdida de isometría local evaluando el residuo bilateral simétrico frente al hiperplano tangente, garantizando diferenciabilidad (Autograd).

References

.. [1] Knuttzen, J. (2026). "Formalismo de Integridad de Bisagra: Aislamiento Topológico de Singularidades y Control de Bifurcaciones en Variedades Continuas".

ContinuousIntegrityOperator

Bases: BaseIntegrityOperator

Operador de Bisagra para el Dominio Continuo.

Cuantifica el grado de curvatura o deformación geométrica local en una variedad diferenciable \Omega. Evalúa el residuo \mathcal{H}(x) asumiendo que las perturbaciones hiper-trascendentales y las bifurcaciones inminentes rompen la linealidad métrica del espacio de fases.

Parameters:

Name	Type	Description	Default
epsilon_tolerance	float	Factor de amortiguamiento numérico (\epsilon) introducido para estabilizar la inversa de las normas de varianza nula y mitigar el límite de precisión de punto flotante (\varepsilon_{mach}).	1e-8

Source code in iobsolve/continuous/hinge.py

class ContinuousIntegrityOperator(BaseIntegrityOperator):
    r"""
    Operador de Bisagra para el Dominio Continuo.

    Cuantifica el grado de curvatura o deformación geométrica local en una 
    variedad diferenciable \Omega. Evalúa el residuo \mathcal{H}(x) asumiendo 
    que las perturbaciones hiper-trascendentales y las bifurcaciones inminentes
    rompen la linealidad métrica del espacio de fases.

    Parameters
    ----------
    epsilon_tolerance : float, default=1e-8
        Factor de amortiguamiento numérico (\epsilon) introducido para 
        estabilizar la inversa de las normas de varianza nula y mitigar el 
        límite de precisión de punto flotante (\varepsilon_{mach}).
    """

    def __init__(self, epsilon_tolerance: float = 1e-8):
        super().__init__(epsilon_tolerance)

    def compute_stress(self, 
                       state_tensor: ManifoldField, 
                       *,  
                       manifold: EuclideanManifold, 
                       normalize: bool = True,
                       **kwargs: Any) -> StressTensor:
        r"""
        Calcula el campo de estrés topológico \mathcal{H}(x) sobre la variedad.

        Notes
        -----
        Matemáticamente, la tensión \mathcal{H} evalúa la divergencia del gradiente 
        (Laplaciano continuo) aislando la curvatura no lineal de la variedad:

        .. math:: \mathcal{H}(x) = \left| \nabla^2 \phi(x) \right|

        Parameters
        ----------
        state_tensor : ManifoldField
            El campo de estados \phi(x) o campo vectorial de fase evaluado.
        manifold : EuclideanManifold
            La topología subyacente que provee la métrica del espaciado (\Delta x).
        normalize : bool, default=True
            Si es True, aplica un mapeo de escalado isométrico para confinar 
            el tensor resultante al intervalo \mathcal{H}_{norm} \in [0, 1].

        Returns
        -------
        StressTensor
            Tensor \mathcal{H} de dimensionalidad isomorfa al campo de entrada.

        Complexity
        ----------
        Dependiente de la resolución de la malla \mathcal{O}(N) por cada dimensión, 
        operado mediante diferencias finitas centrales (\texttt{torch.gradient}).
        """
        manifold.validate_field(state_tensor)

        # 1. Evaluación del Laplaciano como residuo bilateral simétrico
        laplacian_field = ContinuousLaplacian.compute(
            field=state_tensor, 
            grid_spacing=manifold.grid_spacing
        )

        # 2. Magnitud escalar de la curvatura local preservando el grafo de Autograd
        stress_tensor = torch.abs(laplacian_field)

        # 3. Normalización del estrés 
        if normalize:
            max_stress = torch.max(stress_tensor)
            if max_stress > self.epsilon_tolerance:
                stress_tensor = stress_tensor / max_stress
            else:
                stress_tensor = torch.zeros_like(stress_tensor)

        return stress_tensor

    def locate_singularities(self, 
                             stress_tensor: StressTensor, 
                             threshold: float) -> Tuple[torch.Tensor, ...]:
        r"""
        Aísla los tensores coordenados donde la deformación local supera 
        el umbral crítico de bifurcación (\tau_c).

        Parameters
        ----------
        stress_tensor : StressTensor
            El campo de estrés normalizado \mathcal{H} \in [0, 1].
        threshold : float
            Tolerancia de curvatura crítica \tau_c.

        Returns
        -------
        Tuple[torch.Tensor, ...]
            Tensores de índices n-dimensionales (coordenadas de la malla) que 
            albergan las singularidades espaciales detectadas.
        """
        singular_indices = torch.where(stress_tensor > threshold)
        return singular_indices

compute_stress

compute_stress(
    state_tensor: ManifoldField,
    *,
    manifold: EuclideanManifold,
    normalize: bool = True,
    **kwargs: Any
) -> StressTensor

Calcula el campo de estrés topológico \mathcal{H}(x) sobre la variedad.

Notes

Matemáticamente, la tensión \mathcal{H} evalúa la divergencia del gradiente (Laplaciano continuo) aislando la curvatura no lineal de la variedad:

.. math:: \mathcal{H}(x) = \left| \nabla^2 \phi(x) \right|

Parameters:

Name	Type	Description	Default
state_tensor	ManifoldField	El campo de estados \phi(x) o campo vectorial de fase evaluado.	required
manifold	EuclideanManifold	La topología subyacente que provee la métrica del espaciado (\Delta x).	required
normalize	bool	Si es True, aplica un mapeo de escalado isométrico para confinar el tensor resultante al intervalo \mathcal{H}_{norm} \in [0, 1].	True

Returns:

Type	Description
StressTensor	Tensor \mathcal{H} de dimensionalidad isomorfa al campo de entrada.

Complexity

Dependiente de la resolución de la malla \mathcal{O}(N) por cada dimensión, operado mediante diferencias finitas centrales (\texttt{torch.gradient}).

Source code in iobsolve/continuous/hinge.py

def compute_stress(self, 
                   state_tensor: ManifoldField, 
                   *,  
                   manifold: EuclideanManifold, 
                   normalize: bool = True,
                   **kwargs: Any) -> StressTensor:
    r"""
    Calcula el campo de estrés topológico \mathcal{H}(x) sobre la variedad.

    Notes
    -----
    Matemáticamente, la tensión \mathcal{H} evalúa la divergencia del gradiente 
    (Laplaciano continuo) aislando la curvatura no lineal de la variedad:

    .. math:: \mathcal{H}(x) = \left| \nabla^2 \phi(x) \right|

    Parameters
    ----------
    state_tensor : ManifoldField
        El campo de estados \phi(x) o campo vectorial de fase evaluado.
    manifold : EuclideanManifold
        La topología subyacente que provee la métrica del espaciado (\Delta x).
    normalize : bool, default=True
        Si es True, aplica un mapeo de escalado isométrico para confinar 
        el tensor resultante al intervalo \mathcal{H}_{norm} \in [0, 1].

    Returns
    -------
    StressTensor
        Tensor \mathcal{H} de dimensionalidad isomorfa al campo de entrada.

    Complexity
    ----------
    Dependiente de la resolución de la malla \mathcal{O}(N) por cada dimensión, 
    operado mediante diferencias finitas centrales (\texttt{torch.gradient}).
    """
    manifold.validate_field(state_tensor)

    # 1. Evaluación del Laplaciano como residuo bilateral simétrico
    laplacian_field = ContinuousLaplacian.compute(
        field=state_tensor, 
        grid_spacing=manifold.grid_spacing
    )

    # 2. Magnitud escalar de la curvatura local preservando el grafo de Autograd
    stress_tensor = torch.abs(laplacian_field)

    # 3. Normalización del estrés 
    if normalize:
        max_stress = torch.max(stress_tensor)
        if max_stress > self.epsilon_tolerance:
            stress_tensor = stress_tensor / max_stress
        else:
            stress_tensor = torch.zeros_like(stress_tensor)

    return stress_tensor

locate_singularities

locate_singularities(
    stress_tensor: StressTensor, threshold: float
) -> Tuple[torch.Tensor, ...]

Aísla los tensores coordenados donde la deformación local supera el umbral crítico de bifurcación (\tau_c).

Parameters:

Name	Type	Description	Default
stress_tensor	StressTensor	El campo de estrés normalizado \mathcal{H} \in [0, 1].	required
threshold	float	Tolerancia de curvatura crítica \tau_c.	required

Returns:

Type	Description
Tuple[Tensor, ...]	Tensores de índices n-dimensionales (coordenadas de la malla) que albergan las singularidades espaciales detectadas.

Source code in iobsolve/continuous/hinge.py

def locate_singularities(self, 
                         stress_tensor: StressTensor, 
                         threshold: float) -> Tuple[torch.Tensor, ...]:
    r"""
    Aísla los tensores coordenados donde la deformación local supera 
    el umbral crítico de bifurcación (\tau_c).

    Parameters
    ----------
    stress_tensor : StressTensor
        El campo de estrés normalizado \mathcal{H} \in [0, 1].
    threshold : float
        Tolerancia de curvatura crítica \tau_c.

    Returns
    -------
    Tuple[torch.Tensor, ...]
        Tensores de índices n-dimensionales (coordenadas de la malla) que 
        albergan las singularidades espaciales detectadas.
    """
    singular_indices = torch.where(stress_tensor > threshold)
    return singular_indices