Judicial Review

No preview image

1 collaborator

WHAT IS IT?

This model explores how judicial power evolves over the course of a sequence of interactions between a constitutional court (“the Court”) and political branches of government. In particular, it is designed to show how a newly established constitutional court might build its authority – or fail to do so – depending on its strategic choices and the political and institutional conditions in its encompassing environment.

As constitutional challenges arise, the Court must decide to uphold or invalidate a challenged policy. In doing so, the Court is influenced by the direction and strength of its own policy preferences, its belief about how likely the political branches are to comply with its decisions, and its strategic sensibilities (a heuristic decision rule it follows in each case). If the court invalidates a policy, the political branches may decide to comply with or defy the Court. In doing so, the political branches are influenced by the direction and strength of their own policy preferences, as well as existing expectations about compliance with the Court’s decisions. If at any time the political branches decide that the Court costs them too much in preferred policy outcomes, they can attempt to coordinate a court-curbing attack. If they succeed in doing so, the simulation ends.

HOW IT WORKS

At the very beginning of the simulation, NetLogo “breeds” the Court and N Government Agents (these represent the political branches). The number of Government Agents is determined by an adjustable parameter (NUMBER-OF-GOV-AGENTS). This parameter allows the simulation to model varying degrees of institutional complexity. A very simple context would include the Court and just a single Government Agent; a more complex context – for example a federal system – might include dozens of Government Agents representing a set of autonomous legislatures and/or executives.

Two adjustable parameters – POLARIZATION and FRAGMENTATION – model the policy preferences of the Court and Government Agents. POLARIZATION determines how likely the Court is to disagree with existing policy and how likely, on average, the Government Agents are to disagree with the Court. FRAGMENTATION models the variance in policy preferences among Government Agents, i.e., how likely the Government Agents are to disagree with one another.

At the beginning of each “step” in the simulation, a case is generated and assigned a random CASE-SALIENCE value, ranging from 0 to 1 (drawn from a normal distribution). This variable represents how politically important the case is to the agents in the simulation. As in the real world, not all cases will attract the same level of attention. Some cases will be very high profile and divisive; other cases will be relatively low profile. Each case in the simulation is also assigned a random CASE-SCOPE interval that determines the range of government agents that may be affected by the Court’s decision. As in the real world, some cases will have broad policy consequences across the system while others – even if highly salient – will have relatively narrow consequences.

Once a case is generated, POLARIZATION will determine if the Court agrees or disagrees with the challenged policy. If the Court disagrees, it must decide either to invalidate the policy or, alternatively, uphold the policy even though it disagrees with it. This decision is a function of a decision rule determined by COURT-STRATEGY. The Court-Default decision rule is a probabilistic one: if the Court disagrees with a policy, it will decide to invalidate it with a probability equal to the CASE-SALIENCE value (i.e., the more salient the case is, the more likely the court will be to invalidate it). An alternative decision rule – called Avoider – will invalidate policy it disagrees with but with a probability inversely proportionate to the CASE-SALIENCE value. In other words, Avoider aims for policy victories in relatively low-salience cases.

In response to the Court’s decision, the affected Government Agents (as determined by CASE-SCOPE) will each make an independent decision to comply or defy. In this most basic version of the simulation, compliance/defiance is a function of two parameters: CASE-SALIENCE and EXPECTATION-OF-DEFIANCE (the mean of these two values in a given case determines the probability of defiance). In the default setting of the simulation, EXPECTATION-OF-DEFIANCE is simply equal to the proportion of previous decisions that have been defied in the past. Hence, other things being equal, the Government Agents start the simulation with a strong inclination to comply with the Court (because, in that initial state, EXPECTATION-OF-DEFIANCE = 0). However, this parameter is adjustable so that varying baseline expectations of compliance/defiance can be set to model a continuum of contexts, from a context in which there is a very strong initial expectation of judicial power to one in which judicial power is tenuous and expected to fail from the outset.

Once the Court and affected Government Agents have made their decisions, each agent collects a payoff in utility according to the following scheme:

1) If the Court invalidates a policy, then the Court collects utility equivalent to the product of CASE-SALIENCE and the number of affected Government Agents that comply with the decision. Meanwhile. affected Government Agents that agree with the policy suffer a loss equivalent to CASE-SALIENCE.

2) If the Court upholds a policy that it disagrees with, affected Government Agents that agree with the policy collect utility equivalent to CASE-SALIENCE. Meanwhile, the Court suffers a loss equivalent to the product of CASE-SALIENCE and the number of affected Government Agents.

3) If the Court upholds a policy that it agrees with, then the Court suffers no loss and affected Government Agents that agree with the policy collect utility equivalent to CASE-SALIENCE.

When a Government Agent’s utility score drops below zero, it becomes UNHAPPY and it will consider launching a court-curbing attack (e.g., impeachment of judges; jurisdiction stripping; suspending the Court, etc.). The success of this attack depends on two final threshold parameters. The first of these – DEFIANCE-THRESHOLD – represents theoretical expectations about the influence of past defiance on the probability of a present court-curbing attack. Setting this parameter very high models an expectation that Government Agents are cautious about court-curbing and so, even if they are UNHAPPY, they will not attempt an attack until a recent history of defiance suggests that the Court’s authority is already failing. Conversely, setting this parameter at a relatively low level represents an expectation that Government Agents are more cavalier about the costs of court curbing and do not need to perceive much, if any, weakness in the Court’s authority before launching an attack. The second threshold parameter - DISSATISFACTION-THRESHOLD – determines the proportion of Government Agents that must be simultaneously UNHAPPY for a coordinated court-curbing attack to succeed. The idea here is to model the influence of institutional veto points that make a court-curbing attack require the coordinated effort of several Government Agents at once.

HOW TO USE IT

To prepare the simulation, set the parameters at the desired levels and press “SETUP”. To advance the simulation by a single step, press “PLAY ONCE”. To run the simulation continuously, press “PLAY REPEATEDLY”. The simulation will run until there is a successful attack against the Court. To reset and begin again, press “SETUP”.

THINGS TO NOTICE

You will see a visualization of the model in the center display showing the Court (represented by a blue house) and the Government Agents (represented by a circle of faces). The color of each Government Agent changes depending on how each reacts to the Court (they turn green when they comply and red when they defy). Each Government Agent’s facial expression will also change depending on its current attitude to the Court; it will begin with a neutral expression, but will change to a happy expression when the Court is expected to rule in its favor or change to an unhappy expression when the Court is expected to rule against it. The number in the middle of display shows how many “points” in policy utility the Court has accumulated thus far in the simulation.

The plots on the right side of the screen track the Court’s authority. They show the number of Government Agents defying the Court at each step; the percentage of Court decisions that have been complied with by all Government Agents; and the moving average of cases that been complied with by all Government Agents.

THINGS TO TRY

By varying parameter settings, one can investigate how the probability of a successful court-curbing attack covaries or is robust to the Court’s behavior and the system’s conditions.

What difference does COURT-STRATEGY make? Does the Court do better to adopt an Avoider strategy than the Default strategy? If so, is this advantage robust across parameter settings?

Holding other parameters constant, try adjusting POLZARIZATION to model different levels of policy disagreement; above what level of POLARIZATION does the environment become too hostile for the Court to survive beyond 100 steps? Below what level of POLARIZATION is the Court safe from court-curbing attacks?

Try adjusting EXPECTATION-OF-DEFIANCE to model different kinds of environments. Do initially favorable conditions make much of a difference for the Court’s prospects?

EXTENDING THE MODEL

The model makes several simplifying assumptions. One of these is that the policy preferences of the Court and Government Agents are static and fixed at the outset. One potential extension of the model is to simulate the influence of occasional elections so that the preferences of the Government Agents change at regular intervals. Adding elections would make the simulation more dynamic by introducing exogenous shocks that change the probability of policy disagreement. Thus, a Court that is relatively safe may abruptly find itself in a much more hostile political environment. A simple way to model the influence of elections is to reset at new random values POLARIZATION and FRAGMENTATION every 100 steps. A further extension would make the competitiveness of elections an adjustable parameter. A COURT-STRATEGY might also be designed to take the competitiveness of elections into account in deciding to uphold or invalidate policy.

CREDITS AND REFERENCES

If you mention this model or the NetLogo software in a publication, please include the citations below.

For the model itself: • Schwartz, A. (2019). NetLogo Judicial Review model.

Please cite the NetLogo software as: • Wilensky, U. (1999). NetLogo. http://ccl.northwestern.edu/netlogo/. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.

Comments and Questions

Please start the discussion about this model! (You'll first need to log in.)

Click to Run Model

breed [govs gov]
breed [courts court ]


globals [
  court-alive?                     ;is the court still in operation?
  court-invalidated-now?           ;what did the court do this round? (true or false)
  gov-defied-now?                  ;did anyone defy this round (true or false)?
  gov-complied-now?                ;did everyone comply this round (true of false)?
  gov-defied-now-count             ;# of govs defying this turn
  gov-complied-now-count           ;# of govs complying this turn
  last-turn-defied                 ;percentage defiance in last turn
  second-last-turn-defied          ;
  third-last-turn-defied           ;
  fourth-last-turn-defied          ;
  fifth-last-turn-defied           ;
  sixth-last-turn-defied           ;
  seventh-last-turn-defied         ;
  eighth-last-turn-defied          ;
  ninth-last-turn-defied           ;
  tenth-last-turn-defied           ;
  eleventh-last-turn-defied        ;
  twelfth-last-turn-defied         ;
  thirteenth-last-turn-defied      ;
  fourteenth-last-turn-defied      ;
  fifteenth-last-turn-defied       ;
  sixteenth-last-turn-defied       ;
  seventeenth-last-turn-defied     ;
  eighteenth-last-turn-defied      ;
  nineteenth-last-turn-defied      ;
  twentieth-last-turn-defied       ;
  total-number-invalidations       ;how many times has the court invalidated law/policy?
  scope-count                      ;a running sum of the number of times gov't agents have been affected by court invalidations
  total-number-defiances           ;how many times have gov't agents defied?
  total-number-compliances         ;how many times have gov't agents complied?
  number-of-cases-defied           ;how many cases with at least one defiance?
  number-of-cases-complied         ;how many cases with no defiance?
  case-defy-average                ;number of times a decision has had at least one defiance / number of invalidations
  case-comply-average              ;number of times a decision has had no defiances / number of invalidations
  gov-defy-average                 ;the rate of defiance by gov't agents
  moving-defy-average              ;average rate of defiance over the last 20 invalidations
  gov-comply-average               ;the rate of compliance by gov't agents
  sum-salience-weights             ;a running tally of the importance of decisions
  standing-defiance-average        ;a running tally of the average defiance of decisions
  weighted-average-defiance        ; average-defiance rate of decisions weighted by case-salience
  failure-count                    ;number of times the court has 'failed'
  number-of-unhappy-govs           ;the number of gov't agents who are disatisfied with the court
  percentage-of-unhappy-govs       ;the percentage of gov't agents who are disatisfied with the court

  ;;; case variables ;;;
  case-salience                    ;how important is this case in general?
  max-case-scope                   ;the maximum number of gov't agents potentially affected by the outcome of this case
  min-case-scope                   ;the minimum number of gov't agents potentially affected by the outcome of this case
  minimalist?                      ;is the court being minimalist? (true of false)
  scope                            ;number of gov't agents actually affected by the case outcome
  court-payoff                     ;an observer-based measure of what court scores (potential-court-payoff * gov-complied-now-count)
  court-score                      ;an observer-based tally of the court's accumulated score
  court-case-preference            ;an observer-based record of the court's preference (1 to invalidate; 0 to uphold)
  court-case-salience              ;an observer-based measure of how important the case is to the court
  case-defiance-average            ;the proportion of Gov't Agents defying this case
]

courts-own [
score ;current payoff
]

govs-own [
gov-ideology          ;how likely is the gov't agent to disagree with the court? (0.0-1.0)
gov-case-preference   ;does the gov't agent support the law/policy at issue (1 if yes; 0 if no)
gov-payoff            ;gov-case-salience
gov-court-utility     ;the Gov't Agent's expected policy utitlity of retaining an independent Court
unhappy?              ;does the Gov't Agent expect the Court to cost it a net loss in policy utitily?
]

to setup
  clear-all
  ; create a court and place it in the center of the world
  set-default-shape courts "house"
  create-courts 1 [
    set heading 270
    set size 5
    set color 106
  ]
  ; create govs and place them in a cicle
  set-default-shape govs "face neutral"

  create-govs NUMBER-OF-GOV-AGENTS [
    set size 3
    set color white
  ]

  layout-circle govs (max-pxcor - 1)

  ask govs [set gov-ideology random-normal polarization fragmentation]

  ; set a blank slate

set court-alive? true
set number-of-unhappy-govs 0
set total-number-invalidations 0
set total-number-compliances 0
set total-number-defiances     0
set number-of-cases-defied     0
ask courts [set score 0]
set court-score 0
set scope-count 0
set failure-count 0
set gov-defy-average 0
set case-defy-average 0
set moving-defy-average 0
set case-comply-average .5
set gov-comply-average .5
set case-defiance-average 0
set sum-salience-weights 0
set weighted-average-defiance 0
ask govs [set gov-court-utility 0 set unhappy? 0]
reset-ticks
end 

;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Runtime Procedures;;;
;;;;;;;;;;;;;;;;;;;;;;;;;

to play
  if court-alive? [play-a-round tick prepare-next-round]
end 

to play-a-round
  set gov-defied-now-count 0
  set gov-complied-now-count 0

  set case-salience random-normal .5 .15
  set max-case-scope random NUMBER-OF-GOV-AGENTS
  set min-case-scope random (max-case-scope * .5)
  set number-of-unhappy-govs 0

  ask govs [ifelse random-float 1.0 >= .5
    [set case-salience case-salience + random-float .15]
    [set case-salience case-salience - random-float .15]]

  ifelse random-float 1.0 >= .5
    [set court-case-salience case-salience + random-float .15]
    [set court-case-salience case-salience - random-float .15]

  ifelse polarization >= random-float 1.0
    [set court-case-preference 1]
    [set court-case-preference 0]


  ;run the strategy selected for the court
  ask courts [run court-strategy]

  ask govs [ifelse gov-ideology >= random-float 1.0
    [set gov-case-preference 1]
    [set gov-case-preference 0]]

  ;run the strategy selected for the govs
  ifelse minimalist?
    [set scope min-case-scope]
    [set scope max-case-scope]

  ask n-of scope govs
   [get-gov-payoff
   if court-invalidated-now? [run gov-strategy]]

  set case-defiance-average gov-defied-now-count / (scope + 1)

  ask govs [if gov-court-utility < 0   [set unhappy? 1] ]
  ask govs [if gov-court-utility > 0 [set unhappy? -1]]
  ask govs [if gov-court-utility = 0 [set unhappy? 0]]
  ask govs [if unhappy? = 1 [set number-of-unhappy-govs number-of-unhappy-govs + 1]]
  ask govs [if unhappy? = 1 [set shape "face sad"]]
  ask govs [if unhappy? = -1 [set shape "face happy"]]
  ask govs [if unhappy? = 0 [set shape "face neutral"]]

  set percentage-of-unhappy-govs (number-of-unhappy-govs / NUMBER-OF-GOV-AGENTS)

  ifelse (dissatisfaction-threshold < percentage-of-unhappy-govs) and (defiance-threshold < moving-defy-average)
    [ifelse random-float 1.0 < gov-defy-average
      [set court-alive? false]
      [set court-alive? true]]
   [set court-alive? true]

  ifelse court-alive?
   [ask courts [set shape "house"]]
   [ask courts [set shape "x" set failure-count failure-count + 1]]
end 

to prepare-next-round
  update-invalidations

  if court-invalidated-now?
  [update-defiance
  update-compliance
  update-defiance-history
  update-global-defy-average
  update-moving-defy-average
  update-global-comply-average
  update-court-payoff
  update-scope-count
  update-gov-defy-average
  update-gov-comply-average
  update-weighted-average-defiance
  ]

  ask courts [get-court-payoff]
  ask courts [set label pay-off]

  update-court-score
end 

to update-invalidations
  ifelse court-invalidated-now?
    [set  total-number-invalidations   total-number-invalidations + 1]
    [set total-number-invalidations total-number-invalidations]
end 

to update-defiance
  ifelse court-invalidated-now?
    [set total-number-defiances total-number-defiances + gov-defied-now-count]
    [set total-number-defiances total-number-defiances]

  ifelse court-invalidated-now?
    [ifelse gov-defied-now-count > 0 [set gov-defied-now? true] [set gov-defied-now? false]]
    [set gov-defied-now? false]

  ifelse court-invalidated-now?
    [ifelse gov-defied-now? [set number-of-cases-defied number-of-cases-defied + 1] [set number-of-cases-defied number-of-cases-defied]]
    [set number-of-cases-defied number-of-cases-defied]
end 

to  update-compliance
  ifelse court-invalidated-now?
  [set total-number-compliances total-number-compliances + gov-complied-now-count]
  [set total-number-compliances total-number-compliances]

  ifelse court-invalidated-now?
    [ifelse gov-defied-now-count > 0 [set gov-complied-now? false] [set gov-complied-now? true]]
    [set gov-complied-now? false]

  ifelse court-invalidated-now?
    [ifelse gov-complied-now? [set number-of-cases-complied number-of-cases-complied + 1] [set number-of-cases-complied number-of-cases-complied]]
    [set number-of-cases-complied number-of-cases-complied]
end 

to update-court-payoff
ifelse minimalist?
  [set court-payoff (case-salience * gov-complied-now-count)]
  [set court-payoff (case-salience * gov-complied-now-count)]
end 

to update-defiance-history
 ifelse court-invalidated-now?
  [
  set twentieth-last-turn-defied nineteenth-last-turn-defied
  set nineteenth-last-turn-defied eighteenth-last-turn-defied
  set eighteenth-last-turn-defied seventeenth-last-turn-defied
  set seventeenth-last-turn-defied sixteenth-last-turn-defied
  set sixteenth-last-turn-defied fifteenth-last-turn-defied
  set fifteenth-last-turn-defied fourteenth-last-turn-defied
  set fourteenth-last-turn-defied thirteenth-last-turn-defied
  set thirteenth-last-turn-defied twelfth-last-turn-defied
  set twelfth-last-turn-defied eleventh-last-turn-defied
  set eleventh-last-turn-defied tenth-last-turn-defied
  set tenth-last-turn-defied ninth-last-turn-defied
  set ninth-last-turn-defied eighth-last-turn-defied
  set eighth-last-turn-defied seventh-last-turn-defied
  set seventh-last-turn-defied sixth-last-turn-defied
  set sixth-last-turn-defied fifth-last-turn-defied
  set fifth-last-turn-defied fourth-last-turn-defied
  set fourth-last-turn-defied third-last-turn-defied
  set third-last-turn-defied second-last-turn-defied
  set second-last-turn-defied last-turn-defied
  ifelse gov-defied-now? [set last-turn-defied 1] [set last-turn-defied 0]
  ]

  [ set twentieth-last-turn-defied twentieth-last-turn-defied
    set nineteenth-last-turn-defied nineteenth-last-turn-defied
    set eighteenth-last-turn-defied eighteenth-last-turn-defied
    set seventeenth-last-turn-defied seventeenth-last-turn-defied
    set sixteenth-last-turn-defied sixteenth-last-turn-defied
    set fifteenth-last-turn-defied fifteenth-last-turn-defied
    set fourteenth-last-turn-defied fourteenth-last-turn-defied
    set thirteenth-last-turn-defied thirteenth-last-turn-defied
    set twelfth-last-turn-defied twelfth-last-turn-defied
  set eleventh-last-turn-defied eleventh-last-turn-defied
  set tenth-last-turn-defied tenth-last-turn-defied
  set ninth-last-turn-defied ninth-last-turn-defied
  set eighth-last-turn-defied eighth-last-turn-defied
  set seventh-last-turn-defied seventh-last-turn-defied
  set sixth-last-turn-defied sixth-last-turn-defied
  set fifth-last-turn-defied fifth-last-turn-defied
  set fourth-last-turn-defied fourth-last-turn-defied
  set third-last-turn-defied third-last-turn-defied
  set second-last-turn-defied second-last-turn-defied]
end 

to update-global-defy-average
  set case-defy-average (number-of-cases-defied) / (total-number-invalidations)
end 

to update-global-comply-average
  set case-comply-average (number-of-cases-complied) / (total-number-invalidations)
end 

to update-weighted-average-defiance
  set standing-defiance-average standing-defiance-average + case-defiance-average
  set sum-salience-weights  sum-salience-weights + (case-salience * scope)
  set weighted-average-defiance (standing-defiance-average / (sum-salience-weights + 1))
end 

to update-scope-count
  ifelse court-invalidated-now?
    [ifelse minimalist? [set scope-count scope-count + min-case-scope]
    [set scope-count scope-count + max-case-scope]]
    [set scope-count scope-count]
end 

to update-gov-defy-average
  set gov-defy-average (total-number-defiances / (scope-count + 1))
end 

to update-gov-comply-average
  set gov-comply-average (1 - gov-defy-average)
end 

to update-moving-defy-average
 ifelse court-invalidated-now?
    [set moving-defy-average  (last-turn-defied + second-last-turn-defied + third-last-turn-defied + fourth-last-turn-defied + fifth-last-turn-defied + sixth-last-turn-defied + seventh-last-turn-defied + eighth-last-turn-defied + ninth-last-turn-defied + tenth-last-turn-defied + eleventh-last-turn-defied + twelfth-last-turn-defied + thirteenth-last-turn-defied + fourteenth-last-turn-defied + fifteenth-last-turn-defied + sixteenth-last-turn-defied + seventeenth-last-turn-defied + eighteenth-last-turn-defied + nineteenth-last-turn-defied + twentieth-last-turn-defied) / 20]
    [set moving-defy-average moving-defy-average]
end 

to update-salience-effect-average
end 

to-report pay-off; Turtle reporter
  report precision score 2
end 

to-report average-score-by-invalidations ; Turtle reporter
  report precision (score / (total-number-invalidations + 1)) 3
end 

to-report average-score-by-ticks ; Turtle reporter
  report precision (score / (ticks + 1)) 3
end 

to-report average-defiance ; Turtle reporter
  report precision (number-of-cases-defied / (total-number-invalidations + 1)) 3
end 


;;;;;;;;;;;;;;;;;;;;;;;;
;;; Court Strateegies ;;;
;;;;;;;;;;;;;;;;;;;;;;;;

to Court-Default
  set minimalist? one-of [true false]
  ifelse (court-case-preference = 1) and (random-float 1.0 <= case-salience)
    [set court-invalidated-now? true]
    [set court-invalidated-now? false]
end 

to Avoider

  set minimalist? false
  ifelse (court-case-preference = 1) and (case-salience < .5)
        [set court-invalidated-now? true]
        [set court-invalidated-now? false]
end 



;;;;;;;;;;;;;;;;;;;;;;
;;; Gov Strategies ;;;
;;;;;;;;;;;;;;;;;;;;;;

to Defy-randomly
  ifelse random-float 1.0 >= .5
    [set gov-defied-now-count gov-defied-now-count + 1 set shape "face sad" set color red]
    [set gov-complied-now-count gov-complied-now-count + 1 set shape "face happy" set color green]
end 

to Defy-never
   set gov-complied-now-count gov-complied-now-count + 1 set shape "face happy" set color green
end 

to Defy-always
  set gov-defied-now-count gov-defied-now-count + 1 set shape "face sad" set color red
end 

to Gov-Default

ifelse total-number-invalidations < 1

[ifelse (gov-case-preference = 1) and (random-float 1.0 <= (case-salience + EXPECTATION-OF-DEFIANCE / 2))
     [set gov-defied-now-count gov-defied-now-count + 1 set color red ]
     [set gov-complied-now-count gov-complied-now-count + 1 set color green]]

[ifelse (gov-case-preference = 1) and (random-float 1.0 <= (case-salience + standing-defiance-average / 2))
     [set gov-defied-now-count gov-defied-now-count + 1 set color red ]
     [set gov-complied-now-count gov-complied-now-count + 1 set color green]]
end 

;;;;;;;;;;;;;;;
;; Payoffs ;;;;
;;;;;;;;;;;;;;;

to get-court-payoff ;
  ifelse court-invalidated-now?[set score score + court-payoff ][set score score]
end 

to update-court-score
  ifelse court-invalidated-now?
   [set court-score court-score + court-payoff]
   [set court-score court-score]
end 

to get-gov-payoff
  ifelse court-invalidated-now?
   [ifelse gov-case-preference = 1
      [set gov-court-utility gov-court-utility - case-salience]
      [set gov-court-utility gov-court-utility + case-salience]]

  [ifelse gov-case-preference = 1
      [set gov-court-utility gov-court-utility + case-salience]
      [set gov-court-utility gov-court-utility]]
end

There is only one version of this model, created over 6 years ago by Alex Schwartz.

Attached files

No files

This model does not have any ancestors.

This model does not have any descendants.

NetLogo