Pith. sign in

REVIEW 6 minor 2 cited by

Tree-based representation yields flexible numbering for composed finite-element spaces

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Representing composed finite element bases as trees, with multi-index trees and merging strategies, yields flexible dof numberings, implemented in dune-functions.

T0 review reviewed 2026-08-05 challenge →

load-bearing objection A clean, honest formalization of index trees for composed FE bases—useful vocabulary and a real implementation, but no new mathematics, and the performance/interoperability claims are asserted, not measured.

arxiv 2508.10125 v1 pith:AW4UZIPG submitted 2025-08-13 cs.MS cs.NAmath.NA

Concepts for Composing Finite Element Function Space Bases

Christian Engwer , Carsten Gr\"aser , Steffen M\"uthing , Simon Praetorius , Oliver Sander This is my paper
classification cs.MS cs.NAmath.NA MSC 65N3065Y99
keywords finite element methodcomposed function spacesbasis treesmulti-index numberingTaylor-Hood elementsoftware designdegree of freedom indexing
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper introduces a way to represent product-structured finite-element spaces (like Taylor-Hood) as ordered trees of simpler bases. From that representation, it derives several systematic multi-index numberings that let the same mathematical space be stored in nested or flat containers. If correct, finite-element codes could switch data layouts and linear-algebra backends by changing a few annotations. The paper keeps its claim limited to Cartesian products; spaces built by sums are explicitly out of scope. A concrete implementation is said to realize most of the concepts.

Core claim

On the paper's own terms: every composed finite-element space that is a Cartesian product can be represented as a rooted ordered tree whose leaves are irreducible bases. Once such a basis tree is fixed, an index map assigns each basis function a multi-index. The paper defines index trees (multi-index sets with consecutive zero-based child digits) and shows four recursive merging strategies - blocked-lexicographic, blocked-interleaved, flat-lexicographic, flat-interleaved - generate practical numberings. Interleaved strategies apply only to power nodes, where all children are identical. Taylor-Hood is the recurring witness: velocities can be blocked (0,i,j) or interleaved (0,j,i), giving diff

What carries the argument

The basis tree is the central object: leaves are irreducible bases (scalar Lagrange, Raviart-Thomas, etc.), inner nodes are Cartesian products, and each node carries an index map into multi-indices. The index-tree condition - multi-indices as paths in an ordered tree, with children numbered consecutively from zero - makes a numbering legal. The four merging strategies are the mechanism that constructs global multi-indices recursively from child maps; choosing among them adapts the numbering to flat or nested data layouts.

Load-bearing premise

The design assumes every useful composed finite-element space is a Cartesian product of irreducible bases whose multi-index children can be numbered consecutively from zero; if a hybrid space requires sums (hierarchical enrichment, XFEM) or a non-consecutive entity-blocked numbering, the tree construction as presented cannot produce it automatically.

What would settle it

Attempt to construct P2 as P1 plus a bubble enrichment using only the product-based composition; the framework explicitly excludes sums, so no such tree exists. On the numbering side, ask the implementation to generate an entity-blocked numbering automatically for a Taylor-Hood basis on a small mesh; the paper concedes this is not supported by the generic construction, so observing the API gap would bound the claim of covering arbitrary data layouts.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

If this is right

  • The same Taylor-Hood basis can be stored with velocity components blocked for matrix assembly or interleaved for component-wise access by changing one factory tag.
  • Element assembly needs only local shape functions plus two local maps; global multi-indices are cached during binding, keeping per-element cost small.
  • Subtrees of a composite basis behave as independent bases while preserving the parent numbering, enabling velocity-only solvers and pressure visualization.
  • Multi-domain couplings such as Stokes-Darcy are expressible by restricting subtrees to subdomains, with zero extension outside each subdomain.
  • If the implementation is correct, other finite-element frameworks could adopt the same abstractions, making discrete functions interoperable across data layouts.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The four strategies are not a complete classification; the paper's own entity-blocked example needs external mesh-entity information, suggesting a fifth strategy consuming an entity-ordering oracle.
  • The product-only scope implies a companion abstraction for sum-based spaces (hierarchical enrichment, XFEM) - perhaps a DAG mixing products and sums - would extend the tree machinery.
  • A direct test: benchmark assembly and solver performance across the four strategies on the same Stokes problem; the paper motivates flexibility but does not quantify it.
  • The container descriptor concept could be generalized to map any basis to any backend container automatically, turning 'different linear algebra codes' from manual shims into a type-level transformation.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

0 major / 6 minor

Summary. This paper proposes a formal vocabulary for composing finite element space bases from Cartesian products of irreducible bases. The composition is represented as an ordered tree; basis functions are indexed by multi-indices that form index trees; and a small set of recursive merging strategies (blocked/flat, lexicographic/interleaved, and blocked-by-entity) generates different numberings from the same tree. The Taylor-Hood Stokes element is used throughout to illustrate how different indexings affect the layout of coefficient vectors and matrices. The second half documents the dune-functions module, showing how the GlobalBasis and LocalView interfaces, subspace bases, vector backends, interpolation, and container descriptors realize these concepts. The paper explicitly excludes sums of spaces and does not claim full automatic support for every strategy; for example, blocked-by-entity numbering is said not to be automatically constructible.

Significance. The conceptual abstraction is clean and, to my knowledge, not otherwise presented at this level of precision. If accepted, it gives implementers a common language for why one composite FE space can be stored in different flat or nested layouts, and the four merging strategies cover the most common practical numberings. The formal definitions are internally consistent, and the Taylor-Hood example is worked out concretely: 15 local dofs per triangle, and the two index trees in Figs. 4 and 5 produce different matrix occupation patterns in Fig. 6. The implementation in dune-functions is a real released code base, and the paper honestly distinguishes released features from upcoming 2.11 developments. The main weaknesses are that the performance rationale in §3.4 is asserted rather than measured, and the claim about using 'very different linear algebra codes' is supported only by a reference to dune-assembler rather than by demonstrations in this paper. These are limitations of evidence, not internal inconsistencies.

minor comments (6)
  1. [§3.4] The sentence 'using dynamic polymorphism ... would significantly impact performance' is an assertion without measurements, references, or microbenchmarks. Since this is the stated reason for the explicit C++ type tree, I recommend either adding a reference to existing benchmarks or softening to 'is expected to have a significant impact'.
  2. [§2.5, Example 3] The blocked-by-entity construction assumes that the resulting set of multi-indices remains an index tree, but the first digit I(e) can skip an entity index if some entity carries no basis function. Definition 3 requires all smaller child indices to be present. Please state the additional density assumption on the entity numbering (or explain how zero-dof entities are handled); otherwise the example does not always produce an index map in the sense of Definition 5.
  3. [§3.3] The text says the interfaces support blocked-by-entity numbering but the generic construction does not support automatic construction of these multi-indices. Please clarify what a user must do to obtain such a numbering, e.g., supply a custom merging strategy or precomputed entity offsets, so that the limitation and the workaround are concrete.
  4. [§2.1 / Abstract] The restriction to Cartesian products is stated in Section 2.1 but not in the abstract or conclusions. Since sums (hierarchical P2 = P1 + bubble, XFEM) are explicitly excluded, a sentence in the abstract such as 'for product spaces' would prevent overgeneralization of the title's 'composing' claim.
  5. [§3.6.4 / §3.5] Several described features (container descriptors, makeISTLVector, makeContainer, multi-domain restrict) are marked as upcoming 2.11 or experimental. In the code listings it would help to add a callout indicating which snippets require unreleased features, since Section 3.2 identifies 2.10 as the current release.
  6. [General / Typos] Typos and small issues: 'therefor' in Section 1 should be 'therefore'; 'c.f.' should be 'cf.'; data availability 'refere' should be 'refer'; reference [27] lists 'Enger' as first author, which should be 'Engwer'. The multi-index notation in Definition 3 ('but I /∈ I') is confusing because I overloads the set and a prefix; consider using a different letter for the prefix.

Circularity Check

0 steps flagged

No significant circularity identified

full rationale

The paper is a software-concepts and design paper, not a predictive or curve-fitting paper, so the standard circularity failure modes (fitted input called prediction, uniqueness imported from authors, derivation equal to input by definition) do not apply. The central derivation is the formal construction of composed finite element bases as trees (Section 2.1), the definition of multi-index trees and index maps (Definitions 1–5), and the explicit recursive merging strategies (Examples 1–3). These are given by concrete formulas (e.g., blocked-lexicographic: ι(e_i⊗λ̂)=(i,ι_i(λ̂)); flat-interleaved: ι(e_i⊗λ̂)=(i_0 m+i,I)), and the dune-functions realization in Section 3 maps those formulas to concrete C++ factories and interfaces. The paper's claim that 'many different numberings ... can be derived in a natural way' is supported by the shown construction, not by a fitted parameter or a self-referential uniqueness theorem. Self-citations such as [9] (Müthing's thesis) and [23] (prior dune-functions interface paper) are present, but they are used for historical attribution and contextual background, not as the load-bearing justification for the paper's definitions or claims. The paper also explicitly discloses limitations (sums of bases are out of scope, blocked-by-entity numbering is not automatically constructible, some features are in the upcoming 2.11 release), which further indicates that the claims are scoped rather than forced. No passage was found where a conclusion is equivalent to an input by construction or where a prediction reduces to a fit.

Axiom & Free-Parameter Ledger

0 free parameters · 5 axioms · 2 invented entities

The framework is conceptual and contains no numerical fits. It rests on soft engineering premises (performance, strategy completeness) and explicit scope exclusions (sums). The two main invented abstractions, the index tree and the merging strategies, are implemented in released code, giving them external testable handles.

axioms (5)
  • domain assumption Every practically relevant composed finite element space can be written as a Cartesian product of simpler bases; sums are excluded from the framework.
    Section 2.1 explicitly declares sums out of scope. Hierarchical bases [7] and XFEM [10] are named as product-adjacent but not covered, which bounds the framework's coverage.
  • domain assumption Bases are piecewise polynomial with respect to a fixed grid, and element restrictions of basis functions can be constructed cheaply.
    Section 2.4 relies on this for localization; the paper notes the cheap-construction part is sufficient but not strictly required.
  • ad hoc to paper The explicit (static) C++ type tree is necessary to avoid a significant performance impact from dynamic polymorphism.
    Section 3.4 asserts this without benchmark data; it is an engineering premise for the design, not a measured fact.
  • domain assumption The four merging strategies, plus blocked-by-entity, exhaust the numberings needed in practice.
    Section 2.5 presents strategies that are or have been used in practice and Section 3.3 implements four of them; no completeness argument is given.
  • standard math Standard linear algebra facts: the k-th power of a space equals R^k ⊗ V, and products are associative, used freely in Section 2.1.
    Standard vector-space facts invoked for the tree representation; no novel mathematics is claimed.
invented entities (2)
  • Index tree (prefix-closed set of multi-indices) independent evidence
    purpose: Formal characterization of admissible basis numberings; the paper's central abstraction (Definitions 3 to 5).
    Implemented in the released dune-functions 2.10 code, so the abstraction is testable externally; not an unobservable.
  • Merging strategy taxonomy (blocked/flat, lexicographic/interleaved, power nodes) independent evidence
    purpose: Recursive construction of multi-indices over basis trees (Examples 1 to 3).
    The four strategies are shipped as documented tags (BlockedLexicographic, FlatInterleaved, etc.) in dune-functions, providing an external handle.

reviewed 2026-08-05 · how reviews work

0 comments
Cite this review

Pith. "Pith review of Concepts for Composing Finite Element Function Space Bases." pith.science (2026). https://pith.science/paper/AW4UZIPG

@misc{pith2026250810125,
  author       = {Pith},
  title        = {Pith review of: Concepts for Composing Finite Element Function Space Bases},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/AW4UZIPG}},
  note         = {Machine review of arXiv:2508.10125}
}
Share X Bluesky LinkedIn Reddit HN
read the original abstract

Finite Element discretizations of coupled multi-physics partial differential equation models require the handling of composed function spaces. In this paper we discuss software concepts and abstractions to handle the composition of function spaces, based on a representation of product spaces as trees of simpler bases. From this description, many different numberings of degrees of freedom by multi-indices can be derived in a natural way, allowing to adapt the function spaces to very different data layouts, so that it opens the possibility to directly use the finite element code with very different linear algebra codes, different data structures, and different algebraic solvers. A recurring example throughout the paper is the stationary Stokes equation with Taylor--Hood elements as these are naturally formulated as product spaces and highlight why different storage patterns are desirable. In the second half of the paper we discuss a particular realization of most of these concepts in the \dunemodule{dune-functions} module, as part of the DUNE ecosystem.

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Forward citations

Cited by 2 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score.

  1. Disorder-induced persistent random motion and trapping of microswimmers

    cond-mat.soft 2026-03 conditional novelty 6.0

    Deterministic hydrodynamics plus disorder alone produce effective diffusion and reversible pusher–puller trapping asymmetry for squirmers in 2D porous media.

  2. Voltage Support Procurement in Transmission Grids: Incentive Design via Online Bilevel Games

    math.OC 2025-08 unverdicted novelty 4.0

    The abstract claims an online Stackelberg incentive design for TSO-DSO voltage support, but the body text is an unrelated manuscript, leaving the central claim unverifiable.

Reference graph

Works this paper leans on

27 extracted references · 17 canonical work pages · cited by 2 Pith papers · 1 internal anchor

  1. [1]

    Computers & Mathematics with Applications 81, 407–422 (2021) https://doi.org/10.1016/j.camwa.2020.02.022

    Arndt, D., Bangerth, W., Davydov, D., Heister, T., Heltai, L., Kronbichler, M., Maier, M., Pelteret, J.-P., Turcksin, B., Wells, D.: The deal.II finite ele- ment library: Design, features, and insights. Computers & Mathematics with Applications 81, 407–422 (2021) https://doi.org/10.1016/j.camwa.2020.02.022

    doi:10.1016/j.camwa.2020.02.022 2021

  2. [2]

    Zenodo (2023)

    Baratta, I.A., Dean, J.P., Dokken, J.S., Habera, M., Hale, J.S., Richardson, C.N., Rognes, M.E., Scroggs, M.W., Sime, N., Wells, G.N.: DOLFINx: the next gener- ation FEniCS problem solving environment. Zenodo (2023). https://doi.org/10. 5281/zenodo.10447666 10https://gitlab.dune-project.org/staging/dune-functions/ 28

    work page 2023

  3. [3]

    Hecht, F.: New development in FreeFem++. J. Numer. Math. 20(3–4), 251–265 (2012) https://doi.org/10.1515/jnum-2012-0013

    doi:10.1515/jnum-2012-0013 2012

  4. [4]

    Computers & Mathematics with Applications 81, 42–74 (2021) https://doi.org/10.1016/j.camwa.2020.06.009

    Anderson, R., Andrej, J., Barker, A., Bramwell, J., Camier, J.-S., Cerveny, J., Dobrev, V., Dudouit, Y., Fisher, A., Kolev, T., Pazner, W., Stowell, M., Tomov, V., Akkerman, I., Dahm, J., Medina, D., Zampini, S.: MFEM: A modular finite element methods library. Computers & Mathematics with Applications 81, 42–74 (2021) https://doi.org/10.1016/j.camwa.2020.06.009

    doi:10.1016/j.camwa.2020.06.009 2021

  5. [5]

    Technical Report ASC Report 30/2014, Institute for Analysis and Scientific Computing, Vienna University of Technology (2014)

    Sch¨ oberl, J.: C++11 implementation of finite elements in NGSolve. Technical Report ASC Report 30/2014, Institute for Analysis and Scientific Computing, Vienna University of Technology (2014)

    work page 2014

  6. [6]

    Springer, Berlin Heidelberg (2013)

    Braess, D.: Finite Elemente. Springer, Berlin Heidelberg (2013). https://doi.org/ 10.1007/978-3-642-34797-9

    doi:10.1007/978-3-642-34797-9 2013

  7. [7]

    Acta Numerica 5, 1–43 (1996) https://doi.org/10.1017/S0962492900002610

    Bank, R.E.: Hierarchical bases and the finite element method. Acta Numerica 5, 1–43 (1996) https://doi.org/10.1017/S0962492900002610

    work page doi:10.1017/s0962492900002610 1996

  8. [8]

    Springer, New York (2008)

    Hesthaven, J.S., Warburton, T.: Nodal Discontinuous Galerkin Methods. Springer, New York (2008). https://doi.org/10.1007/978-0-387-72067-8

    doi:10.1007/978-0-387-72067-8 2008

  9. [9]

    PhD thesis, Universit¨ at Stuttgart (2015)

    M¨ uthing, S.: A flexible framework for multi physics and multi domain pde simulations. PhD thesis, Universit¨ at Stuttgart (2015)

    work page 2015

  10. [10]

    International Journal for Numerical Methods in Engineer- ing 46(1), 131–150 (1999) https://doi.org/10.1002/(SICI)1097-0207(19990910) 46:1⟨131::AID-NME726⟩3.0.CO;2-J

    Mo¨ es, N., Dolbow, J., Belytschko, T.: A finite element method for crack growth without remeshing. International Journal for Numerical Methods in Engineer- ing 46(1), 131–150 (1999) https://doi.org/10.1002/(SICI)1097-0207(19990910) 46:1⟨131::AID-NME726⟩3.0.CO;2-J

    doi:10.1002/(sici)1097-0207(19990910 1999

  11. [11]

    SIAM, PA (2002)

    Ciarlet, P.G.: The Finite Element Method for Elliptic Problems. SIAM, PA (2002). https://doi.org/10.1137/1.9780898719208

    doi:10.1137/1.9780898719208 2002

  12. [12]

    arXiv: 2506.23558 (2025)

    Blatt, M., Burbulla, S., Burchardt, A., Dedner, A., Engwer, C., Gr¨ aser, C., Gr¨ uninger, C., Kl¨ ofkorn, R., Koch, T., Ospina De Los R ´ ıos, S., Praetorius, S., Sander, O.: The Distributed and Unified Numerics Environment (DUNE), version 2.10. arXiv: 2506.23558 (2025)

    Pith/arXiv arXiv 2025

  13. [13]

    Part I: abstract framework

    Bastian, P., Blatt, M., Dedner, A., Engwer, C., Kl¨ ofkorn, R., Ohlberger, M., Sander, O.: A generic grid interface for parallel and adaptive scientific computing. Part I: abstract framework. Computing 82(2–3), 103–119 (2008) https://doi.org/ 10.1007/s00607-008-0003-x

    doi:10.1007/s00607-008-0003-x 2008

  14. [14]

    Part II: implementation and tests in DUNE

    Bastian, P., Blatt, M., Dedner, A., Engwer, C., Kl¨ ofkorn, R., Kornhuber, R., Ohlberger, M., Sander, O.: A generic grid interface for parallel and adaptive scientific computing. Part II: implementation and tests in DUNE. Computing 82(2–3), 121–138 (2008) https://doi.org/10.1007/s00607-008-0004-9 29

    doi:10.1007/s00607-008-0004-9 2008

  15. [15]

    Technical report, Interdisciplinary Centre for Scientific Computing (IWR), University Heidelberg, Im Neuenheimer Feld 368, 69120 Heidelberg, Germany (2007)

    Blatt, M., Bastian, P.: The iterative solver template library. Technical report, Interdisciplinary Centre for Scientific Computing (IWR), University Heidelberg, Im Neuenheimer Feld 368, 69120 Heidelberg, Germany (2007)

    work page 2007

  16. [16]

    An adaptive central-upwind scheme on quadtree grids for variable density shallow water equations

    Blatt, M., Bastian, P.: On the generic parallelisation of iterative solvers for the finite element method. International Journal of Computational Science and Engineering 4(1), 56–69 (2008) https://doi.org/10.1504/IJCSE.2008.021112

    work page internal anchor Pith review Pith/arXiv arXiv 2008

  17. [17]

    Kybernetika 46(2), 294–315 (2010)

    Bastian, P., Heimann, F., Marnach, S.: Generic implementation of finite ele- ment methods in the Distributed and Unified Numerics Environment (DUNE). Kybernetika 46(2), 294–315 (2010)

    work page 2010

  18. [18]

    https://dune-project.org/modules/dune-pdelab (2025)

    Dune-PDELab. https://dune-project.org/modules/dune-pdelab (2025)

    work page 2025

  19. [19]

    Computing 90(3–4), 165–196 (2010) https://doi.org/10

    Dedner, A., Kl¨ ofkorn, R., Nolte, M., Ohlberger, M.: A generic interface for parallel and adaptive discretization schemes: abstraction principles and the Dune-Fem module. Computing 90(3–4), 165–196 (2010) https://doi.org/10. 1007/s00607-010-0110-3

    work page 2010

  20. [20]

    https://dune-project.org/modules/dune-fem (2025)

    Dune-Fem. https://dune-project.org/modules/dune-fem (2025)

    work page 2025

  21. [21]

    https://gitlab.dune-project.org/fufem/dune-fufem (2025)

    Dune-Fufem. https://gitlab.dune-project.org/fufem/dune-fufem (2025)

    work page 2025

  22. [22]

    https://gitlab.com/amdis/amdis

    Praetorius, S.: The Adaptive Multi-Dimensional Simulation toolbox (AMDiS). https://gitlab.com/amdis/amdis. Version: 2.10 (2025)

    work page 2025

  23. [23]

    Archive of Numerical Software 5(1), 95–105 (2017) https://doi.org/10.11588/ans.2017.1.27683

    Engwer, C., Gr¨ aser, C., M¨ uthing, S., Sander, O.: The interface for functions in the dune-functions module. Archive of Numerical Software 5(1), 95–105 (2017) https://doi.org/10.11588/ans.2017.1.27683

    work page doi:10.11588/ans.2017.1.27683 2017

  24. [24]

    https://petsc.org/

    Balay, S., Abhyankar, S., Adams, M.F., Benson, S., Brown, J., Brune, P., Buschelman, K., Constantinescu, E.M., Dalcin, L., Dener, A., Eijkhout, V., Faibussowitsch, J., Gropp, W.D., Hapla, V., Isaac, T., Jolivet, P., Karpeev, D., Kaushik, D., Knepley, M.G., Kong, F., Kruger, S., May, D.A., McInnes, L.C., Mills, R.T., Mitchell, L., Munson, T., Roman, J.E., ...

    work page 2025

  25. [25]

    https://gitlab.com/libeigen/eigen

    Eigen is a C++ template library for linear algebra: matrices, vectors, numerical solvers, and related algorithms. https://gitlab.com/libeigen/eigen. Version: 3.4 (2021)

    work page 2021

  26. [26]

    https://trilinos.github.io (2020)

    The Trilinos Project. https://trilinos.github.io (2020)

    work page 2020

  27. [27]

    https://gitlab

    Enger, C., Gr¨ aser, C., Praetorius, S., Sander, O.: Dune-Assembler. https://gitlab. dune-project.org/staging/dune-assembler (2025) 30

    work page 2025

This paper was first reviewed by deepseek-v4-flash on August 5, 2026.