fix definition

latex/tacm2024/tacm_poster.tex

@@ -328,7 +328,7 @@
 \jointspacing
 
 \hspace*{2cm}\begin{minipage}[c]{0.90\columnwidth}
-Finite slices of a CFL are finite and therefore regular a fortiori. Just like sets, bitvectors and other datatypes, we can also propagate GREs through a parse chart. Here, the algebra will carry $\text{GRE}^{|V|}$, where 0 is $\varnothing$, and $\oplus, \otimes$ are defined:
+Finite slices of a CFL are finite and therefore regular a fortiori. Just like sets, bitvectors and other datatypes, we can propagate GREs through a parse chart. Here, the algebra will carry $\text{GRE}^{|V|}$, where $0=[\varepsilon]_{v \in V}$, and $\oplus, \otimes$ are defined:
 \end{minipage}
 
 \vspace{-2cm}

latex/thesis/content/Chapter01.tex

@@ -1,7 +1,7 @@
 \chapter{\rm\bfseries Formal Language Theory}
 \label{ch:chapter01}
 
-In computer science, it is common to conflate two distinct notions for a set. The first is a collection of distinct objects sitting on some storage device. The second is a lazy construction: not an explicit collection of objects, but a representation that allows us to efficiently determine membership on demand. This lets us represent infinite sets without requiring an infinite amount of memory. Inclusion then, instead of being simply a lookup query, becomes a decision procedure. This is the basis of formal language theory.
+In computer science, it is common to conflate two distinct notions for a set. The first is a collection sitting on some storage device, e.g., a dataset. The second is a lazy construction: not an explicit collection of objects, but a representation that allows us to efficiently determine membership on demand. This lets us represent infinite sets without requiring an infinite amount of memory. Inclusion then, instead of being simply a lookup query, becomes a decision procedure. This is the basis of formal language theory.
 
 The representation we are chiefly interested in are grammars, which are a common metanotation for specifying the syntactic constraints on programs shared by nearly every programming language. Programming language grammars are overapproximations to the true language of interest, providing a fast procedure for rejecting invalid programs and parsing valid ones.
 

latex/thesis/content/Chapter02.tex

@@ -3,6 +3,6 @@ \chapter{\rm\bfseries Deterministic Program Repair}
 
 Parsimony is a guiding principle in program repair that comes from the 14th century Fransiscan friar named William of Ockham. In keeping with the Fransiscan minimialist lifestyle, Ockham's principle basically says that when you have multiple hypotheses, the simpler one is the better. It is not precisely clear what ``simpler'' should mean in the context of program repair, but a first-order approximation is to strive for the smallest number of changes required to transform an invalid program into a valid one.
 
-Levenshtein distance is one such metric for measuring the number of edits between two strings. First proposed by the Soviet scientist Vladimir Iosifovich Levenshtein, it quantifies how many insertions, deletions, and substitutions are required to transform one string into another. As it turns out, there is an automaton, called the Levenshtein automaton~\cite{schulz2002fast}, that recognizes all strings within a certain Levenshtein distance of a given string. We can use this automaton to find the most likely repair consistent with the observed program and the grammar.
+Levenshtein distance is one such metric for measuring the number of edits between two strings. First proposed by the Soviet scientist Vladimir Levenshtein, it quantifies how many insertions, deletions, and substitutions are required to transform one string into another. As it turns out, there is an automaton, called the Levenshtein automaton~\cite{schulz2002fast}, that recognizes all strings within a certain Levenshtein distance of a given string. We can use this automaton to find the nearest most likely repair consistent with the observed program and the grammar.
 
-Given the source code for a computer program $\hat\sigma$ and a grammar $G$, our goal is to find the most likely valid string $\sigma$ consistent with the grammar $G$ and the observed program $\hat\sigma$. We can formalize all possible repairs as a language intersection problem.
+Given the source code for a computer program $\hat\sigma$ and a grammar $G$, our goal is to find the most likely valid string $\sigma$ consistent with the grammar $G$ and the observed program $\hat\sigma$. We can formalize all possible repairs as a language intersection problem.