listings title position

Author: LauraWangQiu

docs/AlphaDeepChess/Capitulos/AnalysisOfImprovements.tex

@@ -9,7 +9,7 @@ \section{Profiling}
 
 \noindent We run the engine under \texttt{perf} using the following commands:
 
-\begin{lstlisting}[language=bash, caption={Profiling \textit{AlphaDeepChess} with perf}, frame=single, breaklines=true]
+\begin{lstlisting}[language=bash, caption={Profiling \textit{AlphaDeepChess} with perf}, frame=single, breaklines=true, captionpos=b]
 # Record performance data with function stack traces
 sudo perf record -g ./build/release/AlphaDeepChess
 
@@ -19,7 +19,7 @@ \section{Profiling}
 
 \noindent After recording, \texttt{perf report} opens an interactive terminal interface where functions are sorted by CPU overhead, allowing us to easily identify performance-critical regions.
 
-\vspace{2em}
+\vspace{1em}
 
 \noindent First, we profile the basic architecture of the engine implemented in~\cref{cap:descripcionTrabajo}, and then evaluate it again after applying the optimizations described in~\cref{cap:ImprovementTechniques}.
 
@@ -262,7 +262,7 @@ \subsection*{Late move reductions}
 
 \noindent The results show 48 wins, 15 draws, and 37 losses. This outcome is slightly worse than the version without reductions. A likely explanation is that the current move ordering heuristic is not strong enough, leading the search to incorrectly reduce important moves that appear late in the move list. As a result, the potential benefits of LMR are not fully realized and may even degrade search quality in some positions.
 
-\vspace{2em}
+\vspace{1em}
 
 \noindent We can confirm that \textit{AlphaDeepChess} achieves its maximum skill level with the following configuration:
 

docs/AlphaDeepChess/Capitulos/DescripcionTrabajo.tex

@@ -31,8 +31,6 @@ \section{Chessboard representation: bitboards}
 
 \noindent A list of twelve bitboards is used, one for each type of chess piece.~\cref{fig:bitboardPositionExample} illustrates this concept with a chess position example.
 
-\vspace{1em}
-
 \begin{figure}[H]
     \begin{minipage}[c]{0.35\textwidth}
         \newchessgame
@@ -62,8 +60,6 @@ \section{Chessboard representation: bitboards}
     \caption{List of bitboards data structure example.}\label{fig:bitboardPositionExample}
 \end{figure}
 
-\vspace{2em}
-
 \noindent The main advantages of bitboards is that we can operate on multiple squares simultaneously using bitwise operations. For example, we can determine if there are any black pawns on the fifth rank by performing a bitwise AND operation with the corresponding mask.
 
 \begin{figure}[H]
@@ -104,8 +100,6 @@ \subsection*{Game state}
     \item Fifty-move rule counter (moves since a capture or pawn move) (bits 35-42).
 \end{enumerate}
 
-\vspace{2em}
-
 \noindent Having described the data structures that represent chess positions, we can now present the engine's core component: the search algorithm.
 
 \section{Search algorithm}
@@ -169,8 +163,6 @@ \subsection*{Horizon effect problem, quiescence search}\label{sec:horizon-effect
     \caption{Horizon effect position example.}\label{fig:horizonEffectExample}
 \end{figure}
 
-\vspace{1em}
-
 \noindent To avoid this, when we reach the end of the tree at maximum depth, we must extend the search but only considering capture moves until no captures are available. This is known as quiescence search~\cite{QuiescenceSearch}.
 
 \vspace{1em}
@@ -197,14 +189,13 @@ \section{Evaluation: materialistic approach}\label{sec:evaluation}
 
 \vspace{1em}
 
-\noindent \parbox{\textwidth}{The full implementation can be found in \texttt{src\textbackslash{}evaluation\textbackslash{}evaluation\_dynamic.cpp}.}
+\noindent The full implementation can be found in \\
+\texttt{src\textbackslash{}evaluation\textbackslash{}evaluation\_dynamic.cpp.}.
 
 \vspace{1em}
 
 \noindent The following shows the standard centipawn values assigned to each piece type.
 
-\vspace{1em}
-
 \begin{table}[H]
     \centering
     \begin{tabular}{|c|c|}
@@ -231,8 +222,6 @@ \subsection*{Piece square tables (PST's)}
 
 \noindent The basic material evaluation described earlier has a significant limitation, it does not consider the fact that a piece could have more power in different squares of the board. For instance, as illustrated in the following image, a knight placed in the center can control up to eight squares, while a knight positioned in the corner can reach only two.
 
-\vspace{1em}
-
 \begin{figure}[H]
     \centering
     \newchessgame
@@ -470,16 +459,12 @@ \subsection*{Bitboard of danger squares}
     \caption{Example of a danger bitboard squares attacked by the black side.}\label{fig:BitboardDangers}
 \end{figure}
 
-\vspace{1em}
-
 \noindent The danger bitboard is constructed by performing a bitwise OR operation across all legal attacks from the opponent's pieces. For non-sliding pieces such as pawns, knights, and kings, their legal attack bitboards match exactly with their precomputed attack patterns.
 
 \vspace{1em}
 
 \noindent However, sliding pieces as rooks, bishops, and queens require additional handling. Their attacks depend on the presence of blockers in their movement paths.~\cref{fig:blockerExample} shows an example where the attacks of sliding pieces are limited due to blocking pawns. In this case, the rook sliding attack is being blocked by the pawns.
 
-\vspace{1em}
-
 \begin{figure}[H]
     \centering
     \newchessgame
@@ -500,8 +485,6 @@ \subsection*{Bitboard of pinned pieces}
 
 \noindent The next challenging aspect of legal move generation is handling pinned pieces. A pinned piece cannot move freely, as doing so would expose its king to check, making the move illegal. An example of a pinned piece is shown in~\cref{fig:pinnedPiece}.
 
-\vspace{1em}
-
 \begin{figure}[H]
     \centering
     \newchessgame
@@ -512,8 +495,6 @@ \subsection*{Bitboard of pinned pieces}
     \caption{The black rook pins the white knight. If the knight moves, the white king could be captured, making the move illegal.}\label{fig:pinnedPiece}
 \end{figure}
 
-\vspace{1em}
-
 \noindent We must compute a bitboard that contains all pinned pieces on the board. This allows us to restrict their movement accordingly during move generation. However, identifying pinned pieces is computationally expensive, as it requires iterating through the attack patterns of sliding pieces and checking for alignment with the king and potential blockers.
 
 \subsection*{Capture and push mask}
@@ -590,8 +571,7 @@ \subsection*{Testing the move generator: perft test}
     \caption{Perft results at depth 6: comparison between \textit{Stockfish} and \textit{AlphaDeepChess}~\cite{PerftResults}.}\label{tab:perftResults}
 \end{table}
 
-\section{Move ordering}
-\label{cap:moveOrdering}
+\section{Move ordering}\label{cap:moveOrdering}
 Once having explained the move generator function, in this chapter we detail the implementation of the move ordering heuristic.
 
 \vspace{1em}
@@ -640,8 +620,6 @@ \subsection*{Killer moves}
 
 \noindent A \textit{killer move} is a quiet, non-capturing move which can cause a cutoff in different branches of the tree at the same depth~\cite{KillerMoves}.
 
-\vspace{1em}
-
 \begin{figure}[H]
     \centering
     \newchessgame

docs/AlphaDeepChess/Capitulos/EstadoDeLaCuestion.tex

@@ -33,7 +33,7 @@ \section{Search algorithms}
 
 \vspace{1em}
 
-\begin{lstlisting}[caption={Pseudocode of the Depth-First Search algorithm~\cite{CLRS}.}, label={lst:dfs}, frame=single, numbers=left, xleftmargin=15pt]
+\begin{lstlisting}[caption={Pseudocode of the Depth-First Search algorithm~\cite{CLRS}.}, label={lst:dfs}, frame=single, numbers=left, xleftmargin=15pt, captionpos=b]
 Procedure DFS(Graph G, Node v):
     Mark v as visited
     For each neighbor w of v in G.adjacentEdges(v):
@@ -53,7 +53,7 @@ \section{Search algorithms}
 
 \vspace{1em}
 
-\begin{lstlisting}[caption={Pseudocode of the Best-First Search algorithm~\cite{Pearl1984}.}, frame=single, numbers=left, xleftmargin=10pt, breaklines=true]
+\begin{lstlisting}[caption={Pseudocode of the Best-First Search algorithm~\cite{Pearl1984}.}, frame=single, numbers=left, xleftmargin=10pt, breaklines=true, captionpos=b]
 Procedure BestFirstSearch(Graph G, Node start, Node goal):
     Create an empty priority queue PQ
     Add start to PQ with priority 0
@@ -87,7 +87,7 @@ \subsection*{Minimax algorithm}\label{sec:minimax}
 
 \vspace{1em}
 
-\begin{lstlisting}[caption={Pseudocode of the Minimax algorithm~\cite{Russell2021artificial}.}, label={lst:minimax}, frame=single, numbers=left, xleftmargin=15pt, breaklines=true]
+\begin{lstlisting}[caption={Pseudocode of the Minimax algorithm~\cite{Russell2021artificial}.}, label={lst:minimax}, frame=single, numbers=left, xleftmargin=15pt, breaklines=true, captionpos=b]
 Procedure Minimax(Node position, Integer depth, Boolean maximizingPlayer):
     If depth == 0 or position is a terminal node:
         Return the evaluation of the position
@@ -143,8 +143,6 @@ \subsection*{Minimax algorithm}\label{sec:minimax}
 
 \noindent For example, let's say that white always wants the highest value (maximizing the result), while black wants the lowest value (minimizing the result). In~\cref{fig:minimax}, white is represented by square nodes and black by circle nodes. Note that this example is a binary tree, but in a real scenario there would likely be more moves or nodes, because in chess each position usually allows a wide range of legal moves, not just two as in a binary tree. For the leftmost pair of leaf nodes with values of 3 and 5, 3 is chosen because black tries to get the lowest score between them. Then, for the other pair of leaf nodes with values of 2 and 9, 2 is chosen for the same reason. Lastly, at the root node, white selects 3 as the maximum value between 3 and 2.
 
-\vspace{1em}
-
 \subsection*{Alpha-beta pruning}\label{sec:alphaBeta}
 
 Minimax has the problem that a lot of the node evaluation is redundant, because we can know beforehand that some branches will not affect the final decision. For that purpose, we can enhance the search with the \textit{alpha-beta pruning} technique. 
@@ -380,7 +378,7 @@ \subsection*{Alpha-beta pruning}\label{sec:alphaBeta}
 
 \noindent Having described the main search algorithms, it is important to explain how the skill of both human and computer chess players is measured. Next, we describe the console communication protocol used by chess engines, and finally, we provide an overview of how \textit{Stockfish} operates internally.
 
-\section{ELO rating system}
+\section{Elo rating system}
 
 The Elo rating system, developed by \textit{Arpad Elo} in the 1960s, is a method used to calculate the relative skill levels of players in two-player games such as chess~\cite{Elo}. It was adopted by the FIDE in 1970 as the main rating system for all federated players.
 
@@ -422,10 +420,7 @@ \section{ELO rating system}
 
 This system ensures that a player gains more rating points for defeating a higher-rated opponent and loses fewer points when losing to a stronger player.
 
-\newpage
-
-\section{UCI}
-\label{sec:uci}
+\section{UCI}\label{sec:uci}
 
 \noindent The chess community has developed an standard console protocol for chess engines to facilitate interoperability between engines and external applications. The \textit{Universal Chess Interface} (UCI)~\cite{UciProtocol} makes it possible to organize games and tournaments between different bots, as well as to integrate engines into graphical user interfaces (GUIs) and other software tools.
 
@@ -451,33 +446,29 @@ \section{UCI}
     \item \texttt{stop}: stop calculating.
 \end{itemize}
 
-\newpage
-
-Now that we have covered the fundamental concepts behind chess engines, in the following section we present the most powerful and widely used chess engine.
+\noindent Now that we have covered the fundamental concepts behind chess engines, in the following section we present the most powerful and widely used chess engine.
 
-\section{\textit{Stockfish}}
-\label{sec:stockfish}
+\section{\textit{Stockfish}}\label{sec:stockfish}
 
-\par \textit{Stockfish} is an open-source chess engine that has consistently ranked among the strongest in the world~\cite{Stockfish}. It is written in C++ and released under the GNU General Public License (GPL). \textit{Stockfish} has been developed and refined by a large community of contributors.
+\noindent \textit{Stockfish} is an open-source chess engine that has consistently ranked among the strongest in the world~\cite{Stockfish}. It is written in C++ and released under the GNU General Public License (GPL). \textit{Stockfish} has been developed and refined by a large community of contributors.
 
 \vspace{1em}
 
-\par \textit{Stockfish} has an estimated Elo rating of around 3644~\cite{StockfishElo}, placing it far above the best human player, Magnus Carlsen, whose peak Elo rating was 2882 in May 2014~\cite{MagnusCarlsenElo}.
+\noindent \textit{Stockfish} has an estimated Elo rating of around 3644~\cite{StockfishElo}, placing it far above the best human player, Magnus Carlsen, whose peak Elo rating was 2882 in May 2014~\cite{MagnusCarlsenElo}.
 
 \vspace{1em}
 
-\par It is based on the minimax search algorithm, enhanced with alpha-beta pruning. In addition, it incorporates several of the techniques described in later chapters (see Chapter~\cref{cap:descripcionTrabajo}).
+\noindent It is based on the minimax search algorithm, enhanced with alpha-beta pruning. In addition, it incorporates several of the techniques described in later chapters (see Chapter~\cref{cap:descripcionTrabajo}).
 
 \vspace{1em}
 
 \par The key component of \textit{Stockfish}'s strength is its use of machine learning algorithms to evaluate chess positions more accurately, in particular, \textit{Stockfish} uses NNUE (Efficiently Updatable Neural Network), a neural network architecture originally developed for shogi engines and later adapted for chess~\cite{NNUE}. NNUE efficiently evaluates positions by finding and learning complex piece patterns. It is optimized to run quickly even on CPUs and significantly improves move ordering (see Chapter~\cref{cap:moveOrdering}), allowing the engine to explore the most promising lines first and prune large parts of the search tree.
 
-\vspace{2em}
+\vspace{1em}
 
 In the following section, we describe one of the most popular platforms where both humans and chess engines play competitively.
 
-\section{\textit{Lichess}}
-\label{sec:lichess}
+\section{\textit{Lichess}}\label{sec:lichess}
 
 \textit{Lichess} is a free and open-source online chess platform that offers a wide range of features for both casual and competitive players. It was created by Thibault Duplessis in 2010 and has since grown into one of the most popular chess websites in the world, hosting millions of games each day~\cite{Lichess}.
 
@@ -493,12 +484,11 @@ \section{\textit{Lichess}}
 
 \noindent \textit{Lichess} also supports chess engines and bots through the \textit{Lichess} Bot API, enabling integration with engines like \textit{Stockfish}. It is often used for engine testing, AI competitions, and research purposes. Many developers and researchers use the \textit{Lichess} platform as a benchmark or interface for evaluating engine performance.
 
-\vspace{2em}
+\vspace{1em}
 
-Finally, the chess community uses specialized tools to evaluate the relative playing strength of chess engines. One of the most widely used tools for this purpose is \textit{Cutechess}.
+\noindent Finally, the chess community uses specialized tools to evaluate the relative playing strength of chess engines. One of the most widely used tools for this purpose is \textit{Cutechess}.
 
-\section{\textit{Cutechess}}
-\label{sec:cutechess}
+\section{\textit{Cutechess}}\label{sec:cutechess}
 
 \noindent \textit{Cutechess} is an open-source tool widely adopted in the chess programming community. It allows users to run automated matches between engines, compare their performance, and analyze gameplay~\cite{CuteChess}.
 
@@ -512,9 +502,9 @@ \section{\textit{Cutechess}}
 
 \vspace{1em}
 
-\noindent Then, it checks the active status of each engine and manages the start of the games by setting up the board on both engines with the \texttt{position} command. Afterwards, it sends the \texttt{go} command and stops the search with \texttt{stop} when the search time or depth is reached, extracting the best move provided by the engine whose turn it is. This move is then passed to the other engine, alternating turns so that both engines play against each other automatically.~\cref{lst:cutechess-example} we show a \textit{Cutechess} log file, we directly configured the starting positions from a list of FENs in the \texttt{positions.fen} file:
+\noindent Then, it manages the games by setting up the board with the \texttt{position} command, sending \texttt{go} to start the search, and stopping when the search time or depth is reached. Moves are alternated between engines so they play against each other automatically. In~\cref{lst:cutechess-example}, we show a \textit{Cutechess} log file, where the starting positions are taken directly from a list of FENs in the \texttt{positions.fen} file.
 
-\begin{lstlisting}[basicstyle=\ttfamily\scriptsize, breaklines=true, frame=single, caption={Example of \textit{Cutechess}}, label={lst:cutechess-example}]
+\begin{lstlisting}[basicstyle=\ttfamily\scriptsize, breaklines=true, frame=single, captionpos=b, caption={Example of \textit{Cutechess}}, label={lst:cutechess-example}]
 Running test (8) with the following configuration:
 Games: 1, Search Time: 5, Depth: 5
 PGN File: results.pgn, EPD File: results.epd, Log File: results.log
@@ -556,7 +546,7 @@ \section{\textit{Cutechess}}
  >AlphaDeepChess(0): position fen rnbqkb1r/1p2pppp/p2p1n2/8/3NP3/2N5/PPP2PPP/R1BQKB1R w KQkq - 0 6 moves c1g5 e7e6
 \end{lstlisting}
 
-\noindent In~\cref{lst:cutechess-example}, in addition to setting the number of games to $1$, the search time to $5$ seconds, and the search depth to $5$, we provided a list of starting positions, from which one is chosen at random. Each line starting with \texttt{position fen \ldots} establishes the FEN position and continues by adding the moves played.
+\noindent In~\cref{lst:cutechess-example}, we set the number of games to $1$, the search time to $5$ seconds, and the search depth to $5$. We also provided a list of starting positions, from which one is chosen at random. Each line starting with \texttt{position fen \ldots} sets the FEN position and adds the moves played.
 
 \vspace{1em}
 

docs/AlphaDeepChess/Capitulos/ImprovementTechniques.tex

@@ -35,7 +35,7 @@ \section{Transposition table}\label{sec:tt}
 \noindent Taking advantage of dynamic programming, we create a look-up table of chess positions and its evaluation. So if we encounter the same position again, the evaluation is already precalculated. However, we ask ourselves the following question: how much space does the look-up table take up if there are an astronomical amount of chess positions? What we can do is assign a hash to each position and make the table index the last bits of the hash. The larger the table, the less likely access collisions will be. We also want a hash that is fast to calculate and has collision-reducing properties.
 ~\cite{TranspositionTable}
 
-\vspace{2em}
+\vspace{1em}
 
 \noindent \parbox{\textwidth}{The complete implementation can be found in\\\texttt{include\textbackslash{}utilities\textbackslash{}transposition\_table.hpp}.}