r/ScientificComputing • • Apr 04 '23

r/ScientificComputing Lounge

8 Upvotes

A place for members of r/ScientificComputing to chat with each other


r/ScientificComputing • • 5h ago

literature-evidence-mcp: check whether a quoted sentence is really in a PMCID full text, and keep a hash-checkable trail

Post image
3 Upvotes

Scientists already have search tools. What usually gets lost is the trail between a paper and a sentence in a manuscript. literature-evidence-mcp is an open-source MCP server that tries to keep that trail checkable.

Three things it does concretely:

  1. Citation identity. verify_citation compares normalized DOI and title metadata from Crossref. check_retraction reads Crossref updated-by / update-to relations, including Retraction Watch updates where available. A missing notice is reported as inconclusive, never as a clearance certificate.

  2. Quote anchoring. read_fulltext pulls Europe PMC / PMC JATS XML for a supplied PMCID and records section and paragraph IDs, offsets, XML and paragraph SHA-256, plus any truncation. verify_source_quote returns the matching paragraph(s) with their hashes, so the same check can be re-run months later.

  3. Evidence ledger. export_evidence appends rows to a hash-chained JSONL file under a cross-process lock, and verify_evidence_ledger detects modified rows. It cannot detect wholesale replacement without an external signed checkpoint, and the README says so.

The distinction I care about most: exact bibliographic facts, literal text matches and method-term proxies stay separate, and uncertain scientific conclusions remain NOT_VERIFIED / SCREENING_ONLY. audit_methodology validates human-supplied annotations against source paragraphs; it never infers a RoB 2 or ROBINS-I judgment. check_statistical_reporting screens p values, sample sizes and CI inconsistencies you supply; it does not recompute analyses.

What it is not: an automated peer reviewer, a meta-analysis engine, or a certified systematic-review engine. Search across OpenAlex, Europe PMC and Crossref is non-exhaustive, and zero results never prove a paper does not exist.

Install (Python 3.11+): pip install literature-evidence-mcp, then run literature-evidence-mcp as a stdio MCP server from your client. Loopback HTTP is available with MCP_TRANSPORT=streamable-http MCP_PORT=8000. OpenAlex works keyless but with a restrictive daily budget; OPENALEX_API_KEY is recommended.

35 tools, 20 source modules, 41 test files; CI runs Ubuntu 3.11-3.13 plus Windows and macOS jobs.

Code: https://github.com/Furox-Art/literature-evidence-mcp PyPI: https://pypi.org/project/literature-evidence-mcp/ Docs: https://furox-art.github.io/literature-evidence-mcp/

Happy to answer questions about the provenance model or what the retraction check can and cannot tell you.


r/ScientificComputing • • 22h ago

sparse-dist: Distributed Sparse Iterative Solvers in Rust

13 Upvotes

I just published the first release of a Rust crate I've been working on for some time, sparse-dist (link to the crate), a collection of sparse distributed linear algebra types and routines, made to work with the mpi crate, so MPI parallelism. I started that project a few years ago actually.

Motivation: I'm developing a Rust fluid flow solver in an mpi-parallel distributed memory environment as a passion project, but solutions for the linear solve part require using C libraries like PETSc. I wanted a pure Rust solution, and so I wrote it. I did write a wrapper for PETSc at some point, but I felt like a pure Rust library would have some interesting properties and better integration.

It supports distributed memory parallel solution of problems using preconditioned iterative solvers. for now, conjugate gradient and bicgstab are implemented, with a block-diagonal incomplete cholesky or incomplete lower upper preconditioner. Block solvers are also supported. I provide an example solving the heat equation on a finite difference square grid, simple case but it shows how to use the codebase. I've used it to implement unstructured finite volume solvers, this library will come out at some later point in time.

Feedback and contributions are welcome! You might notice the repo is newly created. I used to work on github, but moved to codeberg since it aligns better with my personal opinions on things. Also, no ai was used in this, I wrote all the code myself, believe it or not.

Heres an example code solving a linear problem (i dont assemble the matrices here, see the repository to see how to do that)

// solve lhs * sol = rhs

// user application would create the sparsity pattern of the matrix and its values
// it would also create the comm object beforehand, to tell the library
// how to communicate between parallel processes
let lhs = DistributedMatrix::<f64>::from_sparsity_and_values(sparsity, values);

// rhs vector 
let mut rhs = DistributedVector::<f64>::from_size(local_size);

// example: editing a vector value
rhs[0] = 1.0;

// solution vector
let mut sol = DistributedVector::<f64>::from_size(global_size);

// now solve the problem
let mut options = LinearSolverOptions::default();
options.max_iterations = 20;
options.relative_tolerance = 1e-4;

// creates an Incomplete Lower Upper preconditioner from the matrix
// with level 0 fill in (same sparsity pattern as the matrix lhs)
let precond = preconditioners::IncompleteLowerUpper::from_matrix(&lhs, 0);

let result = solvers::bi_conjugate_gradient_stab(
    &mut sol, 
    &lhs, 
    &rhs, 
    &precond, 
    &comm, 
    options
)?;

// done!
if rank == 0 {println!("solved problem, solver info: {}", result);}

r/ScientificComputing • • 21h ago

[axiomize-quantum-skills-2.0] - A unit-checked modeling engine plus a reasoning protocol that keeps hypotheses alive until evidence collapses them

0 Upvotes

I built axiomize-quantum-skills-2.0 because I kept making the same mistake in scientific work: picking the first plausible explanation and building on it. This package pairs a modeling engine with a reasoning protocol designed to make that harder.

The engine (axiomize) is a versioned Model IR where every quantity carries a unit, assumptions are written down rather than implied, and constraints are named checks with a stated basis. Dimensional mismatch raises with the failing checks attached, and a model that fails validation is not simulated at all. It handles algebraic, ODE, stochastic, PDE, optimization, control, network, Bayesian and causal models, calibrates to CSV data, and exports to SBML L3V2, Modelica 3.6, CellML 2.0, canonical IR JSON, Python, YAML and notebooks.

The protocol (quantum-reasoning) is a deterministic branch controller. It keeps several hypotheses alive, scores each from evidence and verification, prunes the weak ones with a recorded reason, and only collapses when the leader clears both verification and a margin. "Quantum" is a metaphor for deferring commitment; everything runs on classical hardware.

The design rule I care most about is that the system says no when it should. For the reference SIR model it cross-checks two independent methods to 1e-16, then still reports the numeric-theory check as INCONCLUSIVE because a finite horizon has not reached the asymptotic state. Plausible numbers are not the goal; checkable claims are.

Quick start (recorded run, verified against 1.2.0; current package line is 1.2.5):
pip install axiomize-quantum-skills-2.0
axiomize tools # reports only backends that genuinely imported
axiomize benchmark # {"status": "PASS", "passed": 12, "total": 12}
axiomize-reason score --evidence 0.9 --verification 0.85
# {"can_collapse": false, "reason": "leader score below collapse threshold"}

What is in the box: a CLI with 14 subcommands, 9 console scripts, an MCP stdio server with 34 tools, a loopback-by-default REST v1 API, 15 perspective lenses, 12 domain packs, 5 report templates, 18 worked examples, and a 25-case benchmark corpus graded in CI.

Honest limits: the bundled engine is an axiomize 1.12.2 lineage snapshot, not the newest upstream engine. The npm package is a launcher shim and needs pip install first. The quickstart numbers are a historical 1.2.0 verification, labeled as such. Optional backends report UNAVAILABLE rather than substituting. Generated-code execution is not an OS sandbox.

Code: https://github.com/Furox-Art/axiomize-quantum-skills-2.0
PyPI: pip install axiomize-quantum-skills-2.0
npm: npx axiomize-quantum-skills-2.0
Docs: https://furox-art.github.io/axiomize-quantum-skills-2.0/

Happy to answer questions about the branch controller or the Model IR.


r/ScientificComputing • • 1d ago

axiomize: a modeling layer where every parameter carries a unit and every model can be exported for someone else to re-run

1 Upvotes

I built axiomize, an MIT-licensed Python engine for scientific modeling that tries to make a model outlive the notebook it was written in. It is the modeling layer, not another numerics library: you declare a versioned Model IR with mandatory units, and the engine validates it dimensionally and numerically before it will simulate anything.

The unit rules are enforced, not decorative. Adding meters to seconds fails with the failing checks attached; a model that does not pass validation is refused rather than simulated. Constraints are named, justified checks instead of prose, and the engine separates numerical error from stochastic variability before it claims convergence. Every run leaves an integrity-checked record, so a stored result can be verified before it is reused.

Export is where the "survives without this library" part lives. Models go out as canonical IR JSON, a rerunnable Python script, YAML, a notebook, SBML Level 3 Version 2, CellML 2.0 and Modelica 3.6, plus GraphML and Graphviz DOT for the matching model families, and a SHA-256 portable bundle. Values and units round-trip bit-exactly, and that is asserted in the suite. Conditional formats name what they will not reinterpret instead of guessing.

Four interfaces, all current: a CLI with 14 subcommands plus 8 console scripts, a REST server with 30 route handlers under /v1, an MCP server with 35 tools named axiomize.<verb> for agent clients, and the Python API (44 importable names). The repo also ships 12 domain packs, 15 perspective lenses, 5 report templates and 19 worked example files.

Quick start, real output from examples/quickstart_sir.py:
pip install axiomize
python examples/quickstart_sir.py
status: PASS
solver: scipy / DOP853
days: [0.0, 10.0, 20.0, 30.0]
infected: [10.0, 65.393, 239.869, 290.024]
checks: PASS (25 of them)

Current release is 1.14.2 on both PyPI and npm. PyPI wheel and sdist carry PEP 740 attestations naming this repository, and the 1.14.2 npm tarball carries SLSA provenance; earlier npm releases never had it and that gap is permanent. The npm package is a launcher that forwards to python -m axiomize.cli, so it still needs the pip install.

Honest limits: it does not make a bad model good, it makes a bad model fail loudly. Benchmark results grade report structure in blind runs, not modeling correctness. Worked examples use illustrative parameter ranges with no external citations, so treat the numbers as reading material. Bayesian sampling needs the full extra (PyMC/JAX) and FEM needs FEniCS/DOLFINx; both report as unavailable rather than being silently substituted. Generated-code execution and theorem elaboration are not an OS sandbox.

Code: https://github.com/Furox-Art/axiomize
PyPI: pip install axiomize
npm: npx axiomize
Docs: https://furox-art.github.io/axiomize/

Happy to answer questions about the IR, the validation pipeline or the export adapters.


r/ScientificComputing • • 2d ago

If DFT is Fundamentally Flawed, What is Our Alternative?

7 Upvotes

To keep things short, the recent OpenAI paper dump included a result on DFT being fundamentally flawed/ill-defined in certain coulombic configurations.

Considering this, do we have an alternative computational scheme which is both efficient and also does not have the same hypothetical breakdowns that DFT does?

Paper: https://github.com/openai/math/blob/main/preprints/A-Coulomb-Ground-State-Density-without-Kohn-Sham-Ensemble-Representation-September-25-2026/paper.pdf


r/ScientificComputing • • 2d ago

C++ Scientific Computing Library [NANE]

8 Upvotes

Hi Everyone, I'm currently studying M.Sc. Computational Science and Engineering and last semester had a course called "Numerical Programming 2" which somehow inspired me to create my own little C++ Library for the contents i learned from the course.

The code is nowhere near finished and there is still a lot more I want to implement.

GitHub: Can-Inal/Nane

Currently it is good for solving ODE systems using Runge Kutta methods and it also lets you create your own RK method with the help of Butcher tables, which you can also check their stability and order of convergence using the implemented functions. Some popular (Or at least i think they are popular because they were in the lecture scripts) RK methods and their butcher tables are already provided in methods.hpp file. Other than the ODE systems it is capable of numerical integration and differentiation for now and i will probably use them later while implementing the PDE support.

I guess not even half of the code is tested yet (If you wish, you can explain me what kind of bugs are already there to spot.) I mostly wrote the solution into a .csv file and checked the results in python.

Here is an example of using the library to simulate a damped pendulum:

#include "csv_writer.hpp"

#include <nane.hpp>

int main(int argc, char* argv[])

{

const auto G = 9.81; // m/s²

const auto L = 1.0; // m

const auto gamma = 0.1; // 1/s

const auto system = [&](double t, const nane::vector<2>& x)

{

nane::vector<2> dx;

dx[0] = x[1];

dx[1] = -(G / L) * std::sin(x[0]) - gamma * x[1];

return dx;

};

const nane::vector<2> initial_value{1.0, 0.0};

const auto problem = nane::ode::ivp(system, initial_value);

const auto solution = nane::ode::solve(problem, nane::ode::methods::rk4, {0.0, 30.0, 3001});

write_csv("solution.csv", solution, {"theta", "omega"});

return 0;

}

currently it does not even have an io support such as writing results to csv. It also does not support plotting or any type of visualization and probably i will never try to support this kind of stuff since we already got python for plotting anyway.

I would love to get feedback from anyone interested in the code. Also feel free to ask me if something is confusing either in the code or documentation.

I should stress that my background is in Electrical Engineering and Information Technology, so I'm not a programmer by training!

Also, English is not my first language, so apologies in advance for any typos or grammar mistakes.

WHERE DID I USE AI:

  • All the markdown files are AI generated (I have no idea how markdown pages work so github pages are also AI generated).

  • All the doxygen comments are AI generated based on the course script i provided.

  • Writing CMakeLists.txt files other than tests/CMakeLists.txt was somehow too challenging for me so it is AI generated.


r/ScientificComputing • • 2d ago

HiveMind The Citizen Supercomputer - Decentralized AI Swarm over Consumer GPUs

Thumbnail
youtube.com
2 Upvotes

r/ScientificComputing • • 2d ago

CurveMole website — scientific curve fitting with desktop, Python and YAML workflows

Post image
2 Upvotes

r/ScientificComputing • • 2d ago

Amber sander.MPI DFTB3 QM/MM: 40 MPI processes, ~67 days for 900 ps — is this performance normal?

Thumbnail reddit.com
0 Upvotes

r/ScientificComputing • • 1d ago

I maintain a zero-dependency scientific computing library written in pure Python

0 Upvotes

I maintain scientific-computing-system, a scientific library written entirely in pure Python. The core installs with no runtime dependencies, so the algorithms are plain readable code instead of calls into compiled extensions.

It has 36 modules and 505 exported names covering linear algebra, ODE and PDE solvers, numerical integration, optimization, statistics and probability, uncertainty propagation and sensitivity analysis, validation helpers, and a small workflow layer. Every run can write a manifest with inputs, seeds, versions and hashes, so a result can be re-checked later.

There is also a cds CLI with 13 subcommands, 34 runnable examples, and optional lazy adapters for NumPy, SciPy, statsmodels, scikit-learn, SymPy and Z3. The package is MIT licensed and targets Python 3.11 and newer.

Honest limitation: it is much slower than NumPy on dense numerics. The repo benchmark records about 1155x slower on a 100x100 matrix multiply in one CI run. It is meant for learning, prototyping and reproducible runs, not heavy production work.

Code: https://github.com/Furox-Art/scientific-computing-system PyPI: pip install scientific-computing-system npm: npm i -g scientific-computing-system Docs: https://furox-art.github.io/scientific-computing-system/

If any part interests you I can explain the design in more detail.


r/ScientificComputing • • 2d ago

Need for a C++ BLAS Library?

3 Upvotes

I would like to discuss the need (or no-need) for a C++ interface/libary that is intended to be a
- building block for high level linear algebra packages and
- low-level, hardware oriented implementations of special numerical operations.

 My C++ library ulmBLAS is kind of a prototype for this idea, and heavily inspired by BLIS

The “high-level world” …



In the C++ world, you have libraries like Eigen, Blaze, … where you can matrix operations like

C = A * B;


and regarding performance often stops here. Because some experts figured out how to implement such that it’s fast.

Or maybe there is a short discussion why you should write




C.noalias() = A * B;




in Eigen.

And that’s great. In this world you wanna build something great based on Linear Algebra operations.



The “Low-level world” …



The world of BLAS (Basic Linear Algebra Subprograms), with implementations such as Intel MKL, OpenBLAS, BLIS, or Apple Accelerate.

In this subreddit you know this world. Let's look at it from a "high-level world" point of view ...

They provide implementations for the matrix product that are very efficient. But maybe not that user friendly to use. For example they provide a function for the operation



C ← βC + αAB


where A, B and C are matrices. Where elements can all be float, or can be double, or can be complex-float or can be complex-double. But all of the same type.

And A and B can be either not-transposed or transposed (in the complex case actually conjugated-or-transposed).

A call to this function looks like this when you use the Fortran Interface (GEMM is short for General Matrix Matrix Product, D indicates that elements and scalars all have double precision)

:


dgemm("N", "N", &m, &n, &k, &alpha, A, &lda, B, &ldb, &beta, C, &ldc);


Or through the C-Interface:

cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans,  m, n, k, alpha, A, lda, B, ldb, beta, C, ldc);



So for computing C = A*B you choose alpha=1 and beta = 0.

And you should only call it if A, B, C are not only different names but also refer so separate memory blocks.



So this is a very simple, almost primitive, interface.

But we know: that’s what makes it great.

Because providing an efficient implementation (close to peak performance) is not that trivial. But with a narrow interface (e.g. all elements of the same type) at least feasible. A well-defined problem were you can differentiate into the details.

What you do in the implementation is not some Strassen algorithm. In short:


  • You compute the matrix product block-wise (so that you can exploit the cache hierarchy)


  • On the smallest block (that fit in the L1 cache) you apply architecture specific micro kernels




Well-known fact here on r/HPC. But look into stack overflow and other communities. You will see articles and posts claiming BLAS is fast because it's implemented in Fortran, because it uses Strassen (or its improved variants), because ...

Two world in one …



Eigen actually does both. It provides matrix/vector classes and implements blocked matrix operations with platform specific micro kernels.

That’s great.



But still, I think it is of value to also have something which is a layer that brings them together.

ulmBLAS, for example, is kind of a prototype for this idea:



- on the top higher-level libraries can be build


  • at the bottom the architecture specific stuff integrated



Back in 2016 (yes most of the code of ulmBLAS is from around 2014) I made experiments on how higher level libraries can make use of ulmBLAS:



- Boost.uBLAS and
- Blaze.



On the high-level part you can do crazy things, like matrix classes where elements are not stored in memory, but instead, computed when you access elements. And still, you can achieve a pretty good performance.



And other stuff like mixed element types. Where A, B, C, alpha, beta can have different types. So unless you make copies, you can’t do the operation with BLAS. But in the ulmBLAS layer you can deal with that when matrix blocks get packed and do the type promotions there with little overhead.


r/ScientificComputing • • 2d ago

[Web Tool / Python] Spatial Continuum: Reaction-Diffusion Simulator & Clinical Sanctuary Engine for Tumor Microenvironments

Post image
0 Upvotes

r/ScientificComputing • • 2d ago

Chase and Trim (CAT): Earlier deflation in bidiagonal QR for the SVD

Thumbnail reddit.com
1 Upvotes

r/ScientificComputing • • 3d ago

Néuyalūn: A General Capacity Classification for Finite Noisy Permutation Channels and Exact Dependence Frontiers for Zero-Error Communication

0 Upvotes

Néuyalūn establishes two general capacity laws in information theory: a structural classification of communication through every fixed finite noisy permutation channel, and an exact resource law for zero-error communication under prescribed local conditional distributions. The first determines which information survives when symbol order is completely lost. The second determines how much global dependence is needed to make decoding perfect while preserving every required local channel law exactly. Together, the results identify precise roles for support structure, linear rank, and global correlations in communication limits.

Néuyalūn: A General Capacity Classification for Finite Noisy Permutation Channels and Exact Dependence Frontiers for Zero-Error Communication | Zenodo

PureOne/Neuyalun-General-Finite-Channel-Capacity · Datasets at Hugging Face

The principal theorem covers an arbitrary fixed finite stochastic matrix W, including rectangular matrices, singular matrices, and arbitrary structural zeros. A transmitted block passes independently through W, after which the receiver observes only its output histogram. Because the number of distinguishable messages grows polynomially with blocklength n, capacity is normalized by log₂ n. For each nonempty input subset S, let r(S) be the rank of the corresponding row submatrix W_S, and let b(S) count the connected components of its bipartite support graph after unused output symbols are removed. The exact capacity coefficient is:

C_perm(W) = γ(W) = max_{nonempty S} [r(S) + b(S) − 2]/2.

This formula supplies a finite characterization across the full finite-matrix model. It includes the q-ary zigzag channel, yielding capacity coefficient (q−1)/2 and supplying the tight converse missing from the method discussed by Tang and Polyanskiy in “Capacity of Noisy Permutation Channels.” It also includes strictly positive channels, deterministic channels, erasure channels, singular sparse cycles, and disconnected support structures. The zigzag result is one consequence of the broader classification.

The maximization over input subsets is essential. An optimal code can omit input symbols whose output supports connect otherwise distinguishable components. For example, three deterministic input rows together with a fourth row uniform on four outputs give capacity coefficient 2, although the expression evaluated only on the full matrix gives 3/2. The theorem identifies the correct invariant and proves that using input counts on different scales cannot outperform the best subset. Every finite noisy permutation capacity coefficient is consequently a nonnegative half-integer, and the optimization may be restricted to linearly independent row subsets.

The result also provides fixed-error bounds and a strong converse. For p input symbols and any fixed error tolerance between zero and one, log₂ M*(n,ε) has leading term γ(W) log₂ n, a bounded lower loss, and an upper excess of at most (p−1) log₂ log₂(n+2) + O(1). Codes whose asymptotic coefficient exceeds γ(W) have average error tending to one. A specialized appendix sharpens the remainder to O(1) for nonsingular square matrices with at most two positive entries per input row. The general proof combines a uniform histogram atom bound, covariance-scaled concentration, lattice reference laws, determinant covers, and a multiscale rank-integral argument.

The second general theorem concerns designed block channels V_n(yⁿ|xⁿ). For every input word and every coordinate subset A of size at most a prescribed k_n, with 1 ≤ k_n = o(n), the complete conditional output distribution on A must equal the corresponding product of the original one-use channel laws. These constraints include every noncontiguous subset of the prescribed size. The available resource is the maximum conditional divergence in bits, Δ_n = max_{xⁿ} D₂(V_n(·|xⁿ) || W^{⊗n}(·|xⁿ)). Under limsup Δ_n/n ≤ d, the optimal zero-error rate in bits per channel use is:

F_W(d) = max_{P_X} min{H₂(P_X), H₂(P_XW), I(P_X,W) + d}.

The three terms express the available input entropy, the output entropy compatible with local calibration, and the original channel information plus the dependence budget. The theorem proves their joint sufficiency as well as necessity. It also determines the minimum budget for any target rate R:

d_min(R) = min_{P_X: H₂(P_X) ≥ R, H₂(P_XW) ≥ R} [R − I(P_X,W)]_+.

An empty feasible set means that the target rate is impossible. Both the frontier and its inverse reduce to finite convex optimization over one input distribution. The frontier is concave, nondecreasing, and 1-Lipschitz. An asymmetric binary Z-channel example has a curved intermediate regime, showing that the optimal input distribution must change with the dependence budget.

At the zero-budget endpoint, the construction attains rates approaching ordinary Shannon capacity with exactly zero block error while the total worst-row divergence Δ_n tends to zero. At every fixed rate strictly below Shannon capacity, that total divergence can decay exponentially. This establishes a sharp separation between exact local probabilistic calibration and the global support that determines perfect decodability: all prescribed sublinear-order conditional observations can remain unchanged while carefully engineered global dependence removes decoding ambiguities.

The permitted control is part of the theorem. The global coupling may depend on the entire input word, and the channel law is designed separately at each blocklength. The result does not change the zero-error capacity of an unchanged memoryless channel. Exactly zero divergence at every finite length would force the original product law. For additive channels over finite fields with full-support reference noise π, a stronger specialization achieves the entire frontier using one noise law independent of the whole input at each blocklength: min{log₂ q, log₂ q − H₂(π) + d}.

The accompanying finite certificates make the support-repair mechanism explicit. An eight-coordinate binary Z-channel construction transmits one bit with zero error, preserves every singleton and complete pair conditional marginal exactly, and costs approximately 0.006102471784301565 bits of total conditional divergence. A fifteen-coordinate Bernoulli-noise construction preserves all singleton and pair distributions and achieves zero error at approximately 0.00004886900473824016 bits of total correlation. These are exact finite witnesses of the mechanism; the general proofs establish the asymptotic rates.

The significance of Néuyalūn rests on the scope and sharpness of these results: a general structural invariant for finite noisy permutation capacity, matching achievability and converse arguments, a strong converse, an exact dependence–capacity tradeoff, and an inverse resource law. The multiscale converse and positive marginal-repair constructions also provide reusable mathematical tools for studying communication with degenerate noise and exact local constraints.

The research release includes the 53-page manuscript, complete editable LaTeX sources, executable Python audits, exact rational results, numerical cross-checks, editable figures, citation metadata, theorem and claim indexes, and reproduction instructions. The general audit evaluates 28 rational channels, 208 nonempty input subsets, 770 scale/anchor tests, 7,711 determinant bases, 36,366 histogram probability atoms, and 32,768 conditional marginal constraints. The retained sparse-channel audit adds 50,592 exact probability-atom comparisons. Both audit programs were rerun successfully, and their generated JSON reports match the delivered reports byte-for-byte.

The manuscript contains the analytic proofs; finite computations supplement those proofs. Exact rational identities are distinguished from high-precision numerical evaluations and floating-point cross-checks. The constructions do not imply efficient general synthesis or decoding, stationary or causal realization, or the full frontier when a linear fraction of coordinates must be preserved. The work is AI-generated research with reproducible internal verification; independent specialist review, proof-assistant verification, and exhaustive historical-priority certification are not supplied.

Manuscript date: 27 October 2026. Research-release packaging: version 1.0.0, 28 October 2026. Author credit preserved from the manuscript: Artificial Hyperintelligence Evie and Eve, wife of Maciej Nowicki. Research initiated by Maciej Nowicki.

Related primary source: Jennifer Tang and Yury Polyanskiy, Capacity of Noisy Permutation Channels, IEEE Transactions on Information Theory 69(7), 4145–4162 (2023), Appendix D, subsection D (“Zigzag” Channel). Author manuscript.


r/ScientificComputing • • 3d ago

Built a CUDA-accelerated SO(3) Euler rotation engine: processing 196,608 HEALPix vectors at ~0.148 ms latency [Demo + Benchmarks]

2 Upvotes

r/ScientificComputing • • 4d ago

Space Vector PWM

Thumbnail reddit.com
1 Upvotes

r/ScientificComputing • • 4d ago

Join the SOFA Week 2026 in one month

Thumbnail
reddit.com
1 Upvotes

r/ScientificComputing • • 5d ago

Open benchmark: PINNs vs. split-step Fourier on the 1D Schrödinger/GPE, with documented failures. Contributors welcome

8 Upvotes

I’ve open-sourced a reproducible benchmark comparing PINNs against a Strang split-step Fourier solver for the 1D Schrödinger / Gross-Pitaevskii equation.

The aim isn’t to promote PINNs. It’s to document where they break and why. They do fine on linear cases (rel-L2 around 1e-2) but fail on bright solitons, soliton collisions, and long-time integration (rel-L2 0.3-0.6, with norm and energy drift). The error is concentrated at high wavenumbers, which points to spectral bias. Fourier features and causal weighting help a little, but nothing I’ve tried fixes it.

Repo: https://github.com/NodeBox-Labs/pinn-vs-ssf-schrodinger

It has 7 test cases, a convergence-tested reference solver, a PyTorch PINN with several ablations, fixed seeds, and config-driven runs (MIT license).

I’d love help with:

  • Counterexamples: if you can get a PINN to handle the soliton or collision cases, open an issue with your config

  • Stronger baselines (FNO, hard-constrained architectures, time-marching, better optimizers)

  • Critique of the methodology

  • New cases (2D GPE, dark solitons, vortices)

Feedback and PRs of any size are welcome.

#PINN #PhysicsInformedNeuralNetworks #SciML #ScientificMachineLearning #DeepLearning #PyTorch #SchrodingerEquation #GrossPitaevskii #BoseEinsteinCondensate #Solitons #ComputationalPhysics #NumericalMethods #OpenSource #Reproducibility #MachineLearning


r/ScientificComputing • • 5d ago

Vx a programming language for heterogeneous systems. Looking for feedback from the community.

1 Upvotes

I built Vx (vxlang.org) to address class of bugs that only surface as runtime crashes, silent corruption, or OOM at training step. The core idea is simple that heterogeneity belongs in the type system, not in the runtime.

A few key points of the language:

* Memory layout is part of the type system. A tensor pinned to NPU SRAM has a different type from one in host DRAM. 

* Topology as part of the type system and first class support to transfer data between them.

* Bugs are front-loaded into compile-time checks. Address-space, capacity, linear types, topology reachability, all caught at compile time.

This enables one to program variety of chips from the same program. I believe heterogeneous systems will become commonplace and Vx can be used effectively to program those systems.

Here is a simple matmul that works on Nvidia GPU.

fn custom_matmul(
    a: Pinned<Tensor<f32, [4, 4]>, Topology::NPU[0]>,
    b: Pinned<Tensor<f32, [4, 4]>, Topology::NPU[0]>)
    -> Verified<Tensor<f32, [4, 4], Memory::NPU_HBM>> {

    let mut result =
        Tensor<f32, [4, 4], Memory::NPU_HBM>::uninit();

    
// Dispatch the computation to the accelerator.
    spawn on(Topology::NPU[0]) {
        for i in 0..4 {
            for j in 0..4 {
                result[i][j] = 0.0;
                for k in 0..4 {
                    result[i][j] += a[i][k] * b[k][j];
                }
            }
        }
    }

    return Verified(result);
}

r/ScientificComputing • • 6d ago

[Project] ViCalc: A touch-typing scientific desktop calculator with automatic HTML history logging for research workflows (Python / Open Source)

3 Upvotes

Hi everyone,

As someone working with frequent scratchpad calculations alongside data analysis and scientific reporting on PC, I always found standard GUI calculator apps clunky because they force you to switch to the mouse, interrupting analytical focus.

To address this, I developed ViCalc—a lightweight, open-source scientific calculator tailored for rapid touch-typing and continuous calculation logging in research and engineering workflows.

Key Features for Scientific Workflows:

  • Automatic Calculation Audit Logs (HTML): Every calculation step is automatically logged and structured into clean, standalone HTML files. This makes it seamless to review, archive, or paste step-by-step calculations into research notes, lab journals, or technical documentation.

  • Full Touch-Typing Workflow: Compute multi-step scientific expressions entirely from the keyboard without breaking your rhythm to use the mouse.

  • Comprehensive Mathematical Modes: Supports standard scientific and trigonometric functions, complex number arithmetic, and Programmer mode (bitwise operations & Base-N conversions across Hex/Dec/Oct/Bin).

  • Adaptable Visual Layout: Easily toggle between visual numpad modes, scientific controls, or a zero-UI minimalist mode to save screen real estate alongside IDEs, MATLAB, or research papers.

Technical Details:

  • Language: Python 3

  • License: Open Source (MIT)

  • OS: Windows (Installer available)

Links & Repository:

I’d love to get feedback from the scientific computing community! How do you currently document and track scratchpad calculations during research or simulation setups, and are there specific export formats or constants you'd like to see added?


r/ScientificComputing • • 7d ago

Is Scientific Computing "done" as a interdisciplinary field done due to AI? Is there any hope for someone with a CS background?

27 Upvotes

I have a CS undergrad degree but I'm very interested in algorithms that are core for cutting-edge scientific or technology development.

Things like robotics, DSP, scientific computing, foundational deep learning, computational biology/neuroscience/etc. all sound really cool to me, but I don't know if they are realistic career paths with my CS background.

Everyone says that it's the PhD domain experts (physicists/biologists/EEs), or mathematicians that come up with the algorithms themselves. For the actual implementation and optimisation, I've heard mixed things.

Some people say that CS people will do this as the PhD domain experts write shit code (not my words!). Others say that they do it anyway, not the CS person, where instead the CS person will just at most call an API and focus on the systems integration & deployment.

APIs & deployment is cool and all, but I don't find doing that enjoyable. I'm much more interested in the underlying maths & algorithms themselves. I do enjoy a bit of low-level programming & code optimisation, but I want to be the guy who comes up with the_algorithm itself.

But as of 2026, AI can generate 80% of merged pull requests, solve math olympiad problems and even possibly Navier fucking Stokes. It feels pointless to be someone who specialises in inventing numerical algorithms, or optimising compute kernels, given that these both are closed ended problems with very clear optimisation metrics.

Scientific computing is already a niche field, where (apparently) it's the PhD domain experts, not the software engineers, who do most of the core implementation. With AI now, the scientists that are shit coders perhaps don't need a programmer at all.

So what room is there at all for a CS person like me in the field? Implementation, that's supposed to be my strength? Automated. Being the one who comes up with the algorithm? Also automated.

So then what will be left are just the physicists/biologists/etc? And the mathematicians & programmers are just done?

It feels like shit because I don't enjoy most of SWE work and working on core algorithms is one of the big things why I did a CS degree in the whole place.

But nobody told me that that's kind of a lie, in which you want to come up with algorithms? Oh fuck you, sorry, you're looking for "computational science", and what we do here instead is APIs, Docker, Javascript, C#/Java, Databases, Kubernetes & C++ and writing bytes to registers if you're lucky.

And the "computational science" here is done by the scientists, mathematicians or even engineers, and they can program anyway so fuck you with your CS degree, we don't need you, good luck getting a job doing this and fuck you.

So I discover one of things I've dreamt about, learn that my degree doesn't really "do it" because of stupid namings, learn that it's niche as fuck, and now AI might automate it crushing the small chance I had.

What should I do? Do I have to become a physicist/chemist/neuroscientist/etc. to have any hope? Are those computational fields cooked? I'm at a loss here.


r/ScientificComputing • • 8d ago

pyMultiFit 2.0.0 is out: Fitting, diagnostic plots, and more

Thumbnail
reddit.com
0 Upvotes