def simulate_user_experiments(ape_tabular, instance, nb_features_employed, farthest_distance, closest_counterfactual, growing_sphere,
                              position_instances_in_sphere, nb_training_instance_in_sphere):
    """
    Function that generate a classic local surrogate explanation, an anchor explanation and an APE explanation and 
    returns the features that are used by these explanation models
    Args: ape_tabular: ape tabular object used to explain the target instance
          instance: target instance to explain
          nb_features_employed: Number of features employed by the linear explanation model
          farthest_distance: Distance from the target instance to explain and the farthest instance from the training data
          closest_counterfactual: Closest instance from the closest counterfactual from the target instance (on the limit of the hyper field 
                                  from the same class as the target instance)
          growing_sphere: growing sphere object used by APE to explain the target instance
          position_instances_in_sphere: Index of the training data located in the hyper field
          nb_training_instance_in_sphere: Number of training data located in the hyper field
    Return: List of features employed by APE, Anchors and a classic local surrogate
    """
    target_class = ape_tabular.black_box_predict(instance.reshape(1, -1))[0]
    ape_tabular.target_class = target_class
    
    """ Generates or store instances in the area of the hypersphere and their correspoinding labels """
    min_instance_per_class = ape_tabular.nb_min_instance_per_class_in_sphere
    instances_in_sphere, labels_in_sphere, percentage_distribution, instances_in_sphere_libfolding = ape_tabular.generate_instances_inside_sphere(growing_sphere,
                                                                                                            growing_sphere.radius, closest_counterfactual, 
                                                                                                            farthest_distance, min_instance_per_class, position_instances_in_sphere, 
                                                                                                            nb_training_instance_in_sphere, libfolding=True)

    # Always compute an anchor explanation to compare with APE and local Surrogate
    anchor_exp = ape_tabular.anchor_explainer.explain_instance(instance, ape_tabular.black_box_predict, threshold=ape_tabular.threshold_precision, 
                                delta=0.1, tau=0.15, batch_size=100, max_anchor_size=None, stop_on_first=False,
                                desired_label=None, beam_size=4)
    #print("rule by anchor", anchor_exp.names()) => To print the rules returned by Anchors
    # Transform the explanation generated by Anchors to know what are the features employed by Anchors
    rules, training_instances_pandas_frame, features_employed_in_rule = ape_tabular.generate_rule_and_data_for_anchors(anchor_exp.names(), 
                                                                                            ape_tabular.target_class, ape_tabular.train_data, 
                                                                                            simulated_user_experiment=True)
    if not ape_tabular.multimodal_results:
        # In case of unimodal data we compute a local surrogate explanation trained over raw instances located in the hyper sphere 
        local_surogate = ape_tabular.lime_explainer.explain_instance_training_dataset(instance,
                                                                    ape_tabular.black_box_predict_proba, 
                                                                    num_features=nb_features_employed,
                                                                    instances_in_sphere=instances_in_sphere)
        features_linear_employed = []
        for feature_linear_employed in local_surogate.as_list():
            features_linear_employed.append(feature_linear_employed[0])
        #print("features linear employed", features_linear_employed) => To print the features importance generated by Local Surrogate
        # Transform the explanation generated by Local Surrogate to know what are the features employed by LS
        rules, training_instances_pandas_frame, features_employed_in_linear = ape_tabular.generate_rule_and_data_for_anchors(features_linear_employed, 
                                                                                                    ape_tabular.target_class, ape_tabular.train_data, 
                                                                                                    simulated_user_experiment=True)
        features_employed_by_ape = features_employed_in_linear
    else:
        # In case of multimodal data APE choose an anchor explanation 
        features_employed_by_ape = features_employed_in_rule
    
    # Generate a classic local Surrogate explanation model to compare with APE and Anchors
    local_surrogate = ape_tabular.lime_explainer.explain_instance(closest_counterfactual,
                                                                ape_tabular.black_box_predict_proba, 
                                                                num_features=nb_features_employed)
    features_linear_employed = []
    for feature_linear_employed in local_surrogate.as_list():
        features_linear_employed.append(feature_linear_employed[0])
    rules, training_instances_pandas_frame, features_employed_in_linear = ape_tabular.generate_rule_and_data_for_anchors(features_linear_employed, 
                                                                                                    ape_tabular.target_class, ape_tabular.train_data, 
                                                                                                    simulated_user_experiment=True)
        
    return features_employed_in_linear, features_employed_by_ape, features_employed_in_rule