## 1 Introduction  
Program synthesis is the process that aims to simplify or automate programming jobs by providing a toolkit of methods that allow for code generation based on a high-level description of task intents (e.g., a textual task description, input/output examples, sketches). The fusion of AI and program synthesis holds immense promise: it can reduce development time, elevate the quality of programs, and reshape the way we build software. In recent years, numerous algorithms have been proposed to automate programming in various programming languages and targeting diverse problems, from simple tasks (e.g.,symbolic regression [1; 2; 3; 4; 5; 6; 7], string manipulation [8; 9; 10; 11], and binary transformation [12; 13; 14]), to more complex challenges (e.g., robot path-finding [6; 15], algebraic calculations [16; 17; 18; 19; 20; 21], and intricate real-world programming problems). Particularly, [PERSON] et al. [22] proposed an algorithm to generate a machine learning pipeline using a corpus and a human-written pipeline. [PERSON] et al. [23] utilised genetic programming (GP) and context-oriented behavioural programming (COBP) in the tic-tac-toe game. [PERSON] introduced pix2 code [24], which leverages convolutional neural networks (CNNs) to generate web development interface code (HTML/CSS) from screenshots of the graphical user interface. The AlphaCode developer team harnessed large-scale sampling and transformer language models to address previously unsolved competitive programming challenges [25]. Despite the wide range of approaches, GP continues to be a competitive method for addressing program synthesis challenges [26]. GP [27] devises a program using an evolutionary process. It commences with a population of unit programs and gradually develops them into solutions customised for specific tasks--a process akin to natural genetic evolution. However, GP faces limitations in devising syntactically correct and semantically meaningful code. Grammar-guided genetic programming (G3P [28]) evolves programs that fit a predefined grammar, thus improving the synthesis performance by restricting/confining the search space. Furthermore, having code that obeys a grammar has several positive impacts, as the grammar can limit the structure of the code as well as the set of callable functions/methods/libraries. Therefore, having an impact on (i) security, e.g., using malicious functionalities, blacklisted libraries, vulnerable structures, etc. ; (ii) computing environment, e.g., if the hardware is not able to handle some functions or if some functions are too costly in terms of memory or energy; and (iii) code quality, improving readability, reducing code smells, and following design patterns. G3P demonstrated its capability to evolve code in various programming languages to tackle a diverse range of problems. However, the system's reliance on randomly generated populations restricts its efficacy in addressing complicated and extensive scenarios. Lately, large language models (LLMs) have shown to be successful at different software engineering tasks [29; 30; 31; 32; 33], including generating source code from textual problem descriptions. Although LLMs have shown success at program synthesis from a task description, they often struggle to generate correct code due to ambiguity in task specifications and complex programming syntax (e.g., generating known buggy code [34]). Moreover, there is a legitimate lack of trust in the generated code as it comes with documented risks (e.g., generating code with known and risky vulnerabilities [35; 36]). The potential for LLM-generated bad code represents a large and growing risk to software and its stakeholders in general. Furthermore, LLMs' generative nature limits their ability to fix erroneous code with iterative prompting [37; 38]. Recent research by [PERSON] et al. [18] proposed an approach that combines the strengths of G3P and LLMs to evolve programs that fit predefined grammar.