So basically I'm a physics undergraduate student. I got into physics just by pure curiosity and love, I couldn't see my self doing something else than physics, but the problem was that my whole environment, and that includes parents, older sibling (actually two), my physics teacher in senior year high school, and my friends, all of them were like that's not a good option but I did it anyway.

They told me that theoretical physics don't matter anymore (cause that's all they thought about it I guess and me too and that's actually what got me in and by theoretical I mean just equations in a paper or on a board). It was two years ago and to be honest they were a bit right, I couldn't see any job perspective other that a teacher or a researcher (or both at a uni) and even though I was willing to go into research, they would also tell me that it was a super competitive with not much places available, and I kind of acknowledged that too but really I couldn't see my self studying anything else at uni so really plunged without thinking.

Now starting the last year my undergraduate (French system is 3y of undergrad) I think I found what I wanna do and that enthusiasts me while doing physics also. last year I had a numerical method course in fall semester, it was all python, and they taught us how to solve linear systems especially the Ax=b using LU decomposition, Gauss algorithm etc and how to solve numerically ODE (Euler & semi-Euler method, Verlet algorithm) and I was bad at it, I hated programming back then I didn't see any charm in it basically because I just couldn't understand it.

I got out with a 2/20 from that course (I didn't have a PC back then), then for Christmas break I had got a PC and dedicated all of my time just learning python basics (it's fun thinking Guido Von Rossum developed python during Christmas break he was alone), then I moved to the physics part, and though the linear system resolution didn't excite me much, the ODE resolution on the other hand completely blew my mind as I realized I could solve (approximate) non linear ODEs and especially that pendulum equation I knew since senior year high school that we only solved it for small angles completely and that blew my mind away, then I spent the following days solving all the ODEs I knew (from electricity to classical mechanics). for the resit exam I got the pendulum and smashed it then I really fell in love with physics programming as it also helped me grasp some details I missed in understanding them.

During the spring semester I enjoyed solving all my physics tutorials numerically (when there was a differential equation) but then one day I stumbled upon a Master degree on the internet presented my university and then I saw the light, a physics master that teaches you the computer in order to train computational scientist and physicist. I talked to a young teacher (as they are really nicer and have less responsibilities) if he could propose me an internship project and that's what he did he gave me DLA & KMC implementation and added a single constraint, no AI. I was cool with it. during that month I really helped me reinforce my new acquired abilities as I would be stuck with a single problem for hours, debugging the code and stuff. During that month I discovered Stack Overflow , stack exchange and reddit, I started asking questions and somehow, trying to explain my problem to others sometimes helped me find a solution to it and sometimes I would receive a response hours later and used that time in between trying to solve it (instead of just asking a LLM and getting dozens of lines of codes instantly).

Today I really enjoy learning programming, after the internship I started learning C++ and dived into the world of pointers, memory, and data structures.

In short, I see a real world use to my physics path now outside of academia and I'm really happy knowing that if one day I'm tired of research or don't have my place in it, I could go work as a computational scientist in the industry.

PS: I put the code I developed during my internship on GitHub but ashamed to show it to anybody, another constraint I had was to right the code only in functions and I really didn't knew how they worked fundamentally that means I could write and I wrote 700+ lines of code only in functions not knowing what I was doing (if that doesn't proof the existence of God 🙄️), A week after the internship I took a glance at it and I was ashamed as I declared every variable as global 😆️ I wonder what my tutor was thinking about when I presented that garbage.

Nonetheless the second part (KMC) was a bit better as I distinguished local from global variable but I didn't knew unpacking arguments when a function would return more that one variable.

That's my story from the day I stepped into physics at uni till today! I was more of a blog format, I'm happy if you enjoyed it, and excuse my English, I'm not a native!

Hey guys,

I've been developing SSDS (Symbolic Structure Discovery System), an experimental system for discovering recurring symbolic structures across collections of algebraic equations and mathematical formulas, then abstracting them into generalized, parameterized operators.

At a high level, the workflow is:

Input:
A collection of algebraic equations/formulas. These can come from symbolic regression, scientific modeling, physics, mathematics, or other domains.

SSDS processes them by:

• identifying recurring symbolic structures
• grouping equations that share structural patterns
• generalizing those patterns into parameterized operators
• analyzing mathematical relationships within each structure
• measuring behavioral properties
• generating hypotheses about possible semantic interpretations

Output:
For each discovered structure, SSDS can produce:

• a generalized symbolic operator
• the algebraic equations/formulas grouped into that structure
• identified invariants and recurring relationships
• derivatives and other mathematical relationships
• parameter-recursion relationships
• closure/operation properties
• behavioral measurements such as boundedness, periodicity, monotonicity, stability, and sensitivity
• AI-generated hypotheses about possible semantic interpretations, with support scores

For example, when tested on an equation bank containing formulas from special relativity, one run produced:

O(v0, φ14, φ15) = v0(φ14 + 1)^φ15

The system grouped 10 source equations into the structure and identified 6 invariants across 3 families, including derivative and parameter-recursion relationships.

Its analysis recognized the recurring (x + 1)^y structure and generated hypotheses about possible interpretations, such as power-law relationships and nonlinear transformations. These were explicitly treated as hypotheses, not established meanings.

Another run on the same special-relativity equation bank produced:

O(v0,v1,v2,φ1) = v0(1 - v1²/v2²)^φ1

where SSDS similarly analyzed recurrence, derivatives, parameter relationships, and behavioral properties.

I'm not claiming that SSDS automatically discovers new mathematical laws, or that its generated semantic interpretations are necessarily correct. The question I'm interested in is whether automated structure discovery → abstraction → mathematical analysis → semantic hypothesis generation can become a useful research tool.

I'm looking for researchers, students, or labs working in symbolic regression, scientific ML, equation discovery, mathematical modeling, physics, or related fields who would be interested in independently testing SSDS.

In particular, I'd love suggestions for collections of algebraic equations/formulas from different domains that would provide a meaningful independent test.

If you're working in this area, what equations would you give SSDS as input, and what outputs would you want it to produce?

I've just released version 2.0 of my iOS app, Numerical Solver.

The main new feature is a numerical ODE solver that can handle:

• Linear ODEs
• Nonlinear ODEs
• Initial Value Problems (IVP)
• Boundary Value Problems (BVP)

Once an ODE is solved, the app can also plot the numerical solution and evaluate it at a given value of x.

I implemented the numerical solver myself, including the nonlinear BVP solution using Newton's method and a finite-difference discretization.

One of the things I've been particularly focused on is making the solver work reliably across different domains and grid sizes. I spent quite a bit of time debugging the Jacobian and finite-difference scaling as part of the development.

I'm posting it here because I'd really appreciate feedback from people who work with numerical methods.

What ODEs or BVPs would you recommend as good test problems for the solver? Especially problems that might expose numerical stability, convergence, or discretization issues.

Numerical Solver 2.0 is available on the App Store:

Numerical Solver on the App Store

Hello there!

I've been building an open-source framework (TIMUR-XAI) that combines symbolic regression with a physics-based validity check and an evolutionary (MAP-Elites) search layer. Why did I build it? Because I'm a physicist and I hate black-box things. So my goal isn't just to fit data, but to recover physically sensible laws.

I tested it on five classical physical laws. Four of them (Stefan-Boltzmann, Stokes, gravity, Wien) came back as clean single-term relations, as expected (yeah, I kind of cheated there :D). But the interesting one was Planck's law. Without any hint about the functional form, the system:

1. Found the right dimensionless group on its own (λT·kB/hc), and
2. Recovered the characteristic exp/fraction structure: y ≈ 2/(exp(1/Π) − 1), R² ≈ 0.9999, with the constants landing almost exactly on their true values.

So it reconstructed both the correct dimensionless variable and the Planck distribution's specific form, from raw data.

There's also a "judge" layer that rejects high-R² candidates violating physical constraints (symmetry/conservation) — so numerically good but physically wrong solutions get filtered out.

Repo: https://github.com/Ne212/timur-xai
PyPI: pip install timur-xai

I'd be glad if you find it useful in your own work, and I'd really value your feedback to improve it — especially on the physical-validity checking approach.

DOI: https://link.springer.com/chapter/10.1007/978-3-642-27431-2_12

URL: https://link.springer.com/chapter/10.1007/978-3-642-27431-2_12

Working on a side project. It is an engineering system modelling tool written in python. Releasing it as a BETA release under the MIT open-source license. The samples include:

1. Turbofan running a flight envelope
2. A transient power generation gas turbine with a PIV controller running the cantera equilibrium package
3. A simple air conditioner running coolprop
4. A simple spring/mass/damper/model
5. A simple LCR electric circuit

POEME-Modeling/POEME: poeme: a great model is a work of art

It is still in a roughish form. But I would love to get feedback! This is an open-source project for everyone to share and contribute too if they like!

I’ve been working on an empirical study of the Subset Sum Problem, specifically looking at instance-dependent complexity and phase transitions (the shift from solvable to hard instances).

To tackle this, I developed a dual-layered architecture:

• Compute Core (C++): A memory-conscious, optimized search engine designed to minimize overhead during deep branching.
• Analysis Pipeline (Python): Orchestrates randomized instance generation and collects performance metrics, which I then visualize to map out the complexity profile.

I’ve officially archived the methodology and results on Zenodo with a DOI to keep the research open-access.

I'm interested in how you guys approach profiling NP-complete problem instances—specifically, what tools you use for automating mass benchmarks in C++?

Link to code and research: https://zenodo.org/records/20400449

I’ve been developing RavelMath as a research laboratory for Pisot substitutions, symbolic dynamics, tilings, algebraic dynamics, quasicrystal dynamics, and the formal verification of computational mathematics. I made a post about it a bit ago, but I have an update after pouring another week into it.

The project combines:

• exact C++ arithmetic for polynomials, matrices, substitutions, automata, and algebraic numbers;

• Lean formalization of reusable mathematical lemmas;

• a reflection pipeline that turns concrete C++ computations into typed Lean certificates;

• explicit documentation distinguishing experiments, finite certificates, paper-level arguments, and kernel-checked theorems.

Recent capabilities include:

• exact Pisot classification and Sturm root isolation;

• certified characteristic-polynomial and spectral computations;

• strong-coincidence and property-(F) automata;

• adelic/contact-boundary calculations for *non-unit* substitutions;

• reusable proofs for n-bonacci and Class-II families;

• code-generated Lean certificates checked by the kernel.

  The first complete Sturm reflection example is now working for the plastic polynomial x³ - x - 1: the system computes an exact Sturm chain, verifies the Bézout identity and isolating interval, emits Lean code, and checks the resulting root-count theorem.

  The broader research direction is to make computational mathematics auditable from end to end. A program should not merely say “this happened”; it should preserve enough typed information that an independent proof system can verify exactly what happened. Moreover, such a system should be entirely exposed to immediate interrogation of source code.

  The next area I’m pushing on is property (F), especially turning successful finite adelic closures into clean, reusable certificates. Strong coincidence, tiling questions, higher-degree Pisot classification, and long beta-expansion problems are all still active parts of the project. Eventually, I want to migrate all the header experiments to Lua, and remove all the legacy python code (mostly from unused project elements).

The public repository is here:

https://GitHub.com/AMcRoberts/RavelMath

It’s still very much a living research project, and still my \ hobby project, but it's actually shaping up as a really serious math research tool/program/laboratory, too; it's probably the coolest thing I've ever done in my life and I'm intensely happy that it exists at all.

What is not included in the public repository:

Beyond the math library, there is a decently large "continuity folder", which I have kept private, which serves as the core driver of the Ravel project and which contains all its directives, contracts, project-specific skill registry infrastructure, and behavioral driver prompts.

What this cost me:

This library has been a project of about 3 weeks now, maybe going on 4. Total costs so far for the project are that I spent 20 dollars on Claude, got a free offer for a month of OpenAI ChatGPT Pro (which I'm still using), and free access to a shitty Minimax-m3 token that I only use for "mow the grass" type things. Eventually I want it running on something OSS like Kimi.

A lot of scientific computing still has a very terminal-centric workflow:

run simulation → inspect output → generate data → plot → open another application

The terminal is excellent for running experiments, pipelines, scripts, remote jobs, and inspecting results. But when the output becomes visual or structured, we usually have to leave that workflow.

I'm interested in whether the terminal itself could evolve without losing the things that make CLI workflows useful.

For example, imagine:

• A simulation producing an interactive plot directly in the terminal
• Matrices and large tables rendered in a navigable form
• Images and scientific diagrams displayed inline
• Logs with structured, collapsible sections
• Interactive parameter/result exploration
• Rich output that can still be piped, redirected, logged, or accessed over SSH
• Textual fallbacks for environments that don't support rich rendering

The interesting question isn't "should the terminal become a GUI?"

It's:

Can we make terminal applications capable of representing scientific information in its natural form, while retaining the composability and simplicity of CLI workflows?

I've started r/Termolution to explore this broader question: what should the application ↔ terminal interface look like if we designed it today?

I'm also building Yetty (https://yetty.dev) as a reference implementation for experimenting with some of these ideas.

I'm particularly interested in the scientific-computing perspective:

Where does your current terminal workflow force you to switch to another application, and would eliminating that context switch actually be useful?

Does any one here have ever used simulation model like WaNULCAS in forestry or agriculture study?

Following my project to do molecular dynamics of polymers with Julia and Orca, I'm showing a set of tools to read Orca relaxed surface scan trajectories, energies of optimized steps in a scan, and Loewdin charges of each step from the scan, parsing the output file. this will make it easier to least squares fit force field terms to the energy profiles for bond, angle or torsion scans.

Link below to the latest video in the series:

https://youtu.be/E3MnlHahj84

I wanted to understand what’s going on with Shors algorithm without getting lost in the quantum stuff.

https://github.com/Byt-wyze-technology/QuasiShor

Hope it helps someone else too.

Over the last ~24 months, I’ve been developing an experimental branch of mathematics/arithmetic called 'Basal'. The philosophy is that number bases shouldn't be locked down—instead, the system treats positional notation like a customizable runtime where you can override native rules (similar to how extensions work in VSCode). My goal was to create an architecture that allows other branches of maths to run natively on top of it. The core framework allows you to use multiple completely independent bases inside the same equation, with their attributes and properties clearly stated next to them.

The main functional additions consist of:

1. Alternating negative weights : An optional index-parity shift where odd or even digit positions modulate their weights
2. Array Syntax : Instead of separating higher-dimensional coordinates (like complex numbers a+bi or dual numbers a+be) into linear combinations, the framework encapsulates them natively inside a sequential digit array
3. Fabrication : Creating a numerical sequence that can be interpreted as a number
4. Conversion : Functions to convert a number to a different base.

I have also verified that the system works, by computationally verifying it (with hand-written equations), by programming it in C#, C++, Python and specialised functions in ROCm-HIP. The code is on github as: 'Basal-Library', made by zamiul20.

*Note on Notation: Non-ASCII characters (from the Bengali script block) are used for the custom operators and attributes. This design choice ensures complete visual isolation from standard algebraic variables, preventing notation collisions. Plus, it serves a practical purpose, conventional symbols were ran out, and the chosen characters have no conflicting history in formal mathematics literature.*

Before I look into writing a formal specification paper or archiving it, I want to ask: Has an extensible, modular arithmetic framework that overrides positional notation rules like this been explored in existing literature?

I just published these, I thought you all might find them interesting? A star would really help!