PiecewiseLorentz: Analytic Lorentz Transform

• PiecewiseLorentz is a Julia module that extends the Piecewise framework to evaluate Lorentz transforms of piecewise functions using analytic primitives.
• It replaces numerical quadrature with closed-form boundary evaluations, enhancing speed and stability near discontinuities and singularities.
• The module integrates with related packages like Piecewise and PiecewiseHilbert to support advanced fitting of functions with complex local behavior.

Searching arXiv for the cited paper to ground the article and verify the relevant details. Using the arXiv API to retrieve metadata for the main source paper. {"cmd":"python - <<'PY'\nimport urllib.request, urllib.parse\nquery = 'id:(Berthod, 23 Sep 2025)'\nurl = 'http://export.arxiv.org/api/query?search_query=' + urllib.parse.quote(query) + '&start=0&max_results=5'\nprint(urllib.request.urlopen(url, timeout=20).read().decode('utf-8')[:4000])\nPY"} Fetching the arXiv API entry directly for (Berthod, 23 Sep 2025). {"cmd":"curl -L --max-time 20 'https://export.arxiv.org/api/query?id_list=([2509.18829](/papers/2509.18829))' | sed -n '1,120p'"} Querying arXiv for related module and title terms to ensure no distinct paper exists for PiecewiseLorentz itself. {"cmd":"python - <<'PY'\nimport urllib.request, urllib.parse\nterms = ['PiecewiseLorentz', 'Piecewise Julia integral transforms Lorentz']\nfor term in terms:\n url = 'https://export.arxiv.org/api/query?search_query=all:' + urllib.parse.quote(term) + '&start=0&max_results=3'\n data = urllib.request.urlopen(url, timeout=20).read().decode('utf-8')\n print('\nTERM:', term)\n print(data[:1500])\nPY"} PiecewiseLorentz is a Julia module in the Piecewise ecosystem for evaluating a Lorentz transform of piecewise functions of a real variable by analytic boundary evaluation rather than numerical quadrature. In the underlying framework, a piecewise function returns values from different rules on different intervals of $x$, and the user is free to choose those rules. The paper introducing the framework states that the base Piecewise module defines seven formulas for fast moment computation, that PiecewiseHilbert extends some of these formulas for a fast Hilbert transform, and that PiecewiseLorentz extends some of them to enable what the authors call a Lorentz transform (Berthod, 23 Sep 2025).

1. Position within the Piecewise framework

The broader framework is designed for representing and fitting piecewise functions of a real variable. This is useful when the target function has discontinuities, singularities, or other critical points where global polynomial interpolation performs poorly. Within that setting, PiecewiseLorentz is not a standalone fitting system; it is an extension layer that operates on piecewise representations already supported by Piecewise (Berthod, 23 Sep 2025).

The paper organizes the ecosystem around three modules with distinct roles. Piecewise provides the core representation of piecewise functions and a fitting mechanism. PiecewiseHilbert supplements some predefined formulas with methods enabling a fast Hilbert transform. PiecewiseLorentz performs the analogous extension for another integral transform, namely the Lorentz transform. The exact statement supported by the text is that PiecewiseLorentz extends some of the seven predefined Formula types from Piecewise so that the Lorentz transform can be evaluated without quadrature.

A recurrent source of ambiguity is the word “Lorentz.” In this context it denotes a kernel-based integral transform implemented on top of the piecewise-function infrastructure, not a theory of Lorentzian geometry or Lorentz transformations in spacetime. The module’s role is therefore functional-analytic and computational rather than geometric.

2. Data structures and fitting model

The framework is built from three structures. A Formula holds a user-defined function depending on a given number of parameters, together with possible restrictions regarding the values of these parameters with respect to the interval in which the formula is used. A Piece holds an interval, a rule that can be a sum of Formula objects, and the parameters to be passed to these formula. A PiecewiseFunction holds a collection of Piece objects (Berthod, 23 Sep 2025).

This organization gives the module a compositional representation model. Each interval can carry a different analytic rule, and a complete approximation is assembled from a collection of such interval-local rules. Because a rule inside a Piece can itself be a sum of Formula objects, the framework supports decompositions in which singular and regular contributions are represented separately and then recombined.

The fitting mechanism is provided by piecewisefit. It fits a PiecewiseFunction to a target real-valued function after the user selects a set of formulas, an interval, and options such as parity and tolerance. The fit can automatically choose the polynomial order or other formula parameters needed to reach the desired accuracy. The paper’s density-of-states example illustrates a three-step workflow: removing a known singular term represented as a PiecewiseFunction, fitting the smooth residual with a polynomial formula, and adding the singular term back. That example demonstrates that the framework supports decomposing a function into analytic and nonanalytic pieces, fitting each piece appropriately, and then recombining them (Berthod, 23 Sep 2025).

3. Integral-transform formalism

The paper places PiecewiseLorentz inside a general class of linear integral transforms of the form

$$(K\circ f)(\mathbf{X})=\int_{-\infty}^{\infty}dx\,f(x)K(x,\mathbf{X}),$$

where $f(x)$ is a real-variable function, $K(x,\mathbf{X})$ is a kernel, and $\mathbf{X}$ may be scalar or multidimensional (Berthod, 23 Sep 2025).

The central requirement for fast evaluation is that the piecewise function be built from formulas $F_i(x)$ for which an antiderivative of the product with the kernel is analytically known. The paper writes this requirement as

$$\frac{d}{dx}P_i(x,\mathbf{X}) = F_i(x)K(x,\mathbf{X}).$$

Once such a primitive $P_i$ is available, the transform on each piece is obtained by evaluating $P_i$ at the endpoints of the interval and summing the resulting boundary contributions.

For the Hilbert-transform case, the paper explicitly gives comparison kernels,

$$K(x,y)=\frac{1}{y-x+i0^+}, \qquad K(x,z)=\frac{1}{z-x}, \qquad z\in\mathbb{C}\setminus\mathbb{R}.$$

By contrast, the excerpt does not provide a standalone explicit formula labeled “Lorentz transform,” nor does it spell out the Lorentz kernel in the main text. The supportable description is therefore narrower: PiecewiseLorentz treats the Lorentz transform analogously to the Hilbert-transform extension, using kernel-specific analytic primitives for supported formula classes (Berthod, 23 Sep 2025).

4. Computational mechanism of PiecewiseLorentz

The computational idea is to replace quadrature by analytic boundary evaluation. Instead of approximating

$$(K\circ f)(\mathbf{X})=\int_{-\infty}^{\infty}dx\,f(x)K(x,\mathbf{X}),$$0

numerically, PiecewiseLorentz represents $$(K\circ f)(\mathbf{X})=\int_{-\infty}^{\infty}dx\,f(x)K(x,\mathbf{X}),$$1 as a sum of supported piecewise formulas, uses closed-form antiderivatives for each supported formula/kernel pair, evaluates those antiderivatives at the piece boundaries, and sums the contributions over all pieces (Berthod, 23 Sep 2025).

In this architecture, speed comes from preselecting formula families for which the transform is analytically tractable. The base Piecewise module defines seven formulas that enable the fast calculation of the moments of the piecewise function. PiecewiseLorentz extends only some of these formulas. The exact subset is not enumerated in the provided text, and the formula names are not listed there. Consequently, the module should not be described as supporting arbitrary user-defined formulas for Lorentz transforms; the accelerated path is limited to the predefined formulas for which the relevant primitives are known.

The significance of this design is most apparent near singularities or sharp features. The paper notes that boundary evaluation can be much faster and more stable in such settings, where quadrature can converge slowly or fail. This does not eliminate the need for approximation altogether, because the target function may still need to be fitted piecewise, but it shifts the transform stage from generic numerical integration to exact or semi-exact interval-wise evaluation.

5. Implementation characteristics and limitations

The implementation is described as an environment for user-defined formulas $$(K\circ f)(\mathbf{X})=\int_{-\infty}^{\infty}dx\,f(x)K(x,\mathbf{X}),$$2, kernel-dependent primitives $$(K\circ f)(\mathbf{X})=\int_{-\infty}^{\infty}dx\,f(x)K(x,\mathbf{X}),$$3, and piecewise representation and fitting. Its style is symbolic or analytic in spirit, but it is implemented in Julia for speed (Berthod, 23 Sep 2025).

Several practical characteristics follow from the framework presented in the paper. PiecewiseFunction objects can be summed. Known singular parts can be added back after fitting smooth residuals. Printing a PiecewiseFunction shows its constructor-like representation. The demonstration cited in the paper shows that a PiecewiseFunction can encode a logarithmic singularity using a special LOG formula and then be combined with a fitted polynomial residual.

The limitations stated in the text are equally specific. First, only formulas with known analytic transform primitives can be accelerated; if the needed antiderivative $$(K\circ f)(\mathbf{X})=\int_{-\infty}^{\infty}dx\,f(x)K(x,\mathbf{X}),$$4 is not known, the framework cannot avoid quadrature. Second, only some of the predefined formulas are extended by PiecewiseLorentz. Third, the paper excerpt does not spell out the Lorentz kernel formula in the main text, so users must consult the documentation for the exact supported transform definition and formula list. Fourth, fitting is piecewise and may depend on randomness; the paper notes that exact fitted coefficients may vary because randomness is involved in the fitting process (Berthod, 23 Sep 2025).

These constraints delimit the module’s scope. PiecewiseLorentz is not presented as a universal transform engine for arbitrary kernels and arbitrary formulas. It is a specialized extension that yields acceleration when the representation and kernel are compatible with closed-form primitives.

6. Examples, usage context, and interpretive scope

The excerpt does not provide a dedicated numerical example or benchmark specifically for PiecewiseLorentz. No explicit timing benchmark or performance table for the module is included in the provided text. The practical evidence in the paper is therefore indirect, coming from the broader Piecewise methodology and from adjacent modules in the same ecosystem (Berthod, 23 Sep 2025).

The paper does, however, identify several contexts that illuminate how PiecewiseLorentz is meant to be used. It mentions two tutorials: one on constructing approximations with piecewisefit, and one on solving an implicit equation using PiecewiseHilbert. It cites MagnetoTransport.jl as a complete use case, and it mentions a nonlinear integral equation example associated with van der Marel and Berthod. Although these are not Lorentz-transform benchmarks, they show the intended architectural pattern: represent the function in analytically tractable pieces, isolate known singular components when necessary, fit the residual, and evaluate the desired transform from boundary terms rather than from quadratures.

The density-of-states example is especially instructive for interpretation. It demonstrates the framework’s support for a mixed analytic and fitted representation: a known singular part is explicitly encoded, a smoother remainder is approximated by a polynomial piecewise fit, and the two are recombined. This suggests a natural usage model for PiecewiseLorentz as well: functions with nonuniform local structure are first rewritten in a piecewise basis adapted to their singular and regular components, after which the Lorentz transform can be evaluated analytically on the supported formula classes.

In summary, PiecewiseLorentz is the Lorentz-transform branch of a Julia framework for piecewise analytic approximation. Its essential mechanism is the conversion of integral-transform evaluation into endpoint evaluation of kernel-specific primitives on each piece. Its utility depends on representing the target function as a PiecewiseFunction built from supported formulas, and its current scope is determined by the subset of predefined formulas for which those analytic Lorentz-transform primitives have been implemented (Berthod, 23 Sep 2025).