JacNet: Jacobian Neural Function Approximation

• JacNet is a neural architecture that approximates functions by directly learning their Jacobian fields, enabling robust enforcement of constraints like invertibility and Lipschitz continuity.
• It employs structured Jacobian parameterizations, such as positive-definite and spectral-norm bounded formulations, to guarantee controlled derivative properties and theoretical guarantees.
• The network reconstructs functions through numerical integration of the Jacobian, facilitating accurate forward and inverse computations in supervised learning settings.

JacNet is a neural architecture designed for function approximation by directly parameterizing the Jacobian field of the target mapping, rather than the function itself. The key insight is that by learning a structured Jacobian, constraints such as invertibility and Lipschitz continuity can be imposed and controlled through neural network activations and output parameterizations, enabling the encoding of qualitative functional priors into neural models. Integration of the network-predicted Jacobian reconstructs the original function, and invertibility is ensured—or $k$-Lipschitz priors enforced—by appropriate structural modifications to the network output. This approach provides fine-grained control over the differentiable properties of the learned mapping, facilitating both forward and inverse function computations with theoretical guarantees (Lorraine et al., 2024).

1. Core Principle: Jacobian Field Learning

JacNet targets the supervised learning problem where one seeks to model an unknown $C^1$ diffeomorphism $$f: X \subset \mathbb{R}^d \to Y \subset \mathbb{R}^d$$. Rather than directly learning $f_\theta(x)$ as a neural network, JacNet posit that the Jacobian $J_\theta(x) = \partial f_\theta(x) / \partial x$ is instead learned via a separate network. Using the fundamental theorem of line integrals, the function $f_\theta(x)$ can be reconstructed from its Jacobian field as: $$f_\theta(x) = f(x_0) + \int_0^1 J_\theta(x_0 + t(x-x_0)) \cdot (x - x_0)\, dt,$$ where $x_0$ is a fixed base-point with known value.

The learning objective is empirical risk minimization over the data: $$\bar{R}(\theta) = \frac{1}{n} \sum_{i=1}^n L(y_i, f_\theta(x_i)),$$ where $L$ is a loss (e.g., $|\cdot|$ or $\|\cdot\|_2$), optimized via backpropagation through a numerical integration procedure.

This construction allows typical neural network machinery—activation functions, normalization constraints, positive-definite factorizations—to directly operate on the Jacobian, thereby imparting desired structural priors onto the function's derivatives.

2. Structuring the Jacobian Output

The network parameterizing $J_\theta(x)$ can be constructed to enforce particular structural properties essential for qualitative function control:

• Unconstrained Jacobian: $$J_\theta(x) = \text{NN}_\theta(x) \in \mathbb{R}^{d \times d}$$.
• Positive-Definite (PD) Jacobian for Invertibility: Let $M_\theta(x)$ be an unconstrained output, then

$$J_\theta(x) = M_\theta(x) M_\theta(x)^T + \epsilon I,$$

for small $\epsilon > 0$. This guarantees strict positive-definiteness, ensuring all eigenvalues $\geq \epsilon > 0$ and $\det J_\theta(x) > 0$, precluding negative eigen-directions.

• Block-Triangular or Triangular Factorization: (Proposed for future work.) The network outputs a lower-triangular matrix $L_\theta(x)$ (with positive diagonals via softplus activations) and sets $J_\theta(x) = L_\theta(x) L_\theta(x)^T$. This again ensures PD-ness and invertibility.
• Spectral-Norm-Bounded (Lipschitz) Jacobian: To enforce a $k$-Lipschitz bound,

$J_\theta(x) = k \cdot \tanh(A_\theta(x)),$

where $A_\theta(x)$ is unconstrained; the elementwise tanh scales entries to $[-k, k]$ and provides $\|J_\theta(x)\|_2 \leq d k$ (tightened to $k$ with spectral normalization).

These constructions allow invertibility, $k$-Lipschitz, and more general derivative-based priors to be imposed via architectural choice.

3. Theoretical Guarantees: Invertibility and Properness

JacNet's approach is supported by the inverse function and Hadamard's global inverse theorems. Specifically, if $f$ is $C^1$ and $\det Df(x) \neq 0$ for all $x$, then $f$ is locally invertible; if $f$ is also proper (i.e., pre-images of compact sets are compact) and the domains are connected, $f$ is a global $C^1$-diffeomorphism.

In JacNet, parameterizing $J_\theta(x)$ as strictly PD via the method above enforces $\det J_\theta(x) \geq \epsilon^d > 0$. Properness can be ensured by domain clamping or by constructing $J_\theta$ to be coercive (i.e., $\|f_\theta(x)\| \to \infty$ as $\|x\| \to \infty$), which is often achieved in practice.

4. Enforcing Lipschitz and Additional Priors

A function is $k$-Lipschitz if $\|f(x') - f(x)\|_2 \leq k \|x'-x\|_2$ for all $x, x'$. By the mean-value inequality, a sufficient condition is: $\sup_{x \in X} \|Df_\theta(x)\|_2 \leq k.$ JacNet realizes this by bounding the spectral norm of the output Jacobian $J_\theta(x)$ through:

• Elementwise tanh scaling, plus spectral normalization on intermediate weights.
• Direct orthonormal factorization with singular values clamped to $k$.
• Householder or Cayley-based parameterizations.

Because the Jacobian is directly output by the network, these constraints are applied as output layer activations, leaving the reconstruction procedure by line integration unchanged. Other priors, such as convexity or Cauchy–Riemann conditions, can be encoded similarly.

5. Training and Optimization Procedure

Training JacNet involves choosing a base-point $x_0$ (and $y_0 = f(x_0)$ if available), defining the reconstructed function $f_\theta(x)$ via: $$f_\theta(x) = y_0 + \int_0^1 J_\theta\big(x_0 + t(x - x_0)\big)\cdot(x-x_0)\,dt.$$ The training objective is: $$\min_\theta \;\bar{R}(\theta) = \frac{1}{n} \sum_{i=1}^n L\Big(y_i,\, y_0 + \int_0^1 J_\theta(x_0 + t(x_i - x_0))\cdot(x_i - x_0)\,dt\Big) + \lambda \Omega(\theta),$$ where $\Omega(\theta)$ may be a $L_2$ penalty or additional regularization, but experiments are conducted with $\lambda = 0$. Optimization leverages backpropagation through the numerical integrator for end-to-end learning.

6. Inverting the Learned Mapping

Given that $f_\theta$ is a global diffeomorphism under the enforced constraints, inversion is performed by the analogous integral in output space: $$x = x_0 + \int_0^1 [J_\theta(\tilde{c}(t))]^{-1} \cdot (d\tilde{c}/dt)(t)\,dt,$$ where $\tilde{c}(t) = y_0 + t(y - y_0)$. For the matrix-factorized Jacobian form, inversion is efficiently computed via Cholesky or Woodbury identities (complexity $O(d^3)$, reduced to $O(dr^2)$ for low-rank $M_\theta$).

An Euler scheme is proposed for numerical inversion:

Δy = (y - y0) / T x = x0 for t in range(T): Y = x0 + t * Δy J = Jθ(Y) x = x + inv(J) @ Δy return x

7. Empirical Illustration and Comparative Performance

JacNet is empirically validated on 1D problems, including invertible and Lipschitz function approximation:

• Invertible task ($f(x)=\exp(x)$, $x\in[-1,1]$): Using the positive-definite parameterization, JacNet recovers $\exp(x)$ precisely after 50 Adam iterations on $n=5$ training points. The unconstrained baseline fails, collapsing its derivative to zero and making inversion intractable.
• 1-Lipschitz task ($f(x)=|x|$, $x\in[-1,1]$): With $f_\theta'(x) = \tanh(\mathrm{NN}(x))$ so $|f_\theta'(x)|\leq 1$, JacNet matches $|x|$ exactly with bounded slope; the unconstrained baseline fails to maintain Lipschitz bounds and generalizes poorly.

Results are summarized as follows:

Task	Unconstrained	JacNet-PD inv.	JacNet-Lipschitz
$\exp(x)$ inv.	$1.2\text{e}{-1}$	$1.8\text{e}{-3}$	N/A
$|x|$ Lipschitz	$6.5\text{e}{-2}$	N/A	$2.1\text{e}{-3}$

Explicit control of derivative properties, as provided by JacNet, is demonstrated to be essential for correct qualitative behavior (monotonicity, slope-bounds), not merely for minimizing training error.

8. Functional Priors and Modeling Implications

JacNet conceptually unifies a wide range of structural constraints as output constraints on the learned Jacobian field. By this construction, entire families of functional priors (invertibility, Lipschitz continuity, convexity, Cauchy–Riemann, among others) can be incorporated directly into end-to-end differentiable models. This allows modeling of highly flexible, universal-approximation-style derivatives, with precise control over the qualitative behavior of the resulting function mappings (Lorraine et al., 2024).