automaton | Generates elementary cellular automata

I know that Keycloak saves all its "login events" on the server in the "Events" tab, but also in the database (I came across lines referring to KeycloakDS and Keycloak Database in standalone.xml). Hence my question - since login events are saved in the database, is there any way to automatically save them directly to Syslog? Is there any automaton which copies data from the database and saves it in Syslog? I've heard about various extensions for Keycloak (MQTT, RabbitMQ, or various event-listeners), but I don't know if they can be used for direct automatic copying of data from the Keycloak database to Syslog. Does anyone perhaps have any ideas/suggestions?

The R/exams package supports including TikZ graphics using its function include_tikz(), e.g., as shown in the automaton and logic exercises shipped with the package.

After getting include_tikz() to work for these exercises (see: Why are TikZ graphics rendered with exams2pdf but not with exams2moodle?) I tried to create my own exercise. However, so far this does not work yet. My code is:

I have used the R/exams exercise from http://www.R-exams.org/templates/automaton/, more specifically the automaton.Rmd version of the exercise with the aim of importing the exercise from a Moodle platform via exams2moodle().

Having used three different Moodle platforms, the result was always similar to the one shown in the following image:

Whereas, the results when using exams2pdf(), are optimal, as seen below:

Where can the fault be?

There are plenty of solutions on SO and elsewhere for matching pairs of parentheses or brackets, but none that I can find or come up with to exclude inter-leaved items. What is the solution to this challenge:

There is a set of rules, where each rule corresponds to ceratain cellular automaton. I need to check property of bijectivity for each of these rules. As there are too much of them (2^32 to be precise), I decided to use my GPU for this purpose. But after week or so I am still struggling with one bug.
Briefly speaking, when the kernel is enqueued and its execution is supposedly being performed on GPU, the usage of GPU is as if it is idle. Furthermore, after I added several statements to kernel code in order to see if kernel is being executed at all, I found no signs of that the statements and therefore kernel itself were executed. Besides, all error codes are equal to CL_SUCCESS. I might get something wrong as I'm new to OpenCL programming and will apreciate any help.
This is the host side code with some abbreviations:

I've been getting into Automata theory, compilers and the fundamentals of CS, but there is something fundamental that I don't understand.

I have seen the Chomsky Hierarchy of languages where different classes of languages that have different expressive power are "associated" with an equivalently powerful automaton.

From Wikipedia :

GRAMMAR LANGUAGE AUTOMATON

• Type-0 Recursively enumerable Turing machine
• Type-1 Context-sensitive Linear-bounded non-deterministic Turing machine-
• Type-2 Context-free Non-deterministic pushdown automaton
• Type-3 Regular Finite state automaton

I've seen that every programming language are Turing Complete and that the grammar specifications of programming languages (formalised in BNF, etc..) can be expressed as a Context-free Grammar.

Context-free grammars dont have an "associated" Turing Machine as equivalent.

During interpretation / compilation, the string of the source code of a program written in a programming language (like C, python, etc..) is parsed/translated into an Abstract Syntax Tree.

(As I understand, this is like extracting an array from a string when matching the string against a regular expression, except that the pattern here is not a regular expression, it is a context-free grammar, which is more powerful, hence the tree structure extracted which contain more information that a linear array (coming from capture groups of a regex).)

So the program written, potentially implementing a Turing Machine, is converted into an Abstract Syntax Tree, and all the information contained into the original program is now incorporated into the tree. And later, during execution, the program will accompished some computation that can be as complex as a Turing Machine.

My question is : How can a string expressed within the confines of the rules dictated by what a Context-free Grammar can be, be implementing a Turing Machine while the equivalence grammar/language/automata and the Chomsky Hierarchy say a Context-free Grammar isn't expressive enough to do so ?

Is one of my assumptions wrong ? Or is the fact that memory plays a role in this, and that there is a theorem that says something like : a Turing Machine can be implemented "using" a Tree + a Stack ?

This is really bugging me.

Anything that can enlighten me is really appreciated !

EDIT :

Here's a DUPLICATE of my question :

chomsky hierarchy and programming languages

Why I mistakenly thought that the syntax specification of a programming language defines its semantics ?

Because of what YACC does : (syntax-directed translation)

https://en.wikipedia.org/wiki/Syntax-directed_translation

which associates the rules of the context-free grammar used to parse the programming language (which is used to make the abstract syntax tree) with an action. This is the source of my confusion.

For example, here's a copy paste of an extract of the source code of the perl5 interpreter. This is the file perly.y which is used to by yacc to make the first pass of compilation.

@DCTLib, do you recall this discussion below? You suggested a recursive equation, which was the right approach.

Cudd_PrintMinterm, accessing the individual minterms in the sum of products

Now, I am considering multistate reliability, where we can have either not fail or fail to n-1 different states, with n >= 2. Tulip-dd implements MDDs as described in:

https://github.com/tulip-control/dd/blob/master/doc.md#multi-valued-decision-diagrams-mdd

https://github.com/tulip-control/dd/issues/71

https://github.com/tulip-control/dd/issues/66

In the diagrams in the drawings below, we have defined an MDD declared by:

aut.declare_variable(x=(0,3)) u = aut.add_expr(‘x=i’)

Each value/state of the multi-value variable (MSV) x, x=0, x=1, x=2, or x=3 leads to a specific BDD as shown in the diagrams at the bottom, taking a four-state variable x as example here. The notation is that state 0 represents the normal state and x can fail to different states 1, 2, and 3. The failure probabilities are assigned in table below. In the BDDs below, we (and tulip as well) use the binary coding with two bits x_1 and x_0 to represent each state/value of the MSV. The least significant bit (LSB), i.e., x_0, is always the ancestor. Each of the BDD diagrams below is a representation of a specific value, or state.

To quantify the BDD of a specific state, i.e., the top node, we must know probabilities of binary variables x_0 and x_1 taking different branches (then or else) in the BDD. These branch probabilities are not given directly but need to be calculated according to the BDD structure.

The key here is that the child node probabilities and the branch probabilities of the parent node must be known prior to the calculation of the parent node probability. In the previous BDD quantification, we knew the probabilities of branches from node x_1 to leaf nodes when calculating node x_1 probability. We did not need to know how node x_1 was connected to node x_0. Now, for this four-state variable x, we need to know how node x_1 is connected to node x_0, the binary variable representing the least significant bit, to determine the probabilities of branches from node x_1 to leaf nodes. The question is how to implement this?

I'm trying to implement Wolfram’s elementary cellular automaton (rule 30) in haskell.

Result for ./wolfram 10 :

Is it possible in Isabelle to generate code for a function f that is defined using some recursive function f_helper where f_helper does not terminate in general but does always terminate for the inputs applied to it in f?

For example, I am currently trying to use a function very similar to the following function f_helper that performs a powerset construction on a finite automaton - in each recursive step calculating from the set of transitions of the automaton (transitions) and a set of states of the powerset construction to consider in this step (todo) the transitions in the powerset construction originating from states in todo and the states reached by those transitions (the result_-parameters carry the intermediate results):