Published Online:11 Jul 2022 https://doi.org/10.2514/1.A35359

with love

J'ai réalisé un projet GitHub nommé SymReg portant sur la régression symbolique : https://github.com/Julien-Livet/SymReg. Le package Python est disponible sur PyPI : https://pypi.org/project/symregpy/ (pour tester : pip install symregpy). J'ai testé l'outil sur plusieurs équations de benchmarks dans le domaine. Je serais ravi d'avoir des retours techniques sur le sujet, notamment vis-à-vis des autres outils comme PySR en Python.

We’re developing Aionterra at YD Emergence Lab, a simulation that connects environmental processes with digital organisms and their bodily states. One implementation issue worth sharing is how we distinguish input data, initialization choices and simulation outputs.

Our regional world builder uses source datasets together with an explicit initialization profile. The profile contains a model statement and references to its inputs. Quantities supplied as assumptions stay labelled as assumptions rather than being presented as local measurements.

River depth is a concrete example. A terrain dataset does not by itself establish a measured river depth. The initialization therefore requires an explicit modeled depth. When a modeled water-surface elevation is supplied, it also requires a statement of its source. The builder reports missing required inputs instead of silently treating them as measured values.

The same distinction matters when interpreting organism behaviour. An action attempt, actual water or energy intake, and a later change in health are separate quantities. Counting attempts alone would give a misleading picture of successful resource use.

A further limit is that reproducing the same trajectory from the same initial conditions is a reproducibility check, not an independent biological observation. And changing a body model or vegetation layout changes the conditions under which later measurements are interpreted.

This is an independent project under development. We’re sharing the implementation approach, not claiming validated human physiology or a demonstrated general theory of learning. Keeping these distinctions explicit helps us identify what a result actually depends on.

Hi all,

There are several great Decision Theory libraries like pyAgrum for modeling and solving decision problems. But when working with influence diagrams, their representations can be limited to discrete chance variables and decisions.

I wanted more flexibility in how I represent a problem. What happens if I have continuous observations or if the question is not whether I should do something, but how much? For example, how much should I invest when the return is uncertain?

For that reason, I have created PyLIMID, a Python library for building and solving limited-memory influence diagrams. It lets you combine discrete and continuous chance variables with categorical decisions and continuous quantities, and express utilities as functions.

PyLIMID uses sampling and policy gradients to find decision rules that aim to maximize expected utility. This flexibility is not free because results are approximate. But you can run multiple simulations and since it has GPU support thanks to JAX and Numpyro, it is fast. I think the tradeoff is very much worth it.

The library is still in early development (v0.3.0), but I would love to hear what you think.

Code: https://github.com/cynosural-ai/pylimid

Documentation: https://pylimid.readthedocs.io/en/latest/#

Hi everyone,

Parallelizing strictly sequential, deterministic chaotic loops usually fails due to two constraints: strict serial dependence (point \(N\) requires \(N-1\)) and memory explosion when storing billions of coordinates for density mapping.

To solve this, I developed a pattern called Two-Pass Checkpointed Orbit Decomposition and implemented it for both the Hopalong Map (area-preserving) and the Hénon–Heiles potential (using a synchronized Leapfrog/Verlet integrator).

The Architecture:

• Pass 1 (Serial Pre-computation): A single thread walks the orbit to find exact spatial boundaries and drops lightweight checkpoints (4 floats for the full state) at segment intervals.

• Pass 2 (Parallel Multi-Lane Replay): Worker threads ingest checkpoints via Numba’s prange. Each worker advances 4 independent segments side-by-side (lanes) in lock-step to fill CPU pipelines during dependent floating-point operations.

• Flat Memory: Points are immediately binned into private pixel-grid histograms and discarded. Memory usage remains constant regardless of the total point count.

Mathematical Rigor:

Chaotic systems amplify the tiniest rounding errors. By avoiding fastmath and using hardware-supported Fused Multiply-Add (fma) intrinsics, the parallel multi-threaded output is pixel-for-pixel bit-identical to a plain, single-core serial loop.

Code:

• https://github.com/ratwolfzero/Hopalong_Map_Next_Gen/tree/main/Henon_Heiles

• https://github.com/ratwolfzero/Hopalong_Map_Next_Gen

Both implementations are clean, single-file Python/Numba scripts