naming-game.jl

### A Pluto.jl notebook ###
# v0.17.4

using Markdown
using InteractiveUtils

# ╔═╡ 22c16f23-cb6e-4b15-922b-32c4e4b9baba
# This notebook was written with `[julia version 1.6.3]`.
begin
	using Agents
	using Graphs
	using Distributions
	using StatsPlots
	using ColorSchemes
	using StatsFuns
	using GraphRecipes
	using LaTeXStrings
	using DrWatson: @dict
	using Random
	using DataFramesMeta
	using StatsBase
	using PlutoUI

	begin # plot settings
		DPI = 300 # 1200 for poster
		FONT = "Arial"
		COLORSCHEME = ColorSchemes.Greys
		
		gr(dpi = DPI)
		default(fontfamily = FONT)
	end

	TableOfContents()
end

# ╔═╡ ff785b01-f0f3-4feb-9fc0-f07a5b86faa5
let
	using ShortCodes
	[
		DOI("10.1103/PhysRevE.74.036105"),
		DOI("10.1103/PhysRevE.102.012309"),
		DOI("10.1109/NSW.2011.6004642")
	]
end

# ╔═╡ b0b47fa0-b9d1-4e46-be06-31233b3b6f03
BlockDiag("""blockdiag {
  default_fontsize = 15;
  "ABM\t𝑞(𝑥)" -> "𝐱" -> "𝐹";
  "ABM\t𝑞(𝑥)"[color = "#D6E3F4"];
  "𝐱"[color = "#F2F2F2"];
  "𝐹"[color = "#DAEAD2"];
  "ABM\t𝑞(𝑥)" -> "𝐱"[thick];
  "𝐱" -> "𝐹"[thick];
}""")

# ╔═╡ de951afb-2596-4ef6-8c96-c8c03102eea9
BlockDiag("""blockdiag {
  default_fontsize = 15;
  "SCABM\t𝑝(𝑥)" <- "𝐱'" <- "𝐹'";
  "SCABM\t𝑝(𝑥)"[color = "#DAEAD2"];
  "𝐱'"[color = "#F2F2F2"];
  "𝐹'"[color = "#D6E3F4"];
  "SCABM\t𝑝(𝑥)" <- "𝐱'"[thick];
  "𝐱'" <- "𝐹'"[thick];
}""")

# ╔═╡ 9942dd32-e601-4a01-97ef-e3709080fea8
begin # ABM parameters
	N₀ = 30    # Expected number of agents
	M = 10_000 # Number of samples in one ABM ensemble
	T = 5      # Number of time steps the ABM is run

	GRAPHTYPES = [:ErdosRenyi, :WattsStrogatz, :BarabasiAlbert]

	SEED = 123
end;

# ╔═╡ 6f1ddf1f-262b-4a47-8da8-9bf5bb27622f
"""
Sample a `(N, E)` graph with approximately the same number of edges
`E` as an `erdos_renyi(N, 0.5)` graph, i.e., `E = 0.5*N(N-1)/2`.
"""
function sample_calibrated_graph(N, graphtype; seed = -1)
	if graphtype == :ErdosRenyi
		g = erdos_renyi(N, 0.5; seed = seed)
	elseif graphtype == :BarabasiAlbert
		k = round(Int, .5*(√N + N))
		g = barabasi_albert(N, k; seed = seed)
	elseif graphtype == :WattsStrogatz
		k = round(Int, 0.5*(N-1))
		β = 0.05 # Free parameter
		g = watts_strogatz(N, k, β; seed = seed)
	else
		error("Unknown graphtype: $graphtype")
	end
	return g
end

# ╔═╡ f66bed21-ea37-44c1-a238-93bc22778ac3
let
	function example(graphtype; N = 10, size = 500, seed = 1111)
		g = sample_calibrated_graph(N, graphtype; seed = seed)
		c = local_clustering_coefficient(g)
		colors = get.(Ref(COLORSCHEME), c)
		graphplot(g; title=graphtype, titlefontsize = 10, size = (size, size/2), nodecolor = colors, nodesize = .2)
	end

	plot(example.([:ErdosRenyi, :WattsStrogatz, :BarabasiAlbert])..., layout = (1,3))
end

# ╔═╡ 7c46a491-bef6-4db1-a0d3-2cc648ce6fe9
# Define the ABM according to Dall’Asta+ (2006)
begin
	mutable struct Agent <: AbstractAgent
	    id::Int
	    lexicon::Vector{Int}
	end
	
	function initialize(N₀, graphtype)
		# Sample the number of agents for this model
		N = rand(Poisson(N₀))

		# This maps each node to an Int in 1:N
		graphseed = abs(rand(Int))
		graph = sample_calibrated_graph(N, graphtype; seed = graphseed)

		C = mean(local_clustering_coefficient(graph))

		properties = @dict(
			N,
			graphtype,
			graphseed,
			graph,
			C,     # Clustering coefficient ∈ [0,1]
			S = 0. # Succes rate ∈ [0,1]
		)

		# This maps each agent to an Int in 1:N
		model = ABM(Agent, nothing; properties)

		init_lexicon!(agent) = add_agent!(model, [rand(model.rng, Int)])
		for i in 1:N			
	    	init_lexicon!(i)
		end

		return model
	end

	function agent_step!(speaker, model)::Int
		# This relies on the fact that both agents and nodes are
		# mapped to Ints on 1:N (no agents or nodes are removed)
		neighbors = all_neighbors(model.graph, speaker.id)
		isempty(neighbors) && return 0
		listener = model[rand(model.rng, neighbors)]

		message = rand(model.rng, speaker.lexicon)

		if message in listener.lexicon
			speaker.lexicon = [message]
			listener.lexicon = [message]
			return 1
		else
			push!(listener.lexicon, message)
			return 0
		end
	end

	function model_step!(model)
		successes = 0
		for speaker in allagents(model)
			successes += agent_step!(speaker, model)
		end
		model.S = successes/nagents(model)
	end
end;

# ╔═╡ 9b0abb0f-6081-469e-8c3d-69f506cf1caf
begin
	function ensemblerun(N₀, M, T, graphtype)
		models = [initialize(N₀, graphtype) for _ in 1:M]

		adf, mdf, models = ensemblerun!(
			models,
			agent_step!,
			model_step!,
			T;
			mdata = [:S]
		)

		rename!(mdf, :ensemble => :run) # Rename awkwardly named column
		mdf[!, :graphtype] .= graphtype

		ensemble = @chain mdf begin
			@orderby :graphtype :run
			@subset :step .== maximum(:step)
			@select :graphtype :run :S
		end

		ensemble[!, :C] = [m.C for m in models]
		ensemble[!, :N] = [m.N for m in models]
		ensemble[!, :graphseed] = [m.graphseed for m in models]

		return ensemble
	end

	Random.seed!(SEED)

	ensemble = vcat(ensemblerun.(N₀, M, T, GRAPHTYPES)...)
	ensemble = groupby(ensemble, :graphtype)
end

# ╔═╡ 9c70b5d1-a6dd-4687-a0d4-6fa2526286ee
begin
	function weigh!(ensemble, λ)
		@transform!(ensemble, :weight = softmax(+λ*(:C))) # Use `+λ` convention
		return ensemble
	end

	function sample_efficiency(weights)
		νᵐ = floor(Int, 1/maximum(weights))
		e = νᵐ / length(weights)
	end

	wmean(x, w) = mean(x, Weights(w, 1.))
	wstd(x, w) = std(x, Weights(w, 1.))
	wquantile(x, w, p) = quantile(x, Weights(w, 1.), p)

	function project!(ensemble, λ)
		weigh!(ensemble, λ)
		@combine ensemble begin
			:λ = λ
			:ϵ = sample_efficiency(:weight)
			:μᶜ = wmean(:C, :weight)
			:σᶜ = wstd(:C, :weight)
			:μˢ = wmean(:S, :weight)
			:σˢ = wstd(:S, :weight)
			:μⁿ = wmean(:N, :weight)
			:σⁿ = wstd(:N, :weight)
		end
	end

	project!(ensemble, 0.) # Get unconstrained moments
end

# ╔═╡ e4bc40ca-8958-4807-a240-64fcb1fedcb4
begin
	function plotdiagram(ensemble)
		@df DataFrame(ensemble) cornerplot(
			[:C :S]; label = ["Clustering coefficient C", "Success rate S"],
			group = :graphtype, compact = true, size=(400,300), labelfontsize=8
		)
	end
	
	function lambdas(σᶜ; c = 10, n = 100)
		lim = c/σᶜ # In general (λσᶜ) ∼ N(0,1)
		λ = LinRange(-lim, lim, n)
	end

	function project_lambdas!(ensemble, λ)
		s = vcat(project!.(Ref(ensemble), λ)...)
		s = groupby(s, :graphtype)
	end

	function getrange!(ensemble, graphtype)
		r = @chain project!(ensemble, 0.) begin
			@subset :graphtype .== graphtype
			@select :μᶜ :σᶜ
		end
		only(r.μᶜ), only(r.σᶜ)
	end
	
	function plotstates!(p, ensemble; c = 10, n = 100, z = 3)
		σᶜ = project!(ensemble, 0.).σᶜ
		λ = lambdas(minimum(σᶜ); c = c, n = n)
		s = project_lambdas!(ensemble, λ)

		for (k, sᵍ) in pairs(s)
			μ, σ = getrange!(ensemble, k.graphtype)
			keep = @. μ - z*σ < sᵍ.μᶜ < μ + z*σ
			sᵍ = sᵍ[keep, :]
			@df sᵍ plot!(p, :μᶜ, :μˢ; linewidth=3, linecolor = :black, ylim = (0,1))
			annotate!(p, μ, 1., text(k.graphtype, FONT, 6))

			###
			#@df sᵍ plot!(p, :μᶜ, :μⁿ/N₀; linewidth=3, linecolor = :blue, ylim = (0,1))
		end
		s
	end
end

# ╔═╡ 8eb2581b-e4de-4fc5-b716-13bf4ff3ffcd
begin
	diagram = plotdiagram(ensemble)

	states = plotstates!(diagram[2], ensemble) # Equation-of-state

	diagram
end

# ╔═╡ c6dcddcf-0d12-4e9e-b7fa-f761f5f2cacf
let
	using Interpolations
	
	extractname(df) = string(first(df.graphtype))
	atzero(λ, x) = LinearInterpolation(λ, x)(zero(λ))

	function yticks()
		ϵ = DataFrame(states).:ϵ
		scale = sort(unique(round.(Int, log10.(ϵ))))
		ticks = (10.) .^ scale
		labels = ["1:$(10^-s)" for s in scale]
		ticks, labels
	end

	xlim = 3

	p = plot(;
		xticks = -10:10, xlim = (-xlim, xlim), yscale = :log,
		yticks = yticks(), xlabel = "z", ylabel = "Sample efficiency"
	)
	
	for df in states
		graphtype = extractname(df)
		μ = @df df atzero(:λ, :μᶜ)
		σ = @df df atzero(:λ, :σᶜ)
		z = @. (df.μᶜ - μ)/σ
		@df df plot!(p, z, :ϵ; label = graphtype, lw = 3)
	end

	vspan!(p, [-2, 2]; fillalpha = .1, fillcolor = :grey, label = false)

	plot!(p; title = "Worst case sampling effiency")
end

# ╔═╡ fb63305f-09d7-4111-8684-4fbab8c192df
md"""
!!! warning ""
    Notebook still under active construction.
"""

# ╔═╡ 7cd47b87-fceb-4995-970c-ae23e250fb46
md"""
# **SCABMs**: Softly Constrained Agent-Based Models

Marnix Van Soom & Bart de Boer `{marnix,bart}@ai.vub.ac.be` [[VUB AI lab]](https://ai.vub.ac.be/abacus/)

!!! note "Abstract"

    In this notebook we look at the effect of constraining the network clustering coefficient $C$ on the success rate $S$ of a simple language game played by agents on a networks, in order to gauge the influence of social network structure on emerging language conventions.
	This is an example of a generic class of experiments on agent-based models (ABMs) made possible by a simple and flexible conceptual framework called softly constrained agent-based models (SCABMs), which we introduce and discuss here.
"""

# ╔═╡ 8a8a6115-a178-4b97-bc77-371a85288363
md"""
## Introduction and motivation

An **agent-based model (ABM)** can be thought of as a computer program that implicitly defines a probability distribution $q(x)$ over all of its possible outputs $x$.
It is essentially a high-dimensional and ingeniously crafted probability distribution from which it is easy to sample an $x \sim q(x)$, but for which the *value* of the probability density function $q(x)$ itself is unavailable.

Typically, we want to capture the behavior of the ABM by evaluating just a few well-chosen statistics that project the high-dimensional $x$ down to something lower-dimensional and simpler.
Luckily, we don't need to know the value of $q(x)$ to do this: we just estimate the expected value of the statistics by averaging them over independent runs of the ABM.

Formally, given a statistic of choice $f(x)$ and a set of $M$ samples ${\bf x} = \{x_m\}$, where each $x_m \sim q(x)$ is the output of an independent run of the ABM, the expected value $F$ is approximated by Monte Carlo integration:
````math
F := \langle f(x) \rangle_q \equiv \int dx\ q(x) f(x) \approx {1 \over M} \sum_{m=1}^M f(x_m)
````
To obtain $F$, therefore, the ABM is run in what we define as the "**forward**" direction, schematically represented as:
"""

# ╔═╡ b1d4c305-1f87-4a90-9d39-7519b1bb11ab
md"""
In words, this diagram reads that running an ABM $q(x)$ repeatedly produces a set of samples $\bf x$ from which the expected value of a statistic $F := \langle f(x) \rangle_q$ can be estimated. The object of interest $F$ is thus obtained from left to right.
"""

# ╔═╡ a598718d-b65f-41d3-829f-bbb82888002b
md"""
Now we introduce the idea of running the ABM "**backwards**":
"""

# ╔═╡ c9fda3c0-882c-4f48-a225-f3e67d107f13
md"""
The object of interest is now the set of samples ${\bf x'} = \{x_\ell'\}$, which implicity represents a new probability distribution $p(x)$.
In the backward direction the expectation
````math
\langle f(x) \rangle_p \equiv \int dx\ p(x) f(x) := F'
````
is *constrained* to take a given value $F' \neq F$ and now we solve for the probability distribution $p(x)$ which satisfies that soft constraint while still as close as possible to the prior $q(x)$.
We show in the appendix that the optimal solution to this problem can be approximated for some range of $F'$ by a simple reweighting of the original samples $\bf x$, from which the $\bf x'$ can be obtained by standard resampling such that roughly each $x_\ell' \sim p(x)$.
We pay for the efficiency of this approximation by a corresponding cost in samples, such that we can get only $L = \epsilon M$ samples $\bf x'$ from $p(x)$ given $M$ samples $\bf x$ from $q(x)$, where $\epsilon \in (0,1]$ is the sampling efficiency.
Its value depends strongly on $F'$.

Returning to the second diagram above, we may apply the same logic used in the first paragraph and conclude that the obtained $\bf x'$ represent the probability distribution $p(x)$ of a new computer program automatically derived from the original ABM, which we call a **softly constrained agent-based model (SCABM)**. "Softly constrained" means that we only constrain the *expectation* of $f(x)$, rather than demanding that $f(x)$ take on a certain "hard" value.

As the name suggests, a SCABM is itself just another ABM, except that we don't have access to its source code -- we can only study it indirectly via the $\bf x'$.
In particular, using the same rule as above we can estimate the expected value of any statistic
````math
G := \langle g(x) \rangle_p \equiv \int dx\ p(x) g(x) \approx {1 \over L} \sum_{\ell=1}^L g(x'_\ell)
````
This expectation $G$ is a function of the constraint $F'$, so $G \equiv G(F')$.
**This allows us to characterize the behavior of an ABM by studying the effect of constraining the expected value of one statistic on the expected value of another statistic.**
In this notebook, for example, we will look at the effect of constraining the average network clustering coefficient $C$ on the average success rate $S$ of a simple language game played by agents on random networks, in order to gauge certain aspects of the influence of social network structure on emerging language conventions.
"""

# ╔═╡ 8d827b33-d299-48fb-b3e6-b31dc26b9fe6
md"""
!!! terminology "Tip"
	Before we continue, here are some tips for using this [Pluto notebook](https://github.com/fonsp/Pluto.jl).
	- Click the 📕 book icon on the right to see a table of contents.
    - (Most) cells with source code are hidden to keep this notebook legible. To see the source, run this notebook (click *Edit or run this notebook*) in Pluto and click the 👁️ eye when hovering over a cell.
	- When running this notebook for the first time, Pluto will take some time to install the relevant libraries and compile the code on the first pass. After this process, things should be (very) fast.
"""

# ╔═╡ b4d0347f-4074-46da-a3d0-3ae9b7045cf8
md"""
## Playing naming games with SCABMs

To show that SCABMs are useful and computationally feasible, we investigate the influence of softly constraining the clustering coefficient $C$ on the success rate $S$ of a simple language game called the **naming game** played by the agents on three different network types.

!!! note
	See this excellent [Medium blog post](https://medium.com/@ramongarciaseuma/dynamics-for-language-conventions-naming-game-8198c8383197) for a clear introduction to the naming game of Dall’Asta+ (2006).
    The code in this notebook is equivalent to the code in the blog post; only our implementation of the network types differs.
"""

# ╔═╡ 017327e7-7c7d-40b5-8573-ec780f42384b
md"""
### Description of the ABM

Given a network of $N$ agents, the naming game is a simple model of how a set of shared conventions can emerge without obvious high-level intervention.
Agents need to agree on a word for one global concept $X$.
Initially, each agent comes up with a random word for $X$.
Then, taking turns, each agent communicates with a random neighbor in the network and picks a random word from their lexicon to describe $X$.
The communication can be a success or a failure: 
- Success: their neighbor has heard this word before (it is in their lexicon) and both agents agree that this is the "right" word for $X$; their lexicons collapse to just this one word.
- Failure: their neighbor has not heard this word before (it is not in their lexicon) and the word is simply appended to the neighbor's lexicon.
The game is played for $T$ timesteps (during one timestep, each agent communicates once) after which the **success rate $S$** is evaluated, which is the fraction of successful communications during the last timestep.

As mentioned before, we consider three different network models to capture different types of communication in social networks.
Each network has $N$ nodes (the number of agents) and is calibrated to the Erdős–Rényi model to have roughly $E \approx N(N-1)/4$ connections.
These networks are not sparse, since $E \sim O(N^2)$.
The models are:
1. [Erdős–Rényi](https://en.wikipedia.org/wiki/Erd%C5%91s%E2%80%93R%C3%A9nyi_model):
     A network where (in this experiment) each possible connection between a pair of agents is present or not with a probability of $p = 0.5$.
     This represents a random social network with little "intentional" structure.
2. [Watts-Strogatz](https://en.wikipedia.org/wiki/Watts%E2%80%93Strogatz_model):
   A "small world" network where agents are mostly connected within clusters, but sometimes to agents in "distant" clusters.
3. [Barabási–Albert](https://en.wikipedia.org/wiki/Barab%C3%A1si%E2%80%93Albert_model):
   A "scale-free" network where a few popular nodes have lots of connections, while the majority has relatively few.
We will characterize these networks by a single statistic: the **clustering coefficient $C$**.
More precisely, it is defined as the [average local clustering coefficient](https://en.wikipedia.org/wiki/Clustering_coefficient):
````math
C = {1 \over N} \sum_{n=1}^N C_n
````
where $C_n \in [0,1]$ is the local clustering coefficient of node (agent) $n$.
Below we show some example networks for $N = 10$ agents where the nodes are colored according to $C_n$ (darker means higher).
"""

# ╔═╡ 49458fbd-e8e9-4e67-872f-84abd04c56f2
md"""
Finally, an important design of our ABM is that the number of agents $N$ is not constant but varies per run.
Rather, the $N_0$ parameter of the ABM specifies the *expected amount* of agents, and for a given run we sample
````math
N \sim \text{Poisson}(N_0)
````
so roughly $N \simeq N_0 \pm \sqrt{N_0}$
"""

# ╔═╡ 4efd79a5-3e7a-4b3f-8c11-c61a3c9b0e0b
md"""
### Running the ABM
"""

# ╔═╡ a2a71645-aaa3-4462-b6f8-bf8d7d9d2d4a
md"""
!!! terminology "Tip"
	Pluto notebooks are reactive, so you can change the ABM parameters below and execute the cell. The changes will propagate throughout the notebook.
"""

# ╔═╡ d91ed32c-2092-4aaa-ba50-13d93d0da12b
md"""
### Unleashing the SCABMs

We now constrain the expected value (average) of the clustering coefficient $C$ to see how this influences the success rate $S$ at time $T$.
"""

# ╔═╡ 4f4c249a-eaf4-46a9-a5f3-0887715a119c
states

# ╔═╡ 23826464-15bd-4b29-8540-32982e07b709
begin
	function sample_graph(ensemble, graphtype)
		e = ensemble[(graphtype,)]
		i = sample(1:nrow(e), Weights(e.weight, 1.))
		s = e[i,:]
		g = sample_calibrated_graph(s.N, graphtype; seed = s.graphseed)
		g, s
	end

	function mark_diagram!(p, C, S, markershape)
		scatter!(p, [C], [S], markershape = markershape, markercolor = :black)
	end

	function visualize!(ensemble, graphtype, λ, diagram = nothing; ms = :star4, title = true)
		weigh!(ensemble, λ)
		g, s = sample_graph(ensemble, graphtype)

		isnothing(diagram) || mark_diagram!(diagram[2], [s.C], [s.S], ms)
		
		C, S = round.([s.C, s.S], sigdigits=2)
		c = local_clustering_coefficient(g)
		
		colors = get.(Ref(COLORSCHEME), c)
		name = "$graphtype ⋅ C = $C ⋅ S = $S"
		p = graphplot(
			g; title = title ? name : "", nodecolor = colors,
			nodesize = .2, titlefontsize = 10
		)

		savefig(p, "$name.png")

		p
	end
end

# ╔═╡ 4b7f2306-a4c0-42c7-85c2-ea437bc61e50
[
	visualize!(ensemble, :WattsStrogatz, -400, diagram; ms = :star4),
	visualize!(ensemble, :WattsStrogatz, 0, diagram; ms = :star4),
	visualize!(ensemble, :WattsStrogatz, +400, diagram; ms = :star4),
]

# ╔═╡ 08c63f0e-5a64-45e3-97be-c1fa958cc661
visualize!(ensemble, :ErdosRenyi, 0., diagram; ms = :star5)

# ╔═╡ c62e44d4-8501-45f6-bdb0-e357e4c363fb
visualize!(ensemble, :BarabasiAlbert, 0., diagram; ms = :star6)

# ╔═╡ dd40ac6e-d08f-4663-b6c5-9809493e9612
let
	savefig(diagram, "diagram.png")
	diagram
end

# ╔═╡ 6ab8e802-d879-4ec0-a86b-ea1797d34c2b
md"""

As $F' \rightarrow F$, then $p(x) \rightarrow q(x)$, as required.

When $F$ is outside range we need very many samples (very low sample efficiency), so outside that range we need to be careful because the SCABM will turn into a SCAM unless we have very very many samples.

By smoothly varying the soft constraint $F'$, $G(F')$ traces a path known in statistical physics as an *equation of state*.

The resulting $S(C)$ curves are shown below for Erdős–Rényi, Watts-Strogatz and Barabási–Albert networks.
"""

# ╔═╡ 51cee280-ee61-44af-8615-879750f823b4
let
	p = plot(; xlabel = "Clustering coefficient C", ylabel = "Success rate S", legend = false, title = "Equations of state")
	e = ensemble
	plotstates!(p, ensemble)
	p
end

# ╔═╡ fda9c33b-8657-4d8b-b74e-d0a035dd67eb
md"""
## Discussion

!!! warning
    Under construction.

It should be realized that a difficulty with network science is that many standard network measures are strongly correlated (for example, network assortativity and degree sequence (Peixoto 2020)).

One advantage of the SCABM formalism is that the choice and number of statistics -- whether of the "explanatory" $F$ type or "dependant" $G$ type -- is completely free, and multiple statistics and constraints are possible.

Another advantage is note that we have more control over the ABM: we do not need to know how to generate networks with a given clustering coefficient $C$, not even on average; but with a SCABM it is still possible to do this automatically.

!!! note
    In effect this method gives us a new set of "turning knobs" at which we can turn at will and see how the system (ABM) reacts, *without being able to control them explicitly*.
	This is good because this widens scope of ABMs considerably.
    For example #1, neural agents with emergent features -- these emergent features can now be constrained and the effects they have on the system can be studied (as if they were ABM parameters under control of the experimenter).
	For example #2, generating networks with given (average) clustering coefficient, while possible, is not trivial (e.g. Herrera & Zufiria (2011)). And what if we wanted to constrain another network measure such as [betweenness centrality](https://en.wikipedia.org/wiki/Betweenness_centrality)?

!!! terminology "Advantages"
	- Very simple conceptual framework and computationally efficient; scales in linear time
	- A richer behavior than a straight line, with adaptive error bars (not shown) -- error bars just show the width of the distribution of the "effect statistic" ($G$), not some kind of regression error!
	- You get weighted samples so you can go beyond moments and calculate e.g. weighted quantiles for any statistic. Or probabilistic questions such as "what is the probability that $g/f < 3$"? etc.
	- You can resample from the new SCABM and inspect the samples manually to get some intuition
	- Multiple constraints can be active at the same time (like temperature and volume with an ideal gas)

!!! warning "Disadvantages/caveats"
	- Need to be able to sample the ABM many times
	- Can realistically only constrain within one to max. three sigma $\sigma_F$
	- **Everything depends on the expressivity of the original ABM!** A SCABM is only as expressive and powerful as the underlying original ABM. If there is no correlation between $F$ and $G$ and the signal is weak, the SCABM will turn into its evil twin SCAM and give you smooth and likeable curves back which are just noise. But this is can be easily detected by just generating another ensemble and seeing whether the $G(F)$ curves are similar. (For example just change the `SEED` variable in this notebook and rerun). Increasing the number of runs `M` diminishes the variability.

To do:
- Investigate variance of different estimators and communicate theoretical results
- More interesting models
- Verify predictions from $p(x)$ on unseen data
- Beyond reweighing and resampling: reconstruct the data with nested sampling in a high-dimensional space ($O(100)$ max)
"""

# ╔═╡ a0aad24f-1f6b-4f2a-9f54-b61e0609eb76
md"## Appendices"

# ╔═╡ 15a95e15-905f-4996-8000-f4cf3d60aac0
md"""
### Derivations

Given the ABM $q(x)$, we want to find a new $p(x)$, the SCABM, under which the expected value (i.e., the average) of $f(x)$ is $F'$, while being as "close" as possible to the prior $q(x)$ as measured by the Kullback-Leibler distance.
More precisely:
!!! note "Problem"
    Given $q(x)$, $f(x)$ and $F'$, find
    ````math
    p(x) = \text{argmin}_{p(x)} D_\text{KL}(p|q)
    ````
	while satisfying
    ````math
	\langle f(x) \rangle_p \equiv \int dx\ p(x) f(x) := F'
	````
"""

# ╔═╡ 917b1c65-e48f-4e14-aff1-53cef88231a3
md"""
### Robustness and sensitivity

With the Poisson sampling for $N$ in place, the SCABM method gave consistent results throughout the following variations:
- Varying $N_0 \sim O(100)$
- Varying $T \sim O(10)$
- [Clustering statistic](https://en.wikipedia.org/wiki/Clustering_coefficient) used: average local clustering coefficient [used here] or global clustering coeffient
- Which importance sampling estimator to use: reweighing samples [used here] or adjusting the statistic by $\exp(\lambda C_i)/Z(\lambda)$
- Which estimator of $C$ to use: reweighing samples [used here] or using Automatic Differentiation Nested Sampling $\langle C \rangle = {d \over d\lambda} \log Z(\lambda)$ (Van Soom & de Boer 2022, in preparation)
"""

# ╔═╡ b604cefb-8dc6-46d9-b456-7f19af13f067
md"""
### Mediating influence of the number of agents

The two plots below show how $C$ influences $S$: through $N$, the number of agents.

Success rate is **negatively correlated** with $N$ because
- Although success rate is "corrected for" $N$ (it is divided by $N$ and one model step is a sweep through $N$ agents), it is still plausible that more agents simply need relatively more time to converge
- And more importantly: since $E = O(N^2)$, the number of agents strongly influence the average node degree, and the more connections an agent has, the slower convergence (because if the number of connections is small, you have faster collapse of lexicon)
"""

# ╔═╡ f6e4d332-c8b8-425e-a1fe-83378552836c
@df DataFrame(ensemble) cornerplot(
		[:N :S]; label = ["Number of agents N", "Success rate S"], group = :graphtype, compact = true, size=(400,300), labelfontsize=8
	)

# ╔═╡ 31c9068f-90f3-4185-aa4f-17c11563047b
md"""
Plot below is a good example of the power of SCABMs: intricate dependence that cannot be expressed with a simple linear regression.

The number of agents $N$ is **correlated** with clustering coefficient $C$:
- **Erdős–Rényi and Barabási–Albert**: A smaller number of agents $N$ affords for a larger variation in $C$ (because as $N$ increases, clustering of coefficient of network samples converges in the usual $O(N^{-1/2})$ way)
- **Watts-Strogatz**: the same effect as the previous point happens, but there is a real trend: Watts-Strogatz networks are designed to have high local clustering yet short average shortest path lengths. So the positive correlation with $N$ is essentially by design.
"""

# ╔═╡ e8c62155-902b-41f6-bc8d-6f8d74ed352a
let
	p = @df DataFrame(ensemble) cornerplot(
		[:C :N]; label = ["Clustering coefficient C", "Number of agents N"], group = :graphtype, compact = true, size=(400,300), labelfontsize=8
	)

	function plot_nagent_states!(p, ensemble; c = 10, n = 100, z = 3)
		σᶜ = project!(ensemble, 0.).σᶜ
		λ = lambdas(minimum(σᶜ); c = c, n = n)
		s = project_lambdas!(ensemble, λ)

		for (k, sᵍ) in pairs(s)
			μ, σ = getrange!(ensemble, k.graphtype)
			keep = @. μ - z*σ < sᵍ.μᶜ < μ + z*σ
			sᵍ = sᵍ[keep, :]

			Nmax = N₀ + 4*√N₀
			annotate!(p, μ, Nmax, text(k.graphtype, FONT, 6))

			@df sᵍ plot!(p, :μᶜ, :μⁿ; linewidth=3, linecolor = :blue)
		end
		s
	end

	plot_nagent_states!(p[2], ensemble)

	#plot!(p[1]; title = "The influence of C on S is clearly mediated by N")
	p
end

# ╔═╡ dcbfc502-4b53-40e4-b735-9a2aadc96538
md"### References"

# ╔═╡ 6a05d5cf-a51d-47ba-85e1-14c16b369a19
md"---"

# ╔═╡ 73f75064-a6d2-4ae8-bcd6-52ec610315ee
md"""
#### Resampling into a SCABM
"""

# ╔═╡ c2658679-5a20-446d-90d5-644936323b8f
"""
Sample `ν` equally weighted samples from an ensemble of weighted
(posterior) samples using the staircase sampling method from
Sivia & Skilling (2006, p. 197).
"""
function staircase_sampling(
	ensemble, ν; weight = ensemble.weight, rng = Random.GLOBAL_RNG
)
	νmax = 1/maximum(weight)
	ν > νmax && error("Maximum number of samples is $(floor(νmax))")
	
	S = rand(rng)
	current = 0
	samples = zeros(Int, ν)
	for i in 1:nrow(ensemble)
		S += ν*weight[i]
		if floor(S) > current
			current += 1
			samples[current] = i
		end
	end
	return ensemble[samples,:]
end

# ╔═╡ 0957f4e8-2d3a-4c09-b0bc-453d9c2d005a
let
	# 
	e = weigh!(ensemble, -10.)

	e = e[(:BarabasiAlbert,)]
	ν = 1000

	SCABM = staircase_sampling(e, ν)
	wmean(e.S, e.weight), mean(SCABM.S)
end

# ╔═╡ d5409b02-89a5-45e9-bc78-67e566112869
md"""
#### Sample efficiency
!!! warning
	The below sample efficiency is very pessimistic by one or two orders of magnitude.
	The theoretical sample effiency (TODO: show here) is much better, maintaining a 1:10 efficiency throughout 2 sigma (please read on -- see below)
    The real efficiency is somewhere in between and needs more research
	An approximation is given below for theoretical sample efficiency but it is possible to calculate with (ADNS) Automatic Differentiation Nested Sampling (Van Soom & de Boer, in preparation)
"""

# ╔═╡ d6683d9e-d1c2-44c8-9422-7c9e09d0e558
md"""
Calculating sample efficiency with the relative entropy: $\epsilon(\lambda) = e^{-D_\text{KL}(p|q)}$ as "you need $e^{D_\text{KL}(p|q)}$ from $q$ to get one from $p$"

$D_\text{KL}(p|q) = \int dx\ p(x) \log({p(x) \over q(x)})$

$p(x) = q(x) \exp(\lambda f(x)) / Z(\lambda)$

$D_\text{KL}(p|q) = \int dx\ p(x) (\lambda x - \log Z(\lambda)) = \lambda \langle f(x) \rangle_p - \log Z(\lambda)$ where $\langle f(x) \rangle_p = F(\lambda)$

Given that $p(f') = \int dx\ q(x) \delta(f' - f(x))$ is almost a normal PDF $N(f'; \mu,\sigma^2)$ for our hyperparameter settings, then 
$\log Z(\lambda) \simeq \log \int df \exp(\lambda f) N(f; \mu,\sigma^2) = \lambda \mu + \lambda^2 \sigma^2/2$
which is nearly linear when $\sigma^2$ is small (as is the case); it acts like a delta function.

So to second order $D_\text{KL}(p|q) = \lambda \langle f(x) \rangle_p - \log Z(\lambda) \approx \lambda(F(\lambda) - F(0)) - \lambda^2 \sigma^2/2$ where $\lambda \sigma \sim O(1)$, so we cannot expect this approximation to hold over a wide range of $\lambda$.

We can see that this approximation breaks down fast, so better to estimate $D_\text{KL}(p|q)$ directly with nested sampling with $\pi(f) = q(f), L(f) = \lambda f$.
"""

# ╔═╡ ee4c5bca-92e6-4ca5-b957-a11511fa1438
let
	extractname(df) = string(first(df.graphtype))
	atzero(λ, x) = LinearInterpolation(λ, x)(zero(λ))
	
	function yticks()
		ϵ = DataFrame(states).:ϵ
		scale = sort(unique(round.(Int, log10.(ϵ))))
		ticks = (10.) .^ scale
		labels = ["1:$(10^-s)" for s in scale]
		ticks, labels
	end

	xlim = 3

	p = plot(;
		xticks = -10:10, xlim = (-xlim, xlim), yscale = :log,
		yticks = yticks(), xlabel = "z", ylabel = "Sample efficiency", ylim = (1e-4, 1)
	)
	
	for df in states
		graphtype = extractname(df)
		μ = @df df atzero(:λ, :μᶜ)
		σ = @df df atzero(:λ, :σᶜ)
		z = @. (df.μᶜ - μ)/σ
		D = @df df :λ.*(:μᶜ .- μ) - (:λ.*σ).^2/2
		ϵ = exp.(-D)
		@df df plot!(p, z, ϵ; label = graphtype, lw = 3)
	end

	vspan!(p, [-2, 2]; fillalpha = .1, fillcolor = :grey, label = false)
	
	plot!(p; title = "Theoretical sampling effiency: approximation")
end

# ╔═╡ ed907683-f46b-4c6b-9a8a-8263191544d1
md"""
The same curves calculated with automatic differentiation in old.jl nested sampling look good, with efficiencies aroud 1:10 for $|z| < 2$. So in general we have a very positive picture (at least for one constraint.)
Our calculation of $\epsilon$ with the staircase sampling weights depends on the number of posterior samples $M$ (because we are trying to resample $M$ weighted samples), so is a bit sketch.
The "true" sampling efficiency is somewhere between the theoretic upper bound (i.e. based on $-D_\text{KL}(p|q)$) and this more practical one (i.e. based on staircase resampling).
"""

# ╔═╡ 00000000-0000-0000-0000-000000000001
PLUTO_PROJECT_TOML_CONTENTS = """
[deps]
Agents = "46ada45e-f475-11e8-01d0-f70cc89e6671"
ColorSchemes = "35d6a980-a343-548e-a6ea-1d62b119f2f4"
DataFramesMeta = "1313f7d8-7da2-5740-9ea0-a2ca25f37964"
Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"
DrWatson = "634d3b9d-ee7a-5ddf-bec9-22491ea816e1"
GraphRecipes = "bd48cda9-67a9-57be-86fa-5b3c104eda73"
Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
Interpolations = "a98d9a8b-a2ab-59e6-89dd-64a1c18fca59"
LaTeXStrings = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f"
PlutoUI = "7f904dfe-b85e-4ff6-b463-dae2292396a8"
Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
ShortCodes = "f62ebe17-55c5-4640-972f-b59c0dd11ccf"
StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
StatsFuns = "4c63d2b9-4356-54db-8cca-17b64c39e42c"
StatsPlots = "f3b207a7-027a-5e70-b257-86293d7955fd"

[compat]
Agents = "~5.2.0"
ColorSchemes = "~3.18.0"
DataFramesMeta = "~0.11.0"
Distributions = "~0.25.59"
DrWatson = "~2.9.1"
GraphRecipes = "~0.5.9"
Graphs = "~1.7.0"
Interpolations = "~0.13.6"
LaTeXStrings = "~1.3.0"
PlutoUI = "~0.7.39"
ShortCodes = "~0.3.3"
StatsBase = "~0.33.16"
StatsFuns = "~0.9.18"
StatsPlots = "~0.14.34"
"""

# ╔═╡ 00000000-0000-0000-0000-000000000002
PLUTO_MANIFEST_TOML_CONTENTS = """
# This file is machine-generated - editing it directly is not advised

[[AbstractFFTs]]
deps = ["ChainRulesCore", "LinearAlgebra"]
git-tree-sha1 = "6f1d9bc1c08f9f4a8fa92e3ea3cb50153a1b40d4"
uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c"
version = "1.1.0"

[[AbstractPlutoDingetjes]]
deps = ["Pkg"]
git-tree-sha1 = "8eaf9f1b4921132a4cff3f36a1d9ba923b14a481"
uuid = "6e696c72-6542-2067-7265-42206c756150"
version = "1.1.4"

[[AbstractTrees]]
git-tree-sha1 = "03e0550477d86222521d254b741d470ba17ea0b5"
uuid = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"
version = "0.3.4"

[[Adapt]]
deps = ["LinearAlgebra"]
git-tree-sha1 = "af92965fb30777147966f58acb05da51c5616b5f"
uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
version = "3.3.3"

[[Agents]]
deps = ["CSV", "DataFrames", "DataStructures", "Distributed", "Downloads", "Graphs", "JLD2", "LazyArtifacts", "LightOSM", "LinearAlgebra", "Pkg", "ProgressMeter", "Random", "Requires", "Scratch", "StatsBase"]
git-tree-sha1 = "4ffabc883a9021fb57686cee925a0cc501e3c15b"
uuid = "46ada45e-f475-11e8-01d0-f70cc89e6671"
version = "5.2.0"

[[ArgTools]]
uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f"

[[ArnoldiMethod]]
deps = ["LinearAlgebra", "Random", "StaticArrays"]
git-tree-sha1 = "62e51b39331de8911e4a7ff6f5aaf38a5f4cc0ae"
uuid = "ec485272-7323-5ecc-a04f-4719b315124d"
version = "0.2.0"

[[Arpack]]
deps = ["Arpack_jll", "Libdl", "LinearAlgebra", "Logging"]
git-tree-sha1 = "91ca22c4b8437da89b030f08d71db55a379ce958"
uuid = "7d9fca2a-8960-54d3-9f78-7d1dccf2cb97"
version = "0.5.3"

[[Arpack_jll]]
deps = ["Libdl", "OpenBLAS_jll", "Pkg"]
git-tree-sha1 = "e214a9b9bd1b4e1b4f15b22c0994862b66af7ff7"
uuid = "68821587-b530-5797-8361-c406ea357684"
version = "3.5.0+3"

[[Artifacts]]
uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"

[[AxisAlgorithms]]
deps = ["LinearAlgebra", "Random", "SparseArrays", "WoodburyMatrices"]
git-tree-sha1 = "66771c8d21c8ff5e3a93379480a2307ac36863f7"
uuid = "13072b0f-2c55-5437-9ae7-d433b7a33950"
version = "1.0.1"

[[Base64]]
uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"

[[Bzip2_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "19a35467a82e236ff51bc17a3a44b69ef35185a2"
uuid = "6e34b625-4abd-537c-b88f-471c36dfa7a0"
version = "1.0.8+0"

[[CSV]]
deps = ["CodecZlib", "Dates", "FilePathsBase", "InlineStrings", "Mmap", "Parsers", "PooledArrays", "SentinelArrays", "Tables", "Unicode", "WeakRefStrings"]
git-tree-sha1 = "873fb188a4b9d76549b81465b1f75c82aaf59238"
uuid = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b"
version = "0.10.4"

[[Cairo_jll]]
deps = ["Artifacts", "Bzip2_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "JLLWrappers", "LZO_jll", "Libdl", "Pixman_jll", "Pkg", "Xorg_libXext_jll", "Xorg_libXrender_jll", "Zlib_jll", "libpng_jll"]
git-tree-sha1 = "4b859a208b2397a7a623a03449e4636bdb17bcf2"
uuid = "83423d85-b0ee-5818-9007-b63ccbeb887a"
version = "1.16.1+1"

[[Chain]]
git-tree-sha1 = "339237319ef4712e6e5df7758d0bccddf5c237d9"
uuid = "8be319e6-bccf-4806-a6f7-6fae938471bc"
version = "0.4.10"

[[ChainRulesCore]]
deps = ["Compat", "LinearAlgebra", "SparseArrays"]
git-tree-sha1 = "9489214b993cd42d17f44c36e359bf6a7c919abf"
uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"
version = "1.15.0"

[[ChangesOfVariables]]
deps = ["ChainRulesCore", "LinearAlgebra", "Test"]
git-tree-sha1 = "1e315e3f4b0b7ce40feded39c73049692126cf53"
uuid = "9e997f8a-9a97-42d5-a9f1-ce6bfc15e2c0"
version = "0.1.3"

[[Clustering]]
deps = ["Distances", "LinearAlgebra", "NearestNeighbors", "Printf", "SparseArrays", "Statistics", "StatsBase"]
git-tree-sha1 = "75479b7df4167267d75294d14b58244695beb2ac"
uuid = "aaaa29a8-35af-508c-8bc3-b662a17a0fe5"
version = "0.14.2"

[[CodecZlib]]
deps = ["TranscodingStreams", "Zlib_jll"]
git-tree-sha1 = "ded953804d019afa9a3f98981d99b33e3db7b6da"
uuid = "944b1d66-785c-5afd-91f1-9de20f533193"
version = "0.7.0"

[[ColorSchemes]]
deps = ["ColorTypes", "ColorVectorSpace", "Colors", "FixedPointNumbers", "Random"]
git-tree-sha1 = "7297381ccb5df764549818d9a7d57e45f1057d30"
uuid = "35d6a980-a343-548e-a6ea-1d62b119f2f4"
version = "3.18.0"

[[ColorTypes]]
deps = ["FixedPointNumbers", "Random"]
git-tree-sha1 = "a985dc37e357a3b22b260a5def99f3530fb415d3"
uuid = "3da002f7-5984-5a60-b8a6-cbb66c0b333f"
version = "0.11.2"

[[ColorVectorSpace]]
deps = ["ColorTypes", "FixedPointNumbers", "LinearAlgebra", "SpecialFunctions", "Statistics", "TensorCore"]
git-tree-sha1 = "d08c20eef1f2cbc6e60fd3612ac4340b89fea322"
uuid = "c3611d14-8923-5661-9e6a-0046d554d3a4"
version = "0.9.9"

[[Colors]]
deps = ["ColorTypes", "FixedPointNumbers", "Reexport"]
git-tree-sha1 = "417b0ed7b8b838aa6ca0a87aadf1bb9eb111ce40"
uuid = "5ae59095-9a9b-59fe-a467-6f913c188581"
version = "0.12.8"

[[Compat]]
deps = ["Base64", "Dates", "DelimitedFiles", "Distributed", "InteractiveUtils", "LibGit2", "Libdl", "LinearAlgebra", "Markdown", "Mmap", "Pkg", "Printf", "REPL", "Random", "SHA", "Serialization", "SharedArrays", "Sockets", "SparseArrays", "Statistics", "Test", "UUIDs", "Unicode"]
git-tree-sha1 = "b153278a25dd42c65abbf4e62344f9d22e59191b"
uuid = "34da2185-b29b-5c13-b0c7-acf172513d20"
version = "3.43.0"

[[CompilerSupportLibraries_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae"

[[Contour]]
deps = ["StaticArrays"]
git-tree-sha1 = "9f02045d934dc030edad45944ea80dbd1f0ebea7"
uuid = "d38c429a-6771-53c6-b99e-75d170b6e991"
version = "0.5.7"

[[Crayons]]
git-tree-sha1 = "249fe38abf76d48563e2f4556bebd215aa317e15"
uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f"
version = "4.1.1"

[[DataAPI]]
git-tree-sha1 = "fb5f5316dd3fd4c5e7c30a24d50643b73e37cd40"
uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a"
version = "1.10.0"

[[DataFrames]]
deps = ["Compat", "DataAPI", "Future", "InvertedIndices", "IteratorInterfaceExtensions", "LinearAlgebra", "Markdown", "Missings", "PooledArrays", "PrettyTables", "Printf", "REPL", "Reexport", "SortingAlgorithms", "Statistics", "TableTraits", "Tables", "Unicode"]
git-tree-sha1 = "daa21eb85147f72e41f6352a57fccea377e310a9"
uuid = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
version = "1.3.4"

[[DataFramesMeta]]
deps = ["Chain", "DataFrames", "MacroTools", "OrderedCollections", "Reexport"]
git-tree-sha1 = "f1d89a07475dc4b03c08543d1c6b4b2945f33eca"
uuid = "1313f7d8-7da2-5740-9ea0-a2ca25f37964"
version = "0.11.0"

[[DataStructures]]
deps = ["Compat", "InteractiveUtils", "OrderedCollections"]
git-tree-sha1 = "d1fff3a548102f48987a52a2e0d114fa97d730f0"
uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
version = "0.18.13"

[[DataValueInterfaces]]
git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6"
uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464"
version = "1.0.0"

[[DataValues]]
deps = ["DataValueInterfaces", "Dates"]
git-tree-sha1 = "d88a19299eba280a6d062e135a43f00323ae70bf"
uuid = "e7dc6d0d-1eca-5fa6-8ad6-5aecde8b7ea5"
version = "0.4.13"

[[Dates]]
deps = ["Printf"]
uuid = "ade2ca70-3891-5945-98fb-dc099432e06a"

[[DelimitedFiles]]
deps = ["Mmap"]
uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab"

[[DensityInterface]]
deps = ["InverseFunctions", "Test"]
git-tree-sha1 = "80c3e8639e3353e5d2912fb3a1916b8455e2494b"
uuid = "b429d917-457f-4dbc-8f4c-0cc954292b1d"
version = "0.4.0"

[[Distances]]
deps = ["LinearAlgebra", "SparseArrays", "Statistics", "StatsAPI"]
git-tree-sha1 = "3258d0659f812acde79e8a74b11f17ac06d0ca04"
uuid = "b4f34e82-e78d-54a5-968a-f98e89d6e8f7"
version = "0.10.7"

[[Distributed]]
deps = ["Random", "Serialization", "Sockets"]
uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b"

[[Distributions]]
deps = ["ChainRulesCore", "DensityInterface", "FillArrays", "LinearAlgebra", "PDMats", "Printf", "QuadGK", "Random", "SparseArrays", "SpecialFunctions", "Statistics", "StatsBase", "StatsFuns", "Test"]
git-tree-sha1 = "d29d8faf1a0ca59167f04edd4d0eb971a6ae009c"
uuid = "31c24e10-a181-5473-b8eb-7969acd0382f"
version = "0.25.59"

[[DocStringExtensions]]
deps = ["LibGit2"]
git-tree-sha1 = "b19534d1895d702889b219c382a6e18010797f0b"
uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"
version = "0.8.6"

[[Downloads]]
deps = ["ArgTools", "LibCURL", "NetworkOptions"]
uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6"

[[DrWatson]]
deps = ["Dates", "FileIO", "JLD2", "LibGit2", "MacroTools", "Pkg", "Random", "Requires", "Scratch", "UnPack"]
git-tree-sha1 = "67e9001646db6e45006643bf37716ecd831d37d2"
uuid = "634d3b9d-ee7a-5ddf-bec9-22491ea816e1"
version = "2.9.1"

[[EarCut_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "3f3a2501fa7236e9b911e0f7a588c657e822bb6d"
uuid = "5ae413db-bbd1-5e63-b57d-d24a61df00f5"
version = "2.2.3+0"

[[Expat_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "bad72f730e9e91c08d9427d5e8db95478a3c323d"
uuid = "2e619515-83b5-522b-bb60-26c02a35a201"
version = "2.4.8+0"

[[FFMPEG]]
deps = ["FFMPEG_jll"]
git-tree-sha1 = "b57e3acbe22f8484b4b5ff66a7499717fe1a9cc8"
uuid = "c87230d0-a227-11e9-1b43-d7ebe4e7570a"
version = "0.4.1"

[[FFMPEG_jll]]
deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "JLLWrappers", "LAME_jll", "Libdl", "Ogg_jll", "OpenSSL_jll", "Opus_jll", "Pkg", "Zlib_jll", "libass_jll", "libfdk_aac_jll", "libvorbis_jll", "x264_jll", "x265_jll"]
git-tree-sha1 = "d8a578692e3077ac998b50c0217dfd67f21d1e5f"
uuid = "b22a6f82-2f65-5046-a5b2-351ab43fb4e5"
version = "4.4.0+0"

[[FFTW]]
deps = ["AbstractFFTs", "FFTW_jll", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"]
git-tree-sha1 = "505876577b5481e50d089c1c68899dfb6faebc62"
uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341"
version = "1.4.6"

[[FFTW_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "c6033cc3892d0ef5bb9cd29b7f2f0331ea5184ea"
uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a"
version = "3.3.10+0"

[[FileIO]]
deps = ["Pkg", "Requires", "UUIDs"]
git-tree-sha1 = "9267e5f50b0e12fdfd5a2455534345c4cf2c7f7a"
uuid = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549"
version = "1.14.0"

[[FilePathsBase]]
deps = ["Compat", "Dates", "Mmap", "Printf", "Test", "UUIDs"]
git-tree-sha1 = "129b104185df66e408edd6625d480b7f9e9823a0"
uuid = "48062228-2e41-5def-b9a4-89aafe57970f"
version = "0.9.18"

[[FillArrays]]
deps = ["LinearAlgebra", "Random", "SparseArrays", "Statistics"]
git-tree-sha1 = "deed294cde3de20ae0b2e0355a6c4e1c6a5ceffc"
uuid = "1a297f60-69ca-5386-bcde-b61e274b549b"
version = "0.12.8"

[[FixedPointNumbers]]
deps = ["Statistics"]
git-tree-sha1 = "335bfdceacc84c5cdf16aadc768aa5ddfc5383cc"
uuid = "53c48c17-4a7d-5ca2-90c5-79b7896eea93"
version = "0.8.4"

[[Fontconfig_jll]]
deps = ["Artifacts", "Bzip2_jll", "Expat_jll", "FreeType2_jll", "JLLWrappers", "Libdl", "Libuuid_jll", "Pkg", "Zlib_jll"]
git-tree-sha1 = "21efd19106a55620a188615da6d3d06cd7f6ee03"
uuid = "a3f928ae-7b40-5064-980b-68af3947d34b"
version = "2.13.93+0"

[[Formatting]]
deps = ["Printf"]
git-tree-sha1 = "8339d61043228fdd3eb658d86c926cb282ae72a8"
uuid = "59287772-0a20-5a39-b81b-1366585eb4c0"
version = "0.4.2"

[[FreeType2_jll]]
deps = ["Artifacts", "Bzip2_jll", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"]
git-tree-sha1 = "87eb71354d8ec1a96d4a7636bd57a7347dde3ef9"
uuid = "d7e528f0-a631-5988-bf34-fe36492bcfd7"
version = "2.10.4+0"

[[FriBidi_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "aa31987c2ba8704e23c6c8ba8a4f769d5d7e4f91"
uuid = "559328eb-81f9-559d-9380-de523a88c83c"
version = "1.0.10+0"

[[Future]]
deps = ["Random"]
uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820"

[[GLFW_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Libglvnd_jll", "Pkg", "Xorg_libXcursor_jll", "Xorg_libXi_jll", "Xorg_libXinerama_jll", "Xorg_libXrandr_jll"]
git-tree-sha1 = "51d2dfe8e590fbd74e7a842cf6d13d8a2f45dc01"
uuid = "0656b61e-2033-5cc2-a64a-77c0f6c09b89"
version = "3.3.6+0"

[[GR]]
deps = ["Base64", "DelimitedFiles", "GR_jll", "HTTP", "JSON", "Libdl", "LinearAlgebra", "Pkg", "Printf", "Random", "RelocatableFolders", "Serialization", "Sockets", "Test", "UUIDs"]
git-tree-sha1 = "b316fd18f5bc025fedcb708332aecb3e13b9b453"
uuid = "28b8d3ca-fb5f-59d9-8090-bfdbd6d07a71"
version = "0.64.3"

[[GR_jll]]
deps = ["Artifacts", "Bzip2_jll", "Cairo_jll", "FFMPEG_jll", "Fontconfig_jll", "GLFW_jll", "JLLWrappers", "JpegTurbo_jll", "Libdl", "Libtiff_jll", "Pixman_jll", "Pkg", "Qt5Base_jll", "Zlib_jll", "libpng_jll"]
git-tree-sha1 = "1e5490a51b4e9d07e8b04836f6008f46b48aaa87"
uuid = "d2c73de3-f751-5644-a686-071e5b155ba9"
version = "0.64.3+0"

[[GeometryBasics]]
deps = ["EarCut_jll", "IterTools", "LinearAlgebra", "StaticArrays", "StructArrays", "Tables"]
git-tree-sha1 = "83ea630384a13fc4f002b77690bc0afeb4255ac9"
uuid = "5c1252a2-5f33-56bf-86c9-59e7332b4326"
version = "0.4.2"

[[GeometryTypes]]
deps = ["ColorTypes", "FixedPointNumbers", "LinearAlgebra", "StaticArrays"]
git-tree-sha1 = "d796f7be0383b5416cd403420ce0af083b0f9b28"
uuid = "4d00f742-c7ba-57c2-abde-4428a4b178cb"
version = "0.8.5"

[[Gettext_jll]]
deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Libiconv_jll", "Pkg", "XML2_jll"]
git-tree-sha1 = "9b02998aba7bf074d14de89f9d37ca24a1a0b046"
uuid = "78b55507-aeef-58d4-861c-77aaff3498b1"
version = "0.21.0+0"

[[Glib_jll]]
deps = ["Artifacts", "Gettext_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Libiconv_jll", "Libmount_jll", "PCRE_jll", "Pkg", "Zlib_jll"]
git-tree-sha1 = "a32d672ac2c967f3deb8a81d828afc739c838a06"
uuid = "7746bdde-850d-59dc-9ae8-88ece973131d"
version = "2.68.3+2"

[[GraphRecipes]]
deps = ["AbstractTrees", "GeometryTypes", "Graphs", "InteractiveUtils", "Interpolations", "LinearAlgebra", "NaNMath", "NetworkLayout", "PlotUtils", "RecipesBase", "SparseArrays", "Statistics"]
git-tree-sha1 = "1735085e3a8dd0e14020bdcbf8da9893a5508a3f"
uuid = "bd48cda9-67a9-57be-86fa-5b3c104eda73"
version = "0.5.9"

[[Graphite2_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "344bf40dcab1073aca04aa0df4fb092f920e4011"
uuid = "3b182d85-2403-5c21-9c21-1e1f0cc25472"
version = "1.3.14+0"

[[Graphs]]
deps = ["ArnoldiMethod", "Compat", "DataStructures", "Distributed", "Inflate", "LinearAlgebra", "Random", "SharedArrays", "SimpleTraits", "SparseArrays", "Statistics"]
git-tree-sha1 = "4888af84657011a65afc7a564918d281612f983a"
uuid = "86223c79-3864-5bf0-83f7-82e725a168b6"
version = "1.7.0"

[[Grisu]]
git-tree-sha1 = "53bb909d1151e57e2484c3d1b53e19552b887fb2"
uuid = "42e2da0e-8278-4e71-bc24-59509adca0fe"
version = "1.0.2"

[[HTTP]]
deps = ["Base64", "Dates", "IniFile", "Logging", "MbedTLS", "NetworkOptions", "Sockets", "URIs"]
git-tree-sha1 = "0fa77022fe4b511826b39c894c90daf5fce3334a"
uuid = "cd3eb016-35fb-5094-929b-558a96fad6f3"
version = "0.9.17"

[[HarfBuzz_jll]]
deps = ["Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "Graphite2_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Pkg"]
git-tree-sha1 = "129acf094d168394e80ee1dc4bc06ec835e510a3"
uuid = "2e76f6c2-a576-52d4-95c1-20adfe4de566"
version = "2.8.1+1"

[[Hyperscript]]
deps = ["Test"]
git-tree-sha1 = "8d511d5b81240fc8e6802386302675bdf47737b9"
uuid = "47d2ed2b-36de-50cf-bf87-49c2cf4b8b91"
version = "0.0.4"

[[HypertextLiteral]]
deps = ["Tricks"]
git-tree-sha1 = "c47c5fa4c5308f27ccaac35504858d8914e102f9"
uuid = "ac1192a8-f4b3-4bfe-ba22-af5b92cd3ab2"
version = "0.9.4"

[[IOCapture]]
deps = ["Logging", "Random"]
git-tree-sha1 = "f7be53659ab06ddc986428d3a9dcc95f6fa6705a"
uuid = "b5f81e59-6552-4d32-b1f0-c071b021bf89"
version = "0.2.2"

[[Inflate]]
git-tree-sha1 = "f5fc07d4e706b84f72d54eedcc1c13d92fb0871c"
uuid = "d25df0c9-e2be-5dd7-82c8-3ad0b3e990b9"
version = "0.1.2"

[[IniFile]]
git-tree-sha1 = "f550e6e32074c939295eb5ea6de31849ac2c9625"
uuid = "83e8ac13-25f8-5344-8a64-a9f2b223428f"
version = "0.5.1"

[[InlineStrings]]
deps = ["Parsers"]
git-tree-sha1 = "61feba885fac3a407465726d0c330b3055df897f"
uuid = "842dd82b-1e85-43dc-bf29-5d0ee9dffc48"
version = "1.1.2"

[[IntelOpenMP_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "d979e54b71da82f3a65b62553da4fc3d18c9004c"
uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0"
version = "2018.0.3+2"

[[InteractiveUtils]]
deps = ["Markdown"]
uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240"

[[Interpolations]]
deps = ["AxisAlgorithms", "ChainRulesCore", "LinearAlgebra", "OffsetArrays", "Random", "Ratios", "Requires", "SharedArrays", "SparseArrays", "StaticArrays", "WoodburyMatrices"]
git-tree-sha1 = "b7bc05649af456efc75d178846f47006c2c4c3c7"
uuid = "a98d9a8b-a2ab-59e6-89dd-64a1c18fca59"
version = "0.13.6"

[[InverseFunctions]]
deps = ["Test"]
git-tree-sha1 = "336cc738f03e069ef2cac55a104eb823455dca75"
uuid = "3587e190-3f89-42d0-90ee-14403ec27112"
version = "0.1.4"

[[InvertedIndices]]
git-tree-sha1 = "bee5f1ef5bf65df56bdd2e40447590b272a5471f"
uuid = "41ab1584-1d38-5bbf-9106-f11c6c58b48f"
version = "1.1.0"

[[IrrationalConstants]]
git-tree-sha1 = "7fd44fd4ff43fc60815f8e764c0f352b83c49151"
uuid = "92d709cd-6900-40b7-9082-c6be49f344b6"
version = "0.1.1"

[[IterTools]]
git-tree-sha1 = "fa6287a4469f5e048d763df38279ee729fbd44e5"
uuid = "c8e1da08-722c-5040-9ed9-7db0dc04731e"
version = "1.4.0"

[[IteratorInterfaceExtensions]]
git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856"
uuid = "82899510-4779-5014-852e-03e436cf321d"
version = "1.0.0"

[[JLD2]]
deps = ["FileIO", "MacroTools", "Mmap", "OrderedCollections", "Pkg", "Printf", "Reexport", "TranscodingStreams", "UUIDs"]
git-tree-sha1 = "81b9477b49402b47fbe7f7ae0b252077f53e4a08"
uuid = "033835bb-8acc-5ee8-8aae-3f567f8a3819"
version = "0.4.22"

[[JLLWrappers]]
deps = ["Preferences"]
git-tree-sha1 = "abc9885a7ca2052a736a600f7fa66209f96506e1"
uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210"
version = "1.4.1"

[[JSON]]
deps = ["Dates", "Mmap", "Parsers", "Unicode"]
git-tree-sha1 = "3c837543ddb02250ef42f4738347454f95079d4e"
uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
version = "0.21.3"

[[JSON3]]
deps = ["Dates", "Mmap", "Parsers", "StructTypes", "UUIDs"]
git-tree-sha1 = "fd6f0cae36f42525567108a42c1c674af2ac620d"
uuid = "0f8b85d8-7281-11e9-16c2-39a750bddbf1"
version = "1.9.5"

[[JpegTurbo_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "b53380851c6e6664204efb2e62cd24fa5c47e4ba"
uuid = "aacddb02-875f-59d6-b918-886e6ef4fbf8"
version = "2.1.2+0"

[[KernelDensity]]
deps = ["Distributions", "DocStringExtensions", "FFTW", "Interpolations", "StatsBase"]
git-tree-sha1 = "591e8dc09ad18386189610acafb970032c519707"
uuid = "5ab0869b-81aa-558d-bb23-cbf5423bbe9b"
version = "0.6.3"

[[LAME_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "f6250b16881adf048549549fba48b1161acdac8c"
uuid = "c1c5ebd0-6772-5130-a774-d5fcae4a789d"
version = "3.100.1+0"

[[LERC_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "bf36f528eec6634efc60d7ec062008f171071434"
uuid = "88015f11-f218-50d7-93a8-a6af411a945d"
version = "3.0.0+1"

[[LZO_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "e5b909bcf985c5e2605737d2ce278ed791b89be6"
uuid = "dd4b983a-f0e5-5f8d-a1b7-129d4a5fb1ac"
version = "2.10.1+0"

[[LaTeXStrings]]
git-tree-sha1 = "f2355693d6778a178ade15952b7ac47a4ff97996"
uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f"
version = "1.3.0"

[[Latexify]]
deps = ["Formatting", "InteractiveUtils", "LaTeXStrings", "MacroTools", "Markdown", "Printf", "Requires"]
git-tree-sha1 = "46a39b9c58749eefb5f2dc1178cb8fab5332b1ab"
uuid = "23fbe1c1-3f47-55db-b15f-69d7ec21a316"
version = "0.15.15"

[[LazyArtifacts]]
deps = ["Artifacts", "Pkg"]
uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3"

[[LibCURL]]
deps = ["LibCURL_jll", "MozillaCACerts_jll"]
uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21"

[[LibCURL_jll]]
deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"]
uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0"

[[LibGit2]]
deps = ["Base64", "NetworkOptions", "Printf", "SHA"]
uuid = "76f85450-5226-5b5a-8eaa-529ad045b433"

[[LibSSH2_jll]]
deps = ["Artifacts", "Libdl", "MbedTLS_jll"]
uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8"

[[Libdl]]
uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb"

[[Libffi_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "0b4a5d71f3e5200a7dff793393e09dfc2d874290"
uuid = "e9f186c6-92d2-5b65-8a66-fee21dc1b490"
version = "3.2.2+1"

[[Libgcrypt_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Libgpg_error_jll", "Pkg"]
git-tree-sha1 = "64613c82a59c120435c067c2b809fc61cf5166ae"
uuid = "d4300ac3-e22c-5743-9152-c294e39db1e4"
version = "1.8.7+0"

[[Libglvnd_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll", "Xorg_libXext_jll"]
git-tree-sha1 = "7739f837d6447403596a75d19ed01fd08d6f56bf"
uuid = "7e76a0d4-f3c7-5321-8279-8d96eeed0f29"
version = "1.3.0+3"

[[Libgpg_error_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "c333716e46366857753e273ce6a69ee0945a6db9"
uuid = "7add5ba3-2f88-524e-9cd5-f83b8a55f7b8"
version = "1.42.0+0"

[[Libiconv_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "42b62845d70a619f063a7da093d995ec8e15e778"
uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531"
version = "1.16.1+1"

[[Libmount_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "9c30530bf0effd46e15e0fdcf2b8636e78cbbd73"
uuid = "4b2f31a3-9ecc-558c-b454-b3730dcb73e9"
version = "2.35.0+0"

[[Libtiff_jll]]
deps = ["Artifacts", "JLLWrappers", "JpegTurbo_jll", "LERC_jll", "Libdl", "Pkg", "Zlib_jll", "Zstd_jll"]
git-tree-sha1 = "c9551dd26e31ab17b86cbd00c2ede019c08758eb"
uuid = "89763e89-9b03-5906-acba-b20f662cd828"
version = "4.3.0+1"

[[Libuuid_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "7f3efec06033682db852f8b3bc3c1d2b0a0ab066"
uuid = "38a345b3-de98-5d2b-a5d3-14cd9215e700"
version = "2.36.0+0"

[[LightOSM]]
deps = ["DataStructures", "Graphs", "HTTP", "JSON", "LightXML", "MetaGraphs", "NearestNeighbors", "Parameters", "SimpleWeightedGraphs", "SparseArrays", "StaticGraphs", "Statistics"]
git-tree-sha1 = "996b8038d66eb675278ce26bf7f68c29eaf161cb"
uuid = "d1922b25-af4e-4ba3-84af-fe9bea896051"
version = "0.1.19"

[[LightXML]]
deps = ["Libdl", "XML2_jll"]
git-tree-sha1 = "e129d9391168c677cd4800f5c0abb1ed8cb3794f"
uuid = "9c8b4983-aa76-5018-a973-4c85ecc9e179"
version = "0.9.0"

[[LinearAlgebra]]
deps = ["Libdl"]
uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"

[[LogExpFunctions]]
deps = ["ChainRulesCore", "ChangesOfVariables", "DocStringExtensions", "InverseFunctions", "IrrationalConstants", "LinearAlgebra"]
git-tree-sha1 = "09e4b894ce6a976c354a69041a04748180d43637"
uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688"
version = "0.3.15"

[[Logging]]
uuid = "56ddb016-857b-54e1-b83d-db4d58db5568"

[[MKL_jll]]
deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "Pkg"]
git-tree-sha1 = "e595b205efd49508358f7dc670a940c790204629"
uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7"
version = "2022.0.0+0"

[[MacroTools]]
deps = ["Markdown", "Random"]
git-tree-sha1 = "3d3e902b31198a27340d0bf00d6ac452866021cf"
uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
version = "0.5.9"

[[Markdown]]
deps = ["Base64"]
uuid = "d6f4376e-aef5-505a-96c1-9c027394607a"

[[MbedTLS]]
deps = ["Dates", "MbedTLS_jll", "Random", "Sockets"]
git-tree-sha1 = "1c38e51c3d08ef2278062ebceade0e46cefc96fe"
uuid = "739be429-bea8-5141-9913-cc70e7f3736d"
version = "1.0.3"

[[MbedTLS_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1"

[[Measures]]
git-tree-sha1 = "e498ddeee6f9fdb4551ce855a46f54dbd900245f"
uuid = "442fdcdd-2543-5da2-b0f3-8c86c306513e"
version = "0.3.1"

[[Memoize]]
deps = ["MacroTools"]
git-tree-sha1 = "2b1dfcba103de714d31c033b5dacc2e4a12c7caa"
uuid = "c03570c3-d221-55d1-a50c-7939bbd78826"
version = "0.4.4"

[[MetaGraphs]]
deps = ["Graphs", "JLD2", "Random"]
git-tree-sha1 = "2af69ff3c024d13bde52b34a2a7d6887d4e7b438"
uuid = "626554b9-1ddb-594c-aa3c-2596fe9399a5"
version = "0.7.1"

[[Missings]]
deps = ["DataAPI"]
git-tree-sha1 = "bf210ce90b6c9eed32d25dbcae1ebc565df2687f"
uuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28"
version = "1.0.2"

[[Mmap]]
uuid = "a63ad114-7e13-5084-954f-fe012c677804"

[[MozillaCACerts_jll]]
uuid = "14a3606d-f60d-562e-9121-12d972cd8159"

[[MultivariateStats]]
deps = ["Arpack", "LinearAlgebra", "SparseArrays", "Statistics", "StatsBase"]
git-tree-sha1 = "6d019f5a0465522bbfdd68ecfad7f86b535d6935"
uuid = "6f286f6a-111f-5878-ab1e-185364afe411"
version = "0.9.0"

[[NaNMath]]
git-tree-sha1 = "b086b7ea07f8e38cf122f5016af580881ac914fe"
uuid = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"
version = "0.3.7"

[[NearestNeighbors]]
deps = ["Distances", "StaticArrays"]
git-tree-sha1 = "ded92de95031d4a8c61dfb6ba9adb6f1d8016ddd"
uuid = "b8a86587-4115-5ab1-83bc-aa920d37bbce"
version = "0.4.10"

[[NetworkLayout]]
deps = ["GeometryBasics", "LinearAlgebra", "Random", "Requires", "SparseArrays"]
git-tree-sha1 = "cac8fc7ba64b699c678094fa630f49b80618f625"
uuid = "46757867-2c16-5918-afeb-47bfcb05e46a"
version = "0.4.4"

[[NetworkOptions]]
uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908"

[[Observables]]
git-tree-sha1 = "dfd8d34871bc3ad08cd16026c1828e271d554db9"
uuid = "510215fc-4207-5dde-b226-833fc4488ee2"
version = "0.5.1"

[[OffsetArrays]]
deps = ["Adapt"]
git-tree-sha1 = "9cf6b82f7f337c01eac9995be43d11483dee5d7b"
uuid = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
version = "1.12.0"

[[Ogg_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "887579a3eb005446d514ab7aeac5d1d027658b8f"
uuid = "e7412a2a-1a6e-54c0-be00-318e2571c051"
version = "1.3.5+1"

[[OpenBLAS_jll]]
deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"]
uuid = "4536629a-c528-5b80-bd46-f80d51c5b363"

[[OpenLibm_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "05823500-19ac-5b8b-9628-191a04bc5112"

[[OpenSSL_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "ab05aa4cc89736e95915b01e7279e61b1bfe33b8"
uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95"
version = "1.1.14+0"

[[OpenSpecFun_jll]]
deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "13652491f6856acfd2db29360e1bbcd4565d04f1"
uuid = "efe28fd5-8261-553b-a9e1-b2916fc3738e"
version = "0.5.5+0"

[[Opus_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "51a08fb14ec28da2ec7a927c4337e4332c2a4720"
uuid = "91d4177d-7536-5919-b921-800302f37372"
version = "1.3.2+0"

[[OrderedCollections]]
git-tree-sha1 = "85f8e6578bf1f9ee0d11e7bb1b1456435479d47c"
uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
version = "1.4.1"

[[PCRE_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "b2a7af664e098055a7529ad1a900ded962bca488"
uuid = "2f80f16e-611a-54ab-bc61-aa92de5b98fc"
version = "8.44.0+0"

[[PDMats]]
deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"]
git-tree-sha1 = "027185efff6be268abbaf30cfd53ca9b59e3c857"
uuid = "90014a1f-27ba-587c-ab20-58faa44d9150"
version = "0.11.10"

[[Parameters]]
deps = ["OrderedCollections", "UnPack"]
git-tree-sha1 = "34c0e9ad262e5f7fc75b10a9952ca7692cfc5fbe"
uuid = "d96e819e-fc66-5662-9728-84c9c7592b0a"
version = "0.12.3"

[[Parsers]]
deps = ["Dates"]
git-tree-sha1 = "1285416549ccfcdf0c50d4997a94331e88d68413"
uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0"
version = "2.3.1"

[[Pixman_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "b4f5d02549a10e20780a24fce72bea96b6329e29"
uuid = "30392449-352a-5448-841d-b1acce4e97dc"
version = "0.40.1+0"

[[Pkg]]
deps = ["Artifacts", "Dates", "Downloads", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"]
uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"

[[PlotThemes]]
deps = ["PlotUtils", "Statistics"]
git-tree-sha1 = "8162b2f8547bc23876edd0c5181b27702ae58dce"
uuid = "ccf2f8ad-2431-5c83-bf29-c5338b663b6a"
version = "3.0.0"

[[PlotUtils]]
deps = ["ColorSchemes", "Colors", "Dates", "Printf", "Random", "Reexport", "Statistics"]
git-tree-sha1 = "bb16469fd5224100e422f0b027d26c5a25de1200"
uuid = "995b91a9-d308-5afd-9ec6-746e21dbc043"
version = "1.2.0"

[[Plots]]
deps = ["Base64", "Contour", "Dates", "Downloads", "FFMPEG", "FixedPointNumbers", "GR", "GeometryBasics", "JSON", "Latexify", "LinearAlgebra", "Measures", "NaNMath", "Pkg", "PlotThemes", "PlotUtils", "Printf", "REPL", "Random", "RecipesBase", "RecipesPipeline", "Reexport", "Requires", "Scratch", "Showoff", "SparseArrays", "Statistics", "StatsBase", "UUIDs", "UnicodeFun", "Unzip"]
git-tree-sha1 = "d457f881ea56bbfa18222642de51e0abf67b9027"
uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
version = "1.29.0"

[[PlutoUI]]
deps = ["AbstractPlutoDingetjes", "Base64", "ColorTypes", "Dates", "Hyperscript", "HypertextLiteral", "IOCapture", "InteractiveUtils", "JSON", "Logging", "Markdown", "Random", "Reexport", "UUIDs"]
git-tree-sha1 = "8d1f54886b9037091edf146b517989fc4a09efec"
uuid = "7f904dfe-b85e-4ff6-b463-dae2292396a8"
version = "0.7.39"

[[PooledArrays]]
deps = ["DataAPI", "Future"]
git-tree-sha1 = "a6062fe4063cdafe78f4a0a81cfffb89721b30e7"
uuid = "2dfb63ee-cc39-5dd5-95bd-886bf059d720"
version = "1.4.2"

[[Preferences]]
deps = ["TOML"]
git-tree-sha1 = "47e5f437cc0e7ef2ce8406ce1e7e24d44915f88d"
uuid = "21216c6a-2e73-6563-6e65-726566657250"
version = "1.3.0"

[[PrettyTables]]
deps = ["Crayons", "Formatting", "Markdown", "Reexport", "Tables"]
git-tree-sha1 = "dfb54c4e414caa595a1f2ed759b160f5a3ddcba5"
uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d"
version = "1.3.1"

[[Printf]]
deps = ["Unicode"]
uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7"

[[ProgressMeter]]
deps = ["Distributed", "Printf"]
git-tree-sha1 = "d7a7aef8f8f2d537104f170139553b14dfe39fe9"
uuid = "92933f4c-e287-5a05-a399-4b506db050ca"
version = "1.7.2"

[[Qt5Base_jll]]
deps = ["Artifacts", "CompilerSupportLibraries_jll", "Fontconfig_jll", "Glib_jll", "JLLWrappers", "Libdl", "Libglvnd_jll", "OpenSSL_jll", "Pkg", "Xorg_libXext_jll", "Xorg_libxcb_jll", "Xorg_xcb_util_image_jll", "Xorg_xcb_util_keysyms_jll", "Xorg_xcb_util_renderutil_jll", "Xorg_xcb_util_wm_jll", "Zlib_jll", "xkbcommon_jll"]
git-tree-sha1 = "c6c0f690d0cc7caddb74cef7aa847b824a16b256"
uuid = "ea2cea3b-5b76-57ae-a6ef-0a8af62496e1"
version = "5.15.3+1"

[[QuadGK]]
deps = ["DataStructures", "LinearAlgebra"]
git-tree-sha1 = "78aadffb3efd2155af139781b8a8df1ef279ea39"
uuid = "1fd47b50-473d-5c70-9696-f719f8f3bcdc"
version = "2.4.2"

[[REPL]]
deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"]
uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"

[[Random]]
deps = ["Serialization"]
uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"

[[Ratios]]
deps = ["Requires"]
git-tree-sha1 = "dc84268fe0e3335a62e315a3a7cf2afa7178a734"
uuid = "c84ed2f1-dad5-54f0-aa8e-dbefe2724439"
version = "0.4.3"

[[RecipesBase]]
git-tree-sha1 = "6bf3f380ff52ce0832ddd3a2a7b9538ed1bcca7d"
uuid = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
version = "1.2.1"

[[RecipesPipeline]]
deps = ["Dates", "NaNMath", "PlotUtils", "RecipesBase"]
git-tree-sha1 = "dc1e451e15d90347a7decc4221842a022b011714"
uuid = "01d81517-befc-4cb6-b9ec-a95719d0359c"
version = "0.5.2"

[[Reexport]]
git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b"
uuid = "189a3867-3050-52da-a836-e630ba90ab69"
version = "1.2.2"

[[RelocatableFolders]]
deps = ["SHA", "Scratch"]
git-tree-sha1 = "cdbd3b1338c72ce29d9584fdbe9e9b70eeb5adca"
uuid = "05181044-ff0b-4ac5-8273-598c1e38db00"
version = "0.1.3"

[[Requires]]
deps = ["UUIDs"]
git-tree-sha1 = "838a3a4188e2ded87a4f9f184b4b0d78a1e91cb7"
uuid = "ae029012-a4dd-5104-9daa-d747884805df"
version = "1.3.0"

[[Rmath]]
deps = ["Random", "Rmath_jll"]
git-tree-sha1 = "bf3188feca147ce108c76ad82c2792c57abe7b1f"
uuid = "79098fc4-a85e-5d69-aa6a-4863f24498fa"
version = "0.7.0"

[[Rmath_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "68db32dff12bb6127bac73c209881191bf0efbb7"
uuid = "f50d1b31-88e8-58de-be2c-1cc44531875f"
version = "0.3.0+0"

[[SHA]]
uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce"

[[Scratch]]
deps = ["Dates"]
git-tree-sha1 = "0b4b7f1393cff97c33891da2a0bf69c6ed241fda"
uuid = "6c6a2e73-6563-6170-7368-637461726353"
version = "1.1.0"

[[SentinelArrays]]
deps = ["Dates", "Random"]
git-tree-sha1 = "6a2f7d70512d205ca8c7ee31bfa9f142fe74310c"
uuid = "91c51154-3ec4-41a3-a24f-3f23e20d615c"
version = "1.3.12"

[[Serialization]]
uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b"

[[SharedArrays]]
deps = ["Distributed", "Mmap", "Random", "Serialization"]
uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383"

[[ShortCodes]]
deps = ["Base64", "CodecZlib", "HTTP", "JSON3", "Memoize", "UUIDs"]
git-tree-sha1 = "0fcc38215160e0a964e9b0f0c25dcca3b2112ad1"
uuid = "f62ebe17-55c5-4640-972f-b59c0dd11ccf"
version = "0.3.3"

[[Showoff]]
deps = ["Dates", "Grisu"]
git-tree-sha1 = "91eddf657aca81df9ae6ceb20b959ae5653ad1de"
uuid = "992d4aef-0814-514b-bc4d-f2e9a6c4116f"
version = "1.0.3"

[[SimpleTraits]]
deps = ["InteractiveUtils", "MacroTools"]
git-tree-sha1 = "5d7e3f4e11935503d3ecaf7186eac40602e7d231"
uuid = "699a6c99-e7fa-54fc-8d76-47d257e15c1d"
version = "0.9.4"

[[SimpleWeightedGraphs]]
deps = ["Graphs", "LinearAlgebra", "Markdown", "SparseArrays", "Test"]
git-tree-sha1 = "a6f404cc44d3d3b28c793ec0eb59af709d827e4e"
uuid = "47aef6b3-ad0c-573a-a1e2-d07658019622"
version = "1.2.1"

[[Sockets]]
uuid = "6462fe0b-24de-5631-8697-dd941f90decc"

[[SortingAlgorithms]]
deps = ["DataStructures"]
git-tree-sha1 = "b3363d7460f7d098ca0912c69b082f75625d7508"
uuid = "a2af1166-a08f-5f64-846c-94a0d3cef48c"
version = "1.0.1"

[[SparseArrays]]
deps = ["LinearAlgebra", "Random"]
uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"

[[SpecialFunctions]]
deps = ["ChainRulesCore", "IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"]
git-tree-sha1 = "bc40f042cfcc56230f781d92db71f0e21496dffd"
uuid = "276daf66-3868-5448-9aa4-cd146d93841b"
version = "2.1.5"

[[StaticArrays]]
deps = ["LinearAlgebra", "Random", "Statistics"]
git-tree-sha1 = "cd56bf18ed715e8b09f06ef8c6b781e6cdc49911"
uuid = "90137ffa-7385-5640-81b9-e52037218182"
version = "1.4.4"

[[StaticGraphs]]
deps = ["Graphs", "JLD2", "SparseArrays"]
git-tree-sha1 = "855371d8fdfaed46dbb32a7c57a42db4441b9247"
uuid = "4c8beaf5-199b-59a0-a7f2-21d17de635b6"
version = "0.3.0"

[[Statistics]]
deps = ["LinearAlgebra", "SparseArrays"]
uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"

[[StatsAPI]]
deps = ["LinearAlgebra"]
git-tree-sha1 = "c82aaa13b44ea00134f8c9c89819477bd3986ecd"
uuid = "82ae8749-77ed-4fe6-ae5f-f523153014b0"
version = "1.3.0"

[[StatsBase]]
deps = ["DataAPI", "DataStructures", "LinearAlgebra", "LogExpFunctions", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"]
git-tree-sha1 = "8977b17906b0a1cc74ab2e3a05faa16cf08a8291"
uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
version = "0.33.16"

[[StatsFuns]]
deps = ["ChainRulesCore", "InverseFunctions", "IrrationalConstants", "LogExpFunctions", "Reexport", "Rmath", "SpecialFunctions"]
git-tree-sha1 = "5950925ff997ed6fb3e985dcce8eb1ba42a0bbe7"
uuid = "4c63d2b9-4356-54db-8cca-17b64c39e42c"
version = "0.9.18"

[[StatsPlots]]
deps = ["AbstractFFTs", "Clustering", "DataStructures", "DataValues", "Distributions", "Interpolations", "KernelDensity", "LinearAlgebra", "MultivariateStats", "Observables", "Plots", "RecipesBase", "RecipesPipeline", "Reexport", "StatsBase", "TableOperations", "Tables", "Widgets"]
git-tree-sha1 = "43a316e07ae612c461fd874740aeef396c60f5f8"
uuid = "f3b207a7-027a-5e70-b257-86293d7955fd"
version = "0.14.34"

[[StructArrays]]
deps = ["Adapt", "DataAPI", "StaticArrays", "Tables"]
git-tree-sha1 = "9abba8f8fb8458e9adf07c8a2377a070674a24f1"
uuid = "09ab397b-f2b6-538f-b94a-2f83cf4a842a"
version = "0.6.8"

[[StructTypes]]
deps = ["Dates", "UUIDs"]
git-tree-sha1 = "d24a825a95a6d98c385001212dc9020d609f2d4f"
uuid = "856f2bd8-1eba-4b0a-8007-ebc267875bd4"
version = "1.8.1"

[[SuiteSparse]]
deps = ["Libdl", "LinearAlgebra", "Serialization", "SparseArrays"]
uuid = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9"

[[TOML]]
deps = ["Dates"]
uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76"

[[TableOperations]]
deps = ["SentinelArrays", "Tables", "Test"]
git-tree-sha1 = "e383c87cf2a1dc41fa30c093b2a19877c83e1bc1"
uuid = "ab02a1b2-a7df-11e8-156e-fb1833f50b87"
version = "1.2.0"

[[TableTraits]]
deps = ["IteratorInterfaceExtensions"]
git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39"
uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c"
version = "1.0.1"

[[Tables]]
deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "LinearAlgebra", "OrderedCollections", "TableTraits", "Test"]
git-tree-sha1 = "5ce79ce186cc678bbb5c5681ca3379d1ddae11a1"
uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
version = "1.7.0"

[[Tar]]
deps = ["ArgTools", "SHA"]
uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e"

[[TensorCore]]
deps = ["LinearAlgebra"]
git-tree-sha1 = "1feb45f88d133a655e001435632f019a9a1bcdb6"
uuid = "62fd8b95-f654-4bbd-a8a5-9c27f68ccd50"
version = "0.1.1"

[[Test]]
deps = ["InteractiveUtils", "Logging", "Random", "Serialization"]
uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

[[TranscodingStreams]]
deps = ["Random", "Test"]
git-tree-sha1 = "216b95ea110b5972db65aa90f88d8d89dcb8851c"
uuid = "3bb67fe8-82b1-5028-8e26-92a6c54297fa"
version = "0.9.6"

[[Tricks]]
git-tree-sha1 = "6bac775f2d42a611cdfcd1fb217ee719630c4175"
uuid = "410a4b4d-49e4-4fbc-ab6d-cb71b17b3775"
version = "0.1.6"

[[URIs]]
git-tree-sha1 = "97bbe755a53fe859669cd907f2d96aee8d2c1355"
uuid = "5c2747f8-b7ea-4ff2-ba2e-563bfd36b1d4"
version = "1.3.0"

[[UUIDs]]
deps = ["Random", "SHA"]
uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"

[[UnPack]]
git-tree-sha1 = "387c1f73762231e86e0c9c5443ce3b4a0a9a0c2b"
uuid = "3a884ed6-31ef-47d7-9d2a-63182c4928ed"
version = "1.0.2"

[[Unicode]]
uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"

[[UnicodeFun]]
deps = ["REPL"]
git-tree-sha1 = "53915e50200959667e78a92a418594b428dffddf"
uuid = "1cfade01-22cf-5700-b092-accc4b62d6e1"
version = "0.4.1"

[[Unzip]]
git-tree-sha1 = "34db80951901073501137bdbc3d5a8e7bbd06670"
uuid = "41fe7b60-77ed-43a1-b4f0-825fd5a5650d"
version = "0.1.2"

[[Wayland_jll]]
deps = ["Artifacts", "Expat_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Pkg", "XML2_jll"]
git-tree-sha1 = "3e61f0b86f90dacb0bc0e73a0c5a83f6a8636e23"
uuid = "a2964d1f-97da-50d4-b82a-358c7fce9d89"
version = "1.19.0+0"

[[Wayland_protocols_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "4528479aa01ee1b3b4cd0e6faef0e04cf16466da"
uuid = "2381bf8a-dfd0-557d-9999-79630e7b1b91"
version = "1.25.0+0"

[[WeakRefStrings]]
deps = ["DataAPI", "InlineStrings", "Parsers"]
git-tree-sha1 = "b1be2855ed9ed8eac54e5caff2afcdb442d52c23"
uuid = "ea10d353-3f73-51f8-a26c-33c1cb351aa5"
version = "1.4.2"

[[Widgets]]
deps = ["Colors", "Dates", "Observables", "OrderedCollections"]
git-tree-sha1 = "fcdae142c1cfc7d89de2d11e08721d0f2f86c98a"
uuid = "cc8bc4a8-27d6-5769-a93b-9d913e69aa62"
version = "0.6.6"

[[WoodburyMatrices]]
deps = ["LinearAlgebra", "SparseArrays"]
git-tree-sha1 = "de67fa59e33ad156a590055375a30b23c40299d3"
uuid = "efce3f68-66dc-5838-9240-27a6d6f5f9b6"
version = "0.5.5"

[[XML2_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Pkg", "Zlib_jll"]
git-tree-sha1 = "1acf5bdf07aa0907e0a37d3718bb88d4b687b74a"
uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a"
version = "2.9.12+0"

[[XSLT_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Libgcrypt_jll", "Libgpg_error_jll", "Libiconv_jll", "Pkg", "XML2_jll", "Zlib_jll"]
git-tree-sha1 = "91844873c4085240b95e795f692c4cec4d805f8a"
uuid = "aed1982a-8fda-507f-9586-7b0439959a61"
version = "1.1.34+0"

[[Xorg_libX11_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libxcb_jll", "Xorg_xtrans_jll"]
git-tree-sha1 = "5be649d550f3f4b95308bf0183b82e2582876527"
uuid = "4f6342f7-b3d2-589e-9d20-edeb45f2b2bc"
version = "1.6.9+4"

[[Xorg_libXau_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "4e490d5c960c314f33885790ed410ff3a94ce67e"
uuid = "0c0b7dd1-d40b-584c-a123-a41640f87eec"
version = "1.0.9+4"

[[Xorg_libXcursor_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXfixes_jll", "Xorg_libXrender_jll"]
git-tree-sha1 = "12e0eb3bc634fa2080c1c37fccf56f7c22989afd"
uuid = "935fb764-8cf2-53bf-bb30-45bb1f8bf724"
version = "1.2.0+4"

[[Xorg_libXdmcp_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "4fe47bd2247248125c428978740e18a681372dd4"
uuid = "a3789734-cfe1-5b06-b2d0-1dd0d9d62d05"
version = "1.1.3+4"

[[Xorg_libXext_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"]
git-tree-sha1 = "b7c0aa8c376b31e4852b360222848637f481f8c3"
uuid = "1082639a-0dae-5f34-9b06-72781eeb8cb3"
version = "1.3.4+4"

[[Xorg_libXfixes_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"]
git-tree-sha1 = "0e0dc7431e7a0587559f9294aeec269471c991a4"
uuid = "d091e8ba-531a-589c-9de9-94069b037ed8"
version = "5.0.3+4"

[[Xorg_libXi_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll", "Xorg_libXfixes_jll"]
git-tree-sha1 = "89b52bc2160aadc84d707093930ef0bffa641246"
uuid = "a51aa0fd-4e3c-5386-b890-e753decda492"
version = "1.7.10+4"

[[Xorg_libXinerama_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll"]
git-tree-sha1 = "26be8b1c342929259317d8b9f7b53bf2bb73b123"
uuid = "d1454406-59df-5ea1-beac-c340f2130bc3"
version = "1.1.4+4"

[[Xorg_libXrandr_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll", "Xorg_libXrender_jll"]
git-tree-sha1 = "34cea83cb726fb58f325887bf0612c6b3fb17631"
uuid = "ec84b674-ba8e-5d96-8ba1-2a689ba10484"
version = "1.5.2+4"

[[Xorg_libXrender_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"]
git-tree-sha1 = "19560f30fd49f4d4efbe7002a1037f8c43d43b96"
uuid = "ea2f1a96-1ddc-540d-b46f-429655e07cfa"
version = "0.9.10+4"

[[Xorg_libpthread_stubs_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "6783737e45d3c59a4a4c4091f5f88cdcf0908cbb"
uuid = "14d82f49-176c-5ed1-bb49-ad3f5cbd8c74"
version = "0.1.0+3"

[[Xorg_libxcb_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "XSLT_jll", "Xorg_libXau_jll", "Xorg_libXdmcp_jll", "Xorg_libpthread_stubs_jll"]
git-tree-sha1 = "daf17f441228e7a3833846cd048892861cff16d6"
uuid = "c7cfdc94-dc32-55de-ac96-5a1b8d977c5b"
version = "1.13.0+3"

[[Xorg_libxkbfile_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"]
git-tree-sha1 = "926af861744212db0eb001d9e40b5d16292080b2"
uuid = "cc61e674-0454-545c-8b26-ed2c68acab7a"
version = "1.1.0+4"

[[Xorg_xcb_util_image_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"]
git-tree-sha1 = "0fab0a40349ba1cba2c1da699243396ff8e94b97"
uuid = "12413925-8142-5f55-bb0e-6d7ca50bb09b"
version = "0.4.0+1"

[[Xorg_xcb_util_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libxcb_jll"]
git-tree-sha1 = "e7fd7b2881fa2eaa72717420894d3938177862d1"
uuid = "2def613f-5ad1-5310-b15b-b15d46f528f5"
version = "0.4.0+1"

[[Xorg_xcb_util_keysyms_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"]
git-tree-sha1 = "d1151e2c45a544f32441a567d1690e701ec89b00"
uuid = "975044d2-76e6-5fbe-bf08-97ce7c6574c7"
version = "0.4.0+1"

[[Xorg_xcb_util_renderutil_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"]
git-tree-sha1 = "dfd7a8f38d4613b6a575253b3174dd991ca6183e"
uuid = "0d47668e-0667-5a69-a72c-f761630bfb7e"
version = "0.3.9+1"

[[Xorg_xcb_util_wm_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"]
git-tree-sha1 = "e78d10aab01a4a154142c5006ed44fd9e8e31b67"
uuid = "c22f9ab0-d5fe-5066-847c-f4bb1cd4e361"
version = "0.4.1+1"

[[Xorg_xkbcomp_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libxkbfile_jll"]
git-tree-sha1 = "4bcbf660f6c2e714f87e960a171b119d06ee163b"
uuid = "35661453-b289-5fab-8a00-3d9160c6a3a4"
version = "1.4.2+4"

[[Xorg_xkeyboard_config_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xkbcomp_jll"]
git-tree-sha1 = "5c8424f8a67c3f2209646d4425f3d415fee5931d"
uuid = "33bec58e-1273-512f-9401-5d533626f822"
version = "2.27.0+4"

[[Xorg_xtrans_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "79c31e7844f6ecf779705fbc12146eb190b7d845"
uuid = "c5fb5394-a638-5e4d-96e5-b29de1b5cf10"
version = "1.4.0+3"

[[Zlib_jll]]
deps = ["Libdl"]
uuid = "83775a58-1f1d-513f-b197-d71354ab007a"

[[Zstd_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "e45044cd873ded54b6a5bac0eb5c971392cf1927"
uuid = "3161d3a3-bdf6-5164-811a-617609db77b4"
version = "1.5.2+0"

[[libass_jll]]
deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"]
git-tree-sha1 = "5982a94fcba20f02f42ace44b9894ee2b140fe47"
uuid = "0ac62f75-1d6f-5e53-bd7c-93b484bb37c0"
version = "0.15.1+0"

[[libfdk_aac_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "daacc84a041563f965be61859a36e17c4e4fcd55"
uuid = "f638f0a6-7fb0-5443-88ba-1cc74229b280"
version = "2.0.2+0"

[[libpng_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"]
git-tree-sha1 = "94d180a6d2b5e55e447e2d27a29ed04fe79eb30c"
uuid = "b53b4c65-9356-5827-b1ea-8c7a1a84506f"
version = "1.6.38+0"

[[libvorbis_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Ogg_jll", "Pkg"]
git-tree-sha1 = "b910cb81ef3fe6e78bf6acee440bda86fd6ae00c"
uuid = "f27f6e37-5d2b-51aa-960f-b287f2bc3b7a"
version = "1.3.7+1"

[[nghttp2_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d"

[[p7zip_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0"

[[x264_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "4fea590b89e6ec504593146bf8b988b2c00922b2"
uuid = "1270edf5-f2f9-52d2-97e9-ab00b5d0237a"
version = "2021.5.5+0"

[[x265_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "ee567a171cce03570d77ad3a43e90218e38937a9"
uuid = "dfaa095f-4041-5dcd-9319-2fabd8486b76"
version = "3.5.0+0"

[[xkbcommon_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Wayland_jll", "Wayland_protocols_jll", "Xorg_libxcb_jll", "Xorg_xkeyboard_config_jll"]
git-tree-sha1 = "ece2350174195bb31de1a63bea3a41ae1aa593b6"
uuid = "d8fb68d0-12a3-5cfd-a85a-d49703b185fd"
version = "0.9.1+5"
"""

# ╔═╡ Cell order:
# ╟─fb63305f-09d7-4111-8684-4fbab8c192df
# ╟─7cd47b87-fceb-4995-970c-ae23e250fb46
# ╟─22c16f23-cb6e-4b15-922b-32c4e4b9baba
# ╟─8a8a6115-a178-4b97-bc77-371a85288363
# ╟─b0b47fa0-b9d1-4e46-be06-31233b3b6f03
# ╟─b1d4c305-1f87-4a90-9d39-7519b1bb11ab
# ╟─a598718d-b65f-41d3-829f-bbb82888002b
# ╟─de951afb-2596-4ef6-8c96-c8c03102eea9
# ╟─c9fda3c0-882c-4f48-a225-f3e67d107f13
# ╟─8d827b33-d299-48fb-b3e6-b31dc26b9fe6
# ╟─b4d0347f-4074-46da-a3d0-3ae9b7045cf8
# ╟─017327e7-7c7d-40b5-8573-ec780f42384b
# ╟─f66bed21-ea37-44c1-a238-93bc22778ac3
# ╟─49458fbd-e8e9-4e67-872f-84abd04c56f2
# ╟─4efd79a5-3e7a-4b3f-8c11-c61a3c9b0e0b
# ╟─a2a71645-aaa3-4462-b6f8-bf8d7d9d2d4a
# ╠═9942dd32-e601-4a01-97ef-e3709080fea8
# ╠═6f1ddf1f-262b-4a47-8da8-9bf5bb27622f
# ╠═7c46a491-bef6-4db1-a0d3-2cc648ce6fe9
# ╠═9b0abb0f-6081-469e-8c3d-69f506cf1caf
# ╠═9c70b5d1-a6dd-4687-a0d4-6fa2526286ee
# ╟─d91ed32c-2092-4aaa-ba50-13d93d0da12b
# ╠═e4bc40ca-8958-4807-a240-64fcb1fedcb4
# ╟─8eb2581b-e4de-4fc5-b716-13bf4ff3ffcd
# ╠═4f4c249a-eaf4-46a9-a5f3-0887715a119c
# ╠═23826464-15bd-4b29-8540-32982e07b709
# ╠═4b7f2306-a4c0-42c7-85c2-ea437bc61e50
# ╠═08c63f0e-5a64-45e3-97be-c1fa958cc661
# ╠═c62e44d4-8501-45f6-bdb0-e357e4c363fb
# ╟─dd40ac6e-d08f-4663-b6c5-9809493e9612
# ╟─6ab8e802-d879-4ec0-a86b-ea1797d34c2b
# ╟─51cee280-ee61-44af-8615-879750f823b4
# ╟─fda9c33b-8657-4d8b-b74e-d0a035dd67eb
# ╟─a0aad24f-1f6b-4f2a-9f54-b61e0609eb76
# ╟─15a95e15-905f-4996-8000-f4cf3d60aac0
# ╟─917b1c65-e48f-4e14-aff1-53cef88231a3
# ╟─b604cefb-8dc6-46d9-b456-7f19af13f067
# ╟─f6e4d332-c8b8-425e-a1fe-83378552836c
# ╟─31c9068f-90f3-4185-aa4f-17c11563047b
# ╟─e8c62155-902b-41f6-bc8d-6f8d74ed352a
# ╟─dcbfc502-4b53-40e4-b735-9a2aadc96538
# ╟─ff785b01-f0f3-4feb-9fc0-f07a5b86faa5
# ╟─6a05d5cf-a51d-47ba-85e1-14c16b369a19
# ╟─73f75064-a6d2-4ae8-bcd6-52ec610315ee
# ╠═0957f4e8-2d3a-4c09-b0bc-453d9c2d005a
# ╠═c2658679-5a20-446d-90d5-644936323b8f
# ╟─d5409b02-89a5-45e9-bc78-67e566112869
# ╟─c6dcddcf-0d12-4e9e-b7fa-f761f5f2cacf
# ╟─d6683d9e-d1c2-44c8-9422-7c9e09d0e558
# ╟─ee4c5bca-92e6-4ca5-b957-a11511fa1438
# ╟─ed907683-f46b-4c6b-9a8a-8263191544d1
# ╟─00000000-0000-0000-0000-000000000001
# ╟─00000000-0000-0000-0000-000000000002