{"id":"765eb592-7e95-4a80-8cc7-948b6cf7f626","arxiv_id":"2412.14132","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"The paper introduces jinns, a JAX-native PINN library with claimed first-of-its-kind status and superior speed for inverse problems, supported by a small benchmark study.","lead":"jinns is a new Python library for physics-informed neural networks built entirely on JAX, aimed at solving forward and inverse differential equation problems and meta-modeling. This paper describes its design and reports a benchmark comparing it to DeepXDE, PINA, and NVIDIA Modulus, showing competitive speed, especially for inverse problems.","discovery_kind":"new_application","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The 'fastest library for inverse problems' claim is contradicted by the paper's own Table 1: on the Poisson inverse problem, Modulus JAX (135s) is faster than jinns (149s), so the performance claim needs revision or stronger evidence.","rationale":"The reader's weakest assumption correctly targeted the benchmark's methodological fragility: single-run timings, one GPU, and uncertain hyper-parameter equality. My stress-test agrees with that concern but sharpens it into an internal inconsistency: the paper's own Table 1 directly contradicts the 'fastest library for inverse problems' claim on the PInv problem, where Modulus JAX is faster and more accurate. This is not a matter of external consensus or reproducibility alone; the evidence presented in the paper itself fails to support the categorical claim. I do not see a reason to reject the paper: jinns is a real, documented, open-source library with reproducible code, and the benchmark code is provided. A conditional verdict remains appropriate, with the requirement that the authors either revise the speed claim to be per-problem or repeat the benchmark with multiple seeds, controlled sampling, and equal hyper-parameters. The 'first JAX-only PINN library' claim is harder to verify but less load-bearing for the paper's practical contribution, so I leave it aside. My agreement with the reader is partial because the reader identified the benchmark as the weak point but did not notice the direct contradiction within Table 1.","tokens_in":7348,"tokens_out":3515,"duration_ms":33185,"concrete_test":"Rerun the Poisson inverse problem (PInv) from Table 1 with jinns and NVIDIA Modulus JAX using identical numbers of collocation points, the same optimizer, learning rate, iteration count, and validation metric, across at least 10 independent random seeds, recording wall-clock time and parameter error for each seed. If Modulus JAX is faster than jinns in the majority of seeds, Section 2.5's categorical 'fastest library for inverse problems' claim must be revised to a per-problem speed comparison.","verdict_should_be":"UNCHANGED","load_bearing_attack":"Section 2.5 states that 'jinns compares favorably to the other libraries, in particular, it is the fastest library for inverse problems.' Yet Table 1, row PInv, reports jinns at 149s and NVIDIA Modulus JAX at 135s. This is one of the three inverse problems in the benchmark, and on this problem jinns is neither the fastest nor the most accurate: the same row in Tables 2 and 3 shows jinns L1/L2 errors of 0.070/0.088 while Modulus JAX achieves 0.034/0.043. The claim 'fastest for inverse problems' is therefore not supported by the paper's own reported evidence, unless it is restricted to specific problems (e.g., Diffusion-Reaction-Inv and Navier-Stokes-Inv). The methodological limitations noted in Appendix C.2 compound this: all hyper-parameters are said to be equal, but the appendix immediately excepts Modulus, whose collocation points are sampled uniformly rather than regularly spaced; and each timing appears to be a single run on one GPU, with no error bars or seed variation. The central performance claim thus rests on an internally inconsistent benchmark report. The library's broader value as a JAX-native PINN framework is not undermined, but the headline 'fastest' claim should be corrected to a per-problem statement or backed by more rigorous, repeated runs with controlled sampling and equal hyper-parameters.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper presents jinns, an open-source Python library for physics-informed neural networks built natively on the JAX ecosystem, with support for forward problems, inverse problems, and meta-modeling. The authors describe the library's modular design (data, parameters, loss, utility modules), its reliance on equinox and optax, and its use of forward and reverse automatic differentiation, including support for SPINN and HyperPINN architectures. They report a benchmark against DeepXDE, PINA, and NVIDIA Modulus on five problems (Burgers1D, NS2d-C, Poisson inverse, Diffusion-Reaction inverse, Navier-Stokes inverse), claiming that jinns is the fastest library for inverse problems and that the code is reproducible via a dedicated Gitlab repository. The paper also includes code listings illustrating the definition of PDE losses in jinns.","tokens_in":7612,"tokens_out":3116,"duration_ms":28734,"significance":"If its claims are supported, jinns fills a genuine gap in the PINN software ecosystem: a JAX-native library that handles inverse problems and meta-modeling, where the paper states that DeepXDE's JAX backend cannot be used to its full extent. The library appears well-structured and thoughtfully designed: it leverages existing JAX standards (equinox, optax), separates equation parameters from neural-network parameters, offers a DerivativeKeys mask for granular differentiation of loss terms, and provides documentation, tutorials, unit tests, and reproducible benchmark code. The code listings and the description of the workflow indicate that the library is usable and extensible. The central performance claim, however, is not currently supported by the paper's own reported data, and the benchmark methodology is not sufficient to establish a global speed advantage. The software contribution itself is valuable, but the paper's headline claim needs to be corrected or substantially re-evidenced.","major_comments":[{"comment":"The statement that 'jinns compares favorably to the other libraries, in particular, it is the fastest library for inverse problems' is contradicted by the paper's own Table 1. On the Poisson inverse problem (PInv), jinns takes 149 s while NVIDIA Modulus JAX takes 135 s, and Tables 2 and 3 show jinns with L1/L2 errors of 0.070/0.088 versus Modulus JAX's 0.034/0.043. The 'fastest' claim therefore holds only for some inverse problems (e.g., Diffusion-Reaction-Inv and Navier-Stokes-Inv), not for the inverse-problem category as a whole. The claim should either be restricted to per-problem statements or supported by more comprehensive evidence.","section":"Section 2.5, Tables 1-3"},{"comment":"The benchmark timing results are based on a single run on a single Nvidia T600 GPU, with no error bars, no multiple seeds, and no measure of run-to-run variability. Since PINN training involves stochastic initialization and, for Modulus, stochastic collocation-point sampling, a single-run comparison is not a reliable basis for a 'fastest library' claim. The paper should either report repeated runs with means and variances, or soften the conclusion to describe the observed single-run timings.","section":"Appendix C.2"},{"comment":"The claim that 'all hyper-parameters are equal across all libraries' is immediately qualified by the exception that Modulus uses uniformly sampled collocation points rather than regularly spaced points. This exception means that the benchmark does not actually control the sampling scheme across libraries. Since the paper does not enumerate the chosen hyper-parameters (learning rate, network width/depth, optimizer settings, number of iterations, etc.) beyond referring to scripts in the repository, the reader cannot independently verify that the comparison is fair. A table of hyper-parameters per problem and library, or a more explicit discussion of how the Modulus sampling exception could affect timings and accuracy, is needed.","section":"Appendix C.2"}],"minor_comments":[{"comment":"The phrase 'backward problems' is used to mean 'inverse problems'; this terminology is non-standard and may confuse readers. Consider using 'inverse' consistently throughout the introduction.","section":"Section 1"},{"comment":"There is a typo in 'inhomegeneous'; it should be 'inhomogeneous'.","section":"Section 2.2"},{"comment":"The word 'litterature' should be 'literature'.","section":"Section 2.1, utils module"},{"comment":"The code listing defines 'source term(xy)' with one argument but calls 'source term(x, params)' with two arguments; this inconsistency should be corrected.","section":"Appendix B, Code 2"},{"comment":"The text states that the last two rows are identical in Tables 2 and 3 because they report errors on two scalar parameters; clarifying how L1 and L2 relative errors are computed for scalar parameter estimates would make the table easier to interpret.","section":"Appendix C.3, Tables 2-3"}],"recommendation":"major_revision","confidential_remarks":"The paper's main software contribution is credible and likely useful to the community, but the authors' own benchmark data contradict the strongest advertised claim. I would encourage the editor to ask for a revision that either directly addresses the Poisson inverse discrepancy by re-running or re-reporting, or clearly limits the performance claim to specific problems and adds uncertainty quantification. The 'first JAX-only PINN library' and 'first multi-library comparison' claims are also strong; the authors may want to check for prior work to avoid overclaiming."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"This is a library paper with real engineering value: jinns gives you a JAX-native PINN framework that actually supports inverse problems and meta-modeling, which is something the JAX backend of DeepXDE doesn't do well. The API is modular, the code is open and tested, and the DerivativeKeys idea—letting you control which loss terms are differentiated with respect to equation parameters vs network weights—is genuinely handy for inverse problems. The benchmark against DeepXDE, PINA, and Modulus is a useful addition, even though it has problems.\n\nThe main soft spot is the headline performance claim. The paper says jinns \"is the fastest library for inverse problems,\" but its own Table 1 shows that on the Poisson inverse problem, one of the three inverse benchmarks, Modulus's PyTorch backend finishes in 135s with better accuracy while jinns takes 149s. The stress-test note misreads the table—the 135s is Modulus PyTorch, not Modulus JAX, which is 1509s—and that correction matters because the claim is still not fully supported. It would be accurate to say \"fastest on two of three inverse problems\" or \"fastest among JAX libraries,\" not \"the fastest for inverse problems.\" Second, the benchmark methodology is thin: single runs on one T600 GPU, no error bars or seed variation, and the appendix admits that Modulus samples collocation points uniformly while the others use regular grids under the cover of \"all hyper-parameters are equal.\" These issues make the \"fastest\" claim softer than the prose suggests.\n\nThat said, the library stands on its own. The design choices (equinox for modules, optax for optimization, pure JAX PyTrees) are sensible, and the docs/tutorials are a real strength. The \"first JAX-only PINN library\" claim is plausible but unverifiable from the paper; that's a minor point. The citation pattern is fine; no self-citation inflation.\n\nWho should read this? Anyone choosing a PINN library for a JAX-based project, or building on equinox for scientific ML. It deserves a serious referee because the code and benchmark are reproducible and the claims are checkable. My recommendation: send it to review, and require the authors to qualify the \"fastest\" claim, add repeated runs or at least error bars, and fix the benchmark appendix so that hyper-parameter equality is actually true. With those revisions, it's a solid contribution to the PINN tooling literature.","headline":"Solid JAX-native PINN library with real engineering value, but the 'fastest for inverse problems' claim overreaches the paper's own benchmark data.","tokens_in":8146,"tokens_out":7018,"would_cite":true,"duration_ms":55220,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"The paper claims that jinns is the first PINN library built entirely on the JAX ecosystem, and that this native design makes it the fastest library for inverse problems in a five-problem benchmark against three established Python PINN…","keywords":["physics-informed neural networks","PINNs","JAX","python","inverse problems","meta-modeling","open-source software"],"falsifier":"Re-run the five benchmark problems on at least two different GPUs with many repeated trials per library, and check the benchmark scripts for identical optimizers, learning-rate schedules, collocation-point sets, and stopping criteria across all libraries; if another library is faster on average for the inverse problems, or if the scripts reveal unequal hyperparameters, the paper's central speed claim is refuted.","tokens_in":7135,"feed_emoji":"⚡","tokens_out":9023,"duration_ms":71279,"temperature":0.7,"pith_summary":"The paper introduces jinns, an open-source Python library for physics-informed neural networks built entirely on the JAX ecosystem. Its central claim is twofold: jinns is the first PINN library to be native to that ecosystem, and in a benchmark against three established Python PINN libraries on five problems, it is the fastest for inverse problems, with speed-ups up to about an order of magnitude. The paper argues this matters because no dedicated JAX-native PINN library existed, and one major comparison library's JAX backend cannot handle inverse problems. jinns is designed around an explicit split between network weights and equation parameters, with a derivative mask controlling which loss terms are differentiated with respect to which parameters, so forward problems, inverse problems, and meta-modeling share one interface.","feed_headline":"JAX-only PINN library posts fastest inverse-problem times","feed_subtitle":"jinns brings forward and inverse physics-informed neural networks to the JAX stack, with up to 10x speed-ups.","key_machinery":"The argument rides on jinns' modular architecture rather than on a single mathematical identity. The core objects are the Params class, which separates equation parameters from neural-network weights, and the optional DerivativeKeys mask, which controls how each loss component is differentiated with respect to each parameter set; these two mechanisms let one training loop serve forward, inverse, and meta-modeling problems. The library also uses equinox.Module for transparent PyTree registration, so jax.jit, jax.grad, and jax.vmap compose with user-defined models, and it relies on optax for optimization. For evaluation, the benchmark reproduces problems from the PINNacle suite and from the DeepXDE documentation, comparing training times and relative errors against three other Python PINN libraries on an Nvidia T600 GPU.","core_discovery":"The paper's central claim is a software design and an associated empirical result: a modular PINN library written in pure JAX, relying on the equinox and optax libraries for models and optimization, can cover forward problems, inverse problems, and meta-model learning in a uniform interface while remaining fast. The design separates the neural network parameters from the differential operator parameters, and lets users specify a derivative mask so the physics loss, boundary terms, or data terms can be differentiated with respect to either set independently. In the reported benchmark, jinns completes inverse problems in the shortest training time among the compared libraries, with gains up to roughly tenfold over the next fastest on problems such as diffusion-reaction and Navier-Stokes parameter identification, at error levels comparable to the other implementations.","pith_inferences":["The derivative-mask design points beyond the reported use cases: the same mechanism should make it straightforward to train meta-models that differentiate the loss with respect to equation parameters on a per-term basis, a pattern the paper leaves implicit.","Because jinns is pure JAX, it should compose with JAX's parallel and distributed transforms such as pmap and sharding; the paper does not benchmark these, so whether the speed advantage extends to multi-GPU or batch-parallel settings is untested.","The benchmark's single-run, single-GPU measurements are not enough to establish a stable ordering across hardware and random seeds; a repeated-run study would tell whether jinns is reliably the fastest rather than fastest in this particular run."],"forward_implications":["Users of the JAX stack can set up PINN forward and inverse problems without leaving the JAX ecosystem, since models, optimizers, and transformations all come from the same set of libraries.","Inverse problems that the JAX backend of the main comparison library cannot express become implementable, because jinns is JAX-native rather than a backend shim.","Out-of-the-box baselines include SeparablePINN and HyperPINN architectures alongside vanilla MLPs, so architecture comparisons do not require reimplementing them.","If the benchmark timings hold, jinns offers up to a tenfold reduction in training time for inverse problems at comparable estimation error, making parameter-identification studies substantially cheaper."],"supporting_citations":[{"why":"Supplies the PINN formulation and the Navier-Stokes inverse problem used as a benchmark.","marker":"Raissi et al., 2019"},{"why":"Supplies the PINNacle benchmark problems (Burgers, Navier-Stokes, Poisson inverse) on which the comparison is based.","marker":"Hao et al., 2023"},{"why":"Defines DeepXDE, the main comparison library, whose JAX backend cannot handle inverse problems and thereby motivates jinns.","marker":"Lu et al., 2021"},{"why":"Defines PINA, a second comparison library in the benchmark.","marker":"Coscia et al., 2023"},{"why":"Defines Modulus, the third comparison library in the benchmark.","marker":"NVIDIA, 2023"},{"why":"Defines JAX, the ecosystem jinns is built on, grounding the claim of a JAX-native library.","marker":"Bradbury et al., 2024"},{"why":"Supplies the SeparablePINN architecture implemented in jinns as a baseline.","marker":"Cho et al., 2024"},{"why":"Supplies the HyperPINN architecture implemented in jinns for parametric and meta-modeling problems.","marker":"de Avila Belbute-Peres et al., 2021"}],"fun_headline_variants":["JAX PINN library cuts inverse-problem training up to 10x","jinns: pure-JAX PINNs for fast inverse problems","New JAX library speeds PINN inverse problems tenfold","jinns: JAX-based PINNs for fast forward and inverse tasks","Fast inverse PINNs with jinns, a JAX-native library"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The central performance claim rests on the benchmark setup being fair: all hyperparameters truly equal across libraries, and a single run on one Nvidia T600 GPU being representative; if those do not hold, the conclusion that jinns is the fastest library for inverse problems collapses.","fun_headline_variants_meta":{"raw":{"variants":["JAX PINN library cuts inverse-problem training up to 10x","jinns: pure-JAX PINNs for fast inverse problems","New JAX library speeds PINN inverse problems tenfold","jinns: JAX-based PINNs for fast forward and inverse tasks","Fast inverse PINNs with jinns, a JAX-native library"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000638,"raw_usage":{"total_tokens":2876,"prompt_tokens":816,"completion_tokens":2060,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":432,"completion_tokens_details":{"reasoning_tokens":1966}},"tokens_in":432,"tokens_out":2060,"duration_ms":12514,"temperature":1.0,"reasoning_tokens":1966,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-11T12:25:55.575489+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Re-run the five benchmark problems on at least two different GPUs with many repeated trials per library, and check the benchmark scripts for identical optimizers, learning-rate schedules, collocation-point sets, and stopping criteria across all libraries; if another library is faster on average for the inverse problems, or if the scripts reveal unequal hyperparameters, the paper's central speed claim is refuted.","supporting_citations":[{"cited_title":"Physics-informed neural networks for advanced modeling","cited_arxiv_id":null,"evidence_quote":"Defines PINA, a second comparison library in the benchmark."},{"cited_title":"Nvidia modulus, 2023","cited_arxiv_id":null,"evidence_quote":"Defines Modulus, the third comparison library in the benchmark."},{"cited_title":"JAX : composable transformations of P ython+ N um P y programs, 2024","cited_arxiv_id":null,"evidence_quote":"Defines JAX, the ecosystem jinns is built on, grounding the claim of a JAX-native library."},{"cited_title":"Separable physics-informed neural networks","cited_arxiv_id":null,"evidence_quote":"Supplies the SeparablePINN architecture implemented in jinns as a baseline."},{"cited_title":"Hyperpinn: Learning parameterized differential equations with physics-informed hypernetworks","cited_arxiv_id":null,"evidence_quote":"Supplies the HyperPINN architecture implemented in jinns for parametric and meta-modeling problems."}],"review_version":1}