pointblank 0.13.4__py3-none-any.whl → 0.15.0__py3-none-any.whl

pointblank/validate.py

@@ -6,12 +6,14 @@ import copy
 import datetime
 import inspect
 import json
+import pickle
 import re
 import tempfile
 import threading
 from dataclasses import dataclass
 from enum import Enum
 from importlib.metadata import version
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, Literal
 from zipfile import ZipFile
 
@@ -32,6 +34,7 @@ from pointblank._constants import (
     CROSS_MARK_SPAN,
     IBIS_BACKENDS,
     LOG_LEVELS_MAP,
+    MODEL_PROVIDERS,
     REPORTING_LANGUAGES,
     ROW_BASED_VALIDATION_TYPES,
     RTL_LANGUAGES,
@@ -115,6 +118,8 @@ if TYPE_CHECKING:
 __all__ = [
     "Validate",
     "load_dataset",
+    "read_file",
+    "write_file",
     "config",
     "connect_to_table",
     "preview",
@@ -581,6 +586,759 @@ def load_dataset(
     return dataset
 
 
+def read_file(filepath: str | Path) -> Validate:
+    """
+    Read a Validate object from disk that was previously saved with `write_file()`.
+
+    This function loads a validation object that was previously serialized to disk using the
+    `write_file()` function. The validation object will be restored with all its validation results,
+    metadata, and optionally the source data (if it was saved with `keep_tbl=True`).
+
+    :::{.callout-warning}
+    The `read_file()` function is currently experimental. Please report any issues you encounter in
+    the [Pointblank issue tracker](https://github.com/posit-dev/pointblank/issues).
+    :::
+
+    Parameters
+    ----------
+    filepath
+        The path to the saved validation file. Can be a string or Path object.
+
+    Returns
+    -------
+    Validate
+        The restored validation object with all its original state, validation results, and
+        metadata.
+
+    Examples
+    --------
+    Load a validation object that was previously saved:
+
+    ```python
+    import pointblank as pb
+
+    # Load a validation object from disk
+    validation = pb.read_file("my_validation.pkl")
+
+    # View the validation results
+    validation
+    ```
+
+    You can also load using just the filename (without extension):
+
+    ```python
+    # This will automatically look for "my_validation.pkl"
+    validation = pb.read_file("my_validation")
+    ```
+
+    The loaded validation object retains all its functionality:
+
+    ```python
+    # Get validation summary
+    summary = validation.get_json_report()
+
+    # Get sundered data (if original table was saved)
+    if validation.data is not None:
+        failing_rows = validation.get_sundered_data(type="fail")
+    ```
+
+    See Also
+    --------
+    Use the [`write_file()`](`pointblank.Validate.write_file`) method to save a validation object
+    to disk for later retrieval with this function.
+    """
+    # Handle file path and extension
+    file_path = Path(filepath)
+    if not file_path.suffix:
+        file_path = file_path.with_suffix(".pkl")
+
+    # Check if file exists
+    if not file_path.exists():
+        raise FileNotFoundError(f"Validation file not found: {file_path}")
+
+    # Load and deserialize the validation object
+    try:
+        with open(file_path, "rb") as f:
+            loaded_data = pickle.load(f)
+
+        # Expect validation package format with function sources
+        if not isinstance(loaded_data, dict) or "validation" not in loaded_data:
+            raise RuntimeError(f"Invalid validation file format: {file_path}")
+
+        validation = loaded_data["validation"]
+        function_sources = loaded_data["function_sources"]
+
+        # Restore functions from source code
+        if function_sources:  # pragma: no cover
+            restored_functions = {}  # pragma: no cover
+            for func_name, source_code in function_sources.items():  # pragma: no cover
+                try:  # pragma: no cover
+                    # Create a namespace with common imports that functions might need
+                    execution_namespace = {}  # pragma: no cover
+
+                    # Add common imports to the execution namespace
+                    try:  # pragma: no cover
+                        import polars as pl  # pragma: no cover
+
+                        execution_namespace["pl"] = pl  # pragma: no cover
+
+                    except ImportError:  # pragma: no cover
+                        pass  # pragma: no cover
+
+                    try:  # pragma: no cover
+                        import pandas as pd  # pragma: no cover
+
+                        execution_namespace["pd"] = pd  # pragma: no cover
+
+                    except ImportError:  # pragma: no cover
+                        pass  # pragma: no cover
+
+                    try:  # pragma: no cover
+                        import narwhals as nw  # pragma: no cover
+
+                        execution_namespace["nw"] = nw  # pragma: no cover
+
+                    except ImportError:  # pragma: no cover
+                        pass  # pragma: no cover
+
+                    # Execute the function source code with the enhanced namespace
+                    exec(source_code, execution_namespace, execution_namespace)  # pragma: no cover
+
+                    # The function should now be in the execution namespace
+                    if func_name in execution_namespace:  # pragma: no cover
+                        restored_functions[func_name] = execution_namespace[
+                            func_name
+                        ]  # pragma: no cover
+                    else:  # pragma: no cover
+                        print(
+                            f"Warning: Function '{func_name}' not found after executing source code"
+                        )
+
+                except Exception as e:  # pragma: no cover
+                    print(f"Warning: Could not restore function '{func_name}': {e}")
+
+            # Restore functions to validation steps
+            for validation_info in validation.validation_info:  # pragma: no cover
+                if (  # pragma: no cover
+                    hasattr(validation_info, "_pb_function_name")
+                    and validation_info._pb_function_name in restored_functions
+                ):
+                    func_name = validation_info._pb_function_name  # pragma: no cover
+                    validation_info.pre = restored_functions[func_name]  # pragma: no cover
+                    # Clean up the temporary attribute
+                    delattr(validation_info, "_pb_function_name")  # pragma: no cover
+
+        # Verify that we loaded a Validate object
+        if not isinstance(validation, Validate):  # pragma: no cover
+            raise RuntimeError(f"File does not contain a valid Validate object: {file_path}")
+
+        return validation
+
+    except Exception as e:
+        raise RuntimeError(f"Failed to read validation object from {file_path}: {e}")
+
+
+def _check_for_unpicklable_objects(validation: Validate) -> tuple[dict[str, str], list[int]]:
+    """
+    Check for functions and capture source code for preservation across sessions.
+
+    This function examines all preprocessing functions and attempts to capture their source code for
+    later restoration. Lambda functions are rejected. Functions that might be picklable in the
+    current session but fail across sessions (e.g., interactively defined functions) have their
+    source preserved.
+
+    Returns
+    -------
+    tuple[dict[str, str], list[int]]
+        A tuple containing:
+        - A dictionary mapping function names to their source code
+        - A list of step indices that have unpicklable lambda functions (which should cause errors)
+    """
+    import inspect
+    import pickle
+
+    unpicklable_lambda_steps = []
+    function_sources = {}
+
+    for i, validation_info in enumerate(validation.validation_info):
+        if hasattr(validation_info, "pre") and validation_info.pre is not None:
+            func = validation_info.pre
+            func_name = getattr(func, "__name__", "<unknown>")
+
+            # Always reject lambda functions
+            if func_name == "<lambda>":
+                unpicklable_lambda_steps.append((i, validation_info))
+                continue
+
+            # For all non-lambda functions, try to capture source code
+            # This helps with functions that might be picklable now but fail across sessions
+            source_code = None
+
+            try:
+                # Try to get the source code
+                source_code = inspect.getsource(func)
+
+                # Test if the function can be pickled and loaded in a clean environment
+                # by checking if it's defined in a "real" module vs interactively
+                func_module = getattr(func, "__module__", None)
+
+                if func_module == "__main__" or not func_module:
+                    # Functions defined in __main__ or without a module are risky
+                    # These might pickle now but fail when loaded elsewhere
+                    function_sources[func_name] = source_code  # pragma: no cover
+                    validation_info._pb_function_name = func_name  # pragma: no cover
+
+            except (OSError, TypeError):  # pragma: no cover
+                # If we can't get source, check if it's at least picklable
+                try:  # pragma: no cover
+                    pickle.dumps(func, protocol=pickle.HIGHEST_PROTOCOL)  # pragma: no cover
+                    # It's picklable but no source: this might cause issues across sessions
+                    print(  # pragma: no cover
+                        f"Warning: Function '{func_name}' is picklable but source code could not be captured. "
+                        f"It may not be available when loading in a different session."
+                    )
+                except (pickle.PicklingError, AttributeError, TypeError):  # pragma: no cover
+                    # Not picklable and no source: treat as problematic
+                    print(  # pragma: no cover
+                        f"Warning: Function '{func_name}' is not picklable and source could not be captured. "
+                        f"It will not be available after saving/loading."
+                    )
+                    unpicklable_lambda_steps.append((i, validation_info))  # pragma: no cover
+
+    # Only raise error for lambda functions now
+    if unpicklable_lambda_steps:
+        step_descriptions = []
+        for i, step in unpicklable_lambda_steps:
+            desc = f"Step {i + 1}"
+            if hasattr(step, "assertion_type"):
+                desc += f" ({step.assertion_type})"
+            if hasattr(step, "column") and step.column:
+                desc += f" on column '{step.column}'"
+            step_descriptions.append(desc)
+
+        raise ValueError(
+            f"Cannot serialize validation object: found {len(unpicklable_lambda_steps)} validation step(s) "
+            f"with unpicklable preprocessing functions (likely lambda functions defined in interactive "
+            f"environments):\n\n"
+            + "\n".join(f"  - {desc}" for desc in step_descriptions)
+            + "\n\nTo resolve this, define your preprocessing functions at the module level:\n\n"
+            "  # Instead of:\n"
+            "  .col_vals_gt(columns='a', value=10, pre=lambda df: df.with_columns(...))\n\n"
+            "  # Use:\n"
+            "  def preprocess_data(df):\n"
+            "      return df.with_columns(...)\n\n"
+            "  .col_vals_gt(columns='a', value=10, pre=preprocess_data)\n\n"
+            "Module-level functions can be pickled and will preserve the complete validation logic."
+        )
+
+    return function_sources, []
+
+
+def _provide_serialization_guidance(validation: Validate) -> None:
+    """
+    Provide helpful guidance to users about creating serializable validations.
+
+    This function analyzes the validation object and provides tailored advice
+    about preprocessing functions, best practices, and potential issues.
+    """
+    import pickle
+
+    # Find all preprocessing functions in the validation
+    preprocessing_functions = []
+
+    for i, validation_info in enumerate(validation.validation_info):
+        if hasattr(validation_info, "pre") and validation_info.pre is not None:
+            preprocessing_functions.append((i, validation_info))
+
+    if not preprocessing_functions:  # pragma: no cover
+        # No preprocessing functions: validation should serialize cleanly
+        print("  Serialization Analysis:")  # pragma: no cover
+        print("   ✓ No preprocessing functions detected")  # pragma: no cover
+        print(
+            "   ✓ This validation should serialize and load reliably across sessions"
+        )  # pragma: no cover
+        return  # pragma: no cover
+
+    print("  Serialization Analysis:")  # pragma: no cover
+    print(  # pragma: no cover
+        f"   Found {len(preprocessing_functions)} validation step(s) with preprocessing functions"
+    )
+
+    # Analyze each function
+    functions_analysis = {  # pragma: no cover
+        "module_functions": [],
+        "interactive_functions": [],
+        "lambda_functions": [],
+        "unpicklable_functions": [],
+    }
+
+    for i, validation_info in preprocessing_functions:  # pragma: no cover
+        func = validation_info.pre  # pragma: no cover
+        func_name = getattr(func, "__name__", "<unknown>")  # pragma: no cover
+        func_module = getattr(func, "__module__", "<unknown>")  # pragma: no cover
+
+        # Categorize the function
+        if func_name == "<lambda>":  # pragma: no cover
+            functions_analysis["lambda_functions"].append(
+                (i, func_name, func_module)
+            )  # pragma: no cover
+        else:  # pragma: no cover
+            # Test if it can be pickled
+            try:  # pragma: no cover
+                pickle.dumps(func, protocol=pickle.HIGHEST_PROTOCOL)  # pragma: no cover
+                can_pickle = True  # pragma: no cover
+            except (pickle.PicklingError, AttributeError, TypeError):  # pragma: no cover
+                can_pickle = False  # pragma: no cover
+                functions_analysis["unpicklable_functions"].append(
+                    (i, func_name, func_module)
+                )  # pragma: no cover
+                continue  # pragma: no cover
+
+            # Check if it's likely to work across sessions
+            if (
+                func_module == "__main__" or not func_module or func_module == "<unknown>"
+            ):  # pragma: no cover
+                # Function defined interactively - risky for cross-session use
+                functions_analysis["interactive_functions"].append(
+                    (i, func_name, func_module)
+                )  # pragma: no cover
+            else:  # pragma: no cover
+                # Function from a proper module - should work reliably
+                functions_analysis["module_functions"].append(
+                    (i, func_name, func_module)
+                )  # pragma: no cover
+
+    # Provide specific guidance based on analysis
+    if functions_analysis["module_functions"]:  # pragma: no cover
+        print("   ✓ Module-level functions detected:")
+        for i, func_name, func_module in functions_analysis["module_functions"]:
+            print(f"     • Step {i + 1}: {func_name} (from {func_module})")
+        print("     These should work reliably across sessions")
+
+    if functions_analysis["interactive_functions"]:  # pragma: no cover
+        print("      Interactive functions detected:")
+        for i, func_name, func_module in functions_analysis["interactive_functions"]:
+            print(f"     • Step {i + 1}: {func_name} (defined in {func_module})")
+        print("     These may not load properly in different sessions")
+        print()
+        print("     Recommendation: Move these functions to a separate .py module:")
+        print("      1. Create a file like 'preprocessing_functions.py'")
+        print("      2. Define your functions there with proper imports")
+        print("      3. Import them: from preprocessing_functions import your_function")
+        print("      4. This ensures reliable serialization across sessions")
+
+    if functions_analysis["lambda_functions"]:  # pragma: no cover
+        print("     Lambda functions detected:")
+        for i, func_name, func_module in functions_analysis["lambda_functions"]:
+            print(f"     • Step {i + 1}: {func_name}")
+        print("     Lambda functions cannot be serialized!")
+        print()
+        print("     Required fix: Replace lambda functions with named functions:")
+        print("      # Instead of: pre=lambda df: df.with_columns(...)")
+        print("      # Use: ")
+        print("      def my_preprocessing_function(df):")
+        print("          return df.with_columns(...)")
+        print("      # Then: pre=my_preprocessing_function")
+
+    if functions_analysis["unpicklable_functions"]:  # pragma: no cover
+        print("     Unpicklable functions detected:")
+        for i, func_name, func_module in functions_analysis["unpicklable_functions"]:
+            print(f"     • Step {i + 1}: {func_name} (from {func_module})")
+        print("     These functions cannot be serialized")
+
+    # Provide overall assessment
+    total_problematic = (
+        len(functions_analysis["interactive_functions"])
+        + len(functions_analysis["lambda_functions"])
+        + len(functions_analysis["unpicklable_functions"])
+    )
+
+    if total_problematic == 0:  # pragma: no cover
+        print("     All preprocessing functions should serialize reliably!")
+    else:  # pragma: no cover
+        print(
+            f"      {total_problematic} function(s) may cause issues when loading in different sessions"
+        )
+        print()
+        print("     Best Practice Guide:")
+        print("      • Define all preprocessing functions in separate .py modules")
+        print("      • Import functions before creating and loading validations")
+        print("      • Avoid lambda functions and interactive definitions")
+        print("      • Test your validation by loading it in a fresh Python session")
+
+        # Offer to create a template
+        print()
+        print("     Example module structure:")
+        print("      # preprocessing_functions.py")
+        print("      import polars as pl  # or pandas, numpy, etc.")
+        print("      ")
+        print("      def multiply_by_factor(df, factor=10):")
+        print("          return df.with_columns(pl.col('value') * factor)")
+        print("      ")
+        print("      # your_main_script.py")
+        print("      import pointblank as pb")
+        print("      from preprocessing_functions import multiply_by_factor")
+        print("      ")
+        print(
+            "      validation = pb.Validate(data).col_vals_gt('value', 100, pre=multiply_by_factor)"
+        )
+
+
+def write_file(
+    validation: Validate,
+    filename: str,
+    path: str | None = None,
+    keep_tbl: bool = False,
+    keep_extracts: bool = False,
+    quiet: bool = False,
+) -> None:
+    """
+    Write a Validate object to disk as a serialized file.
+
+    Writing a validation object to disk with `write_file()` can be useful for keeping data
+    validation results close at hand for later retrieval (with `read_file()`). By default, any data
+    table that the validation object holds will be removed before writing to disk (not applicable if
+    no data table is present). This behavior can be changed by setting `keep_tbl=True`, but this
+    only works when the table is not of a database type (e.g., DuckDB, PostgreSQL, etc.), as
+    database connections cannot be serialized.
+
+    Extract data from failing validation steps can also be preserved by setting
+    `keep_extracts=True`, which is useful for later analysis of data quality issues.
+
+    The serialized file uses Python's pickle format for storage of the validation object state,
+    including all validation results, metadata, and optionally the source data.
+
+    **Important note.** If your validation uses custom preprocessing functions (via the `pre=`
+    parameter), these functions must be defined at the module level (not interactively or as lambda
+    functions) to ensure they can be properly restored when loading the validation in a different
+    Python session. Read the *Creating Serializable Validations* section below for more information.
+
+    :::{.callout-warning}
+    The `write_file()` function is currently experimental. Please report any issues you encounter in
+    the [Pointblank issue tracker](https://github.com/posit-dev/pointblank/issues).
+    :::
+
+    Parameters
+    ----------
+    validation
+        The `Validate` object to write to disk.
+    filename
+        The filename to create on disk for the validation object. Should not include the file
+        extension as `.pkl` will be added automatically.
+    path
+        An optional directory path where the file should be saved. If not provided, the file will be
+        saved in the current working directory. The directory will be created if it doesn't exist.
+    keep_tbl
+        An option to keep the data table that is associated with the validation object. The default
+        is `False` where the data table is removed before writing to disk. For database tables
+        (e.g., Ibis tables with database backends), the table is always removed even if
+        `keep_tbl=True`, as database connections cannot be serialized.
+    keep_extracts
+        An option to keep any collected extract data for failing rows from validation steps. By
+        default, this is `False` (i.e., extract data is removed to save space).
+    quiet
+        Should the function not inform when the file is written? By default, this is `False`, so a
+        message will be printed when the file is successfully written.
+
+    Returns
+    -------
+    None
+        This function doesn't return anything but saves the validation object to disk.
+
+    Creating Serializable Validations
+    ---------------------------------
+    To ensure your validations work reliably across different Python sessions, the recommended
+    approach is to use module-Level functions. So, create a separate Python file for your
+    preprocessing functions:
+
+    ```python
+    # preprocessing_functions.py
+    import polars as pl
+
+    def multiply_by_100(df):
+        return df.with_columns(pl.col("value") * 100)
+
+    def add_computed_column(df):
+        return df.with_columns(computed=pl.col("value") * 2 + 10)
+    ```
+
+    Then import and use them in your validation:
+
+    ```python
+    # your_main_script.py
+    import pointblank as pb
+    from preprocessing_functions import multiply_by_100, add_computed_column
+
+    validation = (
+        pb.Validate(data=my_data)
+        .col_vals_gt(columns="value", value=500, pre=multiply_by_100)
+        .col_vals_between(columns="computed", left=50, right=1000, pre=add_computed_column)
+        .interrogate()
+    )
+
+    # Save validation and it will work reliably across sessions
+    pb.write_file(validation, "my_validation", keep_tbl=True)
+    ```
+
+    ### Problematic Patterns to Avoid
+
+    Don't use lambda functions as they will cause immediate errors.
+
+    ```python
+    validation = pb.Validate(data).col_vals_gt(
+        columns="value", value=100,
+        pre=lambda df: df.with_columns(pl.col("value") * 2)
+    )
+    ```
+
+    Don't use interactive function definitions (as they may fail when loading).
+
+    ```python
+    def my_function(df):  # Defined in notebook/REPL
+        return df.with_columns(pl.col("value") * 2)
+
+    validation = pb.Validate(data).col_vals_gt(
+        columns="value", value=100, pre=my_function
+    )
+    ```
+
+    ### Automatic Analysis and Guidance
+
+    When you call `write_file()`, it automatically analyzes your validation and provides:
+
+    - confirmation when all functions will work reliably
+    - warnings for functions that may cause cross-session issues
+    - clear errors for unsupported patterns (lambda functions)
+    - specific recommendations and code examples
+    - loading instructions tailored to your validation
+
+    ### Loading Your Validation
+
+    To load a saved validation in a new Python session:
+
+    ```python
+    # In a new Python session
+    import pointblank as pb
+
+    # Import the same preprocessing functions used when creating the validation
+    from preprocessing_functions import multiply_by_100, add_computed_column
+
+    # Upon loading the validation, functions will be automatically restored
+    validation = pb.read_file("my_validation.pkl")
+    ```
+
+    ** Testing Your Validation:**
+
+    To verify your validation works across sessions:
+
+    1. save your validation in one Python session
+    2. start a fresh Python session (restart kernel/interpreter)
+    3. import required preprocessing functions
+    4. load the validation using `read_file()`
+    5. test that preprocessing functions work as expected
+
+    ### Performance and Storage
+
+    - use `keep_tbl=False` (default) to reduce file size when you don't need the original data
+    - use `keep_extracts=False` (default) to save space by excluding extract data
+    - set `quiet=True` to suppress guidance messages in automated scripts
+    - files are saved using pickle's highest protocol for optimal performance
+
+    Examples
+    --------
+    Let's create a simple validation and save it to disk:
+
+    ```{python}
+    import pointblank as pb
+
+    # Create a validation
+    validation = (
+        pb.Validate(data=pb.load_dataset("small_table"), label="My validation")
+        .col_vals_gt(columns="d", value=100)
+        .col_vals_regex(columns="b", pattern=r"[0-9]-[a-z]{3}-[0-9]{3}")
+        .interrogate()
+    )
+
+    # Save to disk (without the original table data)
+    pb.write_file(validation, "my_validation")
+    ```
+
+    To keep the original table data for later analysis:
+
+    ```{python}
+    # Save with the original table data included
+    pb.write_file(validation, "my_validation_with_data", keep_tbl=True)
+    ```
+
+    You can also specify a custom directory and keep extract data:
+
+    ```python
+    pb.write_file(
+        validation,
+        filename="detailed_validation",
+        path="/path/to/validations",
+        keep_tbl=True,
+        keep_extracts=True
+    )
+    ```
+
+    ### Working with Preprocessing Functions
+
+    For validations that use preprocessing functions to be portable across sessions, define your
+    functions in a separate `.py` file:
+
+    ```python
+    # In `preprocessing_functions.py`
+
+    import polars as pl
+
+    def multiply_by_100(df):
+        return df.with_columns(pl.col("value") * 100)
+
+    def add_computed_column(df):
+        return df.with_columns(computed=pl.col("value") * 2 + 10)
+    ```
+
+    Then import and use them in your validation:
+
+    ```python
+    # In your main script
+
+    import pointblank as pb
+    from preprocessing_functions import multiply_by_100, add_computed_column
+
+    validation = (
+        pb.Validate(data=my_data)
+        .col_vals_gt(columns="value", value=500, pre=multiply_by_100)
+        .col_vals_between(columns="computed", left=50, right=1000, pre=add_computed_column)
+        .interrogate()
+    )
+
+    # This validation can now be saved and loaded reliably
+    pb.write_file(validation, "my_validation", keep_tbl=True)
+    ```
+
+    When you load this validation in a new session, simply import the preprocessing functions
+    again and they will be automatically restored.
+
+    See Also
+    --------
+    Use the [`read_file()`](`pointblank.read_file`) function to load a validation object that was
+    previously saved with `write_file()`.
+    """
+    # Construct the full file path
+    if not filename.endswith(".pkl"):
+        filename = f"{filename}.pkl"
+
+    if path is not None:
+        file_path = Path(path) / filename
+    else:
+        file_path = Path(filename)
+
+    # Create directory if it doesn't exist
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Create a copy of the validation object to avoid modifying the original
+    validation_copy = copy.deepcopy(validation)
+
+    # Handle data table preservation
+    if not keep_tbl:
+        validation_copy.data = None
+    else:
+        # Check if the data is a database table that cannot be serialized
+        if validation_copy.data is not None:
+            tbl_type = _get_tbl_type(validation_copy.data)
+
+            # Database tables cannot be serialized, so remove them regardless of keep_tbl
+            if tbl_type in [
+                "duckdb",
+                "mysql",
+                "postgresql",
+                "sqlite",
+                "mssql",
+                "snowflake",
+                "databricks",
+                "bigquery",
+            ]:
+                validation_copy.data = None
+                if not quiet:  # pragma: no cover
+                    print(
+                        f"Note: Database table removed from saved validation "
+                        f"(table type: {tbl_type})"
+                    )
+
+    # Handle extract data preservation
+    if not keep_extracts:
+        # Remove extract data from validation_info to save space
+        for validation_info in validation_copy.validation_info:
+            if hasattr(validation_info, "extract"):
+                validation_info.extract = None
+
+    # Provide user guidance about serialization if not quiet
+    if not quiet:
+        _provide_serialization_guidance(validation_copy)
+
+    # Check for unpicklable objects and capture function sources
+    function_sources, lambda_steps = _check_for_unpicklable_objects(validation_copy)
+
+    # Create a validation package that includes both the object and function sources
+    validation_package = {"validation": validation_copy, "function_sources": function_sources}
+
+    # Serialize to disk using pickle
+    try:
+        with open(file_path, "wb") as f:
+            pickle.dump(validation_package, f, protocol=pickle.HIGHEST_PROTOCOL)
+
+        if not quiet:  # pragma: no cover
+            print(f"✅ Validation object written to: {file_path}")
+
+            if function_sources:  # pragma: no cover
+                print(
+                    f"   🔧 Enhanced preservation: Captured source code for {len(function_sources)} function(s)"
+                )
+                for func_name in function_sources.keys():
+                    print(f"      • {func_name}")
+                print("   📥 These functions will be automatically restored when loading")
+
+            # Provide loading instructions
+            preprocessing_funcs = [
+                info
+                for info in validation_copy.validation_info
+                if hasattr(info, "pre") and info.pre is not None
+            ]
+            if preprocessing_funcs:
+                print()
+                print("   💡 To load this validation in a new session:")
+                print("      import pointblank as pb")
+                if any(
+                    hasattr(info.pre, "__module__")
+                    and info.pre.__module__ not in ["__main__", None]
+                    for info in preprocessing_funcs
+                    if hasattr(info, "pre") and info.pre
+                ):
+                    print("      # Import any preprocessing functions from their modules")
+                    modules_mentioned = set()
+                    for info in preprocessing_funcs:
+                        if (
+                            hasattr(info, "pre")
+                            and hasattr(info.pre, "__module__")
+                            and info.pre.__module__ not in ["__main__", None]
+                        ):
+                            if info.pre.__module__ not in modules_mentioned:
+                                print(
+                                    f"      from {info.pre.__module__} import {info.pre.__name__}"
+                                )
+                                modules_mentioned.add(info.pre.__module__)
+                print(f"      validation = pb.read_file('{file_path.name}')")
+            else:
+                print("   📖 To load: validation = pb.read_file('{}')".format(file_path.name))
+
+    except Exception as e:  # pragma: no cover
+        raise RuntimeError(
+            f"Failed to write validation object to {file_path}: {e}"
+        )  # pragma: no cover
+
+
 def get_data_path(
     dataset: Literal["small_table", "game_revenue", "nycflights", "global_sales"] = "small_table",
     file_type: Literal["csv", "parquet", "duckdb"] = "csv",
@@ -2941,6 +3699,10 @@ class _ValidationInfo:
         The time the validation step was processed. This is in the ISO 8601 format in UTC time.
     proc_duration_s
         The duration of processing for the validation step in seconds.
+    notes
+        An ordered dictionary of notes/footnotes associated with the validation step. Each entry
+        contains both 'markdown' and 'text' versions of the note content. The dictionary preserves
+        insertion order, ensuring notes appear in a consistent sequence in reports and logs.
     """
 
     # Validation plan
@@ -2978,18 +3740,191 @@ class _ValidationInfo:
     val_info: dict[str, any] | None = None
     time_processed: str | None = None
     proc_duration_s: float | None = None
+    notes: dict[str, dict[str, str]] | None = None
 
     def get_val_info(self) -> dict[str, any]:
         return self.val_info
 
+    def _add_note(self, key: str, markdown: str, text: str | None = None) -> None:
+        """
+        Add a note/footnote to the validation step.
 
-def connect_to_table(connection_string: str) -> Any:
-    """
-    Connect to a database table using a connection string.
-
-    This utility function tests whether a connection string leads to a valid table and returns
-    the table object if successful. It provides helpful error messages when no table is specified
-    or when backend dependencies are missing.
+        This internal method adds a note entry to the validation step's notes dictionary.
+        Notes are displayed as footnotes in validation reports and included in log output.
+
+        Parameters
+        ----------
+        key
+            A unique identifier for the note. If a note with this key already exists, it will
+            be overwritten.
+        markdown
+            The note content formatted with Markdown. This version is used for display in
+            HTML reports and other rich text formats.
+        text
+            The note content as plain text. This version is used for log files and text-based
+            output. If not provided, the markdown version will be used (with markdown formatting
+            intact).
+
+        Examples
+        --------
+        ```python
+        # Add a note about evaluation failure
+        validation_info._add_note(
+            key="eval_error",
+            markdown="Column expression evaluation **failed**",
+            text="Column expression evaluation failed"
+        )
+
+        # Add a note about LLM response
+        validation_info._add_note(
+            key="llm_response",
+            markdown="LLM validation returned `200` passing rows",
+            text="LLM validation returned 200 passing rows"
+        )
+        ```
+        """
+        # Initialize notes dictionary if it doesn't exist
+        if self.notes is None:
+            self.notes = {}
+
+        # Use markdown as text if text is not provided
+        if text is None:
+            text = markdown
+
+        # Add the note entry
+        self.notes[key] = {"markdown": markdown, "text": text}
+
+    def _get_notes(self, format: str = "dict") -> dict[str, dict[str, str]] | list[str] | None:
+        """
+        Get notes associated with this validation step.
+
+        Parameters
+        ----------
+        format
+            The format to return notes in:
+            - `"dict"`: Returns the full notes dictionary (default)
+            - `"markdown"`: Returns a list of markdown-formatted note values
+            - `"text"`: Returns a list of plain text note values
+            - `"keys"`: Returns a list of note keys
+
+        Returns
+        -------
+        dict, list, or None
+            The notes in the requested format, or `None` if no notes exist.
+
+        Examples
+        --------
+        ```python
+        # Get all notes as dictionary
+        notes = validation_info._get_notes()
+        # Returns: {'key1': {'markdown': '...', 'text': '...'}, ...}
+
+        # Get just markdown versions
+        markdown_notes = validation_info._get_notes(format="markdown")
+        # Returns: ['First note with **emphasis**', 'Second note']
+
+        # Get just plain text versions
+        text_notes = validation_info._get_notes(format="text")
+        # Returns: ['First note with emphasis', 'Second note']
+
+        # Get just the keys
+        keys = validation_info._get_notes(format="keys")
+        # Returns: ['key1', 'key2']
+        ```
+        """
+        if self.notes is None:
+            return None
+
+        if format == "dict":
+            return self.notes
+        elif format == "markdown":
+            return [note["markdown"] for note in self.notes.values()]
+        elif format == "text":
+            return [note["text"] for note in self.notes.values()]
+        elif format == "keys":
+            return list(self.notes.keys())
+        else:
+            raise ValueError(
+                f"Invalid format '{format}'. Must be one of: 'dict', 'markdown', 'text', 'keys'"
+            )
+
+    def _get_note(self, key: str, format: str = "dict") -> dict[str, str] | str | None:
+        """
+        Get a specific note by its key.
+
+        Parameters
+        ----------
+        key
+            The unique identifier of the note to retrieve.
+        format
+            The format to return the note in:
+            - `"dict"`: Returns `{'markdown': '...', 'text': '...'}` (default)
+            - `"markdown"`: Returns just the markdown string
+            - `"text"`: Returns just the plain text string
+
+        Returns
+        -------
+        dict, str, or None
+            The note in the requested format, or `None` if the note doesn't exist.
+
+        Examples
+        --------
+        ```python
+        # Get a specific note as dictionary
+        note = validation_info._get_note("threshold_info")
+        # Returns: {'markdown': 'Using **default** thresholds', 'text': '...'}
+
+        # Get just the markdown version
+        markdown = validation_info._get_note("threshold_info", format="markdown")
+        # Returns: 'Using **default** thresholds'
+
+        # Get just the text version
+        text = validation_info._get_note("threshold_info", format="text")
+        # Returns: 'Using default thresholds'
+        ```
+        """
+        if self.notes is None or key not in self.notes:
+            return None
+
+        note = self.notes[key]
+
+        if format == "dict":
+            return note
+        elif format == "markdown":
+            return note["markdown"]
+        elif format == "text":
+            return note["text"]
+        else:
+            raise ValueError(
+                f"Invalid format '{format}'. Must be one of: 'dict', 'markdown', 'text'"
+            )
+
+    def _has_notes(self) -> bool:
+        """
+        Check if this validation step has any notes.
+
+        Returns
+        -------
+        bool
+            `True` if the validation step has notes, `False` otherwise.
+
+        Examples
+        --------
+        ```python
+        if validation_info._has_notes():
+            print("This step has notes")
+        ```
+        """
+        return self.notes is not None and len(self.notes) > 0
+
+
+def connect_to_table(connection_string: str) -> Any:
+    """
+    Connect to a database table using a connection string.
+
+    This utility function tests whether a connection string leads to a valid table and returns
+    the table object if successful. It provides helpful error messages when no table is specified
+    or when backend dependencies are missing.
 
     Parameters
     ----------
@@ -3445,7 +4380,7 @@ class Validate:
         summary = pb.get_validation_summary()
         if summary["status"] == "CRITICAL":
             send_alert_email(
-                subject=f"CRITICAL validation failures in {summary['table_name']}",
+                subject=f"CRITICAL validation failures in {summary['tbl_name']}",
                 body=f"{summary['critical_steps']} steps failed with critical severity."
             )
 
@@ -3493,6 +4428,11 @@ class Validate:
     - Japanese (`"ja"`)
     - Korean (`"ko"`)
     - Vietnamese (`"vi"`)
+    - Indonesian (`"id"`)
+    - Ukrainian (`"uk"`)
+    - Hebrew (`"he"`)
+    - Thai (`"th"`)
+    - Persian (`"fa"`)
 
     Automatically generated briefs (produced by using `brief=True` or `brief="...{auto}..."`) will
     be written in the selected language. The language setting will also used when generating the
@@ -6955,9 +7895,12 @@ class Validate:
 
         return self
 
-    def col_vals_null(
+    def col_vals_increasing(
         self,
         columns: str | list[str] | Column | ColumnSelector | ColumnSelectorNarwhals,
+        allow_stationary: bool = False,
+        decreasing_tol: float | None = None,
+        na_pass: bool = False,
         pre: Callable | None = None,
         segments: SegmentSpec | None = None,
         thresholds: int | float | bool | tuple | dict | Thresholds = None,
@@ -6966,11 +7909,14 @@ class Validate:
         active: bool = True,
     ) -> Validate:
         """
-        Validate whether values in a column are Null.
+        Are column data increasing by row?
 
-        The `col_vals_null()` validation method checks whether column values in a table are Null.
-        This validation will operate over the number of test units that is equal to the number
-        of rows in the table.
+        The `col_vals_increasing()` validation method checks whether column values in a table are
+        increasing when moving down a table. There are options for allowing missing values in the
+        target column, allowing stationary phases (where consecutive values don't change), and even
+        one for allowing decreasing movements up to a certain threshold. This validation will
+        operate over the number of test units that is equal to the number of rows in the table
+        (determined after any `pre=` mutation has been applied).
 
         Parameters
         ----------
@@ -6979,6 +7925,20 @@ class Validate:
             [`col()`](`pointblank.col`) with column selectors to specify one or more columns. If
             multiple columns are supplied or resolved, there will be a separate validation step
             generated for each column.
+        allow_stationary
+            An option to allow pauses in increasing values. For example, if the values for the test
+            units are `[80, 82, 82, 85, 88]` then the third unit (`82`, appearing a second time)
+            would be marked as failing when `allow_stationary` is `False`. Using
+            `allow_stationary=True` will result in all the test units in `[80, 82, 82, 85, 88]` to
+            be marked as passing.
+        decreasing_tol
+            An optional threshold value that allows for movement of numerical values in the negative
+            direction. By default this is `None` but using a numerical value will set the absolute
+            threshold of negative travel allowed across numerical test units. Note that setting a
+            value here also has the effect of setting `allow_stationary` to `True`.
+        na_pass
+            Should any encountered None, NA, or Null values be considered as passing test units? By
+            default, this is `False`. Set to `True` to pass test units with missing values.
         pre
             An optional preprocessing function or lambda to apply to the data table during
             interrogation. This function should take a table as input and return a modified table.
@@ -7015,89 +7975,6 @@ class Validate:
         Validate
             The `Validate` object with the added validation step.
 
-        Preprocessing
-        -------------
-        The `pre=` argument allows for a preprocessing function or lambda to be applied to the data
-        table during interrogation. This function should take a table as input and return a modified
-        table. This is useful for performing any necessary transformations or filtering on the data
-        before the validation step is applied.
-
-        The preprocessing function can be any callable that takes a table as input and returns a
-        modified table. For example, you could use a lambda function to filter the table based on
-        certain criteria or to apply a transformation to the data. Note that you can refer to
-        a column via `columns=` that is expected to be present in the transformed table, but may not
-        exist in the table before preprocessing. Regarding the lifetime of the transformed table, it
-        only exists during the validation step and is not stored in the `Validate` object or used in
-        subsequent validation steps.
-
-        Segmentation
-        ------------
-        The `segments=` argument allows for the segmentation of a validation step into multiple
-        segments. This is useful for applying the same validation step to different subsets of the
-        data. The segmentation can be done based on a single column or specific fields within a
-        column.
-
-        Providing a single column name will result in a separate validation step for each unique
-        value in that column. For example, if you have a column called `"region"` with values
-        `"North"`, `"South"`, and `"East"`, the validation step will be applied separately to each
-        region.
-
-        Alternatively, you can provide a tuple that specifies a column name and its corresponding
-        values to segment on. For example, if you have a column called `"date"` and you want to
-        segment on only specific dates, you can provide a tuple like
-        `("date", ["2023-01-01", "2023-01-02"])`. Any other values in the column will be disregarded
-        (i.e., no validation steps will be created for them).
-
-        A list with a combination of column names and tuples can be provided as well. This allows
-        for more complex segmentation scenarios. The following inputs are both valid:
-
-        ```
-        # Segments from all unique values in the `region` column
-        # and specific dates in the `date` column
-        segments=["region", ("date", ["2023-01-01", "2023-01-02"])]
-
-        # Segments from all unique values in the `region` and `date` columns
-        segments=["region", "date"]
-        ```
-
-        The segmentation is performed during interrogation, and the resulting validation steps will
-        be numbered sequentially. Each segment will have its own validation step, and the results
-        will be reported separately. This allows for a more granular analysis of the data and helps
-        identify issues within specific segments.
-
-        Importantly, the segmentation process will be performed after any preprocessing of the data
-        table. Because of this, one can conceivably use the `pre=` argument to generate a column
-        that can be used for segmentation. For example, you could create a new column called
-        `"segment"` through use of `pre=` and then use that column for segmentation.
-
-        Thresholds
-        ----------
-        The `thresholds=` parameter is used to set the failure-condition levels for the validation
-        step. If they are set here at the step level, these thresholds will override any thresholds
-        set at the global level in `Validate(thresholds=...)`.
-
-        There are three threshold levels: 'warning', 'error', and 'critical'. The threshold values
-        can either be set as a proportion failing of all test units (a value between `0` to `1`),
-        or, the absolute number of failing test units (as integer that's `1` or greater).
-
-        Thresholds can be defined using one of these input schemes:
-
-        1. use the [`Thresholds`](`pointblank.Thresholds`) class (the most direct way to create
-        thresholds)
-        2. provide a tuple of 1-3 values, where position `0` is the 'warning' level, position `1` is
-        the 'error' level, and position `2` is the 'critical' level
-        3. create a dictionary of 1-3 value entries; the valid keys: are 'warning', 'error', and
-        'critical'
-        4. a single integer/float value denoting absolute number or fraction of failing test units
-        for the 'warning' level only
-
-        If the number of failing test units exceeds set thresholds, the validation step will be
-        marked as 'warning', 'error', or 'critical'. All of the threshold levels don't need to be
-        set, you're free to set any combination of them.
-
-        Aside from reporting failure conditions, thresholds can be used to determine the actions to
-        take for each level of failure (using the `actions=` parameter).
-
         Examples
         --------
         ```{python}
@@ -7106,8 +7983,9 @@ class Validate:
         import pointblank as pb
         pb.config(report_incl_header=False, report_incl_footer=False, preview_incl_header=False)
         ```
-        For the examples here, we'll use a simple Polars DataFrame with two numeric columns (`a` and
-        `b`). The table is shown below:
+
+        For the examples here, we'll use a simple Polars DataFrame with a numeric column (`a`). The
+        table is shown below:
 
         ```{python}
         import pointblank as pb
@@ -7115,54 +7993,55 @@ class Validate:
 
         tbl = pl.DataFrame(
             {
-                "a": [None, None, None, None],
-                "b": [None, 2, None, 9],
+                "a": [1, 2, 3, 4, 5, 6],
+                "b": [1, 2, 2, 3, 4, 5],
+                "c": [1, 2, 1, 3, 4, 5],
             }
-        ).with_columns(pl.col("a").cast(pl.Int64))
+        )
 
         pb.preview(tbl)
         ```
 
-        Let's validate that values in column `a` are all Null values. We'll determine if this
-        validation had any failing test units (there are four test units, one for each row).
+        Let's validate that values in column `a` are increasing. We'll determine if this validation
+        had any failing test units (there are six test units, one for each row).
 
         ```{python}
         validation = (
             pb.Validate(data=tbl)
-            .col_vals_null(columns="a")
+            .col_vals_increasing(columns="a")
             .interrogate()
         )
 
         validation
         ```
 
-        Printing the `validation` object shows the validation table in an HTML viewing environment.
-        The validation table shows the single entry that corresponds to the validation step created
-        by using `col_vals_null()`. All test units passed, and there are no failing test units.
-
-        Now, let's use that same set of values for a validation on column `b`.
+        The validation passed as all values in column `a` are increasing. Now let's check column
+        `b` which has a stationary value:
 
         ```{python}
         validation = (
             pb.Validate(data=tbl)
-            .col_vals_null(columns="b")
+            .col_vals_increasing(columns="b")
             .interrogate()
         )
 
         validation
         ```
 
-        The validation table reports two failing test units. The specific failing cases are for the
-        two non-Null values in column `b`.
-        """
-        assertion_type = _get_fn_name()
+        This validation fails at the third row because the value `2` is repeated. If we want to
+        allow stationary values, we can use `allow_stationary=True`:
 
-        _check_column(column=columns)
-        _check_pre(pre=pre)
-        # TODO: add check for segments
-        # _check_segments(segments=segments)
-        _check_thresholds(thresholds=thresholds)
-        _check_boolean_input(param=active, param_name="active")
+        ```{python}
+        validation = (
+            pb.Validate(data=tbl)
+            .col_vals_increasing(columns="b", allow_stationary=True)
+            .interrogate()
+        )
+
+        validation
+        ```
+        """
+        assertion_type = "col_vals_increasing"
 
         # Determine threshold to use (global or local) and normalize a local `thresholds=` value
         thresholds = (
@@ -7186,21 +8065,30 @@ class Validate:
             val_info = _ValidationInfo(
                 assertion_type=assertion_type,
                 column=column,
+                values="",
+                na_pass=na_pass,
                 pre=pre,
                 segments=segments,
                 thresholds=thresholds,
                 actions=actions,
                 brief=brief,
                 active=active,
+                val_info={
+                    "allow_stationary": allow_stationary,
+                    "decreasing_tol": decreasing_tol if decreasing_tol else 0.0,
+                },
             )
 
             self._add_validation(validation_info=val_info)
 
         return self
 
-    def col_vals_not_null(
+    def col_vals_decreasing(
         self,
         columns: str | list[str] | Column | ColumnSelector | ColumnSelectorNarwhals,
+        allow_stationary: bool = False,
+        increasing_tol: float | None = None,
+        na_pass: bool = False,
         pre: Callable | None = None,
         segments: SegmentSpec | None = None,
         thresholds: int | float | bool | tuple | dict | Thresholds = None,
@@ -7209,11 +8097,14 @@ class Validate:
         active: bool = True,
     ) -> Validate:
         """
-        Validate whether values in a column are not Null.
+        Are column data decreasing by row?
 
-        The `col_vals_not_null()` validation method checks whether column values in a table are not
-        Null. This validation will operate over the number of test units that is equal to the number
-        of rows in the table.
+        The `col_vals_decreasing()` validation method checks whether column values in a table are
+        decreasing when moving down a table. There are options for allowing missing values in the
+        target column, allowing stationary phases (where consecutive values don't change), and even
+        one for allowing increasing movements up to a certain threshold. This validation will
+        operate over the number of test units that is equal to the number of rows in the table
+        (determined after any `pre=` mutation has been applied).
 
         Parameters
         ----------
@@ -7222,6 +8113,20 @@ class Validate:
             [`col()`](`pointblank.col`) with column selectors to specify one or more columns. If
             multiple columns are supplied or resolved, there will be a separate validation step
             generated for each column.
+        allow_stationary
+            An option to allow pauses in decreasing values. For example, if the values for the test
+            units are `[88, 85, 85, 82, 80]` then the third unit (`85`, appearing a second time)
+            would be marked as failing when `allow_stationary` is `False`. Using
+            `allow_stationary=True` will result in all the test units in `[88, 85, 85, 82, 80]` to
+            be marked as passing.
+        increasing_tol
+            An optional threshold value that allows for movement of numerical values in the positive
+            direction. By default this is `None` but using a numerical value will set the absolute
+            threshold of positive travel allowed across numerical test units. Note that setting a
+            value here also has the effect of setting `allow_stationary` to `True`.
+        na_pass
+            Should any encountered None, NA, or Null values be considered as passing test units? By
+            default, this is `False`. Set to `True` to pass test units with missing values.
         pre
             An optional preprocessing function or lambda to apply to the data table during
             interrogation. This function should take a table as input and return a modified table.
@@ -7258,154 +8163,73 @@ class Validate:
         Validate
             The `Validate` object with the added validation step.
 
-        Preprocessing
-        -------------
-        The `pre=` argument allows for a preprocessing function or lambda to be applied to the data
-        table during interrogation. This function should take a table as input and return a modified
-        table. This is useful for performing any necessary transformations or filtering on the data
-        before the validation step is applied.
-
-        The preprocessing function can be any callable that takes a table as input and returns a
-        modified table. For example, you could use a lambda function to filter the table based on
-        certain criteria or to apply a transformation to the data. Note that you can refer to
-        a column via `columns=` that is expected to be present in the transformed table, but may not
-        exist in the table before preprocessing. Regarding the lifetime of the transformed table, it
-        only exists during the validation step and is not stored in the `Validate` object or used in
-        subsequent validation steps.
+        Examples
+        --------
+        ```{python}
+        #| echo: false
+        #| output: false
+        import pointblank as pb
+        pb.config(report_incl_header=False, report_incl_footer=False, preview_incl_header=False)
+        ```
 
-        Segmentation
-        ------------
-        The `segments=` argument allows for the segmentation of a validation step into multiple
-        segments. This is useful for applying the same validation step to different subsets of the
-        data. The segmentation can be done based on a single column or specific fields within a
-        column.
+        For the examples here, we'll use a simple Polars DataFrame with a numeric column (`a`). The
+        table is shown below:
 
-        Providing a single column name will result in a separate validation step for each unique
-        value in that column. For example, if you have a column called `"region"` with values
-        `"North"`, `"South"`, and `"East"`, the validation step will be applied separately to each
-        region.
-
-        Alternatively, you can provide a tuple that specifies a column name and its corresponding
-        values to segment on. For example, if you have a column called `"date"` and you want to
-        segment on only specific dates, you can provide a tuple like
-        `("date", ["2023-01-01", "2023-01-02"])`. Any other values in the column will be disregarded
-        (i.e., no validation steps will be created for them).
-
-        A list with a combination of column names and tuples can be provided as well. This allows
-        for more complex segmentation scenarios. The following inputs are both valid:
-
-        ```
-        # Segments from all unique values in the `region` column
-        # and specific dates in the `date` column
-        segments=["region", ("date", ["2023-01-01", "2023-01-02"])]
-
-        # Segments from all unique values in the `region` and `date` columns
-        segments=["region", "date"]
-        ```
-
-        The segmentation is performed during interrogation, and the resulting validation steps will
-        be numbered sequentially. Each segment will have its own validation step, and the results
-        will be reported separately. This allows for a more granular analysis of the data and helps
-        identify issues within specific segments.
-
-        Importantly, the segmentation process will be performed after any preprocessing of the data
-        table. Because of this, one can conceivably use the `pre=` argument to generate a column
-        that can be used for segmentation. For example, you could create a new column called
-        `"segment"` through use of `pre=` and then use that column for segmentation.
-
-        Thresholds
-        ----------
-        The `thresholds=` parameter is used to set the failure-condition levels for the validation
-        step. If they are set here at the step level, these thresholds will override any thresholds
-        set at the global level in `Validate(thresholds=...)`.
-
-        There are three threshold levels: 'warning', 'error', and 'critical'. The threshold values
-        can either be set as a proportion failing of all test units (a value between `0` to `1`),
-        or, the absolute number of failing test units (as integer that's `1` or greater).
-
-        Thresholds can be defined using one of these input schemes:
-
-        1. use the [`Thresholds`](`pointblank.Thresholds`) class (the most direct way to create
-        thresholds)
-        2. provide a tuple of 1-3 values, where position `0` is the 'warning' level, position `1` is
-        the 'error' level, and position `2` is the 'critical' level
-        3. create a dictionary of 1-3 value entries; the valid keys: are 'warning', 'error', and
-        'critical'
-        4. a single integer/float value denoting absolute number or fraction of failing test units
-        for the 'warning' level only
-
-        If the number of failing test units exceeds set thresholds, the validation step will be
-        marked as 'warning', 'error', or 'critical'. All of the threshold levels don't need to be
-        set, you're free to set any combination of them.
-
-        Aside from reporting failure conditions, thresholds can be used to determine the actions to
-        take for each level of failure (using the `actions=` parameter).
-
-        Examples
-        --------
-        ```{python}
-        #| echo: false
-        #| output: false
-        import pointblank as pb
-        pb.config(report_incl_header=False, report_incl_footer=False, preview_incl_header=False)
-        ```
-        For the examples here, we'll use a simple Polars DataFrame with two numeric columns (`a` and
-        `b`). The table is shown below:
-
-        ```{python}
-        import pointblank as pb
-        import polars as pl
+        ```{python}
+        import pointblank as pb
+        import polars as pl
 
         tbl = pl.DataFrame(
             {
-                "a": [4, 7, 2, 8],
-                "b": [5, None, 1, None],
+                "a": [6, 5, 4, 3, 2, 1],
+                "b": [5, 4, 4, 3, 2, 1],
+                "c": [5, 4, 5, 3, 2, 1],
             }
         )
 
         pb.preview(tbl)
         ```
 
-        Let's validate that none of the values in column `a` are Null values. We'll determine if
-        this validation had any failing test units (there are four test units, one for each row).
+        Let's validate that values in column `a` are decreasing. We'll determine if this validation
+        had any failing test units (there are six test units, one for each row).
 
         ```{python}
         validation = (
             pb.Validate(data=tbl)
-            .col_vals_not_null(columns="a")
+            .col_vals_decreasing(columns="a")
             .interrogate()
         )
 
         validation
         ```
 
-        Printing the `validation` object shows the validation table in an HTML viewing environment.
-        The validation table shows the single entry that corresponds to the validation step created
-        by using `col_vals_not_null()`. All test units passed, and there are no failing test units.
-
-        Now, let's use that same set of values for a validation on column `b`.
+        The validation passed as all values in column `a` are decreasing. Now let's check column
+        `b` which has a stationary value:
 
         ```{python}
         validation = (
             pb.Validate(data=tbl)
-            .col_vals_not_null(columns="b")
+            .col_vals_decreasing(columns="b")
             .interrogate()
         )
 
         validation
         ```
 
-        The validation table reports two failing test units. The specific failing cases are for the
-        two Null values in column `b`.
-        """
-        assertion_type = _get_fn_name()
+        This validation fails at the third row because the value `4` is repeated. If we want to
+        allow stationary values, we can use `allow_stationary=True`:
 
-        _check_column(column=columns)
-        _check_pre(pre=pre)
-        # TODO: add check for segments
-        # _check_segments(segments=segments)
-        _check_thresholds(thresholds=thresholds)
-        _check_boolean_input(param=active, param_name="active")
+        ```{python}
+        validation = (
+            pb.Validate(data=tbl)
+            .col_vals_decreasing(columns="b", allow_stationary=True)
+            .interrogate()
+        )
+
+        validation
+        ```
+        """
+        assertion_type = "col_vals_decreasing"
 
         # Determine threshold to use (global or local) and normalize a local `thresholds=` value
         thresholds = (
@@ -7429,24 +8253,27 @@ class Validate:
             val_info = _ValidationInfo(
                 assertion_type=assertion_type,
                 column=column,
+                values="",
+                na_pass=na_pass,
                 pre=pre,
                 segments=segments,
                 thresholds=thresholds,
                 actions=actions,
                 brief=brief,
                 active=active,
+                val_info={
+                    "allow_stationary": allow_stationary,
+                    "increasing_tol": increasing_tol if increasing_tol else 0.0,
+                },
             )
 
             self._add_validation(validation_info=val_info)
 
         return self
 
-    def col_vals_regex(
+    def col_vals_null(
         self,
         columns: str | list[str] | Column | ColumnSelector | ColumnSelectorNarwhals,
-        pattern: str,
-        na_pass: bool = False,
-        inverse: bool = False,
         pre: Callable | None = None,
         segments: SegmentSpec | None = None,
         thresholds: int | float | bool | tuple | dict | Thresholds = None,
@@ -7455,12 +8282,11 @@ class Validate:
         active: bool = True,
     ) -> Validate:
         """
-        Validate whether column values match a regular expression pattern.
+        Validate whether values in a column are Null.
 
-        The `col_vals_regex()` validation method checks whether column values in a table
-        correspond to a `pattern=` matching expression. This validation will operate over the number
-        of test units that is equal to the number of rows in the table (determined after any `pre=`
-        mutation has been applied).
+        The `col_vals_null()` validation method checks whether column values in a table are Null.
+        This validation will operate over the number of test units that is equal to the number
+        of rows in the table.
 
         Parameters
         ----------
@@ -7469,14 +8295,6 @@ class Validate:
             [`col()`](`pointblank.col`) with column selectors to specify one or more columns. If
             multiple columns are supplied or resolved, there will be a separate validation step
             generated for each column.
-        pattern
-            A regular expression pattern to compare against.
-        na_pass
-            Should any encountered None, NA, or Null values be considered as passing test units? By
-            default, this is `False`. Set to `True` to pass test units with missing values.
-        inverse
-            Should the validation step be inverted? If `True`, then the expectation is that column
-            values should *not* match the specified `pattern=` regex.
         pre
             An optional preprocessing function or lambda to apply to the data table during
             interrogation. This function should take a table as input and return a modified table.
@@ -7604,7 +8422,7 @@ class Validate:
         import pointblank as pb
         pb.config(report_incl_header=False, report_incl_footer=False, preview_incl_header=False)
         ```
-        For the examples here, we'll use a simple Polars DataFrame with two string columns (`a` and
+        For the examples here, we'll use a simple Polars DataFrame with two numeric columns (`a` and
         `b`). The table is shown below:
 
         ```{python}
@@ -7613,22 +8431,21 @@ class Validate:
 
         tbl = pl.DataFrame(
             {
-                "a": ["rb-0343", "ra-0232", "ry-0954", "rc-1343"],
-                "b": ["ra-0628", "ra-583", "rya-0826", "rb-0735"],
+                "a": [None, None, None, None],
+                "b": [None, 2, None, 9],
             }
-        )
+        ).with_columns(pl.col("a").cast(pl.Int64))
 
         pb.preview(tbl)
         ```
 
-        Let's validate that all of the values in column `a` match a particular regex pattern. We'll
-        determine if this validation had any failing test units (there are four test units, one for
-        each row).
+        Let's validate that values in column `a` are all Null values. We'll determine if this
+        validation had any failing test units (there are four test units, one for each row).
 
         ```{python}
         validation = (
             pb.Validate(data=tbl)
-            .col_vals_regex(columns="a", pattern=r"r[a-z]-[0-9]{4}")
+            .col_vals_null(columns="a")
             .interrogate()
         )
 
@@ -7637,14 +8454,14 @@ class Validate:
 
         Printing the `validation` object shows the validation table in an HTML viewing environment.
         The validation table shows the single entry that corresponds to the validation step created
-        by using `col_vals_regex()`. All test units passed, and there are no failing test units.
+        by using `col_vals_null()`. All test units passed, and there are no failing test units.
 
-        Now, let's use the same regex for a validation on column `b`.
+        Now, let's use that same set of values for a validation on column `b`.
 
         ```{python}
         validation = (
             pb.Validate(data=tbl)
-            .col_vals_regex(columns="b", pattern=r"r[a-z]-[0-9]{4}")
+            .col_vals_null(columns="b")
             .interrogate()
         )
 
@@ -7652,9 +8469,8 @@ class Validate:
         ```
 
         The validation table reports two failing test units. The specific failing cases are for the
-        string values of rows 1 and 2 in column `b`.
+        two non-Null values in column `b`.
         """
-
         assertion_type = _get_fn_name()
 
         _check_column(column=columns)
@@ -7662,8 +8478,6 @@ class Validate:
         # TODO: add check for segments
         # _check_segments(segments=segments)
         _check_thresholds(thresholds=thresholds)
-        _check_boolean_input(param=na_pass, param_name="na_pass")
-        _check_boolean_input(param=inverse, param_name="inverse")
         _check_boolean_input(param=active, param_name="active")
 
         # Determine threshold to use (global or local) and normalize a local `thresholds=` value
@@ -7683,16 +8497,11 @@ class Validate:
         # Determine brief to use (global or local) and transform any shorthands of `brief=`
         brief = self.brief if brief is None else _transform_auto_brief(brief=brief)
 
-        # Package up the `pattern=` and boolean params into a dictionary for later interrogation
-        values = {"pattern": pattern, "inverse": inverse}
-
         # Iterate over the columns and create a validation step for each
         for column in columns:
             val_info = _ValidationInfo(
                 assertion_type=assertion_type,
                 column=column,
-                values=values,
-                na_pass=na_pass,
                 pre=pre,
                 segments=segments,
                 thresholds=thresholds,
@@ -7705,9 +8514,9 @@ class Validate:
 
         return self
 
-    def col_vals_expr(
+    def col_vals_not_null(
         self,
-        expr: any,
+        columns: str | list[str] | Column | ColumnSelector | ColumnSelectorNarwhals,
         pre: Callable | None = None,
         segments: SegmentSpec | None = None,
         thresholds: int | float | bool | tuple | dict | Thresholds = None,
@@ -7716,20 +8525,19 @@ class Validate:
         active: bool = True,
     ) -> Validate:
         """
-        Validate column values using a custom expression.
+        Validate whether values in a column are not Null.
 
-        The `col_vals_expr()` validation method checks whether column values in a table satisfy a
-        custom `expr=` expression. This validation will operate over the number of test units that
-        is equal to the number of rows in the table (determined after any `pre=` mutation has been
-        applied).
+        The `col_vals_not_null()` validation method checks whether column values in a table are not
+        Null. This validation will operate over the number of test units that is equal to the number
+        of rows in the table.
 
         Parameters
         ----------
-        expr
-            A column expression that will evaluate each row in the table, returning a boolean value
-            per table row. If the target table is a Polars DataFrame, the expression should either
-            be a Polars column expression or a Narwhals one. For a Pandas DataFrame, the expression
-            should either be a lambda expression or a Narwhals column expression.
+        columns
+            A single column or a list of columns to validate. Can also use
+            [`col()`](`pointblank.col`) with column selectors to specify one or more columns. If
+            multiple columns are supplied or resolved, there will be a separate validation step
+            generated for each column.
         pre
             An optional preprocessing function or lambda to apply to the data table during
             interrogation. This function should take a table as input and return a modified table.
@@ -7747,7 +8555,7 @@ class Validate:
             be set locally and global thresholds (if any) will take effect. Look at the *Thresholds*
             section for information on how to set threshold levels.
         actions
-            Optional actions to take when the validation step meets or exceeds any set threshold
+            Optional actions to take when the validation step(s) meets or exceeds any set threshold
             levels. If provided, the [`Actions`](`pointblank.Actions`) class should be used to
             define the actions.
         brief
@@ -7775,9 +8583,11 @@ class Validate:
 
         The preprocessing function can be any callable that takes a table as input and returns a
         modified table. For example, you could use a lambda function to filter the table based on
-        certain criteria or to apply a transformation to the data. Regarding the lifetime of the
-        transformed table, it only exists during the validation step and is not stored in the
-        `Validate` object or used in subsequent validation steps.
+        certain criteria or to apply a transformation to the data. Note that you can refer to
+        a column via `columns=` that is expected to be present in the transformed table, but may not
+        exist in the table before preprocessing. Regarding the lifetime of the transformed table, it
+        only exists during the validation step and is not stored in the `Validate` object or used in
+        subsequent validation steps.
 
         Segmentation
         ------------
@@ -7855,8 +8665,8 @@ class Validate:
         import pointblank as pb
         pb.config(report_incl_header=False, report_incl_footer=False, preview_incl_header=False)
         ```
-        For the examples here, we'll use a simple Polars DataFrame with three columns (`a`, `b`, and
-        `c`). The table is shown below:
+        For the examples here, we'll use a simple Polars DataFrame with two numeric columns (`a` and
+        `b`). The table is shown below:
 
         ```{python}
         import pointblank as pb
@@ -7864,22 +8674,21 @@ class Validate:
 
         tbl = pl.DataFrame(
             {
-                "a": [1, 2, 1, 7, 8, 6],
-                "b": [0, 0, 0, 1, 1, 1],
-                "c": [0.5, 0.3, 0.8, 1.4, 1.9, 1.2],
+                "a": [4, 7, 2, 8],
+                "b": [5, None, 1, None],
             }
         )
 
         pb.preview(tbl)
         ```
 
-        Let's validate that the values in column `a` are all integers. We'll determine if this
-        validation had any failing test units (there are six test units, one for each row).
+        Let's validate that none of the values in column `a` are Null values. We'll determine if
+        this validation had any failing test units (there are four test units, one for each row).
 
         ```{python}
         validation = (
             pb.Validate(data=tbl)
-            .col_vals_expr(expr=pl.col("a") % 1 == 0)
+            .col_vals_not_null(columns="a")
             .interrogate()
         )
 
@@ -7888,13 +8697,26 @@ class Validate:
 
         Printing the `validation` object shows the validation table in an HTML viewing environment.
         The validation table shows the single entry that corresponds to the validation step created
-        by using `col_vals_expr()`. All test units passed, with no failing test units.
-        """
+        by using `col_vals_not_null()`. All test units passed, and there are no failing test units.
+
+        Now, let's use that same set of values for a validation on column `b`.
 
+        ```{python}
+        validation = (
+            pb.Validate(data=tbl)
+            .col_vals_not_null(columns="b")
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        The validation table reports two failing test units. The specific failing cases are for the
+        two Null values in column `b`.
+        """
         assertion_type = _get_fn_name()
 
-        # TODO: Add a check for the expression to ensure it's a valid expression object
-        # _check_expr(expr=expr)
+        _check_column(column=columns)
         _check_pre(pre=pre)
         # TODO: add check for segments
         # _check_segments(segments=segments)
@@ -7906,20 +8728,799 @@ class Validate:
             self.thresholds if thresholds is None else _normalize_thresholds_creation(thresholds)
         )
 
+        # If `columns` is a ColumnSelector or Narwhals selector, call `col()` on it to later
+        # resolve the columns
+        if isinstance(columns, (ColumnSelector, nw.selectors.Selector)):
+            columns = col(columns)
+
+        # If `columns` is Column value or a string, place it in a list for iteration
+        if isinstance(columns, (Column, str)):
+            columns = [columns]
+
         # Determine brief to use (global or local) and transform any shorthands of `brief=`
         brief = self.brief if brief is None else _transform_auto_brief(brief=brief)
 
-        val_info = _ValidationInfo(
-            assertion_type=assertion_type,
-            column=None,
-            values=expr,
-            pre=pre,
-            segments=segments,
-            thresholds=thresholds,
-            actions=actions,
-            brief=brief,
-            active=active,
-        )
+        # Iterate over the columns and create a validation step for each
+        for column in columns:
+            val_info = _ValidationInfo(
+                assertion_type=assertion_type,
+                column=column,
+                pre=pre,
+                segments=segments,
+                thresholds=thresholds,
+                actions=actions,
+                brief=brief,
+                active=active,
+            )
+
+            self._add_validation(validation_info=val_info)
+
+        return self
+
+    def col_vals_regex(
+        self,
+        columns: str | list[str] | Column | ColumnSelector | ColumnSelectorNarwhals,
+        pattern: str,
+        na_pass: bool = False,
+        inverse: bool = False,
+        pre: Callable | None = None,
+        segments: SegmentSpec | None = None,
+        thresholds: int | float | bool | tuple | dict | Thresholds = None,
+        actions: Actions | None = None,
+        brief: str | bool | None = None,
+        active: bool = True,
+    ) -> Validate:
+        """
+        Validate whether column values match a regular expression pattern.
+
+        The `col_vals_regex()` validation method checks whether column values in a table
+        correspond to a `pattern=` matching expression. This validation will operate over the number
+        of test units that is equal to the number of rows in the table (determined after any `pre=`
+        mutation has been applied).
+
+        Parameters
+        ----------
+        columns
+            A single column or a list of columns to validate. Can also use
+            [`col()`](`pointblank.col`) with column selectors to specify one or more columns. If
+            multiple columns are supplied or resolved, there will be a separate validation step
+            generated for each column.
+        pattern
+            A regular expression pattern to compare against.
+        na_pass
+            Should any encountered None, NA, or Null values be considered as passing test units? By
+            default, this is `False`. Set to `True` to pass test units with missing values.
+        inverse
+            Should the validation step be inverted? If `True`, then the expectation is that column
+            values should *not* match the specified `pattern=` regex.
+        pre
+            An optional preprocessing function or lambda to apply to the data table during
+            interrogation. This function should take a table as input and return a modified table.
+            Have a look at the *Preprocessing* section for more information on how to use this
+            argument.
+        segments
+            An optional directive on segmentation, which serves to split a validation step into
+            multiple (one step per segment). Can be a single column name, a tuple that specifies a
+            column name and its corresponding values to segment on, or a combination of both
+            (provided as a list). Read the *Segmentation* section for usage information.
+        thresholds
+            Set threshold failure levels for reporting and reacting to exceedences of the levels.
+            The thresholds are set at the step level and will override any global thresholds set in
+            `Validate(thresholds=...)`. The default is `None`, which means that no thresholds will
+            be set locally and global thresholds (if any) will take effect. Look at the *Thresholds*
+            section for information on how to set threshold levels.
+        actions
+            Optional actions to take when the validation step(s) meets or exceeds any set threshold
+            levels. If provided, the [`Actions`](`pointblank.Actions`) class should be used to
+            define the actions.
+        brief
+            An optional brief description of the validation step that will be displayed in the
+            reporting table. You can use the templating elements like `"{step}"` to insert
+            the step number, or `"{auto}"` to include an automatically generated brief. If `True`
+            the entire brief will be automatically generated. If `None` (the default) then there
+            won't be a brief.
+        active
+            A boolean value indicating whether the validation step should be active. Using `False`
+            will make the validation step inactive (still reporting its presence and keeping indexes
+            for the steps unchanged).
+
+        Returns
+        -------
+        Validate
+            The `Validate` object with the added validation step.
+
+        Preprocessing
+        -------------
+        The `pre=` argument allows for a preprocessing function or lambda to be applied to the data
+        table during interrogation. This function should take a table as input and return a modified
+        table. This is useful for performing any necessary transformations or filtering on the data
+        before the validation step is applied.
+
+        The preprocessing function can be any callable that takes a table as input and returns a
+        modified table. For example, you could use a lambda function to filter the table based on
+        certain criteria or to apply a transformation to the data. Note that you can refer to
+        a column via `columns=` that is expected to be present in the transformed table, but may not
+        exist in the table before preprocessing. Regarding the lifetime of the transformed table, it
+        only exists during the validation step and is not stored in the `Validate` object or used in
+        subsequent validation steps.
+
+        Segmentation
+        ------------
+        The `segments=` argument allows for the segmentation of a validation step into multiple
+        segments. This is useful for applying the same validation step to different subsets of the
+        data. The segmentation can be done based on a single column or specific fields within a
+        column.
+
+        Providing a single column name will result in a separate validation step for each unique
+        value in that column. For example, if you have a column called `"region"` with values
+        `"North"`, `"South"`, and `"East"`, the validation step will be applied separately to each
+        region.
+
+        Alternatively, you can provide a tuple that specifies a column name and its corresponding
+        values to segment on. For example, if you have a column called `"date"` and you want to
+        segment on only specific dates, you can provide a tuple like
+        `("date", ["2023-01-01", "2023-01-02"])`. Any other values in the column will be disregarded
+        (i.e., no validation steps will be created for them).
+
+        A list with a combination of column names and tuples can be provided as well. This allows
+        for more complex segmentation scenarios. The following inputs are both valid:
+
+        ```
+        # Segments from all unique values in the `region` column
+        # and specific dates in the `date` column
+        segments=["region", ("date", ["2023-01-01", "2023-01-02"])]
+
+        # Segments from all unique values in the `region` and `date` columns
+        segments=["region", "date"]
+        ```
+
+        The segmentation is performed during interrogation, and the resulting validation steps will
+        be numbered sequentially. Each segment will have its own validation step, and the results
+        will be reported separately. This allows for a more granular analysis of the data and helps
+        identify issues within specific segments.
+
+        Importantly, the segmentation process will be performed after any preprocessing of the data
+        table. Because of this, one can conceivably use the `pre=` argument to generate a column
+        that can be used for segmentation. For example, you could create a new column called
+        `"segment"` through use of `pre=` and then use that column for segmentation.
+
+        Thresholds
+        ----------
+        The `thresholds=` parameter is used to set the failure-condition levels for the validation
+        step. If they are set here at the step level, these thresholds will override any thresholds
+        set at the global level in `Validate(thresholds=...)`.
+
+        There are three threshold levels: 'warning', 'error', and 'critical'. The threshold values
+        can either be set as a proportion failing of all test units (a value between `0` to `1`),
+        or, the absolute number of failing test units (as integer that's `1` or greater).
+
+        Thresholds can be defined using one of these input schemes:
+
+        1. use the [`Thresholds`](`pointblank.Thresholds`) class (the most direct way to create
+        thresholds)
+        2. provide a tuple of 1-3 values, where position `0` is the 'warning' level, position `1` is
+        the 'error' level, and position `2` is the 'critical' level
+        3. create a dictionary of 1-3 value entries; the valid keys: are 'warning', 'error', and
+        'critical'
+        4. a single integer/float value denoting absolute number or fraction of failing test units
+        for the 'warning' level only
+
+        If the number of failing test units exceeds set thresholds, the validation step will be
+        marked as 'warning', 'error', or 'critical'. All of the threshold levels don't need to be
+        set, you're free to set any combination of them.
+
+        Aside from reporting failure conditions, thresholds can be used to determine the actions to
+        take for each level of failure (using the `actions=` parameter).
+
+        Examples
+        --------
+        ```{python}
+        #| echo: false
+        #| output: false
+        import pointblank as pb
+        pb.config(report_incl_header=False, report_incl_footer=False, preview_incl_header=False)
+        ```
+        For the examples here, we'll use a simple Polars DataFrame with two string columns (`a` and
+        `b`). The table is shown below:
+
+        ```{python}
+        import pointblank as pb
+        import polars as pl
+
+        tbl = pl.DataFrame(
+            {
+                "a": ["rb-0343", "ra-0232", "ry-0954", "rc-1343"],
+                "b": ["ra-0628", "ra-583", "rya-0826", "rb-0735"],
+            }
+        )
+
+        pb.preview(tbl)
+        ```
+
+        Let's validate that all of the values in column `a` match a particular regex pattern. We'll
+        determine if this validation had any failing test units (there are four test units, one for
+        each row).
+
+        ```{python}
+        validation = (
+            pb.Validate(data=tbl)
+            .col_vals_regex(columns="a", pattern=r"r[a-z]-[0-9]{4}")
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        Printing the `validation` object shows the validation table in an HTML viewing environment.
+        The validation table shows the single entry that corresponds to the validation step created
+        by using `col_vals_regex()`. All test units passed, and there are no failing test units.
+
+        Now, let's use the same regex for a validation on column `b`.
+
+        ```{python}
+        validation = (
+            pb.Validate(data=tbl)
+            .col_vals_regex(columns="b", pattern=r"r[a-z]-[0-9]{4}")
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        The validation table reports two failing test units. The specific failing cases are for the
+        string values of rows 1 and 2 in column `b`.
+        """
+
+        assertion_type = _get_fn_name()
+
+        _check_column(column=columns)
+        _check_pre(pre=pre)
+        # TODO: add check for segments
+        # _check_segments(segments=segments)
+        _check_thresholds(thresholds=thresholds)
+        _check_boolean_input(param=na_pass, param_name="na_pass")
+        _check_boolean_input(param=inverse, param_name="inverse")
+        _check_boolean_input(param=active, param_name="active")
+
+        # Determine threshold to use (global or local) and normalize a local `thresholds=` value
+        thresholds = (
+            self.thresholds if thresholds is None else _normalize_thresholds_creation(thresholds)
+        )
+
+        # If `columns` is a ColumnSelector or Narwhals selector, call `col()` on it to later
+        # resolve the columns
+        if isinstance(columns, (ColumnSelector, nw.selectors.Selector)):
+            columns = col(columns)
+
+        # If `columns` is Column value or a string, place it in a list for iteration
+        if isinstance(columns, (Column, str)):
+            columns = [columns]
+
+        # Determine brief to use (global or local) and transform any shorthands of `brief=`
+        brief = self.brief if brief is None else _transform_auto_brief(brief=brief)
+
+        # Package up the `pattern=` and boolean params into a dictionary for later interrogation
+        values = {"pattern": pattern, "inverse": inverse}
+
+        # Iterate over the columns and create a validation step for each
+        for column in columns:
+            val_info = _ValidationInfo(
+                assertion_type=assertion_type,
+                column=column,
+                values=values,
+                na_pass=na_pass,
+                pre=pre,
+                segments=segments,
+                thresholds=thresholds,
+                actions=actions,
+                brief=brief,
+                active=active,
+            )
+
+            self._add_validation(validation_info=val_info)
+
+        return self
+
+    def col_vals_within_spec(
+        self,
+        columns: str | list[str] | Column | ColumnSelector | ColumnSelectorNarwhals,
+        spec: str,
+        na_pass: bool = False,
+        pre: Callable | None = None,
+        segments: SegmentSpec | None = None,
+        thresholds: int | float | bool | tuple | dict | Thresholds = None,
+        actions: Actions | None = None,
+        brief: str | bool | None = None,
+        active: bool = True,
+    ) -> Validate:
+        """
+        Validate whether column values fit within a specification.
+
+        The `col_vals_within_spec()` validation method checks whether column values in a table
+        correspond to a specification (`spec=`) type (details of which are available in the
+        *Specifications* section). Specifications include common data types like email addresses,
+        URLs, postal codes, vehicle identification numbers (VINs), International Bank Account
+        Numbers (IBANs), and more. This validation will operate over the number of test units that
+        is equal to the number of rows in the table.
+
+        Parameters
+        ----------
+        columns
+            A single column or a list of columns to validate. Can also use
+            [`col()`](`pointblank.col`) with column selectors to specify one or more columns. If
+            multiple columns are supplied or resolved, there will be a separate validation step
+            generated for each column.
+        spec
+            A specification string for defining the specification type. Examples are `"email"`,
+            `"url"`, and `"postal_code[USA]"`. See the *Specifications* section for all available
+            options.
+        na_pass
+            Should any encountered None, NA, or Null values be considered as passing test units? By
+            default, this is `False`. Set to `True` to pass test units with missing values.
+        pre
+            An optional preprocessing function or lambda to apply to the data table during
+            interrogation. This function should take a table as input and return a modified table.
+            Have a look at the *Preprocessing* section for more information on how to use this
+            argument.
+        segments
+            An optional directive on segmentation, which serves to split a validation step into
+            multiple (one step per segment). Can be a single column name, a tuple that specifies a
+            column name and its corresponding values to segment on, or a combination of both
+            (provided as a list). Read the *Segmentation* section for usage information.
+        thresholds
+            Set threshold failure levels for reporting and reacting to exceedences of the levels.
+            The thresholds are set at the step level and will override any global thresholds set in
+            `Validate(thresholds=...)`. The default is `None`, which means that no thresholds will
+            be set locally and global thresholds (if any) will take effect. Look at the *Thresholds*
+            section for information on how to set threshold levels.
+        actions
+            Optional actions to take when the validation step(s) meets or exceeds any set threshold
+            levels. If provided, the [`Actions`](`pointblank.Actions`) class should be used to
+            define the actions.
+        brief
+            An optional brief description of the validation step that will be displayed in the
+            reporting table. You can use the templating elements like `"{step}"` to insert
+            the step number, or `"{auto}"` to include an automatically generated brief. If `True`
+            the entire brief will be automatically generated. If `None` (the default) then there
+            won't be a brief.
+        active
+            A boolean value indicating whether the validation step should be active. Using `False`
+            will make the validation step inactive (still reporting its presence and keeping indexes
+            for the steps unchanged).
+
+        Returns
+        -------
+        Validate
+            The `Validate` object with the added validation step.
+
+        Specifications
+        --------------
+        A specification type must be used with the `spec=` argument. This is a string-based keyword
+        that corresponds to the type of data in the specified columns. The following keywords can
+        be used:
+
+        - `"isbn"`: The International Standard Book Number (ISBN) is a unique numerical identifier
+          for books. This keyword validates both 10-digit and 13-digit ISBNs.
+
+        - `"vin"`: A vehicle identification number (VIN) is a unique code used by the automotive
+          industry to identify individual motor vehicles.
+
+        - `"postal_code[<country_code>]"`: A postal code (also known as postcodes, PIN, or ZIP
+          codes) is a series of letters, digits, or both included in a postal address. Because the
+          coding varies by country, a country code in either the 2-letter (ISO 3166-1 alpha-2) or
+          3-letter (ISO 3166-1 alpha-3) format needs to be supplied (e.g., `"postal_code[US]"` or
+          `"postal_code[USA]"`). The keyword alias `"zip"` can be used for US ZIP codes.
+
+        - `"credit_card"`: A credit card number can be validated across a variety of issuers. The
+          validation uses the Luhn algorithm.
+
+        - `"iban[<country_code>]"`: The International Bank Account Number (IBAN) is a system of
+          identifying bank accounts across countries. Because the length and coding varies by
+          country, a country code needs to be supplied (e.g., `"iban[DE]"` or `"iban[DEU]"`).
+
+        - `"swift"`: Business Identifier Codes (also known as SWIFT-BIC, BIC, or SWIFT code) are
+          unique identifiers for financial and non-financial institutions.
+
+        - `"phone"`, `"email"`, `"url"`, `"ipv4"`, `"ipv6"`, `"mac"`: Phone numbers, email
+          addresses, Internet URLs, IPv4 or IPv6 addresses, and MAC addresses can be validated with
+          their respective keywords.
+
+        Only a single `spec=` value should be provided per function call.
+
+        Preprocessing
+        -------------
+        The `pre=` argument allows for a preprocessing function or lambda to be applied to the data
+        table during interrogation. This function should take a table as input and return a modified
+        table. This is useful for performing any necessary transformations or filtering on the data
+        before the validation step is applied.
+
+        The preprocessing function can be any callable that takes a table as input and returns a
+        modified table. For example, you could use a lambda function to filter the table based on
+        certain criteria or to apply a transformation to the data. Note that you can refer to
+        a column via `columns=` that is expected to be present in the transformed table, but may not
+        exist in the table before preprocessing. Regarding the lifetime of the transformed table, it
+        only exists during the validation step and is not stored in the `Validate` object or used in
+        subsequent validation steps.
+
+        Segmentation
+        ------------
+        The `segments=` argument allows for the segmentation of a validation step into multiple
+        segments. This is useful for applying the same validation step to different subsets of the
+        data. The segmentation can be done based on a single column or specific fields within a
+        column.
+
+        Providing a single column name will result in a separate validation step for each unique
+        value in that column. For example, if you have a column called `"region"` with values
+        `"North"`, `"South"`, and `"East"`, the validation step will be applied separately to each
+        region.
+
+        Alternatively, you can provide a tuple that specifies a column name and its corresponding
+        values to segment on. For example, if you have a column called `"date"` and you want to
+        segment on only specific dates, you can provide a tuple like
+        `("date", ["2023-01-01", "2023-01-02"])`. Any other values in the column will be disregarded
+        (i.e., no validation steps will be created for them).
+
+        A list with a combination of column names and tuples can be provided as well. This allows
+        for more complex segmentation scenarios. The following inputs are both valid:
+
+        ```
+        # Segments from all unique values in the `region` column
+        # and specific dates in the `date` column
+        segments=["region", ("date", ["2023-01-01", "2023-01-02"])]
+
+        # Segments from all unique values in the `region` and `date` columns
+        segments=["region", "date"]
+        ```
+
+        The segmentation is performed during interrogation, and the resulting validation steps will
+        be numbered sequentially. Each segment will have its own validation step, and the results
+        will be reported separately. This allows for a more granular analysis of the data and helps
+        identify issues within specific segments.
+
+        Importantly, the segmentation process will be performed after any preprocessing of the data
+        table. Because of this, one can conceivably use the `pre=` argument to generate a column
+        that can be used for segmentation. For example, you could create a new column called
+        `"segment"` through use of `pre=` and then use that column for segmentation.
+
+        Thresholds
+        ----------
+        The `thresholds=` parameter is used to set the failure-condition levels for the validation
+        step. If they are set here at the step level, these thresholds will override any thresholds
+        set at the global level in `Validate(thresholds=...)`.
+
+        There are three threshold levels: 'warning', 'error', and 'critical'. The threshold values
+        can either be set as a proportion failing of all test units (a value between `0` to `1`),
+        or, the absolute number of failing test units (as integer that's `1` or greater).
+
+        Thresholds can be defined using one of these input schemes:
+
+        1. use the [`Thresholds`](`pointblank.Thresholds`) class (the most direct way to create
+        thresholds)
+        2. provide a tuple of 1-3 values, where position `0` is the 'warning' level, position `1` is
+        the 'error' level, and position `2` is the 'critical' level
+        3. create a dictionary of 1-3 value entries; the valid keys: are 'warning', 'error', and
+        'critical'
+        4. a single integer/float value denoting absolute number or fraction of failing test units
+        for the 'warning' level only
+
+        If the number of failing test units exceeds set thresholds, the validation step will be
+        marked as 'warning', 'error', or 'critical'. All of the threshold levels don't need to be
+        set, you're free to set any combination of them.
+
+        Aside from reporting failure conditions, thresholds can be used to determine the actions to
+        take for each level of failure (using the `actions=` parameter).
+
+        Examples
+        --------
+        ```{python}
+        #| echo: false
+        #| output: false
+        import pointblank as pb
+        pb.config(report_incl_header=False, report_incl_footer=False, preview_incl_header=False)
+        ```
+
+        For the examples here, we'll use a simple Polars DataFrame with an email column. The table
+        is shown below:
+
+        ```{python}
+        import pointblank as pb
+        import polars as pl
+
+        tbl = pl.DataFrame(
+            {
+                "email": [
+                    "user@example.com",
+                    "admin@test.org",
+                    "invalid-email",
+                    "contact@company.co.uk",
+                ],
+            }
+        )
+
+        pb.preview(tbl)
+        ```
+
+        Let's validate that all of the values in the `email` column are valid email addresses.
+        We'll determine if this validation had any failing test units (there are four test units,
+        one for each row).
+
+        ```{python}
+        validation = (
+            pb.Validate(data=tbl)
+            .col_vals_within_spec(columns="email", spec="email")
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        The validation table shows that one test unit failed (the invalid email address in row 3).
+        """
+
+        assertion_type = _get_fn_name()
+
+        _check_column(column=columns)
+        _check_pre(pre=pre)
+        # TODO: add check for segments
+        # _check_segments(segments=segments)
+        _check_thresholds(thresholds=thresholds)
+        _check_boolean_input(param=na_pass, param_name="na_pass")
+        _check_boolean_input(param=active, param_name="active")
+
+        # Determine threshold to use (global or local) and normalize a local `thresholds=` value
+        thresholds = (
+            self.thresholds if thresholds is None else _normalize_thresholds_creation(thresholds)
+        )
+
+        # If `columns` is a ColumnSelector or Narwhals selector, call `col()` on it to later
+        # resolve the columns
+        if isinstance(columns, (ColumnSelector, nw.selectors.Selector)):
+            columns = col(columns)
+
+        # If `columns` is Column value or a string, place it in a list for iteration
+        if isinstance(columns, (Column, str)):
+            columns = [columns]
+
+        # Determine brief to use (global or local) and transform any shorthands of `brief=`
+        brief = self.brief if brief is None else _transform_auto_brief(brief=brief)
+
+        # Package up the `spec=` param into a dictionary for later interrogation
+        values = {"spec": spec}
+
+        # Iterate over the columns and create a validation step for each
+        for column in columns:
+            val_info = _ValidationInfo(
+                assertion_type=assertion_type,
+                column=column,
+                values=values,
+                na_pass=na_pass,
+                pre=pre,
+                segments=segments,
+                thresholds=thresholds,
+                actions=actions,
+                brief=brief,
+                active=active,
+            )
+
+            self._add_validation(validation_info=val_info)
+
+        return self
+
+    def col_vals_expr(
+        self,
+        expr: any,
+        pre: Callable | None = None,
+        segments: SegmentSpec | None = None,
+        thresholds: int | float | bool | tuple | dict | Thresholds = None,
+        actions: Actions | None = None,
+        brief: str | bool | None = None,
+        active: bool = True,
+    ) -> Validate:
+        """
+        Validate column values using a custom expression.
+
+        The `col_vals_expr()` validation method checks whether column values in a table satisfy a
+        custom `expr=` expression. This validation will operate over the number of test units that
+        is equal to the number of rows in the table (determined after any `pre=` mutation has been
+        applied).
+
+        Parameters
+        ----------
+        expr
+            A column expression that will evaluate each row in the table, returning a boolean value
+            per table row. If the target table is a Polars DataFrame, the expression should either
+            be a Polars column expression or a Narwhals one. For a Pandas DataFrame, the expression
+            should either be a lambda expression or a Narwhals column expression.
+        pre
+            An optional preprocessing function or lambda to apply to the data table during
+            interrogation. This function should take a table as input and return a modified table.
+            Have a look at the *Preprocessing* section for more information on how to use this
+            argument.
+        segments
+            An optional directive on segmentation, which serves to split a validation step into
+            multiple (one step per segment). Can be a single column name, a tuple that specifies a
+            column name and its corresponding values to segment on, or a combination of both
+            (provided as a list). Read the *Segmentation* section for usage information.
+        thresholds
+            Set threshold failure levels for reporting and reacting to exceedences of the levels.
+            The thresholds are set at the step level and will override any global thresholds set in
+            `Validate(thresholds=...)`. The default is `None`, which means that no thresholds will
+            be set locally and global thresholds (if any) will take effect. Look at the *Thresholds*
+            section for information on how to set threshold levels.
+        actions
+            Optional actions to take when the validation step meets or exceeds any set threshold
+            levels. If provided, the [`Actions`](`pointblank.Actions`) class should be used to
+            define the actions.
+        brief
+            An optional brief description of the validation step that will be displayed in the
+            reporting table. You can use the templating elements like `"{step}"` to insert
+            the step number, or `"{auto}"` to include an automatically generated brief. If `True`
+            the entire brief will be automatically generated. If `None` (the default) then there
+            won't be a brief.
+        active
+            A boolean value indicating whether the validation step should be active. Using `False`
+            will make the validation step inactive (still reporting its presence and keeping indexes
+            for the steps unchanged).
+
+        Returns
+        -------
+        Validate
+            The `Validate` object with the added validation step.
+
+        Preprocessing
+        -------------
+        The `pre=` argument allows for a preprocessing function or lambda to be applied to the data
+        table during interrogation. This function should take a table as input and return a modified
+        table. This is useful for performing any necessary transformations or filtering on the data
+        before the validation step is applied.
+
+        The preprocessing function can be any callable that takes a table as input and returns a
+        modified table. For example, you could use a lambda function to filter the table based on
+        certain criteria or to apply a transformation to the data. Regarding the lifetime of the
+        transformed table, it only exists during the validation step and is not stored in the
+        `Validate` object or used in subsequent validation steps.
+
+        Segmentation
+        ------------
+        The `segments=` argument allows for the segmentation of a validation step into multiple
+        segments. This is useful for applying the same validation step to different subsets of the
+        data. The segmentation can be done based on a single column or specific fields within a
+        column.
+
+        Providing a single column name will result in a separate validation step for each unique
+        value in that column. For example, if you have a column called `"region"` with values
+        `"North"`, `"South"`, and `"East"`, the validation step will be applied separately to each
+        region.
+
+        Alternatively, you can provide a tuple that specifies a column name and its corresponding
+        values to segment on. For example, if you have a column called `"date"` and you want to
+        segment on only specific dates, you can provide a tuple like
+        `("date", ["2023-01-01", "2023-01-02"])`. Any other values in the column will be disregarded
+        (i.e., no validation steps will be created for them).
+
+        A list with a combination of column names and tuples can be provided as well. This allows
+        for more complex segmentation scenarios. The following inputs are both valid:
+
+        ```
+        # Segments from all unique values in the `region` column
+        # and specific dates in the `date` column
+        segments=["region", ("date", ["2023-01-01", "2023-01-02"])]
+
+        # Segments from all unique values in the `region` and `date` columns
+        segments=["region", "date"]
+        ```
+
+        The segmentation is performed during interrogation, and the resulting validation steps will
+        be numbered sequentially. Each segment will have its own validation step, and the results
+        will be reported separately. This allows for a more granular analysis of the data and helps
+        identify issues within specific segments.
+
+        Importantly, the segmentation process will be performed after any preprocessing of the data
+        table. Because of this, one can conceivably use the `pre=` argument to generate a column
+        that can be used for segmentation. For example, you could create a new column called
+        `"segment"` through use of `pre=` and then use that column for segmentation.
+
+        Thresholds
+        ----------
+        The `thresholds=` parameter is used to set the failure-condition levels for the validation
+        step. If they are set here at the step level, these thresholds will override any thresholds
+        set at the global level in `Validate(thresholds=...)`.
+
+        There are three threshold levels: 'warning', 'error', and 'critical'. The threshold values
+        can either be set as a proportion failing of all test units (a value between `0` to `1`),
+        or, the absolute number of failing test units (as integer that's `1` or greater).
+
+        Thresholds can be defined using one of these input schemes:
+
+        1. use the [`Thresholds`](`pointblank.Thresholds`) class (the most direct way to create
+        thresholds)
+        2. provide a tuple of 1-3 values, where position `0` is the 'warning' level, position `1` is
+        the 'error' level, and position `2` is the 'critical' level
+        3. create a dictionary of 1-3 value entries; the valid keys: are 'warning', 'error', and
+        'critical'
+        4. a single integer/float value denoting absolute number or fraction of failing test units
+        for the 'warning' level only
+
+        If the number of failing test units exceeds set thresholds, the validation step will be
+        marked as 'warning', 'error', or 'critical'. All of the threshold levels don't need to be
+        set, you're free to set any combination of them.
+
+        Aside from reporting failure conditions, thresholds can be used to determine the actions to
+        take for each level of failure (using the `actions=` parameter).
+
+        Examples
+        --------
+        ```{python}
+        #| echo: false
+        #| output: false
+        import pointblank as pb
+        pb.config(report_incl_header=False, report_incl_footer=False, preview_incl_header=False)
+        ```
+        For the examples here, we'll use a simple Polars DataFrame with three columns (`a`, `b`, and
+        `c`). The table is shown below:
+
+        ```{python}
+        import pointblank as pb
+        import polars as pl
+
+        tbl = pl.DataFrame(
+            {
+                "a": [1, 2, 1, 7, 8, 6],
+                "b": [0, 0, 0, 1, 1, 1],
+                "c": [0.5, 0.3, 0.8, 1.4, 1.9, 1.2],
+            }
+        )
+
+        pb.preview(tbl)
+        ```
+
+        Let's validate that the values in column `a` are all integers. We'll determine if this
+        validation had any failing test units (there are six test units, one for each row).
+
+        ```{python}
+        validation = (
+            pb.Validate(data=tbl)
+            .col_vals_expr(expr=pl.col("a") % 1 == 0)
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        Printing the `validation` object shows the validation table in an HTML viewing environment.
+        The validation table shows the single entry that corresponds to the validation step created
+        by using `col_vals_expr()`. All test units passed, with no failing test units.
+        """
+
+        assertion_type = _get_fn_name()
+
+        # TODO: Add a check for the expression to ensure it's a valid expression object
+        # _check_expr(expr=expr)
+        _check_pre(pre=pre)
+        # TODO: add check for segments
+        # _check_segments(segments=segments)
+        _check_thresholds(thresholds=thresholds)
+        _check_boolean_input(param=active, param_name="active")
+
+        # Determine threshold to use (global or local) and normalize a local `thresholds=` value
+        thresholds = (
+            self.thresholds if thresholds is None else _normalize_thresholds_creation(thresholds)
+        )
+
+        # Determine brief to use (global or local) and transform any shorthands of `brief=`
+        brief = self.brief if brief is None else _transform_auto_brief(brief=brief)
+
+        val_info = _ValidationInfo(
+            assertion_type=assertion_type,
+            column=None,
+            values=expr,
+            pre=pre,
+            segments=segments,
+            thresholds=thresholds,
+            actions=actions,
+            brief=brief,
+            active=active,
+        )
 
         self._add_validation(validation_info=val_info)
 
@@ -8461,27 +10062,367 @@ class Validate:
         step. If they are set here at the step level, these thresholds will override any thresholds
         set at the global level in `Validate(thresholds=...)`.
 
-        There are three threshold levels: 'warning', 'error', and 'critical'. The threshold values
-        can either be set as a proportion failing of all test units (a value between `0` to `1`),
-        or, the absolute number of failing test units (as integer that's `1` or greater).
+        There are three threshold levels: 'warning', 'error', and 'critical'. The threshold values
+        can either be set as a proportion failing of all test units (a value between `0` to `1`),
+        or, the absolute number of failing test units (as integer that's `1` or greater).
+
+        Thresholds can be defined using one of these input schemes:
+
+        1. use the [`Thresholds`](`pointblank.Thresholds`) class (the most direct way to create
+        thresholds)
+        2. provide a tuple of 1-3 values, where position `0` is the 'warning' level, position `1` is
+        the 'error' level, and position `2` is the 'critical' level
+        3. create a dictionary of 1-3 value entries; the valid keys: are 'warning', 'error', and
+        'critical'
+        4. a single integer/float value denoting absolute number or fraction of failing test units
+        for the 'warning' level only
+
+        If the number of failing test units exceeds set thresholds, the validation step will be
+        marked as 'warning', 'error', or 'critical'. All of the threshold levels don't need to be
+        set, you're free to set any combination of them.
+
+        Aside from reporting failure conditions, thresholds can be used to determine the actions to
+        take for each level of failure (using the `actions=` parameter).
+
+        Examples
+        --------
+        ```{python}
+        #| echo: false
+        #| output: false
+        import pointblank as pb
+        pb.config(report_incl_header=False, report_incl_footer=False, preview_incl_header=False)
+        ```
+        For the examples here, we'll use a simple Polars DataFrame with three string columns
+        (`col_1`, `col_2`, and `col_3`). The table is shown below:
+
+        ```{python}
+        import pointblank as pb
+        import polars as pl
+
+        tbl = pl.DataFrame(
+            {
+                "col_1": ["a", None, "c", "d"],
+                "col_2": ["a", "a", "c", None],
+                "col_3": ["a", "a", "d", None],
+            }
+        )
+
+        pb.preview(tbl)
+        ```
+
+        Let's validate that the rows in the table are complete with `rows_complete()`. We'll
+        determine if this validation had any failing test units (there are four test units, one for
+        each row). A failing test units means that a given row is not complete (i.e., has at least
+        one missing value).
+
+        ```{python}
+        validation = (
+            pb.Validate(data=tbl)
+            .rows_complete()
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        From this validation table we see that there are two failing test units. This is because
+        two rows in the table have at least one missing value (the second row and the last row).
+
+        We can also use a subset of columns to determine completeness. Let's specify the subset
+        using columns `col_2` and `col_3` for the next validation.
+
+        ```{python}
+        validation = (
+            pb.Validate(data=tbl)
+            .rows_complete(columns_subset=["col_2", "col_3"])
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        The validation table reports a single failing test units. The last row contains missing
+        values in both the `col_2` and `col_3` columns.
+        others.
+        """
+
+        assertion_type = _get_fn_name()
+
+        _check_pre(pre=pre)
+        # TODO: add check for segments
+        # _check_segments(segments=segments)
+        _check_thresholds(thresholds=thresholds)
+        _check_boolean_input(param=active, param_name="active")
+
+        # Determine threshold to use (global or local) and normalize a local `thresholds=` value
+        thresholds = (
+            self.thresholds if thresholds is None else _normalize_thresholds_creation(thresholds)
+        )
+
+        if columns_subset is not None and isinstance(columns_subset, str):  # pragma: no cover
+            columns_subset = [columns_subset]  # pragma: no cover
+
+        # TODO: incorporate Column object
+
+        # Determine brief to use (global or local) and transform any shorthands of `brief=`
+        brief = self.brief if brief is None else _transform_auto_brief(brief=brief)
+
+        val_info = _ValidationInfo(
+            assertion_type=assertion_type,
+            column=columns_subset,
+            pre=pre,
+            segments=segments,
+            thresholds=thresholds,
+            actions=actions,
+            brief=brief,
+            active=active,
+        )
+
+        self._add_validation(validation_info=val_info)
+
+        return self
+
+    def prompt(
+        self,
+        prompt: str,
+        model: str,
+        columns_subset: str | list[str] | None = None,
+        batch_size: int = 1000,
+        max_concurrent: int = 3,
+        pre: Callable | None = None,
+        segments: SegmentSpec | None = None,
+        thresholds: int | float | bool | tuple | dict | Thresholds = None,
+        actions: Actions | None = None,
+        brief: str | bool | None = None,
+        active: bool = True,
+    ) -> Validate:
+        """
+        Validate rows using AI/LLM-powered analysis.
+
+        The `prompt()` validation method uses Large Language Models (LLMs) to validate rows of data
+        based on natural language criteria. Similar to other Pointblank validation methods, this
+        generates binary test results (pass/fail) that integrate seamlessly with the standard
+        reporting framework.
+
+        Like `col_vals_*()` methods, `prompt()` evaluates data against specific criteria, but
+        instead of using programmatic rules, it uses natural language prompts interpreted by an LLM.
+        Like `rows_distinct()` and `rows_complete()`, it operates at the row level and allows you to
+        specify a subset of columns for evaluation using `columns_subset=`.
+
+        The system automatically combines your validation criteria from the `prompt=` parameter with
+        the necessary technical context, data formatting instructions, and response structure
+        requirements. This is all so you only need to focus on describing your validation logic in
+        plain language.
+
+        Each row becomes a test unit that either passes or fails the validation criteria, producing
+        the familiar True/False results that appear in Pointblank validation reports. This method
+        is particularly useful for complex validation rules that are difficult to express with
+        traditional validation methods, such as semantic checks, context-dependent validation, or
+        subjective quality assessments.
+
+        Parameters
+        ----------
+        prompt
+            A natural language description of the validation criteria. This prompt should clearly
+            describe what constitutes valid vs invalid rows. Some examples:
+            `"Each row should contain a valid email address and a realistic person name"`,
+            `"Values should indicate positive sentiment"`,
+            `"The description should mention a country name"`.
+        columns_subset
+            A single column or list of columns to include in the validation. If `None`, all columns
+            will be included. Specifying fewer columns can improve performance and reduce API costs
+            so try to include only the columns necessary for the validation.
+        model
+            The model to be used. This should be in the form of `provider:model` (e.g.,
+            `"anthropic:claude-sonnet-4-5"`). Supported providers are `"anthropic"`, `"openai"`,
+            `"ollama"`, and `"bedrock"`. The model name should be the specific model to be used from
+            the provider. Model names are subject to change so consult the provider's documentation
+            for the most up-to-date model names.
+        batch_size
+            Number of rows to process in each batch. Larger batches are more efficient but may hit
+            API limits. Default is `1000`.
+        max_concurrent
+            Maximum number of concurrent API requests. Higher values speed up processing but may
+            hit rate limits. Default is `3`.
+        pre
+            An optional preprocessing function or lambda to apply to the data table during
+            interrogation. This function should take a table as input and return a modified table.
+        segments
+            An optional directive on segmentation, which serves to split a validation step into
+            multiple (one step per segment). Can be a single column name, a tuple that specifies a
+            column name and its corresponding values to segment on, or a combination of both
+            (provided as a list).
+        thresholds
+            Set threshold failure levels for reporting and reacting to exceedences of the levels.
+            The thresholds are set at the step level and will override any global thresholds set in
+            `Validate(thresholds=...)`. The default is `None`, which means that no thresholds will
+            be set locally and global thresholds (if any) will take effect.
+        actions
+            Optional actions to take when the validation step meets or exceeds any set threshold
+            levels. If provided, the [`Actions`](`pointblank.Actions`) class should be used to
+            define the actions.
+        brief
+            An optional brief description of the validation step that will be displayed in the
+            reporting table. You can use the templating elements like `"{step}"` to insert
+            the step number, or `"{auto}"` to include an automatically generated brief. If `True`
+            the entire brief will be automatically generated. If `None` (the default) then there
+            won't be a brief.
+        active
+            A boolean value indicating whether the validation step should be active. Using `False`
+            will make the validation step inactive (still reporting its presence and keeping indexes
+            for the steps unchanged).
+
+        Returns
+        -------
+        Validate
+            The `Validate` object with the added validation step.
+
+        Constructing the `model` Argument
+        ---------------------------------
+        The `model=` argument should be constructed using the provider and model name separated by a
+        colon (`provider:model`). The provider text can any of:
+
+        - `"anthropic"` (Anthropic)
+        - `"openai"` (OpenAI)
+        - `"ollama"` (Ollama)
+        - `"bedrock"` (Amazon Bedrock)
+
+        The model name should be the specific model to be used from the provider. Model names are
+        subject to change so consult the provider's documentation for the most up-to-date model
+        names.
+
+        Notes on Authentication
+        -----------------------
+        API keys are automatically loaded from environment variables or `.env` files and are **not**
+        stored in the validation object for security reasons. You should consider using a secure
+        method for handling API keys.
+
+        One way to do this is to load the API key from an environment variable and retrieve it using
+        the `os` module (specifically the `os.getenv()` function). Places to store the API key might
+        include `.bashrc`, `.bash_profile`, `.zshrc`, or `.zsh_profile`.
+
+        Another solution is to store one or more model provider API keys in an `.env` file (in the
+        root of your project). If the API keys have correct names (e.g., `ANTHROPIC_API_KEY` or
+        `OPENAI_API_KEY`) then the AI validation will automatically load the API key from the `.env`
+        file. An `.env` file might look like this:
+
+        ```plaintext
+        ANTHROPIC_API_KEY="your_anthropic_api_key_here"
+        OPENAI_API_KEY="your_openai_api_key_here"
+        ```
+
+        There's no need to have the `python-dotenv` package installed when using `.env` files in
+        this way.
+
+        **Provider-specific setup**:
+
+        - **OpenAI**: set `OPENAI_API_KEY` environment variable or create `.env` file
+        - **Anthropic**: set `ANTHROPIC_API_KEY` environment variable or create `.env` file
+        - **Ollama**: no API key required, just ensure Ollama is running locally
+        - **Bedrock**: configure AWS credentials through standard AWS methods
+
+        AI Validation Process
+        ---------------------
+        The AI validation process works as follows:
+
+        1. data batching: the data is split into batches of the specified size
+        2. row deduplication: duplicate rows (based on selected columns) are identified and only
+        unique combinations are sent to the LLM for analysis
+        3. json conversion: each batch of unique rows is converted to JSON format for the LLM
+        4. prompt construction: the user prompt is embedded in a structured system prompt
+        5. llm processing: each batch is sent to the LLM for analysis
+        6. response parsing: LLM responses are parsed to extract validation results
+        7. result projection: results are mapped back to all original rows using row signatures
+        8. result aggregation: results from all batches are combined
+
+        **Performance Optimization**: the process uses row signature memoization to avoid redundant
+        LLM calls. When multiple rows have identical values in the selected columns, only one
+        representative row is validated, and the result is applied to all matching rows. This can
+        dramatically reduce API costs and processing time for datasets with repetitive patterns.
+
+        The LLM receives data in this JSON format:
+
+        ```json
+        {
+          "columns": ["col1", "col2", "col3"],
+          "rows": [
+            {"col1": "value1", "col2": "value2", "col3": "value3", "_pb_row_index": 0},
+            {"col1": "value4", "col2": "value5", "col3": "value6", "_pb_row_index": 1}
+          ]
+        }
+        ```
+
+        The LLM returns validation results in this format:
+        ```json
+        [
+          {"index": 0, "result": true},
+          {"index": 1, "result": false}
+        ]
+        ```
+
+        Prompt Design Tips
+        ------------------
+        For best results, design prompts that are:
+
+        - boolean-oriented: frame validation criteria to elicit clear valid/invalid responses
+        - specific: clearly define what makes a row valid/invalid
+        - unambiguous: avoid subjective language that could be interpreted differently
+        - context-aware: include relevant business rules or domain knowledge
+        - example-driven: consider providing examples in the prompt when helpful
+
+        **Critical**: Prompts must be designed so the LLM can determine whether each row passes or
+        fails the validation criteria. The system expects binary validation responses, so avoid
+        open-ended questions or prompts that might generate explanatory text instead of clear
+        pass/fail judgments.
+
+        Good prompt examples:
+
+        - "Each row should contain a valid email address in the 'email' column and a non-empty name
+        in the 'name' column"
+        - "The 'sentiment' column should contain positive sentiment words (happy, good, excellent,
+        etc.)"
+        - "Product descriptions should mention at least one technical specification"
+
+        Poor prompt examples (avoid these):
+
+        - "What do you think about this data?" (too open-ended)
+        - "Describe the quality of each row" (asks for description, not validation)
+        - "How would you improve this data?" (asks for suggestions, not pass/fail)
+
+        Performance Considerations
+        --------------------------
+        AI validation is significantly slower than traditional validation methods due to API calls
+        to LLM providers. However, performance varies dramatically based on data characteristics:
 
-        Thresholds can be defined using one of these input schemes:
+        **High Memoization Scenarios** (seconds to minutes):
 
-        1. use the [`Thresholds`](`pointblank.Thresholds`) class (the most direct way to create
-        thresholds)
-        2. provide a tuple of 1-3 values, where position `0` is the 'warning' level, position `1` is
-        the 'error' level, and position `2` is the 'critical' level
-        3. create a dictionary of 1-3 value entries; the valid keys: are 'warning', 'error', and
-        'critical'
-        4. a single integer/float value denoting absolute number or fraction of failing test units
-        for the 'warning' level only
+        - data with many duplicate rows in the selected columns
+        - low cardinality data (repeated patterns)
+        - small number of unique row combinations
 
-        If the number of failing test units exceeds set thresholds, the validation step will be
-        marked as 'warning', 'error', or 'critical'. All of the threshold levels don't need to be
-        set, you're free to set any combination of them.
+        **Low Memoization Scenarios** (minutes to hours):
 
-        Aside from reporting failure conditions, thresholds can be used to determine the actions to
-        take for each level of failure (using the `actions=` parameter).
+        - high cardinality data with mostly unique rows
+        - large datasets with few repeated patterns
+        - all or most rows requiring individual LLM evaluation
+
+        The row signature memoization optimization can reduce processing time significantly when
+        data has repetitive patterns. For datasets where every row is unique, expect longer
+        processing times similar to validating each row individually.
+
+        **Strategies to Reduce Processing Time**:
+
+        - test on data slices: define a sampling function like `def sample_1000(df): return df.head(1000)`
+        and use `pre=sample_1000` to validate on smaller samples
+        - filter relevant data: define filter functions like `def active_only(df): return df.filter(df["status"] == "active")`
+        and use `pre=active_only` to focus on a specific subset
+        - optimize column selection: use `columns_subset=` to include only the columns necessary
+        for validation
+        - start with smaller batches: begin with `batch_size=100` for testing, then increase
+        gradually
+        - reduce concurrency: lower `max_concurrent=1` if hitting rate limits
+        - use faster/cheaper models: consider using smaller or more efficient models for initial
+        testing before switching to more capable models
 
         Examples
         --------
@@ -8491,84 +10432,139 @@ class Validate:
         import pointblank as pb
         pb.config(report_incl_header=False, report_incl_footer=False, preview_incl_header=False)
         ```
-        For the examples here, we'll use a simple Polars DataFrame with three string columns
-        (`col_1`, `col_2`, and `col_3`). The table is shown below:
+        The following examples demonstrate how to use AI validation for different types of data
+        quality checks. These examples show both basic usage and more advanced configurations with
+        custom thresholds and actions.
 
-        ```{python}
-        import pointblank as pb
-        import polars as pl
+        **Basic AI validation example:**
 
-        tbl = pl.DataFrame(
-            {
-                "col_1": ["a", None, "c", "d"],
-                "col_2": ["a", "a", "c", None],
-                "col_3": ["a", "a", "d", None],
-            }
-        )
+        This first example shows a simple validation scenario where we want to check that customer
+        records have both valid email addresses and non-empty names. Notice how we use
+        `columns_subset=` to focus only on the relevant columns, which improves both performance
+        and cost-effectiveness.
 
-        pb.preview(tbl)
-        ```
+        ```python
+        import pointblank as pb
+        import polars as pl
 
-        Let's validate that the rows in the table are complete with `rows_complete()`. We'll
-        determine if this validation had any failing test units (there are four test units, one for
-        each row). A failing test units means that a given row is not complete (i.e., has at least
-        one missing value).
+        # Sample data with email and name columns
+        tbl = pl.DataFrame({
+            "email": ["john@example.com", "invalid-email", "jane@test.org"],
+            "name": ["John Doe", "", "Jane Smith"],
+            "age": [25, 30, 35]
+        })
 
-        ```{python}
+        # Validate using AI
         validation = (
             pb.Validate(data=tbl)
-            .rows_complete()
+            .prompt(
+                prompt="Each row should have a valid email address and a non-empty name",
+                columns_subset=["email", "name"],  # Only check these columns
+                model="openai:gpt-4o-mini",
+            )
             .interrogate()
         )
 
         validation
         ```
 
-        From this validation table we see that there are two failing test units. This is because
-        two rows in the table have at least one missing value (the second row and the last row).
+        In this example, the AI will identify that the second row fails validation because it has
+        an invalid email format (`"invalid-email"`) and the third row also fails because it has an
+        empty name field. The validation results will show 2 out of 3 rows failing the criteria.
 
-        We can also use a subset of columns to determine completeness. Let's specify the subset
-        using columns `col_2` and `col_3` for the next validation.
+        **Advanced example with custom thresholds:**
+
+        This more sophisticated example demonstrates how to use AI validation with custom thresholds
+        and actions. Here we're validating phone number formats to ensure they include area codes,
+        which is a common data quality requirement for customer contact information.
+
+        ```python
+        customer_data = pl.DataFrame({
+            "customer_id": [1, 2, 3, 4, 5],
+            "name": ["John Doe", "Jane Smith", "Bob Johnson", "Alice Brown", "Charlie Davis"],
+            "phone_number": [
+                "(555) 123-4567",  # Valid with area code
+                "555-987-6543",    # Valid with area code
+                "123-4567",        # Missing area code
+                "(800) 555-1234",  # Valid with area code
+                "987-6543"         # Missing area code
+            ]
+        })
 
-        ```{python}
         validation = (
-            pb.Validate(data=tbl)
-            .rows_complete(columns_subset=["col_2", "col_3"])
+            pb.Validate(data=customer_data)
+            .prompt(
+                prompt="Do all the phone numbers include an area code?",
+                columns_subset="phone_number",  # Only check the `phone_number` column
+                model="openai:gpt-4o",
+                batch_size=500,
+                max_concurrent=5,
+                thresholds=pb.Thresholds(warning=0.1, error=0.2, critical=0.3),
+                actions=pb.Actions(error="Too many phone numbers missing area codes.")
+            )
             .interrogate()
         )
-
-        validation
         ```
 
-        The validation table reports a single failing test units. The last row contains missing
-        values in both the `col_2` and `col_3` columns.
-        others.
+        This validation will identify that 2 out of 5 phone numbers (40%) are missing area codes,
+        which exceeds all threshold levels. The validation will trigger the specified error action
+        since the failure rate (40%) is above the error threshold (20%). The AI can recognize
+        various phone number formats and determine whether they include area codes.
         """
 
         assertion_type = _get_fn_name()
 
+        # Validation of inputs
+        if not isinstance(prompt, str) or not prompt.strip():
+            raise ValueError("prompt must be a non-empty string")
+
+        # Parse the provider and model name from the `model=` argument
+        try:
+            provider, model_name = model.split(sep=":", maxsplit=1)
+        except ValueError:
+            raise ValueError(f"Model must be in format 'provider:model_name', got: {model}")
+
+        # Error if an unsupported provider is used
+        if provider not in MODEL_PROVIDERS:
+            raise ValueError(
+                f"Unsupported provider: {provider}. Supported providers are {MODEL_PROVIDERS}."
+            )
+
+        # Ensure that `batch_size` and `max_concurrent` are positive integers
+        if not isinstance(batch_size, int) or batch_size < 1:
+            raise ValueError("batch_size must be a positive integer")
+        if not isinstance(max_concurrent, int) or max_concurrent < 1:
+            raise ValueError("max_concurrent must be a positive integer")
+
         _check_pre(pre=pre)
-        # TODO: add check for segments
-        # _check_segments(segments=segments)
         _check_thresholds(thresholds=thresholds)
         _check_boolean_input(param=active, param_name="active")
 
+        # Promote a single column given as a string to a list
+        if columns_subset is not None and isinstance(columns_subset, str):
+            columns_subset = [columns_subset]
+
         # Determine threshold to use (global or local) and normalize a local `thresholds=` value
         thresholds = (
             self.thresholds if thresholds is None else _normalize_thresholds_creation(thresholds)
         )
 
-        if columns_subset is not None and isinstance(columns_subset, str):  # pragma: no cover
-            columns_subset = [columns_subset]  # pragma: no cover
-
-        # TODO: incorporate Column object
-
         # Determine brief to use (global or local) and transform any shorthands of `brief=`
         brief = self.brief if brief is None else _transform_auto_brief(brief=brief)
 
+        # Package up the AI-specific parameters as a dictionary for later use
+        ai_config = {
+            "prompt": prompt,
+            "llm_provider": provider,
+            "llm_model": model_name,
+            "batch_size": batch_size,
+            "max_concurrent": max_concurrent,
+        }
+
         val_info = _ValidationInfo(
             assertion_type=assertion_type,
             column=columns_subset,
+            values=ai_config,
             pre=pre,
             segments=segments,
             thresholds=thresholds,
@@ -8963,24 +10959,203 @@ class Validate:
             .interrogate()
         )
 
-        validation
+        validation
+
+        validation = (
+            pb.Validate(data=smaller_small_table)
+            .row_count_match(count=13,tol=.05) # .05% tolerance of 13
+            .interrogate()
+        )
+
+        even_smaller_table = small_table.sample(n = 2)
+        validation = (
+            pb.Validate(data=even_smaller_table)
+            .row_count_match(count=13,tol=5) # plus or minus 5; this test will fail
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        """
+
+        assertion_type = _get_fn_name()
+
+        _check_pre(pre=pre)
+        _check_thresholds(thresholds=thresholds)
+        _check_boolean_input(param=active, param_name="active")
+        _check_boolean_input(param=inverse, param_name="inverse")
+
+        # Determine threshold to use (global or local) and normalize a local `thresholds=` value
+        thresholds = (
+            self.thresholds if thresholds is None else _normalize_thresholds_creation(thresholds)
+        )
+
+        # If `count` is a DataFrame or table then use the row count of the DataFrame as
+        # the expected count
+        if _is_value_a_df(count) or "ibis.expr.types.relations.Table" in str(type(count)):
+            count = get_row_count(count)
+
+        # Check the integrity of tolerance
+        bounds: AbsoluteBounds = _derive_bounds(ref=int(count), tol=tol)
+
+        # Package up the `count=` and boolean params into a dictionary for later interrogation
+        values = {"count": count, "inverse": inverse, "abs_tol_bounds": bounds}
+
+        # Determine brief to use (global or local) and transform any shorthands of `brief=`
+        brief = self.brief if brief is None else _transform_auto_brief(brief=brief)
+
+        val_info = _ValidationInfo(
+            assertion_type=assertion_type,
+            values=values,
+            pre=pre,
+            thresholds=thresholds,
+            actions=actions,
+            brief=brief,
+            active=active,
+        )
+
+        self._add_validation(validation_info=val_info)
+
+        return self
+
+    def col_count_match(
+        self,
+        count: int | FrameT | Any,
+        inverse: bool = False,
+        pre: Callable | None = None,
+        thresholds: int | float | bool | tuple | dict | Thresholds = None,
+        actions: Actions | None = None,
+        brief: str | bool | None = None,
+        active: bool = True,
+    ) -> Validate:
+        """
+        Validate whether the column count of the table matches a specified count.
+
+        The `col_count_match()` method checks whether the column count of the target table matches a
+        specified count. This validation will operate over a single test unit, which is whether the
+        column count matches the specified count.
+
+        We also have the option to invert the validation step by setting `inverse=True`. This will
+        make the expectation that column row count of the target table *does not* match the
+        specified count.
+
+        Parameters
+        ----------
+        count
+            The expected column count of the table. This can be an integer value, a Polars or Pandas
+            DataFrame object, or an Ibis backend table. If a DataFrame/table is provided, the column
+            count of that object will be used as the expected count.
+        inverse
+            Should the validation step be inverted? If `True`, then the expectation is that the
+            column count of the target table should not match the specified `count=` value.
+        pre
+            An optional preprocessing function or lambda to apply to the data table during
+            interrogation. This function should take a table as input and return a modified table.
+            Have a look at the *Preprocessing* section for more information on how to use this
+            argument.
+        thresholds
+            Set threshold failure levels for reporting and reacting to exceedences of the levels.
+            The thresholds are set at the step level and will override any global thresholds set in
+            `Validate(thresholds=...)`. The default is `None`, which means that no thresholds will
+            be set locally and global thresholds (if any) will take effect. Look at the *Thresholds*
+            section for information on how to set threshold levels.
+        actions
+            Optional actions to take when the validation step meets or exceeds any set threshold
+            levels. If provided, the [`Actions`](`pointblank.Actions`) class should be used to
+            define the actions.
+        brief
+            An optional brief description of the validation step that will be displayed in the
+            reporting table. You can use the templating elements like `"{step}"` to insert
+            the step number, or `"{auto}"` to include an automatically generated brief. If `True`
+            the entire brief will be automatically generated. If `None` (the default) then there
+            won't be a brief.
+        active
+            A boolean value indicating whether the validation step should be active. Using `False`
+            will make the validation step inactive (still reporting its presence and keeping indexes
+            for the steps unchanged).
+
+        Returns
+        -------
+        Validate
+            The `Validate` object with the added validation step.
+
+        Preprocessing
+        -------------
+        The `pre=` argument allows for a preprocessing function or lambda to be applied to the data
+        table during interrogation. This function should take a table as input and return a modified
+        table. This is useful for performing any necessary transformations or filtering on the data
+        before the validation step is applied.
+
+        The preprocessing function can be any callable that takes a table as input and returns a
+        modified table. For example, you could use a lambda function to filter the table based on
+        certain criteria or to apply a transformation to the data. Regarding the lifetime of the
+        transformed table, it only exists during the validation step and is not stored in the
+        `Validate` object or used in subsequent validation steps.
+
+        Thresholds
+        ----------
+        The `thresholds=` parameter is used to set the failure-condition levels for the validation
+        step. If they are set here at the step level, these thresholds will override any thresholds
+        set at the global level in `Validate(thresholds=...)`.
+
+        There are three threshold levels: 'warning', 'error', and 'critical'. The threshold values
+        can either be set as a proportion failing of all test units (a value between `0` to `1`),
+        or, the absolute number of failing test units (as integer that's `1` or greater).
+
+        Thresholds can be defined using one of these input schemes:
+
+        1. use the [`Thresholds`](`pointblank.Thresholds`) class (the most direct way to create
+        thresholds)
+        2. provide a tuple of 1-3 values, where position `0` is the 'warning' level, position `1` is
+        the 'error' level, and position `2` is the 'critical' level
+        3. create a dictionary of 1-3 value entries; the valid keys: are 'warning', 'error', and
+        'critical'
+        4. a single integer/float value denoting absolute number or fraction of failing test units
+        for the 'warning' level only
+
+        If the number of failing test units exceeds set thresholds, the validation step will be
+        marked as 'warning', 'error', or 'critical'. All of the threshold levels don't need to be
+        set, you're free to set any combination of them.
+
+        Aside from reporting failure conditions, thresholds can be used to determine the actions to
+        take for each level of failure (using the `actions=` parameter).
+
+        Examples
+        --------
+        ```{python}
+        #| echo: false
+        #| output: false
+        import pointblank as pb
+        pb.config(report_incl_header=False, report_incl_footer=False)
+        ```
+
+        For the examples here, we'll use the built in dataset `"game_revenue"`. The table can be
+        obtained by calling `load_dataset("game_revenue")`.
+
+        ```{python}
+        import pointblank as pb
 
-        validation = (
-            pb.Validate(data=smaller_small_table)
-            .row_count_match(count=13,tol=.05) # .05% tolerance of 13
-            .interrogate()
-        )
+        game_revenue = pb.load_dataset("game_revenue")
 
-        even_smaller_table = small_table.sample(n = 2)
+        pb.preview(game_revenue)
+        ```
+
+        Let's validate that the number of columns in the table matches a fixed value. In this case,
+        we will use the value `11` as the expected column count.
+
+        ```{python}
         validation = (
-            pb.Validate(data=even_smaller_table)
-            .row_count_match(count=13,tol=5) # plus or minus 5; this test will fail
+            pb.Validate(data=game_revenue)
+            .col_count_match(count=11)
             .interrogate()
         )
 
         validation
         ```
 
+        The validation table shows that the expectation value of `11` matches the actual count of
+        columns in the target table. So, the single test unit passed.
         """
 
         assertion_type = _get_fn_name()
@@ -8995,16 +11170,13 @@ class Validate:
             self.thresholds if thresholds is None else _normalize_thresholds_creation(thresholds)
         )
 
-        # If `count` is a DataFrame or table then use the row count of the DataFrame as
+        # If `count` is a DataFrame or table then use the column count of the DataFrame as
         # the expected count
         if _is_value_a_df(count) or "ibis.expr.types.relations.Table" in str(type(count)):
-            count = get_row_count(count)
-
-        # Check the integrity of tolerance
-        bounds: AbsoluteBounds = _derive_bounds(ref=int(count), tol=tol)
+            count = get_column_count(count)
 
         # Package up the `count=` and boolean params into a dictionary for later interrogation
-        values = {"count": count, "inverse": inverse, "abs_tol_bounds": bounds}
+        values = {"count": count, "inverse": inverse}
 
         # Determine brief to use (global or local) and transform any shorthands of `brief=`
         brief = self.brief if brief is None else _transform_auto_brief(brief=brief)
@@ -9023,10 +11195,9 @@ class Validate:
 
         return self
 
-    def col_count_match(
+    def tbl_match(
         self,
-        count: int | FrameT | Any,
-        inverse: bool = False,
+        tbl_compare: FrameT | Any,
         pre: Callable | None = None,
         thresholds: int | float | bool | tuple | dict | Thresholds = None,
         actions: Actions | None = None,
@@ -9034,25 +11205,29 @@ class Validate:
         active: bool = True,
     ) -> Validate:
         """
-        Validate whether the column count of the table matches a specified count.
+        Validate whether the target table matches a comparison table.
 
-        The `col_count_match()` method checks whether the column count of the target table matches a
-        specified count. This validation will operate over a single test unit, which is whether the
-        column count matches the specified count.
+        The `tbl_match()` method checks whether the target table's composition matches that of a
+        comparison table. The validation performs a comprehensive comparison using progressively
+        stricter checks (from least to most stringent):
 
-        We also have the option to invert the validation step by setting `inverse=True`. This will
-        make the expectation that column row count of the target table *does not* match the
-        specified count.
+        1. **Column count match**: both tables must have the same number of columns
+        2. **Row count match**: both tables must have the same number of rows
+        3. **Schema match (loose)**: column names and dtypes match (case-insensitive, any order)
+        4. **Schema match (order)**: columns in the correct order (case-insensitive names)
+        5. **Schema match (exact)**: column names match exactly (case-sensitive, correct order)
+        6. **Data match**: values in corresponding cells must be identical
+
+        This progressive approach helps identify exactly where tables differ. The validation will
+        fail at the first check that doesn't pass, making it easier to diagnose mismatches. This
+        validation operates over a single test unit (pass/fail for complete table match).
 
         Parameters
         ----------
-        count
-            The expected column count of the table. This can be an integer value, a Polars or Pandas
-            DataFrame object, or an Ibis backend table. If a DataFrame/table is provided, the column
-            count of that object will be used as the expected count.
-        inverse
-            Should the validation step be inverted? If `True`, then the expectation is that the
-            column count of the target table should not match the specified `count=` value.
+        tbl_compare
+            The comparison table to validate against. This can be a DataFrame object (Polars or
+            Pandas), an Ibis table object, or a callable that returns a table. If a callable is
+            provided, it will be executed during interrogation to obtain the comparison table.
         pre
             An optional preprocessing function or lambda to apply to the data table during
             interrogation. This function should take a table as input and return a modified table.
@@ -9093,9 +11268,10 @@ class Validate:
 
         The preprocessing function can be any callable that takes a table as input and returns a
         modified table. For example, you could use a lambda function to filter the table based on
-        certain criteria or to apply a transformation to the data. Regarding the lifetime of the
-        transformed table, it only exists during the validation step and is not stored in the
-        `Validate` object or used in subsequent validation steps.
+        certain criteria or to apply a transformation to the data. Note that the same preprocessing
+        is **not** applied to the comparison table; only the target table is preprocessed. Regarding
+        the lifetime of the transformed table, it only exists during the validation step and is not
+        stored in the `Validate` object or used in subsequent validation steps.
 
         Thresholds
         ----------
@@ -9125,6 +11301,66 @@ class Validate:
         Aside from reporting failure conditions, thresholds can be used to determine the actions to
         take for each level of failure (using the `actions=` parameter).
 
+        Cross-Backend Validation
+        ------------------------
+        The `tbl_match()` method supports **automatic backend coercion** when comparing tables from
+        different backends (e.g., comparing a Polars DataFrame against a Pandas DataFrame, or
+        comparing database tables from DuckDB/SQLite against in-memory DataFrames). When tables with
+        different backends are detected, the comparison table is automatically converted to match the
+        data table's backend before validation proceeds.
+
+        **Certified Backend Combinations:**
+
+        All combinations of the following backends have been tested and certified to work (in both
+        directions):
+
+        - Pandas DataFrame
+        - Polars DataFrame
+        - DuckDB (native)
+        - DuckDB (as Ibis table)
+        - SQLite (via Ibis)
+
+        Note that database backends (DuckDB, SQLite, PostgreSQL, MySQL, Snowflake, BigQuery) are
+        automatically materialized during validation:
+
+        - if comparing **against Polars**: materialized to Polars
+        - if comparing **against Pandas**: materialized to Pandas
+        - if **both tables are database backends**: both materialized to Polars
+
+        This ensures optimal performance and type consistency.
+
+        **Data Types That Work Best in Cross-Backend Validation:**
+
+        - numeric types: int, float columns (including proper NaN handling)
+        - string types: text columns with consistent encodings
+        - boolean types: True/False values
+        - null values: `None` and `NaN` are treated as equivalent across backends
+        - list columns: nested list structures (with basic types)
+
+        **Known Limitations:**
+
+        While many data types work well in cross-backend validation, there are some known
+        limitations to be aware of:
+
+        - date/datetime types: When converting between Polars and Pandas, date objects may be
+          represented differently. For example, `datetime.date` objects in Pandas may become
+          `pd.Timestamp` objects when converted from Polars, leading to false mismatches. To work
+          around this, ensure both tables use the same datetime representation before comparison.
+        - custom types: User-defined types or complex nested structures may not convert cleanly
+          between backends and could cause unexpected comparison failures.
+        - categorical types: Categorical/factor columns may have different internal
+          representations across backends.
+        - timezone-aware datetimes: Timezone handling differs between backends and may cause
+          comparison issues.
+
+        Here are some ideas to overcome such limitations:
+
+        - for date/datetime columns, consider using `pre=` preprocessing to normalize representations
+          before comparison.
+        - when working with custom types, manually convert tables to the same backend before using
+          `tbl_match()`.
+        - use the same datetime precision (e.g., milliseconds vs microseconds) in both tables.
+
         Examples
         --------
         ```{python}
@@ -9134,32 +11370,67 @@ class Validate:
         pb.config(report_incl_header=False, report_incl_footer=False)
         ```
 
-        For the examples here, we'll use the built in dataset `"game_revenue"`. The table can be
-        obtained by calling `load_dataset("game_revenue")`.
+        For the examples here, we'll create two simple tables to demonstrate the `tbl_match()`
+        validation.
 
         ```{python}
         import pointblank as pb
+        import polars as pl
 
-        game_revenue = pb.load_dataset("game_revenue")
+        # Create the first table
+        tbl_1 = pl.DataFrame({
+            "a": [1, 2, 3, 4],
+            "b": ["w", "x", "y", "z"],
+            "c": [4.0, 5.0, 6.0, 7.0]
+        })
 
-        pb.preview(game_revenue)
+        # Create an identical table
+        tbl_2 = pl.DataFrame({
+            "a": [1, 2, 3, 4],
+            "b": ["w", "x", "y", "z"],
+            "c": [4.0, 5.0, 6.0, 7.0]
+        })
+
+        pb.preview(tbl_1)
         ```
 
-        Let's validate that the number of columns in the table matches a fixed value. In this case,
-        we will use the value `11` as the expected column count.
+        Let's validate that `tbl_1` matches `tbl_2`. Since these tables are identical, the
+        validation should pass.
 
         ```{python}
         validation = (
-            pb.Validate(data=game_revenue)
-            .col_count_match(count=11)
+            pb.Validate(data=tbl_1)
+            .tbl_match(tbl_compare=tbl_2)
             .interrogate()
         )
 
         validation
         ```
 
-        The validation table shows that the expectation value of `11` matches the actual count of
-        columns in the target table. So, the single test unit passed.
+        The validation table shows that the single test unit passed, indicating that the two tables
+        match completely.
+
+        Now, let's create a table with a slight difference and see what happens.
+
+        ```{python}
+        # Create a table with one different value
+        tbl_3 = pl.DataFrame({
+            "a": [1, 2, 3, 4],
+            "b": ["w", "x", "y", "z"],
+            "c": [4.0, 5.5, 6.0, 7.0]  # Changed 5.0 to 5.5
+        })
+
+        validation = (
+            pb.Validate(data=tbl_1)
+            .tbl_match(tbl_compare=tbl_3)
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        The validation table shows that the single test unit failed because the tables don't match
+        (one value is different in column `c`).
         """
 
         assertion_type = _get_fn_name()
@@ -9167,20 +11438,14 @@ class Validate:
         _check_pre(pre=pre)
         _check_thresholds(thresholds=thresholds)
         _check_boolean_input(param=active, param_name="active")
-        _check_boolean_input(param=inverse, param_name="inverse")
 
         # Determine threshold to use (global or local) and normalize a local `thresholds=` value
         thresholds = (
             self.thresholds if thresholds is None else _normalize_thresholds_creation(thresholds)
         )
 
-        # If `count` is a DataFrame or table then use the column count of the DataFrame as
-        # the expected count
-        if _is_value_a_df(count) or "ibis.expr.types.relations.Table" in str(type(count)):
-            count = get_column_count(count)
-
-        # Package up the `count=` and boolean params into a dictionary for later interrogation
-        values = {"count": count, "inverse": inverse}
+        # Package up the `tbl_compare` into a dictionary for later interrogation
+        values = {"tbl_compare": tbl_compare}
 
         # Determine brief to use (global or local) and transform any shorthands of `brief=`
         brief = self.brief if brief is None else _transform_auto_brief(brief=brief)
@@ -9354,13 +11619,17 @@ class Validate:
         We can also use preprocessing to filter the data before applying the conjoint validation:
 
         ```{python}
+        # Define preprocessing function for serialization compatibility
+        def filter_by_c_gt_5(df):
+            return df.filter(pl.col("c") > 5)
+
         validation = (
             pb.Validate(data=tbl)
             .conjointly(
                 lambda df: pl.col("a") > 2,
                 lambda df: pl.col("b") < 7,
                 lambda df: pl.col("a") + pl.col("b") < pl.col("c"),
-                pre=lambda df: df.filter(pl.col("c") > 5)
+                pre=filter_by_c_gt_5
             )
             .interrogate()
         )
@@ -10069,6 +12338,26 @@ class Validate:
                 tbl_type=tbl_type
             )
 
+            # Check if preprocessing or segmentation resulted in zero rows
+            # Only apply this check to row-based validations, not table-level validations
+            # (table-level validations like row_count_match(), col_count_match(), etc.,
+            # operate on the table as a whole, so zero rows is a valid input)
+            table_level_assertions = [
+                "col_exists",
+                "col_schema_match",
+                "row_count_match",
+                "col_count_match",
+            ]
+
+            if validation.n == 0 and assertion_type not in table_level_assertions:
+                # Mark the validation as having an eval_error
+                validation.eval_error = True
+                end_time = datetime.datetime.now(datetime.timezone.utc)
+                validation.proc_duration_s = (end_time - start_time).total_seconds()
+                validation.time_processed = end_time.isoformat(timespec="milliseconds")
+                validation.active = False
+                continue
+
             # ------------------------------------------------
             # Validation stage
             # ------------------------------------------------
@@ -10086,11 +12375,14 @@ class Validate:
                         "col_vals_le",
                         "col_vals_null",
                         "col_vals_not_null",
+                        "col_vals_increasing",
+                        "col_vals_decreasing",
                         "col_vals_between",
                         "col_vals_outside",
                         "col_vals_in_set",
                         "col_vals_not_in_set",
                         "col_vals_regex",
+                        "col_vals_within_spec",
                     ]:
                         # Process table for column validation
                         tbl = _column_test_prep(
@@ -10126,6 +12418,36 @@ class Validate:
                         elif assertion_method == "not_null":
                             results_tbl = interrogate_not_null(tbl=tbl, column=column)
 
+                        elif assertion_type == "col_vals_increasing":
+                            from pointblank._interrogation import interrogate_increasing
+
+                            # Extract direction options from val_info
+                            allow_stationary = validation.val_info.get("allow_stationary", False)
+                            decreasing_tol = validation.val_info.get("decreasing_tol", 0.0)
+
+                            results_tbl = interrogate_increasing(
+                                tbl=tbl,
+                                column=column,
+                                allow_stationary=allow_stationary,
+                                decreasing_tol=decreasing_tol,
+                                na_pass=na_pass,
+                            )
+
+                        elif assertion_type == "col_vals_decreasing":
+                            from pointblank._interrogation import interrogate_decreasing
+
+                            # Extract direction options from val_info
+                            allow_stationary = validation.val_info.get("allow_stationary", False)
+                            increasing_tol = validation.val_info.get("increasing_tol", 0.0)
+
+                            results_tbl = interrogate_decreasing(
+                                tbl=tbl,
+                                column=column,
+                                allow_stationary=allow_stationary,
+                                increasing_tol=increasing_tol,
+                                na_pass=na_pass,
+                            )
+
                         elif assertion_type == "col_vals_between":
                             results_tbl = interrogate_between(
                                 tbl=tbl,
@@ -10159,6 +12481,13 @@ class Validate:
                                 tbl=tbl, column=column, values=value, na_pass=na_pass
                             )
 
+                        elif assertion_type == "col_vals_within_spec":
+                            from pointblank._interrogation import interrogate_within_spec
+
+                            results_tbl = interrogate_within_spec(
+                                tbl=tbl, column=column, values=value, na_pass=na_pass
+                            )
+
                     elif assertion_type == "col_vals_expr":
                         results_tbl = col_vals_expr(
                             data_tbl=data_tbl_step, expr=value, tbl_type=tbl_type
@@ -10172,6 +12501,13 @@ class Validate:
                     elif assertion_type == "rows_complete":
                         results_tbl = rows_complete(data_tbl=data_tbl_step, columns_subset=column)
 
+                    elif assertion_type == "prompt":
+                        from pointblank._interrogation import interrogate_prompt
+
+                        results_tbl = interrogate_prompt(
+                            tbl=data_tbl_step, columns_subset=column, ai_config=value
+                        )
+
                     elif assertion_type == "col_exists":
                         result_bool = col_exists(
                             data_tbl=data_tbl_step,
@@ -10245,6 +12581,25 @@ class Validate:
 
                         results_tbl = None
 
+                    elif assertion_type == "tbl_match":
+                        from pointblank._interrogation import tbl_match
+
+                        # Get the comparison table (could be callable or actual table)
+                        tbl_compare = value["tbl_compare"]
+
+                        # If tbl_compare is callable, execute it to get the table
+                        if callable(tbl_compare):
+                            tbl_compare = tbl_compare()
+
+                        result_bool = tbl_match(data_tbl=data_tbl_step, tbl_compare=tbl_compare)
+
+                        validation.all_passed = result_bool
+                        validation.n = 1
+                        validation.n_passed = int(result_bool)
+                        validation.n_failed = 1 - result_bool
+
+                        results_tbl = None
+
                     elif assertion_type == "conjointly":
                         results_tbl = conjointly_validation(
                             data_tbl=data_tbl_step,
@@ -10504,7 +12859,7 @@ class Validate:
                     # Try without order_by first (for DataFrames)
                     validation_extract_nw = validation_extract_nw.with_row_index(name="_row_num_")
                 except TypeError:
-                    # LazyFrames require order_by parameter - use first column for ordering
+                    # LazyFrames require order_by parameter: use first column for ordering
                     first_col = validation_extract_nw.columns[0]
                     validation_extract_nw = validation_extract_nw.with_row_index(
                         name="_row_num_", order_by=first_col
@@ -11103,11 +13458,15 @@ class Validate:
             }
         )
 
+        # Define a preprocessing function
+        def filter_by_a_gt_1(df):
+            return df.filter(pl.col("a") > 1)
+
         validation = (
             pb.Validate(data=tbl)
             .col_vals_gt(columns="a", value=0)
             .col_exists(columns="b")
-            .col_vals_lt(columns="b", value=9, pre=lambda df: df.filter(pl.col("a") > 1))
+            .col_vals_lt(columns="b", value=9, pre=filter_by_a_gt_1)
             .interrogate()
         )
         ```
@@ -12244,7 +14603,7 @@ class Validate:
             # Try without order_by first (for DataFrames)
             data_nw = data_nw.with_row_index(name=index_name)
         except TypeError:  # pragma: no cover
-            # LazyFrames require order_by parameter - use first column for ordering
+            # LazyFrames require order_by parameter: use first column for ordering
             first_col = data_nw.columns[0]  # pragma: no cover
             data_nw = data_nw.with_row_index(
                 name=index_name, order_by=first_col
@@ -12261,7 +14620,7 @@ class Validate:
                 # Try without order_by first (for DataFrames)
                 results_tbl = results_tbl.with_row_index(name=index_name)
             except TypeError:  # pragma: no cover
-                # LazyFrames require order_by parameter - use first column for ordering
+                # LazyFrames require order_by parameter: use first column for ordering
                 first_col = results_tbl.columns[0]  # pragma: no cover
                 results_tbl = results_tbl.with_row_index(
                     name=index_name, order_by=first_col
@@ -12301,6 +14660,151 @@ class Validate:
 
         return sundered_tbl
 
+    def get_notes(
+        self, i: int, format: str = "dict"
+    ) -> dict[str, dict[str, str]] | list[str] | None:
+        """
+        Get notes from a validation step by its step number.
+
+        This is a convenience method that retrieves notes from a specific validation step using
+        the step number (1-indexed). It provides easier access to step notes without having to
+        navigate through the `validation_info` list.
+
+        Parameters
+        ----------
+        i
+            The step number (1-indexed) to retrieve notes from. This corresponds to the step
+            numbers shown in validation reports.
+        format
+            The format to return notes in:
+            - `"dict"`: Returns the full notes dictionary (default)
+            - `"markdown"`: Returns a list of markdown-formatted note values
+            - `"text"`: Returns a list of plain text note values
+            - `"keys"`: Returns a list of note keys
+
+        Returns
+        -------
+        dict, list, or None
+            The notes in the requested format, or `None` if the step doesn't exist or has no notes.
+
+        Examples
+        --------
+        ```python
+        import pointblank as pb
+        import polars as pl
+
+        # Create validation with notes
+        validation = pb.Validate(pl.DataFrame({"x": [1, 2, 3]}))
+        validation.col_vals_gt(columns="x", value=0)
+
+        # Add a note to step 1
+        validation.validation_info[0]._add_note(
+            key="info",
+            markdown="This is a **test** note",
+            text="This is a test note"
+        )
+
+        # Interrogate
+        validation.interrogate()
+
+        # Get notes from step 1 using the step number
+        notes = validation.get_notes(1)
+        # Returns: {'info': {'markdown': 'This is a **test** note', 'text': '...'}}
+
+        # Get just the markdown versions
+        markdown_notes = validation.get_notes(1, format="markdown")
+        # Returns: ['This is a **test** note']
+
+        # Get just the keys
+        keys = validation.get_notes(1, format="keys")
+        # Returns: ['info']
+        ```
+        """
+        # Validate step number
+        if not isinstance(i, int) or i < 1:
+            raise ValueError(f"Step number must be a positive integer, got: {i}")
+
+        # Find the validation step with the matching step number
+        # Note: validation_info may contain multiple steps after segmentation,
+        # so we need to find the one with the matching `i` value
+        for validation in self.validation_info:
+            if validation.i == i:
+                return validation._get_notes(format=format)
+
+        # Step not found
+        return None
+
+    def get_note(self, i: int, key: str, format: str = "dict") -> dict[str, str] | str | None:
+        """
+        Get a specific note from a validation step by its step number and note key.
+
+        This method retrieves a specific note from a validation step using the step number
+        (1-indexed) and the note key. It provides easier access to individual notes without having
+        to navigate through the `validation_info` list or retrieve all notes.
+
+        Parameters
+        ----------
+        i
+            The step number (1-indexed) to retrieve the note from. This corresponds to the step
+            numbers shown in validation reports.
+        key
+            The key of the note to retrieve.
+        format
+            The format to return the note in:
+            - `"dict"`: Returns the note as a dictionary with 'markdown' and 'text' keys (default)
+            - `"markdown"`: Returns just the markdown-formatted note value
+            - `"text"`: Returns just the plain text note value
+
+        Returns
+        -------
+        dict, str, or None
+            The note in the requested format, or `None` if the step or note doesn't exist.
+
+        Examples
+        --------
+        ```python
+        import pointblank as pb
+        import polars as pl
+
+        # Create validation with notes
+        validation = pb.Validate(pl.DataFrame({"x": [1, 2, 3]}))
+        validation.col_vals_gt(columns="x", value=0)
+
+        # Add a note to step 1
+        validation.validation_info[0]._add_note(
+            key="threshold_info",
+            markdown="Using **default** thresholds",
+            text="Using default thresholds"
+        )
+
+        # Interrogate
+        validation.interrogate()
+
+        # Get a specific note from step 1 using step number and key
+        note = validation.get_note(1, "threshold_info")
+        # Returns: {'markdown': 'Using **default** thresholds', 'text': '...'}
+
+        # Get just the markdown version
+        markdown = validation.get_note(1, "threshold_info", format="markdown")
+        # Returns: 'Using **default** thresholds'
+
+        # Get just the text version
+        text = validation.get_note(1, "threshold_info", format="text")
+        # Returns: 'Using default thresholds'
+        ```
+        """
+        # Validate step number
+        if not isinstance(i, int) or i < 1:
+            raise ValueError(f"Step number must be a positive integer, got: {i}")
+
+        # Find the validation step with the matching step number
+        for validation in self.validation_info:
+            if validation.i == i:
+                return validation._get_note(key=key, format=format)
+
+        # Step not found
+        return None
+
     def get_tabular_report(
         self, title: str | None = ":default:", incl_header: bool = None, incl_footer: bool = None
     ) -> GT:
@@ -12634,7 +15138,7 @@ class Validate:
                 "col_vals_expr",
             ]:
                 columns_upd.append("&mdash;")
-            elif assertion_type[i] in ["rows_distinct", "rows_complete"]:
+            elif assertion_type[i] in ["rows_distinct", "rows_complete", "prompt"]:
                 if not column:
                     # If there is no column subset, then all columns are used
                     columns_upd.append("ALL COLUMNS")
@@ -12707,6 +15211,9 @@ class Validate:
             elif assertion_type[i] in ["col_vals_expr", "conjointly"]:
                 values_upd.append("COLUMN EXPR")
 
+            elif assertion_type[i] in ["col_vals_increasing", "col_vals_decreasing"]:
+                values_upd.append("")
+
             elif assertion_type[i] in ["row_count_match", "col_count_match"]:
                 count = values[i]["count"]
                 inverse = values[i]["inverse"]
@@ -12716,6 +15223,9 @@ class Validate:
 
                 values_upd.append(str(count))
 
+            elif assertion_type[i] in ["tbl_match"]:
+                values_upd.append("EXTERNAL TABLE")
+
             elif assertion_type[i] in ["specially"]:
                 values_upd.append("EXPR")
 
@@ -12724,9 +15234,21 @@ class Validate:
 
                 values_upd.append(str(pattern))
 
+            elif assertion_type[i] in ["col_vals_within_spec"]:
+                spec = value["spec"]
+
+                values_upd.append(str(spec))
+
+            elif assertion_type[i] in ["prompt"]:  # pragma: no cover
+                # For AI validation, show only the prompt, not the full config
+                if isinstance(value, dict) and "prompt" in value:  # pragma: no cover
+                    values_upd.append(value["prompt"])  # pragma: no cover
+                else:  # pragma: no cover
+                    values_upd.append(str(value))  # pragma: no cover
+
             # If the assertion type is not recognized, add the value as a string
-            else:
-                values_upd.append(str(value))
+            else:  # pragma: no cover
+                values_upd.append(str(value))  # pragma: no cover
 
         # Remove the `inclusive` entry from the dictionary
         validation_info_dict.pop("inclusive")
@@ -12973,6 +15495,7 @@ class Validate:
         validation_info_dict.pop("label")
         validation_info_dict.pop("active")
         validation_info_dict.pop("all_passed")
+        validation_info_dict.pop("notes")
 
         # If no interrogation performed, populate the `i` entry with a sequence of integers
         # from `1` to the number of validation steps
@@ -13157,8 +15680,14 @@ class Validate:
             gt_tbl = gt_tbl.tab_header(title=html(title_text), subtitle=html(combined_subtitle))
 
         if incl_footer:
+            # Add table time as HTML source note
             gt_tbl = gt_tbl.tab_source_note(source_note=html(table_time))
 
+            # Create notes markdown from validation steps and add as separate source note
+            notes_markdown = _create_notes_html(self.validation_info)
+            if notes_markdown:
+                gt_tbl = gt_tbl.tab_source_note(source_note=md(notes_markdown))
+
         # If the interrogation has not been performed, then style the table columns dealing with
         # interrogation data as grayed out
         if not interrogation_performed:
@@ -14265,6 +16794,15 @@ def _create_autobrief_or_failure_text(
     if assertion_type == "specially":
         return _create_text_specially(lang=lang, for_failure=for_failure)
 
+    if assertion_type == "prompt":
+        return _create_text_prompt(
+            lang=lang,
+            prompt=values["prompt"]
+            if isinstance(values, dict) and "prompt" in values
+            else str(values),
+            for_failure=for_failure,
+        )
+
     return None  # pragma: no cover
 
 
@@ -14383,10 +16921,10 @@ def _create_text_regex(
     if isinstance(pattern, dict):
         pattern_str = pattern["pattern"]
         inverse = pattern.get("inverse", False)
-    else:
+    else:  # pragma: no cover
         # For backward compatibility, assume it's just the pattern string
-        pattern_str = pattern
-        inverse = False
+        pattern_str = pattern  # pragma: no cover
+        inverse = False  # pragma: no cover
 
     # Use inverse-specific translations if inverse=True
     if inverse:
@@ -14484,6 +17022,11 @@ def _create_text_specially(lang: str, for_failure: bool = False) -> str:
     return EXPECT_FAIL_TEXT[f"specially_{type_}_text"][lang]
 
 
+def _create_text_prompt(lang: str, prompt: str, for_failure: bool = False) -> str:
+    """Create text for prompt validation: just return the prompt."""
+    return prompt
+
+
 def _prep_column_text(column: str | list[str]) -> str:
     if isinstance(column, list):
         return "`" + str(column[0]) + "`"
@@ -14843,6 +17386,7 @@ def _validation_info_as_dict(validation_info: _ValidationInfo) -> dict:
         "critical",
         "extract",
         "proc_duration_s",
+        "notes",
     ]
 
     # Filter the validation information to include only the selected fields
@@ -15186,6 +17730,14 @@ def _transform_assertion_str(
         # Use Markdown-to-HTML conversion to format the `brief_str` text
         brief_str = [commonmark.commonmark(x) for x in brief_str]
 
+        # Add inline styles to <p> tags for proper rendering in all environments
+        # In some sandboxed HTML environments (e.g., Streamlit), <p> tags don't inherit
+        # font-size from parent divs, so we add inline styles directly to the <p> tags
+        brief_str = [
+            re.sub(r"<p>", r'<p style="font-size: inherit; margin: 0;">', x) if x.strip() else x
+            for x in brief_str
+        ]
+
     # Obtain the number of characters contained in the assertion
     # string; this is important for sizing components appropriately
     assertion_type_nchar = [len(x) for x in assertion_str]
@@ -15314,6 +17866,86 @@ def _create_table_time_html(
     )
 
 
+def _create_notes_html(validation_info: list) -> str:
+    """
+    Create markdown text for validation notes/footnotes.
+
+    This function collects notes from all validation steps and formats them as footnotes
+    for display in the report footer. Each note is prefixed with the step number in
+    uppercase small caps bold formatting, and the note content is rendered as markdown.
+
+    Parameters
+    ----------
+    validation_info
+        List of _ValidationInfo objects from which to extract notes.
+
+    Returns
+    -------
+    str
+        Markdown string containing formatted footnotes, or empty string if no notes exist.
+    """
+    # Collect all notes from validation steps
+    all_notes = []
+    for step in validation_info:
+        if step.notes:
+            for key, content in step.notes.items():
+                # Store note with step number for context
+                all_notes.append(
+                    {
+                        "step": step.i,
+                        "key": key,
+                        "markdown": content["markdown"],
+                        "text": content["text"],
+                    }
+                )
+
+    # If no notes, return empty string
+    if not all_notes:
+        return ""
+
+    # Build markdown for notes section
+    # Start with a styled horizontal rule and bold "Notes" header
+    notes_parts = [
+        (
+            "<hr style='border: none; border-top-width: 1px; border-top-style: dotted; "
+            "border-top-color: #B5B5B5; margin-top: -3px; margin-bottom: 3px;'>"
+        ),
+        "<strong>Notes</strong>",
+        "",
+    ]
+
+    previous_step = None
+    for note in all_notes:
+        # Determine if this is the first note for this step
+        is_first_for_step = note["step"] != previous_step
+        previous_step = note["step"]
+
+        # Format step label with HTML for uppercase small caps bold
+        # Use lighter color for subsequent notes of the same step
+        step_color = "#333333" if is_first_for_step else "#999999"
+        step_label = (
+            f"<span style='font-variant: small-caps; font-weight: bold; font-size: smaller; "
+            f"text-transform: uppercase; color: {step_color};'>Step {note['step']}</span>"
+        )
+
+        # Format note key in monospaced font with smaller size
+        note_key = f"<span style='font-family: \"IBM Plex Mono\", monospace; font-size: smaller;'>({note['key']})</span>"
+
+        # Combine step label, note key, and markdown content
+        note_text = f"{step_label} {note_key} {note['markdown']}"
+        notes_parts.append(note_text)
+        notes_parts.append("")  # Add blank line between notes
+
+    # Remove trailing blank line
+    if notes_parts[-1] == "":
+        notes_parts.pop()
+
+    # Join with newlines to create markdown text
+    notes_markdown = "\n".join(notes_parts)
+
+    return notes_markdown
+
+
 def _create_label_html(label: str | None, start_time: str) -> str:
     if label is None:
         # Remove the decimal and everything beyond that