lifejacket 0.2.1__py3-none-any.whl → 1.0.2__py3-none-any.whl

lifejacket/input_checks.py

@@ -8,7 +8,7 @@ from jax import numpy as jnp
 import pandas as pd
 import plotext as plt
 
-from .constants import InverseStabilizationMethods, SmallSampleCorrections
+from .constants import SmallSampleCorrections
 from .helper_functions import (
     confirm_input_check_result,
 )
@@ -26,12 +26,12 @@ logging.basicConfig(
 
 # TODO: any checks needed here about alg update function type?
 def perform_first_wave_input_checks(
-    study_df,
-    in_study_col_name,
+    analysis_df,
+    active_col_name,
     action_col_name,
     policy_num_col_name,
     calendar_t_col_name,
-    user_id_col_name,
+    subject_id_col_name,
     action_prob_col_name,
     reward_col_name,
     action_prob_func,
@@ -48,11 +48,11 @@ def perform_first_wave_input_checks(
     small_sample_correction,
 ):
     ### Validate algorithm loss/estimating function and args
-    require_alg_update_args_given_for_all_users_at_each_update(
-        study_df, user_id_col_name, alg_update_func_args
+    require_alg_update_args_given_for_all_subjects_at_each_update(
+        analysis_df, subject_id_col_name, alg_update_func_args
     )
-    require_no_policy_numbers_present_in_alg_update_args_but_not_study_df(
-        study_df, policy_num_col_name, alg_update_func_args
+    require_no_policy_numbers_present_in_alg_update_args_but_not_analysis_df(
+        analysis_df, policy_num_col_name, alg_update_func_args
     )
     require_beta_is_1D_array_in_alg_update_args(
         alg_update_func_args, alg_update_func_args_beta_index
@@ -60,11 +60,13 @@ def perform_first_wave_input_checks(
     require_previous_betas_is_2D_array_in_alg_update_args(
         alg_update_func_args, alg_update_func_args_previous_betas_index
     )
-    require_all_policy_numbers_in_study_df_except_possibly_initial_and_fallback_present_in_alg_update_args(
-        study_df, in_study_col_name, policy_num_col_name, alg_update_func_args
+    require_all_policy_numbers_in_analysis_df_except_possibly_initial_and_fallback_present_in_alg_update_args(
+        analysis_df, active_col_name, policy_num_col_name, alg_update_func_args
     )
     confirm_action_probabilities_not_in_alg_update_args_if_index_not_supplied(
-        alg_update_func_args_action_prob_index, suppress_interactive_data_checks
+        alg_update_func_args_action_prob_index,
+        alg_update_func_args_previous_betas_index,
+        suppress_interactive_data_checks,
     )
     require_action_prob_times_given_if_index_supplied(
         alg_update_func_args_action_prob_index,
@@ -80,17 +82,17 @@ def perform_first_wave_input_checks(
     require_previous_betas_match_in_alg_update_args_each_update(
         alg_update_func_args, alg_update_func_args_previous_betas_index
     )
-    require_action_prob_args_in_alg_update_func_correspond_to_study_df(
-        study_df,
+    require_action_prob_args_in_alg_update_func_correspond_to_analysis_df(
+        analysis_df,
         action_prob_col_name,
         calendar_t_col_name,
-        user_id_col_name,
+        subject_id_col_name,
         alg_update_func_args,
         alg_update_func_args_action_prob_index,
         alg_update_func_args_action_prob_times_index,
     )
     require_valid_action_prob_times_given_if_index_supplied(
-        study_df,
+        analysis_df,
         calendar_t_col_name,
         alg_update_func_args,
         alg_update_func_args_action_prob_times_index,
@@ -101,28 +103,28 @@ def perform_first_wave_input_checks(
     )
 
     ### Validate action prob function and args
-    require_action_prob_func_args_given_for_all_users_at_each_decision(
-        study_df, user_id_col_name, action_prob_func_args
+    require_action_prob_func_args_given_for_all_subjects_at_each_decision(
+        analysis_df, subject_id_col_name, action_prob_func_args
     )
     require_action_prob_func_args_given_for_all_decision_times(
-        study_df, calendar_t_col_name, action_prob_func_args
+        analysis_df, calendar_t_col_name, action_prob_func_args
     )
-    require_action_probabilities_in_study_df_can_be_reconstructed(
-        study_df,
+    require_action_probabilities_in_analysis_df_can_be_reconstructed(
+        analysis_df,
         action_prob_col_name,
         calendar_t_col_name,
-        user_id_col_name,
-        in_study_col_name,
+        subject_id_col_name,
+        active_col_name,
         action_prob_func_args,
         action_prob_func,
     )
 
     require_out_of_study_decision_times_are_exactly_blank_action_prob_args_times(
-        study_df,
+        analysis_df,
         calendar_t_col_name,
         action_prob_func_args,
-        in_study_col_name,
-        user_id_col_name,
+        active_col_name,
+        subject_id_col_name,
     )
     require_beta_is_1D_array_in_action_prob_args(
         action_prob_func_args, action_prob_func_args_beta_index
@@ -131,13 +133,13 @@ def perform_first_wave_input_checks(
         action_prob_func_args, action_prob_func_args_beta_index
     )
 
-    ### Validate study_df
-    verify_study_df_summary_satisfactory(
-        study_df,
-        user_id_col_name,
+    ### Validate analysis_df
+    verify_analysis_df_summary_satisfactory(
+        analysis_df,
+        subject_id_col_name,
         policy_num_col_name,
         calendar_t_col_name,
-        in_study_col_name,
+        active_col_name,
         action_prob_col_name,
         reward_col_name,
         beta_dim,
@@ -145,46 +147,46 @@ def perform_first_wave_input_checks(
         suppress_interactive_data_checks,
     )
 
-    require_all_users_have_all_times_in_study_df(
-        study_df, calendar_t_col_name, user_id_col_name
+    require_all_subjects_have_all_times_in_analysis_df(
+        analysis_df, calendar_t_col_name, subject_id_col_name
     )
-    require_all_named_columns_present_in_study_df(
-        study_df,
-        in_study_col_name,
+    require_all_named_columns_present_in_analysis_df(
+        analysis_df,
+        active_col_name,
         action_col_name,
         policy_num_col_name,
         calendar_t_col_name,
-        user_id_col_name,
+        subject_id_col_name,
         action_prob_col_name,
     )
-    require_all_named_columns_not_object_type_in_study_df(
-        study_df,
-        in_study_col_name,
+    require_all_named_columns_not_object_type_in_analysis_df(
+        analysis_df,
+        active_col_name,
         action_col_name,
         policy_num_col_name,
         calendar_t_col_name,
-        user_id_col_name,
+        subject_id_col_name,
         action_prob_col_name,
     )
-    require_binary_actions(study_df, in_study_col_name, action_col_name)
-    require_binary_in_study_indicators(study_df, in_study_col_name)
+    require_binary_actions(analysis_df, active_col_name, action_col_name)
+    require_binary_active_indicators(analysis_df, active_col_name)
     require_consecutive_integer_policy_numbers(
-        study_df, in_study_col_name, policy_num_col_name
+        analysis_df, active_col_name, policy_num_col_name
     )
-    require_consecutive_integer_calendar_times(study_df, calendar_t_col_name)
-    require_hashable_user_ids(study_df, in_study_col_name, user_id_col_name)
-    require_action_probabilities_in_range_0_to_1(study_df, action_prob_col_name)
+    require_consecutive_integer_calendar_times(analysis_df, calendar_t_col_name)
+    require_hashable_subject_ids(analysis_df, active_col_name, subject_id_col_name)
+    require_action_probabilities_in_range_0_to_1(analysis_df, action_prob_col_name)
 
     ### Validate theta estimation
     require_theta_is_1D_array(theta_est)
 
 
 def perform_alg_only_input_checks(
-    study_df,
-    in_study_col_name,
+    analysis_df,
+    active_col_name,
     policy_num_col_name,
     calendar_t_col_name,
-    user_id_col_name,
+    subject_id_col_name,
     action_prob_col_name,
     action_prob_func,
     action_prob_func_args,
@@ -193,20 +195,23 @@ def perform_alg_only_input_checks(
     alg_update_func_args_beta_index,
     alg_update_func_args_action_prob_index,
     alg_update_func_args_action_prob_times_index,
+    alg_update_func_args_previous_betas_index,
     suppress_interactive_data_checks,
 ):
     ### Validate algorithm loss/estimating function and args
-    require_alg_update_args_given_for_all_users_at_each_update(
-        study_df, user_id_col_name, alg_update_func_args
+    require_alg_update_args_given_for_all_subjects_at_each_update(
+        analysis_df, subject_id_col_name, alg_update_func_args
     )
     require_beta_is_1D_array_in_alg_update_args(
         alg_update_func_args, alg_update_func_args_beta_index
     )
-    require_all_policy_numbers_in_study_df_except_possibly_initial_and_fallback_present_in_alg_update_args(
-        study_df, in_study_col_name, policy_num_col_name, alg_update_func_args
+    require_all_policy_numbers_in_analysis_df_except_possibly_initial_and_fallback_present_in_alg_update_args(
+        analysis_df, active_col_name, policy_num_col_name, alg_update_func_args
     )
     confirm_action_probabilities_not_in_alg_update_args_if_index_not_supplied(
-        alg_update_func_args_action_prob_index, suppress_interactive_data_checks
+        alg_update_func_args_action_prob_index,
+        alg_update_func_args_previous_betas_index,
+        suppress_interactive_data_checks,
     )
     require_action_prob_times_given_if_index_supplied(
         alg_update_func_args_action_prob_index,
@@ -219,45 +224,45 @@ def perform_alg_only_input_checks(
     require_betas_match_in_alg_update_args_each_update(
         alg_update_func_args, alg_update_func_args_beta_index
     )
-    require_action_prob_args_in_alg_update_func_correspond_to_study_df(
-        study_df,
+    require_action_prob_args_in_alg_update_func_correspond_to_analysis_df(
+        analysis_df,
         action_prob_col_name,
         calendar_t_col_name,
-        user_id_col_name,
+        subject_id_col_name,
         alg_update_func_args,
         alg_update_func_args_action_prob_index,
         alg_update_func_args_action_prob_times_index,
     )
     require_valid_action_prob_times_given_if_index_supplied(
-        study_df,
+        analysis_df,
         calendar_t_col_name,
         alg_update_func_args,
         alg_update_func_args_action_prob_times_index,
     )
 
     ### Validate action prob function and args
-    require_action_prob_func_args_given_for_all_users_at_each_decision(
-        study_df, user_id_col_name, action_prob_func_args
+    require_action_prob_func_args_given_for_all_subjects_at_each_decision(
+        analysis_df, subject_id_col_name, action_prob_func_args
     )
     require_action_prob_func_args_given_for_all_decision_times(
-        study_df, calendar_t_col_name, action_prob_func_args
+        analysis_df, calendar_t_col_name, action_prob_func_args
     )
-    require_action_probabilities_in_study_df_can_be_reconstructed(
-        study_df,
+    require_action_probabilities_in_analysis_df_can_be_reconstructed(
+        analysis_df,
         action_prob_col_name,
         calendar_t_col_name,
-        user_id_col_name,
-        in_study_col_name,
+        subject_id_col_name,
+        active_col_name,
         action_prob_func_args,
         action_prob_func=action_prob_func,
     )
 
     require_out_of_study_decision_times_are_exactly_blank_action_prob_args_times(
-        study_df,
+        analysis_df,
         calendar_t_col_name,
         action_prob_func_args,
-        in_study_col_name,
-        user_id_col_name,
+        active_col_name,
+        subject_id_col_name,
     )
     require_beta_is_1D_array_in_action_prob_args(
         action_prob_func_args, action_prob_func_args_beta_index
@@ -268,94 +273,96 @@ def perform_alg_only_input_checks(
 
 
 # TODO: Give a hard-to-use option to loosen this check somehow
-def require_action_probabilities_in_study_df_can_be_reconstructed(
-    study_df,
+def require_action_probabilities_in_analysis_df_can_be_reconstructed(
+    analysis_df,
     action_prob_col_name,
     calendar_t_col_name,
-    user_id_col_name,
-    in_study_col_name,
+    subject_id_col_name,
+    active_col_name,
     action_prob_func_args,
     action_prob_func,
 ):
     """
-    Check that the action probabilities in the study dataframe can be reconstructed from the supplied
+    Check that the action probabilities in the analysis DataFrame can be reconstructed from the supplied
     action probability function and its arguments.
 
     NOTE THAT THIS IS A HARD FAILURE IF THE RECONSTRUCTION DOESN'T PASS.
     """
     logger.info("Reconstructing action probabilities from function and arguments.")
 
-    in_study_df = study_df[study_df[in_study_col_name] == 1]
-    reconstructed_action_probs = in_study_df.apply(
+    active_df = analysis_df[analysis_df[active_col_name] == 1]
+    reconstructed_action_probs = active_df.apply(
         lambda row: action_prob_func(
-            *action_prob_func_args[row[calendar_t_col_name]][row[user_id_col_name]]
+            *action_prob_func_args[row[calendar_t_col_name]][row[subject_id_col_name]]
         ),
         axis=1,
     )
 
     np.testing.assert_allclose(
-        in_study_df[action_prob_col_name].to_numpy(dtype="float64"),
+        active_df[action_prob_col_name].to_numpy(dtype="float64"),
         reconstructed_action_probs.to_numpy(dtype="float64"),
         atol=1e-6,
     )
 
 
-def require_all_users_have_all_times_in_study_df(
-    study_df, calendar_t_col_name, user_id_col_name
+def require_all_subjects_have_all_times_in_analysis_df(
+    analysis_df, calendar_t_col_name, subject_id_col_name
 ):
-    logger.info("Checking that all users have the same set of unique calendar times.")
+    logger.info(
+        "Checking that all subjects have the same set of unique calendar times."
+    )
     # Get the unique calendar times
-    unique_calendar_times = set(study_df[calendar_t_col_name].unique())
+    unique_calendar_times = set(analysis_df[calendar_t_col_name].unique())
 
-    # Group by user ID and aggregate the unique calendar times for each user
-    user_calendar_times = study_df.groupby(user_id_col_name)[calendar_t_col_name].apply(
-        set
-    )
+    # Group by subject ID and aggregate the unique calendar times for each subject
+    subject_calendar_times = analysis_df.groupby(subject_id_col_name)[
+        calendar_t_col_name
+    ].apply(set)
 
-    # Check if all users have the same set of unique calendar times
-    if not user_calendar_times.apply(lambda x: x == unique_calendar_times).all():
+    # Check if all subjects have the same set of unique calendar times
+    if not subject_calendar_times.apply(lambda x: x == unique_calendar_times).all():
         raise AssertionError(
-            "Not all users have all calendar times in the study dataframe. Please see the contract for details."
+            "Not all subjects have all calendar times in the analysis DataFrame. Please see the contract for details."
         )
 
 
-def require_alg_update_args_given_for_all_users_at_each_update(
-    study_df, user_id_col_name, alg_update_func_args
+def require_alg_update_args_given_for_all_subjects_at_each_update(
+    analysis_df, subject_id_col_name, alg_update_func_args
 ):
     logger.info(
-        "Checking that algorithm update function args are given for all users at each update."
+        "Checking that algorithm update function args are given for all subjects at each update."
     )
-    all_user_ids = set(study_df[user_id_col_name].unique())
+    all_subject_ids = set(analysis_df[subject_id_col_name].unique())
     for policy_num in alg_update_func_args:
         assert (
-            set(alg_update_func_args[policy_num].keys()) == all_user_ids
-        ), f"Not all users present in algorithm update function args for policy number {policy_num}. Please see the contract for details."
+            set(alg_update_func_args[policy_num].keys()) == all_subject_ids
+        ), f"Not all subjects present in algorithm update function args for policy number {policy_num}. Please see the contract for details."
 
 
-def require_action_prob_args_in_alg_update_func_correspond_to_study_df(
-    study_df,
+def require_action_prob_args_in_alg_update_func_correspond_to_analysis_df(
+    analysis_df,
     action_prob_col_name,
     calendar_t_col_name,
-    user_id_col_name,
+    subject_id_col_name,
     alg_update_func_args,
     alg_update_func_args_action_prob_index,
     alg_update_func_args_action_prob_times_index,
 ):
     logger.info(
         "Checking that the action probabilities supplied in the algorithm update function args, if"
-        " any, correspond to those in the study dataframe for the corresponding users and decision"
+        " any, correspond to those in the analysis DataFrame for the corresponding subjects and decision"
         " times."
     )
     if alg_update_func_args_action_prob_index < 0:
         return
 
     # Precompute a lookup dictionary for faster access
-    study_df_lookup = study_df.set_index([calendar_t_col_name, user_id_col_name])[
-        action_prob_col_name
-    ].to_dict()
+    analysis_df_lookup = analysis_df.set_index(
+        [calendar_t_col_name, subject_id_col_name]
+    )[action_prob_col_name].to_dict()
 
-    for policy_num, user_args in alg_update_func_args.items():
-        for user_id, args in user_args.items():
+    for policy_num, subject_args in alg_update_func_args.items():
+        for subject_id, args in subject_args.items():
             if not args:
                 continue
             arg_action_probs = args[alg_update_func_args_action_prob_index]
@@ -364,43 +371,43 @@ def require_action_prob_args_in_alg_update_func_correspond_to_study_df(
             ].flatten()
 
             # Use the precomputed lookup dictionary
-            study_df_action_probs = [
-                study_df_lookup[(decision_time.item(), user_id)]
+            analysis_df_action_probs = [
+                analysis_df_lookup[(decision_time.item(), subject_id)]
                 for decision_time in action_prob_times
             ]
 
             assert np.allclose(
                 arg_action_probs.flatten(),
-                study_df_action_probs,
+                analysis_df_action_probs,
             ), (
-                f"There is a mismatch for user {user_id} between the action probabilities supplied"
+                f"There is a mismatch for subject {subject_id} between the action probabilities supplied"
                 f" in the args to the algorithm update function at policy {policy_num} and those in"
-                " the study dataframe for the supplied times. Please see the contract for details."
+                " the analysis DataFrame for the supplied times. Please see the contract for details."
             )
 
 
-def require_action_prob_func_args_given_for_all_users_at_each_decision(
-    study_df,
-    user_id_col_name,
+def require_action_prob_func_args_given_for_all_subjects_at_each_decision(
+    analysis_df,
+    subject_id_col_name,
     action_prob_func_args,
 ):
     logger.info(
-        "Checking that action prob function args are given for all users at each decision time."
+        "Checking that action prob function args are given for all subjects at each decision time."
     )
-    all_user_ids = set(study_df[user_id_col_name].unique())
+    all_subject_ids = set(analysis_df[subject_id_col_name].unique())
     for decision_time in action_prob_func_args:
         assert (
-            set(action_prob_func_args[decision_time].keys()) == all_user_ids
-        ), f"Not all users present in algorithm update function args for decision time {decision_time}. Please see the contract for details."
+            set(action_prob_func_args[decision_time].keys()) == all_subject_ids
+        ), f"Not all subjects present in algorithm update function args for decision time {decision_time}. Please see the contract for details."
 
 
 def require_action_prob_func_args_given_for_all_decision_times(
-    study_df, calendar_t_col_name, action_prob_func_args
+    analysis_df, calendar_t_col_name, action_prob_func_args
 ):
     logger.info(
         "Checking that action prob function args are given for all decision times."
     )
-    all_times = set(study_df[calendar_t_col_name].unique())
+    all_times = set(analysis_df[calendar_t_col_name].unique())
 
     assert (
         set(action_prob_func_args.keys()) == all_times
@@ -408,106 +415,112 @@ def require_action_prob_func_args_given_for_all_decision_times(
 
 
 def require_out_of_study_decision_times_are_exactly_blank_action_prob_args_times(
-    study_df: pd.DataFrame,
+    analysis_df: pd.DataFrame,
     calendar_t_col_name: str,
     action_prob_func_args: dict[str, dict[str, tuple[Any, ...]]],
-    in_study_col_name,
-    user_id_col_name,
+    active_col_name,
+    subject_id_col_name,
 ):
     logger.info(
-        "Checking that action probability function args are blank for exactly the times each user"
-        " is not in the study according to the study dataframe."
+        "Checking that action probability function args are blank for exactly the times each subject"
+        "is not in the study according to the analysis DataFrame."
     )
-    out_of_study_df = study_df[study_df[in_study_col_name] == 0]
-    out_of_study_times_by_user_according_to_study_df = (
-        out_of_study_df.groupby(user_id_col_name)[calendar_t_col_name]
+    inactive_df = analysis_df[analysis_df[active_col_name] == 0]
+    inactive_times_by_subject_according_to_analysis_df = (
+        inactive_df.groupby(subject_id_col_name)[calendar_t_col_name]
         .apply(set)
         .to_dict()
     )
 
-    out_of_study_times_by_user_according_to_action_prob_func_args = (
+    inactive_times_by_subject_according_to_action_prob_func_args = (
         collections.defaultdict(set)
     )
-    for decision_time, action_prob_args_by_user in action_prob_func_args.items():
-        for user_id, action_prob_args in action_prob_args_by_user.items():
+    for decision_time, action_prob_args_by_subject in action_prob_func_args.items():
+        for subject_id, action_prob_args in action_prob_args_by_subject.items():
             if not action_prob_args:
-                out_of_study_times_by_user_according_to_action_prob_func_args[
-                    user_id
+                inactive_times_by_subject_according_to_action_prob_func_args[
+                    subject_id
                 ].add(decision_time)
 
     assert (
-        out_of_study_times_by_user_according_to_study_df
-        == out_of_study_times_by_user_according_to_action_prob_func_args
+        inactive_times_by_subject_according_to_analysis_df
+        == inactive_times_by_subject_according_to_action_prob_func_args
     ), (
-        "Out-of-study decision times according to the study dataframe do not match up with the"
-        " times for which action probability arguments are blank for all users. Please see the"
+        "Inactive decision times according to the analysis DataFrame do not match up with the"
+        " times for which action probability arguments are blank for all subjects. Please see the"
         " contract for details."
     )
 
 
-def require_all_named_columns_present_in_study_df(
-    study_df,
-    in_study_col_name,
+def require_all_named_columns_present_in_analysis_df(
+    analysis_df,
+    active_col_name,
     action_col_name,
     policy_num_col_name,
     calendar_t_col_name,
-    user_id_col_name,
+    subject_id_col_name,
     action_prob_col_name,
 ):
-    logger.info("Checking that all named columns are present in the study dataframe.")
+    logger.info(
+        "Checking that all named columns are present in the analysis DataFrame."
+    )
+    assert (
+        active_col_name in analysis_df.columns
+    ), f"{active_col_name} not in analysis DataFrame."
+    assert (
+        action_col_name in analysis_df.columns
+    ), f"{action_col_name} not in analysis DataFrame."
     assert (
-        in_study_col_name in study_df.columns
-    ), f"{in_study_col_name} not in study df."
-    assert action_col_name in study_df.columns, f"{action_col_name} not in study df."
+        policy_num_col_name in analysis_df.columns
+    ), f"{policy_num_col_name} not in analysis DataFrame."
     assert (
-        policy_num_col_name in study_df.columns
-    ), f"{policy_num_col_name} not in study df."
+        calendar_t_col_name in analysis_df.columns
+    ), f"{calendar_t_col_name} not in analysis DataFrame."
     assert (
-        calendar_t_col_name in study_df.columns
-    ), f"{calendar_t_col_name} not in study df."
-    assert user_id_col_name in study_df.columns, f"{user_id_col_name} not in study df."
+        subject_id_col_name in analysis_df.columns
+    ), f"{subject_id_col_name} not in analysis DataFrame."
     assert (
-        action_prob_col_name in study_df.columns
-    ), f"{action_prob_col_name} not in study df."
+        action_prob_col_name in analysis_df.columns
+    ), f"{action_prob_col_name} not in analysis DataFrame."
 
 
-def require_all_named_columns_not_object_type_in_study_df(
-    study_df,
-    in_study_col_name,
+def require_all_named_columns_not_object_type_in_analysis_df(
+    analysis_df,
+    active_col_name,
     action_col_name,
     policy_num_col_name,
     calendar_t_col_name,
-    user_id_col_name,
+    subject_id_col_name,
     action_prob_col_name,
 ):
     logger.info("Checking that all named columns are not type object.")
     for colname in (
-        in_study_col_name,
+        active_col_name,
         action_col_name,
         policy_num_col_name,
         calendar_t_col_name,
-        user_id_col_name,
+        subject_id_col_name,
         action_prob_col_name,
     ):
         assert (
-            study_df[colname].dtype != "object"
-        ), f"At least {colname} is of object type in study df."
+            analysis_df[colname].dtype != "object"
+        ), f"At least {colname} is of object type in analysis DataFrame."
 
 
-def require_binary_actions(study_df, in_study_col_name, action_col_name):
+def require_binary_actions(analysis_df, active_col_name, action_col_name):
     logger.info("Checking that actions are binary.")
     assert (
-        study_df[study_df[in_study_col_name] == 1][action_col_name]
+        analysis_df[analysis_df[active_col_name] == 1][action_col_name]
         .astype("int64")
         .isin([0, 1])
         .all()
     ), "Actions are not binary."
 
 
-def require_binary_in_study_indicators(study_df, in_study_col_name):
-    logger.info("Checking that in-study indicators are binary.")
+def require_binary_active_indicators(analysis_df, active_col_name):
+    logger.info("Checking that active indicators are binary.")
     assert (
-        study_df[study_df[in_study_col_name] == 1][in_study_col_name]
+        analysis_df[analysis_df[active_col_name] == 1][active_col_name]
         .astype("int64")
         .isin([0, 1])
         .all()
@@ -515,7 +528,7 @@ def require_binary_in_study_indicators(study_df, in_study_col_name):
 
 
 def require_consecutive_integer_policy_numbers(
-    study_df, in_study_col_name, policy_num_col_name
+    analysis_df, active_col_name, policy_num_col_name
 ):
     # TODO: This is a somewhat rough check of this, could also check nondecreasing temporally
 
@@ -523,8 +536,8 @@ def require_consecutive_integer_policy_numbers(
         "Checking that in-study, non-fallback policy numbers are consecutive integers."
     )
 
-    in_study_df = study_df[study_df[in_study_col_name] == 1]
-    nonnegative_policy_df = in_study_df[in_study_df[policy_num_col_name] >= 0]
+    active_df = analysis_df[analysis_df[active_col_name] == 1]
+    nonnegative_policy_df = active_df[active_df[policy_num_col_name] >= 0]
     # Ideally we actually have integers, but for legacy reasons we will support
     # floats as well.
     if nonnegative_policy_df[policy_num_col_name].dtype == "float64":
@@ -540,78 +553,83 @@ def require_consecutive_integer_policy_numbers(
     ), "Policy numbers are not consecutive integers."
 
 
-def require_consecutive_integer_calendar_times(study_df, calendar_t_col_name):
+def require_consecutive_integer_calendar_times(analysis_df, calendar_t_col_name):
     # This is a somewhat rough check of this, more like checking there are no
-    # gaps in the integers covered.  But we have other checks that all users
+    # gaps in the integers covered.  But we have other checks that all subjects
     # have same times, etc.
-    # Note these times should be well-formed even when the user is not in the study.
+    # Note these times should be well-formed even when the subject is not in the study.
     logger.info("Checking that calendar times are consecutive integers.")
     assert np.array_equal(
-        study_df[calendar_t_col_name].unique(),
+        analysis_df[calendar_t_col_name].unique(),
         range(
-            study_df[calendar_t_col_name].min(), study_df[calendar_t_col_name].max() + 1
+            analysis_df[calendar_t_col_name].min(),
+            analysis_df[calendar_t_col_name].max() + 1,
         ),
     ), "Calendar times are not consecutive integers."
 
 
-def require_hashable_user_ids(study_df, in_study_col_name, user_id_col_name):
-    logger.info("Checking that user IDs are hashable.")
+def require_hashable_subject_ids(analysis_df, active_col_name, subject_id_col_name):
+    logger.info("Checking that subject IDs are hashable.")
     isinstance(
-        study_df[study_df[in_study_col_name] == 1][user_id_col_name][0],
+        analysis_df[analysis_df[active_col_name] == 1][subject_id_col_name][0],
         collections.abc.Hashable,
     )
 
 
-def require_action_probabilities_in_range_0_to_1(study_df, action_prob_col_name):
+def require_action_probabilities_in_range_0_to_1(analysis_df, action_prob_col_name):
     logger.info("Checking that action probabilities are in the interval (0, 1).")
-    study_df[action_prob_col_name].between(0, 1, inclusive="neither").all()
+    analysis_df[action_prob_col_name].between(0, 1, inclusive="neither").all()
 
 
-def require_no_policy_numbers_present_in_alg_update_args_but_not_study_df(
-    study_df, policy_num_col_name, alg_update_func_args
+def require_no_policy_numbers_present_in_alg_update_args_but_not_analysis_df(
+    analysis_df, policy_num_col_name, alg_update_func_args
 ):
     logger.info(
-        "Checking that policy numbers in algorithm update function args are present in the study dataframe."
+        "Checking that policy numbers in algorithm update function args are present in the analysis DataFrame."
     )
     alg_update_policy_nums = sorted(alg_update_func_args.keys())
-    study_df_policy_nums = sorted(study_df[policy_num_col_name].unique())
-    assert set(alg_update_policy_nums).issubset(set(study_df_policy_nums)), (
-        f"There are policy numbers present in algorithm update function args but not in the study dataframe. "
+    analysis_df_policy_nums = sorted(analysis_df[policy_num_col_name].unique())
+    assert set(alg_update_policy_nums).issubset(set(analysis_df_policy_nums)), (
+        f"There are policy numbers present in algorithm update function args but not in the analysis DataFrame. "
         f"\nalg_update_func_args policy numbers: {alg_update_policy_nums}"
-        f"\nstudy_df policy numbers: {study_df_policy_nums}.\nPlease see the contract for details."
+        f"\nanalysis_df policy numbers: {analysis_df_policy_nums}.\nPlease see the contract for details."
     )
 
 
-def require_all_policy_numbers_in_study_df_except_possibly_initial_and_fallback_present_in_alg_update_args(
-    study_df, in_study_col_name, policy_num_col_name, alg_update_func_args
+def require_all_policy_numbers_in_analysis_df_except_possibly_initial_and_fallback_present_in_alg_update_args(
+    analysis_df, active_col_name, policy_num_col_name, alg_update_func_args
 ):
     logger.info(
-        "Checking that all policy numbers in the study dataframe are present in the algorithm update function args."
+        "Checking that all policy numbers in the analysis DataFrame are present in the algorithm update function args."
     )
-    in_study_df = study_df[study_df[in_study_col_name] == 1]
+    active_df = analysis_df[analysis_df[active_col_name] == 1]
     # Get the number of the initial policy. 0 is recommended but not required.
-    min_nonnegative_policy_number = in_study_df[in_study_df[policy_num_col_name] >= 0][
+    min_nonnegative_policy_number = active_df[active_df[policy_num_col_name] >= 0][
         policy_num_col_name
     ]
     assert set(
-        in_study_df[in_study_df[policy_num_col_name] > min_nonnegative_policy_number][
+        active_df[active_df[policy_num_col_name] > min_nonnegative_policy_number][
             policy_num_col_name
         ].unique()
     ).issubset(
         alg_update_func_args.keys()
-    ), f"There are non-fallback, non-initial policy numbers in the study dataframe that are not in the update function args: {set(in_study_df[in_study_df[policy_num_col_name] > 0][policy_num_col_name].unique()) - set(alg_update_func_args.keys())}. Please see the contract for details."
+    ), f"There are non-fallback, non-initial policy numbers in the analysis DataFrame that are not in the update function args: {set(active_df[active_df[policy_num_col_name] > 0][policy_num_col_name].unique()) - set(alg_update_func_args.keys())}. Please see the contract for details."
 
 
 def confirm_action_probabilities_not_in_alg_update_args_if_index_not_supplied(
     alg_update_func_args_action_prob_index,
+    alg_update_func_args_previous_betas_index,
     suppress_interactive_data_checks,
 ):
     logger.info(
         "Confirming that action probabilities are not in algorithm update function args IF their index is not specified"
     )
-    if alg_update_func_args_action_prob_index < 0:
+    if (
+        alg_update_func_args_action_prob_index < 0
+        and alg_update_func_args_previous_betas_index < 0
+    ):
         confirm_input_check_result(
-            "\nYou specified that the algorithm update function supplied does not have action probabilities as one of its arguments. Please verify this is correct.\n\nContinue? (y/n)\n",
+            "\nYou specified that the algorithm update function supplied does not have action probabilities or previous betas in its arguments. Please verify this is correct.\n\nContinue? (y/n)\n",
             suppress_interactive_data_checks,
         )
 
@@ -630,20 +648,6 @@ def confirm_no_small_sample_correction_desired_if_not_requested(
         )
 
 
-def confirm_no_adaptive_bread_inverse_stabilization_method_desired_if_not_requested(
-    adaptive_bread_inverse_stabilization_method,
-    suppress_interactive_data_checks,
-):
-    logger.info(
-        "Confirming that no adaptive bread inverse stabilization method is desired if it's not requested."
-    )
-    if adaptive_bread_inverse_stabilization_method == InverseStabilizationMethods.NONE:
-        confirm_input_check_result(
-            "\nYou specified that you would not like to perform any inverse stabilization while forming the adaptive variance. This is not usually recommended. Please verify that it is correct or select one of the available options.\n\nContinue? (y/n)\n",
-            suppress_interactive_data_checks,
-        )
-
-
 def require_action_prob_times_given_if_index_supplied(
     alg_update_func_args_action_prob_index,
     alg_update_func_args_action_prob_times_index,
@@ -672,28 +676,29 @@ def require_beta_is_1D_array_in_alg_update_args(
     alg_update_func_args, alg_update_func_args_beta_index
 ):
     for policy_num in alg_update_func_args:
-        for user_id in alg_update_func_args[policy_num]:
-            if not alg_update_func_args[policy_num][user_id]:
+        for subject_id in alg_update_func_args[policy_num]:
+            if not alg_update_func_args[policy_num][subject_id]:
                 continue
             assert (
-                alg_update_func_args[policy_num][user_id][
+                alg_update_func_args[policy_num][subject_id][
                     alg_update_func_args_beta_index
                 ].ndim
                 == 1
             ), "Beta is not a 1D array in the algorithm update function args."
 
+
 def require_previous_betas_is_2D_array_in_alg_update_args(
     alg_update_func_args, alg_update_func_args_previous_betas_index
 ):
     if alg_update_func_args_previous_betas_index < 0:
         return
-    
+
     for policy_num in alg_update_func_args:
-        for user_id in alg_update_func_args[policy_num]:
-            if not alg_update_func_args[policy_num][user_id]:
+        for subject_id in alg_update_func_args[policy_num]:
+            if not alg_update_func_args[policy_num][subject_id]:
                 continue
             assert (
-                alg_update_func_args[policy_num][user_id][
+                alg_update_func_args[policy_num][subject_id][
                     alg_update_func_args_previous_betas_index
                 ].ndim
                 == 2
@@ -704,11 +709,11 @@ def require_beta_is_1D_array_in_action_prob_args(
     action_prob_func_args, action_prob_func_args_beta_index
 ):
     for decision_time in action_prob_func_args:
-        for user_id in action_prob_func_args[decision_time]:
-            if not action_prob_func_args[decision_time][user_id]:
+        for subject_id in action_prob_func_args[decision_time]:
+            if not action_prob_func_args[decision_time][subject_id]:
                 continue
             assert (
-                action_prob_func_args[decision_time][user_id][
+                action_prob_func_args[decision_time][subject_id][
                     action_prob_func_args_beta_index
                 ].ndim
                 == 1
@@ -719,12 +724,12 @@ def require_theta_is_1D_array(theta_est):
     assert theta_est.ndim == 1, "Theta is not a 1D array."
 
 
-def verify_study_df_summary_satisfactory(
-    study_df,
-    user_id_col_name,
+def verify_analysis_df_summary_satisfactory(
+    analysis_df,
+    subject_id_col_name,
     policy_num_col_name,
     calendar_t_col_name,
-    in_study_col_name,
+    active_col_name,
     action_prob_col_name,
     reward_col_name,
     beta_dim,
@@ -732,43 +737,41 @@ def verify_study_df_summary_satisfactory(
     suppress_interactive_data_checks,
 ):
 
-    in_study_df = study_df[study_df[in_study_col_name] == 1]
-    num_users = in_study_df[user_id_col_name].nunique()
-    num_non_initial_or_fallback_policies = in_study_df[
-        in_study_df[policy_num_col_name] > 0
+    active_df = analysis_df[analysis_df[active_col_name] == 1]
+    num_subjects = active_df[subject_id_col_name].nunique()
+    num_non_initial_or_fallback_policies = active_df[
+        active_df[policy_num_col_name] > 0
     ][policy_num_col_name].nunique()
     num_decision_times_with_fallback_policies = len(
-        in_study_df[in_study_df[policy_num_col_name] < 0]
+        active_df[active_df[policy_num_col_name] < 0]
     )
-    num_decision_times = in_study_df[calendar_t_col_name].nunique()
-    avg_decisions_per_user = len(in_study_df) / num_users
+    num_decision_times = active_df[calendar_t_col_name].nunique()
+    avg_decisions_per_subject = len(active_df) / num_subjects
     num_decision_times_with_multiple_policies = (
-        in_study_df[in_study_df[policy_num_col_name] >= 0]
+        active_df[active_df[policy_num_col_name] >= 0]
         .groupby(calendar_t_col_name)[policy_num_col_name]
         .nunique()
         > 1
     ).sum()
-    min_action_prob = in_study_df[action_prob_col_name].min()
-    max_action_prob = in_study_df[action_prob_col_name].max()
-    min_non_fallback_policy_num = in_study_df[in_study_df[policy_num_col_name] >= 0][
+    min_action_prob = active_df[action_prob_col_name].min()
+    max_action_prob = active_df[action_prob_col_name].max()
+    min_non_fallback_policy_num = active_df[active_df[policy_num_col_name] >= 0][
         policy_num_col_name
     ].min()
     num_data_points_before_first_update = len(
-        in_study_df[in_study_df[policy_num_col_name] == min_non_fallback_policy_num]
+        active_df[active_df[policy_num_col_name] == min_non_fallback_policy_num]
     )
 
     median_action_probabilities = (
-        in_study_df.groupby(calendar_t_col_name)[action_prob_col_name]
-        .median()
-        .to_numpy()
+        active_df.groupby(calendar_t_col_name)[action_prob_col_name].median().to_numpy()
     )
-    quartiles = in_study_df.groupby(calendar_t_col_name)[action_prob_col_name].quantile(
+    quartiles = active_df.groupby(calendar_t_col_name)[action_prob_col_name].quantile(
         [0.25, 0.75]
     )
     q25_action_probabilities = quartiles.xs(0.25, level=1).to_numpy()
     q75_action_probabilities = quartiles.xs(0.75, level=1).to_numpy()
 
-    avg_rewards = in_study_df.groupby(calendar_t_col_name)[reward_col_name].mean()
+    avg_rewards = active_df.groupby(calendar_t_col_name)[reward_col_name].mean()
 
     # Plot action probability quartile trajectories
     plt.clear_figure()
@@ -807,11 +810,11 @@ def verify_study_df_summary_satisfactory(
     avg_reward_trajectory_plot = plt.build()
 
     confirm_input_check_result(
-        f"\nYou provided a study dataframe reflecting a study with"
-        f"\n* {num_users} users"
+        f"\nYou provided an analysis DataFrame reflecting a study with"
+        f"\n* {num_subjects} subjects"
         f"\n* {num_non_initial_or_fallback_policies} policy updates"
-        f"\n* {num_decision_times} decision times, for an average of {avg_decisions_per_user}"
-        f" decisions per user"
+        f"\n* {num_decision_times} decision times, for an average of {avg_decisions_per_subject}"
+        f" decisions per subject"
         f"\n* RL parameters of dimension {beta_dim} per update"
         f"\n* Inferential target of dimension {theta_dim}"
         f"\n* {num_data_points_before_first_update} data points before the first update"
@@ -834,14 +837,14 @@ def require_betas_match_in_alg_update_args_each_update(
     alg_update_func_args, alg_update_func_args_beta_index
 ):
     logger.info(
-        "Checking that betas match across users for each update in the algorithm update function args."
+        "Checking that betas match across subjects for each update in the algorithm update function args."
     )
     for policy_num in alg_update_func_args:
         first_beta = None
-        for user_id in alg_update_func_args[policy_num]:
-            if not alg_update_func_args[policy_num][user_id]:
+        for subject_id in alg_update_func_args[policy_num]:
+            if not alg_update_func_args[policy_num][subject_id]:
                 continue
-            beta = alg_update_func_args[policy_num][user_id][
+            beta = alg_update_func_args[policy_num][subject_id][
                 alg_update_func_args_beta_index
             ]
             if first_beta is None:
@@ -849,23 +852,24 @@ def require_betas_match_in_alg_update_args_each_update(
             else:
                 assert np.array_equal(
                     beta, first_beta
-                ), f"Betas do not match across users in the algorithm update function args for policy number {policy_num}. Please see the contract for details."
+                ), f"Betas do not match across subjects in the algorithm update function args for policy number {policy_num}. Please see the contract for details."
+
 
 def require_previous_betas_match_in_alg_update_args_each_update(
     alg_update_func_args, alg_update_func_args_previous_betas_index
 ):
     logger.info(
-        "Checking that previous betas match across users for each update in the algorithm update function args."
+        "Checking that previous betas match across subjects for each update in the algorithm update function args."
     )
     if alg_update_func_args_previous_betas_index < 0:
-        return 
-    
+        return
+
     for policy_num in alg_update_func_args:
         first_previous_betas = None
-        for user_id in alg_update_func_args[policy_num]:
-            if not alg_update_func_args[policy_num][user_id]:
+        for subject_id in alg_update_func_args[policy_num]:
+            if not alg_update_func_args[policy_num][subject_id]:
                 continue
-            previous_betas = alg_update_func_args[policy_num][user_id][
+            previous_betas = alg_update_func_args[policy_num][subject_id][
                 alg_update_func_args_previous_betas_index
             ]
             if first_previous_betas is None:
@@ -873,21 +877,21 @@ def require_previous_betas_match_in_alg_update_args_each_update(
             else:
                 assert np.array_equal(
                     previous_betas, first_previous_betas
-                ), f"Previous betas do not match across users in the algorithm update function args for policy number {policy_num}. Please see the contract for details."
+                ), f"Previous betas do not match across subjects in the algorithm update function args for policy number {policy_num}. Please see the contract for details."
 
 
 def require_betas_match_in_action_prob_func_args_each_decision(
     action_prob_func_args, action_prob_func_args_beta_index
 ):
     logger.info(
-        "Checking that betas match across users for each decision time in the action prob args."
+        "Checking that betas match across subjects for each decision time in the action prob args."
     )
     for decision_time in action_prob_func_args:
         first_beta = None
-        for user_id in action_prob_func_args[decision_time]:
-            if not action_prob_func_args[decision_time][user_id]:
+        for subject_id in action_prob_func_args[decision_time]:
+            if not action_prob_func_args[decision_time][subject_id]:
                 continue
-            beta = action_prob_func_args[decision_time][user_id][
+            beta = action_prob_func_args[decision_time][subject_id][
                 action_prob_func_args_beta_index
             ]
             if first_beta is None:
@@ -895,11 +899,11 @@ def require_betas_match_in_action_prob_func_args_each_decision(
             else:
                 assert np.array_equal(
                     beta, first_beta
-                ), f"Betas do not match across users in the action prob args for decision_time {decision_time}. Please see the contract for details."
+                ), f"Betas do not match across subjects in the action prob args for decision_time {decision_time}. Please see the contract for details."
 
 
 def require_valid_action_prob_times_given_if_index_supplied(
-    study_df,
+    analysis_df,
     calendar_t_col_name,
     alg_update_func_args,
     alg_update_func_args_action_prob_times_index,
@@ -909,19 +913,19 @@ def require_valid_action_prob_times_given_if_index_supplied(
     if alg_update_func_args_action_prob_times_index < 0:
         return
 
-    min_time = study_df[calendar_t_col_name].min()
-    max_time = study_df[calendar_t_col_name].max()
-    for policy_idx, args_by_user in alg_update_func_args.items():
-        for user_id, args in args_by_user.items():
+    min_time = analysis_df[calendar_t_col_name].min()
+    max_time = analysis_df[calendar_t_col_name].max()
+    for policy_idx, args_by_subject in alg_update_func_args.items():
+        for subject_id, args in args_by_subject.items():
             if not args:
                 continue
             times = args[alg_update_func_args_action_prob_times_index]
             assert (
                 times[i] > times[i - 1] for i in range(1, len(times))
-            ), f"Non-strictly-increasing times were given for action probabilities in the algorithm update function args for user {user_id} and policy {policy_idx}. Please see the contract for details."
+            ), f"Non-strictly-increasing times were given for action probabilities in the algorithm update function args for subject {subject_id} and policy {policy_idx}. Please see the contract for details."
             assert (
                 times[0] >= min_time and times[-1] <= max_time
-            ), f"Times not present in the study were given for action probabilities in the algorithm update function args. The min and max times in the study dataframe are {min_time} and {max_time}, while user {user_id} has times {times} supplied for policy {policy_idx}. Please see the contract for details."
+            ), f"Times not present in the study were given for action probabilities in the algorithm update function args. The min and max times in the analysis DataFrame are {min_time} and {max_time}, while subject {subject_id} has times {times} supplied for policy {policy_idx}. Please see the contract for details."
 
 
 def require_estimating_functions_sum_to_zero(
@@ -933,15 +937,15 @@ def require_estimating_functions_sum_to_zero(
     """
     This is a test that the correct loss/estimating functions have
     been given for both the algorithm updates and inference. If that is true, then the
-    loss/estimating functions when evaluated should sum to approximately zero across users.  These
-    values have been stacked and averaged across users in mean_estimating_function_stack, which
+    loss/estimating functions when evaluated should sum to approximately zero across subjects.  These
+    values have been stacked and averaged across subjects in mean_estimating_function_stack, which
     we simply compare to the zero vector.  We can isolate components for each update and inference
     by considering the dimensions of the beta vectors and the theta vector.
 
     Inputs:
     mean_estimating_function_stack:
         The mean of the estimating function stack (a component for each algorithm update and
-        inference) across users. This should be a 1D array.
+        inference) across subjects. This should be a 1D array.
     beta_dim:
         The dimension of the beta vectors that parameterize the algorithm.
     theta_dim:
@@ -951,7 +955,7 @@ def require_estimating_functions_sum_to_zero(
     None
     """
 
-    logger.info("Checking that estimating functions average to zero across users")
+    logger.info("Checking that estimating functions average to zero across subjects")
 
     # Have a looser hard failure cutoff before the typical interactive check
     try:
@@ -962,7 +966,7 @@ def require_estimating_functions_sum_to_zero(
         )
     except AssertionError as e:
         logger.info(
-            "Estimating function stacks do not average to within loose tolerance of zero across users.  Drilling in to specific updates and inference component."
+            "Estimating function stacks do not average to within loose tolerance of zero across subjects.  Drilling in to specific updates and inference component."
         )
         # If this is not true there is an internal problem in the package.
         assert (mean_estimating_function_stack.size - theta_dim) % beta_dim == 0
@@ -987,11 +991,11 @@ def require_estimating_functions_sum_to_zero(
         np.testing.assert_allclose(
             mean_estimating_function_stack,
             jnp.zeros(mean_estimating_function_stack.size),
-            atol=1e-5,
+            atol=5e-4,
         )
     except AssertionError as e:
         logger.info(
-            "Estimating function stacks do not average to within specified tolerance of zero across users.  Drilling in to specific updates and inference component."
+            "Estimating function stacks do not average to within specified tolerance of zero across subjects.  Drilling in to specific updates and inference component."
         )
         # If this is not true there is an internal problem in the package.
         assert (mean_estimating_function_stack.size - theta_dim) % beta_dim == 0
@@ -1021,15 +1025,15 @@ def require_RL_estimating_functions_sum_to_zero(
     """
     This is a test that the correct loss/estimating functions have
     been given for both the algorithm updates and inference. If that is true, then the
-    loss/estimating functions when evaluated should sum to approximately zero across users.  These
-    values have been stacked and averaged across users in mean_estimating_function_stack, which
+    loss/estimating functions when evaluated should sum to approximately zero across subjects.  These
+    values have been stacked and averaged across subjects in mean_estimating_function_stack, which
     we simply compare to the zero vector.  We can isolate components for each update and inference
     by considering the dimensions of the beta vectors and the theta vector.
 
     Inputs:
     mean_estimating_function_stack:
         The mean of the estimating function stack (a component for each algorithm update and
-        inference) across users. This should be a 1D array.
+        inference) across subjects. This should be a 1D array.
     beta_dim:
         The dimension of the beta vectors that parameterize the algorithm.
     theta_dim:
@@ -1039,7 +1043,7 @@ def require_RL_estimating_functions_sum_to_zero(
     None
     """
 
-    logger.info("Checking that RL estimating functions average to zero across users")
+    logger.info("Checking that RL estimating functions average to zero across subjects")
 
     # Have a looser hard failure cutoff before the typical interactive check
     try:
@@ -1050,7 +1054,7 @@ def require_RL_estimating_functions_sum_to_zero(
         )
     except AssertionError as e:
         logger.info(
-            "RL estimating function stacks do not average to zero across users.  Drilling in to specific updates and inference component."
+            "RL estimating function stacks do not average to zero across subjects.  Drilling in to specific updates and inference component."
         )
         num_updates = (mean_estimating_function_stack.size) // beta_dim
         for i in range(num_updates):
@@ -1070,7 +1074,7 @@ def require_RL_estimating_functions_sum_to_zero(
         )
     except AssertionError as e:
         logger.info(
-            "RL estimating function stacks do not average to zero across users.  Drilling in to specific updates and inference component."
+            "RL estimating function stacks do not average to zero across subjects.  Drilling in to specific updates and inference component."
         )
         num_updates = (mean_estimating_function_stack.size) // beta_dim
         for i in range(num_updates):
@@ -1079,7 +1083,6 @@ def require_RL_estimating_functions_sum_to_zero(
                 i + 1,
                 mean_estimating_function_stack[i * beta_dim : (i + 1) * beta_dim],
             )
-        # TODO: Email instead of requiring user input for monitoring alg.
         confirm_input_check_result(
             f"\nEstimating functions do not average to within default tolerance of zero vector. Please decide if the following is a reasonable result, taking into account the above breakdown by update number and inference. If not, there are several possible reasons for failure mentioned in the contract. Results:\n{str(e)}\n\nContinue? (y/n)\n",
             suppress_interactive_data_checks,
@@ -1087,20 +1090,18 @@ def require_RL_estimating_functions_sum_to_zero(
         )
 
 
-def require_adaptive_bread_inverse_is_true_inverse(
-    joint_adaptive_bread_matrix,
-    joint_adaptive_bread_inverse_matrix,
+def require_joint_bread_inverse_is_true_inverse(
+    joint_bread_inverse_matrix,
+    joint_bread_matrix,
     suppress_interactive_data_checks,
 ):
     """
-    Check that the product of the joint adaptive bread matrix and its inverse is
+    Check that the product of the joint bread matrix and its inverse is
     sufficiently close to the identity matrix.  This is a direct check that the
-    joint_adaptive_bread_inverse_matrix we create is "well-conditioned".
+    joint_bread_matrix we create is "well-conditioned".
     """
-    should_be_identity = (
-        joint_adaptive_bread_matrix @ joint_adaptive_bread_inverse_matrix
-    )
-    identity = np.eye(joint_adaptive_bread_matrix.shape[0])
+    should_be_identity = joint_bread_inverse_matrix @ joint_bread_matrix
+    identity = np.eye(joint_bread_matrix.shape[0])
     try:
         np.testing.assert_allclose(
             should_be_identity,
@@ -1110,7 +1111,7 @@ def require_adaptive_bread_inverse_is_true_inverse(
         )
     except AssertionError as e:
         confirm_input_check_result(
-            f"\nJoint adaptive bread is not exact inverse of the constructed matrix that was inverted to form it. This likely illustrates poor conditioning:\n{str(e)}\n\nContinue? (y/n)\n",
+            f"\nJoint bread inverse is not exact inverse of the constructed matrix that was inverted to form it. This likely illustrates poor conditioning:\n{str(e)}\n\nContinue? (y/n)\n",
             suppress_interactive_data_checks,
             e,
         )
@@ -1118,7 +1119,7 @@ def require_adaptive_bread_inverse_is_true_inverse(
     # If we haven't already errored out, return some measures of how far off we are from identity
     diff = should_be_identity - identity
     logger.debug(
-        "Difference between should-be-identity produced by multiplying joint adaptive bread inverse and its computed inverse and actual identity:\n%s",
+        "Difference between should-be-identity produced by multiplying joint bread and its computed inverse and actual identity:\n%s",
         diff,
     )
 
@@ -1133,8 +1134,8 @@ def require_adaptive_bread_inverse_is_true_inverse(
 
 def require_threaded_algorithm_estimating_function_args_equivalent(
     algorithm_estimating_func,
-    update_func_args_by_by_user_id_by_policy_num,
-    threaded_update_func_args_by_policy_num_by_user_id,
+    update_func_args_by_by_subject_id_by_policy_num,
+    threaded_update_func_args_by_policy_num_by_subject_id,
     suppress_interactive_data_checks,
 ):
     """
@@ -1144,12 +1145,12 @@ def require_threaded_algorithm_estimating_function_args_equivalent(
     """
     for (
         policy_num,
-        update_func_args_by_user_id,
-    ) in update_func_args_by_by_user_id_by_policy_num.items():
+        update_func_args_by_subject_id,
+    ) in update_func_args_by_by_subject_id_by_policy_num.items():
         for (
-            user_id,
+            subject_id,
             unthreaded_args,
-        ) in update_func_args_by_user_id.items():
+        ) in update_func_args_by_subject_id.items():
             if not unthreaded_args:
                 continue
             np.testing.assert_allclose(
@@ -1157,9 +1158,9 @@ def require_threaded_algorithm_estimating_function_args_equivalent(
                 # Need to stop gradient here because we can't convert a traced value to np array
                 jax.lax.stop_gradient(
                     algorithm_estimating_func(
-                        *threaded_update_func_args_by_policy_num_by_user_id[user_id][
-                            policy_num
-                        ]
+                        *threaded_update_func_args_by_policy_num_by_subject_id[
+                            subject_id
+                        ][policy_num]
                     )
                 ),
                 atol=1e-7,
@@ -1169,8 +1170,8 @@ def require_threaded_algorithm_estimating_function_args_equivalent(
 
 def require_threaded_inference_estimating_function_args_equivalent(
     inference_estimating_func,
-    inference_func_args_by_user_id,
-    threaded_inference_func_args_by_user_id,
+    inference_func_args_by_subject_id,
+    threaded_inference_func_args_by_subject_id,
     suppress_interactive_data_checks,
 ):
     """
@@ -1178,7 +1179,7 @@ def require_threaded_inference_estimating_function_args_equivalent(
     when called with the original arguments and when called with the
     reconstructed action probabilities substituted in.
     """
-    for user_id, unthreaded_args in inference_func_args_by_user_id.items():
+    for subject_id, unthreaded_args in inference_func_args_by_subject_id.items():
         if not unthreaded_args:
             continue
         np.testing.assert_allclose(
@@ -1186,7 +1187,7 @@ def require_threaded_inference_estimating_function_args_equivalent(
             # Need to stop gradient here because we can't convert a traced value to np array
             jax.lax.stop_gradient(
                 inference_estimating_func(
-                    *threaded_inference_func_args_by_user_id[user_id]
+                    *threaded_inference_func_args_by_subject_id[subject_id]
                 )
             ),
             rtol=1e-2,