2023Activity reportProject-TeamPARKAS

5.1.1 Zelus

• Keywords:
  Numerical simulations, Compilers, Embedded systems, Hybrid systems
• Scientific Description:
  The Zélus implementation has two main parts: a compiler that transforms Zélus programs into OCaml programs and a runtime library that orchestrates compiled programs and numeric solvers. The runtime can use the Sundials numeric solver, or custom implementations of well-known algorithms for numerically approximating continuous dynamics.
• Functional Description:
  Zélus is a new programming language for hybrid system modeling. It is based on a synchronous language but extends it with Ordinary Differential Equations (ODEs) to model continuous-time behaviors. It allows for combining arbitrarily data-flow equations, hierarchical automata and ODEs. The language keeps all the fundamental features of synchronous languages: the compiler statically ensure the absence of deadlocks and critical races, it is able to generate statically scheduled code running in bounded time and space and a type-system is used to distinguish discrete and logical-time signals from continuous-time ones. The ability to combines those features with ODEs made the language usable both for programming discrete controllers and their physical environment.
• URL:
  https://­zelus.­di.­ens.­fr
• Publications:
  hal-03051954v1, hal-02333603v1, hal-02426533v1, inria-00554271v1, hal-01242732v1, hal-00654113v1, hal-00909029v1, hal-01575621v4, hal-01575631v1, hal-00766726v1, hal-00938891v1, hal-00654112v1, hal-01879026v1, hal-01549183v2, hal-00938866v1
• Contact:
  Marc Pouzet
• Participants:
  Marc Pouzet, Timothy Bourke
• Partner:
  ENS Paris

5.1.2 Vélus

• Name:
  Verified Lustre Compiler
• Keywords:
  Synchronous Language, Compilation, Software Verification, Coq, Ocaml
• Functional Description:
  Vélus is a prototype compiler from a subset of Lustre to assembly code. It is written in a mix of Coq and OCaml and incorporates the CompCert verified C compiler. The compiler includes formal specifications of the semantics and type systems of Lustre, as well as the semantics of intermediate languages, and a proof of correctness that relates the high-level dataflow model to the values produced by iterating the generated assembly code.
• Release Contributions:
  Vélus 3.0 introduces syntax and semantics for Lustre (previous versions only treated the normalized form of Lustre). It includes a verified normalization pass that transforms Lustre programs into NLustre programs.
• URL:
  https://­velus.­inria.­fr
• Publications:
  hal-01817949, hal-03287572, hal-01512286, hal-01403830, tel-03068862, hal-02005639, hal-02426573, hal-03370264
• Contact:
  Timothy Bourke
• Participants:
  Timothy Bourke, Basile Pesin, Paul Jeanmaire, Marc Pouzet

5.1.3 ProbZelus

• Keywords:
  Probabilistic Programming, Synchronous Language
• Scientific Description:
  ProbZelus is a probabilistic reactive language which provides the facilities of a synchronous language to write control software, with probabilistic constructs to model uncertainties and perform inference-in-the-loop.
• Functional Description:
  ProbZelus is built on top of Zelus a dataflow language à la Scade/Lustre and offers several streaming inference techniques including classic Sequential Monte Carlo (SMC) algorithms and semi-symbolic inference algorithm based on delayed sampling.
• URL:
  https://­github.­com/­IBM/­probzelus
• Authors:
  Guillaume Baudart, Louis Mandel, Eric Atkinson, Benjamin Sherman, Marc Pouzet, Michael Carbin
• Contact:
  Guillaume Baudart
• Partners:
  CSAIL, IBM

5.1.4 presseail

• Name:
  All-in-Lustre Compiler
• Keywords:
  Embedded systems, Compilers, Synchronous Language, Real-time application
• Functional Description:
  The input to the compiler is the rate-synchronous language described in our ECRTS 2023 article. The compiler generates and Integer Linear Programming (ILP) problem that includes data dependency and resource constraints. The problem is solved using an external solver and the resulting schedule is used by the compiler to generate sequential code using a generalization of the modular clock-driven compilation scheme used in modern Lustre/Scade compilers. The compiler implements special features for analyzing and eliminating cyclic data dependencies.
• Release Contributions:
  First version described in the ECRTS 2023 publication.
• Contact:
  Timothy Bourke

5.1.5 SundialsML

• Name:
  Sundials/ML
• Keywords:
  Simulation, Mathematics, Numerical simulations
• Scientific Description:

  Sundials/ML is a comprehensive OCaml interface to the Sundials suite of numerical solvers (CVODE, CVODES, IDA, IDAS, KINSOL). Its structure mostly follows that of the Sundials library, both for ease of reading the existing documentation and for adapting existing source code, but several changes have been made for programming convenience and to increase safety, namely:

  solver sessions are mostly configured via algebraic data types rather than multiple function calls,

  errors are signalled by exceptions not return codes (also from user-supplied callback routines),

  user data is shared between callback routines via closures (partial applications of functions),

  vectors are checked for compatibility (using a combination of static and dynamic checks), and

  explicit free commands are not necessary since OCaml is a garbage-collected language.

• Functional Description:
  Sundials/ML is an OCaml interface to the Sundials suite of numerical solvers (CVODE, CVODES, IDA, IDAS, KINSOL, ARKODE).
• Release Contributions:
  Sundials/ML v6.0.0p0 adds support for v5.x and v6.x of the Sundials Suite of numerical solvers. This includes the latest Arkode features, many vectors, and nonlinear solvers.
• URL:
  http://­inria-parkas.­github.­io/­sundialsml/
• Publications:
  hal-01408230v1, hal-01967659v1
• Contact:
  Timothy Bourke
• Participants:
  Jun Inoue, Marc Pouzet, Timothy Bourke

5.1.6 DeepStan

• Keywords:
  Probabilistic Programming, Compilers, Stan, Pyro
• Scientific Description:
  Stan is a probabilistic programming language that is popular in the statistics community, with a high-level syntax for expressing probabilistic models. Stan differs by nature from generative probabilistic programming languages like Pyro. DeepStan is a compiler from Stan to Pyro. Building on Pyro we can extend Stan with support for explicit variational inference guides, automatic guide generation, and deep probabilistic models.
• Functional Description:
  The compiler is a fork of the Stanc3 compiler with two new backends for Pyro and NumPyro. The runtime is packaged as an independent Python library and contains the Stan standard library and thin wrapper for the Pyro/NumPyro runtime.
• URL:
  https://­github.­com/­deepppl
• Contact:
  Guillaume Baudart
• Participants:
  Guillaume Baudart, Louis Mandel
• Partner:
  IBM

5.1.7 Heptagon

• Keywords:
  Compilers, Synchronous Language, Controller synthesis
• Functional Description:

  Heptagon is an experimental language for the implementation of embedded real-time reactive systems. It is developed inside the Synchronics large-scale initiative, in collaboration with Inria Rhones-Alpes. It is essentially a subset of Lucid Synchrone, without type inference, type polymorphism and higher-order. It is thus a Lustre-like language extended with hierchical automata in a form very close to SCADE 6. The intention for making this new language and compiler is to develop new aggressive optimization techniques for sequential C code and compilation methods for generating parallel code for different platforms. This explains much of the simplifications we have made in order to ease the development of compilation techniques.

  The current version of the compiler includes the following features: - Inclusion of discrete controller synthesis within the compilation: the language is equipped with a behavioral contract mechanisms, where assumptions can be described, as well as an "enforce" property part. The semantics of this latter is that the property should be enforced by controlling the behaviour of the node equipped with the contract. This property will be enforced by an automatically built controller, which will act on free controllable variables given by the programmer. This extension has been named BZR in previous works. - Expression and compilation of array values with modular memory optimization. The language allows the expression and operations on arrays (access, modification, iterators). With the use of location annotations, the programmer can avoid unnecessary array copies.

• URL:
  https://­gitlab.­inria.­fr/­synchrone/­heptagon
• Contact:
  Gwenaël Delaval
• Participants:
  Adrien Guatto, Brice Gelineau, Cédric Pasteur, Eric Rutten, Gwenaël Delaval, Léonard Gérard, Marc Pouzet
• Partners:
  UGA, ENS Paris, Inria, LIG

5.1.8 ZRun

• Name:
  The ZRun Synchronous Language Interpreter
• Keywords:
  Formal semantics, Interpreter, Ocaml, Reactive programming
• Functional Description:

  ZRun is an executable semantics of a synchronous data-flow language. It takes the form of a purely functional interpreter and is implemented in OCaml. The input of Zrun is a large subset of the language Zélus, but only its discrete-time (synchronous) subset. The basic primitives are those of Lustre: a unit non-initialized delay (pre), the initialization operator (->), the initialized delay (fby), and streams can be defined by mutually recursive definitions. It also provides richer programming constructs that were introduced in Lucid Synchrone and Scade 6, but are not in Lustre: the by-case definition of streams, the last computed value of a signal, hierarchical automata with parameters, stream functions with static parameters that are either know at compile time or at instanciation time, and two forms of iteratiors on arrays: the "forward" to perform an iteration in time, the "foreach" to perform an iteration on space.

  The objective of this prototype is to give a reference executable semantics that is independent of a compiler. It can be used, e.g., as an oracle for compiler testing, to execute unfinished programs or programs that are semantically correct but are statically rejected by the compiler.

• Release Contributions:

  Branch Master (2000) - v1.x. - first-order language, streams, hierarchical automata, by-case definition of streams, operator last.

  Branch Works (2023): - v2.x - static higher-order, hierarchical automata with parameters, valued signals. - arrays, - "forward" and "foreach" iterations.

• URL:
  https://­github.­com/­marcpouzet/­zrun
• Contact:
  Marc Pouzet

Compiling shared variables:   

This year, in the context of Basile Pesin 's thesis project, we completed the work on the semantics and compilation of hierarchical state machines and related control structures. Shared variables, defined with a last value, are a useful enhancment of state machines. They allow access to the previous value of a variable relative to the whole state machine, rather than just the current state. Importantly, they permit implicit completion: for a shared variable x, if no explicit definition is given, then x = last x. This construct was already added to the Coq-based semantics, but it was compiled away early in the compiler, which often results in unnecessary copying in the generated code. This year, we modified the compiler so that last variables are carried right through to the back-end passes which faciliates the elimination of redundant assignments and the associated correctness proofs. This improvement required changes to all the intermediate languages, semantic definitions, and compilation algorithms. In particuarly, we found it necessary to modify the Stc intermediate language to include both `next` and `last` definitions. In terms of expressivity, only one such form is necesary, but having both facilitates optimizations and their correctness proofs, at the expense of more complicated semantics and scheduling. Basile Pesin presented this work at EMSOFT 2023 17 and defended his thesis in October 2023  30.

Denotational semantics for program verification:   

To date we have focused on proving the correctness of compilation passes. This involves specifying semantic models to define the input/output relation associated with a program, implementing compilation functions to transform the syntax of a program, and proving that the relation is unchanged by the functions. In addition to specifying compiler correctness, semantic models can also serve as a base for verifying individual programs. The challenge is to present and manipulate such detailed specifications in interactive proofs. The potential advantage is to be able to reason on abstract models and to obtain, via the compiler correctness theorem, proofs that apply to generated code. Making this idea work requires solving several scientific and technical challenges. It is the subject of Paul Jeanmaire 's thesis.

This year we continued developing a Kahn-style semantics in Coq using C. Paulin-Mohring's library  29. The model now treats the dataflow core of Lustre as presented in our EMSOFT 2021 article  26 with the generalization to enumerated types. We show that, under specific conditions, the denotational model satisfies the relational predicates used in the compiler correctness proof. This allows us to strengthen the overall compiler correctness theorem. Rather than state “If a semantics exists for a program, then it is preseved by the generated code”, we show that “Under specific conditions, a semantics exists and it is preserved by the generated code”. The “specific conditions” are, as usual, that the source program satisfies typing and clock typing rules, but also, that it is not subject to run-time errors. Run-time errors cannot be ignored in our context of end-to-end proof. The CompCert definitions for several arithmetic and logical operators are partial, for example, integer division by zero is not defined. Such partiality simply propogates to the the Vélus relational model, but the denotational model is a total function and operator failures must thus be modeled explicitly. We expressed the absence of run-time errors as a predicate over the dynamic behavior of a program. We implemented a simple static analysis, that nevertheless suffices for many practical programs, and showed that it is a sufficient condition for the absence of run-time errors. The next version of the Vélus compiler will now print warning messages if the source program uses features not treated in the denotational model or if the simple static analysis cannot guarantee the absence of errors. In this case, it becomes the user's responsability to show that run-time errors cannot occur. Our denotational model clarifies several points about the clock typing and Kahn semantics of the function reset operator. We are currently formalizing an alternative model for the function reset operator to further improve our understanding of this topic. We have started drafting an article on these results.

Scheduling and code generation for periodic streams:   

In this approach, the top-level node of a Lustre program is distinguished from inner nodes. It may contain special annotations to specify the triggering and other details of node instances from which separate “tasks” are to be generated. Special operators are introduced to describe the buffering between top-level instances. Notably, different forms of the when and current operators are provided. Some of the operators are under-specified and a constraint solver is used to determine their exact meaning, that is, whether the signal is delayed by zero, one, or more cycles of the receiving clock, which depends on the scheduling of the source and destination nodes. Scheduling is formalized as a constraint solving problem based on latency constraints between some pairs of input/outputs that are specified by the designer.

This year we presented our previous results at ECRTS 2023 16. We also looked more closely at the possibilty of eliminating inter-period instantaneous cycles by adding constraints to the ILP scheduling problem. This problem is related to the detection of feedback arc sets for which there are two well-known encodings. Unfortunately, they can both induce a very large number of additional variables and constraints in the ILP encoding. This is not surprising since the base problem is NP-hard. We thus worked on mitigating heuristics. On the positive side, it turns out that our existing data-dependency and end-to-end latency constraints are readily generalized to allow for “variable concomitance” which may sometimes be useful for breaking instantanous cycles. In particular, we can require that the end-to-end latency along a cycle of data dependencies be strictly greater than zero. The ILP solver is then free to break dependencies by either scheduling the components in different phases or choosing concomitance values to prevent cycles during microscheduling. We presented these preliminary results at the Synchron 2023 workshop. In the collaboration with Airbus we extended the prototype compiler with a hyper-period expansion pass to permit an integration with the Lopht compiler. In the collaboration with Airbus we extended the prototype compiler with a hyper-period expansion pass to permit an integration with the Lopht compiler.

This work is funded by direct industrial contracts with Airbus.

Distribution of the language

The language, its compiler and examples (release 2.1) are on GitHub. It is also available as an OPAM package. All the installation machinery has been greatly simplified.

The implementation of Zelus is now relatively mature. The language has been used in a collection of advances projects; the most important of the recent years being the design and implementation of ProbZelus on top of Zelus. This experiment called for several internal deep changes in the Zelus language.

One of the biggest troubles we faced when implementing Zélus was the lack of a tool to automatically test the compiler and to prototype language extensions before finding how to incorporate in the language and how to compile them. This is what motivated first our work on an executable semantics. The tool Zrun works well now. It is detailled in the Section below. Based on it, we have started a new implementation of Zélus with the objective that every pass of the compiler can be tested, using Zrun as an oracle.

Schedule agnostic semantics for reactive probabilistic programming

In ProbZelus, the semantics of probabilistic models is only defined for scheduled equations. This is a significant limitation compared to synchronous dataflow languages where sets of mutually recursive equations are not ordered. This is a key requirement for commercial synchronous data-flow languages where programs are written using a block diagram graphical interface. Scheduling should not depend on the placement of the blocks which motivate their definition as mutually recursive equations. Besides, the compiler implements a series of source-to-source transformations which often introduces new variables in arbitrary order. Scheduling local declarations is one of the very last compilation passes. The original semantics of ProbZelus is thus far from what is exposed to the programmer and prevents reasoning about most program transformations and compilation passes.

Building on existing semantics for deterministic synchronous languages, we proposed two schedule agnostic semantics for ProbZelus. The key idea is to interpret probabilistic expressions as a stream of un-normalized density functions which maps random variable values to a result and positive score. The co-iterative semantics extends the original semantics to interpret mutually recursive equations using a fixpoint operator. The relational semantics directly manipulates streams and is thus a better fit to reason about program equivalence. We use the relational semantics to prove the correctness of a program transformation required to run the Assumed Parameter Filter (APF) an optimized inference algorithm for state-space models with constant parameters.

A preliminary version of this work is available online 24. The work on the APF-based inference engine (static analysis, compilation, runtime) was presented By G. Bussone at the Journées Francophones des Langages Applicatifs (JFLA) 2023 18.

Semi-symbolic Inference for Efficient Streaming Probabilistic Programming

 (with Erik Atkinson, Michael Carbin, L. Mandel).

Advanced probabilistic inference algorithms combine exact and approximate inference to improve performance in probabilistic programs, and often use various heuristics and optimizations. The inference engine tries to compute exact solution as much as possible and falls back to approximate sampling when symbolic computations fail. The dynamic nature of these systems comes at a cost: 1) The heuristics are not guaranteed to be globally optimal, and 2) inference behavior is unpredictable.

We propose a new probabilistic language with a semi-symbolic inference engine based on our previous work on Delayed Sampling and Semi-Symbolic inference. In this language the user can annotate the program with constraints on the random variable representation (e.g., sampled or symbolic). A specialized static analysis then checks at compile time if these constraints are satisfiable.

A short version of this work was presented at the VeriProP workshop at the International Conference on Computer Aided Verification (CAV) 2023 23.

OnlineSampling.jl

 (with Marc Lelarge and Waïss Azizian).

We continued our work on OnlineSampling.jl. OnlineSampling.jl is an embedded reactive probabilistic language in Julia. Inspired by ProbZelus we designed a domain specific language for describing reactive probabilistic models using Julia macros. Following ProbZelus ideas, the inference method is a Rao-Blackwellised particle filter, a semi-symbolic algorithm which tries to analytically compute closed-form solutions, and falls back to a particle filter when symbolic computations fail. For Gaussian random variables with linear relations, we use belief propagation instead of delayed sampling if the factor graph is a tree. We can thus compute exact solutions for a broader class of models.

This work was accepted at the SPIGM workshop at the International Conference on Machine Learning (ICML) 20

Collaboration with Airbus

Participants: Timothy Bourke, Marc Pouzet.

Our work on multi-clock Lustre programs is funded by contracts with Airbus.

8.1.1 ANR

9.1.1 Scientific events: organisation

• Timothy Bourke presided and organized, with D. Demange as vice-president, the Journées Francophones des Langages Applicatifs (JFLA) 2023.

9.1.2 Scientific expertise

• Timothy Bourke was an expert reviewer for the ANR AAPG 2023 call.

9.2.1 Teaching

• Marc Pouzet is Director of Studies for the CS department, at ENS.
• Licence : Marc Pouzet & Timothy Bourke : “Operating Systems” (L3), Lectures and TDs, ENS, France.
• Master : Marc Pouzet , Guillaume Baudart , & Timothy Bourke , “Models and Languages for Programming Reactive Systems” (M1), Lectures and TDs, ENS, France.
• Master: Marc Pouzet & Timothy Bourke : “Synchronous Systems” (M2), Lectures and TDs, MPRI, France
• Master: Marc Pouzet : “Synchronous Reactive Languages” (M2), Lectures, Master CPS (Cyber-physical Systems, led by Giorgio Mover (École Polytechnique).
• Master: Marc Pouzet "The Elements of Computing Systems". Cycle pluridisciplinaire d'études supérieures (CPES), L2.
• Master: Timothy Bourke : “A Programmer’s introduction to Computer Architectures and Operating Systems" (M1), École Polytechnique, France
• Master: Timothy Bourke and Basile Pesin presented two lectures and TPs on Synchronous Languages in Carlos Agon's course on concurrent models at Sorbonne Université.
• Master: Guillaume Baudart : “Synchronous Programming” (M2), TDs, Université de Paris, France
• Master: Guillaume Baudart : “Probabilistic Programming Languages” (M2), Lectures and TDs, MPRI, France
• Aggregation: Guillaume Baudart : “Introduction to Software Engineering” (préparation à l'aggrégation d'informatique), Lectures and TDs, France
• Bachelor: Timothy Bourke : “A Programmer’s introduction to Computer Architectures and Operating Systems" (L2), École Polytechnique, France

9.2.2 Supervision

• Timothy Bourke supervised the L3 Internship of Vrushank Agrawal on “Model-Based Engineering of Quadcopter Control Software”.
• Timothy Bourke supervised the M2 (MPRI) Internship of Paul Robert (MPRI)on “"Delay Sensitive Static Scheduling of Periodic Synchronous Systems".
• Marc Pouzet supervised the M2 (MPRI)Internship of Antoine Grimod on "A clock-calculus for Zélus".

9.2.3 Juries

• Timothy Bourke was examiner for PhD defense of Jayanth Krishnamurthy (Université Côté d'Azur)
• Timothy Bourke was examiner for PhD defense of Nicolas Nalpon (INSA Toulouse)
• Timothy Bourke was examiner for PhD defense of Baptiste Pollien (ISAE SUPAERO)
• Timothy Bourke was examiner for PhD defense of Fabien Siron (Université Côté d'Azur)
• Marc Pouzet was reviewer of the HDR of Claire Maiza (Université Grenoble-Alpes)
• Marc Pouzet was reviewer of the HDR of Julien Forget (Université de Lille)
• Marc Pouzet was examiner for the HDR of Jérôme Feret (Ecole normale supérieure and PSL University)
• Marc Pouzet was examiner for PhD defense of Léo Gourdin (Université Grenble-Alpe). Dir: Sylvain Boulmé et David Monniaux.
• Marc Pouzet was examiner for the PhD of Amaury Maille, Ecole normale supérieure de Lyon. Dir: Ludovic Henrio and Matthieu Moy.
• Marc Pouzet was examiner for the PhD of Albin Salazar. Ecole normale supérieure and PSL University. Dir: Jérôme Feret.

9.2.4 PhD. Defenses at PARKAS

• Basile Pesin defended his PhD. the 13th of October, 2023 (Jury: Florence Maraninchi (President); Magnus Myreen, Robert de Simone (Reviewers); Carlos Agon (IRCAM and Sorbonne Université; Julien Forget, Xavier Leroy (Examiner).
• Baptiste Pauget defended his PhD. the 8th of December, 2023 (Jury: Jean-Louis Giavitto (President); Albert Cohen, Francois Pottier (Reviewers); Yamine Ait-Ameur, Laure Gonnor (Examiner); Jean-Louis Colaco, Marc Pouzet (director)

9.2.5 Internal or external Inria responsibilities

• Timothy Bourke served on the Jury for the Inria PARIS CRCN/ISFP Concours.

9.2.6 Education

• Timothy Bourke gave a “Chiche” presentation to the groups at the Lycée Montaigne, Paris 6e.

International journals

• 12 articleJ.-L.Jean-Louis Colaço, M.Michael Mendler, B.Baptiste Pauget and M.Marc Pouzet. A Constructive State-based Semantics and Interpreter for a Synchronous Data-flow Language with State Machines: Application to the Language Scade.ACM Transactions on Embedded Computing Systems (TECS)225sSeptember 2023, Article 152: 1-26HALDOI
• 13 articleI.Ingkarat Rak‐amnouykit, A.Ana Milanova, G.Guillaume Baudart, M.Martin Hirzel and J.Julian Dolby. Principled and practical static analysis for Python: Weakest precondition inference of hyperparameter constraints.Software: Practice and Experience5432024, 363-393HALDOI
• 14 articleS.Steven Varoumas, B.Basile Pesin, B.Benoît Vaugon and E.Emmanuel Chailloux. Programming microcontrollers through high-level abstractions: The OMicroB project.Journal of Computer Languages77November 2023, 101228HALDOI

Invited conferences

• 15 inproceedingsG.Guillaume Baudart and C.Christine Tasson. Programmation réactive probabiliste.35es Journées Francophones des Langages Applicatifs (JFLA 2024)Saint-Jacut-de-la-Mer, FranceJanuary 2024HAL

International peer-reviewed conferences

• 16 inproceedingsT.Timothy Bourke, V.Vincent Bregeon and M.Marc Pouzet. Scheduling and Compiling Rate-Synchronous Programs with End-To-End Latency Constraints.Leibniz International Proceedings in Informatics35th Euromicro Conference on Real-Time Systems (ECRTS 2023)26235th Euromicro Conference on Real-Time Systems (ECRTS 2023)Vienna, AustriaJuly 2023, 1:1--1:22HALDOIback to text
• 17 inproceedingsT.Timothy Bourke, B.Basile Pesin and M.Marc Pouzet. Verified Compilation of Synchronous Dataflow with State Machines.ACM Transactions on Embedded Computing SystemsEMSOFT 2023: 23rd International Conference on Embedded Software225sHamburg, GermanySeptember 2023, 137:1–137:26HALDOIback to text

National peer-reviewed Conferences

• 18 inproceedingsG.Guillaume Baudart, G.Grégoire Bussone, L.Louis Mandel and C.Christine Tasson. Filtrer sans s'appauvrir : inférer les paramètres constants des modèles réactifs probabilistes.Journées Francophones des Langages ApplicatifsJFLA 2023 - 34èmes Journées Francophones des Langages ApplicatifsPraz-sur-Arly, FranceJanuary 2023, 24-42HALback to text
• 19 inproceedingsT.Timothy Bourke, B.Basile Pesin and M.Marc Pouzet. Analyse de dépendance vérifiée pour un langage synchrone à flot de données.Journées Francophones des Langages ApplicatifsJFLA 2023 - 34èmes Journées Francophones des Langages ApplicatifsPraz-sur-Arly, FranceJanuary 2023, 101-120HAL

Conferences without proceedings

• 20 inproceedingsW.Waïss Azizian, G.Guillaume Baudart and M.Marc Lelarge. Automatic Rao-Blackwellization for Sequential Monte Carlo with Belief Propagation.SPIGM@ICMLHonolulu, United StatesJuly 2023HALback to text
• 21 inproceedingsJ.-L.Jean-Louis Colaço, B.Baptiste Pauget and M.Marc Pouzet. Polymorphic Types with Polynomial Sizes.Proceedings 9th ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming (ARRAY 2023)9th ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming (ARRAY 2023)Orlando, United StatesACMJune 2023, 36-49HALDOI

Edition (books, proceedings, special issue of a journal)

• 22 proceedingsT.Timothy BourkeD.Delphine DemangeJFLA 2023 - 34èmes Journées Francophones des Langages Applicatifs.JFLA 2023 - 34èmes Journées Francophones des Langages ApplicatifsJournées Francophones des Langages ApplicatifsJanuary 2023, 1-308HAL

Reports & preprints

• 23 miscE.Eric Atkinson, E. Y.Ellie Y. Cheng, G.Guillaume Baudart, L.Louis Mandel and M.Michael Carbin. Verifying Performance Properties of Probabilistic Inference.July 2023HALback to text
• 24 miscG.Guillaume Baudart, L.Louis Mandel and C.Christine Tasson. Density-Based Semantics for Reactive Probabilistic Programming.September 2023HALback to text