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
@#$#@#$#@
GRAPHICS-WINDOW
325
11
762
449
-1
-1
13.0
1
10
1
1
1
0
1
1
1
-16
16
-16
16
1
1
1
ticks
30.0

BUTTON
18
12
88
45
SETUP
setup
NIL
1
T
OBSERVER
NIL
NIL
NIL
NIL
1

CHOOSER
18
70
236
115
COURT-STRATEGY
COURT-STRATEGY
"Court-Default" "Avoider"
0

SLIDER
20
224
237
257
EXPECTATION-OF-DEFIANCE
EXPECTATION-OF-DEFIANCE
0
1
0.75
0.01
1
NIL
HORIZONTAL

BUTTON
86
12
188
45
PLAY ONCE
play
NIL
1
T
OBSERVER
NIL
NIL
NIL
NIL
0

BUTTON
177
12
324
45
PLAY REPEATEDLY 
play 
T
1
T
OBSERVER
NIL
NIL
NIL
NIL
0

PLOT
762
10
962
160
Defiances
Iterations
Defiance
0.0
100.0
0.0
10.0
true
false
"" ""
PENS
"default" 1.0 0 -16777216 true "" "plot gov-defied-now-count "
"pen-1" 1.0 2 -5298144 true "" "plot scope"

MONITOR
961
10
1072
55
# of Invalidations
total-number-invalidations
3
1
11

SLIDER
20
185
209
218
NUMBER-OF-GOV-AGENTS
NUMBER-OF-GOV-AGENTS
0
10
10.0
1
1
NIL
HORIZONTAL

MONITOR
961
63
1056
108
# of Defiances
total-number-defiances
17
1
11

MONITOR
961
113
1143
158
% of Decisions Defied
case-defy-average
3
1
11

SLIDER
22
263
194
296
POLARIZATION
POLARIZATION
0
1
0.8
0.01
1
NIL
HORIZONTAL

SLIDER
22
377
207
410
DEFIANCE-THRESHOLD
DEFIANCE-THRESHOLD
0
1
0.07
0.01
1
NIL
HORIZONTAL

CHOOSER
18
128
270
173
GOV-STRATEGY
GOV-STRATEGY
"Gov-Default"
0

PLOT
762
166
962
316
% of Decisions with Full Compliance 
Iterations
NIL
0.0
100.0
0.0
100.0
true
false
"" ""
PENS
"default" 1.0 0 -16777216 true "" "plot 100 * (case-comply-average)"

MONITOR
961
166
1146
211
% of Gov't Agent Defiance 
gov-defy-average
3
1
11

MONITOR
962
214
1052
259
Court Failure
failure-count
17
1
11

PLOT
762
322
962
472
Moving Average of Full Compliance
NIL
NIL
0.0
100.0
0.0
100.0
true
false
"" ""
PENS
"default" 1.0 0 -16777216 true "" "plot 100 * (1 - moving-defy-average)"
"pen-1" 1.0 0 -2674135 true "" "plot 100 * (1 - defiance-threshold) "

SLIDER
22
300
194
333
FRAGMENTATION
FRAGMENTATION
0
1
0.1
.01
1
NIL
HORIZONTAL

SLIDER
22
337
254
370
DISSATISFACTION-THRESHOLD
DISSATISFACTION-THRESHOLD
0
1
0.18
.01
1
NIL
HORIZONTAL

@#$#@#$#@
## 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. 

@#$#@#$#@
default
true
0
Polygon -7500403 true true 150 5 40 250 150 205 260 250

airplane
true
0
Polygon -7500403 true true 150 0 135 15 120 60 120 105 15 165 15 195 120 180 135 240 105 270 120 285 150 270 180 285 210 270 165 240 180 180 285 195 285 165 180 105 180 60 165 15

arrow
true
0
Polygon -7500403 true true 150 0 0 150 105 150 105 293 195 293 195 150 300 150

box
false
0
Polygon -7500403 true true 150 285 285 225 285 75 150 135
Polygon -7500403 true true 150 135 15 75 150 15 285 75
Polygon -7500403 true true 15 75 15 225 150 285 150 135
Line -16777216 false 150 285 150 135
Line -16777216 false 150 135 15 75
Line -16777216 false 150 135 285 75

bug
true
0
Circle -7500403 true true 96 182 108
Circle -7500403 true true 110 127 80
Circle -7500403 true true 110 75 80
Line -7500403 true 150 100 80 30
Line -7500403 true 150 100 220 30

butterfly
true
0
Polygon -7500403 true true 150 165 209 199 225 225 225 255 195 270 165 255 150 240
Polygon -7500403 true true 150 165 89 198 75 225 75 255 105 270 135 255 150 240
Polygon -7500403 true true 139 148 100 105 55 90 25 90 10 105 10 135 25 180 40 195 85 194 139 163
Polygon -7500403 true true 162 150 200 105 245 90 275 90 290 105 290 135 275 180 260 195 215 195 162 165
Polygon -16777216 true false 150 255 135 225 120 150 135 120 150 105 165 120 180 150 165 225
Circle -16777216 true false 135 90 30
Line -16777216 false 150 105 195 60
Line -16777216 false 150 105 105 60

car
false
0
Polygon -7500403 true true 300 180 279 164 261 144 240 135 226 132 213 106 203 84 185 63 159 50 135 50 75 60 0 150 0 165 0 225 300 225 300 180
Circle -16777216 true false 180 180 90
Circle -16777216 true false 30 180 90
Polygon -16777216 true false 162 80 132 78 134 135 209 135 194 105 189 96 180 89
Circle -7500403 true true 47 195 58
Circle -7500403 true true 195 195 58

circle
false
0
Circle -7500403 true true 0 0 300

circle 2
false
0
Circle -7500403 true true 0 0 300
Circle -16777216 true false 30 30 240

cow
false
0
Polygon -7500403 true true 200 193 197 249 179 249 177 196 166 187 140 189 93 191 78 179 72 211 49 209 48 181 37 149 25 120 25 89 45 72 103 84 179 75 198 76 252 64 272 81 293 103 285 121 255 121 242 118 224 167
Polygon -7500403 true true 73 210 86 251 62 249 48 208
Polygon -7500403 true true 25 114 16 195 9 204 23 213 25 200 39 123

cylinder
false
0
Circle -7500403 true true 0 0 300

dot
false
0
Circle -7500403 true true 90 90 120

face happy
false
0
Circle -7500403 true true 8 8 285
Circle -16777216 true false 60 75 60
Circle -16777216 true false 180 75 60
Polygon -16777216 true false 150 255 90 239 62 213 47 191 67 179 90 203 109 218 150 225 192 218 210 203 227 181 251 194 236 217 212 240

face neutral
false
0
Circle -7500403 true true 8 7 285
Circle -16777216 true false 60 75 60
Circle -16777216 true false 180 75 60
Rectangle -16777216 true false 60 195 240 225

face sad
false
0
Circle -7500403 true true 8 8 285
Circle -16777216 true false 60 75 60
Circle -16777216 true false 180 75 60
Polygon -16777216 true false 150 168 90 184 62 210 47 232 67 244 90 220 109 205 150 198 192 205 210 220 227 242 251 229 236 206 212 183

fish
false
0
Polygon -1 true false 44 131 21 87 15 86 0 120 15 150 0 180 13 214 20 212 45 166
Polygon -1 true false 135 195 119 235 95 218 76 210 46 204 60 165
Polygon -1 true false 75 45 83 77 71 103 86 114 166 78 135 60
Polygon -7500403 true true 30 136 151 77 226 81 280 119 292 146 292 160 287 170 270 195 195 210 151 212 30 166
Circle -16777216 true false 215 106 30

flag
false
0
Rectangle -7500403 true true 60 15 75 300
Polygon -7500403 true true 90 150 270 90 90 30
Line -7500403 true 75 135 90 135
Line -7500403 true 75 45 90 45

flower
false
0
Polygon -10899396 true false 135 120 165 165 180 210 180 240 150 300 165 300 195 240 195 195 165 135
Circle -7500403 true true 85 132 38
Circle -7500403 true true 130 147 38
Circle -7500403 true true 192 85 38
Circle -7500403 true true 85 40 38
Circle -7500403 true true 177 40 38
Circle -7500403 true true 177 132 38
Circle -7500403 true true 70 85 38
Circle -7500403 true true 130 25 38
Circle -7500403 true true 96 51 108
Circle -16777216 true false 113 68 74
Polygon -10899396 true false 189 233 219 188 249 173 279 188 234 218
Polygon -10899396 true false 180 255 150 210 105 210 75 240 135 240

house
false
0
Rectangle -7500403 true true 45 120 255 285
Rectangle -16777216 true false 120 210 180 285
Polygon -7500403 true true 15 120 150 15 285 120
Line -16777216 false 30 120 270 120

leaf
false
0
Polygon -7500403 true true 150 210 135 195 120 210 60 210 30 195 60 180 60 165 15 135 30 120 15 105 40 104 45 90 60 90 90 105 105 120 120 120 105 60 120 60 135 30 150 15 165 30 180 60 195 60 180 120 195 120 210 105 240 90 255 90 263 104 285 105 270 120 285 135 240 165 240 180 270 195 240 210 180 210 165 195
Polygon -7500403 true true 135 195 135 240 120 255 105 255 105 285 135 285 165 240 165 195

line
true
0
Line -7500403 true 150 0 150 300

line half
true
0
Line -7500403 true 150 0 150 150

pentagon
false
0
Polygon -7500403 true true 150 15 15 120 60 285 240 285 285 120

person
false
0
Circle -7500403 true true 110 5 80
Polygon -7500403 true true 105 90 120 195 90 285 105 300 135 300 150 225 165 300 195 300 210 285 180 195 195 90
Rectangle -7500403 true true 127 79 172 94
Polygon -7500403 true true 195 90 240 150 225 180 165 105
Polygon -7500403 true true 105 90 60 150 75 180 135 105

plant
false
0
Rectangle -7500403 true true 135 90 165 300
Polygon -7500403 true true 135 255 90 210 45 195 75 255 135 285
Polygon -7500403 true true 165 255 210 210 255 195 225 255 165 285
Polygon -7500403 true true 135 180 90 135 45 120 75 180 135 210
Polygon -7500403 true true 165 180 165 210 225 180 255 120 210 135
Polygon -7500403 true true 135 105 90 60 45 45 75 105 135 135
Polygon -7500403 true true 165 105 165 135 225 105 255 45 210 60
Polygon -7500403 true true 135 90 120 45 150 15 180 45 165 90

sheep
false
15
Circle -1 true true 203 65 88
Circle -1 true true 70 65 162
Circle -1 true true 150 105 120
Polygon -7500403 true false 218 120 240 165 255 165 278 120
Circle -7500403 true false 214 72 67
Rectangle -1 true true 164 223 179 298
Polygon -1 true true 45 285 30 285 30 240 15 195 45 210
Circle -1 true true 3 83 150
Rectangle -1 true true 65 221 80 296
Polygon -1 true true 195 285 210 285 210 240 240 210 195 210
Polygon -7500403 true false 276 85 285 105 302 99 294 83
Polygon -7500403 true false 219 85 210 105 193 99 201 83

square
false
0
Rectangle -7500403 true true 30 30 270 270

square 2
false
0
Rectangle -7500403 true true 30 30 270 270
Rectangle -16777216 true false 60 60 240 240

star
false
0
Polygon -7500403 true true 151 1 185 108 298 108 207 175 242 282 151 216 59 282 94 175 3 108 116 108

target
false
0
Circle -7500403 true true 0 0 300
Circle -16777216 true false 30 30 240
Circle -7500403 true true 60 60 180
Circle -16777216 true false 90 90 120
Circle -7500403 true true 120 120 60

tree
false
0
Circle -7500403 true true 118 3 94
Rectangle -6459832 true false 120 195 180 300
Circle -7500403 true true 65 21 108
Circle -7500403 true true 116 41 127
Circle -7500403 true true 45 90 120
Circle -7500403 true true 104 74 152

triangle
false
0
Polygon -7500403 true true 150 30 15 255 285 255

triangle 2
false
0
Polygon -7500403 true true 150 30 15 255 285 255
Polygon -16777216 true false 151 99 225 223 75 224

truck
false
0
Rectangle -7500403 true true 4 45 195 187
Polygon -7500403 true true 296 193 296 150 259 134 244 104 208 104 207 194
Rectangle -1 true false 195 60 195 105
Polygon -16777216 true false 238 112 252 141 219 141 218 112
Circle -16777216 true false 234 174 42
Rectangle -7500403 true true 181 185 214 194
Circle -16777216 true false 144 174 42
Circle -16777216 true false 24 174 42
Circle -7500403 false true 24 174 42
Circle -7500403 false true 144 174 42
Circle -7500403 false true 234 174 42

turtle
true
0
Polygon -10899396 true false 215 204 240 233 246 254 228 266 215 252 193 210
Polygon -10899396 true false 195 90 225 75 245 75 260 89 269 108 261 124 240 105 225 105 210 105
Polygon -10899396 true false 105 90 75 75 55 75 40 89 31 108 39 124 60 105 75 105 90 105
Polygon -10899396 true false 132 85 134 64 107 51 108 17 150 2 192 18 192 52 169 65 172 87
Polygon -10899396 true false 85 204 60 233 54 254 72 266 85 252 107 210
Polygon -7500403 true true 119 75 179 75 209 101 224 135 220 225 175 261 128 261 81 224 74 135 88 99

wheel
false
0
Circle -7500403 true true 3 3 294
Circle -16777216 true false 30 30 240
Line -7500403 true 150 285 150 15
Line -7500403 true 15 150 285 150
Circle -7500403 true true 120 120 60
Line -7500403 true 216 40 79 269
Line -7500403 true 40 84 269 221
Line -7500403 true 40 216 269 79
Line -7500403 true 84 40 221 269

wolf
false
0
Polygon -16777216 true false 253 133 245 131 245 133
Polygon -7500403 true true 2 194 13 197 30 191 38 193 38 205 20 226 20 257 27 265 38 266 40 260 31 253 31 230 60 206 68 198 75 209 66 228 65 243 82 261 84 268 100 267 103 261 77 239 79 231 100 207 98 196 119 201 143 202 160 195 166 210 172 213 173 238 167 251 160 248 154 265 169 264 178 247 186 240 198 260 200 271 217 271 219 262 207 258 195 230 192 198 210 184 227 164 242 144 259 145 284 151 277 141 293 140 299 134 297 127 273 119 270 105
Polygon -7500403 true true -1 195 14 180 36 166 40 153 53 140 82 131 134 133 159 126 188 115 227 108 236 102 238 98 268 86 269 92 281 87 269 103 269 113

x
false
0
Polygon -7500403 true true 270 75 225 30 30 225 75 270
Polygon -7500403 true true 30 75 75 30 270 225 225 270
@#$#@#$#@
NetLogo 6.0.4
@#$#@#$#@
@#$#@#$#@
@#$#@#$#@
<experiments>
  <experiment name="experiment" repetitions="30" runMetricsEveryStep="false">
    <setup>setup</setup>
    <go>play</go>
    <timeLimit steps="1000"/>
    <exitCondition>failure-count &gt; 0</exitCondition>
    <metric>precision court-score 0</metric>
    <metric>failure-count</metric>
    <metric>failure-count + ticks</metric>
    <metric>precision case-comply-average 2</metric>
    <metric>precision gov-defy-average 2</metric>
    <enumeratedValueSet variable="court-strategy">
      <value value="&quot;basic&quot;"/>
      <value value="&quot;basic-minimalist&quot;"/>
      <value value="&quot;basic-avoider&quot;"/>
      <value value="&quot;strategic-minimalist&quot;"/>
      <value value="&quot;strategic-avoider&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gov-strategy">
      <value value="&quot;case-sensitive-dynamic-phased&quot;"/>
    </enumeratedValueSet>
    <steppedValueSet variable="number-of-govs" first="2" step="2" last="10"/>
    <enumeratedValueSet variable="probability-of-defiance">
      <value value="0.5"/>
    </enumeratedValueSet>
    <steppedValueSet variable="polarization" first="0.2" step="0.2" last="1"/>
    <enumeratedValueSet variable="fragmentation">
      <value value="0.1"/>
      <value value="0.2"/>
      <value value="0.3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="defiance-threshold">
      <value value="0.2"/>
      <value value="0.5"/>
      <value value="10"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gov-strategy">
      <value value="&quot;dynamic&quot;"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="27.5. experiment" repetitions="20" runMetricsEveryStep="false">
    <setup>setup</setup>
    <go>play</go>
    <timeLimit steps="1000"/>
    <exitCondition>failure-count &gt; 0</exitCondition>
    <metric>precision court-score 0</metric>
    <metric>failure-count</metric>
    <metric>failure-count + ticks</metric>
    <metric>precision case-comply-average 2</metric>
    <metric>precision gov-comply-average 2</metric>
    <enumeratedValueSet variable="fragmentation">
      <value value="0.25"/>
      <value value="0.5"/>
      <value value="0.1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="court-strategy">
      <value value="&quot;basic&quot;"/>
      <value value="&quot;basic-avoider&quot;"/>
      <value value="&quot;basic-minimalist&quot;"/>
      <value value="&quot;strategic-avoider&quot;"/>
      <value value="&quot;strategic-minimalist&quot;"/>
    </enumeratedValueSet>
    <steppedValueSet variable="number-of-govs" first="2" step="2" last="10"/>
    <steppedValueSet variable="polarization" first="0.2" step="0.2" last="1"/>
    <enumeratedValueSet variable="probability-of-defiance">
      <value value="0.5"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="dissatisfaction-threshold">
      <value value="0.25"/>
      <value value="0.5"/>
      <value value="0.75"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="defiance-threshold">
      <value value="0"/>
      <value value="0.25"/>
      <value value="0.5"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gov-strategy">
      <value value="&quot;dynamic&quot;"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="4.9 experiment" repetitions="10" runMetricsEveryStep="false">
    <setup>setup</setup>
    <go>play</go>
    <timeLimit steps="1000"/>
    <exitCondition>failure-count &gt; 0</exitCondition>
    <metric>precision court-score 0</metric>
    <metric>failure-count</metric>
    <metric>failure-count + ticks</metric>
    <metric>precision case-comply-average 2</metric>
    <metric>precision gov-comply-average 2</metric>
    <enumeratedValueSet variable="court-strategy">
      <value value="&quot;basic-random&quot;"/>
      <value value="&quot;avoider&quot;"/>
      <value value="&quot;minimalist&quot;"/>
      <value value="&quot;strategic-avoider&quot;"/>
      <value value="&quot;strategic-minimalist&quot;"/>
      <value value="&quot;gambler&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="number-of-govs">
      <value value="2"/>
      <value value="4"/>
      <value value="6"/>
      <value value="8"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="polarization">
      <value value="0.2"/>
      <value value="0.4"/>
      <value value="0.6"/>
      <value value="0.8"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="fragmentation">
      <value value="0.1"/>
      <value value="0.2"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="probability-of-defiance">
      <value value="0.2"/>
      <value value="0.4"/>
      <value value="0.6"/>
      <value value="0.8"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="dissatisfaction-threshold">
      <value value="0.25"/>
      <value value="0.5"/>
      <value value="0.75"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="defiance-threshold">
      <value value="0"/>
      <value value="0.25"/>
      <value value="0.5"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gov-strategy">
      <value value="&quot;dynamic&quot;"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="experiment" repetitions="1" runMetricsEveryStep="true">
    <setup>setup</setup>
    <go>go</go>
    <metric>count turtles</metric>
    <enumeratedValueSet variable="FRAGMENTATION">
      <value value="0.1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="EXPECTATION-OF-DEFIANCE">
      <value value="0.41"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="DISSATISFACTION-THRESHOLD">
      <value value="0.2"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="POLARIZATION">
      <value value="0.52"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="GOV-STRATEGY">
      <value value="&quot;gov-default&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="DEFIANCE-THRESHOLD">
      <value value="0.2"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="dynamic-cases?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="NUMBER-OF-GOV-AGENTS">
      <value value="10"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="COURT-STRATEGY">
      <value value="&quot;court-default&quot;"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="experiment" repetitions="1" runMetricsEveryStep="true">
    <setup>setup</setup>
    <go>go</go>
    <metric>count turtles</metric>
    <enumeratedValueSet variable="FRAGMENTATION">
      <value value="0.1"/>
      <value value="0.2"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="EXPECTATION-OF-DEFIANCE">
      <value value="0.61"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="POLARIZATION">
      <value value="0.25"/>
      <value value="0.5"/>
      <value value="0.75"/>
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="DISSATISFACTION-THRESHOLD">
      <value value="0.2"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="DEFIANCE-THRESHOLD">
      <value value="0.1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="dynamic-cases?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="NUMBER-OF-GOV-AGENTS">
      <value value="2"/>
      <value value="4"/>
      <value value="6"/>
      <value value="8"/>
      <value value="10"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="dynamic">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="COURT-STRATEGY">
      <value value="&quot;court-default&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="GOV-STRATEGY">
      <value value="&quot;gov-dynamic&quot;"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="experiment 27.22.2019" repetitions="20" runMetricsEveryStep="false">
    <setup>setup</setup>
    <go>play</go>
    <timeLimit steps="1000"/>
    <exitCondition>failure-count &gt; 0</exitCondition>
    <metric>precision court-score 0</metric>
    <metric>failure-count</metric>
    <metric>failure-count + ticks</metric>
    <metric>precision case-comply-average 2</metric>
    <metric>precision gov-comply-average 2</metric>
    <enumeratedValueSet variable="NUMBER-OF-GOV-AGENTS">
      <value value="2"/>
      <value value="4"/>
      <value value="6"/>
      <value value="8"/>
      <value value="10"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="POLARIZATION">
      <value value="0.2"/>
      <value value="0.4"/>
      <value value="0.6"/>
      <value value="0.8"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="FRAGMENTATION">
      <value value="0.1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="EXPECTATION-OF-DEFIANCE">
      <value value="0.25"/>
      <value value="0.5"/>
      <value value="0.75"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="DISSATISFACTION-THRESHOLD">
      <value value="0.25"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="DEFIANCE-THRESHOLD">
      <value value="0"/>
      <value value="0.25"/>
      <value value="0.5"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="COURT-STRATEGY">
      <value value="&quot;court-default&quot;"/>
      <value value="&quot;avoider&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="GOV-STRATEGY">
      <value value="&quot;gov-dynamic&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="dynamic-cases?">
      <value value="false"/>
    </enumeratedValueSet>
  </experiment>
</experiments>
@#$#@#$#@
@#$#@#$#@
default
0.0
-0.2 0 0.0 1.0
0.0 1 1.0 0.0
0.2 0 0.0 1.0
link direction
true
0
Line -7500403 true 150 150 90 180
Line -7500403 true 150 150 210 180
@#$#@#$#@
0
@#$#@#$#@