Refactor evaluation logic: streamline user_eval.py, update evaluation script references, and clean up eval.py

src/eval.py

@@ -1,30 +1,14 @@
-import datetime
 import time
 import json
 import tempfile
 
-import minizinc
-from datasets import load_dataset
 from huggingface_hub import HfApi, hf_hub_download
 import os
-import sys
-import subprocess
 import threading
 from pathlib import Path
 
-from src.config import DATASET_REPO_ID, DS_RESULTS_PATH, CPMPY_FRAMEWORK, ORTOOLS_FRAMEWORK, \
-    MINIZINC_FRAMEWORK
-
-# --- Configuration ---
-
-GT_DATASET_NAME = "kostis-init/CP-Bench"
-
-# Column names in the Hugging Face dataset for problem identifier and model script
-GT_PROBLEM_NAME_COLUMN = "id"
-GT_MODEL_CODE_COLUMN = "model"
-
-# Timeout for running individual model scripts (both generated and modified ground-truth)
-SCRIPT_EXECUTION_TIMEOUT = 60  # seconds
+from src.config import DATASET_REPO_ID, DS_RESULTS_PATH
+from src.user_eval import evaluate_submission
 
 
 def run_evaluation(submission_path):
@@ -43,171 +27,6 @@ def start_background_evaluation(submission_path):
     return True
 
 
-def extract_json_from_code_output(output: str):
-    try:
-        start_index = output.find('{')
-        end_index = output.rfind('}') + 1
-        # Extract the JSON part
-        json_part = output[start_index:end_index]
-        return json.loads(json_part)
-    except json.JSONDecodeError:
-        return None
-
-
-def exec_code_minizinc(code: str, timeout_sec):
-    """
-    Executes a MiniZinc model string using the minizinc-python library.
-
-    :param code: The MiniZinc model code as a string.
-    :param timeout_sec: The maximum time to wait for the solver in seconds.
-    :return: A tuple of (success, output, timeout_occured)
-    """
-    successfully_executed = False
-    output = ""
-    timeout_occurred = False
-    timeout_duration = datetime.timedelta(seconds=timeout_sec)
-
-    try:
-        # 1. Create a MiniZinc model instance
-        model = minizinc.Model()
-        model.add_string(code)
-
-        # 2. Find a default solver configured with MiniZinc
-        # You can be more specific, e.g., solver = minizinc.Solver.lookup("gecode")
-        # If the default solver isn't found or suitable, this will raise an error.
-        gecode = minizinc.Solver.lookup("gecode")
-        if gecode is None:
-            raise RuntimeError("No suitable solver found. Please install a MiniZinc solver.")
-
-        # 3. Create an Instance to solve
-        instance = minizinc.Instance(gecode, model)
-
-        # 4. Solve the instance with the specified timeout
-        # The solve() method handles the timeout internally.
-        result = instance.solve(timeout=timeout_duration)
-
-        # 5. Process the result
-        if result.status in {minizinc.Status.SATISFIED, minizinc.Status.OPTIMAL_SOLUTION}:
-            successfully_executed = True
-            output = str(result.solution) if result.solution is not None else ""
-            timeout_occurred = False
-        elif result.status == minizinc.Status.UNKNOWN:
-             successfully_executed = False
-             output = f"Timeout Error: Solver stopped after {timeout_sec} seconds (Status: UNKNOWN)."
-             timeout_occurred = True
-        else:
-            # Handle other non-success statuses (UNSAT, ERROR, etc.)
-            successfully_executed = False
-            output = f"Solving failed. Status: {result.status}"
-            timeout_occurred = False
-
-    except minizinc.MiniZincError as e:
-        # Catch MiniZinc specific errors (e.g., syntax errors, solver not found)
-        successfully_executed = False
-        output = f"MiniZinc Error: {e}"
-        timeout_occurred = False
-    except Exception as e:
-        # Catch other unexpected errors
-        successfully_executed = False
-        output = f"Unexpected Error during MiniZinc execution: {e}"
-        timeout_occurred = False
-
-    return successfully_executed, output, timeout_occurred
-
-
-def exec_code(code: str, timeout=10, modelling_language='cpmpy'):
-    """
-    Execute the given code and return the output
-
-    :param code: The code to execute as a string
-    :param timeout: The maximum time to wait for the code to execute in seconds
-    :param modelling_language: The language to use for execution (cpmpy, minizinc, or-tools)
-    :return: A tuple of (success, output, timeout_occured)
-    """
-
-    # create a temp directory to store the temporary file
-    temp_dir_name = "temp_dir_for_exec_code"
-    temp_dir = os.path.join(os.getcwd(), temp_dir_name)
-    os.makedirs(temp_dir, exist_ok=True)
-
-    # write the code to a temporary file
-    suffix = '.__hidden_py__' if modelling_language == CPMPY_FRAMEWORK or modelling_language == ORTOOLS_FRAMEWORK else '.mzn'
-    with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix=suffix, dir=temp_dir, encoding='utf-8') as temp_file:
-        temp_instance_path = temp_file.name
-        temp_file.write(code)
-
-    try:
-        # execute the code
-        if modelling_language == CPMPY_FRAMEWORK or modelling_language == ORTOOLS_FRAMEWORK:
-            command = [sys.executable, temp_instance_path]
-            result = subprocess.run(command, capture_output=True, text=True, timeout=timeout, encoding='utf-8')
-
-            successfully_executed = (result.returncode == 0)
-            output = result.stdout if successfully_executed else result.stderr
-            timeout_occurred = False
-        elif modelling_language == MINIZINC_FRAMEWORK:
-            successfully_executed, output, timeout_occurred = exec_code_minizinc(code, timeout)
-        else:
-            raise ValueError(f"MODELLING_LANGUAGE not supported: {modelling_language}")
-
-    except subprocess.TimeoutExpired as e:
-        successfully_executed = False
-        output = f"Timeout Error: Execution time exceeded {timeout} seconds"
-        timeout_occurred = True
-    except Exception as e:
-        successfully_executed = False
-        output = f"Error: {e}"
-        timeout_occurred = False
-
-    os.remove(temp_instance_path)
-
-    return successfully_executed, output, timeout_occurred
-
-
-def add_constraints_as_string(solution):
-    """Generate constraints as a string to be added to the original script."""
-    constraints = ""
-    if solution:  # Ensure solution is not None
-        for key, value in solution.items():
-            # Basic escaping for string values if they occur, though typically solutions are numeric/boolean
-            if isinstance(value, str):
-                constraints += f"\nmodel += ({key} == \"{value}\")"
-            else:
-                constraints += f"\nmodel += ({key} == {value})"
-    return constraints
-
-
-def get_modified_script(script_content, solution):
-    """Add constraints to the script content and self-consistency checks."""
-    constraints_str = add_constraints_as_string(solution)
-    modified_script = f"{script_content}\n{constraints_str}"
-    modified_script += """
-# Print the absolute path of the current directory along with the script name
-import os
-print(os.path.abspath(__file__))
-
-# Keep old objective
-old_objective = None
-if hasattr(model, 'objective_is_min') and model.objective_is_min is not None:
-    old_objective = model.objective_value()
-
-# Check self-consistency
-if not model.solve():
-    print('ERROR: The model is unsatisfiable with the self-consistency constraints')
-else:
-    print('SUCCESS: Model is consistent')
-
-# Check if the objective value is the same
-if old_objective is None:
-    print('SUCCESS: No objective defined')
-elif model.objective_value() != old_objective:
-    print('ERROR: The objective value has changed')
-else:
-    print('SUCCESS: Objective value is consistent')
-"""
-    return modified_script
-
-
 # --- Main Evaluation Logic ---
 def main_eval(
         user_dataset_repo_id: str,
@@ -237,7 +56,7 @@ def main_eval(
         # Path for the summary file within the local temporary result directory
         summary_file_path = local_result_dir_for_upload / "summary.txt"
 
-        # 1. Download submitted files from HF Dataset
+        # Download submitted files from HF Dataset
         print(f"  Downloading submission files from '{submission_path_in_dataset}' to '{local_submission_dir}'...",
               flush=True)
         try:
@@ -262,28 +81,11 @@ def main_eval(
             print(f"  CRITICAL ERROR - Failed to download submission files: {e_download}", flush=True)
             return 1
 
-        # 2. Load ground-truth dataset
-        print(f"  Loading ground-truth dataset '{GT_DATASET_NAME}'...", flush=True)
-        try:
-            gt_dataset = load_dataset(GT_DATASET_NAME, split="train", trust_remote_code=True)
-            ground_truth_models = {
-                item[GT_PROBLEM_NAME_COLUMN]: item[GT_MODEL_CODE_COLUMN]
-                for item in gt_dataset if
-                GT_PROBLEM_NAME_COLUMN in item and GT_MODEL_CODE_COLUMN in item and item[GT_MODEL_CODE_COLUMN]
-            }
-            if not ground_truth_models: raise ValueError("No models in GT dataset.")
-            print(f"  Loaded {len(ground_truth_models)} ground-truth models.", flush=True)
-        except Exception as e_gt:
-            print(f"  CRITICAL ERROR - Failed to load ground-truth dataset: {e_gt}", flush=True)
-            with open(summary_file_path, "w") as f:
-                f.write(f"CRITICAL ERROR: Failed to load ground-truth dataset '{GT_DATASET_NAME}'.\nError: {e_gt}\n")
-            # (Attempt to upload error summary)
-            return 1
-
         # load generated models from jsonl to memory
         print(f"  Loading generated models from '{local_submission_dir}'...", flush=True)
         submitted_models = []
-        with open(os.path.join(local_submission_dir, submission_path_in_dataset, "submission.jsonl"), "r", encoding="utf-8") as f:
+        with open(os.path.join(local_submission_dir, submission_path_in_dataset, "submission.jsonl"), "r",
+                  encoding="utf-8") as f:
             for line in f:
                 try:
                     json_obj = json.loads(line)
@@ -292,124 +94,16 @@ def main_eval(
                     print(f"  ERROR: Failed to parse JSON object from line: {line}. Error: {e}", flush=True)
 
         # load metadata file
-        with open(os.path.join(local_submission_dir, submission_path_in_dataset, "metadata.json"), "r", encoding="utf-8") as f:
+        with open(os.path.join(local_submission_dir, submission_path_in_dataset, "metadata.json"), "r",
+                  encoding="utf-8") as f:
             metadata = json.load(f)
 
         print(f"  Loaded {len(submitted_models)} generated models.", flush=True)
 
+        # Writes stats to the summary file
+        evaluate_submission(submitted_models, summary_file_path, metadata["modelling_framework"], top_level_temp_dir)
 
-        # Statistics
-        total_submitted_models = 0
-        models_ran_successfully = 0
-        consistency_checks_passed = 0
-        objective_checks_passed = 0
-        all_checks_passed = 0
-        gt_models_found = 0
-
-        with open(summary_file_path, "w", encoding="utf-8") as summary_f:
-            summary_f.write(f"Evaluation Summary for Submission: {submission_name_for_files}\n")
-            summary_f.write(f"User Data Repo: {user_dataset_repo_id}\n")
-            summary_f.write(f"Submission Path in Dataset: {submission_path_in_dataset}\n")
-            summary_f.write(f"Ground-Truth Dataset: {GT_DATASET_NAME}\n")
-            summary_f.write("-" * 30 + "\n")
-
-            # Iterate through downloaded submitted models
-            for submitted_model in submitted_models:
-                curr_model = submitted_model[GT_MODEL_CODE_COLUMN]
-
-                total_submitted_models += 1
-                problem_name = submitted_model[GT_PROBLEM_NAME_COLUMN]
-                print(f"\n  Processing downloaded model: {problem_name}", flush=True)
-                summary_f.write(f"\n--- Model: {problem_name} ---\n")
-
-                summary_f.write("    1. Running submitted model...\n")
-
-                succ_exec, output, timeout_occurred = exec_code(curr_model, timeout=SCRIPT_EXECUTION_TIMEOUT, modelling_language=metadata["modelling_framework"])
-
-                if succ_exec:
-                    models_ran_successfully += 1
-                    summary_f.write("      - SUCCESS: Model executed successfully.\n")
-
-                if timeout_occurred:
-                    summary_f.write(f"      - TIMEOUT: Execution time exceeded {SCRIPT_EXECUTION_TIMEOUT} seconds.\n")
-                    continue
-                if not succ_exec:
-                    summary_f.write(f"      - FAILED: Execution failed with error: {output}\n")
-                    continue
-                if output is None or not output.strip():
-                    summary_f.write(f"      - FAILED: No output from execution.\n")
-                    continue
-                # Attempt to extract JSON from stdout
-                generated_solution = extract_json_from_code_output(output)
-                if generated_solution is None:
-                    summary_f.write(f"      - FAILED: Could not extract JSON solution from output: {output}\n")
-                    continue
-                summary_f.write(f"      - SUCCESS: Got solution: {generated_solution}\n")
-
-                summary_f.write(f"    2. Checking against ground-truth for '{problem_name}'...\n")
-                if problem_name not in ground_truth_models:
-                    summary_f.write(f"      - FAILED: Ground-truth model for '{problem_name}' not found in dataset.\n")
-                    continue
-                gt_models_found += 1
-                ground_truth_script_content = ground_truth_models[problem_name]
-                summary_f.write("      - SUCCESS: Found ground-truth model.\n")
-
-                summary_f.write("    3. Performing self-consistency check on ground-truth model...\n")
-                modified_gt_script = get_modified_script(ground_truth_script_content, generated_solution)
-
-                try:
-                    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False, encoding='utf-8',
-                                                     dir=top_level_temp_dir) as tmp_file:
-                        tmp_file.write(modified_gt_script)
-                        tmp_file_path_str = tmp_file.name
-
-                    gt_check_result = subprocess.run(
-                        [sys.executable, tmp_file_path_str],
-                        capture_output=True, text=True, timeout=SCRIPT_EXECUTION_TIMEOUT, encoding='utf-8',
-                    )
-                    os.unlink(tmp_file_path_str)
-
-                    gt_stdout = gt_check_result.stdout
-                    if "SUCCESS: Model is consistent" in gt_stdout:
-                        summary_f.write("      - CONSISTENCY: PASSED\n")
-                        consistency_checks_passed += 1
-                    else:
-                        summary_f.write(
-                            "      - CONSISTENCY: FAILED (Details in logs or stdout)\n")
-
-                    if "SUCCESS: No objective defined" in gt_stdout or "SUCCESS: Objective value is consistent" in gt_stdout:
-                        summary_f.write("      - OBJECTIVE: PASSED\n")
-                        objective_checks_passed += 1
-                    else:
-                        summary_f.write("      - OBJECTIVE: FAILED (Details in logs or stdout)\n")
-
-                    if "SUCCESS: Model is consistent" in gt_stdout and ("SUCCESS: No objective defined" in gt_stdout or "SUCCESS: Objective value is consistent" in gt_stdout):
-                        summary_f.write("      - SELF-CONSISTENCY CHECK: PASSED fully\n")
-                        all_checks_passed += 1
-
-                except Exception as e_gt_run:
-                    summary_f.write(f"      - SELF-CONSISTENCY CHECK: FAILED (Error: {e_gt_run})\n")
-
-            # Final statistics (write to summary_f)
-            summary_f.write("\n" + "=" * 30 + "\n")
-            summary_f.write("Overall Evaluation Statistics:\n")
-            summary_f.write(f"  Total Submitted Models Parsed: {total_submitted_models}\n")
-            summary_f.write(f"  Models That Ran Successfully: {models_ran_successfully}/{total_submitted_models}\n")
-            summary_f.write(f"  Ground-Truth Models Found: {gt_models_found}/{models_ran_successfully}\n")
-            summary_f.write(f"  Consistency Checks Passed: {consistency_checks_passed}/{gt_models_found}\n")
-            summary_f.write(f"  Objective Value Checks Passed: {objective_checks_passed}/{gt_models_found}\n")
-            summary_f.write("=" * 30 + "\n")
-            summary_f.write("Final Evaluation Summary:\n")
-            summary_f.write(f"  Submission coverage perc: {float(total_submitted_models) / len(ground_truth_models) * 100:.2f}%\n")
-            summary_f.write(f"  Execution perc: {models_ran_successfully / len(ground_truth_models) * 100:.2f}%\n")
-            summary_f.write(f"  Error perc: {(total_submitted_models - models_ran_successfully) / len(ground_truth_models) * 100:.2f}%\n")
-            summary_f.write(f"  Consistency perc: {consistency_checks_passed / len(ground_truth_models) * 100:.2f}%\n")
-            summary_f.write(f"  Objective perc: {objective_checks_passed / len(ground_truth_models) * 100:.2f}%\n")
-            summary_f.write(f"  Final Solution Accuracy perc: {all_checks_passed / len(ground_truth_models) * 100:.2f}%\n")
-            summary_f.write("-" * 30 + "\n")
-
-        # 4. Upload the entire local_result_dir_for_upload to HF Dataset
-        # This directory contains summary.txt and could contain other result files.
+        # Upload the entire local_result_dir_for_upload to HF Dataset
         result_path_on_hub = f"{results_base_path_in_dataset}/{submission_name_for_files}"
         print(f"  Uploading results from '{local_result_dir_for_upload}' to '{result_path_on_hub}' on dataset...",
               flush=True)
@@ -428,19 +122,3 @@ def main_eval(
 
     elapsed_time = time.time() - start_time
     print(f"eval.py: Evaluation finished in {elapsed_time:.2f} seconds.", flush=True)
-    # return 0
-
-
-# if __name__ == "__main__":
-#     if len(sys.argv) < 4:
-#         print(
-#             "Usage: python eval.py <user_dataset_repo_id> <submission_path_in_dataset> <results_base_path_in_dataset>")
-#         print("Example: python eval.py your-username/my-storage submissions/run123 results")
-#         sys.exit(1)
-#
-#     arg_user_dataset_repo_id = sys.argv[1]
-#     arg_submission_path_in_dataset = sys.argv[2]
-#     arg_results_base_path_in_dataset = sys.argv[3]
-#
-#     exit_code = main(arg_user_dataset_repo_id, arg_submission_path_in_dataset, arg_results_base_path_in_dataset)
-#     sys.exit(exit_code)

src/hf_utils.py

@@ -73,10 +73,6 @@ def load_leaderboard_data():
                     for line in f:
                         if 'Error perc' in line:
                             entry[LDB_COLS[3]] = float(line.split(":")[1].strip().replace("%", ""))
-                        # if 'Execution perc' in line:
-                        #     entry[LDB_COLS[1]] = float(line.split(":")[1].strip().replace("%", ""))
-                        # if 'Consistency perc' in line:
-                        #     entry[LDB_COLS[2]] = float(line.split(":")[1].strip().replace("%", ""))
                         if 'Final Solution Accuracy' in line:
                             entry[LDB_COLS[2]] = float(line.split(":")[1].strip().replace("%", ""))
                         if 'Submission coverage perc' in line:

src/ui.py

@@ -97,14 +97,14 @@ def create_ui():
             "## Important Notes\n"
             "1. **Submission Name**: The submission name must be different from any existing submission names.\n"
             "2. **File Format**: Ensure that the uploaded files are in the correct format. The submission file must be a `.jsonl` file, and the report must be a `pdf` file.\n"
-            "3. **Evaluation Script**: It is highly recommended to use the evaluation script provided [here](https://huggingface.co/spaces/kostis-init/CP-Bench-competition/blob/main/user_eval.py) to check your results before submission. You can run the script as follows:\n"
+            "3. **Evaluation Script**: It is highly recommended to use the evaluation script provided [here](https://huggingface.co/spaces/kostis-init/CP-Bench-competition/blob/main/src/user_eval.py) to check your results before submission. You can run the script as follows:\n"
             "   ```bash\n"
-            "   python user_eval.py --submission_file path/to/my/submission.jsonl\n"
+            "   python user_eval.py --submission_file path/to/my/submission.jsonl --modelling_framework CPMpy\n"
             "   ```\n"
             "   This will evaluate your submission locally and print the results to the console.\n"
             "4. **Modelling Frameworks**: Currently, the supported modelling frameworks are MiniZinc, CPMpy and OR-Tools. More frameworks can be added (feel free to submit pull requests).\n"
             "\n\n"
-            "### If you have any questions or issues, please feel free to reach out to us.\n"
+            "### If you have any questions or issues, feel free to reach out to us.\n"
             "---\n"
         )
 

user_eval.py → src/user_eval.py

@@ -1,17 +1,85 @@
+import time
 import json
 import os
 import subprocess
 import sys
 import tempfile
-
 import click
 from pathlib import Path
-
+import minizinc
+import datetime
 from datasets import load_dataset
+from tqdm import tqdm
+
+CPMPY_FRAMEWORK = "CPMpy"
+MINIZINC_FRAMEWORK = "MiniZinc"
+ORTOOLS_FRAMEWORK = "OR-Tools"
 
 GT_DATASET_NAME = "kostis-init/CP-Bench"
 GT_PROBLEM_NAME_COLUMN = "id"
 GT_MODEL_CODE_COLUMN = "model"
+SCRIPT_EXECUTION_TIMEOUT = 60  # seconds
+
+
+def exec_code_minizinc(code: str, timeout_sec):
+    """
+    Executes a MiniZinc model string using the minizinc-python library.
+
+    :param code: The MiniZinc model code as a string.
+    :param timeout_sec: The maximum time to wait for the solver in seconds.
+    :return: A tuple of (success, output, timeout_occured)
+    """
+    successfully_executed = False
+    output = ""
+    timeout_occurred = False
+    timeout_duration = datetime.timedelta(seconds=timeout_sec)
+
+    try:
+        # 1. Create a MiniZinc model instance
+        model = minizinc.Model()
+        model.add_string(code)
+
+        # 2. Find a default solver configured with MiniZinc
+        # You can be more specific, e.g., solver = minizinc.Solver.lookup("gecode")
+        # If the default solver isn't found or suitable, this will raise an error.
+        gecode = minizinc.Solver.lookup("gecode")
+        if gecode is None:
+            raise RuntimeError("No suitable solver found. Please install a MiniZinc solver.")
+
+        # 3. Create an Instance to solve
+        instance = minizinc.Instance(gecode, model)
+
+        # 4. Solve the instance with the specified timeout
+        # The solve() method handles the timeout internally.
+        result = instance.solve(timeout=timeout_duration)
+
+        # 5. Process the result
+        if result.status in {minizinc.Status.SATISFIED, minizinc.Status.OPTIMAL_SOLUTION}:
+            successfully_executed = True
+            output = str(result.solution) if result.solution is not None else ""
+            timeout_occurred = False
+        elif result.status == minizinc.Status.UNKNOWN:
+            successfully_executed = False
+            output = f"Timeout Error: Solver stopped after {timeout_sec} seconds (Status: UNKNOWN)."
+            timeout_occurred = True
+        else:
+            # Handle other non-success statuses (UNSAT, ERROR, etc.)
+            successfully_executed = False
+            output = f"Solving failed. Status: {result.status}"
+            timeout_occurred = False
+
+    except minizinc.MiniZincError as e:
+        # Catch MiniZinc specific errors (e.g., syntax errors, solver not found)
+        successfully_executed = False
+        output = f"MiniZinc Error: {e}"
+        timeout_occurred = False
+    except Exception as e:
+        # Catch other unexpected errors
+        successfully_executed = False
+        output = f"Unexpected Error during MiniZinc execution: {e}"
+        timeout_occurred = False
+
+    return successfully_executed, output, timeout_occurred
 
 
 def exec_code(code: str, timeout=10, modelling_language='cpmpy'):
@@ -25,27 +93,28 @@ def exec_code(code: str, timeout=10, modelling_language='cpmpy'):
     """
 
     # create a temp directory to store the temporary file
-    temp_dir_name = "_temp_dir_for_exec_code"
+    temp_dir_name = "temp_dir_for_exec_code"
     temp_dir = os.path.join(os.getcwd(), temp_dir_name)
     os.makedirs(temp_dir, exist_ok=True)
 
     # write the code to a temporary file
-    suffix = '.__hidden_py__' if modelling_language == "cpmpy" or modelling_language == "or-tools" else '.mzn'
-    with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix=suffix, dir=temp_dir, encoding='utf-8') as temp_file:
+    suffix = '.__hidden_py__' if modelling_language == CPMPY_FRAMEWORK or modelling_language == ORTOOLS_FRAMEWORK else '.mzn'
+    with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix=suffix, dir=temp_dir,
+                                     encoding='utf-8') as temp_file:
         temp_instance_path = temp_file.name
         temp_file.write(code)
 
     try:
         # execute the code
-        if modelling_language == "cpmpy" or modelling_language == "or-tools":
+        if modelling_language == CPMPY_FRAMEWORK or modelling_language == ORTOOLS_FRAMEWORK:
             command = [sys.executable, temp_instance_path]
             result = subprocess.run(command, capture_output=True, text=True, timeout=timeout, encoding='utf-8')
 
             successfully_executed = (result.returncode == 0)
             output = result.stdout if successfully_executed else result.stderr
             timeout_occurred = False
-        # elif modelling_language == "minizinc":
-        #     successfully_executed, output, timeout_occurred = exec_code_minizinc(code, timeout)
+        elif modelling_language == MINIZINC_FRAMEWORK:
+            successfully_executed, output, timeout_occurred = exec_code_minizinc(code, timeout)
         else:
             raise ValueError(f"MODELLING_LANGUAGE not supported: {modelling_language}")
 
@@ -153,10 +222,125 @@ else:
 """
     return modified_script
 
+
+def evaluate_submission(submitted_models, summary_file_path, modelling_framw, top_lvl_temp_dir):
+    # Load ground-truth dataset
+    print(f"  Loading ground-truth dataset '{GT_DATASET_NAME}'...", flush=True)
+    try:
+        gt_dataset = load_dataset(GT_DATASET_NAME, split="train", trust_remote_code=True)
+        ground_truth_models = {
+            item[GT_PROBLEM_NAME_COLUMN]: item[GT_MODEL_CODE_COLUMN]
+            for item in gt_dataset if
+            GT_PROBLEM_NAME_COLUMN in item and GT_MODEL_CODE_COLUMN in item and item[GT_MODEL_CODE_COLUMN]
+        }
+        if not ground_truth_models: raise ValueError("No models in GT dataset.")
+        print(f"  Loaded {len(ground_truth_models)} ground-truth models.", flush=True)
+    except Exception as e_gt:
+        print(f"  CRITICAL ERROR - Failed to load ground-truth dataset: {e_gt}", flush=True)
+        with open(summary_file_path, "w") as f:
+            f.write(f"CRITICAL ERROR: Failed to load ground-truth dataset '{GT_DATASET_NAME}'.\nError: {e_gt}\n")
+        return 1
+
+    # Statistics
+    total_submitted_models = 0
+    models_ran_successfully = 0
+    consistency_checks_passed = 0
+    all_checks_passed = 0
+
+    with (open(summary_file_path, "w", encoding="utf-8") as summary_f):
+        summary_f.write(f"Ground-Truth Dataset: {GT_DATASET_NAME}\n")
+        summary_f.write("-" * 30 + "\n")
+
+        # Iterate through downloaded submitted models
+        for submitted_model in tqdm(submitted_models):
+            curr_model = submitted_model[GT_MODEL_CODE_COLUMN]
+
+            total_submitted_models += 1
+            problem_name = submitted_model[GT_PROBLEM_NAME_COLUMN]
+            print(f"\n  Processing model: {problem_name}", flush=True)
+            summary_f.write(f"\n--- Model: {problem_name} ---\n")
+
+            summary_f.write("    1. Running submitted model...\n")
+
+            succ_exec, output, timeout_occurred = exec_code(curr_model, timeout=SCRIPT_EXECUTION_TIMEOUT,
+                                                            modelling_language=modelling_framw)
+
+            if succ_exec:
+                models_ran_successfully += 1
+                summary_f.write("      - SUCCESS: Model executed successfully.\n")
+
+            if timeout_occurred:
+                summary_f.write(f"      - TIMEOUT: Execution time exceeded {SCRIPT_EXECUTION_TIMEOUT} seconds.\n")
+                continue
+            if not succ_exec:
+                summary_f.write(f"      - FAILED: Execution failed with error: {output}\n")
+                continue
+            if output is None or not output.strip():
+                summary_f.write(f"      - FAILED: No output from execution.\n")
+                continue
+            # Attempt to extract JSON from stdout
+            generated_solution = extract_json_from_code_output(output)
+            if generated_solution is None:
+                summary_f.write(f"      - FAILED: Could not extract JSON solution from output: {output}\n")
+                continue
+            summary_f.write(f"      - SUCCESS: Got solution: {generated_solution}\n")
+
+            summary_f.write(f"    2. Checking against ground-truth for '{problem_name}'...\n")
+            if problem_name not in ground_truth_models:
+                summary_f.write(f"      - FAILED: Ground-truth model for '{problem_name}' not found in dataset.\n")
+                continue
+            ground_truth_script_content = ground_truth_models[problem_name]
+            summary_f.write("      - SUCCESS: Found ground-truth model.\n")
+
+            summary_f.write("    3. Performing self-consistency check on ground-truth model...\n")
+            modified_gt_script = get_modified_script(ground_truth_script_content, generated_solution)
+
+            try:
+                with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False, encoding='utf-8',
+                                                 dir=top_lvl_temp_dir) as tmp_file:
+                    tmp_file.write(modified_gt_script)
+                    tmp_file_path_str = tmp_file.name
+
+                gt_check_result = subprocess.run(
+                    [sys.executable, tmp_file_path_str],
+                    capture_output=True, text=True, timeout=SCRIPT_EXECUTION_TIMEOUT, encoding='utf-8',
+                )
+                os.unlink(tmp_file_path_str)
+
+                gt_stdout = gt_check_result.stdout
+                if "SUCCESS: Model is consistent" in gt_stdout:
+                    summary_f.write("      - CONSISTENCY: PASSED\n")
+                    consistency_checks_passed += 1
+                else:
+                    summary_f.write("      - CONSISTENCY: FAILED (Details in logs or stdout)\n")
+
+                if "SUCCESS: Model is consistent" in gt_stdout and (
+                        "SUCCESS: No objective defined" in gt_stdout or "SUCCESS: Objective value is consistent" in gt_stdout):
+                    summary_f.write("      - SELF-CONSISTENCY CHECK: PASSED fully\n")
+                    all_checks_passed += 1
+
+            except Exception as e_gt_run:
+                summary_f.write(f"      - SELF-CONSISTENCY CHECK: FAILED (Error: {e_gt_run})\n")
+
+        # Final statistics (write to summary_f)
+        summary_f.write("\n" + "=" * 30 + "\n")
+        summary_f.write("Overall Evaluation Statistics:\n")
+        summary_f.write(f"  Total Submitted Models Parsed: {total_submitted_models}\n")
+        summary_f.write(f"  Models That Ran Successfully (out of the submitted models): {models_ran_successfully}/{total_submitted_models}\n")
+        summary_f.write(f"  Submission coverage perc: {float(total_submitted_models) / len(ground_truth_models) * 100:.2f}%\n")
+        summary_f.write(f"  Error perc: {(total_submitted_models - models_ran_successfully) / len(ground_truth_models) * 100:.2f}%\n")
+        summary_f.write(f"  Consistency perc: {consistency_checks_passed / len(ground_truth_models) * 100:.2f}%\n")
+        summary_f.write(f"  Final Solution Accuracy perc: {all_checks_passed / len(ground_truth_models) * 100:.2f}%\n")
+        summary_f.write("-" * 30 + "\n")
+
+
 @click.command()
 @click.option('--submission_file', required=True, type=click.Path(exists=True, path_type=Path),
               help='Path to the submission JSONL file')
-def main(submission_file: Path):
+@click.option('--modelling_framework', required=True,
+              type=click.Choice([CPMPY_FRAMEWORK, ORTOOLS_FRAMEWORK, MINIZINC_FRAMEWORK]),
+              help='Modelling framework used in the submission')
+def main(submission_file: Path, modelling_framework: str):
     """Evaluate a submission file for the CP-Bench competition."""
     is_valid, message = validate_submission_file(submission_file)
     if not is_valid:
@@ -177,116 +361,30 @@ def main(submission_file: Path):
                 print(f"  ERROR: Failed to parse JSON object from line: {line}. Error: {e}", flush=True)
     print(f"  Loaded {len(submitted_models)} generated models.", flush=True)
 
+    summary_file_path = Path("summary.txt")
+    top_level_temp_dir = tempfile.mkdtemp(prefix="cp_bench_eval_")
 
-    # eval
-    total_submitted_models = 0
-    models_ran_successfully = 0
-    consistency_checks_passed = 0
-    objective_checks_passed = 0
-    all_checks_passed = 0
-    gt_models_found = 0
-    
-    # Load ground-truth models
-    print(f"  Loading ground-truth dataset '{GT_DATASET_NAME}'...", flush=True)
     try:
-        gt_dataset = load_dataset(GT_DATASET_NAME, split="train", trust_remote_code=True)
-        ground_truth_models = {
-            item[GT_PROBLEM_NAME_COLUMN]: item[GT_MODEL_CODE_COLUMN]
-            for item in gt_dataset if
-            GT_PROBLEM_NAME_COLUMN in item and GT_MODEL_CODE_COLUMN in item and item[GT_MODEL_CODE_COLUMN]
-        }
-        if not ground_truth_models: raise ValueError("No models in GT dataset.")
-        print(f"  Loaded {len(ground_truth_models)} ground-truth models.", flush=True)
-    except Exception as e_gt:
-        print(f"  CRITICAL ERROR - Failed to load ground-truth dataset: {e_gt}", flush=True)
+        start_time = time.time()
+        evaluate_submission(submitted_models, summary_file_path, modelling_framework, top_level_temp_dir)
+        elapsed_time = time.time() - start_time
+    except Exception as e:
+        click.echo(f"Error during evaluation: {e}")
         return
 
-    # Iterate through downloaded submitted models
-    for submitted_model in submitted_models:
-        curr_model = submitted_model[GT_MODEL_CODE_COLUMN]
-
-        total_submitted_models += 1
-        problem_name = submitted_model[GT_PROBLEM_NAME_COLUMN]
-        print(f"\n  Processing model: {problem_name}", flush=True)
-        print(f"\n--- Model: {problem_name} ---\n")
-
-        print("    1. Running submitted model...\n")
-
-        succ_exec, output, timeout_occurred = exec_code(curr_model, timeout=60)
-
-        if timeout_occurred:
-            print(f"      - TIMEOUT: Execution time exceeded 60 seconds.\n")
-            continue
-        if not succ_exec:
-            print(f"      - FAILED: Execution failed with error: {output}\n")
-            continue
-        if output is None or not output.strip():
-            print(f"      - FAILED: No output from execution.\n")
-            continue
-        # Attempt to extract JSON from stdout
-        generated_solution = extract_json_from_code_output(output)
-        if generated_solution is None:
-            print(f"      - FAILED: Could not extract JSON solution from output: {output}\n")
-            continue
-
-        models_ran_successfully += 1
-        print(f"      - SUCCESS: Got solution: {generated_solution}\n")
-
-        print(f"    2. Checking against ground-truth for '{problem_name}'...\n")
-        if problem_name not in ground_truth_models:
-            print(f"      - FAILED: Ground-truth model for '{problem_name}' not found in dataset.\n")
-            continue
-        gt_models_found += 1
-        ground_truth_script_content = ground_truth_models[problem_name]
-        print("      - SUCCESS: Found ground-truth model.\n")
-
-        print("    3. Performing self-consistency check on ground-truth model...\n")
-        modified_gt_script = get_modified_script(ground_truth_script_content, generated_solution)
+    click.echo("Evaluation complete!")
+    click.echo(f"Results written to {summary_file_path}")
+    click.echo(f"Total evaluation time: {elapsed_time:.2f} seconds")
 
+    # Clean up temporary directory
+    if os.path.exists(top_level_temp_dir):
         try:
-            with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False, encoding='utf-8') as tmp_file:
-                tmp_file.write(modified_gt_script)
-                tmp_file_path_str = tmp_file.name
-
-            gt_check_result = subprocess.run(
-                [sys.executable, tmp_file_path_str],
-                capture_output=True, text=True, timeout=60, encoding='utf-8',
-            )
-            os.unlink(tmp_file_path_str)
-
-            gt_stdout = gt_check_result.stdout
-            if "SUCCESS: Model is consistent" in gt_stdout:
-                print("      - CONSISTENCY: PASSED\n")
-                consistency_checks_passed += 1
-            else:
-                print(
-                    "      - CONSISTENCY: FAILED (Details in logs or stdout)\n")
-
-            if "SUCCESS: No objective defined" in gt_stdout or "SUCCESS: Objective value is consistent" in gt_stdout:
-                print("      - OBJECTIVE: PASSED\n")
-                objective_checks_passed += 1
-            else:
-                print("      - OBJECTIVE: FAILED (Details in logs or stdout)\n")
-
-            if "SUCCESS: Model is consistent" in gt_stdout and (
-                    "SUCCESS: No objective defined" in gt_stdout or "SUCCESS: Objective value is consistent" in gt_stdout):
-                print("      - SELF-CONSISTENCY CHECK: PASSED fully\n")
-                all_checks_passed += 1
-
-        except Exception as e_gt_run:
-            print(f"      - SELF-CONSISTENCY CHECK: FAILED (Error: {e_gt_run})\n")
-
-    # Final statistics (write to summary_f)
-    print("\n" + "=" * 30 + "\n")
-    print("Overall Evaluation:\n")
-    print(f"  Total Submitted Models Parsed: {total_submitted_models}\n")
-    print(f"  Execution perc: {models_ran_successfully / len(ground_truth_models) * 100:.2f}%\n")
-    print(f"  Consistency perc: {consistency_checks_passed / len(ground_truth_models) * 100:.2f}%\n")
-    print(f"  Objective perc: {objective_checks_passed / len(ground_truth_models) * 100:.2f}%\n")
-    print(f"  Final Solution Accuracy perc: {all_checks_passed / len(ground_truth_models) * 100:.2f}%\n")
-    print("-" * 30 + "\n")
-
-    click.echo("Evaluation complete!")
+            os.rmdir(top_level_temp_dir)
+        except OSError as e:
+            click.echo(f"Warning: Could not remove temporary directory {top_level_temp_dir}: {e}")
+    else:
+        click.echo(f"Temporary directory {top_level_temp_dir} does not exist, nothing to clean up.")
+    click.echo("Thank you for your submission!")
 
 
 if __name__ == "__main__":

template_submission.jsonl

@@ -81,21 +81,21 @@
 {"id": "cpmpy_examples__who_killed_agatha", "model": "from cpmpy import *\nimport json\n\n# Data\nnames = [\"Agatha herself\", \"the butler\", \"Charles\"]\n\n# Variables\nkiller = int_var(0, 2, name=\"killer\")\n\n# Constraints\n# Agatha hates everybody except the butler\nagatha_hates = [1, 2]  # indices of people Agatha hates\n# The butler hates everyone not richer than Aunt Agatha\nbutler_hates = [0, 2]  # indices of people the butler hates\n# The butler hates everyone whom Agatha hates\n# This is already included in butler_hates\n# Charles hates noone that Agatha hates\ncharles_hates = []  # indices of people Charles hates\n\n# Model\nmodel = Model(\n    # A killer always hates, and is no richer than his victim\n    [killer in agatha_hates, \n     killer != 0],  # Agatha cannot kill herself\n    # Additional constraints based on the problem description\n    [killer in butler_hates if killer == 1 else True],  # butler hates everyone not richer than Agatha\n    [killer not in agatha_hates if killer == 2 else True]  # Charles hates noone that Agatha hates\n)\n\n# Solve\nif model.solve():\n    # Print solution as JSON\n    solution = {\"killer\": names[killer.value()]}\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
 {"id": "cpmpy_examples__wolf_goat_cabbage", "model": "from cpmpy import *\nimport json\n\n# Define the number of stages\nstage = 8\n\n# Define the decision variables\nwolf_pos = boolvar(shape=stage+1, name=\"wolf_pos\")\ngoat_pos = boolvar(shape=stage+1, name=\"goat_pos\")\ncabbage_pos = boolvar(shape=stage+1, name=\"cabbage_pos\")\nboat_pos = boolvar(shape=stage+1, name=\"boat_pos\")\n\n# Model\nmodel = Model(\n    # Initial positions\n    wolf_pos[0] == 0,\n    goat_pos[0] == 0,\n    cabbage_pos[0] == 0,\n    boat_pos[0] == 0,\n\n    # Final positions\n    wolf_pos[stage] == 1,\n    goat_pos[stage] == 1,\n    cabbage_pos[stage] == 1,\n    boat_pos[stage] == 1,\n\n    # Boat movement\n    [boat_pos[t] != boat_pos[t+1] for t in range(stage)],\n\n    # Farmer is with the boat\n    [wolf_pos[t] == boat_pos[t] or goat_pos[t] == boat_pos[t] or cabbage_pos[t] == boat_pos[t] for t in range(1, stage+1)],\n\n    # Wolf and goat are not left together\n    [(wolf_pos[t] != goat_pos[t]) or boat_pos[t] == wolf_pos[t] or boat_pos[t] == goat_pos[t] for t in range(1, stage+1)],\n\n    # Goat and cabbage are not left together\n    [(goat_pos[t] != cabbage_pos[t]) or boat_pos[t] == goat_pos[t] or boat_pos[t] == cabbage_pos[t] for t in range(1, stage+1)],\n\n    # Wolf and cabbage are not left together (this constraint is not necessary, but it helps the solver)\n    [(wolf_pos[t] != cabbage_pos[t]) or boat_pos[t] == wolf_pos[t] or boat_pos[t] == cabbage_pos[t] for t in range(1, stage+1)]\n)\n\n# Solve the model\nif model.solve():\n    # Create the solution dictionary\n    solution = {\n        \"boat_pos\": [int(boat_pos[t].value()) for t in range(stage+1)],\n        \"0\": 0,\n        \"cabbage_pos\": [int(cabbage_pos[t].value()) for t in range(stage+1)],\n        \"goat_pos\": [int(goat_pos[t].value()) for t in range(stage+1)],\n        \"wolf_pos\": [int(wolf_pos[t].value()) for t in range(stage+1)],\n        \"1\": 1\n    }\n\n    # Print the solution as a JSON object\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
 {"id": "cpmpy_examples__zebra", "model": "from cpmpy import *\nimport json\n\n# Define the variables\ncolors = [\"yellow\", \"green\", \"red\", \"white\", \"blue\"]\nnations = [\"italy\", \"spain\", \"japan\", \"england\", \"norway\"]\njobs = [\"painter\", \"sculptor\", \"diplomat\", \"pianist\", \"doctor\"]\npets = [\"cat\", \"zebra\", \"bear\", \"snails\", \"horse\"]\ndrinks = [\"milk\", \"water\", \"tea\", \"coffee\", \"juice\"]\n\n# Define the model\nmodel = Model()\n\n# Define the decision variables\ncolor_vars = intvar(1, 5, shape=5, name=\"color\")\nnation_vars = intvar(1, 5, shape=5, name=\"nation\")\njob_vars = intvar(1, 5, shape=5, name=\"job\")\npet_vars = intvar(1, 5, shape=5, name=\"pet\")\ndrink_vars = intvar(1, 5, shape=5, name=\"drink\")\n\n# Constraints\nmodel += [AllDifferent(color_vars)]\nmodel += [AllDifferent(nation_vars)]\nmodel += [AllDifferent(job_vars)]\nmodel += [AllDifferent(pet_vars)]\nmodel += [AllDifferent(drink_vars)]\n\n# The painter owns the horse\nmodel += [job_vars[0] == 1, pet_vars[0] == 5]\n\n# The diplomat drinks coffee\nmodel += [job_vars[2] == 3, drink_vars[2] == 4]\n\n# The one who drinks milk lives in the white house\nmodel += [drink_vars[3] == 1, color_vars[3] == 4]\n\n# The Spaniard is a painter\nmodel += [nation_vars[1] == 2, job_vars[1] == 1]\n\n# The Englishman lives in the red house\nmodel += [nation_vars[3] == 4, color_vars[3] == 3]\n\n# The snails are owned by the sculptor\nmodel += [pet_vars[2] == 4, job_vars[2] == 2]\n\n# The green house is on the left of the red one\nmodel += [color_vars[1] == 2, color_vars[2] == 3]\n\n# The Norwegian lives on the right of the blue house\nmodel += [color_vars[4] == 5, nation_vars[4] == 5]\n\n# The doctor drinks milk\nmodel += [job_vars[4] == 5, drink_vars[4] == 1]\n\n# The diplomat is Japanese\nmodel += [nation_vars[2] == 3, job_vars[2] == 3]\n\n# The Norwegian owns the zebra\nmodel += [pet_vars[4] == 2, nation_vars[4] == 5]\n\n# The green house is next to the white one\nmodel += [color_vars[2] == 2, color_vars[3] == 4]\n\n# The horse is owned by the neighbor of the diplomat\nmodel += [pet_vars[1] == 5, job_vars[2] == 3]\n\n# The Italian either lives in the red, white or green house\nmodel += [Or([nation_vars[1] == 1, nation_vars[2] == 1, nation_vars[3] == 1])]\n\n# Solve the model\nif model.solve():\n    # Print the solution as a JSON object\n    solution = {\n        \"colors\": [colors[i-1] for i in color_vars.value()],\n        \"jobs\": [jobs[i-1] for i in job_vars.value()],\n        \"nations\": [nations[i-1] for i in nation_vars.value()],\n        \"pets\": [pets[i-1] for i in pet_vars.value()],\n        \"drinks\": [drinks[i-1] for i in drink_vars.value()]\n    }\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
-{"id": "aplai_course__bank_card", "model": "from cpmpy import *\nimport json\n\n# Define the model\na, b, c, d = int_var(0, 9), int_var(0, 9), int_var(0, 9), int_var(0, 9)\n\nmodel = Model(\n    [a != b, a != c, a != d, b != c, b != d, c != d],  # all digits are different\n    [10*a + b <= 9*10 + 9],  # ab is at most 99\n    [10*c + d <= 9*10 + 9],  # cd is at most 99\n    [10*d + a <= 9*10 + 9],  # da is at most 99\n    [10*b + c <= 9*10 + 9],  # bc is at most 99\n    [3*(10*a + b) == (10*c + d)],  # cd is 3 times ab\n    [2*(10*b + c) == (10*d + a)],  # da is 2 times bc\n)\n\n# Solve the model\nif model.solve():\n    solution = {\"a\": a.value(), \"b\": b.value(), \"c\": c.value(), \"d\": d.value()}\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
-{"id": "aplai_course__climbing_stairs", "model": "from cpmpy import *\nimport json\n\n# Define the model\nn = 20  # Total steps\nm1 = 3  # Minimum steps at a time\nm2 = 5  # Maximum steps at a time\n\n# Define the variable\nsteps = intvar(0, m2, shape=n)\n\n# Define the model\nmodel = Model(\n    # Objective: sum of steps equals n\n    [sum(steps) == n],\n    # Each step is between m1 and m2 (inclusive) or 0\n    [steps[i] in [0, m1, m2] for i in range(n)],\n    # Cumulative sum of steps does not exceed n at any point\n    [cumsum(steps[:i+1]) <= n for i in range(n)],\n    # If a step is not 0, it must be m1 or m2\n    [steps[i] >= m1 for i in range(n)]\n)\n\n# Solve the model\nif model.solve():\n    # Print the solution as a JSON object\n    print(json.dumps({\"steps\": [steps[i].value() for i in range(n)]}))\nelse:\n    print(\"No solution found\")"}
-{"id": "aplai_course__color_simple", "model": "from cpmpy import *\nimport json\n\n# Define the adjacency list\ngraph = [\n    [3, 1],\n    [3, 6],\n    [3, 4],\n    [6, 4],\n    [6, 1],\n    [1, 5],\n    [1, 4],\n    [4, 5],\n    [4, 2]\n]\n\n# Define the number of countries\nnum_countries = len(graph)\n\n# Define the number of colors\nnum_colors = num_countries\n\n# Define the color variables\ncolors = intvar(1, num_colors, shape=num_countries, name=\"colors\")\n\n# Define the model\nmodel = Model()\n\n# Add constraints: two neighbouring countries cannot have the same color\nfor i in range(num_countries):\n    for j in graph[i]:\n        model += colors[i] != colors[j-1]\n\n# Solve the model\nif model.solve():\n    # Print the colors assigned to each country as a JSON object\n    output = {\"colors\": [int(c) for c in colors.value()]}\n    print(json.dumps(output))\nelse:\n    print(\"No solution found\")"}
-{"id": "aplai_course__exodus", "model": "from cpmpy import *\nimport json\n\n# Define the variables\nages = [3, 5, 7, 8, 10]\nchildren = [\"Bernice\", \"Carl\", \"Debby\", \"Sammy\", \"Ted\"]\ncountries = [\"Ethiopia\", \"Kazakhstan\", \"Lithuania\", \"Morocco\", \"Yemen\"]\nstories = [\"burning bush\", \"captivity\", \"Moses\u2019s youth\", \"Passover\", \"Ten Commandments\"]\n\n# Define the model\nmodel = Model()\n\n# Define the decision variables\nchild = intvar(1, 5, shape=5, name=\"child\")\ncountry = intvar(1, 5, shape=5, name=\"country\")\nstory = intvar(1, 5, shape=5, name=\"story\")\nage = intvar(1, 5, shape=5, name=\"age\")\n\n# Constraints\nmodel += [AllDifferent(child)]\nmodel += [AllDifferent(country)]\nmodel += [AllDifferent(story)]\nmodel += [AllDifferent(age)]\n\n# Debby\u2019s family is from Lithuania\nmodel += [country[children.index(\"Debby\")] == countries.index(\"Lithuania\") + 1]\n\n# The child who told the story of the Passover is two years older than Bernice\nmodel += [age[stories.index(\"Passover\")] - age[children.index(\"Bernice\")] == 2]\n\n# The child whose family is from Yemen is younger than the child from the Ethiopian family\nmodel += [age[countries.index(\"Yemen\")] < age[countries.index(\"Ethiopia\")]]\n\n# The child from the Moroccan family is three years older than Ted\nmodel += [age[countries.index(\"Morocco\")] - age[children.index(\"Ted\")] == 3]\n\n# Sammy is three years older than the child who told the story of Moses\u2019s youth\nmodel += [age[children.index(\"Sammy\")] - age[stories.index(\"Moses\u2019s youth\")] == 3]\n\n# Solve the model\nif model.solve():\n    # Get the solution\n    child_sol = [child[i].value() for i in range(5)]\n    country_sol = [country[i].value() for i in range(5)]\n    story_sol = [story[i].value() for i in range(5)]\n    age_sol = [age[i].value() for i in range(5)]\n\n    # Map the solution to the original lists\n    countries_sol = [countries[i-1] for i in country_sol]\n    children_sol = [children[i-1] for i in child_sol]\n    stories_sol = [stories[i-1] for i in story_sol]\n    ages_sol = [ages[i-1] for i in age_sol]\n\n    # Print the solution as a JSON object\n    print(json.dumps({\n        \"countries\": [countries.index(c) + 1 for c in countries_sol],\n        \"children\": [children.index(c) + 1 for c in children_sol],\n        \"stories\": [stories.index(s) + 1 for s in stories_sol],\n        \"ages\": [ages.index(a) + 1 for a in ages_sol]\n    }))\nelse:\n    print(\"No solution found\")"}
-{"id": "aplai_course__farmer_and_cows", "model": "from cpmpy import *\nimport json\n\n# Data\nnum_cows = 25\nnum_sons = 5\ncows_per_son = [7, 6, 5, 4, 3]\nmilk_per_cow = list(range(1, num_cows + 1))\n\n# Model\nmodel = Model()\n\n# Variables\ncow_assignments = intvar(0, num_sons - 1, shape=num_cows, name=\"cow_assignments\")\n\n# Constraints\nfor i, num in enumerate(cows_per_son):\n    model += sum([cow_assignments[j] == i for j in range(num_cows)]) == num\n\nmilk_per_son = [[milk_per_cow[j] for j in range(num_cows) if cow_assignments[j] == i] for i in range(num_sons)]\nfor i in range(1, num_sons):\n    model += sum(milk_per_cow[j] for j in range(num_cows) if cow_assignments[j] == 0) == sum(milk_per_cow[j] for j in range(num_cows) if cow_assignments[j] == i)\n\n# Solve\nif model.solve():\n    solution = {\"cow_assignments\": [int(x.value()) for x in cow_assignments]}\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
-{"id": "aplai_course__five_floors", "model": "from cpmpy import *\nimport json\n\n# Define the variables\nB = int_var(1, 5, name=\"B\")\nC = int_var(1, 5, name=\"C\")\nF = int_var(1, 5, name=\"F\")\nM = int_var(1, 5, name=\"M\")\nS = int_var(1, 5, name=\"S\")\n\n# Define the model\nmodel = Model(\n    [B != 5,  # Baker does not live on the fifth floor\n     C != 1,  # Cooper does not live on the first floor\n     F != 1, F != 5,  # Fletcher does not live on either the fifth or the first floor\n     M > C,  # Miller lives on a higher floor than does Cooper\n     abs(S - F) > 1,  # Smith does not live on a floor adjacent to Fletcher's\n     abs(F - C) > 1,  # Fletcher does not live on a floor adjacent to Cooper's\n     AllDifferent([B, C, F, M, S])  # They all live on different floors\n     ]\n)\n\n# Solve the model\nif model.solve():\n    # Print the solution as a JSON object\n    solution = {\"B\": B.value(), \"C\": C.value(), \"F\": F.value(), \"M\": M.value(), \"S\": S.value()}\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
-{"id": "aplai_course__grocery", "model": "from cpmpy import *\nimport json\n\n# Define the model\nx = intvar(1, 100, shape=4, name=\"prices\")\n\n# Define the constraints\nmodel = Model(\n    [x[0] * x[1] * x[2] * x[3] == 711],\n    [sum(x) == 711]\n)\n\n# Solve the model\nif model.solve():\n    # Get the solution\n    solution = {f\"prices[{i}]\": x[i].value() for i in range(4)}\n    solution[\"prices\"] = [x[i].value() for i in range(4)]\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
-{"id": "aplai_course__guards_and_apples", "model": "from cpmpy import *\nimport json\n\n# Define the model\nx = intvar(1, 1000, shape=6, name=\"apples\")\n\n# Define the model constraints\nmodel = Model(\n    [x[i] == (x[i-1] + 1) // 2 + (x[i-1] + 1) % 2 for i in range(1, 6)],\n    [x[5] == 1]\n)\n\n# Solve the model\nif model.solve():\n    # Print the solution as a JSON object\n    print(json.dumps({\"apples\": [int(val) for val in x.value]}))\nelse:\n    print(\"No solution found\")"}
-{"id": "aplai_course__hardy_1729_square", "model": "from cpmpy import *\nimport json\n\n# Model\na, b, c, d = intvar(1, 100, shape=4, name=\"vars\")\n\n# Constraints\nmodel = Model(\n    AllDifferent([a, b, c, d]),\n    a**2 + b**2 == c**2 + d**2\n)\n\n# Solve\nif model.solve():\n    solution = {\n        \"a\": a.value(),\n        \"b\": b.value(),\n        \"c\": c.value(),\n        \"d\": d.value()\n    }\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
-{"id": "aplai_course__kidney_exchange", "model": "from cpmpy import *\nimport json\n\n# Data\nnum_people = 8\ncompatible = [\n    [2, 3],\n    [1, 6],\n    [1, 4, 7],\n    [2],\n    [2],\n    [5],\n    [8],\n    [3]\n]\n\n# Model\nmodel = Model()\n\n# Variable: transplants[i][j] is 1 if person i donates to person j, and 0 otherwise\ntransplants = [[model.new_int(var=0, name=f\"transplants_{i}_{j}\") for j in range(num_people)] for i in range(num_people)]\n\n# Constraints\nfor i in range(num_people):\n    for j in range(num_people):\n        model += [transplants[i][j] == 1].only_if(compatible[i].__contains__(j + 1))\n\nfor i in range(num_people):\n    model += sum(transplants[i]) <= 1  # person i donates to at most one person\n    model += sum([transplants[j][i] for j in range(num_people)]) <= 1  # person i receives at most one kidney\n\nfor i in range(num_people):\n    model += sum(transplants[i]) == sum([transplants[j][i] for j in range(num_people)])  # person i donates if and only if they receive\n\n# Objective\nmodel.maximize(sum([sum(transplants[i]) for i in range(num_people)]))\n\n# Solve\nif model.solve():\n    # Extract solution\n    transplants_solution = [[transplants[i][j].value() for j in range(num_people)] for i in range(num_people)]\n\n    # Print solution as JSON\n    print(json.dumps({\"transplants\": transplants_solution}))\nelse:\n    print(\"No solution found\")"}
-{"id": "aplai_course__magic_square", "model": "from cpmpy import *\nimport json\n\n# Define the size of the magic square\nn = 4\n\n# Define the sum of integers in each row, column and diagonal\ntarget_sum = n * (n**2 + 1) // 2\n\n# Define the variables\nx = intvar(1, n**2, shape=(n, n), name=\"x\")\n\n# Define the model\nmodel = Model()\n\n# Each cell contains a different integer\nmodel += AllDifferent(x.flatten())\n\n# The sum of integers in each row is equal to the target sum\nfor i in range(n):\n    model += sum(x[i, :]) == target_sum\n\n# The sum of integers in each column is equal to the target sum\nfor j in range(n):\n    model += sum(x[:, j]) == target_sum\n\n# The sum of integers in the main diagonal is equal to the target sum\nmodel += sum([x[i, i] for i in range(n)]) == target_sum\n\n# The sum of integers in the anti-diagonal is equal to the target sum\nmodel += sum([x[i, n-i-1] for i in range(n)]) == target_sum\n\n# Solve the model\nif model.solve():\n    # Print the solution as a JSON object\n    solution = x.value()\n    print(json.dumps({\"square\": [list(row) for row in solution]}))\nelse:\n    print(\"No solution found\")"}
-{"id": "aplai_course__maximal_independent_sets", "model": "from cpmpy import *\nimport json\n\n# Data\nn = 8\nadjacency_list = [\n    [2, 3, 7],\n    [1, 4, 8],\n    [1, 4, 5],\n    [2, 3, 6],\n    [3, 6, 7],\n    [4, 5, 8],\n    [1, 5, 8],\n    [2, 6, 7]\n]\n\n# Model\nmodel = Model()\n\n# Variables\nx = boolvar(shape=n, name=\"x\")\n\n# Constraints\nfor i in range(n):\n    for j in adjacency_list[i]:\n        model += ~x[i] | ~x[j-1]  # subtract 1 because adjacency list is 1-indexed\n\n# Objective: maximize the number of nodes in the independent set\nmodel.maximize(sum(x))\n\n# Solve\nif model.solve():\n    # Get the solution\n    solution = {f\"node_{i+1}\": bool(x[i].value()) for i in range(n)}\n    print(json.dumps({\"nodes\": solution}))\nelse:\n    print(\"No solution found\")"}
-{"id": "aplai_course__money_change", "model": "from cpmpy import *\nimport json\n\n# Define the available coins and their counts\ncoin_values = [1, 2, 5, 10, 25, 50]\ncoin_counts_available = [20, 10, 15, 8, 4, 2]\n\n# Define the target change\nchange = 199\n\n# Define the model\nmodel = Model()\n\n# Define the decision variables\ncoin_counts = intvar(0, max(coin_counts_available), shape=len(coin_values), name=\"coin_counts\")\n\n# Define the constraints\nmodel += (sum([coin_values[i] * coin_counts[i] for i in range(len(coin_values))]) == change)\nfor i in range(len(coin_values)):\n    model += (coin_counts[i] <= coin_counts_available[i])\n\n# Define the objective\nmodel.minimize(sum(coin_counts))\n\n# Solve the model\nif model.solve():\n    # Print the solution as a JSON object\n    solution = {\"coin_counts\": [int(x) for x in coin_counts.value()]}\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
-{"id": "aplai_course__movie_scheduling", "model": "from cpmpy import *\nimport json\n\n# Input data\nmovies = [\n    [\"Tarjan of the Jungle\", 4, 13],\n    [\"The Four Volume Problem\", 17, 27],\n    [\"The President's Algorist\", 1, 10],\n    [\"Steiner's Tree\", 12, 18],\n    [\"Process Terminated\", 23, 30],\n    [\"Halting State\", 9, 16],\n    [\"Programming Challenges\", 19, 25],\n    [\"Discrete Mathematics\", 2, 7],\n    [\"Calculated Bets\", 26, 31]\n]\n\n# Sort movies by end date\nmovies.sort(key=lambda x: x[2])\n\n# Model\nmodel = Model()\n\n# Decision variables\nselected_movies = [model.bool_var() for _ in range(len(movies))]\n\n# Constraints\nfor i in range(len(movies)):\n    for j in range(i+1, len(movies)):\n        model.add(selected_movies[i] + selected_movies[j] <= (movies[j][1] > movies[i][2]))\n\n# Objective\nmodel.maximize(sum(selected_movies))\n\n# Solve\nif model.solve():\n    num_selected_movies = sum([int(var.value()) for var in selected_movies])\n    solution = {\n        \"selected_movies\": [int(var.value()) for var in selected_movies],\n        \"num_selected_movies\": num_selected_movies\n    }\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
-{"id": "aplai_course__people_in_a_room", "model": "from cpmpy import *\nimport json\n\n# Model\nnum_people = 13\nnum_males = 4\nnum_females = num_people - num_males\n\n# Decision variable: sequence of people entering the room (0 = male, 1 = female)\nsequence = intvar(0, 1, shape=num_people, name=\"sequence\")\n\n# Constraints\nmodel = Model(\n    # Exactly num_males males and num_females females\n    sum(sequence) == num_females,\n    # Ratio of females to males at any time is no greater than 7/3\n    [sum(sequence[:i+1]) / (i + 1 - sum(sequence[:i+1])) <= 7/3 for i in range(num_people)]\n)\n\n# Solve\nif model.solve():\n    # Print solution as JSON\n    solution = {\"sequence\": [int(x) for x in sequence.value()]}\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
-{"id": "aplai_course__subsets_100", "model": "from cpmpy import *\nimport json\n\n# Define the set of integers\nA = [81, 21, 79, 4, 29, 70, 28, 20, 14, 7]\n\n# Define the model\nmodel = Model()\n\n# Define the decision variables\nin_S = boolvar(shape=len(A), name=\"in_S\")\nin_T = boolvar(shape=len(A), name=\"in_T\")\n\n# Define the constraints\nmodel += [sum([A[i] * in_S[i] for i in range(len(A))]) == sum([A[i] * in_T[i] for i in range(len(A))])]\nmodel += [(in_S[i] + in_T[i]) <= 1 for i in range(len(A))]\nmodel += [sum(in_S) > 0]\nmodel += [sum(in_T) > 0]\n\n# Solve the model\nif model.solve():\n    # Print the solution as a JSON object\n    solution = {\n        \"in_S\": [int(in_S[i].value()) for i in range(len(A))],\n        \"in_T\": [int(in_T[i].value()) for i in range(len(A))]\n    }\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
-{"id": "aplai_course__subset_sum", "model": "from cpmpy import *\nimport json\n\n# Define the possible number of coins in each bag\ncoin_values = [16, 17, 23, 24, 39, 40]\n\n# Define the number of coins lost\ntotal_coins_lost = 100\n\n# Define the decision variables\nbags = intvar(0, 100, shape=len(coin_values), name=\"bags\")\n\n# Define the model\nmodel = Model(\n    sum([coin_values[i] * bags[i] for i in range(len(coin_values))]) == total_coins_lost\n)\n\n# Solve the model\nif model.solve():\n    # Print the solution as a JSON object\n    solution = {f\"bags_{i}\": bags[i].value() for i in range(len(coin_values))}\n    print(json.dumps({\"bags\": solution}))\nelse:\n    print(\"No solution found\")"}
-{"id": "aplai_course__thick_as_thieves", "model": "from cpmpy import *\nimport json\n\n# Define the variables\nartie = boolvar(name=\"artie\")\nbill = boolvar(name=\"bill\")\ncrackitt = boolvar(name=\"crackitt\")\ndodgy = boolvar(name=\"dodgy\")\nedgy = boolvar(name=\"edgy\")\nfingers = boolvar(name=\"fingers\")\n\n# At least 4 of them are innocent\nmodel = Model(\n    4 <= sum([~artie, ~bill, ~crackitt, ~dodgy, ~edgy, ~fingers])\n)\n\n# ARTIE: \"It wasn't me.\"\nmodel += [artie == ~artie]\n\n# BILL: \"Crackitt was in it up to his neck.\"\nmodel += [bill == crackitt]\n\n# CRACKITT: \"No I wasn't.\"\nmodel += [crackitt == ~crackitt]\n\n# DODGY: \"If Crackitt did it, Bill did it with him.\"\nmodel += [crackitt <= bill]\n\n# EDGY: \"Nobody did it alone.\"\nmodel += [(~edgy) | (sum([artie, bill, crackitt, dodgy, fingers]) >= 2)]\n\n# FINGERS: \"That\u2019s right: it was Artie and Dodgy together.\"\nmodel += [fingers == (artie & dodgy)]\n\n# Solve the model\nif model.solve():\n    solution = {\n        \"artie\": artie.value(),\n        \"bill\": bill.value(),\n        \"crackitt\": crackitt.value(),\n        \"dodgy\": dodgy.value(),\n        \"edgy\": edgy.value(),\n        \"fingers\": fingers.value()\n    }\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
+{"id": "aplai_course__1_bank_card", "model": "from cpmpy import *\nimport json\n\n# Define the model\na, b, c, d = int_var(0, 9), int_var(0, 9), int_var(0, 9), int_var(0, 9)\n\nmodel = Model(\n    [a != b, a != c, a != d, b != c, b != d, c != d],  # all digits are different\n    [10*a + b <= 9*10 + 9],  # ab is at most 99\n    [10*c + d <= 9*10 + 9],  # cd is at most 99\n    [10*d + a <= 9*10 + 9],  # da is at most 99\n    [10*b + c <= 9*10 + 9],  # bc is at most 99\n    [3*(10*a + b) == (10*c + d)],  # cd is 3 times ab\n    [2*(10*b + c) == (10*d + a)],  # da is 2 times bc\n)\n\n# Solve the model\nif model.solve():\n    solution = {\"a\": a.value(), \"b\": b.value(), \"c\": c.value(), \"d\": d.value()}\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
+{"id": "aplai_course__5_climbing_stairs", "model": "from cpmpy import *\nimport json\n\n# Define the model\nn = 20  # Total steps\nm1 = 3  # Minimum steps at a time\nm2 = 5  # Maximum steps at a time\n\n# Define the variable\nsteps = intvar(0, m2, shape=n)\n\n# Define the model\nmodel = Model(\n    # Objective: sum of steps equals n\n    [sum(steps) == n],\n    # Each step is between m1 and m2 (inclusive) or 0\n    [steps[i] in [0, m1, m2] for i in range(n)],\n    # Cumulative sum of steps does not exceed n at any point\n    [cumsum(steps[:i+1]) <= n for i in range(n)],\n    # If a step is not 0, it must be m1 or m2\n    [steps[i] >= m1 for i in range(n)]\n)\n\n# Solve the model\nif model.solve():\n    # Print the solution as a JSON object\n    print(json.dumps({\"steps\": [steps[i].value() for i in range(n)]}))\nelse:\n    print(\"No solution found\")"}
+{"id": "aplai_course__2_color_simple", "model": "from cpmpy import *\nimport json\n\n# Define the adjacency list\ngraph = [\n    [3, 1],\n    [3, 6],\n    [3, 4],\n    [6, 4],\n    [6, 1],\n    [1, 5],\n    [1, 4],\n    [4, 5],\n    [4, 2]\n]\n\n# Define the number of countries\nnum_countries = len(graph)\n\n# Define the number of colors\nnum_colors = num_countries\n\n# Define the color variables\ncolors = intvar(1, num_colors, shape=num_countries, name=\"colors\")\n\n# Define the model\nmodel = Model()\n\n# Add constraints: two neighbouring countries cannot have the same color\nfor i in range(num_countries):\n    for j in graph[i]:\n        model += colors[i] != colors[j-1]\n\n# Solve the model\nif model.solve():\n    # Print the colors assigned to each country as a JSON object\n    output = {\"colors\": [int(c) for c in colors.value()]}\n    print(json.dumps(output))\nelse:\n    print(\"No solution found\")"}
+{"id": "aplai_course__3_exodus", "model": "from cpmpy import *\nimport json\n\n# Define the variables\nages = [3, 5, 7, 8, 10]\nchildren = [\"Bernice\", \"Carl\", \"Debby\", \"Sammy\", \"Ted\"]\ncountries = [\"Ethiopia\", \"Kazakhstan\", \"Lithuania\", \"Morocco\", \"Yemen\"]\nstories = [\"burning bush\", \"captivity\", \"Moses\u2019s youth\", \"Passover\", \"Ten Commandments\"]\n\n# Define the model\nmodel = Model()\n\n# Define the decision variables\nchild = intvar(1, 5, shape=5, name=\"child\")\ncountry = intvar(1, 5, shape=5, name=\"country\")\nstory = intvar(1, 5, shape=5, name=\"story\")\nage = intvar(1, 5, shape=5, name=\"age\")\n\n# Constraints\nmodel += [AllDifferent(child)]\nmodel += [AllDifferent(country)]\nmodel += [AllDifferent(story)]\nmodel += [AllDifferent(age)]\n\n# Debby\u2019s family is from Lithuania\nmodel += [country[children.index(\"Debby\")] == countries.index(\"Lithuania\") + 1]\n\n# The child who told the story of the Passover is two years older than Bernice\nmodel += [age[stories.index(\"Passover\")] - age[children.index(\"Bernice\")] == 2]\n\n# The child whose family is from Yemen is younger than the child from the Ethiopian family\nmodel += [age[countries.index(\"Yemen\")] < age[countries.index(\"Ethiopia\")]]\n\n# The child from the Moroccan family is three years older than Ted\nmodel += [age[countries.index(\"Morocco\")] - age[children.index(\"Ted\")] == 3]\n\n# Sammy is three years older than the child who told the story of Moses\u2019s youth\nmodel += [age[children.index(\"Sammy\")] - age[stories.index(\"Moses\u2019s youth\")] == 3]\n\n# Solve the model\nif model.solve():\n    # Get the solution\n    child_sol = [child[i].value() for i in range(5)]\n    country_sol = [country[i].value() for i in range(5)]\n    story_sol = [story[i].value() for i in range(5)]\n    age_sol = [age[i].value() for i in range(5)]\n\n    # Map the solution to the original lists\n    countries_sol = [countries[i-1] for i in country_sol]\n    children_sol = [children[i-1] for i in child_sol]\n    stories_sol = [stories[i-1] for i in story_sol]\n    ages_sol = [ages[i-1] for i in age_sol]\n\n    # Print the solution as a JSON object\n    print(json.dumps({\n        \"countries\": [countries.index(c) + 1 for c in countries_sol],\n        \"children\": [children.index(c) + 1 for c in children_sol],\n        \"stories\": [stories.index(s) + 1 for s in stories_sol],\n        \"ages\": [ages.index(a) + 1 for a in ages_sol]\n    }))\nelse:\n    print(\"No solution found\")"}
+{"id": "aplai_course__3_farmer_and_cows", "model": "from cpmpy import *\nimport json\n\n# Data\nnum_cows = 25\nnum_sons = 5\ncows_per_son = [7, 6, 5, 4, 3]\nmilk_per_cow = list(range(1, num_cows + 1))\n\n# Model\nmodel = Model()\n\n# Variables\ncow_assignments = intvar(0, num_sons - 1, shape=num_cows, name=\"cow_assignments\")\n\n# Constraints\nfor i, num in enumerate(cows_per_son):\n    model += sum([cow_assignments[j] == i for j in range(num_cows)]) == num\n\nmilk_per_son = [[milk_per_cow[j] for j in range(num_cows) if cow_assignments[j] == i] for i in range(num_sons)]\nfor i in range(1, num_sons):\n    model += sum(milk_per_cow[j] for j in range(num_cows) if cow_assignments[j] == 0) == sum(milk_per_cow[j] for j in range(num_cows) if cow_assignments[j] == i)\n\n# Solve\nif model.solve():\n    solution = {\"cow_assignments\": [int(x.value()) for x in cow_assignments]}\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
+{"id": "aplai_course__1_five_floors", "model": "from cpmpy import *\nimport json\n\n# Define the variables\nB = int_var(1, 5, name=\"B\")\nC = int_var(1, 5, name=\"C\")\nF = int_var(1, 5, name=\"F\")\nM = int_var(1, 5, name=\"M\")\nS = int_var(1, 5, name=\"S\")\n\n# Define the model\nmodel = Model(\n    [B != 5,  # Baker does not live on the fifth floor\n     C != 1,  # Cooper does not live on the first floor\n     F != 1, F != 5,  # Fletcher does not live on either the fifth or the first floor\n     M > C,  # Miller lives on a higher floor than does Cooper\n     abs(S - F) > 1,  # Smith does not live on a floor adjacent to Fletcher's\n     abs(F - C) > 1,  # Fletcher does not live on a floor adjacent to Cooper's\n     AllDifferent([B, C, F, M, S])  # They all live on different floors\n     ]\n)\n\n# Solve the model\nif model.solve():\n    # Print the solution as a JSON object\n    solution = {\"B\": B.value(), \"C\": C.value(), \"F\": F.value(), \"M\": M.value(), \"S\": S.value()}\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
+{"id": "aplai_course__5_grocery", "model": "from cpmpy import *\nimport json\n\n# Define the model\nx = intvar(1, 100, shape=4, name=\"prices\")\n\n# Define the constraints\nmodel = Model(\n    [x[0] * x[1] * x[2] * x[3] == 711],\n    [sum(x) == 711]\n)\n\n# Solve the model\nif model.solve():\n    # Get the solution\n    solution = {f\"prices[{i}]\": x[i].value() for i in range(4)}\n    solution[\"prices\"] = [x[i].value() for i in range(4)]\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
+{"id": "aplai_course__1_guards_and_apples", "model": "from cpmpy import *\nimport json\n\n# Define the model\nx = intvar(1, 1000, shape=6, name=\"apples\")\n\n# Define the model constraints\nmodel = Model(\n    [x[i] == (x[i-1] + 1) // 2 + (x[i-1] + 1) % 2 for i in range(1, 6)],\n    [x[5] == 1]\n)\n\n# Solve the model\nif model.solve():\n    # Print the solution as a JSON object\n    print(json.dumps({\"apples\": [int(val) for val in x.value]}))\nelse:\n    print(\"No solution found\")"}
+{"id": "aplai_course__5_hardy_1729_square", "model": "from cpmpy import *\nimport json\n\n# Model\na, b, c, d = intvar(1, 100, shape=4, name=\"vars\")\n\n# Constraints\nmodel = Model(\n    AllDifferent([a, b, c, d]),\n    a**2 + b**2 == c**2 + d**2\n)\n\n# Solve\nif model.solve():\n    solution = {\n        \"a\": a.value(),\n        \"b\": b.value(),\n        \"c\": c.value(),\n        \"d\": d.value()\n    }\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
+{"id": "aplai_course__3_kidney_exchange", "model": "from cpmpy import *\nimport json\n\n# Data\nnum_people = 8\ncompatible = [\n    [2, 3],\n    [1, 6],\n    [1, 4, 7],\n    [2],\n    [2],\n    [5],\n    [8],\n    [3]\n]\n\n# Model\nmodel = Model()\n\n# Variable: transplants[i][j] is 1 if person i donates to person j, and 0 otherwise\ntransplants = [[model.new_int(var=0, name=f\"transplants_{i}_{j}\") for j in range(num_people)] for i in range(num_people)]\n\n# Constraints\nfor i in range(num_people):\n    for j in range(num_people):\n        model += [transplants[i][j] == 1].only_if(compatible[i].__contains__(j + 1))\n\nfor i in range(num_people):\n    model += sum(transplants[i]) <= 1  # person i donates to at most one person\n    model += sum([transplants[j][i] for j in range(num_people)]) <= 1  # person i receives at most one kidney\n\nfor i in range(num_people):\n    model += sum(transplants[i]) == sum([transplants[j][i] for j in range(num_people)])  # person i donates if and only if they receive\n\n# Objective\nmodel.maximize(sum([sum(transplants[i]) for i in range(num_people)]))\n\n# Solve\nif model.solve():\n    # Extract solution\n    transplants_solution = [[transplants[i][j].value() for j in range(num_people)] for i in range(num_people)]\n\n    # Print solution as JSON\n    print(json.dumps({\"transplants\": transplants_solution}))\nelse:\n    print(\"No solution found\")"}
+{"id": "aplai_course__1_magic_square", "model": "from cpmpy import *\nimport json\n\n# Define the size of the magic square\nn = 4\n\n# Define the sum of integers in each row, column and diagonal\ntarget_sum = n * (n**2 + 1) // 2\n\n# Define the variables\nx = intvar(1, n**2, shape=(n, n), name=\"x\")\n\n# Define the model\nmodel = Model()\n\n# Each cell contains a different integer\nmodel += AllDifferent(x.flatten())\n\n# The sum of integers in each row is equal to the target sum\nfor i in range(n):\n    model += sum(x[i, :]) == target_sum\n\n# The sum of integers in each column is equal to the target sum\nfor j in range(n):\n    model += sum(x[:, j]) == target_sum\n\n# The sum of integers in the main diagonal is equal to the target sum\nmodel += sum([x[i, i] for i in range(n)]) == target_sum\n\n# The sum of integers in the anti-diagonal is equal to the target sum\nmodel += sum([x[i, n-i-1] for i in range(n)]) == target_sum\n\n# Solve the model\nif model.solve():\n    # Print the solution as a JSON object\n    solution = x.value()\n    print(json.dumps({\"square\": [list(row) for row in solution]}))\nelse:\n    print(\"No solution found\")"}
+{"id": "aplai_course__2_maximal_independent_sets", "model": "from cpmpy import *\nimport json\n\n# Data\nn = 8\nadjacency_list = [\n    [2, 3, 7],\n    [1, 4, 8],\n    [1, 4, 5],\n    [2, 3, 6],\n    [3, 6, 7],\n    [4, 5, 8],\n    [1, 5, 8],\n    [2, 6, 7]\n]\n\n# Model\nmodel = Model()\n\n# Variables\nx = boolvar(shape=n, name=\"x\")\n\n# Constraints\nfor i in range(n):\n    for j in adjacency_list[i]:\n        model += ~x[i] | ~x[j-1]  # subtract 1 because adjacency list is 1-indexed\n\n# Objective: maximize the number of nodes in the independent set\nmodel.maximize(sum(x))\n\n# Solve\nif model.solve():\n    # Get the solution\n    solution = {f\"node_{i+1}\": bool(x[i].value()) for i in range(n)}\n    print(json.dumps({\"nodes\": solution}))\nelse:\n    print(\"No solution found\")"}
+{"id": "aplai_course__1_money_change", "model": "from cpmpy import *\nimport json\n\n# Define the available coins and their counts\ncoin_values = [1, 2, 5, 10, 25, 50]\ncoin_counts_available = [20, 10, 15, 8, 4, 2]\n\n# Define the target change\nchange = 199\n\n# Define the model\nmodel = Model()\n\n# Define the decision variables\ncoin_counts = intvar(0, max(coin_counts_available), shape=len(coin_values), name=\"coin_counts\")\n\n# Define the constraints\nmodel += (sum([coin_values[i] * coin_counts[i] for i in range(len(coin_values))]) == change)\nfor i in range(len(coin_values)):\n    model += (coin_counts[i] <= coin_counts_available[i])\n\n# Define the objective\nmodel.minimize(sum(coin_counts))\n\n# Solve the model\nif model.solve():\n    # Print the solution as a JSON object\n    solution = {\"coin_counts\": [int(x) for x in coin_counts.value()]}\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
+{"id": "aplai_course__2_movie_scheduling", "model": "from cpmpy import *\nimport json\n\n# Input data\nmovies = [\n    [\"Tarjan of the Jungle\", 4, 13],\n    [\"The Four Volume Problem\", 17, 27],\n    [\"The President's Algorist\", 1, 10],\n    [\"Steiner's Tree\", 12, 18],\n    [\"Process Terminated\", 23, 30],\n    [\"Halting State\", 9, 16],\n    [\"Programming Challenges\", 19, 25],\n    [\"Discrete Mathematics\", 2, 7],\n    [\"Calculated Bets\", 26, 31]\n]\n\n# Sort movies by end date\nmovies.sort(key=lambda x: x[2])\n\n# Model\nmodel = Model()\n\n# Decision variables\nselected_movies = [model.bool_var() for _ in range(len(movies))]\n\n# Constraints\nfor i in range(len(movies)):\n    for j in range(i+1, len(movies)):\n        model.add(selected_movies[i] + selected_movies[j] <= (movies[j][1] > movies[i][2]))\n\n# Objective\nmodel.maximize(sum(selected_movies))\n\n# Solve\nif model.solve():\n    num_selected_movies = sum([int(var.value()) for var in selected_movies])\n    solution = {\n        \"selected_movies\": [int(var.value()) for var in selected_movies],\n        \"num_selected_movies\": num_selected_movies\n    }\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
+{"id": "aplai_course__3_people_in_a_room", "model": "from cpmpy import *\nimport json\n\n# Model\nnum_people = 13\nnum_males = 4\nnum_females = num_people - num_males\n\n# Decision variable: sequence of people entering the room (0 = male, 1 = female)\nsequence = intvar(0, 1, shape=num_people, name=\"sequence\")\n\n# Constraints\nmodel = Model(\n    # Exactly num_males males and num_females females\n    sum(sequence) == num_females,\n    # Ratio of females to males at any time is no greater than 7/3\n    [sum(sequence[:i+1]) / (i + 1 - sum(sequence[:i+1])) <= 7/3 for i in range(num_people)]\n)\n\n# Solve\nif model.solve():\n    # Print solution as JSON\n    solution = {\"sequence\": [int(x) for x in sequence.value()]}\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
+{"id": "aplai_course__2_subsets_100", "model": "from cpmpy import *\nimport json\n\n# Define the set of integers\nA = [81, 21, 79, 4, 29, 70, 28, 20, 14, 7]\n\n# Define the model\nmodel = Model()\n\n# Define the decision variables\nin_S = boolvar(shape=len(A), name=\"in_S\")\nin_T = boolvar(shape=len(A), name=\"in_T\")\n\n# Define the constraints\nmodel += [sum([A[i] * in_S[i] for i in range(len(A))]) == sum([A[i] * in_T[i] for i in range(len(A))])]\nmodel += [(in_S[i] + in_T[i]) <= 1 for i in range(len(A))]\nmodel += [sum(in_S) > 0]\nmodel += [sum(in_T) > 0]\n\n# Solve the model\nif model.solve():\n    # Print the solution as a JSON object\n    solution = {\n        \"in_S\": [int(in_S[i].value()) for i in range(len(A))],\n        \"in_T\": [int(in_T[i].value()) for i in range(len(A))]\n    }\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}
+{"id": "aplai_course__2_subset_sum", "model": "from cpmpy import *\nimport json\n\n# Define the possible number of coins in each bag\ncoin_values = [16, 17, 23, 24, 39, 40]\n\n# Define the number of coins lost\ntotal_coins_lost = 100\n\n# Define the decision variables\nbags = intvar(0, 100, shape=len(coin_values), name=\"bags\")\n\n# Define the model\nmodel = Model(\n    sum([coin_values[i] * bags[i] for i in range(len(coin_values))]) == total_coins_lost\n)\n\n# Solve the model\nif model.solve():\n    # Print the solution as a JSON object\n    solution = {f\"bags_{i}\": bags[i].value() for i in range(len(coin_values))}\n    print(json.dumps({\"bags\": solution}))\nelse:\n    print(\"No solution found\")"}
+{"id": "aplai_course__1_thick_as_thieves", "model": "from cpmpy import *\nimport json\n\n# Define the variables\nartie = boolvar(name=\"artie\")\nbill = boolvar(name=\"bill\")\ncrackitt = boolvar(name=\"crackitt\")\ndodgy = boolvar(name=\"dodgy\")\nedgy = boolvar(name=\"edgy\")\nfingers = boolvar(name=\"fingers\")\n\n# At least 4 of them are innocent\nmodel = Model(\n    4 <= sum([~artie, ~bill, ~crackitt, ~dodgy, ~edgy, ~fingers])\n)\n\n# ARTIE: \"It wasn't me.\"\nmodel += [artie == ~artie]\n\n# BILL: \"Crackitt was in it up to his neck.\"\nmodel += [bill == crackitt]\n\n# CRACKITT: \"No I wasn't.\"\nmodel += [crackitt == ~crackitt]\n\n# DODGY: \"If Crackitt did it, Bill did it with him.\"\nmodel += [crackitt <= bill]\n\n# EDGY: \"Nobody did it alone.\"\nmodel += [(~edgy) | (sum([artie, bill, crackitt, dodgy, fingers]) >= 2)]\n\n# FINGERS: \"That\u2019s right: it was Artie and Dodgy together.\"\nmodel += [fingers == (artie & dodgy)]\n\n# Solve the model\nif model.solve():\n    solution = {\n        \"artie\": artie.value(),\n        \"bill\": bill.value(),\n        \"crackitt\": crackitt.value(),\n        \"dodgy\": dodgy.value(),\n        \"edgy\": edgy.value(),\n        \"fingers\": fingers.value()\n    }\n    print(json.dumps(solution))\nelse:\n    print(\"No solution found\")"}