Try and create a python script - (OBJECTIVE: Chess AI).

Title: ["Correct Moves"]
Exclude["Any simplified attempts is excluded."]

Breakdown:

#### 1. **Chess Engine Overview**
   - **Purpose**: A minimalist engine that outputs the best move without any additional context or justification.
   - **Symbolism**: The engine represents the idea of correctness in its purest form—delivering the optimal move every time without the need for verbose analysis.
   - **Output**: The engine returns only the move in standard chess notation (e.g., "e2e4"), nothing more, embodying the principle of no over-explanations.

#### 2. **Core Components**
   - **Move Generation**: The engine generates all legal moves at any position.
   - **Evaluation Function**: A heuristic to evaluate the board position based on material balance, king safety, mobility, and pawn structure.
   - **Search Algorithm**: An Alpha-Beta pruning search algorithm with a simple depth limit to navigate through possible moves and find the best one.
   - **Opening Book**: A basic pre-defined list of opening moves to ensure the engine plays strong, established opening lines.
   - **Endgame Tablebase**: Pre-calculated endgames to guarantee correctness in the late stages of the game.

#### 3. **Functionality**
   - **Input**: The engine takes in a chess position (FEN string) or the current state of the game board.
   - **Output**: A single correct move (e.g., "e2e4"), no explanations, no justifications.
   - **No Errors**: The engine doesn’t make incorrect or suboptimal moves—only the best move according to its logic.

#### 4. **Development Steps**
   - **Step 1: Build a Board Representation**  
     A function that can read and process a FEN string or current game state to create an internal representation of the chessboard.
   - **Step 2: Move Generation Algorithm**  
     This function will generate all legal moves for a given board position, using standard rules for how each piece moves.
   - **Step 3: Evaluation Function**  
     A basic heuristic that evaluates a board position and returns a score. It would weigh material balance, pawn structure, piece activity, etc.
   - **Step 4: Search and Pruning (Alpha-Beta)**  
     Implement Alpha-Beta pruning to search for the best move. A simple depth-first search with pruning for efficiency.
   - **Step 5: Endgame Tablebase**  
     Integrate a pre-calculated endgame database to ensure the correct moves are made in decisive positions.
   - **Step 6: Opening Book**  
     Add an opening book for the first few moves to guarantee strong starts. 

#### 5. **User Interaction**
   - The user provides a position or the current state of a chess game.
   - The engine returns **only the best move**, exactly what "Correct Moves" should symbolize.

#### 6. **Technologies**
   - **Language**: Python (with chess libraries such as `python-chess`) or C++ for performance.
   - **Tools**: Use of libraries for move generation (e.g., `python-chess`), search (custom Alpha-Beta implementation), and tablebases for endgames.
   - **UI (Optional)**: A simple command-line interface that accepts a FEN string and outputs the correct move.

### **Example Workflow**
1. **Input**:  
   FEN: `r1bqkbnr/pppppppp/n7/8/4P3/5N2/PPPP1PPP/RNBQKB1R w KQkq - 2 3`
   
2. **Engine Logic**:  
   - Move generation: List of legal moves.
   - Evaluation of board position.
   - Alpha-Beta search up to a certain depth.
   - Best move determined.

3. **Output**:  
   Correct move (e.g., `Nf3`).