Update app.R

app.R

@@ -1,15 +1,10 @@
 # -----------------------------
 # R Shiny App (K=3)
 # "largest-group-wins" scenario
-#
-# CHANGES:
-#   1. alpha-tilde3 = 1 - (tilde1 + tilde2).
-#   2. Checks that alpha0 > 0, all tilde-params > 0, and they sum to 1.
-#   3. Immediate computation on load (no action button).
-#   4. nsim up to 10k.
-# -----------------------------
+
 
 library(shiny)
+library(scales)
 
 # Helper: sample Dirichlet( alpha1, alpha2, alpha3 ) via Gamma shape draws.
 rdirichlet_3 <- function(n, alpha_vec) {
@@ -19,26 +14,34 @@ rdirichlet_3 <- function(n, alpha_vec) {
 
 # -----------------------------
 ui <- fluidPage(
-  titlePanel("Representation Index under Largest-Group-Wins (K=3)"),
+  titlePanel("Representation Index under SMD (Largest-Vote-Share-Wins) with K=3"),
   
   sidebarLayout(
     sidebarPanel(
-      numericInput("alpha0", "Concentration Parameter (alpha0):", 
-                   value = 4, min = 0.1, step = 0.1),
+      # Use sliderInput for alpha0
+      sliderInput("alpha0", "Concentration Parameter (alpha0):",
+                  min = 0.1, max = 200, value = 6, step = 0.1),
       
-      numericInput("alphaTilde1", "alpha-tilde1:", 0.41, min = 0.0001, step = 0.01),
-      numericInput("alphaTilde2", "alpha-tilde2:", 0.33, min = 0.0001, step = 0.01),
+      # Use sliderInput for alphaTilde1
+      sliderInput("alphaTilde1", "alpha-tilde1:",
+                  min = 0.01, max = 0.90, value = 0.45, step = 0.01),
+      
+      # Use sliderInput for alphaTilde2
+      sliderInput("alphaTilde2", "alpha-tilde2:",
+                  min = 0.01, max = 0.90, value = 0.34, step = 0.01),
       
       helpText("Note: alpha-tilde3 is automatically 1 - (tilde1 + tilde2)."),
-      helpText("All tilde-params must be positive and sum exactly to 1."),
+      helpText("All tilde-params must be positive and sum to 1."),
       
-      sliderInput("nsim", "Number of Dirichlet samples (Monte Carlo):",
-                  min = 1000, max = 10000, value = 5000, step = 1000)
+      # Removed the nsim slider; fix nsim = 10,000 internally
+      # sliderInput("nsim", "Number of Dirichlet samples (Monte Carlo):",
+      #             min = 1000, max = 10000, value = 5000, step = 1000)
     ),
     
     mainPanel(
       verbatimTextOutput("resultsText"),
-      plotOutput("plotPi")
+      plotOutput("plotPi"),
+      plotOutput("plotIndex")  # Representation Index vs. varied alpha0
     )
   )
 )
@@ -46,6 +49,10 @@ ui <- fluidPage(
 # -----------------------------
 server <- function(input, output) {
   
+  # We fix the number of MC draws at 10k
+  nsim_fixed <- 10000
+  
+  # Reactive expression computing the simulation results for the *current* alpha0
   dataSim <- reactive({
     # Read user inputs
     alpha0 <- input$alpha0
@@ -55,7 +62,7 @@ server <- function(input, output) {
     # Compute alpha-tilde3
     at3 <- 1 - (at1 + at2)
     
-    # Run validation checks:
+    # Validation checks
     validate(
       need(alpha0 > 0, 
            "alpha0 must be > 0"),
@@ -75,20 +82,19 @@ server <- function(input, output) {
     # Summation check (should be alpha0 if at1+at2+at3=1)
     alpha0_check <- sum(alpha_vec)
     
-    # Number of MC draws
-    nsim <- input$nsim
-    
     # Sample from Dirichlet
-    X <- rdirichlet_3(nsim, alpha_vec)
+    X <- rdirichlet_3(nsim_fixed, alpha_vec)
     
     # Identify which group is largest
     largest_index <- apply(X, 1, which.max)
-    pi_hat <- as.numeric(table(factor(largest_index, levels = c(1,2,3)))) / nsim
-    names(pi_hat) <- c("pi1", "pi2", "pi3")
+    pi_hat <- as.numeric(table(factor(largest_index, levels = c(1,2,3)))) / nsim_fixed
+    names(pi_hat) <- c("k=1", "k=3", "k=3")
     
     # Population fraction
     popFrac <- alpha_vec / alpha0_check
-    names(popFrac) <- c("popFrac1", "popFrac2", "popFrac3")
+    names(popFrac) <- c("k=1", 
+                        "k=2", 
+                        "k=3")
     
     # Representation index
     sq_diff <- (popFrac - pi_hat)^2
@@ -104,7 +110,7 @@ server <- function(input, output) {
     )
   })
   
-  # Display text results
+  # Display text results for the *current* alpha0
   output$resultsText <- renderPrint({
     res <- dataSim()
     
@@ -118,17 +124,17 @@ server <- function(input, output) {
         round(res$alpha0_check, 4),
         "(should match alpha0 if they sum to 1)\n\n")
     
-    cat("Estimated seat-winning probabilities (pi_k):\n")
+    cat("Estimated seat-winning probabilities:\n")
     print(round(res$pi_hat, 4))
     
-    cat("\nPopulation Fractions (alpha_k / sum(alpha_k)):\n")
+    cat("\nPopulation Fractions:\n")
     print(round(res$popFrac, 4))
     
-    cat("\nRepresentation Index (tilde{R}^SMD) ~\n")
+    cat("\nRepresentation Index:\n")
     cat(round(res$representation_index, 4), "\n")
   })
   
-  # Basic barplot comparison
+  # Basic barplot comparison for the *current* alpha0
   output$plotPi <- renderPlot({
     res <- dataSim()
     popFrac <- res$popFrac
@@ -137,16 +143,76 @@ server <- function(input, output) {
     op <- par(mfrow=c(1,2))
     
     barplot(popFrac,
-            main="Population Fractions (alpha_k / sum(alpha_k))",
+            main="Pop. Frac.",
+            cex.lab = 1.5, cex.main = 1.80,
             ylim=c(0,1), col="steelblue", ylab="Fraction")
     
     barplot(pi_hat,
-            main="Prob. of Winning Seat (pi_k)",
+            main="Win Seat Prob.",
+            cex.lab = 1.5, cex.main = 1.80,
             ylim=c(0,1), col="tomato", ylab="Probability")
     
     par(op)
   })
+  
+  # New plot: Representation Index vs. scaled alpha0 (log scale w/ scientific notation)
+  output$plotIndex <- renderPlot({
+    # We use the user's alpha0 and multiply by a range of factors
+    alpha0_base <- input$alpha0
+    alpha0_list <- alpha0_base * c(0.01, 0.1, 1, 10, 100, 1000)
+    
+    # We'll extract the tilde values from the *current* inputs as well
+    at1 <- input$alphaTilde1
+    at2 <- input$alphaTilde2
+    at3 <- 1 - (at1 + at2)
+    
+    # For each alpha0 in alpha0_list, compute the representation index
+    rep_index_vals <- sapply(alpha0_list, function(a0) {
+      alpha_vec <- c(a0 * at1, a0 * at2, a0 * at3)
+      
+      # Use the fixed 10k draws
+      X <- rdirichlet_3(nsim_fixed, alpha_vec)
+      
+      largest_index <- apply(X, 1, which.max)
+      pi_hat <- as.numeric(table(factor(largest_index, levels = c(1,2,3)))) / nsim_fixed
+      
+      popFrac <- alpha_vec / sum(alpha_vec)
+      sq_diff <- (popFrac - pi_hat)^2
+      1 - 0.5 * sum(sq_diff)
+    })
+    
+    # Helper to format scientific notation nicely
+    sci_lab <- function(x) format(x, scientific=TRUE, digits=2)
+    
+    # Plot with log scale on x-axis, plus scientific notation
+    # Create the plot with a logarithmic x-axis
+    options(scipen=999)
+    par(mar=c(5,5,3,1))
+    plot(alpha0_list, rep_index_vals,
+         type="b", pch=19, col="blue",
+         log="x", axes=FALSE, 
+         cex.axis = 1.5, 
+         cex = 1.5, 
+         cex.lab = 1.75, 
+         cex.main = 1.8,
+         xlab="",#expression(alpha[0]),
+         ylab="SMD Representation Index",
+         main=expression("Representation Index vs."~alpha[0]))
+    mtext(text = expression(alpha[0]:" Concentrated"%<->%"Dispersed"),
+          side = 1,
+          line = 3,
+          cex=1.5)
+    x_ticks <- axTicks(1)
+    abline(h=1, lty = 2, col = "gray")
+    text(x = mean(alpha0_list),
+         y = 1, 
+         col = "gray", 
+         cex = 1.5, 
+         label = "MMD Index")
+    axis(1, at=x_ticks, labels=(x_ticks))
+    axis(2)
+    box()
+  })
 }
 
-# -----------------------------
 shinyApp(ui=ui, server=server)