updated to use diff. distributions, added more explanation.

app.py

@@ -1,10 +1,10 @@
 # -*- coding: utf-8 -*-
-"""ranking_simulation_0.ipynb
+"""ranking_simulation_1_asymmetric_judges.ipynb
 
 Automatically generated by Colaboratory.
 
 Original file is located at
-    https://colab.research.google.com/drive/1GzjewA8ePLJ1fdk76Qax-aRRsSsNp417
+    https://colab.research.google.com/drive/1d7GP8R96AgQSvJq4YL3nnzEmtBomevu0
 """
 
 # Commented out IPython magic to ensure Python compatibility.
@@ -17,6 +17,9 @@ import numpy as np
 import pandas as pd
 import opinionated
 import matplotlib.pyplot as plt
+from scipy.stats import skewnorm
+
+
 plt.style.use("opinionated_rc")
 
 from opinionated.core import download_googlefont
@@ -26,22 +29,55 @@ plt.rc('font', family='Quicksand')
 
 import colormaps as cmaps
 
-def simulate_applicant_judging(num_applicants, num_judges, ratings_per_applicant, alpha, beta,
-                               judge_error=1, judgment_coarse_graining=False):
+def sample_skewed_normal(alpha, loc, scale, n, range_min=None, range_max=None):
+    samples = []
+    while len(samples) < n:
+        sample = skewnorm.rvs(alpha, loc, scale)
+        if (range_min is None or sample >= range_min) and (range_max is None or sample <= range_max):
+            samples.append(sample)
+    return np.array(samples)
+
+
+# # Example usage
+# alpha = 5  # Skewness
+# loc = 0    # Location (mean)
+# scale = 1  # Scale (standard deviation)
+# n_samples = 10000  # Number of samples to generate
+# range_min, range_max = -2, 2  # Range for the samples
+
+# samples = sample_skewed_normal(alpha, loc, scale, n_samples, range_min, range_max)
+# # print(samples)
+
+# import seaborn as sns
+# sns.histplot(samples)
+
+from scipy.stats import norm
+
+
+
+def simulate_applicant_judging(num_applicants=100, num_judges=10, ratings_per_applicant=5,alpha=0, loc=50, scale=15, judge_error=1, judges_attitude=0.3,
+                                        judgment_coarse_graining=False):
     """
-    Simulates judging of applicants by a set of judges with coarse graining functionality and random tie-breaking in ranking.
-
-    :param num_applicants: Number of applicants to be judged.
-    :param num_judges: Number of judges available for judging.
-    :param ratings_per_applicant: Number of ratings each applicant should receive.
-    :param alpha: Alpha parameter for the Beta distribution.
-    :param beta: Beta parameter for the Beta distribution.
-    :param judge_error_std_dev: Standard deviation for the judge's margin of error.
-    :param judgment_coarse_graining: Number of buckets for coarse graining (2 to 100) or False to disable.
-    :return: A Pandas DataFrame with detailed results for each applicant.
+    Simulates the process of judging applicants by a set of judges, incorporating randomness in evaluations, judge bias, and error.
+
+    Parameters:
+    - num_applicants (int): Number of applicants to be judged.
+    - num_judges (int): Number of judges involved in the evaluation process.
+    - ratings_per_applicant (int): Number of ratings each applicant receives from different judges.
+    - alpha (float): Alpha parameter for the skewed normal distribution to simulate applicant qualities.
+    - loc (float): The mean ('location') for the skewed normal distribution of applicant qualities.
+    - scale (float): Standard deviation for the skewed normal distribution of applicant qualities.
+    - judge_error (float): Standard deviation for the random error in judges' evaluations.
+    - judges_attitude (float): Mean for the normal distribution representing judges' biases.
+    - judgment_coarse_graining (int/bool): Enables coarse graining of evaluations into specified number of buckets. Set to False to disable.
+
+    The function simulates the quality of each applicant using a skewed normal distribution and then assigns each applicant a set of evaluations by different judges, considering the judges' workload distribution, biases, and random error margin. Coarse graining of evaluations is applied if enabled.
+
+    Returns:
+    - pandas.DataFrame: A DataFrame with columns for each applicant's identifier, inherent quality, average evaluation score, individual scores from each judge, original ranking based on scores, and final rankings after applying random tie-breaking for identical scores.
     """
     # Generate the quality of applicants from a Beta distribution normalized to 0-100
-    applicant_qualities = np.random.beta(alpha, beta, num_applicants) * 100
+    applicant_qualities = sample_skewed_normal(alpha, loc, scale, num_applicants, 0, 100)
 
     # Function to apply coarse graining
     def coarse_grain_evaluation(evaluation, grain_size):
@@ -50,6 +86,7 @@ def simulate_applicant_judging(num_applicants, num_judges, ratings_per_applicant
     # Initialize evaluations dictionary
     evaluations = {f"Applicant_{i+1}": [] for i in range(num_applicants)}
     judge_workload = np.zeros(num_judges)
+    judges_attitudes =np.random.normal(0,judges_attitude,num_judges)
 
     # Randomly assign judges to applicants
     for _ in range(ratings_per_applicant):
@@ -57,7 +94,9 @@ def simulate_applicant_judging(num_applicants, num_judges, ratings_per_applicant
             probabilities = (max(judge_workload) - judge_workload + 1) / sum(max(judge_workload) - judge_workload + 1)
             judge = np.random.choice(num_judges, p=probabilities)
             judge_workload[judge] += 1
-            evaluation = np.random.uniform(applicant_qualities[applicant]-judge_error, applicant_qualities[applicant]+judge_error)
+            evaluation = sample_skewed_normal(alpha=judges_attitudes[judge], loc=applicant_qualities[applicant],  scale=judge_error/norm.ppf(0.975), n=1)[0]
+            # print(np.random.normal(loc=applicant_qualities[applicant], scale=judge_error/norm.ppf(0.975)))
+            # print(evaluation)
 
             # Apply coarse graining if enabled
             if judgment_coarse_graining:
@@ -90,38 +129,51 @@ def simulate_applicant_judging(num_applicants, num_judges, ratings_per_applicant
 
     return df
 
-# # Example usage with specified alpha and beta values
-# df_results = simulate_applicant_judging(num_applicants=100, num_judges=10, ratings_per_applicant=5, alpha=4, beta=4, judgment_coarse_graining=10)
-# df_results.head(30)  # Displaying the top 30 rows for brevity
+df_results = simulate_applicant_judging(num_applicants=100, num_judges=10, ratings_per_applicant=5,alpha=0, loc=50, scale=15, judge_error=1, judges_attitude=0.3,
+                                        judgment_coarse_graining=10)
+df_results.head(30)
+
 
 
+df_results.sort_values(by='Rank of Evaluation').head(30)
 
 
-# df_results.sort_values(by='Rank of Evaluation').head(30)
 
 import pandas as pd
 
-def summarize_simulation_runs(num_runs, num_applicants, num_judges, ratings_per_applicant, top_n, alpha, beta,
-                               judge_error=1, judgment_coarse_graining=False):
-    """
-    Runs the applicant judging simulation multiple times and summarizes how often each candidate by quality was in the top n.
-
-    :param num_runs: Number of times to run the simulation.
-    :param num_applicants: Number of applicants to be judged.
-    :param num_judges: Number of judges available for judging.
-    :param ratings_per_applicant: Number of ratings each applicant should receive.
-    :param top_n: Number of top positions to consider in the summary.
-    :param applicant_std_dev: Standard deviation for the quality of applicants.
-    :param judge_error_std_dev: Standard deviation for the judge's margin of error.
-    :param judgment_coarse_graining: Number of buckets for coarse graining or False to disable.
-    :return: A Pandas DataFrame summarizing the results.
+def summarize_simulation_runs(num_runs, num_applicants, num_judges, ratings_per_applicant, top_n, alpha, loc, scale,
+                               judge_error, judges_attitude, judgment_coarse_graining):
     """
+      Runs multiple simulations of applicant judging and summarizes the frequency of each candidate's placement in the top n positions based on their quality ranking.
+
+      Parameters:
+      - num_runs (int): Number of simulation iterations to run.
+      - num_applicants (int): Number of applicants in each simulation.
+      - num_judges (int): Number of judges evaluating the applicants in each simulation.
+      - ratings_per_applicant (int): Number of evaluations each applicant receives.
+      - top_n (int): The number of top positions to analyze in the ranking.
+      - alpha (float): Alpha parameter for the skewed normal distribution to simulate applicant qualities.
+      - loc (float): The mean ('location') for the skewed normal distribution of applicant qualities.
+      - scale (float): Standard deviation for the skewed normal distribution of applicant qualities.
+      - judge_error (float): Standard deviation for the random error in judges' evaluations.
+      - judges_attitude (float): Mean for the normal distribution representing judges' biases.
+      - judgment_coarse_graining (int/bool): Enables coarse graining of evaluations into specified number of buckets. Set to False to disable.
+
+      The function performs multiple runs of the applicant judging simulation. It aggregates and summarizes how often each applicant, based on their quality rank, appears in the top n positions of the evaluation rankings.
+
+      Returns:
+      - pandas.DataFrame: A DataFrame where each row corresponds to an applicant (ranked by quality) and each column represents how often that applicant was in a specific top n position across all simulation runs.
+      """
     # Initialize counts for each quality-ranked candidate in top n positions
     top_n_counts = pd.DataFrame(0, index=range(1, num_applicants + 1), columns=[f'Top {i}' for i in range(1, top_n + 1)])
 
     for _ in range(num_runs):
-        df_results = simulate_applicant_judging(num_applicants, num_judges, ratings_per_applicant,
-                                                alpha=alpha, beta=beta, judge_error=judge_error, judgment_coarse_graining=judgment_coarse_graining)
+        # df_results = simulate_applicant_judging(num_applicants, num_judges, ratings_per_applicant,
+        #                                         alpha=alpha, beta=beta, judge_error=judge_error, judgment_coarse_graining=judgment_coarse_graining)
+        df_results = simulate_applicant_judging(num_applicants=num_applicants, num_judges=num_judges, ratings_per_applicant=ratings_per_applicant,
+                                                alpha=alpha, loc=loc, scale=scale,
+                                                judge_error=judge_error, judges_attitude=judges_attitude,
+                                                judgment_coarse_graining=judgment_coarse_graining)
         # Sort by Rank of Applicant Quality
         sorted_by_quality = df_results.sort_values(by='Applicant Quality', ascending=False).reset_index()
         # Sort by Rank of Evaluation
@@ -135,10 +187,10 @@ def summarize_simulation_runs(num_runs, num_applicants, num_judges, ratings_per_
     return top_n_counts
 
 # Example usage
-# num_runs = 1000  # Number of simulation runs
-# top_n_results = summarize_simulation_runs(num_runs=num_runs, num_applicants=100, num_judges=5, ratings_per_applicant=3,
-#                                           top_n=5,alpha=2, beta=1,judge_error=4, judgment_coarse_graining=False)
-# top_n_results
+num_runs = 100  # Number of simulation runs
+top_n_results = summarize_simulation_runs(num_runs=num_runs, num_applicants=100, num_judges=5, ratings_per_applicant=3,
+                                          top_n=5, alpha=0, loc=50, scale=15, judge_error=4, judges_attitude=0.3, judgment_coarse_graining=False)
+top_n_results
 
 
 
@@ -184,6 +236,8 @@ def plot_top_n_results(top_n_results, num_runs):
         labels = [label.replace("Top", "Rank") for label in top_n_results.columns] + ['Not chosen']
 
         ax.legend(labels=labels, title='Rank in Evaluation', loc='lower center', bbox_to_anchor=(0.5, -0.2), ncol=top_n_results.shape[1]+1)  # Legend below the chart
+    else:
+        ax.legend().set_visible(False)
     plt.tight_layout()
     return fig
 
@@ -272,69 +326,128 @@ def plot_top_n_results(top_n_results, num_runs):
 # # Example usage
 # visualize_applicant_and_judge_distributions(alpha=2, beta=1, judge_error=5)
 
+
+
 import gradio as gr
 import matplotlib.pyplot as plt
 from io import BytesIO
 
-from scipy.stats import beta
+# from scipy.stats import beta
+
+#     x = np.linspace(-10, 10, 1000)
+#     y = skewnorm.pdf(x, alpha, loc, scale)
+
+#     fig, ax = plt.subplots(figsize=(7, 3))
+#     plt.fill_between(x, y, color="#6a4c93", alpha=0.8)
+#     plt.xlabel('Value')
+#     plt.ylabel('Probability Density')
+#     ax.set_yticks([])  # Optional: Remove y-axis labels for cleaner look
+
+#     return fig
 
-# Function to plot beta distribution
-def plot_beta_distribution(a, b, judgement_variability):
-    x = np.linspace(0, 1, 1000)
-    y = beta.pdf(x, a, b)
+def plot_skewed_normal_distribution(alpha, loc, scale, judge_error,judgement_variability,):
+    x = np.linspace(0, 100, 1000)
+    y_pop_dist = skewnorm.pdf(x, alpha, loc, scale)
 
     fig, ax = plt.subplots(figsize=(7, 3))  # Figure size
-    plt.fill_between(np.linspace(0, 100, 1000), y, color="#ee4d5a", alpha=0.8)
-    # plt.title('Distribution of Applicant Qualities')
+    plt.fill_between(np.linspace(0, 100, 1000), y_pop_dist, color="#ee4d5a", alpha=0.8)
     plt.xlabel('True Applicants Quality-Distribution')
     plt.xlim(0, 100)
     ax.set_yticklabels([])  # Remove y-axis labels
 
-    # Drawing the line
-    line_length = 2 * judgement_variability
+    # Judgement Variability Line
+    line_length = judge_error
     line_x = [50 - line_length/2, 50 + line_length/2]
-    plt.plot(line_x, [0, 0], color='black', linewidth=2)
+    plt.plot(line_x, [0, 0], color='black', linewidth=1.4, linestyle='dotted')
 
-    # Labeling the line
-    plt.text(np.mean(line_x), 0.02, 'Judgement Variability', ha='center', va='bottom', color='black')
+
+    # Small Normal Distribution
+    std_dev = judge_error / 2 / norm.ppf(0.975)
+    small_dist_x = np.linspace(50 - 3*std_dev, 50 + 3*std_dev, 100)  # 3 standard deviations on each side
+    small_dist_y = skewnorm.pdf(small_dist_x,0, loc=50, scale=std_dev)  #
+    small_dist_y_scaled = small_dist_y / max(small_dist_y) * np.max(y_pop_dist)*.12  # Scale down for representation
+    plt.plot(small_dist_x, small_dist_y_scaled, color='black', linewidth=2)
+    plt.text(np.mean(line_x), np.max(y_pop_dist)*.08 + np.max(small_dist_y_scaled) , 'Judgement Variability', ha='center', va='bottom', color='black',weight='bold',)
+
+
+
+    # Small Normal Distribution Cranky judge
+    small_dist_x = np.linspace(25 - 3*std_dev, 25 + 3*std_dev, 100)  # 3 standard deviations on each side
+    small_dist_y = skewnorm.pdf(small_dist_x,-judgement_variability, loc=25, scale=std_dev)  #
+    small_dist_y_scaled = small_dist_y / max(small_dist_y) * np.max(y_pop_dist)*.12  # Scale down for representation
+    plt.text(25, np.max(y_pop_dist)*.05 + np.max(small_dist_y_scaled), 'Most Harsh', ha='center', va='bottom', color='black')
+    plt.plot(small_dist_x, small_dist_y_scaled, color='black', linewidth=2)
+
+        # Small Normal Distribution genereous judge
+    small_dist_x = np.linspace(75 - 3*std_dev, 75 + 3*std_dev, 100)  # 3 standard deviations on each side
+    small_dist_y = skewnorm.pdf(small_dist_x,judgement_variability, loc=75, scale=std_dev)  #
+    small_dist_y_scaled = small_dist_y / max(small_dist_y) * np.max(y_pop_dist)*.12  # Scale down for representation
+    plt.text(75, np.max(y_pop_dist)*.05 + np.max(small_dist_y_scaled) , 'Most Generous', ha='center', va='bottom', color='black')
+    plt.plot(small_dist_x, small_dist_y_scaled, color='black', linewidth=2)
 
     return fig
 
 # Your existing function for running simulation and plotting
-def run_simulation_and_plot(num_runs, num_applicants, num_judges, ratings_per_applicant, top_n, alpha, beta, judge_error, judgment_coarse_graining,judgment_coarse_graining_true_false):
+def run_simulation_and_plot(num_runs, num_applicants, num_judges, ratings_per_applicant, top_n, alpha, loc, scale,  judge_error, judges_attitude, judgment_coarse_graining,judgment_coarse_graining_true_false):
     if judgment_coarse_graining_true_false == False:
       judgment_coarse_graining = False
-    top_n_results = summarize_simulation_runs(num_runs, num_applicants, num_judges, ratings_per_applicant, top_n, alpha, beta, judge_error, judgment_coarse_graining)
+    top_n_results = summarize_simulation_runs(num_runs, num_applicants, num_judges, ratings_per_applicant, top_n, alpha, loc, scale,
+                               judge_error, judges_attitude, judgment_coarse_graining)
     return plot_top_n_results(top_n_results, num_runs)
 
 
 
-intro_html = """
-    <h1>On Rankings</h1>
-    <p>One of the central experiences of being an academic is the experience of being ranked. We are ranked when we apply for graduate school, or maybe already for a master's degree. We are ranked when we're up for faculty positions. We are ranked when we submit abstracts for conferences. And when we publish papers, we do so, of course, in journals that are ranked. The places where we work, the departments, are ranked, of course, as well. But although rankings apparently are catnip to academics, and probably everybody else as well, we do have some agreement. Most people probably share the intuition that there's something weird or iffy about rankings, and the suspicion that maybe often they are not as informative as there are some beings absolutely everywhere who suggest.</p>
+intro_md = """
+   # On Rankings
+
+_by [Max Noichl](https://homepage.univie.ac.at/maximilian.noichl/)_
+
+One of the central experiences of being an academic is the experience of being ranked. We are ranked when we submit abstracts for conferences, when we publish papers in ranked journals, when we apply for graduate school or maybe already for a master's degree, and when we apply for faculty positions, at departments, which are, of course, ranked as well. But although rankings are catnip to academics (and presumably everybody else as well), most people probably share the intuition that there's something weird or iffy about rankings and may suspect that often they are not as informative as their prevalence suggests.
+
+The simulation, which you can run yourself below, should give some further insight into that perceived weirdness. It involves setting up a population of candidates (like conference abstracts or job applicants) according to a distribution which you specify. Candidates with objective qualities are then sampled from this distribution and evaluated by judges, who have a certain error margin in their assessments, reflecting real-world inaccuracies. The simulation averages the ratings each candidate receives. The results show that in many plausible scenarios the best candidates often don't make it into the top of the rankings, highlighting the rankings limited value for accurately identifying the most qualified individuals. Below, I give some more detailed explanation – but first, the simulation.
 """
+
+
+explanation_md = """
+The simulation works like this: We set up a population of candidates. These could be abstracts for a conference, applicants to a PhD position, departments getting ranked for 'eliteness', etc. We can determine how this distribution looks. For instance, you might expect many strong candidates and few inappropriate ones, a normal distribution around a midpoint, or predominantly poor applicants with rare exceptional cases. You can set the parameters of this distribution, (which we model as a skewed normal), **Mean**, **Standard Deviation**, and **Skewness**, yourself, depending on your prior expectations. Your settings are reflected in the red distribution-graphic on the right. This simulation then generates a **Number of Applicants** with objectively determined qualities for our ranking.
+
+Applicant contributions are evaluated by a **Number of Judges**, who evenly distribute the task of rating until all applicants have received a rating. Importantly, like in the real world, judges are not infallible; they make errors in assessing applicants. This is adjustable via the **Judge Error** property, which represents the width of the 95% confidence interval of a distribution centered around the applicant's objective quality. For example, if an applicant has an objective quality score of 70 and the **Judge Error** is set to 4, it means that in 95% of cases, judges are expected to score the applicant between 68 and 72. In most cases of academic ratings, it seems implausible that people can reliably distinguish closely scored candidates (e.g., 75 vs. 77). Depending on your application, you can therefore experiment with different plausible error-ranges for your specific scenario.
+
+Judges' rating styles naturally vary. Some may be more critical, rating applicants harshly, while others may be more lenient. This variability is adjustable in the simulation through the **Judges' Attitude Range**, which defines the maximum and minimum levels of strictness or leniency. The impact of these settings is visually represented in the simulation by the black distributions within the population-distribution-graphic on the right.
+
+Once all evaluations are complete, each applicant's final score is determined by averaging all their received ratings. Additionally, the simulation allows for coarse-grained judgments, where judges have to select the most appropriate score on a predefined scale (e.g., 0 to 7, determined by the **Coarse Graining Factor**). In that case (a very common practice), we do lose quite some information about the quality of the candidates.
+
+To complete the setup, we specify the number of simulation runs before activating them with the **Run Simulations** button. The outcomes are displayed in the green graphic under the 'Simulation Results' tab on the right. These results, indicated by green bars, show the frequency with which the objectively best candidates make it into the top spots after undergoing our ranking. In many realistic scenarios, the simulation reveals a significant element of randomness, particularly in lower top spots. **Often, the most qualified candidates don't consistently reach the top ranks**, and even the highest-ranked candidates are commonly misplaced.
+
+I don't think that this is a particularly new or surprising result. But I think that it is very important to keep in mind, and have an intuitive feel for, when interacting with rankings. I hope the simulation can help you with that. We should also note, that the setup of this simulation in many ways presents an unrealistic best case for rankings. While our judges do make errors, they do not make errors systematically. They are not biased against specific candidates for reasons of gender, ethnic, or class background, or the intellectual traditions they come from. But even in our very idealized ranking situation, we can see that the information contained in the final ranking about the reality of things is often severely limited. Which just goes to say that probably we shouldn't make that much of a fuss about rankings, in most cases.
+"""
+
 comment_distribution_image = """<p>This is the distribution from which our applicants will be sampled:</p>"""
 
 # Building the interface
-with gr.Blocks(theme=gr.themes.Monochrome(primary_hue="red", secondary_hue="pink",spacing_size="sm",text_size="lg", radius_size="none")) as demo:
+with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
   with gr.Column():
-    gr.HTML(intro_html)
+    gr.Markdown(intro_md)
     with gr.Row():
       with gr.Column():
         run_button = gr.Button("Run Simulations!")
 
         # control applicant distribution
         # with gr.Group():
-        alpha_slider = gr.Slider(0.1, 5, step=0.1, value=1.4, label="Alpha (β Distribution)")
-        beta_slider = gr.Slider(0.1, 5, step=0.1,value=2.7, label="Beta (β Distribution)")
+        loc_slider = gr.Slider(0,100, step=1, value=70, label="Mean (Population)")
+        scale_slider = gr.Slider(0, 80, step=1, value=50, label="Standard Deviation (Population)")
+        alpha_slider = gr.Slider(-10, 10, step=1, value=0, label="Skewness (Population)")
+
         # simumlation-settings:
         with gr.Group():
-          num_applicants = gr.Slider(10, 300, step=10, value=100, label="Number of Applicants")
-          num_judges = gr.Slider(1, 100, step=1, value=7, label="Number of Judges")
-          ratings_per_applicant = gr.Slider(1, 5, step=1, value=3, label="Ratings per Applicant", info='how many different ratings each application gets.')
-          top_n = gr.Slider(1, 40, step=1, value=5, label="Top N")
+          num_applicants = gr.Slider(10, 300, step=10, value=100, label="Number of Applicants", info='How many applications were submitted.')
+          num_judges = gr.Slider(1, 100, step=1, value=7, label="Number of Judges", info='How many Judges are involved.')
+          ratings_per_applicant = gr.Slider(1, 5, step=1, value=3, label="Ratings per Applicant", info='How many different ratings each application gets.')
+          top_n = gr.Slider(1, 40, step=1, value=5, label="Top N", info='How many candidates can be selected.')
+
+        judge_error = gr.Slider(0, 20, step=1, value=7, label="Judge Error", info='How much error judges can plausibly commit in their ratings.')
+        judges_attitude = gr.Slider(0, 10, step=.1, value=1.7, label="Judges attitude-range")
 
-        judge_error = gr.Slider(0, 10, step=1, value=2, label="Judge Error")
         judgment_coarse_graining_true_false = gr.Checkbox(value= True, label="Coarse grain judgements.")
         judgment_coarse_graining = gr.Slider(0, 30, step=1, value=7, label="Coarse Graining Factor")
         num_runs = gr.Slider(10, 1000, step=10,value=100, label="Number of Runs")
@@ -344,25 +457,153 @@ with gr.Blocks(theme=gr.themes.Monochrome(primary_hue="red", secondary_hue="pink
 
       with gr.Column():
         with gr.Group():
-          # gr.HTML(comment_distribution_image)
-          beta_plot = gr.Plot(label="Applicants quality distribution")
-
-        # Your existing plot output
-        plot_output = gr.Plot(label="Simulation Results",show_label=True)
-#https://discuss.huggingface.co/t/gradio-changing-background-colour-in-all-devices/42519
+          population_plot = gr.Plot(label="Applicants quality distribution & judgement errors")
+          gr.Markdown("""Above you can see in red the distribution from which we draw the real qualities of our applicants.
+                         You can alter its **Mean, Scale and Skewness** on the left side. You can also see how large the errors are,
+                         which our judges commit, and how harshly the most harsh and most generous judges judge.
+                         You can alter these values by playing with the **Judge Error** and the **Judge's attitude range** on the left.""")
+        with gr.Group():
+          # Your existing plot output
+          plot_output = gr.Plot(label="Simulation Results",show_label=True)
+          gr.Markdown("""Above are the results of our simulation. The green bars represent the frequency of the first, second,
+                        and subsequent applicants being selected for the **Top N** spots. The shade of green shows the rank each
+                        applicant achieved in the number of simulations. The grey area indicates the frequency with which applicants,
+                        who were objectively top candidates, failed to be selected into the Top N at all.""")
 
     # Function call on button click
     run_button.click(
         run_simulation_and_plot,
-        inputs=[num_runs, num_applicants, num_judges, ratings_per_applicant, top_n, alpha_slider, beta_slider, judge_error, judgment_coarse_graining,judgment_coarse_graining_true_false],
+        inputs=[num_runs, num_applicants, num_judges, ratings_per_applicant, top_n, alpha_slider, loc_slider, scale_slider,  judge_error, judges_attitude, judgment_coarse_graining,judgment_coarse_graining_true_false],
         outputs=[plot_output], scroll_to_output = True
     )
 
-    alpha_slider.change(plot_beta_distribution, inputs=[alpha_slider, beta_slider,judge_error], outputs=[beta_plot])
-    beta_slider.change(plot_beta_distribution, inputs=[alpha_slider, beta_slider,judge_error], outputs=[beta_plot])
-    judge_error.change(plot_beta_distribution, inputs=[alpha_slider, beta_slider,judge_error], outputs=[beta_plot])
-
-    demo.load(plot_beta_distribution, inputs=[alpha_slider, beta_slider,judge_error], outputs=[beta_plot])
+    alpha_slider.change(plot_skewed_normal_distribution, inputs=[alpha_slider, loc_slider,scale_slider,judge_error,judges_attitude], outputs=[population_plot])
+    loc_slider.change(plot_skewed_normal_distribution, inputs=[alpha_slider, loc_slider,scale_slider,judge_error,judges_attitude], outputs=[population_plot])
+    scale_slider.change(plot_skewed_normal_distribution, inputs=[alpha_slider, loc_slider,scale_slider,judge_error,judges_attitude], outputs=[population_plot])
+    judge_error.change(plot_skewed_normal_distribution, inputs=[alpha_slider, loc_slider,scale_slider,judge_error,judges_attitude], outputs=[population_plot])
+    judges_attitude.change(plot_skewed_normal_distribution, inputs=[alpha_slider, loc_slider,scale_slider,judge_error,judges_attitude], outputs=[population_plot])
 
+    demo.load(plot_skewed_normal_distribution, inputs=[alpha_slider, loc_slider,scale_slider,judge_error,judges_attitude], outputs=[population_plot])
+    demo.load(run_simulation_and_plot,inputs=[num_runs, num_applicants, num_judges, ratings_per_applicant, top_n, alpha_slider, loc_slider, scale_slider,  judge_error, judges_attitude, judgment_coarse_graining,judgment_coarse_graining_true_false],
+              outputs=[plot_output])
+    gr.Markdown(explanation_md)
 if __name__ == "__main__":
-    demo.launch(debug=True)
+    demo.launch(debug=True)
+
+"""Next steps:
+* Add inter-rater-agreement for the simulation.
+* ~make both population and judges Potentially skewed normals.~
+* Add parameter description and fazit. - This is about what we can expect from rankings.
+* add an explanation of graphics.
+* ~immediately run simulation~
+* ~get rid of active legend for large plots~
+"""
+
+# import gradio as gr
+# import numpy as np
+# import matplotlib.pyplot as plt
+# from scipy.stats import skewnorm
+
+# # Function to plot skewed normal distribution
+# def plot_skewed_normal(alpha, loc, scale):
+#     x = np.linspace(-10, 10, 1000)
+#     y = skewnorm.pdf(x, alpha, loc, scale)
+
+#     fig, ax = plt.subplots(figsize=(7, 3))
+#     plt.fill_between(x, y, color="#6a4c93", alpha=0.8)
+#     plt.xlabel('Value')
+#     plt.ylabel('Probability Density')
+#     ax.set_yticks([])  # Optional: Remove y-axis labels for cleaner look
+
+#     return fig
+
+# # Building the Gradio interface
+# with gr.Blocks() as demo:
+#     with gr.Column():
+#         gr.Markdown("# Explore the Skewed Normal Distribution")
+
+#         with gr.Row():
+#             with gr.Column():
+#                 # Control parameters of the skewed normal distribution
+#                 alpha_slider = gr.Slider(-10, 10, step=0.1, value=0, label="Alpha (Skewness)")
+#                 loc_slider = gr.Slider(-5, 5, step=0.1, value=0, label="Location (Mean)")
+#                 scale_slider = gr.Slider(0.1, 10, step=0.1, value=1, label="Scale (Standard Deviation)")
+
+#             with gr.Column():
+#                 # Plot output
+#                 plot_output = gr.Plot(label="Skewed Normal Distribution")
+
+#         # Update the plot based on slider changes
+#         alpha_slider.change(plot_skewed_normal, inputs=[alpha_slider, loc_slider, scale_slider], outputs=[plot_output])
+#         loc_slider.change(plot_skewed_normal, inputs=[alpha_slider, loc_slider, scale_slider], outputs=[plot_output])
+#         scale_slider.change(plot_skewed_normal, inputs=[alpha_slider, loc_slider, scale_slider], outputs=[plot_output])
+
+#         # Load initial plot
+#         demo.load(plot_skewed_normal, inputs=[alpha_slider, loc_slider, scale_slider], outputs=[plot_output])
+
+# if __name__ == "__main__":
+#     demo.launch()
+
+# import numpy as np
+# import matplotlib.pyplot as plt
+# from scipy.stats import skewnorm, norm
+
+# def plot_skewed_normal_distribution(alpha, loc, scale, judgement_variability, judge_error):
+#     x = np.linspace(0, 100, 1000)
+#     y_pop_dist = skewnorm.pdf(x, alpha, loc, scale)
+
+#     fig, ax = plt.subplots(figsize=(7, 3))  # Figure size
+#     plt.fill_between(np.linspace(0, 100, 1000), y_pop_dist, color="#ee4d5a", alpha=0.8)
+#     plt.xlabel('True Applicants Quality-Distribution')
+#     plt.xlim(0, 100)
+#     ax.set_yticklabels([])  # Remove y-axis labels
+
+#     # Judgement Variability Line
+#     line_length = judge_error
+#     line_x = [50 - line_length/2, 50 + line_length/2]
+#     plt.plot(line_x, [0, 0], color='black', linewidth=2)
+
+
+#     # Small Normal Distribution
+#     std_dev = judge_error / 2 / norm.ppf(0.975)
+#     small_dist_x = np.linspace(50 - 3*std_dev, 50 + 3*std_dev, 100)  # 3 standard deviations on each side
+#     small_dist_y = skewnorm.pdf(small_dist_x,0, loc=50, scale=std_dev)  #
+#     small_dist_y_scaled = small_dist_y / max(small_dist_y) * np.max(y_pop_dist)*.02  # Scale down for representation
+#     plt.plot(small_dist_x, small_dist_y_scaled, color='black', linewidth=2)
+#     plt.text(np.mean(line_x), np.max(y_pop_dist)*.05 + np.max(small_dist_y_scaled) , 'Judgement Variability', ha='center', va='bottom', color='black')
+
+
+
+#     plt.text(25, 0.008, 'Most Cranky', ha='center', va='bottom', color='black')
+#     # Small Normal Distribution Cranky judge
+#     std_dev = judge_error / 2 / norm.ppf(0.975)
+#     small_dist_x = np.linspace(25 - 3*std_dev, 25 + 3*std_dev, 100)  # 3 standard deviations on each side
+#     small_dist_y = skewnorm.pdf(small_dist_x,-judgement_variability, loc=25, scale=std_dev)  #
+#     small_dist_y_scaled = small_dist_y / max(small_dist_y) * 0.005  # Scale down for representation
+
+#     plt.plot(small_dist_x, small_dist_y_scaled, color='black', linewidth=2)
+
+#     plt.text(75, 0.008, 'Most Generous', ha='center', va='bottom', color='black')
+#         # Small Normal Distribution genereous judge
+#     std_dev = judge_error / 2 / norm.ppf(0.975)
+#     small_dist_x = np.linspace(75 - 3*std_dev, 75 + 3*std_dev, 100)  # 3 standard deviations on each side
+#     small_dist_y = skewnorm.pdf(small_dist_x,judgement_variability, loc=75, scale=std_dev)  #
+#     small_dist_y_scaled = small_dist_y / max(small_dist_y) * 0.005  # Scale down for representation
+
+#     plt.plot(small_dist_x, small_dist_y_scaled, color='black', linewidth=2)
+#     plt.show()
+
+#     return fig
+
+
+# # Example parameters
+# alpha = 5
+# loc = 50
+# scale = 10
+# judgement_variability = 2
+# judge_error = 8
+
+# # Call the function with the example parameters
+# plot = plot_skewed_normal_distribution(alpha, loc, scale, judgement_variability, judge_error)
+# plt.show()
+