text
stringlengths 0
3.34M
|
|---|
Require Export Qpositive.
Fixpoint Qpositive_le_bool (w w' : Qpositive) {struct w'} : bool :=
match w with
| One => match w' with
| dL y => false
| _ => true
end
| dL y => match w' with
| dL y' => Qpositive_le_bool y y'
| _ => true
end
| nR y => match w' with
| nR y' => Qpositive_le_bool y y'
| _ => false
end
end.
Definition Qpositive_le (w w' : Qpositive) := Qpositive_le_bool w w' = true.
Definition Qpositive_le' (w w' : Qpositive) :=
match Qpositive_i w, Qpositive_i w' with
| (p, q), (p', q') => p * q' <= p' * q
end.
Theorem Qpositive_le_to_Qpositive_le' :
forall w w' : Qpositive, Qpositive_le w w' -> Qpositive_le' w w'.
intros w w'; generalize w; elim w'; clear w w'.
intros w'1 Hrec w; case w.
unfold Qpositive_le in |- *; simpl in |- *.
intros w1 H; generalize (Hrec w1 H).
unfold Qpositive_le' in |- *.
simpl in |- *.
case (Qpositive_i w1); case (Qpositive_i w'1).
intros p' q' p q Hle; repeat rewrite mult_plus_distr_r.
rewrite (mult_comm q').
apply plus_le_compat_r.
auto.
intros w1; unfold Qpositive_le in |- *.
simpl in |- *.
unfold Qpositive_le' in |- *; simpl in |- *; intros H; case (Qpositive_i w1);
case (Qpositive_i w'1); intros p' q' p q.
rewrite mult_plus_distr_r.
repeat rewrite <- (mult_comm (p + q)).
repeat rewrite mult_plus_distr_r.
rewrite (plus_comm (p * p' + q * p')).
repeat rewrite <- plus_assoc.
auto with arith.
unfold Qpositive_le, Qpositive_le' in |- *.
simpl in |- *.
case (Qpositive_i w'1).
intros; omega.
intros w'1 Hrec w; case w; clear w; unfold Qpositive_le in |- *;
simpl in |- *.
intros q H; discriminate H.
intros w1 H; generalize (Hrec w1 H); unfold Qpositive_le' in |- *.
simpl in |- *; case (Qpositive_i w1); case (Qpositive_i w'1);
intros p' q' p q.
repeat rewrite (mult_comm p); repeat rewrite (mult_comm p');
repeat rewrite mult_plus_distr_r.
intros H1.
rewrite (mult_comm p').
apply plus_le_compat_l.
auto.
intros H; discriminate H.
unfold Qpositive_le, Qpositive_le' in |- *.
intros w; case w.
3: simpl in |- *; auto.
intros w1; simpl in |- *.
intros Heq; discriminate Heq.
intros w'; simpl in |- *.
case (Qpositive_i w').
intros; omega.
Qed.
Theorem Qpositive_le'_to_Qpositive_le :
forall w w' : Qpositive, Qpositive_le' w w' -> Qpositive_le w w'.
intros w w'; generalize w; elim w'; clear w w'.
intros w'1 Hrec w; case w; clear w.
intros w; unfold Qpositive_le', Qpositive_le in |- *; simpl in |- *.
generalize (Hrec w); clear Hrec; unfold Qpositive_le, Qpositive_le' in |- *;
simpl in |- *.
elim (interp_non_zero w); intros p Hex; elim Hex; intros q Heq; clear Hex;
rewrite Heq.
elim (interp_non_zero w'1); intros p' Hex; elim Hex; intros q' Heq1;
clear Hex; rewrite Heq1.
intros H H1; (lapply H; [ intros H0; try exact H0 | idtac ]).
apply (fun p n m : nat => plus_le_reg_l n m p) with (S q * S q').
replace (S q * S q' + S p * S q') with ((S p + S q) * S q').
replace (S q * S q' + S p' * S q) with ((S p' + S q') * S q).
auto.
ring.
ring.
unfold Qpositive_le in |- *; simpl in |- *; auto.
unfold Qpositive_le in |- *; simpl in |- *.
auto.
intros w'1 Hrec w; case w; clear w; unfold Qpositive_le in |- *;
simpl in |- *; auto.
intros w1; unfold Qpositive_le' in |- *; simpl in |- *.
elim (interp_non_zero w1); intros p Hex; elim Hex; intros q Heq; clear Hex;
rewrite Heq.
elim (interp_non_zero w'1); intros p' Hex; elim Hex; intros q' Heq1;
clear Hex; rewrite Heq1.
rewrite mult_plus_distr_r.
repeat rewrite <- (mult_comm (S p' + S q')).
repeat rewrite mult_plus_distr_r.
repeat rewrite <- (plus_comm (S p' * S q)) || rewrite plus_assoc;
repeat rewrite <- plus_assoc.
pattern (S p' * S q) at 2 in |- *; rewrite plus_n_O.
intros H; generalize (plus_le_reg_l _ _ _ H); simpl in |- *; intros H1;
inversion H1.
intros w; unfold Qpositive_le', Qpositive_le in |- *; simpl in |- *.
generalize (Hrec w); clear Hrec; unfold Qpositive_le, Qpositive_le' in |- *;
simpl in |- *.
elim (interp_non_zero w); intros p Hex; elim Hex; intros q Heq; clear Hex;
rewrite Heq.
elim (interp_non_zero w'1); intros p' Hex; elim Hex; intros q' Heq1;
clear Hex; rewrite Heq1.
intros H H1; (lapply H; [ intros H0; try exact H0 | idtac ]).
apply (fun p n m : nat => plus_le_reg_l n m p) with (S p * S p').
replace (S p * S p' + S p * S q') with (S p * (S p' + S q')).
replace (S p * S p' + S p' * S q) with (S p' * (S p + S q)).
auto.
ring.
ring.
unfold Qpositive_le' in |- *; simpl in |- *.
elim (interp_non_zero w'1); intros p' Hex; elim Hex; intros q' Heq1;
clear Hex; rewrite Heq1.
rewrite <- plus_n_O; rewrite <- (mult_comm 1); simpl in |- *; intros H;
generalize (plus_le_reg_l _ _ _ (le_S_n _ _ H)).
intros H1; inversion H1.
intros w; case w; clear w; unfold Qpositive_le', Qpositive_le in |- *;
simpl in |- *.
intros w; elim (interp_non_zero w).
intros p Hex; elim Hex; intros q Heq; rewrite Heq.
rewrite mult_1_r.
rewrite (plus_comm (S p)).
intros H; generalize (plus_le_reg_l _ _ _ H); intros H1; inversion H1.
auto.
auto.
Qed.
Theorem Qpositive_le_trans :
forall w w' w'' : Qpositive,
Qpositive_le w w' -> Qpositive_le w' w'' -> Qpositive_le w w''.
intros w w'; generalize w; elim w'; unfold Qpositive_le in |- *;
simpl in |- *; clear w w'.
intros w' Hrec w; case w.
3: intros w''; case w''; simpl in |- *; auto.
intros w0 w''; case w''; simpl in |- *; auto.
intros w0 w''; case w''; simpl in |- *; auto.
intros w''0 H H1; discriminate H1.
intros w' Hrec w; case w.
3: intros w'' H; discriminate H.
intros w0 w'' H; discriminate H.
intros w0 w''; case w''; simpl in |- *; auto.
intros w; case w; clear w; simpl in |- *.
3: auto.
intros w w'' H; discriminate H.
intros w w''; case w''; simpl in |- *; auto.
intros w''0 H H1; discriminate H1.
Qed.
Theorem Qpositive_le_antisym :
forall w w' : Qpositive, Qpositive_le w w' -> Qpositive_le w' w -> w = w'.
intros w; elim w; unfold Qpositive_le in |- *; simpl in |- *.
intros w0 Hrec w'; case w'; simpl in |- *.
3: intros H; discriminate H.
intros; apply f_equal with (f := nR); auto.
intros w'0 H; discriminate H.
intros w0 Hrec w'; case w'; simpl in |- *.
3: intros H H1; discriminate H1.
intros w'1 H H1; discriminate H1.
intros; apply f_equal with (f := dL); auto.
intros w'; case w'; auto with *.
intros w'0 H H1; discriminate H1.
intros w'0 H; discriminate H.
Qed.
Theorem Qpositive_le_refl : forall w : Qpositive, Qpositive_le w w.
intros w; unfold Qpositive_le in |- *; elim w; simpl in |- *; auto.
Qed.
Theorem Qpositive_le_total :
forall w w' : Qpositive, Qpositive_le w w' \/ Qpositive_le w' w.
intros w w'; cut (Qpositive_le' w w' \/ Qpositive_le' w' w).
intros H; elim H; intros H1;
generalize (Qpositive_le'_to_Qpositive_le _ _ H1);
auto.
unfold Qpositive_le' in |- *.
case (Qpositive_i w'); case (Qpositive_i w); intros p q p' q'.
elim (le_or_lt (p * q') (p' * q)); auto with arith.
Qed.
Theorem not_Qpositive_le_not_eq :
forall n m : Qpositive, ~ Qpositive_le n m -> n <> m.
intros n m H; red in |- *; intros H1; elim H; rewrite H1;
apply Qpositive_le_refl.
Qed.
Theorem not_Qpositive_le_Qpositive_le' :
forall n m : Qpositive, ~ Qpositive_le n m -> Qpositive_le m n.
intros n m Hle; elim (Qpositive_le_total n m); auto.
intros H; elim Hle; auto.
Qed.
Lemma Qpositive_le_noneq_explicit: forall qp qp', Qpositive_le qp qp' -> ~ qp=qp' ->
let (p, q) := Qpositive_i qp in
let (p', q') := Qpositive_i qp' in (p * q' < p' * q)%nat.
Proof.
intros qp qp' H_le H_neq; generalize (Qpositive_le_to_Qpositive_le' qp qp' H_le); unfold Qpositive_le';
destruct (interp_non_zero qp) as [p [q H]];
destruct (interp_non_zero qp') as [p' [q' H']];
rewrite H; rewrite H'; intros H_le_unfold; destruct (le_lt_eq_dec _ _ H_le_unfold) as [H1|H1]; trivial;
apply False_ind; apply H_neq;
rewrite <- (construct_correct qp (S p) (S q) (S p+S q)%nat H); auto with arith;
rewrite <- (construct_correct qp' (S p') (S q') (S p'+S q')%nat H'); auto with arith;
apply construct_correct4'; auto with arith.
Qed.
|
[STATEMENT]
lemma differentiable_on_empty: "f differentiable_on {}"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. f differentiable_on {}
[PROOF STEP]
unfolding differentiable_on_def
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<forall>x\<in>{}. f differentiable at x within {}
[PROOF STEP]
by auto |
Formal statement is: lemma tendsto_at_left_sequentially: fixes a b :: "'b::{linorder_topology,first_countable_topology}" assumes "b < a" assumes *: "\<And>S. (\<And>n. S n < a) \<Longrightarrow> (\<And>n. b < S n) \<Longrightarrow> incseq S \<Longrightarrow> S \<longlonglongrightarrow> a \<Longrightarrow> (\<lambda>n. X (S n)) \<longlonglongrightarrow> L" shows "(X \<longlongrightarrow> L) (at_left a)" Informal statement is: If $X$ converges to $L$ along any sequence $S$ that converges to $a$ from the left, then $X$ converges to $L$ at $a$ from the left. |
\section{Evaluation}
\label{sec:reval}
To evaluate Rocksteady, we focused on five key questions:
\begin{enumerate}
\item {\bf How fast can Rocksteady go and meet tight SLAs?}
Section~\ref{sec:e2e} shows that Rocksteady can sustain migration at
758~MB/s with \nnnth percentile access latency of lesser than 250~\us.
\item {\bf Does lineage accelerate migration?}
Lineage and deferred log replication allow Rocksteady to migrate data
1.4$\times$ faster than synchronous rereplication while shifting
load from the source to the target more quickly (Section~\ref{sec:e2e}).
\item {\bf What is the impact at the source and target?}
Section~\ref{sec:eval-load} shows that regardless of workload skew, Rocksteady
migrations cause almost no increase in source dispatch load, which is the source's
most scarce resource for typical read-heavy workloads. Background \pulls
add about 45\% worker CPU utilization on the source, and Rocksteady
effectively equalizes CPU load on the source and target.
Dispatch load due to the migration manager on the target is minimal.
\item {\bf Are asynchronous batched priority pulls effective?}
Section~\ref{sec:eval-priopulls} shows that asynchronous priority pulls are
essential in two ways. First, synchronous priority pulls would increase both
dispatch and worker load during migration due to the increased number of
RPCs to the source and the wasted effort waiting for \priopull responses. Second,
asynchronous batched \priopulls reduce load at the source fast enough to help
hide the extra load due to background \pulls on the source, which is key to
Rocksteady's fast transfer.
\item {\bf What limits migration?}
Section~\ref{sec:eval-replay} shows that the source and target can send/consume
small records at 5.7~GB/s and 3~GB/s, respectively; for small
records,
target replay limits migration more than
networking (5~GB/s today).
Target worker cores spend 1.8~to~2.4$\times$ more cycles
processing records during migration than source worker cores.
%\item[What is the impact of migration on source and target throughput and tail latnecy}]
% Tunables include: pull size, parallelism (pulls, and replays).
% (Microbenchmark)
%\item What is rocksteady's impact on the source and destination -
%dispatch and worker load? (Microbenchmark)
%\item How does hash table selectivity impact migration speed?
%(Microbenchmark)
%\item How good is rocksteady at balancing load? Present three
%configurations - only background task, background task + synchronous
%priority pulls, and background task + batched priority pulls with client
%backoffs. Might want to vary the priority of replay and pull rpcs for
%each of these configurations.
%\item How does re-replication speed impact performance after migration?
\end{enumerate}
\subsection{Experimental Setup}
\label{sec:setup}
%K aniraj: Should we mention Mellanox VPI since that
%K enables flipping b/w 40G ethernet and 56G FDR
%K or even 3:5:1 blocking factor or the topology?
%K Manual mentions 4x SATA disks in a RAID5 config
%K Our processors are 8 cores and 16 threads
All evaluation was done on a 24~server Dell c6220~cluster on the CloudLab
testbed~\cite{cloudlab} (Table~\ref{table:rexptconfig}). RAMCloud is transport
agnostic; it offers RPC over many hardware and transport protocol
combinations. For these experiments, servers were interconnected with 40~Gbps
Ethernet and Mellanox ConnectX-3 cards; hosts used DPDK~\cite{dpdk} and
the \texttt{mlx4} poll-mode driver for kernel-bypass support. Each RAMCloud
server used one core solely as a dispatch core to manage the network; it used
12~additional cores as workers to process requests; the remaining
three cores helped prevent interference from background threads. The
dispatch core runs a user-level reliable transport protocol on top of
Ethernet that provides flow control, retransmission, among other
features, without the
overhead of relying on the kernel TCP stack.
%Today, a custom transport protocol (\texttt{Basic
%Transport}\xspace) running over Ethernet using DPDK~\cite{dpdk} is the
%preferred deployment. We used the MLX4 poll mode DPDK driver over the 40
%Gbps NIC port, and allocated two 1~GB hugepages for packet buffers.
%Each node was configured with a dual port Mellanox
%MX354A FDR ConnectX-3 adapter, with both ports flipped to Ethernet mode
%(one at 40 Gbps and the other at 10 Gbps) using Mellanox VPI
%technology~\cite{mellanoxvpi}. Cloudlab's \texttt{r-320}\xspace network
%fabric has two layers of switches: seven on the edge (28 nodes per
%switch), and 2 on the core, with a blocking factor of 3:5:1. We
%allocated all nodes in our cluster under a single edge switch.
%
%For each of our experiments, we configured our cluster to run one
%coordinator, multiple masters, and multiple clients. Each node of our
%cluster always ran only one such RAMCloud instance. We configured our
%RAMCloud masters to allocate 8000~MB of memory for the log, 1 dispatch
%thread, and 7 worker threads. For fault tolerance, we set the
%replication factor to 3 and had every master allocate 32~GB of disk
%space to serve remote replication requests. Additionally, RAMCloud
%supports in-memory buffering of replicated data which can be flushed to
%non-volatile storage in the case of a failure. We set the number of such
%buffers to a value as high as possible to compensate for our small
%experimental cluster and prevent the disks from becoming a bottleneck; a
%real RAMCloud deployment will typically span hundreds of machines and
%hence spray replication requests uniformly across all backups.
%./scripts/clusterperf.py migrateLoaded -T basic+dpdk --workload=YCSB-B --loadPct=90 --seconds=30 --timeout=600 --migratePercentage=50 --size=100 --numObjects=20000000 --masterArgs='--totalMasterMemory=8000 --segmentFrames=4096 --maxCores=8 --maxNonVolatileBuffers=0 -d' --verbose -r 3 --fullSamples --debug --servers=7 --clients=16
To evaluate migration under load, eight~client machines run the YCSB-B~\cite{ycsb}
workload (95\% reads, 5\% writes, keys chosen according to a Zipfian
distribution with $\theta$ = 0.99), which accesses a table on the source
server. The table consists of 300~million 100~B record payloads with 30~B
primary keys constituting 27.9~GB of record data consuming 44.4~GB of in-memory
log on the source. Clients offer a nearly open load to the cluster sufficient to keep
a single server at 80\% (dispatch) load. While the YCSB load is running, a
migration is triggered that live-migrates half of the source's records
to the target.
Rocksteady was configured to partition the source's key-hash space into
eight parts, with each \pull returning 20~KB of data. \pulls were configured
to have the lowest priority in the system. \priopulls returned a batch
of at most 16 records from the
source and were configured
to have the highest priority among RPCs in the system. The version of Rocksteady
used for the evaluation can be accessed online on GitHub at\linebreak{}
{\url{https://github.com/utah-scs/RAMCloud/tree/rocksteady-sosp2017}}.
\subsection{Migration Impact and Ownership}
\label{sec:e2e}
Figures~\ref{fig:running-throughput} and~\ref{fig:running-latency} (a) show
Rocksteady's impact from the perspective of the YCSB clients. Migration
takes 30~seconds and transfers at 758~MB/s. Throughput drops when ownership is
transferred at the start of migration since the clients must wait for records
to arrive at the target. As records are being transferred, \nnnth percentile
end-to-end response times start at 250~\us and taper back down to 183~\us as
hot records from \priopulls arrive at the target. After migration, median
response times drop from 10.1~\us to 6.7~\us since each server's dispatch is under
less load. Likewise, after migration moves enough records, throughput briefly
exceeds the before-migration throughput since client load is open, and some
requests are backlogged.
Figures~\ref{fig:running-throughput} and~\ref{fig:running-latency} (b) show
that \priopulls are essential to Rocksteady's design. Without
\priopulls, client
requests for a record cannot complete until they are moved by the
\pulls, resulting in requests that cannot complete
until the migration is done. Only a small fraction of requests complete
while the migration is ongoing, and throughput is elevated after
migration for a more extended period. In practice, this would result in
timeouts for client operations. Migration speed is 19\% faster
(904~MB/s) without \priopulls enabled.
Instead of transferring ownership to the target at the start of migration,
another option is to leave ownership at the source during migration
while synchronously re-replicating migrated data at the target.
Figures~\ref{fig:running-throughput} and~\ref{fig:running-latency} (c) explore
this approach. The main drawback is that it cannot take advantage of the
extra resources that the target provides. Similar to the
case above, source throughput decreases under migration load, and clients
eventually fall behind. For long migrations, this can lead to client timeouts
%which is evidenced by the increased median access latency while migration
%is ongoing.
in a fully open load since throughput would drop below the offered load
for the duration of migration.
Additionally, migration suffers a 27.7\% slowdown
(758~MB/s down to 549~MB/s), and the impact on the \nnnth
percentile access latency is worse than the full Rocksteady protocol
because of the rereplication load generated by the target interfering
with the replication load generated by writes at the source. For larger
RAMCloud clusters, such interference will not be an issue, and one would
expect the \nnnth percentile to be similar to Rocksteady.
\subsection{Load Impact}
\label{sec:eval-load}
Figure~\ref{fig:load} (a) shows Rocksteady immediately equalizes
dispatch load on the source and target. Worker and dispatch load on the
target jumps immediately when migration starts, offloading the source.
Clients refresh their stale tablet mappings after migration starts.
Dispatch is immediately equalized because
a) exactly half of the table ownership has been shifted to the target, and
b) the migration manager is asynchronous and requires little CPU.
% XXX What causes 11b to increase dispatch load after migration? The decrease
% might be due to the fact that the clients are "stuck" on the target, so they
% backoff on the source too. As the target starts to get the data the clients
% become unstuck and accelerate against the source.
%Dispatch load drops immediately on
%the source, showing that the batching priority pulls have the intended effect.
%Figure~\ref{fig:load} (b) shows that without \priopulls the source and target remain at elevated load longer after migration, since pent up client
%
A key goal of Rocksteady is to shift load quickly from the source to the
target. Most workloads exhibit some skew, but the extent of that skew impacts
Rocksteady's ability to shift load quickly. Figure~\ref{fig:load-skew}
examines the extent to which Rocksteady's effectiveness at reducing client load
is skew dependent. With no skew (uniform access, skew $\theta$ = 0), \priopulls are
sufficient to maintain client access to the tablet. However, low request locality
means the full load transfer only proceeds as quickly as the background
\pulls
can transfer records. Overall, the results are promising when considering the
source's dispatch load, which is its most scarce resource for typical
read-heavy workloads. Regardless of workload skew, source-side dispatch load
remains relatively flat from the time migration starts until it completes.
This result means that Rocksteady's eager ownership transfer enabled by
batched \priopulls makes up for any extra dispatch load the \pulls place
on the source regardless of the skew.
\subsection{Asynchronous Batched Priority Pulls}
\label{sec:eval-priopulls}
Figures~\ref{fig:batching-lat} and~\ref{fig:batching-load} compare
asynchronous batched \priopulls with the na\"{i}ve, synchronous approach
when background \pulls are disabled. The asynchronous
approach does not help tail latency:
\nnnth latency stays consistent at 160~\us for the rest of the
experiment, but median access latency drops to 7.4~\us immediately.
On the other hand, the synchronous approach results in
median latency jitter,
primarily due to workers at the target waiting for \priopulls to return, which
can be seen in the increased worker utilization at the target
(Figure~\ref{fig:batching-load}b). However, \nnnth percentile access latency
is lower than the asynchronous approach since pull responses are sent to
clients immediately.
\priopulls are critical to the goal of
rapidly shifting load away from the source. The headroom thus
obtained can be used to service \pulls at the source, thereby allowing
the migration to go as fast as possible. At the same time, \priopulls
help to maintain tail latencies by fetching client requested data
on-demand.
\subsection{Pull and Replay Scalability}
\label{sec:eval-replay}
Parallel and pipelined pulls and replay are essential to migration speed that
interleaves with normal-case request processing. The microbenchmark shown in
Figure~\ref{fig:parallel-replay} explores the scalability of the source and
target pull processing logic. In the experiment, the source and target
pull/replay logic was run in isolation on large batches of records to stress
contention and to determine the upper bound on migration speed at both ends
independently.
Overall, both the source and target can process pulls and replays in parallel with
little contention. In initial experiments, replay's performance was limited when the
target replayed records into a single, shared in-memory log, but per-worker side logs
remedy this. Small 128~B records (like those used in the evaluation) are
challenging. They require computing hashes and checksums over many small log
entries on both the source and target. On the target, they also require many
probes into the hash table to insert references, which induces many costly
cache misses. Even so, the source and target can migrate 5.7~GB/s and
3~GB/s,
respectively. The source outpaces replay by 1.8~to~2.4$\times$ on the
same number of cores, so migration stresses the target more than the source.
This result works well for scaling out since the source is likely to be under an
existing load that is being redistributed to a less loaded target. For larger
record sizes, pull/replay logic does not limit migration.
|
function diff_fab = usim(fa, f)
diff_fab = 0;
N = length(f);
for i = 1 : N
fb = f{i};
diff_ab = usimole(fa, fb);
diff_fab = diff_fab + diff_ab;
end |
= Michael Jordan =
|
| pc = 0xc002 | a = 0x03 | x = 0x00 | y = 0x00 | sp = 0x01fd | p[NV-BDIZC] = 00110100 |
| pc = 0xc005 | a = 0x03 | x = 0x00 | y = 0x00 | sp = 0x01fd | p[NV-BDIZC] = 00110100 | MEM[0x0513] = 0x03 |
| pc = 0xc007 | a = 0x02 | x = 0x00 | y = 0x00 | sp = 0x01fd | p[NV-BDIZC] = 00110100 |
| pc = 0xc009 | a = 0x02 | x = 0x02 | y = 0x00 | sp = 0x01fd | p[NV-BDIZC] = 00110100 |
| pc = 0xc00c | a = 0x02 | x = 0x02 | y = 0x00 | sp = 0x01fd | p[NV-BDIZC] = 10110100 | MEM[0x0513] = 0x03 |
|
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
def generate_colours(df, column, cmap_name):
# TODO: they get generated a little different than what pandas does automatically
labels = np.sort(df[column].unique())
cmap = plt.get_cmap(cmap_name)
colours = cmap(np.linspace(0,1,len(labels)+1))
colour_dict = dict(zip(labels,colours))
return colour_dict
def populate_plot_options(kind, alpha, cmap_name, df=pd.DataFrame(),
index=False, legend=False, stacked=True):
plot_options = dict()
plot_options['kind'] = kind
plot_options['alpha'] = alpha
if not df.empty:
colour_dict = generate_colours(df, legend, cmap_name)
label = df.loc[index,legend]
plot_options['c'] = colour_dict[label]
plot_options['label'] = str(label)
else:
plot_options['colormap'] = cmap_name
if kind == 'line':
plot_options['linewidth'] = 2
# plot_options['marker'] = '.'
# plot_options['markersize'] = 12
# TODO: move default marker size to MatplotlibSettings.py
elif kind == 'scatter':
plot_options['edgecolors'] = 'face'
plot_options['s'] = 12
elif 'bar' in kind:
plot_options['stacked'] = stacked
plot_options['edgecolor'] = 'none'
return plot_options |
#include <anie/activation_layers/sigmoid_layer.hpp>
#include <cassert>
#include <memory>
#include <boost/compute.hpp>
namespace anie
{
sigmoid_layer::sigmoid_layer(const anie::device& device) noexcept
: activation_layer(device), u_(device)
{}
std::string_view sigmoid_layer::name() const noexcept
{
return "Sigmoid";
}
matrix sigmoid_layer::forward(const matrix& z) const
{
assert(device() == z.device());
static BOOST_COMPUTE_FUNCTION(arithemtic_type, sigmoid, (const double x),
{
return 1. / (1. + exp(-x));
});
matrix result(z);
boost::compute::transform(result.begin(), result.end(), result.begin(), sigmoid, device().queue());
u_ = z;
return result;
}
matrix sigmoid_layer::backward(const matrix& d)
{
assert(device() == d.device());
static BOOST_COMPUTE_FUNCTION(arithemtic_type, dsigmoid, (const double x),
{
const double y = 1. / (1. + exp(-x));
return y * (1. - y);
});
matrix result(u_);
boost::compute::transform(result.begin(), result.end(), result.begin(), dsigmoid, device().queue());
return result;
}
}
namespace anie
{
layer_ptr sigmoid_layer_generator::operator()(const anie::device& device) const
{
return std::make_shared<sigmoid_layer>(device);
}
layer_generator_ptr sigmoid()
{
return std::make_shared<sigmoid_layer_generator>();
}
layer_ptr sigmoid(const anie::device& device)
{
return std::make_shared<sigmoid_layer>(device);
}
} |
-- Picture.idr
--
-- Demonstraters recursive data types
import Shape
||| Represents a picture with multiple shapes
public export
data Picture = Primitive Shape
| Combine Picture Picture
| Rotate Double Picture
| Translate Double Double Picture
-- %name Shape shape, shape1, shape2
%name Picture pic, pic1, pic2
-- a test picture
rectangle : Picture
rectangle = Primitive (Rectangle 20 10)
circle : Picture
circle = Primitive (Circle 5)
triangle : Picture
triangle = Primitive (Triangle 10 10)
testPicture : Picture
testPicture = Combine (Translate 5 5 rectangle)
(Combine (Translate 35 5 circle)
(Translate 15 25 triangle))
||| Calculates the sum area of all shapes in a picture
export
pictureArea : Picture -> Double
pictureArea (Primitive shape) = area shape
pictureArea (Combine pic pic1) = pictureArea pic + pictureArea pic1
pictureArea (Rotate x pic) = pictureArea pic
pictureArea (Translate x y pic) = pictureArea pic
|
## Arithmétique
### Nombre rationels
```python
# Étant donné un nombre rationnel trouver le plus petit ratio a/b permettant de l'exprimer
def plus_petit_ratio(nombre):
b = 1
a = 1
while (a/b) != nombre:
if (a/b) < nombre:
a = a + 1
elif (a/b) > nombre:
b = b + 1
return a, b
a, b = plus_petit_ratio(1.2376)
print(a)
print(b)
print(a/b)
```
1547
1250
1.2376
### Nombre irrationnels
```python
# Comment les nombres irrationels sont représentés par l'ordinateur
# (nombre limité d'espace)
print(2**(1/2))
from math import pi
print(pi)
```
1.4142135623730951
3.141592653589793
```python
# modifier la fonction précédente pour qu'elle donne un message d'erreur dans le cas ou le nombre
# est irrationnel
nombre = pi
def plus_petit_ratio2(nombre):
b = 1
a = 1
compteur = 0
while (a/b) != nombre:
compteur += 1
if (a/b) < nombre:
a = a + 1
elif (a/b) > nombre:
b = b + 1
if compteur > 5000:
print('Le nombre est probablement irrationnel')
break
return a, b
a, b = plus_petit_ratio2(nombre)
print(a)
print(b)
print(a/b)
```
Le nombre est probablement irrationnel
3795
1208
3.1415562913907285
```python
# Faire une fonction pour ordonner les nombre irrationnels (niveau 2)
def ordonner(nombre1, nombre2):
if nombre1 > nombre2:
print(' le nombre 1 est plus grand ')
elif nombre1 < nombre2:
print(' le nombre 2 est plus grand ')
else:
print(' les nombres sont égaux')
ordonner(pi, 2**(1/2))
```
le nombre 1 est plus grand
### Ensembles de nombres
```python
# Exercice pour comprendre la fonction range() de python
from support import *
# L'ensemble des nombres naturels impairs compris entre 2 et 10.
print(range(3, 10, 2))
# L'ensemble des multiples de 4 compris entre 3 et 101.
print(range(4, 101, 4))
```
[3, 5, 7, 9]
[4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96, 100]
```python
# Classifier les nombres selon à quel ensemble ils appartiennent
def plus_petit_ratio3(nombre):
b = 1
a = 1
compteur = 0
while (a/b) != nombre:
compteur += 1
if (a/b) < nombre:
a = a + 1
elif (a/b) > nombre:
b = b + 1
if compteur > 1000:
return -1, -1
return a, b
def classificateur(nombre):
if (nombre // 1) == nombre:
if nombre >= 0:
print('je suis un entier positif dans N')
elif nombre < 0:
print('je suis un entier négatif dans Z')
else:
if nombre > 0:
a, b = plus_petit_ratio3(nombre)
if (a+b) == -2:
print("Je suis un nombre irrationnel positif Q'")
else:
print('Je suis un nombre rationel positif Q')
elif nombre < 0:
a, b = plus_petit_ratio3(-nombre)
if (a+b) == -2:
print("Je suis un nombre irrationnel négatif Q'")
else:
print('Je suis un nombre rationel négatif Q')
```
Je suis un nombre irrationnel positif Q'
### La notation exponentielle
```python
# Faire un calculateur d'exposants (niveau 1)
# Calcul les exposants de la forme (a/b)**(c/d)
def calculateur_exposant(a, b, c, d):
return (a/b)**(c/d)
calculateur_exposant(1, 27, 1, 3)
# Changer la fonction pour être certain de pas avoir de résultat complexe
```
0.33333333333333337
### Lois sur les exposants
```python
from sympy import symbols, Eq, solve
# niveau 2
x = symbols('x')
# Equation : 0.96^7 = 0.96^2 * 0.96^x
solve(Eq(0.96**7, 0.96**2 * 0.96**x))
solve(Eq(1.15**4 / 1.15**2, 1.15**x))
```
[2.00000000000000]
### La notation scientifique
```python
# Crée une fonction qui imprime un nombre selon sa notation exponentielle
def expo_print(nombre, exposant):
# Transformer en lettres
nombre_lettres = str(nombre)
# enlever le point
nombre_lettres = nombre_lettres[0] + nombre_lettres[2:]
# ajouter les zéros
nombre_lettres = nombre_lettres + '0'*(exposant - len(nombre_lettres) + 1)
print(nombre_lettres)
expo_print(6.022, 23)
```
602200000000000000000000
### Les nombres cubiques et racines cubiques
```python
# Faire un programme qui donne les n premières racines cubiques
def racines_cubiques(n):
racines_trouvees = 0
nombre = 1
while racines_trouvees < n:
racine = nombre **(1/3)
if abs(round(racine) - racine) < 1e-6:
print('Voici un nombre cubique : ', nombre)
racines_trouvees = racines_trouvees + 1
nombre = nombre + 1
else:
nombre = nombre + 1
```
### Algèbre
```python
# niveau 3
def intersection(a1, b1, a2, b2):
if a1 == a2:
if b1 == b2:
print('droites parallèles confondues')
else:
print('droites parallèles disjointes')
else:
x = (b2 - b1) / (a1 - a2)
y = a1*x + b1
if a1*a2 == -1:
print('droites perpendiculaires')
print('intersection : (', x,',', y, ')')
else:
print('droites sécantes')
print('intersection : (', x, ',', y, ')')
```
### Factorisation
```python
from sympy import factor, symbols
m = symbols('m')
expression = 22*m - 55
factor(expression)
```
$\displaystyle 11 \left(2 m - 5\right)$
### Algèbre sec. 2
```python
x, y = symbols('x y')
3*x + 4*y - 2*x
```
$\displaystyle x + 4 y$
```python
from sympy import solve, Eq
x = symbols('x')
solve(Eq(2*x + 8, 16), x)
```
[4]
### Fonctions imbriquées et géométrie
```python
def aire_prisme(hauteur, perimetre, aire_base):
A_totale = perimetre*hauteur + 2*aire_base
return A_totale
def aire_triangle(b, h):
A = b*h /2
return A
def aire_rectangle(b, h):
return b*h
def perimetre_rectangle(b, h):
return 2*b + 2*h
```
Aire d'un prisme à base rectangulaire h = 10, b = 3, a = 2
```python
h, b, a = 10, 3, 2
aire_base = aire_rectangle(b, a)
perimetre_base = perimetre_rectangle(b, a)
A_prisme = aire_prisme(h, perimetre_base, aire_base)
print('Aire du prisme : ', A_prisme)
```
Aire du prisme : 112
```python
```
```python
from matplotlib.pyplot import plot as tracer
```
```python
tracer([-2, 0, 0.5, 2.1, 4])
```
### Fonctions
```python
def f(x):
y = 1/x
return y
```
```python
import numpy as np
import matplotlib.pyplot as plt
def plot_function(f):
x = np.linspace(-1, 1)
y = f(x)
plt.plot(x, y)
```
```python
f1 = lambda x: 2*x + 1
f2 = lambda x: 2*x + 2
f3 = lambda x: 2*x + 2
plot_function(f1)
plot_function(f2)
```
```python
```
|
module Invincy.Core
%access public export
interface Monoid s => Stream t s | s where
single : t -> s
uncons : s -> Maybe (t, s)
cons : t -> s -> s
cons x s = single x <+> s
implementation Stream t (List t) where
single = pure
uncons (x::xs) = Just (x, xs)
uncons [] = Nothing
cons = (::)
implementation Stream Char String where
single = singleton
uncons s = case strM s of
StrNil => Nothing
StrCons x xs => Just (x, xs)
cons = strCons
fromString : Stream Char s => String -> s
fromString = concatMap single . unpack
toList : Stream t s => s -> List t
toList s = case uncons s of
Nothing => []
Just (x, xs) => x :: toList xs
fromList : Stream t s => List t -> s
fromList [] = neutral
fromList (x::xs) = cons x $ fromList xs
|
lemma lipschitz_onD: "dist (f x) (f y) \<le> L * dist x y" if "L-lipschitz_on X f" "x \<in> X" "y \<in> X" |
\section{Biological background}
\begin{frame}
\frametitle{Coral Reef}
\includegraphics[scale=.175]{./US-Wildlife-coral-1.jpg}
\begin{itemize}
\item A complex aquatic ecosystem physically supported by calcium carbonate secretions of the colorful stone coral.
\item Modeling approach by Li-Wang-Zhang-Hastings is to describe the relationships between macroalgae, algal turfs, and corals \cite{Hastings}.
\end{itemize}
\end{frame}
\begin{frame}
\frametitle{Advantages of Macroalgae}
\begin{itemize}
\item Naturally filter the water by reducing the levels of phosphate and nitrogenous waste.
\item Provide hiding places for fishes and invertebrates.
\item Convert energy into food for the rest of the reef food web.
\end{itemize}
\end{frame}
\begin{frame}
\frametitle{Coral Reef Ecosystem}
McClanahan identifies three major components\cite{McClanahan}:
\begin{itemize}
\item Primary producers (algae)\\
\item Herbivores (e.g. scarid grazing)\\
\item Carnivores
\end{itemize}
\end{frame}
\begin{frame}
\centering
\frametitle{Reef Food Web}
\includegraphics[scale=.65]{./CoralFoodWeb}
\end{frame}
\begin{frame}
\frametitle{Disadvantages of Macroalgae}
\begin{itemize}
\item Competes with the coral population for space at low grazing levels.
\item Alter the microbial communities associated with corals increasing pathogens on corals.
\item Macroalgal abundance may lead to reef degradation.
\item Coral mortality is generally followed by algal recruitment.
\end{itemize}
\end{frame}
\begin{frame}
\frametitle{Coral Reef Dynamics}
\includegraphics[scale=.7]{./CoralDynamics}
\end{frame}
|
# GPyTorch Regression Tutorial
<a href="https://colab.research.google.com/github/jwangjie/gpytorch/blob/master/examples/01_Exact_GPs/Simple_GP_Regression.ipynb" target="_parent"></a>
## Introduction
In this notebook, we demonstrate many of the design features of GPyTorch using the simplest example, training an RBF kernel Gaussian process on a simple function. We'll be modeling the function
\begin{align}
y &= \sin(2\pi x) + \epsilon \\
\epsilon &\sim \mathcal{N}(0, 0.04)
\end{align}
with 100 training examples, and testing on 51 test examples.
**Note:** this notebook is not necessarily intended to teach the mathematical background of Gaussian processes, but rather how to train a simple one and make predictions in GPyTorch. For a mathematical treatment, Chapter 2 of Gaussian Processes for Machine Learning provides a very thorough introduction to GP regression (this entire text is highly recommended): http://www.gaussianprocess.org/gpml/chapters/RW2.pdf
```python
# COMMENT this if not used in colab
!pip3 install gpytorch
```
Collecting gpytorch
[?25l Downloading https://files.pythonhosted.org/packages/9c/5f/ce79e35c1a36deb25a0eac0f67bfe85fb8350eb8e19223950c3d615e5e9a/gpytorch-1.0.1.tar.gz (229kB)
[K |████████████████████████████████| 235kB 2.8MB/s
[?25hBuilding wheels for collected packages: gpytorch
Building wheel for gpytorch (setup.py) ... [?25l[?25hdone
Created wheel for gpytorch: filename=gpytorch-1.0.1-py2.py3-none-any.whl size=390441 sha256=4c1c86a4228d2a6b7a30cf734f9a1b61de06c54de6177c0c84e34ae7d7b02939
Stored in directory: /root/.cache/pip/wheels/10/2f/7a/3328e5713d796daeec2ce8ded141d5f3837253fc3c2a5c62e0
Successfully built gpytorch
Installing collected packages: gpytorch
Successfully installed gpytorch-1.0.1
```python
import math
import torch
import gpytorch
from matplotlib import pyplot as plt
%matplotlib inline
%load_ext autoreload
%autoreload 2
```
### Set up training data
In the next cell, we set up the training data for this example. We'll be using 100 regularly spaced points on [0,1] which we evaluate the function on and add Gaussian noise to get the training labels.
```python
# Training data is 100 points in [0,1] inclusive regularly spaced
train_x = torch.linspace(0, 1, 100)
# True function is sin(2*pi*x) with Gaussian noise
train_y = torch.sin(train_x * (2 * math.pi)) + torch.randn(train_x.size()) * math.sqrt(0.04)
```
```python
plt.plot(train_x.numpy(), train_y.numpy())
plt.show()
```
## Setting up the model
The next cell demonstrates the most critical features of a user-defined Gaussian process model in GPyTorch. Building a GP model in GPyTorch is different in a number of ways.
First in contrast to many existing GP packages, we do not provide full GP models for the user. Rather, we provide *the tools necessary to quickly construct one*. This is because we believe, analogous to building a neural network in standard PyTorch, it is important to have the flexibility to include whatever components are necessary. As can be seen in more complicated examples, this allows the user great flexibility in designing custom models.
For most GP regression models, you will need to construct the following GPyTorch objects:
1. A **GP Model** (`gpytorch.models.ExactGP`) - This handles most of the inference.
1. A **Likelihood** (`gpytorch.likelihoods.GaussianLikelihood`) - This is the most common likelihood used for GP regression.
1. A **Mean** - This defines the prior mean of the GP.(If you don't know which mean to use, a `gpytorch.means.ConstantMean()` is a good place to start.)
1. A **Kernel** - This defines the prior covariance of the GP.(If you don't know which kernel to use, a `gpytorch.kernels.ScaleKernel(gpytorch.kernels.RBFKernel())` is a good place to start).
1. A **MultivariateNormal** Distribution (`gpytorch.distributions.MultivariateNormal`) - This is the object used to represent multivariate normal distributions.
### The GP Model
The components of a user built (Exact, i.e. non-variational) GP model in GPyTorch are, broadly speaking:
1. An `__init__` method that takes the training data and a likelihood, and constructs whatever objects are necessary for the model's `forward` method. This will most commonly include things like a mean module and a kernel module.
2. A `forward` method that takes in some $n \times d$ data `x` and returns a `MultivariateNormal` with the *prior* mean and covariance evaluated at `x`. In other words, we return the vector $\mu(x)$ and the $n \times n$ matrix $K_{xx}$ representing the prior mean and covariance matrix of the GP.
This specification leaves a large amount of flexibility when defining a model. For example, to compose two kernels via addition, you can either add the kernel modules directly:
```python
self.covar_module = ScaleKernel(RBFKernel() + WhiteNoiseKernel())
```
Or you can add the outputs of the kernel in the forward method:
```python
covar_x = self.rbf_kernel_module(x) + self.white_noise_module(x)
```
```python
# We will use the simplest form of GP model, exact inference
class ExactGPModel(gpytorch.models.ExactGP):
def __init__(self, train_x, train_y, likelihood):
super(ExactGPModel, self).__init__(train_x, train_y, likelihood)
self.mean_module = gpytorch.means.ConstantMean()
self.covar_module = gpytorch.kernels.ScaleKernel(gpytorch.kernels.RBFKernel())
def forward(self, x):
mean_x = self.mean_module(x)
covar_x = self.covar_module(x)
return gpytorch.distributions.MultivariateNormal(mean_x, covar_x)
# initialize likelihood and model
likelihood = gpytorch.likelihoods.GaussianLikelihood()
model = ExactGPModel(train_x, train_y, likelihood)
```
### Plot before optimizing the hyperparamters
Let's take a look at the model parameters. More information is <a href="https://colab.research.google.com/github/jwangjie/gpytorch/blob/master/examples/00_Basic_Usage/Hyperparameters.ipynb">here</a>.
```python
model.state_dict()
```
OrderedDict([('likelihood.noise_covar.raw_noise', tensor([0.])),
('mean_module.constant', tensor([0.])),
('covar_module.raw_outputscale', tensor(0.)),
('covar_module.base_kernel.raw_lengthscale', tensor([[0.]]))])
Goes to run [Make predictions with the model](https://colab.research.google.com/github/jwangjie/gpytorch/blob/master/examples/01_Exact_GPs/Simple_GP_Regression.ipynb#scrollTo=S1gMlb1TCM7i), and then run `Plot the model fit`.
```python
# Get into evaluation (predictive posterior) mode
model.eval()
likelihood.eval()
# Test points are regularly spaced along [0,1]
# Make predictions by feeding model through likelihood
with torch.no_grad(), gpytorch.settings.fast_pred_var():
test_x = torch.linspace(0, 1, 51)
observed_pred = likelihood(model(test_x))
with torch.no_grad():
# Initialize plot
f, ax = plt.subplots(1, 1, figsize=(8, 6))
# Get upper and lower confidence bounds
lower, upper = observed_pred.confidence_region()
# Plot training data as black stars
ax.plot(train_x.numpy(), train_y.numpy(), 'k*')
# Plot predictive means as blue line
ax.plot(test_x.numpy(), observed_pred.mean.numpy(), 'r')
# Shade between the lower and upper confidence bounds
ax.fill_between(test_x.numpy(), lower.numpy(), upper.numpy(), alpha=0.3)
ax.set_ylim([-3, 3])
ax.legend(['Observed Data', 'Mean', 'Confidence'])
```
### Model modes
Like most PyTorch modules, the `ExactGP` has a `.train()` and `.eval()` mode.
- `.train()` mode is for optimizing model hyperameters.
- `.eval()` mode is for computing predictions through the model posterior.
## Training the model
In the next cell, we handle using Type-II MLE to train the hyperparameters of the Gaussian process.
The most obvious difference here compared to many other GP implementations is that, as in standard PyTorch, the core training loop is written by the user. In GPyTorch, we make use of the standard PyTorch optimizers as from `torch.optim`, and all trainable parameters of the model should be of type `torch.nn.Parameter`. Because GP models directly extend `torch.nn.Module`, calls to methods like `model.parameters()` or `model.named_parameters()` function as you might expect coming from PyTorch.
In most cases, the boilerplate code below will work well. It has the same basic components as the standard PyTorch training loop:
1. Zero all parameter gradients
2. Call the model and compute the loss
3. Call backward on the loss to fill in gradients
4. Take a step on the optimizer
However, defining custom training loops allows for greater flexibility. For example, it is easy to save the parameters at each step of training, or use different learning rates for different parameters (which may be useful in deep kernel learning for example).
```python
# this is for running the notebook in our testing framework
import os
smoke_test = ('CI' in os.environ)
training_iter = 2 if smoke_test else 50
# Find optimal model hyperparameters
model.train()
likelihood.train()
# Use the adam optimizer
optimizer = torch.optim.Adam([
{'params': model.parameters()}, # Includes GaussianLikelihood parameters
], lr=0.1)
# "Loss" for GPs - the marginal log likelihood
mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, model)
for i in range(training_iter):
# Zero gradients from previous iteration
optimizer.zero_grad()
# Output from model
output = model(train_x)
# Calc loss and backprop gradients
loss = -mll(output, train_y)
loss.backward()
print('Iter %d/%d - Loss: %.3f lengthscale: %.3f noise: %.3f' % (
i + 1, training_iter, loss.item(),
model.covar_module.base_kernel.lengthscale.item(),
model.likelihood.noise.item()
))
optimizer.step()
```
Iter 1/50 - Loss: 0.906 lengthscale: 0.693 noise: 0.693
Iter 2/50 - Loss: 0.873 lengthscale: 0.644 noise: 0.644
Iter 3/50 - Loss: 0.839 lengthscale: 0.598 noise: 0.598
Iter 4/50 - Loss: 0.802 lengthscale: 0.554 noise: 0.554
Iter 5/50 - Loss: 0.762 lengthscale: 0.513 noise: 0.513
Iter 6/50 - Loss: 0.717 lengthscale: 0.475 noise: 0.474
Iter 7/50 - Loss: 0.671 lengthscale: 0.438 noise: 0.437
Iter 8/50 - Loss: 0.624 lengthscale: 0.404 noise: 0.402
Iter 9/50 - Loss: 0.579 lengthscale: 0.371 noise: 0.370
Iter 10/50 - Loss: 0.537 lengthscale: 0.341 noise: 0.339
Iter 11/50 - Loss: 0.498 lengthscale: 0.315 noise: 0.311
Iter 12/50 - Loss: 0.462 lengthscale: 0.292 noise: 0.284
Iter 13/50 - Loss: 0.427 lengthscale: 0.273 noise: 0.260
Iter 14/50 - Loss: 0.393 lengthscale: 0.258 noise: 0.237
Iter 15/50 - Loss: 0.359 lengthscale: 0.247 noise: 0.216
Iter 16/50 - Loss: 0.325 lengthscale: 0.238 noise: 0.197
Iter 17/50 - Loss: 0.291 lengthscale: 0.233 noise: 0.180
Iter 18/50 - Loss: 0.257 lengthscale: 0.229 noise: 0.163
Iter 19/50 - Loss: 0.223 lengthscale: 0.228 noise: 0.149
Iter 20/50 - Loss: 0.190 lengthscale: 0.229 noise: 0.135
Iter 21/50 - Loss: 0.157 lengthscale: 0.232 noise: 0.123
Iter 22/50 - Loss: 0.126 lengthscale: 0.236 noise: 0.112
Iter 23/50 - Loss: 0.096 lengthscale: 0.241 noise: 0.102
Iter 24/50 - Loss: 0.067 lengthscale: 0.248 noise: 0.093
Iter 25/50 - Loss: 0.040 lengthscale: 0.256 noise: 0.084
Iter 26/50 - Loss: 0.016 lengthscale: 0.264 noise: 0.077
Iter 27/50 - Loss: -0.005 lengthscale: 0.274 noise: 0.070
Iter 28/50 - Loss: -0.024 lengthscale: 0.283 noise: 0.064
Iter 29/50 - Loss: -0.039 lengthscale: 0.292 noise: 0.059
Iter 30/50 - Loss: -0.051 lengthscale: 0.300 noise: 0.054
Iter 31/50 - Loss: -0.059 lengthscale: 0.307 noise: 0.050
Iter 32/50 - Loss: -0.065 lengthscale: 0.311 noise: 0.046
Iter 33/50 - Loss: -0.069 lengthscale: 0.312 noise: 0.043
Iter 34/50 - Loss: -0.071 lengthscale: 0.310 noise: 0.040
Iter 35/50 - Loss: -0.072 lengthscale: 0.306 noise: 0.038
Iter 36/50 - Loss: -0.071 lengthscale: 0.300 noise: 0.036
Iter 37/50 - Loss: -0.069 lengthscale: 0.293 noise: 0.034
Iter 38/50 - Loss: -0.066 lengthscale: 0.285 noise: 0.033
Iter 39/50 - Loss: -0.063 lengthscale: 0.278 noise: 0.032
Iter 40/50 - Loss: -0.059 lengthscale: 0.271 noise: 0.031
Iter 41/50 - Loss: -0.056 lengthscale: 0.265 noise: 0.030
Iter 42/50 - Loss: -0.054 lengthscale: 0.260 noise: 0.030
Iter 43/50 - Loss: -0.053 lengthscale: 0.256 noise: 0.029
Iter 44/50 - Loss: -0.053 lengthscale: 0.253 noise: 0.029
Iter 45/50 - Loss: -0.054 lengthscale: 0.251 noise: 0.030
Iter 46/50 - Loss: -0.056 lengthscale: 0.250 noise: 0.030
Iter 47/50 - Loss: -0.058 lengthscale: 0.250 noise: 0.031
Iter 48/50 - Loss: -0.061 lengthscale: 0.251 noise: 0.031
Iter 49/50 - Loss: -0.064 lengthscale: 0.252 noise: 0.032
Iter 50/50 - Loss: -0.066 lengthscale: 0.253 noise: 0.033
```python
model.state_dict()
```
OrderedDict([('likelihood.noise_covar.raw_noise', tensor([-3.3824])),
('mean_module.constant', tensor([0.0588])),
('covar_module.raw_outputscale', tensor(-0.4108)),
('covar_module.base_kernel.raw_lengthscale',
tensor([[-1.2372]]))])
## Make predictions with the model
In the next cell, we make predictions with the model. To do this, we simply put the model and likelihood in eval mode, and call both modules on the test data.
Just as a user defined GP model returns a `MultivariateNormal` containing the prior mean and covariance from forward, a trained GP model in eval mode returns a `MultivariateNormal` containing the posterior mean and covariance. Thus, getting the predictive mean and variance, and then sampling functions from the GP at the given test points could be accomplished with calls like:
```python
f_preds = model(test_x)
y_preds = likelihood(model(test_x))
f_mean = f_preds.mean
f_var = f_preds.variance
f_covar = f_preds.covariance_matrix
f_samples = f_preds.sample(sample_shape=torch.Size(1000,))
```
The `gpytorch.settings.fast_pred_var` context is not needed, but here we are giving a preview of using one of our cool features, getting faster predictive distributions using [LOVE](https://arxiv.org/abs/1803.06058).
```python
# Get into evaluation (predictive posterior) mode
model.eval()
likelihood.eval()
# Test points are regularly spaced along [0,1]
# Make predictions by feeding model through likelihood
with torch.no_grad(), gpytorch.settings.fast_pred_var():
test_x = torch.linspace(0, 1, 51)
observed_pred = likelihood(model(test_x))
```
## Plot the model fit
In the next cell, we plot the mean and confidence region of the Gaussian process model. The `confidence_region` method is a helper method that returns 2 standard deviations above and below the mean.
```python
with torch.no_grad():
# Initialize plot
f, ax = plt.subplots(1, 1, figsize=(8, 6))
# Get upper and lower confidence bounds
lower, upper = observed_pred.confidence_region()
# Plot training data as black stars
ax.plot(train_x.numpy(), train_y.numpy(), 'k*')
# Plot predictive means as blue line
ax.plot(test_x.numpy(), observed_pred.mean.numpy(), 'r')
# Shade between the lower and upper confidence bounds
ax.fill_between(test_x.numpy(), lower.numpy(), upper.numpy(), alpha=0.3)
ax.set_ylim([-3, 3])
ax.legend(['Observed Data', 'Mean', 'Confidence'])
```
```python
```
|
(* Author: Tobias Nipkow *)
theory Abs_Int2
imports Abs_Int1
begin
instantiation prod :: (order,order) order
begin
definition "less_eq_prod p1 p2 = (fst p1 \<le> fst p2 \<and> snd p1 \<le> snd p2)"
definition "less_prod p1 p2 = (p1 \<le> p2 \<and> \<not> p2 \<le> (p1::'a*'b))"
instance
proof
case goal1 show ?case by(rule less_prod_def)
next
case goal2 show ?case by(simp add: less_eq_prod_def)
next
case goal3 thus ?case unfolding less_eq_prod_def by(metis order_trans)
next
case goal4 thus ?case by(simp add: less_eq_prod_def)(metis eq_iff surjective_pairing)
qed
end
subsection "Backward Analysis of Expressions"
subclass (in bounded_lattice) semilattice_sup_top ..
locale Val_lattice_gamma = Gamma_semilattice where \<gamma> = \<gamma>
for \<gamma> :: "'av::bounded_lattice \<Rightarrow> val set" +
assumes inter_gamma_subset_gamma_inf:
"\<gamma> a1 \<inter> \<gamma> a2 \<subseteq> \<gamma>(a1 \<sqinter> a2)"
and gamma_bot[simp]: "\<gamma> \<bottom> = {}"
begin
lemma in_gamma_inf: "x : \<gamma> a1 \<Longrightarrow> x : \<gamma> a2 \<Longrightarrow> x : \<gamma>(a1 \<sqinter> a2)"
by (metis IntI inter_gamma_subset_gamma_inf set_mp)
lemma gamma_inf: "\<gamma>(a1 \<sqinter> a2) = \<gamma> a1 \<inter> \<gamma> a2"
by(rule equalityI[OF _ inter_gamma_subset_gamma_inf])
(metis inf_le1 inf_le2 le_inf_iff mono_gamma)
end
locale Val_inv = Val_lattice_gamma where \<gamma> = \<gamma>
for \<gamma> :: "'av::bounded_lattice \<Rightarrow> val set" +
fixes test_num' :: "val \<Rightarrow> 'av \<Rightarrow> bool"
and inv_plus' :: "'av \<Rightarrow> 'av \<Rightarrow> 'av \<Rightarrow> 'av * 'av"
and inv_less' :: "bool \<Rightarrow> 'av \<Rightarrow> 'av \<Rightarrow> 'av * 'av"
assumes test_num': "test_num' i a = (i : \<gamma> a)"
and inv_plus': "inv_plus' a a1 a2 = (a\<^sub>1',a\<^sub>2') \<Longrightarrow>
i1 : \<gamma> a1 \<Longrightarrow> i2 : \<gamma> a2 \<Longrightarrow> i1+i2 : \<gamma> a \<Longrightarrow> i1 : \<gamma> a\<^sub>1' \<and> i2 : \<gamma> a\<^sub>2'"
and inv_less': "inv_less' (i1<i2) a1 a2 = (a\<^sub>1',a\<^sub>2') \<Longrightarrow>
i1 : \<gamma> a1 \<Longrightarrow> i2 : \<gamma> a2 \<Longrightarrow> i1 : \<gamma> a\<^sub>1' \<and> i2 : \<gamma> a\<^sub>2'"
locale Abs_Int_inv = Val_inv where \<gamma> = \<gamma>
for \<gamma> :: "'av::bounded_lattice \<Rightarrow> val set"
begin
lemma in_gamma_sup_UpI:
"s : \<gamma>\<^sub>o S1 \<or> s : \<gamma>\<^sub>o S2 \<Longrightarrow> s : \<gamma>\<^sub>o(S1 \<squnion> S2)"
by (metis (hide_lams, no_types) sup_ge1 sup_ge2 mono_gamma_o subsetD)
fun aval'' :: "aexp \<Rightarrow> 'av st option \<Rightarrow> 'av" where
"aval'' e None = \<bottom>" |
"aval'' e (Some S) = aval' e S"
lemma aval''_correct: "s : \<gamma>\<^sub>o S \<Longrightarrow> aval a s : \<gamma>(aval'' a S)"
by(cases S)(auto simp add: aval'_correct split: option.splits)
subsubsection "Backward analysis"
fun inv_aval' :: "aexp \<Rightarrow> 'av \<Rightarrow> 'av st option \<Rightarrow> 'av st option" where
"inv_aval' (N n) a S = (if test_num' n a then S else None)" |
"inv_aval' (V x) a S = (case S of None \<Rightarrow> None | Some S \<Rightarrow>
let a' = fun S x \<sqinter> a in
if a' = \<bottom> then None else Some(update S x a'))" |
"inv_aval' (Plus e1 e2) a S =
(let (a1,a2) = inv_plus' a (aval'' e1 S) (aval'' e2 S)
in inv_aval' e1 a1 (inv_aval' e2 a2 S))"
text{* The test for @{const bot} in the @{const V}-case is important: @{const
bot} indicates that a variable has no possible values, i.e.\ that the current
program point is unreachable. But then the abstract state should collapse to
@{const None}. Put differently, we maintain the invariant that in an abstract
state of the form @{term"Some s"}, all variables are mapped to non-@{const
bot} values. Otherwise the (pointwise) sup of two abstract states, one of
which contains @{const bot} values, may produce too large a result, thus
making the analysis less precise. *}
fun inv_bval' :: "bexp \<Rightarrow> bool \<Rightarrow> 'av st option \<Rightarrow> 'av st option" where
"inv_bval' (Bc v) res S = (if v=res then S else None)" |
"inv_bval' (Not b) res S = inv_bval' b (\<not> res) S" |
"inv_bval' (And b1 b2) res S =
(if res then inv_bval' b1 True (inv_bval' b2 True S)
else inv_bval' b1 False S \<squnion> inv_bval' b2 False S)" |
"inv_bval' (Less e1 e2) res S =
(let (a1,a2) = inv_less' res (aval'' e1 S) (aval'' e2 S)
in inv_aval' e1 a1 (inv_aval' e2 a2 S))"
lemma inv_aval'_correct: "s : \<gamma>\<^sub>o S \<Longrightarrow> aval e s : \<gamma> a \<Longrightarrow> s : \<gamma>\<^sub>o (inv_aval' e a S)"
proof(induction e arbitrary: a S)
case N thus ?case by simp (metis test_num')
next
case (V x)
obtain S' where "S = Some S'" and "s : \<gamma>\<^sub>s S'" using `s : \<gamma>\<^sub>o S`
by(auto simp: in_gamma_option_iff)
moreover hence "s x : \<gamma> (fun S' x)"
by(simp add: \<gamma>_st_def)
moreover have "s x : \<gamma> a" using V(2) by simp
ultimately show ?case
by(simp add: Let_def \<gamma>_st_def)
(metis mono_gamma emptyE in_gamma_inf gamma_bot subset_empty)
next
case (Plus e1 e2) thus ?case
using inv_plus'[OF _ aval''_correct aval''_correct]
by (auto split: prod.split)
qed
lemma inv_bval'_correct: "s : \<gamma>\<^sub>o S \<Longrightarrow> bv = bval b s \<Longrightarrow> s : \<gamma>\<^sub>o(inv_bval' b bv S)"
proof(induction b arbitrary: S bv)
case Bc thus ?case by simp
next
case (Not b) thus ?case by simp
next
case (And b1 b2) thus ?case
by simp (metis And(1) And(2) in_gamma_sup_UpI)
next
case (Less e1 e2) thus ?case
apply hypsubst_thin
apply (auto split: prod.split)
apply (metis (lifting) inv_aval'_correct aval''_correct inv_less')
done
qed
definition "step' = Step
(\<lambda>x e S. case S of None \<Rightarrow> None | Some S \<Rightarrow> Some(update S x (aval' e S)))
(\<lambda>b S. inv_bval' b True S)"
definition AI :: "com \<Rightarrow> 'av st option acom option" where
"AI c = pfp (step' \<top>) (bot c)"
lemma strip_step'[simp]: "strip(step' S c) = strip c"
by(simp add: step'_def)
lemma top_on_inv_aval': "\<lbrakk> top_on_opt S X; vars e \<subseteq> -X \<rbrakk> \<Longrightarrow> top_on_opt (inv_aval' e a S) X"
by(induction e arbitrary: a S) (auto simp: Let_def split: option.splits prod.split)
lemma top_on_inv_bval': "\<lbrakk>top_on_opt S X; vars b \<subseteq> -X\<rbrakk> \<Longrightarrow> top_on_opt (inv_bval' b r S) X"
by(induction b arbitrary: r S) (auto simp: top_on_inv_aval' top_on_sup split: prod.split)
lemma top_on_step': "top_on_acom C (- vars C) \<Longrightarrow> top_on_acom (step' \<top> C) (- vars C)"
unfolding step'_def
by(rule top_on_Step)
(auto simp add: top_on_top top_on_inv_bval' split: option.split)
subsubsection "Correctness"
lemma step_step': "step (\<gamma>\<^sub>o S) (\<gamma>\<^sub>c C) \<le> \<gamma>\<^sub>c (step' S C)"
unfolding step_def step'_def
by(rule gamma_Step_subcomm)
(auto simp: intro!: aval'_correct inv_bval'_correct in_gamma_update split: option.splits)
lemma AI_correct: "AI c = Some C \<Longrightarrow> CS c \<le> \<gamma>\<^sub>c C"
proof(simp add: CS_def AI_def)
assume 1: "pfp (step' \<top>) (bot c) = Some C"
have pfp': "step' \<top> C \<le> C" by(rule pfp_pfp[OF 1])
have 2: "step (\<gamma>\<^sub>o \<top>) (\<gamma>\<^sub>c C) \<le> \<gamma>\<^sub>c C" --"transfer the pfp'"
proof(rule order_trans)
show "step (\<gamma>\<^sub>o \<top>) (\<gamma>\<^sub>c C) \<le> \<gamma>\<^sub>c (step' \<top> C)" by(rule step_step')
show "... \<le> \<gamma>\<^sub>c C" by (metis mono_gamma_c[OF pfp'])
qed
have 3: "strip (\<gamma>\<^sub>c C) = c" by(simp add: strip_pfp[OF _ 1] step'_def)
have "lfp c (step (\<gamma>\<^sub>o \<top>)) \<le> \<gamma>\<^sub>c C"
by(rule lfp_lowerbound[simplified,where f="step (\<gamma>\<^sub>o \<top>)", OF 3 2])
thus "lfp c (step UNIV) \<le> \<gamma>\<^sub>c C" by simp
qed
end
subsubsection "Monotonicity"
locale Abs_Int_inv_mono = Abs_Int_inv +
assumes mono_plus': "a1 \<le> b1 \<Longrightarrow> a2 \<le> b2 \<Longrightarrow> plus' a1 a2 \<le> plus' b1 b2"
and mono_inv_plus': "a1 \<le> b1 \<Longrightarrow> a2 \<le> b2 \<Longrightarrow> r \<le> r' \<Longrightarrow>
inv_plus' r a1 a2 \<le> inv_plus' r' b1 b2"
and mono_inv_less': "a1 \<le> b1 \<Longrightarrow> a2 \<le> b2 \<Longrightarrow>
inv_less' bv a1 a2 \<le> inv_less' bv b1 b2"
begin
lemma mono_aval':
"S1 \<le> S2 \<Longrightarrow> aval' e S1 \<le> aval' e S2"
by(induction e) (auto simp: mono_plus' mono_fun)
lemma mono_aval'':
"S1 \<le> S2 \<Longrightarrow> aval'' e S1 \<le> aval'' e S2"
apply(cases S1)
apply simp
apply(cases S2)
apply simp
by (simp add: mono_aval')
lemma mono_inv_aval': "r1 \<le> r2 \<Longrightarrow> S1 \<le> S2 \<Longrightarrow> inv_aval' e r1 S1 \<le> inv_aval' e r2 S2"
apply(induction e arbitrary: r1 r2 S1 S2)
apply(auto simp: test_num' Let_def inf_mono split: option.splits prod.splits)
apply (metis mono_gamma subsetD)
apply (metis le_bot inf_mono le_st_iff)
apply (metis inf_mono mono_update le_st_iff)
apply(metis mono_aval'' mono_inv_plus'[simplified less_eq_prod_def] fst_conv snd_conv)
done
lemma mono_inv_bval': "S1 \<le> S2 \<Longrightarrow> inv_bval' b bv S1 \<le> inv_bval' b bv S2"
apply(induction b arbitrary: bv S1 S2)
apply(simp)
apply(simp)
apply simp
apply(metis order_trans[OF _ sup_ge1] order_trans[OF _ sup_ge2])
apply (simp split: prod.splits)
apply(metis mono_aval'' mono_inv_aval' mono_inv_less'[simplified less_eq_prod_def] fst_conv snd_conv)
done
theorem mono_step': "S1 \<le> S2 \<Longrightarrow> C1 \<le> C2 \<Longrightarrow> step' S1 C1 \<le> step' S2 C2"
unfolding step'_def
by(rule mono2_Step) (auto simp: mono_aval' mono_inv_bval' split: option.split)
lemma mono_step'_top: "C1 \<le> C2 \<Longrightarrow> step' \<top> C1 \<le> step' \<top> C2"
by (metis mono_step' order_refl)
end
end
|
module Text.PrettyPrint.Prettyprinter.Util
import Data.List
import Data.String
import Text.PrettyPrint.Prettyprinter.Doc
import Text.PrettyPrint.Prettyprinter.Render.String
%default total
||| Split an input into word-sized `Doc`.
export
words : String -> List (Doc ann)
words s = map pretty $ map pack (helper (unpack s))
where
helper : List Char -> List (List Char)
helper s =
case dropWhile isSpace s of
[] => []
s' => let (w, s'') = break isSpace s' in
w :: helper (assert_smaller s s'')
||| Insert soft linebreaks between words, so that text is broken into multiple
||| lines when it exceeds the available width.
export
reflow : String -> Doc ann
reflow = fillSep . words
||| Renders a document with a certain width.
export
putDocW : Nat -> Doc ann -> IO ()
putDocW w = renderIO . layoutPretty (record { layoutPageWidth = AvailablePerLine (cast w) 1 } defaultLayoutOptions)
|
# Computing Pi with Colliding Blocks
This notebook attempts to use colliding blocks to calculate the digits of pi, based off a really cool video by 3Blue1Brown
```python
%%html
```
and the paper [Playing Pool with $\pi$](https://www.maths.tcd.ie/~lebed/Galperin.%20Playing%20pool%20with%20pi.pdf) by G. Galperin,
in which a simple problem is described: a block of mass $M$ moves at a constant speed $V$ on a frictionless surface towards a vertical wall. Closer to the wall there is another block of mass $m$ at rest. After the collision, the small block will hit the wall and be reflected back so that the blocks collide again.
If the ratio between the block masses is a power of 100, and the collisions are perfectly elastic, then the total number of collisions $N_\text{collisions}$ (i.e. collisions + reflections) is equal to certain number of digits of $\pi$. Basically, if the masses satisfy the relation $\frac{M}{m} = 100^{d-1}$, then the number of clacks is equal to the first $d$ digits of $\pi$.
## 1. Below is the javascript i attempted to use to get a nice display for the computation simulation
Only problem is that I wanted to try and use a physics engine for the collision calculations. The first one I used is matter.js, but I learned that they don't have continuous collision detection, so when setting the mass of the larger block > 1000kg, the inner mass goes so fast that the engine no longer detects its collisions, and the block just dissapears... I tried again with planck.js, which is a port of box2d and features ccd, however I get a similar problem, where the inner block goes so fast and begins to clip into the larger block at around 1000kg, throwing off the computation.
```python
%%html
```
## 2. Equations and definitions, according to the paper
### Definitions/Conditions
- when the two blocks hit each other we count it as a ***collision***
- when the inner block hits the wall we count it as a ***reflection***
- both collisions and reflections are elastic, so energy and momentum are conserved in these processes
We are interested in the total number of "clacks" given by
\begin{equation}
N_\text{clacks} = N_\text{collisions} + N_\text{reflections} \tag*{(1)}
\end{equation}
**Pre-condition:**
- We initialize the simulation with the large block (of mass $M$) moving at some constant speed $V_0$ before colliding with the small block (of mass $m$) initially at rest.
**Post-condition:**
- The final state of the simulation will have the two blocks moving independently away from the wall, with the large block moving faster than the small block, guaranteeing no further collisions.
### Equations
**Reflections:** before hitting the wall, the small block moves with positive velocity, which is fully reversed after the collision. This can be proven in general by writting the conservation of total energy and momentum:
\begin{eqnarray}
\frac12 mv^2_\text{before} &=& \frac12 mv^2_\text{after}, \tag*{(2)}\\
mv_\text{before} &=& mv_\text{after}, \tag*{(3)}\\
\end{eqnarray}
and velocity is reversed, so
\begin{equation}
v_\text{before} = -v_\text{after} \tag*{(4)}
\end{equation}
**Collisions:** when the blocks collide with one another, their collision is perfectly elastic, so both momentum and energy is conserved, leading to the following:
\begin{align*}
\text{conservation of energy :} \qquad & \frac12 MV^2_k + \frac12 mv^2_k = \frac12 MV^2_{k+1} + \frac12 mv^2_{k+1}, \tag*{(5)}\\
\text{conservation of momentum :} \qquad & MV_k - mv_k = MV_{k+1} + mv_{k+1}. \tag*{(6)}\\
\end{align*}
Doing some work, getting lazy, and using wolfram alpha magic to solve the rest for $V_{k+1}$ and $v_{k+1}$, we get
\begin{align}
v_{k+1} &= \frac{m-M}{m+M}v_k + \frac{2M}{m+M}V_k \tag*{(7)}, \\
V_{k+1} &= \frac{2m}{m+M}v_k + \frac{M-m}{m+M}V_k \tag*{(8)}
\end{align}
which leads to a pretty nice computation for our simulation
## 3. Calculations
```python
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
```
```python
# if collision is between two blocks...
def collision(m, M, vec):
msum = (m + M)
v_1 = (m - M)/float(msum)
v_2 = 2*M/float(msum)
V_1 = 2*m/float(msum)
V_2 = (M - m)/float(msum)
v = v_1*vec[0] + v_2*vec[1] # (eq #7)
V = V_1*vec[0] + V_2*vec[1] # (eq #8)
return v,V
```
```python
# if collision is a reflection...
def reflection(vec):
v = (-1)*vec[0] # reverse velocity of small block (eq #4)
V = vec[1]
return [v, V]
```
```python
# checks whether large block is moving away faster than smaller block, which is our end condition
def checkspeeds(speed1, speed2):
if (speed1 <= 0 and speed2 <=0):
if(abs(speed2) >= abs(speed1)):
return False
return True
```
```python
def run_sim(num_digits):
M = 100**(num_digits-1)
currentVector = [0,1]
ctype = 'C' # the large block will always initially collide with the small block
clackCount = 0
v, V = [], []
while(checkspeeds(currentVector[0], currentVector[1])):
if (ctype == 'C'):
currentVector = collision(1, M, currentVector)
v.append(currentVector[0])
V.append(currentVector[1])
clackCount += 1 # increment counter on collision
ctype = 'R'
elif (ctype == 'R'):
currentVector = reflection(currentVector)
v.append(currentVector[0])
V.append(currentVector[1])
clackCount += 1 # increment counter on collision
ctype = 'C'
return clackCount, v, V
```
```python
print(run_sim(6)[0])
```
314159
```python
print(np.pi)
```
3.141592653589793
it works!
### now to plot the velocities
```python
def plot_velocities(V, v, num_digits, clack_count, linemarkers=True):
M = 100**(num_digits-1)
x = np.arange(0, len(V), 1)
fig, ax1 = plt.subplots()
ax1.set_title('Velocity of each block ($m=1, M={}$)'.format(M), fontsize=16)
colorV = 'g'
colorv = 'b'
ax2 = ax1.twinx()
if linemarkers:
ax1.plot(x, V, 'o-', color=colorV)
ax2.plot(x, v, 'o-', color=colorv)
else:
ax1.plot(x, V, '-', color=colorV)
ax2.plot(x, v, '-', color=colorv)
ax1.grid(False)
ax2.grid(False)
ax1.set_xlabel(r'$k$ (number of collisions)', fontsize=16)
ax1.set_ylabel('velocity large block', fontsize=16, color=colorV)
ax2.set_ylabel('velocity small block', fontsize=16, color=colorv)
Vmax = 1.5
vmax = max(v)*1.1
xmax = max(x)*1.1
ax1.plot([0, xmax], [0, 0], 'k-', lw=1) # y=0 line
ax1.plot([0, 0], [-2*Vmax, 2*Vmax], 'k-', lw=1) # x=0 line
ax1.text(xmax*7/9, 1.3, 'clacks: {}'.format(clack_count), fontsize=16)
ax1.xaxis.set_ticks(np.arange(0, len(V), np.max([1, int(1/7*len(V))])))
ax1.set_xlim(-xmax/50, xmax)
ax1.set_ylim(-Vmax, Vmax)
ax2.set_ylim(-vmax, vmax);
```
```python
clacks, v, V = run_sim(2)
v_1 = np.asarray(v)
V_1 = np.asarray(V)
```
```python
plot_velocities(V_1, v_1,
num_digits=2,
clack_count=clacks,
linemarkers=True)
```
So you can sort of see the makings of a velocity phase diagram, and I probably could have made one if I figured out a way to stretch the axes enough.
## 4. Conclusion
Overall, a pretty cool problem. I learned a lot about elastic collisions (I also did some research on relativistic elastic collisions and learned that the equations I used break down when the speed of the colliding bodies is close to the speed of light), physics engines and their pitfalls, the fact that you can model interesting physics phenomenon with geometry, and also the sheer amount of stuff I can cram into a jupyter notebook.
|
The eLearning Studio is a free to use multimedia space where faculty and graduate students can record themselves lecturing. The facility’s primary function is to enable content creation by faculty members with minimal supervision of ATS Staff. The studio includes a video camera that records directly to a Mac Pro, a lapel microphone, screen capture software, video editing software, a green screen, and a waccom tablet.
ATS Hopes to offer a http://acmsblog.wordpress.com/2014/04/29/thelearningglass/ Learning Glass system in the near future, which will make it much easy to record math and physics lessons.
|
c---------------------------------------------------------------------
c---------------------------------------------------------------------
subroutine setcoeff
c---------------------------------------------------------------------
c---------------------------------------------------------------------
implicit none
include 'applu.incl'
c---------------------------------------------------------------------
c local variables
c---------------------------------------------------------------------
c---------------------------------------------------------------------
c set up coefficients
c---------------------------------------------------------------------
dxi = 1.0d+00 / ( nx0 - 1 )
deta = 1.0d+00 / ( ny0 - 1 )
dzeta = 1.0d+00 / ( nz0 - 1 )
tx1 = 1.0d+00 / ( dxi * dxi )
tx2 = 1.0d+00 / ( 2.0d+00 * dxi )
tx3 = 1.0d+00 / dxi
ty1 = 1.0d+00 / ( deta * deta )
ty2 = 1.0d+00 / ( 2.0d+00 * deta )
ty3 = 1.0d+00 / deta
tz1 = 1.0d+00 / ( dzeta * dzeta )
tz2 = 1.0d+00 / ( 2.0d+00 * dzeta )
tz3 = 1.0d+00 / dzeta
c---------------------------------------------------------------------
c diffusion coefficients
c---------------------------------------------------------------------
dx1 = 0.75d+00
dx2 = dx1
dx3 = dx1
dx4 = dx1
dx5 = dx1
dy1 = 0.75d+00
dy2 = dy1
dy3 = dy1
dy4 = dy1
dy5 = dy1
dz1 = 1.00d+00
dz2 = dz1
dz3 = dz1
dz4 = dz1
dz5 = dz1
c---------------------------------------------------------------------
c fourth difference dissipation
c---------------------------------------------------------------------
dssp = ( max (dx1, dy1, dz1 ) ) / 4.0d+00
c---------------------------------------------------------------------
c coefficients of the exact solution to the first pde
c---------------------------------------------------------------------
ce(1,1) = 2.0d+00
ce(1,2) = 0.0d+00
ce(1,3) = 0.0d+00
ce(1,4) = 4.0d+00
ce(1,5) = 5.0d+00
ce(1,6) = 3.0d+00
ce(1,7) = 5.0d-01
ce(1,8) = 2.0d-02
ce(1,9) = 1.0d-02
ce(1,10) = 3.0d-02
ce(1,11) = 5.0d-01
ce(1,12) = 4.0d-01
ce(1,13) = 3.0d-01
c---------------------------------------------------------------------
c coefficients of the exact solution to the second pde
c---------------------------------------------------------------------
ce(2,1) = 1.0d+00
ce(2,2) = 0.0d+00
ce(2,3) = 0.0d+00
ce(2,4) = 0.0d+00
ce(2,5) = 1.0d+00
ce(2,6) = 2.0d+00
ce(2,7) = 3.0d+00
ce(2,8) = 1.0d-02
ce(2,9) = 3.0d-02
ce(2,10) = 2.0d-02
ce(2,11) = 4.0d-01
ce(2,12) = 3.0d-01
ce(2,13) = 5.0d-01
c---------------------------------------------------------------------
c coefficients of the exact solution to the third pde
c---------------------------------------------------------------------
ce(3,1) = 2.0d+00
ce(3,2) = 2.0d+00
ce(3,3) = 0.0d+00
ce(3,4) = 0.0d+00
ce(3,5) = 0.0d+00
ce(3,6) = 2.0d+00
ce(3,7) = 3.0d+00
ce(3,8) = 4.0d-02
ce(3,9) = 3.0d-02
ce(3,10) = 5.0d-02
ce(3,11) = 3.0d-01
ce(3,12) = 5.0d-01
ce(3,13) = 4.0d-01
c---------------------------------------------------------------------
c coefficients of the exact solution to the fourth pde
c---------------------------------------------------------------------
ce(4,1) = 2.0d+00
ce(4,2) = 2.0d+00
ce(4,3) = 0.0d+00
ce(4,4) = 0.0d+00
ce(4,5) = 0.0d+00
ce(4,6) = 2.0d+00
ce(4,7) = 3.0d+00
ce(4,8) = 3.0d-02
ce(4,9) = 5.0d-02
ce(4,10) = 4.0d-02
ce(4,11) = 2.0d-01
ce(4,12) = 1.0d-01
ce(4,13) = 3.0d-01
c---------------------------------------------------------------------
c coefficients of the exact solution to the fifth pde
c---------------------------------------------------------------------
ce(5,1) = 5.0d+00
ce(5,2) = 4.0d+00
ce(5,3) = 3.0d+00
ce(5,4) = 2.0d+00
ce(5,5) = 1.0d-01
ce(5,6) = 4.0d-01
ce(5,7) = 3.0d-01
ce(5,8) = 5.0d-02
ce(5,9) = 4.0d-02
ce(5,10) = 3.0d-02
ce(5,11) = 1.0d-01
ce(5,12) = 3.0d-01
ce(5,13) = 2.0d-01
return
end
|
/*
* Copyright Andrey Semashev 2019.
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or copy at
* https://www.boost.org/LICENSE_1_0.txt)
*/
/*!
* \file keywords/auto_newline_mode.hpp
* \author Andrey Semashev
* \date 23.06.2019
*
* The header contains the \c auto_newline_mode keyword declaration.
*/
#ifndef BOOST_LOG_KEYWORDS_AUTO_NEWLINE_MODE_HPP_INCLUDED_
#define BOOST_LOG_KEYWORDS_AUTO_NEWLINE_MODE_HPP_INCLUDED_
#include <boost/parameter/keyword.hpp>
#include <boost/log/detail/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
namespace boost {
BOOST_LOG_OPEN_NAMESPACE
namespace keywords {
//! The keyword for passing automatic trailing newline insertion mode to a sink backend initialization
BOOST_PARAMETER_KEYWORD(tag, auto_newline_mode)
} // namespace keywords
BOOST_LOG_CLOSE_NAMESPACE // namespace log
} // namespace boost
#endif // BOOST_LOG_KEYWORDS_AUTO_NEWLINE_MODE_HPP_INCLUDED_
|
If $S$ is a nonempty set of real numbers that is bounded above, then the supremum of $S$ is in the closure of $S$. |
theory Benchmark_Set
imports
"HOL-Library.Word"
"HOL-Library.Cardinality"
begin
instantiation word :: (len) card_UNIV begin
definition "finite_UNIV = Phantom('a word) True"
definition "card_UNIV = Phantom('a word) (2 ^ LENGTH('a))"
instance by(intro_classes)(simp_all add: card_UNIV_word_def card_word finite_UNIV_word_def)
end
definition word_of_integer :: "integer \<Rightarrow> 'a::len word"
where "word_of_integer = word_of_int \<circ> int_of_integer"
lemma word_of_integer_code [code]:
"word_of_integer k =
(if k < 0 then - word_of_integer (- k)
else if k = 0 then 0
else let (q, r) = divmod_integer k 2
in if r = 0 then 2 * word_of_integer q else 2 * word_of_integer q + 1)"
apply (unfold word_of_integer_def)
apply transfer
apply (auto simp add: not_less comp_def split_beta)
apply (subst int_of_integer_code)
apply (clarsimp simp add: divmod_integer_def)
done
definition word_of :: "natural \<Rightarrow> 'a::len word"
where "word_of = word_of_integer o integer_of_natural"
text \<open>randomly generate a set of (up to) n elements drawn from 0 to bound\<close>
fun gen_build1 :: "natural \<Rightarrow> nat \<Rightarrow> (32 word set \<times> Random.seed) \<Rightarrow> (32 word set \<times> Random.seed)"
where
"gen_build1 bound n (A, seed) =
(if n = 0 then (A, seed)
else let (x, seed') = Random.range bound seed in gen_build1 bound (n - 1) (insert (word_of x) A, seed'))"
declare gen_build1.simps[simp del]
definition build1 :: "natural \<Rightarrow> Random.seed \<Rightarrow> (32 word set \<times> Random.seed)"
where
"build1 bound seed =
(let (n', seed') = Random.range bound seed;
(compl, seed'') = Random.range 2 seed;
(x, seed''') = gen_build1 bound (Code_Numeral.nat_of_natural n') ({}, seed'')
in (if compl = 0 then x else - x, seed'''))"
text \<open>randomly generate a set of (up to) n sets each with a random number between 0 and bound of elements between 0 and bound\<close>
fun gen_build2 :: "natural \<Rightarrow> nat \<Rightarrow> (32 word set set \<times> Random.seed) \<Rightarrow> (32 word set set \<times> Random.seed)"
where
"gen_build2 bound n (A, seed) =
(if n = 0 then (A, seed)
else let (x, seed') = build1 bound seed
in gen_build2 bound (n - 1) (insert x A, seed'))"
declare gen_build2.simps[simp del]
definition build :: "nat \<Rightarrow> nat \<Rightarrow> Random.seed \<Rightarrow> 32 word set set \<times> Random.seed"
where "build n m seed = gen_build2 (of_nat m) n ({}, seed)"
fun gen_lookup :: "32 word set set \<Rightarrow> natural \<Rightarrow> nat \<Rightarrow> (nat \<times> Random.seed) \<Rightarrow> (nat \<times> Random.seed)"
where
"gen_lookup A bound n (hits, seed) =
(if n = 0 then (hits, seed)
else let (x, seed') = build1 bound seed
in gen_lookup A bound (n - 1) (if x : A then hits + 1 else hits, seed'))"
declare gen_lookup.simps [simp del]
primrec lookup :: "nat \<Rightarrow> nat \<Rightarrow> (32 word set set \<times> Random.seed) \<Rightarrow> (nat \<times> Random.seed)"
where "lookup n m (A, seed) = gen_lookup A (of_nat m) 100 (0, seed)"
definition covered :: "32 word set set \<Rightarrow> nat"
where "covered A = card (\<Union>A)"
definition complete :: "nat \<Rightarrow> nat \<Rightarrow> Random.seed \<Rightarrow> (nat \<times> nat)"
where "complete n m seed = (let (A, seed') = build n m seed in (fst (lookup n m (A, seed)), covered A))"
end
|
lemma mem_interior: "x \<in> interior S \<longleftrightarrow> (\<exists>e>0. ball x e \<subseteq> S)" |
module snoc where
open import unit
open import empty
open import bool
open import product
data Snoc (A : Set) : Set where
[] : Snoc A
_::_ : Snoc A → A → Snoc A
infixl 6 _::_ _++_
[_] : {A : Set} → A → Snoc A
[ x ] = [] :: x
_++_ : {A : Set} → Snoc A → Snoc A → Snoc A
[] ++ l₂ = l₂
(l₁ :: x) ++ l₂ = (l₁ ++ l₂) :: x
member : {A : Set} → (A → A → 𝔹) → A → Snoc A → 𝔹
member _=A_ x (l :: y) with x =A y
... | tt = tt
... | ff = ff
member _=A_ x _ = ff
inPairSnocFst : {A B : Set} → (A → A → 𝔹) → A → Snoc (A × B) → Set
inPairSnocFst _=A_ x [] = ⊥
inPairSnocFst _=A_ x (l :: (a , _)) with x =A a
... | tt = ⊤
... | ff = inPairSnocFst _=A_ x l
|
Student Focus was one of two main political parties on campus before being replaced by the GO slate. (The other one being L.E.A.D..) when it comes to ASUCD elections. Fraternities and Sororities have been commonly associated with Student Focus candidates, and some go so far as to refer to Focus as the greek slate. However, in recent elections, this has been the exception rather than the rule. They are also well known for their Student Focus Hold Em yellow glossy flyers. What causes the Partys focus on shiny yellow flyers is as unknown as the structure of its internal decision making apparatus. Chris Herold called the shots after the departure of Kalen Gallagher.
The Focus Slate slate got a lot of flack about Campaigning in Dorms Controversy breaking the election rules during the elections of Fall 2004, and this contributed to the resignation of two of the winning senators. However, as is the case in every ASUCD election, this batch of candidates is different than the ones that came before them. In the last (Fall 2006 Election) Student focus supporters were removed from the dorms for unwanted solicitation.
Student Focus was instrumental in passing the Campus Expansion Initiative in 2003, which allowed UCD to Move to D1 (NCAA Division I athletics).
Student Focus grew from an alliance of Student Action and UNITE, which fell out of power when L.E.A.D. won the Winter 2000 ASUCD Executive Office election. All of the Student Focus elected officials from the Fall 2006 ASUCD election and the Winter 2007 ASUCD election (Molly Sundstrom, Alexandra Frick, Mara Harris, Cem Turhal, Eric Friedman) and former Student Focus Senator Natalia Farhad Motamed have reorganized as the GO slate. Student Focus also lost Commission Chair Pete Markevich when he became Independent and was succeeded by Christine Pham. Rumor has it that the Student Focus name will continue.
Party Statement
Student Focus is one of the two main political parties on campus. Student Focus brings attention back to students attending the University of California, Davis. With UCD being the largest and most diverse university within the UC system, Student Focus realizes the necessity of making sure that the campus is running smoothly and as efficiently as possible. Paying close attention to Unit activities, fiscal responsibility, student representation, campus pride and working with the city of Davis and campus facilities are key values of Student Focus.
We are here to represent YOU and make sure that YOU are equipped with every tool needed to maximize your experience here at UCD!
Winter 2008 Candidates
Executive: Joseph Bleckman/Andrea Thomas
Senate: Greg Webb
Greg is not officially running under Student Focus, but he is known as the last person in ASUCD to still rock the yellow on a regular basis. Many former Student Focus members are ecstatic that he is keeping the legacy alive.
Joseph and Andrea sported the yellow during their run for exec office.
Random people are spotted sporting yellow shirts, perhaps there will be a return of Focus someday.
OMG StuFo is back!
Winter 2007 Candidates
President: Spencer Higgins
VicePresident: Tiny Sanders
Senators:
Molly Sundstrom (Elected)
Pete Markevich
Cem Turhal (Elected)
Lorig Kalfayan
Billy Durham
James Adams
Joseph Bleckman
Greg Webb
/Platform Winter 2007 Platform
Previous platforms and candidates
Student Focus Platform Previous Student Focus platforms
/Prior Candidates Previous Student focus candidates
Student Focus II
Flyers promoting a Student Focus II Student Focus group have been circulating in the Education departments sector of campus, which coincides with the rumors of Student Focus executives fleeing to the south campus following their fall from power in 2005.
See also /Original Student Focus/Original.
20061030 00:00:39 nbsp no one ever spoke to me about increasing the number of quad shows on campus...and im pretty sure things like that are under the Entertainment Councils jurisdiction. to say it bluntly, guys...i really think it is unwise to make promises that you have yet to even consider or discuss about with certain individuals who can make it happen. Users/EmilyTung
Well obviously they will have a chat with you once they are elected. Users/SteveOstrowski
Student Focus has also come under fire recently for proposed cuts to our student lobby efforts. Users/PaulHarms
I actually talked with Pete Markevich about this while we were in his car on the way to SF for the Regents Meeting (for ASUCD Lobby Corps Lobby Corps). The way he explained the situation was that if the company we are receiving training from is successful at their job, then eventually we can reduce the amount we are paying them and become more and more self sufficient, teaching each other the skills they are currently teaching us. This seems pretty logical to me, and I hope that turns out to be their proposition. I would not support, say, money going from Lobby Corps to Aggie Pack. Then again, I can be unpopular like that. Users/MaxMikalonis
On the flip side of that, it wouldnt make sence to keep using that firm if they werent successful in boosting the Corps skills. Users/JosephBleckman
Good thing they talked to the Lobby Corps folks about this idea.... oh wait they didnt. It would also make sense if students didnt graduate every 4 years or move on to different stuff after a year or two. You can only build up to a certain amount of experience in a student organization before there is a completely new bunch of students. Having a longterm, very well experienced advisor, the private firm, for Lobby Corps will go a long way for not just Davis students but all UC students. However, the point is, they made it an issue without talking to the right people and now those people are mad. James Schwab
No offense to Pete, but I dont think he understands exactly what our lobby firm does for us. They do so much more for us than train us. Plus, the day we have nothing to learn from professional lobbyists is the day Ill support reducing our funding to our lobby contract. Users/PaulHarms
I think its a bit premature to state that Student Focus will cut anything unless they specifically say so on their platform objectives or stated so in a public forum or newspaper. Users/SteveOstrowski
Where do you guys get this faulty information?... Seriously, rumors dont become fact once their published on the Wiki. We dont want to cut Lobby Corps. The comment in question, made by one of our senate candidates, had to deal more with our old lobbying through UCSA. He really just wants to work with lobby corps to make sure that their lobbying focus remains student oriented. Users/SpencerHiggins
|
(*-------------------------------------------*
| DFP package |
| June 2005 |
| December 2005 (modified) |
| |
| DFP on CSP-Prover ver.3.0 |
| September 2006 (modified) |
| April 2007 (modified) |
| |
| CSP-Prover on Isabelle2016 |
| May 2016 (modified) |
| |
| Yoshinao Isobe (AIST JAPAN) |
*-------------------------------------------*)
theory DFP_subseteqEX
imports CSP_F_Main
begin
datatype Event = left real | right "real * nat"
datatype Name = Empty nat | Full real nat
datatype DFName = DF
primrec
Bufferfun :: "Name => (Name, Event) proc"
where
"Bufferfun (Empty n) = left ? r -> $(Full r n)"
|"Bufferfun (Full r n) = right (r,n) -> $(Empty (Suc n))"
overloading Set_Bufferfun ==
"PNfun :: (Name, Event) pnfun"
begin
definition "PNfun == Bufferfun"
end
(*****************************************************************
1. safe subsets of [[P]]F, used for deadlock-free verification.
*****************************************************************)
(*********************************************************
safe cut of [[_]]F
This is used for deadlock-free verification.
*********************************************************)
definition
restRefusal :: "'a setF => 'a event set => 'a failure set"
("(0_/ restRefusal /_)" [52,990] 52)
where
restRefusal_def :
"F restRefusal A == {(s,Y)| s Y. (s,Y) :f F & Y <= A}"
definition
subseteqEX :: "'a failure set => 'a failure set => bool"
("(0_/ <=EX /_)" [50,50] 50)
where
subseteqEX_def :
"F <=EX E == (F <= E) & (ALL s Y. (s,Y) : E --> (EX Z. (s,Z) : F & Y <= Z))"
(*********************************************************
subseteqEX & restRefusal
*********************************************************)
lemma subseteqEX_reflex[simp]: "F <=EX F"
apply (simp add: subseteqEX_def)
apply (auto)
done
lemma subseteqEX_Int:
"F restRefusal A = {(s,Y Int A)|s Y. (s,Y) :f F}"
apply (simp add: restRefusal_def)
apply (auto)
apply (rule memF_F2)
apply (simp)
apply (fast)
done
lemma subseteqEX_restRefusal_iff:
"(F <=EX E restRefusal A)
= ((ALL s Y. (s, Y) : F --> (s, Y) :f E & Y <= A) &
(ALL s Y. (s, Y) :f E --> (EX Z. (s, Z) : F & Y Int A <= Z)))"
apply (simp add: subseteqEX_def)
apply (simp add: restRefusal_def)
apply (rule iffI)
(* --> *)
apply (rule conjI)
apply (intro allI impI)
apply (elim conjE)
apply (erule subsetE)
apply (drule_tac x="(s,Y)" in bspec, simp)
apply (simp)
apply (intro allI impI)
apply (elim conjE)
apply (drule_tac x="s" in spec)
apply (drule_tac x="Y Int A" in spec)
apply (drule mp)
apply (rule conjI)
apply (rule memF_F2, simp_all)
apply (fast)
(* <-- *)
apply (fast)
done
(*********************************************************
How to prove F <=EX ([[P]]F restRefusal A)
*********************************************************)
(*--------------------*
| DIV |
*--------------------*)
lemma subseteqEX_DIV[simp]: "{} <=EX failures (DIV) MF restRefusal A"
apply (simp add: subseteqEX_def)
apply (simp add: restRefusal_def)
apply (simp add: in_failures)
done
(*-----------*
| csp rules |
*-----------*)
lemma cspF_subseteqEX_DIV:
"P =F DIV ==> {} <=EX failures (DIV) MF restRefusal A"
by (simp add: eqF_def)
(*--------------------*
| Int_choice |
*--------------------*)
(* eq *)
lemma subseteqEX_Int_choice:
"[| F1 <=EX failures P1 MF restRefusal A ;
F2 <=EX failures P2 MF restRefusal A |]
==> F1 Un F2 <=EX failures (P1 |~| P2) MF restRefusal A"
apply (simp add: subseteqEX_restRefusal_iff)
apply (simp add: in_failures)
apply (intro allI impI)
apply (elim conjE)
apply (rule conjI)
apply (rotate_tac 1)
apply (drule_tac x="s" in spec)
apply (drule_tac x="Y" in spec)
apply (fast)
apply (rotate_tac 3)
apply (drule_tac x="s" in spec)
apply (drule_tac x="Y" in spec)
apply (fast)
done
(*-----------*
| csp rules |
*-----------*)
lemma cspF_subseteqEX_Int_choice:
"[| P =F P1 |~| P2 ;
F = F1 Un F2 ;
F1 <=EX failures P1 MF restRefusal A ;
F2 <=EX failures P2 MF restRefusal A |]
==> F <=EX failures P MF restRefusal A"
apply (simp add: eqF_def)
apply (simp add: eqF_decompo)
apply (simp add: subseteqEX_Int_choice)
done
(*------------------------*
| Rep_int_choice_nat |
*------------------------*)
(* eq *)
lemma subseteqEX_Rep_int_choice_nat:
"[| ALL n : N. Ff n <=EX failures(Pf n) MF restRefusal A |]
==> Union {(Ff n)|n. n : N} <=EX failures (!nat :N .. Pf) MF restRefusal A"
apply (simp add: subseteqEX_restRefusal_iff)
apply (simp add: in_failures)
apply (rule conjI)
(* 1 *)
apply (force)
(* 2 *)
apply (intro allI impI)
apply (elim conjE bexE)
apply (drule_tac x="n" in bspec, simp)
apply (elim conjE)
apply (rotate_tac -1)
apply (drule_tac x="s" in spec)
apply (drule_tac x="Y" in spec)
apply (auto)
done
(*-----------*
| csp rules |
*-----------*)
lemma cspF_subseteqEX_Rep_int_choice_nat:
"[| P =F !nat :N .. Pf ;
F = Union {(Ff n)|n. n : N} ;
ALL n : N. Ff n <=EX failures(Pf n) MF restRefusal A |]
==> F <=EX failures (!nat :N .. Pf) MF restRefusal A"
by (simp add: subseteqEX_Rep_int_choice_nat)
(*------------------------*
| Rep_int_choice_set |
*------------------------*)
(* eq *)
lemma subseteqEX_Rep_int_choice_set:
"[| ALL X : Xs. Ff X <=EX failures(Pf X) MF restRefusal A |]
==> Union {(Ff X)|X. X : Xs} <=EX failures (!set :Xs .. Pf) MF restRefusal A"
apply (simp add: subseteqEX_restRefusal_iff)
apply (simp add: in_failures)
apply (rule conjI)
(* 1 *)
apply (force)
(* 2 *)
apply (intro allI impI)
apply (elim conjE bexE)
apply (drule_tac x="X" in bspec, simp)
apply (elim conjE)
apply (rotate_tac -1)
apply (drule_tac x="s" in spec)
apply (drule_tac x="Y" in spec)
apply (auto)
done
(*-----------*
| csp rules |
*-----------*)
lemma cspF_subseteqEX_Rep_int_choice_set:
"[| P =F !set :Xs .. Pf ;
F = Union {(Ff X)|X. X : Xs} ;
ALL X : Xs. Ff X <=EX failures(Pf X) MF restRefusal A |]
==> F <=EX failures (!set :Xs .. Pf) MF restRefusal A"
by (simp add: subseteqEX_Rep_int_choice_set)
(* com *)
lemma cspF_subseteqEX_Rep_int_choice_com:
"[| P =F ! :X .. Pf ;
F = Union {(Ff a)|a. a : X} ;
ALL a : X. Ff a <=EX failures(Pf a) MF restRefusal A |]
==> F <=EX failures (! :X .. Pf) MF restRefusal A"
apply (unfold Rep_int_choice_com_def)
apply (rule cspF_subseteqEX_Rep_int_choice_set[of _ _ _ _ "(%X. Ff(the_elem X))"])
apply (auto)
apply (rule_tac x="Ff (the_elem {aa})" in exI)
apply (simp)
apply (rule_tac x="{aa}" in exI)
apply (simp)
done
(* f *)
lemma cspF_subseteqEX_Rep_int_choice_f:
"[| inj f; P =F !<f> :X .. Pf ;
F = Union {(Ff a) |a. a : X} ;
ALL a : X. Ff a <=EX failures(Pf a) MF restRefusal A |]
==> F <=EX failures (!<f> :X .. Pf) MF restRefusal A"
apply (unfold Rep_int_choice_f_def)
apply (rule cspF_subseteqEX_Rep_int_choice_com[of _ _ _ _ "(%x. Ff(inv f x))"])
apply (auto)
apply (rule_tac x="Ff aa" in exI)
apply (simp)
apply (rule_tac x="f aa" in exI)
apply (simp)
done
lemmas cspF_subseteqEX_Rep_int_choice =
cspF_subseteqEX_Rep_int_choice_nat
cspF_subseteqEX_Rep_int_choice_set
cspF_subseteqEX_Rep_int_choice_com
cspF_subseteqEX_Rep_int_choice_f
lemma cspF_subseteqEX_Rep_int_choice_nat_UNIV:
"[| P =F !nat n .. Pf n ;
F = Union {(Ff a) |a. True} ;
ALL a. Ff a <=EX failures(Pf a) MF restRefusal A |]
==> F <=EX failures (!nat n .. Pf n) MF restRefusal A"
apply (insert cspF_subseteqEX_Rep_int_choice_nat[of P UNIV Pf F Ff A])
by (simp_all)
(*--------------------*
| Ext_pre_choice |
*--------------------*)
(* eq *)
lemma subseteqEX_Ext_pre_choice:
"ALL a : X. Ff a <=EX failures (Pf a) MF restRefusal A
==> insert (<>, A - Ev ` X)
{(<Ev a> ^^^ s, Y) |a s Y. (s,Y) : Ff a & a : X}
<=EX failures (? :X -> Pf) MF restRefusal A"
apply (simp add: subseteqEX_restRefusal_iff)
apply (simp add: in_failures)
apply (intro conjI)
(* 1 *)
apply (fast)
(* 2 *)
apply (intro allI impI)
apply (rule conjI)
apply (fast)
apply (intro impI)
apply (elim conjE exE)
apply (drule_tac x="a" in bspec, simp)
apply (elim conjE)
apply (rotate_tac -1)
apply (drule_tac x="sa" in spec)
apply (drule_tac x="Y" in spec)
apply (simp)
done
(*-----------*
| csp rules |
*-----------*)
lemma cspF_subseteqEX_Ext_pre_choice:
"[| P =F ? :X -> Pf ;
F = insert (<>, A - Ev ` X)
{(<Ev a> ^^^ s, Y) |a s Y. (s,Y) : Ff a & a : X} ;
ALL a : X. Ff a <=EX failures (Pf a) MF restRefusal A |]
==> F <=EX failures P MF restRefusal A"
by (simp add: eqF_def eqF_decompo subseteqEX_Ext_pre_choice)
(*-----------*
| csp rules |
*-----------*)
lemma cspF_subseteqEX_eqF:
"[| P =F Q ;
FS <=EX failures Q MF restRefusal A |]
==> FS <=EX failures P MF restRefusal A"
by (simp add: eqF_def eqF_decompo)
(****************** to add them again ******************)
end
|
```python
%load_ext autoreload
from mps.state import *
```
# TIME EVOLUTION
```python
# file: mps/evolution.py
import numpy as np
import scipy.linalg
from numbers import Number
import mps.state
import scipy.sparse as sp
from mps.state import _truncate_vector, DEFAULT_TOLERANCE
```
## Suzuki-Trotter Decomposition
In Suzuki-Trotter decomposition, the Hamiltonians of the nearest neighbor couplings can be decomposed into two non-commuting parts, $H_{\text{odd}} $ and $ H_{\text{even}} $, so that all additive 2-site operators in each part commute with each other.
Let us consider a simple example of tight binding model with on-site potential and decompose the Hamiltonian into 2-site terms, so that $H=\sum_i h_{i,i+1}$.
\begin{equation}
h_{i,i+1} = \left(\frac{\omega}{2} a_i^\dagger a_i \right) + \left(\frac{\omega}{2} a_{i+1}^\dagger a_{i+1} \right) - \left( t a_{i}^\dagger a_{i+1} + \text{h.c.} \right).
\end{equation}
Since $[h_{i,i+1},h_{i+2,i+3}] = 0$, we can group these terms for even and odd $i$, so that $H = H_{\text{odd}} + H_{\text{even}} $.
Note that the local term $ a_i^\dagger a_i$ appears only in one of the groups for $i=1$ and $i=N$. Therefore we need to add two on-site terms $h_1 = \left(\frac{\omega}{2} a_1^\dagger a_1 \right) $ and $h_N = \left(\frac{\omega}{2} a_N^\dagger a_N \right) $, to the corresponding two-site terms. So that $h_{1,2} \rightarrow h_{1,2} + h_1$, and $h_{N-1,N} \rightarrow h_{N-1,N} + h_N$.
And for the first order Suzuki-Trotter decomposition, the evolution operator becomes
\begin{equation}
e^{-i \hat{H} \Delta t} = e^{-i \hat{H}_{\text{odd}} \Delta t} e^{-i \hat{H}_{\text{even}} \Delta t} + O(\Delta t^2).
\end{equation}
`pairwise_unitaries` creates a list of Trotter unitarities corresponding to two-site operators, $U_{i,i+1} = e^{-i h_{i,i+1} \Delta t}$. The Trotter unitarities associated with $\hat{H}_{\text{odd}}$ and $\hat{H}_{\text{even}}$ are applied separately in consecutive sweeps depending on evenodd value passed to TEBD_sweep class:
$$ U = [U_{1,2}, U_{2,3}, U_{3,4}, \dots ]. $$
```python
# file: mps/evolution.py
def pairwise_unitaries(H, δt):
return [scipy.linalg.expm((-1j * δt) * H.interaction_term(k)).
reshape(H.dimension(k), H.dimension(k+1),
H.dimension(k), H.dimension(k+1))
for k in range(H.size-1)]
```
We apply each $U_{i,i+1} = e^{-i h_{i,i+1} \Delta t}$ to two neighbouring tensors, $A_i$ and $A_{i+1}$ simultaneously, as shown below.
The resulting tensor $B$ is a two-site tensor. We split this tensor using the canonical form algorithm defined in [this notebook](File%201c%20-%20Canonical%20form.ipynb).
```python
# file: mps/evolution.py
def apply_pairwise_unitaries(U, ψ, start, direction, tol=DEFAULT_TOLERANCE):
"""Apply the list of pairwise unitaries U onto an MPS state ψ in
canonical form. Unitaries are applied onto pairs of sites (i,i+1),
(i+2,i+3), etc. We start at 'i=start' and move in increasing or
decreasing order of sites depending on 'direction'
Arguments:
U -- List of pairwise unitaries
ψ -- State in canonical form
start -- First site for applying pairwise unitaries
direction -- Direction of sweep.
Returns:
ψ -- MPS in canonical form"""
#print("Apply pairwise unitarities in direction {} and at starting site {} with center {}".format(direction, start, ψ.center))
ψ.recenter(start)
if direction > 0:
newstart = ψ.size-2
for j in range(start, ψ.size-1, +2):
#print('Updating sites ({}, {}), center={}, direction={}'.format(j, j+1, ψ.center, direction))
AA = np.einsum('ijk,klm,nrjl -> inrm', ψ[j], ψ[j+1], U[j])
ψ.update_2site(AA, j, +1, tolerance=tol)
if j < newstart:
ψ.update_canonical(ψ[j+1], +1, tolerance=tol)
#print("New center= {}, new direction = {}".format(ψ.center, direction))
return newstart, -1
else:
newstart = 0
for j in range(start, -1, -2):
#print('Updating sites ({}, {}), center={}, direction={}'.format(j, j+1, ψ.center, direction))
AA = np.einsum('ijk,klm,nrjl -> inrm', ψ[j], ψ[j+1], U[j])
ψ.update_2site(AA, j, -1, tolerance=tol)
if j > 0:
ψ.update_canonical(ψ[j], -1, tolerance=tol)
#print("New center= {}, new direction = {}".format(ψ.center, direction))
return newstart, +1
```
```python
# file: mps/evolution.py
class TEBD_evolution(object):
"""TEBD_evolution is a class that continuously updates a quantum state ψ
evolving it with a Hamiltonian H over intervals of time dt."""
def __init__(self, ψ, H, dt, timesteps=1, order=1, tol=DEFAULT_TOLERANCE):
"""Create a TEBD algorithm to evolve a quantum state ψ with a fixed
Hamiltonian H.
Arguments:
ψ -- Quantum state to be updated. The class keeps a copy.
H -- NNHamiltonian for the evolution
dt -- Size of each Trotter step
timesteps -- How many Trotter steps in each call to evolve()
order -- Order of the Trotter approximation (1 or 2)
tol -- Tolerance in MPS truncation
"""
self.H = H
self.dt = float(dt)
self.timesteps = timesteps
self.order = order
self.tolerance = tol
self.Udt = pairwise_unitaries(H, dt)
if order == 2:
self.Udt2 = pairwise_unitaries(H, dt/2)
if not isinstance(ψ, mps.state.CanonicalMPS):
ψ = mps.state.CanonicalMPS(ψ, center=0)
else:
ψ = ψ.copy()
self.ψ = ψ
if ψ.center <= 1:
self.start = 0
self.direction = +1
else:
self.start = ψ.size-2
self.direction = -1
def evolve(self, timesteps=None):
"""Update the quantum state with `timesteps` repetitions of the
Trotter algorithms."""
#print("Apply TEBD for {} timesteps in the order {}".format(self.timesteps, self.order))
if timesteps is None:
timesteps = self.timesteps
for i in range(self.timesteps):
#print(i)
if self.order == 1:
#print("Sweep in direction {} and at starting site {}".format(self.direction, self.start))
self.start, self.direction = apply_pairwise_unitaries(self.Udt, self.ψ, self.start, self.direction, tol=self.tolerance)
#print("Sweep in direction {} and at starting site {}".format(self.direction, self.start))
self.start, self.direction = apply_pairwise_unitaries(self.Udt, self.ψ, self.start, self.direction, tol=self.tolerance)
else:
self.start, self.direction = apply_pairwise_unitaries(self.Udt2, self.ψ, self.start, self.direction, tol=self.tolerance)
self.start, self.direction = apply_pairwise_unitaries(self.Udt, self.ψ, self.start, self.direction, tol=self.tolerance)
self.start, self.direction = apply_pairwise_unitaries(self.Udt2, self.ψ, self.start, self.direction, tol=self.tolerance)
#print("New direction = {} and new starting site = {}".format(self.direction, self.start))
return self.ψ
def state():
return self.ψ
```
## Error in Suzuki-Trotter decomposition
In the first order Suzuki-Trotter decomposition, evolution operator becomes
\begin{equation}
e^{-i \hat{H} \Delta t} = e^{-i \hat{H}_{\text{odd}} \Delta t} e^{-i \hat{H}_{\text{even}} \Delta t} + O(\Delta t^2).
\end{equation}
Note that after $T/\Delta t$ time steps, the accumulated error is in the order of $\Delta t$.
Higher order Suzuki-Trotter decompositions can be used to reduce error.
# Tests
```python
# file: mps/test/test_TEBD.py
import unittest
import scipy.sparse as sp
import scipy.sparse.linalg
from mps.state import CanonicalMPS
from mps.tools import *
from mps.test.tools import *
from mps.evolution import *
from mps.hamiltonians import make_ti_Hamiltonian, ConstantNNHamiltonian
def random_wavefunction(n):
ψ = np.random.rand(n) - 0.5
return ψ / np.linalg.norm(ψ)
class TestTEBD_sweep(unittest.TestCase):
@staticmethod
def hopping_model(N, t, ω):
a = annihilation(2)
ad = creation(2)
return make_ti_Hamiltonian(N, [t*a, t*ad], [ad, a], local_term = ω*(ad@a))
@staticmethod
def hopping_model_Trotter_matrix(N, t, ω):
#
# Hamiltonian that generates the evolution of the odd hoppings
# and local frequencies
return sp.diags([[t,0]*(N//2), [ω]+[ω/2]*(N-2)+[ω], [t,0]*(N//2)],
offsets=[-1,0,+1], shape=(N,N), dtype=np.float64)
@staticmethod
def hopping_model_matrix(N, t, ω):
return sp.diags([[t]*(N), ω, [t]*(N)], offsets=[-1,0,+1], shape=(N,N))
def inactive_test_apply_pairwise_unitaries(self):
N = 2
tt = -np.pi/2
ω = np.pi
dt = 0.1
#
# Numerically exact solution using Scipy's exponentiation routine
ψwave = random_wavefunction(N)
print(mps.state.wavepacket(ψwave).tovector())
HMat = self.hopping_model_Trotter_matrix(N, tt, ω)
ψwave_final = sp.linalg.expm_multiply(+1j * dt * HMat, ψwave)
print(mps.state.wavepacket(ψwave_final).tovector())
print(HMat.todense())
#
# Evolution using Trrotter
H = self.hopping_model(N, tt, ω)
U = pairwise_unitaries(H, dt)
ψ = CanonicalMPS(mps.state.wavepacket(ψwave))
start = 0
direction = 1
apply_pairwise_unitaries(U, ψ, start, direction, tol=DEFAULT_TOLERANCE)
print(ψ.tovector())
print(np.abs(mps.state.wavepacket(ψwave_final).tovector() - ψ.tovector()))
self.assertTrue(similar(abs(mps.state.wavepacket(ψwave_final).tovector()),
abs(ψ.tovector())))
def test_TEBD_evolution_first_order(self):
#
#
#
N = 19
t = - np.pi/2
ω = np.pi
dt = 1e-6
Nt = int(1000)
#ψwave = random_wavefunction(N)
xx=np.arange(N)
x0 = int(N//2)
w0 = 5
k0 = np.pi/2
#
# Approximate evolution of a wavepacket in a tight-binding model
ψwave = np.exp(-(xx-x0)**2 / w0**2 + 1j * k0*xx)
ψwave = ψwave / np.linalg.norm(ψwave)
Hmat = self.hopping_model_matrix(N, t, ω)
ψwave_final = sp.linalg.expm_multiply(-1j * dt* Nt * Hmat, ψwave)
#
# Trotter solution
ψmps = CanonicalMPS(mps.state.wavepacket(ψwave))
H = self.hopping_model(N, t, ω)
ψmps = TEBD_evolution(ψmps, H, dt, timesteps=Nt, order=1, tol=DEFAULT_TOLERANCE).evolve()
self.assertTrue(similar(abs(mps.state.wavepacket(ψwave_final).tovector()),
abs(ψmps.tovector())))
def test_TEBD_evolution_second_order(self):
#
#
#
N = 21
t = 0.1
ω = 0.5
dt = 1e-6
Nt = int(1000)
#ψwave = random_wavefunction(N)
xx=np.arange(N)
x0 = int(N//2)
w0 = 5
k0 = np.pi/2
#
# Approximate evolution of a wavepacket in a tight-binding model
ψwave = np.exp(-(xx-x0)**2 / w0**2 + 1j * k0*xx)
ψwave = ψwave / np.linalg.norm(ψwave)
Hmat = self.hopping_model_matrix(N, t, ω)
ψwave_final = sp.linalg.expm_multiply(-1j * dt * Nt * Hmat, ψwave)
#
# Trotter evolution
H = self.hopping_model(N, t, ω)
ψmps = CanonicalMPS(mps.state.wavepacket(ψwave))
ψmps = TEBD_evolution(ψmps, H, dt, timesteps=Nt, order=2, tol=DEFAULT_TOLERANCE).evolve()
self.assertTrue(similar(abs(mps.state.wavepacket(ψwave_final).tovector()),
abs(ψmps.tovector())))
```
```python
suite1 = unittest.TestLoader().loadTestsFromNames(['__main__.TestTEBD_sweep'])
unittest.TextTestRunner(verbosity=2).run(suite1);
```
|
Formal statement is: lemma (in finite_measure) finite_measure_mono_AE: assumes imp: "AE x in M. x \<in> A \<longrightarrow> x \<in> B" and B: "B \<in> sets M" shows "measure M A \<le> measure M B" Informal statement is: If $A$ is a subset of $B$ almost everywhere, then the measure of $A$ is less than or equal to the measure of $B$. |
Formal statement is: lemma sup_lexord_commute: "sup_lexord A B k s c = sup_lexord B A k s c" Informal statement is: The lexicographic order on pairs of sets is commutative. |
\section{Upgrading from the 8.4 series to the 8.6 series of HTCondor}\label{sec:to-8.6}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\index{upgrading!items to be aware of}
Upgrading from the 8.4 series of HTCondor to the 8.6 series
will bring new features introduced in the 8.5 series of HTCondor.
These new features include the following (note that this list contains
only the most significant changes; a full list of changes can be
found in the version history:~\ref{sec:History-8-5}):
\begin{itemize}
\item \Condor{q}-related changes:
\begin{itemize}
\item \Condor{q} now defaults to showing only the current user's jobs.
\Ticket{5271}
Similarly, \Condor{qedit} defaults to editing only jobs owned by the
current user.
\Ticket{5889}
(The previous behavior of both commands can be restored by setting
\MacroNI{CONDOR\_Q\_ONLY\_MY\_JOBS} to \Expr{False} --
see ~\ref{param:CondorQOnlyMyJobs}.)
\item \Condor{q} now defaults to batch mode, which produces a single
line of output summarizing a batch of jobs (see~\pageref{batches-of-jobs}).
\Ticket{5708}
(The previous behavior can be restored by setting
\MacroNI{CONDOR\_Q\_DASH\_BATCH\_IS\_DEFAULT} to \Expr{False} --
see ~\ref{param:CondorQDashBatchIsDefault}.)
\item \Condor{q} (and \Condor{history} and \Condor{status}) can now
read and write JSON, XML, and new ClassAd formats
(see~\pageref{man-condor-q}, ~\pageref{man-condor-history},
and ~\pageref{man-condor-status}).
\Ticket{5688}
\Ticket{5844}
\Ticket{5820}
\end{itemize}
\item Job submission-related changes:
\begin{itemize}
\item Added the ability for the \Condor{schedd} to transform
job ClassAds upon job submission
(see section~\ref{sec:Schedd-Config-Job-Transforms}).
\item Added the ability to group jobs into batches, and assign
names to the batches, using the new \Opt{-batch} arguments to
\Condor{submit} and \Condor{submit\_dag}.
\item Added support in the submit language for retrying jobs
if they fail (see~\pageref{condor-submit-max-retries}).
\end{itemize}
\item \Condor{dagman}-related changes:
\begin{itemize}
\item Added the ability to define SCRIPTS, VARS, etc., for all nodes
in a DAG with a single command (see section~\ref{sec:DAGAllNodes}).
\Ticket{5729}
\item Simplified how DAG node priorities work
(see section~\ref{sec:DAG-SetNodePriority}).
This means that existing DAGs that use the node priority feature
will run differently than they have in the past.
\Ticket{4024}
\Ticket{5749}
\item Added the new splice connection feature
(see section~\ref{sec:DAGSpliceConnections}), which
allows more flexible dependencies between splices.
\Ticket{5213}
\end{itemize}
\item HTCondor can now use IPv6 interfaces; it prefers IPv4 if both
IPv4 and IPv6 are available.
\Ticket{5104}
\item HTCondor now has initial support for Singularity containers
(see section~\ref{sec:singularity-support}).
\Ticket{5828}
\item \Condor{status} can now display a single line of output for
each machine (rather than a line per slot).
\Ticket{5596}
\item A number of improvements to the Python bindings including: submission
\Ticket{5666}
\Ticket{4916};
draining
\Ticket{5507};
per-thread security contexts
\Ticket{5632};
Computing-On-Demand support
\Ticket{5130}; and
multiple query support
\Ticket{5187}
\item Jobs can now be submitted to the Slurm batch scheduling system via
the new \SubmitCmdNI{slurm} type in the grid universe.
\Ticket{5515}
\item Numerous improvements to Docker support, including
\Ticket{5680};
\Ticket{5760};
\Ticket{5761};
\Ticket{5750};
\Ticket{5740};
\Ticket{5609};
\Ticket{5456}
\end{itemize}
Upgrading from the 8.4 series of HTCondor to the 8.6 series will
also introduce changes that administrators and users of sites running
from an older HTCondor version should be aware of when planning an upgrade.
Here is a list of items that administrators should be aware of.
\begin{itemize}
\item Shared port (see section~\ref{sec:shared-port-daemon}) is now
enabled by default; set \MacroNI{USE\_SHARED\_PORT} to \Expr{False} to
disable it. Note that this configuration macro does not control the HAD or
replication daemon's use of shared port; use \MacroNI{HAD\_USE\_SHARED\_PORT}
or \MacroNI{REPLICATION\_USE\_SHARED\_PORT} instead. See section
~\ref{sec:HA-configuration} for more details on how to configure HAD (and/or
the replication daemon) to work with shared port, since just activating
shared port without any other configuration change will not work.
\Ticket{3813}
\Ticket{5103}
\item To mitigate performance problems, \MacroNI{LOWPORT} and
\MacroNI{HIGHPORT} no longer restrict outbound port ranges on Windows. To
re-enable this functionality, set \MacroNI{OUT\_LOWPORT} and
\MacroNI{OUT\_HIGHPORT} (see ~\ref{param:OutLowPort} and
~\ref{param:OutHighPort}).
\Ticket{4711}
\item Cgroups (see section~\ref{sec:CGroupTracking}) are now enabled
by default. This means that if you
have partitionable slots, jobs need to get \SubmitCmd{request\_memory}
correct.
\Ticket{5936}
\item By default, \Condor{q} queries only the current user's jobs,
unless the current user is a queue superuser or the
\MacroNI{CONDOR\_Q\_ONLY\_MY\_JOBS} configuration macro is set to
\Expr{False}.
\Ticket{5271}
\item Added support for immutable and protected job attributes, which
makes SUBMIT\_REQUIREMENTS more useful
(see section~\ref{param:ImmutableJobAttrs}).
\Ticket{5065}
\item By default, the \Condor{schedd} no longer changes the ownership
of spooled job files (they remain owned by the submitting user).
\Ticket{5226}
\item When \MacroNI{SEC\_ENABLE\_MATCH\_PASSWORD\_AUTHENTICATION} is set
to \Expr{True}, the related authorizations are now automatically enabled.
\Ticket{5304} (See ~\ref{param:SecEnableMatchPasswordAuthentication}
for details.)
\item The master can now run an administrator-defined script at shutdown;
see section~\ref{param:DefaultMasterShutdownScript} for details.
\Ticket{5590}
\end{itemize}
|
!
! -------------------------------------------------------------
! S I X J 4
! -------------------------------------------------------------
!
! *
! THIS PACKAGE DETERMINES THE VALUES OF 6j COEFFICIENT *
! *
! | JC/2 JE/2 JD/2 | *
! | JB/2 JF/2 4 | *
! *
! *
! Written by G. Gaigalas, *
! Vanderbilt University, Nashville October 1996 *
!
!
SUBROUTINE SIXJ4(JC, JE, JD, JB, JF, ITIK, SI)
!-----------------------------------------------
! M o d u l e s
!-----------------------------------------------
USE vast_kind_param, ONLY: DOUBLE
USE CONSTS_C
!...Translated by Pacific-Sierra Research 77to90 4.3E 10:06:26 11/16/01
!...Switches:
!-----------------------------------------------
! I n t e r f a c e B l o c k s
!-----------------------------------------------
USE ixjtik_I
USE gracah1_I
USE sixj2_I
USE sixj3_I
IMPLICIT NONE
!-----------------------------------------------
! D u m m y A r g u m e n t s
!-----------------------------------------------
INTEGER :: JC
INTEGER :: JE
INTEGER :: JD
INTEGER :: JB
INTEGER :: JF
INTEGER , INTENT(IN) :: ITIK
REAL(DOUBLE) :: SI
!-----------------------------------------------
! L o c a l V a r i a b l e s
!-----------------------------------------------
REAL(DOUBLE) :: A, C, E, D, B, F, X1, X2, X3, S2, S3
!-----------------------------------------------
SI = ZERO
IF (ITIK /= 0) THEN
!
! CHESKED TRIANGULAR CONDITIONS
!
IF (IXJTIK(JC,JE,JD,JB,JF,8) == 0) RETURN
ENDIF
IF (IXJTIK(JC,JE,JD,JB,JF,6) == 0) THEN
CALL GRACAH1 (JC, JE, JF, JB, JD, 8, SI)
IF (MOD(JC + JE + JF + JB,4) /= 0) SI = -SI
ELSE
A = THREE
C = DBLE(JC)*HALF
E = DBLE(JE)*HALF
D = DBLE(JD)*HALF
B = DBLE(JB)*HALF
F = DBLE(JF)*HALF
X1 = A*DSQRT((A + B + E + TWO)*(A - B + E + ONE)*(A + B - E + ONE)*((-&
A) + B + E)*(A + C + F + TWO)*(A - C + F + ONE)*(A + C - F + ONE)*(&
(-A) + C + F))
X2 = (A + ONE)*DSQRT((A + B + E + ONE)*(A - B + E)*(A + B - E)*((-A)&
+ B + E + ONE)*(A + C + F + ONE)*(A - C + F)*(A + C - F)*((-A) + C&
+ F + ONE))
X3 = (TWO*A + ONE)*(TWO*(A*(A + ONE)*D*(D + ONE) - B*(B + ONE)*C*(C + &
ONE) - E*(E + ONE)*F*(F + ONE)) + (A*(A + ONE) - B*(B + ONE) - E*(E&
+ ONE))*(A*(A + ONE) - C*(C + ONE) - F*(F + ONE)))
IF (DABS(X2) < EPS) THEN
S2 = ZERO
ELSE
CALL SIXJ2 (JC, JE, JD, JB, JF, 0, S2)
ENDIF
IF (DABS(X3) < EPS) THEN
S3 = ZERO
ELSE
CALL SIXJ3 (JC, JE, JD, JB, JF, 0, S3)
ENDIF
SI = (X3*S3 - X2*S2)/X1
ENDIF
RETURN
END SUBROUTINE SIXJ4
|
[STATEMENT]
lemma asprod_amult:"0 < z \<Longrightarrow> z *\<^sub>a x = (ant z) * x"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. 0 < z \<Longrightarrow> z *\<^sub>a x = ant z * x
[PROOF STEP]
apply (simp add:asprod_def)
[PROOF STATE]
proof (prove)
goal:
No subgoals!
[PROOF STEP]
done |
from __future__ import print_function
from keras.models import Sequential, Model
from keras.layers import Dense, Activation, Dropout
from keras.layers import LSTM, Input, Flatten, Bidirectional
from keras.layers.normalization import BatchNormalization
from keras.optimizers import Adam
from keras.callbacks import EarlyStopping, ModelCheckpoint
from keras.metrics import categorical_accuracy
import pandas as pd
import numpy as np
import random
import sys
import os
import time
import codecs
import collections
from six.moves import cPickle
import spacy
nlp = spacy.load('en')
data_dir = '/home/irina/winterwell/egbot/data-collection/data'# data directory
save_dir = 'save' # directory to store models
seq_length = 30 # sequence length
sequences_step = 1 #step to create sequences
file_list = ["101"]
vocab_file = os.path.join(save_dir, "words_vocab.pkl")
def create_wordlist(doc):
wl = []
for word in doc:
if word.text not in ("\n","\n\n",'\u2009','\xa0'):
wl.append(word.text.lower())
return wl
wordlist = []
for file_name in file_list:
input_file = os.path.join(data_dir, file_name + ".txt")
#read data
with codecs.open(input_file, "r", encoding="utf-8") as f:
data = f.read()
#create sentences
doc = nlp(data)
wl = create_wordlist(doc)
wordlist = wordlist + wl
# input_file = os.path.join(data_dir, file_name + ".json")
# #read data
# df = pd.read_json(codecs.open(input_file, 'r', 'utf-8')).
# data = df['egbot_answer_body'].values.tolist()
# for ans in data:
# #create sentences
# doc = nlp(ans)
# wl = create_wordlist(doc)
# wordlist = wordlist + wl
# count the number of words
word_counts = collections.Counter(wordlist)
# Mapping from index to word : that's the vocabulary
vocabulary_inv = [x[0] for x in word_counts.most_common()]
vocabulary_inv = list(sorted(vocabulary_inv))
# Mapping from word to index
vocab = {x: i for i, x in enumerate(vocabulary_inv)}
words = [x[0] for x in word_counts.most_common()]
#size of the vocabulary
vocab_size = len(words)
print("vocab size: ", vocab_size)
#save the words and vocabulary
with open(os.path.join(vocab_file), 'wb') as f:
cPickle.dump((words, vocab, vocabulary_inv), f)
#create sequences
sequences = []
next_words = []
for i in range(0, len(wordlist) - seq_length, sequences_step):
sequences.append(wordlist[i: i + seq_length])
next_words.append(wordlist[i + seq_length])
print('nb sequences:', len(sequences))
X = np.zeros((len(sequences), seq_length, vocab_size), dtype=np.bool)
y = np.zeros((len(sequences), vocab_size), dtype=np.bool)
for i, sentence in enumerate(sequences):
for t, word in enumerate(sentence):
X[i, t, vocab[word]] = 1
y[i, vocab[next_words[i]]] = 1
def bidirectional_lstm_model(seq_length, vocab_size):
print('Build LSTM model.')
model = Sequential()
model.add(Bidirectional(LSTM(rnn_size, activation="relu"),input_shape=(seq_length, vocab_size)))
model.add(Dropout(0.6))
model.add(Dense(vocab_size))
model.add(Activation('softmax'))
optimizer = Adam(lr=learning_rate)
callbacks=[EarlyStopping(patience=2, monitor='val_loss')]
model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=[categorical_accuracy])
return model
rnn_size = 256 # size of RNN
batch_size = 32 # minibatch size
seq_length = 30 # sequence length
num_epochs = 50 # number of epochs
learning_rate = 0.001 #learning rate
sequences_step = 1 #step to create sequences
md = bidirectional_lstm_model(seq_length, vocab_size)
md.summary()
#fit the model
callbacks=[EarlyStopping(patience=4, monitor='val_loss'),
ModelCheckpoint(filepath=save_dir + "/" + 'gen_sentences_lstm_model.{epoch:02d}-{val_loss:.2f}.hdf5',\
monitor='val_loss', verbose=0, mode='auto', period=2)]
history = md.fit(X, y,
batch_size=batch_size,
shuffle=True,
epochs=num_epochs,
callbacks=callbacks,
validation_split=0.01)
#save the model
md.save(save_dir + "/" + 'gen_sentences_lstm_model.final.hdf5')
#load vocabulary
print("loading vocabulary...")
vocab_file = os.path.join(save_dir, "words_vocab.pkl")
with open(os.path.join(save_dir, 'words_vocab.pkl'), 'rb') as f:
words, vocab, vocabulary_inv = cPickle.load(f)
vocab_size = len(words)
from keras.models import load_model
# load the model
print("loading model...")
model = load_model(save_dir + "/" + 'gen_sentences_lstm_model.final.hdf5')
def sample(preds, temperature=1.0):
# helper function to sample an index from a probability array
preds = np.asarray(preds).astype('float64')
preds = np.log(preds) / temperature
exp_preds = np.exp(preds)
preds = exp_preds / np.sum(exp_preds)
probas = np.random.multinomial(1, preds, 1)
return np.argmax(probas)
#initiate sentences
seed_sentences = "In brief, to write a history, we must know more than mere facts."
generated = ''
sentence = []
for i in range (seq_length):
sentence.append("a")
seed = seed_sentences.split()
for i in range(len(seed)):
sentence[seq_length-i-1]=seed[len(seed)-i-1]
generated += ' '.join(sentence)
print('Generating text with the following seed: "' + ' '.join(sentence) + '"')
print ()
words_number = 100
#generate the text
for i in range(words_number):
#create the vector
x = np.zeros((1, seq_length, vocab_size))
for t, word in enumerate(sentence):
x[0, t, vocab[word]] = 1.
#print(x.shape)
#calculate next word
preds = model.predict(x, verbose=0)[0]
next_index = sample(preds, 0.34)
next_word = vocabulary_inv[next_index]
#add the next word to the text
generated += " " + next_word
# shift the sentence by one, and and the next word at its end
sentence = sentence[1:] + [next_word]
print(generated)
|
theory Chapter3
imports Main
begin
type_synonym vname = string
datatype aexp = N int | V vname | Plus aexp aexp
type_synonym val = int
type_synonym state = "vname \<Rightarrow> val"
text {* A little syntax magic to write larger states compactly: *}
definition null_state ("<>") where
"null_state \<equiv> \<lambda>x. 0"
syntax
"_State" :: "updbinds => 'a" ("<_>")
translations
"_State ms" == "_Update <> ms"
"_State (_updbinds b bs)" <= "_Update (_State b) bs"
fun aval :: "aexp \<Rightarrow> state \<Rightarrow> val" where
"aval (N n) s = n" |
"aval (V x) s = s x" |
"aval (Plus a1 a2) s = aval a1 s + aval a2 s"
value "aval (Plus (N 3) (V ''x'')) (\<lambda>x.0)"
fun asimp_const :: "aexp \<Rightarrow> aexp" where
"asimp_const (N i) = N i" |
"asimp_const (V x) = V x" |
"asimp_const (Plus a1 a2) =
(case (asimp_const a1, asimp_const a2) of
(N n1, N n2) \<Rightarrow> N (n1 + n2) |
(b1, b2) \<Rightarrow> Plus b1 b2)"
lemma "aval (asimp_const a) s = aval a s"
by (induction a, auto split: aexp.split)
fun plus :: "aexp \<Rightarrow> aexp \<Rightarrow> aexp" where
"plus (N i1) (N i2) = N (i1 + i2)" |
"plus (N i) a = (if i = 0 then a else Plus (N i) a)" |
"plus a (N i) = (if i = 0 then a else Plus a (N i))" |
"plus a1 a2 = Plus a1 a2"
lemma aval_plus: "aval (plus a1 a2) s = aval a1 s + aval a2 s"
apply (induction a1 a2 rule: plus.induct)
apply auto
done
fun asimp :: "aexp \<Rightarrow> aexp" where
"asimp (N n) = N n" |
"asimp (V x) = V x" |
"asimp (Plus a1 a2) = plus (asimp a1) (asimp a2)"
lemma "aval (asimp a) s = aval a s"
apply (induction a)
apply (auto simp: aval_plus)
done
(* Exercise 3.1
To show that asimp_const really folds all subexpressions of the form Plus (N
i) (N j), define a function optimal :: aexp \<Rightarrow> bool that checks that its
argument does not contain a subexpression of the form Plus (N i) (N j). Then
prove optimal (asimp_const a)
*)
fun optimal :: "aexp \<Rightarrow> bool" where
"optimal (Plus (N _) (N _)) = False" |
"optimal _ = True"
lemma "optimal (asimp_const a)"
by (induction a, auto split: aexp.split)
(* Exercise 3.2 *)
fun asimp_constant_total :: "aexp \<Rightarrow> int" where
"asimp_constant_total (N i) = i" |
"asimp_constant_total (V x) = 0 "|
"asimp_constant_total (Plus a1 a2) = asimp_constant_total a1 + asimp_constant_total a2"
fun asimp_remove_constants :: "aexp \<Rightarrow> aexp option" where
"asimp_remove_constants (N i) = None" |
"asimp_remove_constants (V x) = Some (V x)" |
"asimp_remove_constants (Plus a1 a2) =
(case (asimp_remove_constants a1, asimp_remove_constants a2) of
(Some a1P, Some a2P) \<Rightarrow> Some (Plus a1P a2P) |
(None, Some a2P) \<Rightarrow> Some a2P |
(Some a1P, None) \<Rightarrow> Some a1P |
(None, None) \<Rightarrow> None)"
fun full_asimp :: "aexp \<Rightarrow> aexp" where
"full_asimp a =
(case (asimp_constant_total a, asimp_remove_constants a) of
(i, None) \<Rightarrow> N i |
(i, Some a) \<Rightarrow> (if i = 0 then a else Plus a (N i)))"
lemma "aval (full_asimp a) s = aval a s"
apply (induction a)
apply (auto split: aexp.splits option.splits if_splits)
done
(* Exercise 3.3 *)
fun subst :: "vname \<Rightarrow> aexp \<Rightarrow> aexp \<Rightarrow> aexp" where
"subst _ _ (N i) = N i" |
"subst x a (V y) = (if x = y then a else V y)" |
"subst x a (Plus a1 a2) = Plus (subst x a a1) (subst x a a2)"
(* Should evaluate to Plus (N 3) V ''y'' *)
value "subst ''x'' (N 3) (Plus (V ''x'') (V ''y''))"
lemma aval_subst_eq: "aval (subst x a e) s = aval e (s(x:= aval a s))"
by (induction e, auto)
lemma aval_subst_ext: "aval a1 s = aval a2 s \<Longrightarrow> aval (subst x a1 e) s = aval (subst x a2 e) s"
by (auto simp: aval_subst_eq)
(* Exercise 3.4: see Exercise3p4.thy *)
(* Execise 3.5
Define a datatype aexp2 of extended arithmetic expressions that has, in
addition to the constructors of aexp, a constructor for modelling a C-like
post-increment operation x++, where x must be a variable. Define an evaluation
function aval2 :: aexp2 \<Rightarrow> state \<Rightarrow> val \<times> state that returns both the value of
the expression and the new state. The latter is required because post-
increment changes the state.
Extend aexp2 and aval2 with a division operation.
Model partiality of division by changing the return type of aval2 to (val \<times>
state) option. In case of division by 0 let aval2 return None. Division on int
is the infix div
*)
datatype aexp2 = N2 int | V2 vname | Plus2 aexp2 aexp2 | PostInc2 vname | Div2 aexp2 aexp2
(* sseefried: It's not mentioned in the exercise but we have to choose an order in
which to evaluate sub expressions for Plus and Div. We choose left-to-right
So that, for instance in the expression Plus a1 a2, a1 is first evaluated and the
state that arises from that is passed in when evaluating a2
*)
fun aval2 :: "aexp2 \<Rightarrow> state \<Rightarrow> (val \<times> state) option" where
"aval2 (N2 n) s = Some (n, s)" |
"aval2 (V2 x) s = Some (s x, s)" |
"aval2 (Plus2 a1 a2) s =
(case aval2 a1 s of
None \<Rightarrow> None |
Some (n1, s1) \<Rightarrow>
(case aval2 a2 s1 of
None \<Rightarrow> None |
Some (n2, s2) \<Rightarrow> Some (n1 + n2, s2)
)
)" |
"aval2 (PostInc2 x) s = Some (s x, s (x:= s x + 1))" |
"aval2 (Div2 a1 a2) s =
(case aval2 a1 s of
None \<Rightarrow> None |
Some (n1, s1) \<Rightarrow>
(case aval2 a2 s1 of
None \<Rightarrow> None |
Some (n2, s2) \<Rightarrow> (if n2 = 0 then None else Some (n1 div n2, s2))
)
)"
(* Exercise 3.6
The following type adds a LET construct to arithmetic ex- pressions:
datatype lexp = Nl int | Vl vname | Plusl lexp lexp | LET vname lexp lexp
The LET constructor introduces a local variable: the value of LET x e1 e2 is
the value of e2 in the state where x is bound to the value of e1 in the
original state. Define a function lval :: lexp \<Rightarrow> state \<Rightarrow> int that evaluates
lexp expressions. Remember s(x := i).
Define a conversion inline :: lexp \<Rightarrow>
aexp. The expression LET x e1 e2 is inlined by substituting the converted form
of e1 for x in the converted form of e2. See Exercise 3.3 for more on
substitution. Prove that inline is correct w.r.t. evaluation.
*)
datatype lexp = Nl int | Vl vname | Plusl lexp lexp | LET vname lexp lexp
fun lval :: "lexp \<Rightarrow> state \<Rightarrow> int" where
"lval (Nl i) s = i" |
"lval (Vl x) s = s x" |
"lval (Plusl l1 l2) s = lval l1 s + lval l2 s" |
"lval (LET x rhs body) s = lval body (s (x := lval rhs s))"
fun inline :: "lexp \<Rightarrow> aexp" where
"inline (Nl i) = N i" |
"inline (Vl x) = V x" |
"inline (Plusl l1 l2) = Plus (inline l1) (inline l2)" |
"inline (LET x rhs body) = subst x (inline rhs) (inline body)"
value "lval (LET ''x'' (Plusl (Nl 1) (Nl 2)) (Plusl (Vl ''x'') (Nl 3))) (\<lambda>x.0)"
value "inline (LET ''x'' (Plusl (Nl 1) (Nl 2)) (Plusl (Vl ''x'') (Nl 3)))"
(* Wow, this one was hard. I needed to make sure that I was quantifying over an _arbitrary_
state.
Without "arbitrary: s" I got the following goal:
\<And>x rhs body. aval (inline rhs) s = lval rhs s \<Longrightarrow>
aval (inline body) s = lval body s \<Longrightarrow>
aval (inline body) (s(x := lval rhs s)) = lval body (s(x := lval rhs s))
With "arbitrary: s" the goal becomes:
\<And>x rhs body s. (\<And>s. aval (inline rhs) s = lval rhs s) \<Longrightarrow>
(\<And>s. aval (inline body) s = lval body s) \<Longrightarrow>
aval (subst x (inline rhs) (inline body)) s = lval body (s(x := lval rhs s))
The term "aval (subst x (inline rhs) (inline body)) s = lval body (s(x := lval rhs s))" is
first simplified to:
aval (inline body) (s(x := aval (inline rhs) s)) = lval body (s(x := lval rhs s))
and then to:
aval (inline body) (s(x := lval rhs s)) = lval body (s(x := lval rhs s))
(by the first assumption above)
The universal quantification on "s" in the assumptions now helps us. The second assumption
is applied where the quantified "s" is replaced with "s(x := lval rhs s)" and hence we
can discharge this goal.
The book is well written. This issue was already covered in p20-21.
*)
lemma "aval (inline l) s = lval l s"
apply (induction l arbitrary: s rule: inline.induct)
apply (auto simp: aval_subst_eq)
done
datatype bexp = Bc bool | Not bexp | And bexp bexp | Less aexp aexp
fun bval :: "bexp \<Rightarrow> state \<Rightarrow> bool" where
"bval (Bc v) s = v" |
"bval (Not b) s = (\<not> bval b s)" |
"bval (And b1 b2) s = (bval b1 s \<and> bval b2 s)" |
"bval (Less a1 a2) s = (aval a1 s < aval a2 s)"
fun not :: "bexp \<Rightarrow> bexp" where
"not (Bc True) = Bc False" |
"not (Bc False) = Bc True" |
"not b = Not b"
fun "and" :: "bexp \<Rightarrow> bexp \<Rightarrow> bexp" where
"and (Bc True) b = b" |
"and b (Bc True) = b" |
"and (Bc False) b = Bc False" |
"and b (Bc False) = Bc False" |
"and b1 b2 = And b1 b2"
fun less :: "aexp \<Rightarrow> aexp \<Rightarrow> bexp" where
"less (N n1) (N n2) = Bc (n1 < n2)" |
"less a1 a2 = Less a1 a2"
fun bsimp :: "bexp \<Rightarrow> bexp" where
"bsimp (Bc v) = Bc v" |
"bsimp (Not b) = not (bsimp b)" |
"bsimp (And b1 b2) = and (bsimp b1) (bsimp b2)" |
"bsimp (Less a1 a2) = less (asimp a1) (asimp a2)"
(* Exercise 3.7
Define functions Eq, Le :: aexp \<Rightarrow> aexp \<Rightarrow> bexp and
prove bval(Eqa1 a2) s = (aval a1 s = aval a2 s) and
bval (Le a1 a2) s = (aval a1 s \<le> aval a2 s)
*)
(* I've decided to make these constant-folding, but for this I will
require some helper theorems
*)
lemma [simp]: "bval (and b1 b2) s = bval (And b1 b2) s"
by (induction b1 b2 rule: and.induct, auto)
lemma [simp]: "bval (less a1 a2) s = bval (Less a1 a2) s"
by (induction a1 a2 rule: less.induct, auto)
fun Eq :: "aexp \<Rightarrow> aexp \<Rightarrow> bexp" where
"Eq a1 a2 = and (not (less a1 a2)) (not (less a2 a1))"
lemma "bval (Eq a1 a2) s = (aval a1 s = aval a2 s)"
by auto
fun Le :: "aexp \<Rightarrow> aexp \<Rightarrow> bexp" where
"Le a1 a2 = not (less a2 a1)"
lemma "bval (Le a1 a2) s = (aval a1 s \<le> aval a2 s)"
by auto
(* Exercise 3.8
Consider an alternative type of boolean expressions featuring a conditional:
datatype ifexp = Bc2 bool | If ifexp ifexp ifexp | Less2 aexp aexp
First define an evaluation function ifval :: ifexp \<Rightarrow> state \<Rightarrow> bool analogously to bval.
Then define two functions b2ifexp :: bexp \<Rightarrow> ifexp and if2bexp :: ifexp \<Rightarrow> bexp and
prove their correctness, i.e., that they preserve the value of an expression.
*)
datatype ifexp = Bc2 bool | If ifexp ifexp ifexp | Less2 aexp aexp
fun ifval :: "ifexp \<Rightarrow> state \<Rightarrow> bool" where
"ifval (Bc2 b) s = b" |
"ifval (If cond thn els) s = (if (ifval cond s) then (ifval thn s) else (ifval els s))" |
"ifval (Less2 a1 a2) s = (aval a1 s < aval a2 s)"
fun or :: "bexp \<Rightarrow> bexp \<Rightarrow> bexp" where
"or b1 b2 = Not (And (Not b1) (Not b2))" (* de Morgan's Law *)
fun b2ifexp :: "bexp \<Rightarrow> ifexp" where
"b2ifexp (Bc b) = Bc2 b" |
"b2ifexp (Not b) = If (b2ifexp b) (Bc2 False) (Bc2 True)" |
"b2ifexp (And b1 b2) = If (b2ifexp b1) (b2ifexp b2) (Bc2 False)" |
"b2ifexp (Less a1 a2) = Less2 a1 a2"
fun if2bexp :: "ifexp \<Rightarrow> bexp" where
"if2bexp (Bc2 b) = Bc b" |
"if2bexp (If cond thn els) =
or (And (if2bexp cond) (if2bexp thn)) (And (Not (if2bexp cond)) (if2bexp els))" |
"if2bexp (Less2 a1 a2) = Less a1 a2"
value "bval (if2bexp (If (Less2 (N 2) (N 2)) (Bc2 True) (Bc2 False))) (\<lambda>x.0)"
lemma "ifval (b2ifexp b) s = bval b s"
by (induction b arbitrary: s, auto)
lemma "bval (if2bexp b) s = ifval b s"
by (induction b arbitrary: s, auto)
(* Exercise 3.9
Define a new type of purely boolean expressions
datatype pbexp = VAR vname | NOT pbexp | AND pbexp pbexp | OR pbexp pbexp
where variables range over values of type bool:
fun pbval :: "pbexp \<Rightarrow> (vname \<Rightarrow> bool) \<Rightarrow> bool" where
"pbval (VAR x) s = s x" |
"pbval (NOT b) s = (\<not> pbval b s)" |
"pbval (AND b1 b2) s =(pbval b1 s \<and> pbval b2 s)"|
"pbval (OR b1 b2) s = (pbval b1 s \<or> pbval b2 s)"
Define a function is_nnf :: pbexp \<Rightarrow> bool that checks whether a boolean expression is in
NNF (negation normal form), i.e., if NOT is only applied directly to VARs. Also define a
function nnf :: pbexp \<Rightarrow> pbexp that converts a pbexp into NNF by pushing NOT inwards as much as
possible. Prove that nnf preserves the value (pbval (nnf b) s = pbval b s) and returns
an NNF (is_nnf (nnf b)).
An expression is in DNF (disjunctive normal form) if it is in NNF and if no
OR occurs below an AND. Define a corresponding test is_dnf :: pbexp \<Rightarrow> bool. An NNF can be
converted into a DNF in a bottom-up manner. The critical case is the conversion of AND b1 b2.
Having converted b1 and b2, apply distributivity of AND over OR.
Define a conversion function dnf_of_nnf :: pbexp \<Rightarrow> pbexp from NNF to DNF.
Prove that your function preserves the value (pbval (dnf_of_nnf b) s = pbval b s) and
converts an NNF into a DNF (is_nnf b \<Longrightarrow> is_dnf (dnf_of_nnf b))
*)
datatype pbexp = VAR vname | NOT pbexp | AND pbexp pbexp | OR pbexp pbexp
fun pbval :: "pbexp \<Rightarrow> (vname \<Rightarrow> bool) \<Rightarrow> bool" where
"pbval (VAR x) s = s x" |
"pbval (NOT b) s = (\<not> pbval b s)" |
"pbval (AND b1 b2)s = (pbval b1 s \<and> pbval b2 s)"|
"pbval (OR b1 b2) s = (pbval b1 s \<or> pbval b2 s)"
fun is_nnf :: "pbexp \<Rightarrow> bool" where
"is_nnf (VAR _) = True" |
"is_nnf (NOT (VAR _)) = True" |
"is_nnf (NOT b) = False" |
"is_nnf (AND b1 b2) = (is_nnf b1 \<and> is_nnf b2)" |
"is_nnf (OR b1 b2) = (is_nnf b1 \<and> is_nnf b2)"
value "is_nnf (NOT (AND (VAR ''x'') (VAR ''y'')))"
value "is_nnf (AND (AND (NOT (VAR ''x'')) (VAR ''y'')) (OR (VAR ''z'') (NOT (VAR ''a'' ))))"
fun nnf :: "pbexp \<Rightarrow> pbexp" where
"nnf (VAR x) = VAR x" |
"nnf (AND b1 b2) = AND (nnf b1) (nnf b2)" |
"nnf (OR b1 b2) = OR (nnf b1) (nnf b2)" |
"nnf (NOT (VAR x)) = NOT (VAR x)" |
"nnf (NOT (NOT b)) = nnf b" |
"nnf (NOT (AND b1 b2)) = OR (nnf (NOT b1)) (nnf (NOT b2))" |
"nnf (NOT (OR b1 b2)) = AND (nnf (NOT b1)) (nnf (NOT b2))"
value "nnf (NOT (OR (NOT (AND (VAR ''x'') (VAR ''y''))) (VAR ''z'')))"
lemma "is_nnf (nnf b)"
by (induction b rule: nnf.induct, auto)
lemma "pbval (nnf b) s = pbval b s"
by (induction b rule: nnf.induct, auto)
fun is_dnf :: "pbexp \<Rightarrow> bool"
and no_ors :: "pbexp \<Rightarrow> bool" where
"is_dnf (VAR _) = True" |
"is_dnf (NOT b) = is_nnf (NOT b)" |
"is_dnf (AND b1 b2) = (no_ors b1 \<and> no_ors b2 \<and> is_dnf b1 \<and> is_dnf b2)" |
"is_dnf (OR b1 b2) = (is_dnf b1 \<and> is_dnf b2)" |
"no_ors (VAR _) = True" |
"no_ors (NOT b) = no_ors b" |
"no_ors (AND b1 b2) = (no_ors b1 \<and> no_ors b2)" |
"no_ors (OR _ _) = False"
(* left distribute AND A (OR B C)" *)
fun dist :: "pbexp \<Rightarrow> pbexp \<Rightarrow> pbexp" where
"dist a (OR b c) = OR (dist a b) (dist a c)" |
"dist (OR a b) c = OR (dist a c) (dist b c)" |
"dist a b = AND a b"
value "dist (VAR ''a'') (OR (OR (VAR ''x'') (VAR ''y'')) (VAR ''z''))"
fun dnf_of_nnf :: "pbexp \<Rightarrow> pbexp" where
"dnf_of_nnf (VAR x) = VAR x" |
"dnf_of_nnf (NOT b) = NOT b" |
"dnf_of_nnf (OR b1 b2) = OR (dnf_of_nnf b1) (dnf_of_nnf b2)" |
"dnf_of_nnf (AND b1 b2) = dist (dnf_of_nnf b1) (dnf_of_nnf b2)"
value "is_dnf (AND (AND (OR (VAR ''x'') (VAR ''y'')) (VAR ''z'')) (VAR ''a''))"
value "dnf_of_nnf (nnf (NOT (OR (VAR ''x'') (AND (VAR ''y'') (VAR ''z'')))))"
value "dnf_of_nnf (AND (OR (VAR ''x1'') (VAR ''y1'')) (OR (VAR ''x2'') (VAR ''y2'')))"
value "dnf_of_nnf (AND (AND (OR (VAR ''x1'') (VAR ''y1'')) (OR (VAR ''x2'') (VAR ''y2''))) (OR (VAR ''x3'') (VAR ''y3'')))"
value "dnf_of_nnf (AND (OR (OR (VAR ''x'') (VAR ''y'')) (VAR ''z'')) (VAR ''a''))"
(* The order of the equality matters! *)
lemma dist_AND_eq: "pbval (dist a b) s = pbval (AND a b) s"
by (induction a b rule: dist.induct, auto)
lemma "pbval (dnf_of_nnf b) s = pbval b s"
by (induction b rule: dnf_of_nnf.induct, auto simp: dist_AND_eq)
(* This is true because v must be a VAR *)
lemma no_ors_in_NOT_if_nnf: "is_nnf (NOT v) \<Longrightarrow> no_ors v"
by (induction v, auto)
lemma dnf_dist: "is_dnf a \<Longrightarrow> is_dnf b \<Longrightarrow> is_dnf (dist a b)"
by (induction a b rule: dist.induct, auto simp: no_ors_in_NOT_if_nnf)
lemma "is_nnf b \<Longrightarrow> is_dnf (dnf_of_nnf b)"
by (induction b rule: dnf_of_nnf.induct, auto simp: dnf_dist)
(* End of Exercise 3.9 *)
end |
Load LFindLoad.
From lfind Require Import LFind.
From QuickChick Require Import QuickChick.
From adtind Require Import goal33.
Derive Show for natural.
Derive Arbitrary for natural.
Instance Dec_Eq_natural : Dec_Eq natural.
Proof. dec_eq. Qed.
Lemma conj16eqsynthconj2 : forall (lv0 : natural) (lv1 : natural), (@eq natural (plus lv0 lv1) (plus Zero (plus lv1 lv0))).
Admitted.
QuickChick conj16eqsynthconj2.
|
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE RecordWildCards #-}
-- |
-- Module : Statistics.Distribution.Normal
-- Copyright : (c) 2021 Alexander E. Zarebski
-- License : MIT
--
-- Maintainer : [email protected]
-- Stability : experimental
-- Portability : portable
--
-- The lognormal distribution.
module Statistics.Distribution.Lognormal
(
LognormalDistribution
-- * constructors
, lognormalDistr
, lognormalDistrE
) where
import Data.Data (Data, Typeable)
import GHC.Generics (Generic)
import Numeric.MathFunctions.Constants (m_sqrt_2, m_sqrt_2_pi)
import Numeric.SpecFunctions (erf, invErf)
import qualified Statistics.Distribution as D
-- | The lognormal distribution.
data LognormalDistribution = LND {
meanlog :: {-# UNPACK #-} !Double
, sdlog :: {-# UNPACK #-} !Double
} deriving (Eq, Typeable, Data, Generic)
instance D.Distribution LognormalDistribution where
cumulative = cumulative
instance D.ContDistr LognormalDistribution where
logDensity = logDensity
quantile = quantile
instance D.MaybeMean LognormalDistribution where
maybeMean = Just . D.mean
instance D.Mean LognormalDistribution where
mean LND {..} = exp (meanlog + 0.5 * sdlog ** 2.0)
instance D.MaybeVariance LognormalDistribution where
maybeStdDev = Just . D.stdDev
maybeVariance = Just . D.variance
instance D.Variance LognormalDistribution where
variance LND {..} = exp (2.0 * meanlog + sdlog ** 2.0) * (exp (sdlog ** 2.0) - 1)
-- | Create lognormal distribution from parameters.
lognormalDistr :: Double -- ^ Mean of the logarithm
-> Double -- ^ Standard deviation of the logarithm
-> LognormalDistribution
lognormalDistr m sd = maybe (error $ errMsg m sd) id $ lognormalDistrE m sd
-- | Create normal distribution from parameters.
lognormalDistrE :: Double -- ^ Mean of logarithm
-> Double -- ^ Standard deviation of logarithm
-> Maybe LognormalDistribution
lognormalDistrE mln sdln
| sdln > 0 = Just LND { meanlog = mln
, sdlog = sdln
}
| otherwise = Nothing
errMsg :: Double -> Double -> String
errMsg _ sd = "Statistics.Distribution.Lognormal.lognormalDistr: standard deviation must be positive. Got " ++ show sd
logDensity :: LognormalDistribution -> Double -> Double
logDensity LND {..} x = - (log x - meanlog) ** 2.0 / (2 * sdlog ** 2.0) - log (x * sdlog * m_sqrt_2_pi)
cumulative :: LognormalDistribution -> Double -> Double
cumulative LND {..} x = 0.5 * (1 + erf ((log x - meanlog) / (sdlog * m_sqrt_2)))
quantile :: LognormalDistribution -> Double -> Double
quantile LND {..} p
| p == 0 = 0
| p == 1 = inf
| p == 0.5 = exp meanlog
| p > 0 && p < 1 = exp (meanlog + sdlog * m_sqrt_2 * invErf (2 * p - 1))
| otherwise = error $ "Statistics.Distribution.Lognormal.quantile: p must be in [0,1] range. Got: "++show p
where inf = 1/0
|
function k=FibonacciNumInv(n,choice)
%FIBONACCINUMINV Given a real number >=1, determine the k such that
% n==FibonacciNum(k). If n given is not a Fibonacci number,
% then the behaviour is determined by the choice option.
%
%INPUTS: n A scalar or matrix of values for which the argument of
% FibonacciNum is desired, n>=1.
% choice An optional parameter that determines what is returned if n
% is not an exact Fibonacci number. If this parameter is omitted,
% then the default is one (the next lower value).
% 0 means return the closest value.
% 1 means return the next lower value.
% 2 means return the next higher value.
%
%OUTPUTS: k The argument of FibonacciNum that gives n, or an appropriately
% close value selected by the choice option. k will always be
% >=2.
%
%A non-recursive expression for Fibonacci numbers is given in [1] and can
%be inverted. However, due to finite prevision issues, for n in the mid
%70's the value returned can be off. Thus, testing needs to be done for all
%inputs in the choice option to make sure that the proper value is chosen.
%
%REFERENCES:
%[1] Chandra, Pravin and Weisstein, Eric W. "Fibonacci Number." From
% MathWorld--A Wolfram Web Resource.
% http://mathworld.wolfram.com/FibonacciNumber.html
%
%November 2015 David F. Crouse, Naval Research Laboratory, Washington D.C.
%(UNCLASSIFIED) DISTRIBUTION STATEMENT A. Approved for public release.
if(nargin<2||isempty(choice))
choice=1;
end
%The golden ratio.
phi=(1+sqrt(5))/2;
k=fix(log(n*sqrt(5))/log(phi)+(1/2));
%Due to finite precision errors, even if n is a Fibonacci number, k
%might be the correct value, it might be 1 less or it might be 1 too
%much. We will adjust k to deal with the situation. Note that from
%above, k>=2, so there are no issues with k-1 being <1.
switch(choice)
case 0%Return the closest value
valsLower=FibonacciNum(k-1);
valsCur=FibonacciNum(k);
valsUpper=FibonacciNum(k+1);
diffLower=abs(n-valsLower);
diffCur=abs(n-valsCur);
diffUpper=abs(n-valsUpper);
sel=(diffLower<diffCur)&(diffLower<diffUpper);
k(sel)=k(sel)-1;
sel=(valsUpper<diffCur)&(diffUpper<diffLower);
k(sel)=k(sel)+1;
case 1%Return the next lower value.
%We have to do a check, because finite precision error
%above might make k be too large.
valsCur=FibonacciNum(k);
sel=valsCur>n;
k(sel)=k(sel)-1;
case 2%Return the next higher value.
valsCur=FibonacciNum(k);
sel=valsCur<n;
k(sel)=k(sel)+1;
otherwise
error('Unknown choice value specified.')
end
end
%LICENSE:
%
%The source code is in the public domain and not licensed or under
%copyright. The information and software may be used freely by the public.
%As required by 17 U.S.C. 403, third parties producing copyrighted works
%consisting predominantly of the material produced by U.S. government
%agencies must provide notice with such work(s) identifying the U.S.
%Government material incorporated and stating that such material is not
%subject to copyright protection.
%
%Derived works shall not identify themselves in a manner that implies an
%endorsement by or an affiliation with the Naval Research Laboratory.
%
%RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF THE
%SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY THE NAVAL
%RESEARCH LABORATORY FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE ACTIONS
%OF RECIPIENT IN THE USE OF THE SOFTWARE.
|
{-# OPTIONS --without-K #-}
module container.m.from-nat.bisimulation where
open import level
open import sum
open import equality
open import function
open import container.core
open import container.m.coalgebra as MC hiding (IsMor ; _⇒_)
open import container.m.from-nat.coalgebra hiding (X)
open import hott.level
module Def {la lb lc} {C : Container la lb lc} (𝓧 : Coalg C (lb ⊔ lc)) where
open Container C
open Σ 𝓧 renaming (proj₁ to X ; proj₂ to γ)
open MC C using (IsMor ; _⇒_)
-- Σ-closure of an indexed binary relation
Σ₂[_] : (∀ {i} → X i → X i → Set (lb ⊔ lc)) → I → Set _
Σ₂[ _∼_ ] i = Σ (X i) λ x → Σ (X i) λ x′ → x ∼ x′
-- projections
module _ {_∼_ : ∀ {i} → X i → X i → Set _} (i : I) where
Σ₂-proj₁ : Σ₂[ _∼_ ] i → X i
Σ₂-proj₁ = proj₁
Σ₂-proj₂ : Σ₂[ _∼_ ] i → X i
Σ₂-proj₂ = proj₁ ∘' proj₂
Σ₂-proj₃ : (r : Σ₂[ _∼_ ] i) → _∼_ (Σ₂-proj₁ r) (Σ₂-proj₂ r)
Σ₂-proj₃ = proj₂ ∘' proj₂
-- Definition 16 in Ahrens, Capriotti and Spadotti (arXiv:1504.02949v1 [cs.LO])
-- bisimulation definition
record Bisim (_∼_ : ∀ {i} → X i → X i → Set _): Set(lb ⊔ lc ⊔ lsuc la) where
field
α : Σ₂[ _∼_ ] →ⁱ F Σ₂[ _∼_ ]
π₁-Mor : IsMor (_ , α) 𝓧 Σ₂-proj₁
π₂-Mor : IsMor (_ , α) 𝓧 Σ₂-proj₂
𝓑 : Coalg C _
𝓑 = _ , α
π₁ : 𝓑 ⇒ 𝓧
π₁ = _ , π₁-Mor
π₂ : 𝓑 ⇒ 𝓧
π₂ = _ , π₂-Mor
-- Lemma 17 in Ahrens, Capriotti and Spadotti (arXiv:1504.02949v1 [cs.LO])
Δ : Bisim (λ {i} → _≡_)
Δ = record { α = α ; π₁-Mor = π₁-Mor ; π₂-Mor = π₂-Mor }
where α : Σ₂[ _≡_ ] →ⁱ F Σ₂[ _≡_ ]
α i (x , ._ , refl) = proj₁ (γ _ x)
, λ b → (proj₂ (γ _ x) b) , (_ , refl)
π₁-Mor : IsMor (_ , α) 𝓧 _
π₁-Mor = funextⁱ helper
where helper : (i : I) → (p : Σ₂[ _≡_ ] i) → _
helper i (m , ._ , refl) = refl
π₂-Mor : IsMor (_ , α) 𝓧 _
π₂-Mor = funextⁱ helper
where helper : (i : I) → (p : Σ₂[ _≡_ ] i) → _
helper i (m , ._ , refl) = refl
--------------------------------------------------------------------------------
-- coinduction proof principle
module _ {la lb lc} {C : Container la lb lc} where
open Container C
open MC C using (IsMor ; _⇒_)
private
𝓜 : Coalg C (lb ⊔ lc)
𝓜 = 𝓛 C
unfold : ∀ (𝓧 : Coalg C (lb ⊔ lc)) → 𝓧 ⇒ 𝓜
unfold 𝓧 = proj₁ $ lim-terminal C 𝓧
unfold-universal = λ {ℓ} (𝓧 : Coalg C ℓ) → proj₂ (lim-terminal C 𝓧)
open Σ 𝓜 renaming (proj₁ to M ; proj₂ to out) ; open Def 𝓜
module _ {_∼_ : ∀ {i} → M i → M i → Set (lb ⊔ lc)} (B : Bisim _∼_) where
-- Theorem 18 in Ahrens, Capriotti and Spadotti (arXiv:1504.02949v1 [cs.LO])
-- coinduction proof principle
cpp : ∀ {i} {m m′ : M i} → m ∼ m′ → m ≡ m′
cpp {i} p = funext-invⁱ (proj₁ $ apΣ π₁=π₂) i (_ , _ , p)
where open Bisim B
abstract
π₁=π₂ : π₁ ≡ π₂
π₁=π₂ = (sym $ unfold-universal 𝓑 π₁) · unfold-universal 𝓑 π₂
-- In particular, provided that the bisimulation _∼_ is reflexive, we have:
module _ (∼-refl : ∀ {i} {m : M i} → m ∼ m) where
cpp′ : ∀ {i} {m m′ : M i} → m ∼ m′ → m ≡ m′
cpp′ {i} p = cpp p · sym (cpp ∼-refl)
cpp′-inv : ∀ {i} {m m′ : M i} → m ≡ m′ → m ∼ m′
cpp′-inv refl = ∼-refl
cpp′-id : ∀ {i} {m : M i} → cpp′ ∼-refl ≡ refl {x = m}
cpp′-id = left-inverse $ cpp ∼-refl
cpp′-retraction : ∀ {i} {m m′ : M i} (p : m ≡ m′) → cpp′ (cpp′-inv p) ≡ p
cpp′-retraction refl = left-inverse $ cpp ∼-refl
|
function qr=rotqc2qr(qc)
%ROTQC2QR converts a matrix of complex quaternion row vectors into real form
%
% Inputs:
%
% QC(2m,n) mxn matrix of complex-valued quaternions
%
% Outputs:
%
% QR(4m,n) mxn matrix of real-valued quaternions
%
% The complex-valued quaternion [r+j*b a+j*c] becomes [r a b c]
%
% Copyright (C) Mike Brookes 2000-2006
% Version: $Id: rotqc2qr.m 713 2011-10-16 14:45:43Z dmb $
%
% VOICEBOX is a MATLAB toolbox for speech processing.
% Home page: http://www.ee.ic.ac.uk/hp/staff/dmb/voicebox/voicebox.html
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% This program is free software; you can redistribute it and/or modify
% it under the terms of the GNU General Public License as published by
% the Free Software Foundation; either version 2 of the License, or
% (at your option) any later version.
%
% This program is distributed in the hope that it will be useful,
% but WITHOUT ANY WARRANTY; without even the implied warranty of
% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
% GNU General Public License for more details.
%
% You can obtain a copy of the GNU General Public License from
% http://www.gnu.org/copyleft/gpl.html or by writing to
% Free Software Foundation, Inc.,675 Mass Ave, Cambridge, MA 02139, USA.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
[m,n]=size(qc);
i=(1:2:2*m)-mod(0:m-1,2);
qr=zeros(2*m,n);
qr(i,:)=real(qc);
qr(i+2,:)=imag(qc); |
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
#pragma once
#include "arcana/finally_scope.h"
#include "arcana/functional/inplace_function.h"
#include "arcana/utils/algorithm.h"
#include "sorted_vector.h"
#include <gsl/gsl>
#include <iterator>
#include <map>
#include <mutex>
#include <stdint.h>
namespace mira
{
/*
A collection that mimics a coat check. You insert something into it and it gives you a ticket.
Once you're done with the ticket, your item gets removed from the collection.
*/
template<typename T, typename MutexT = std::mutex>
class ticketed_collection
{
using seed_t = int64_t;
struct compare
{
bool operator()(const std::pair<seed_t, T>& left, const std::pair<seed_t, T>& right) const
{
return left.first < right.first;
}
bool operator()(const std::pair<seed_t, T>& left, const seed_t& right) const
{
return left.first < right;
}
};
using storage_t = sorted_vector<std::pair<seed_t, T>, compare>;
struct ticket_functor
{
ticket_functor(seed_t id, MutexT& mutex, storage_t& items)
: m_id{ id }
, m_mutex{ mutex }
, m_items{ items }
{}
void operator()()
{
std::lock_guard<MutexT> guard{ m_mutex };
auto found = m_items.find(
m_id, [](const std::pair<seed_t, T>& left, const seed_t& right) { return left.first == right; });
assert(found != m_items.end() && "ticketed item wasn't found in the collection");
m_items.erase(found);
}
seed_t m_id;
MutexT& m_mutex;
storage_t& m_items;
};
public:
struct iterator
{
using iter_t = typename storage_t::const_iterator;
using difference_type = typename std::iterator_traits<iter_t>::difference_type;
using value_type = T;
using pointer = const value_type*;
using reference = const value_type&;
using iterator_category = std::input_iterator_tag;
explicit iterator(const iter_t& itr)
: m_iter{ itr }
{}
bool operator==(const iterator& other) const
{
return m_iter == other.m_iter;
}
bool operator!=(const iterator& other) const
{
return !(*this == other);
}
iterator& operator++()
{
++m_iter;
return *this;
}
iterator operator++(int)
{
iterator pre{ *this };
++m_iter;
return pre;
}
const T* operator->() const
{
return &m_iter->second;
}
const T& operator*() const
{
return m_iter->second;
}
private:
typename storage_t::const_iterator m_iter;
};
using ticket = gsl::final_action<
stdext::inplace_function<void(), sizeof(ticket_functor), alignof(ticket_functor)>>;
using ticket_scope = finally_scope<ticket>;
ticketed_collection() = default;
ticketed_collection(const ticketed_collection&) = delete;
ticketed_collection& operator=(const ticketed_collection&) = delete;
iterator begin() const
{
return iterator{ m_items.cbegin() };
}
iterator end() const
{
return iterator{ m_items.cend() };
}
auto size() const
{
return m_items.size();
}
auto empty() const
{
return m_items.empty();
}
//
// Inserts an element into the collection and returns a ticket
// that will remove the item on its destruction. The mutex passed
// in should be already locked when calling this method. That same
// mutex will get locked when removing the item from the collection.
//
template<typename ElementT>
ticket insert(ElementT&& element, MutexT& mutex)
{
seed_t id = m_seed++;
m_items.insert(std::pair<seed_t, T>{ id, std::forward<ElementT>(element) });
return ticket{ ticket_functor(id, mutex, m_items) };
}
private:
seed_t m_seed = 0;
storage_t m_items;
};
}
|
/-
Copyright (c) 2018 Mario Carneiro. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Author: Mario Carneiro
Additional equiv and encodable instances for lists, finsets, and fintypes.
-/
import Mathlib.PrePort
import Mathlib.Lean3Lib.init.default
import Mathlib.data.equiv.denumerable
import Mathlib.data.finset.sort
import Mathlib.PostPort
universes u_1 u_2
namespace Mathlib
namespace encodable
def encode_list {α : Type u_1} [encodable α] : List α → ℕ := sorry
def decode_list {α : Type u_1} [encodable α] : ℕ → Option (List α) := sorry
protected instance list {α : Type u_1} [encodable α] : encodable (List α) :=
mk encode_list decode_list sorry
@[simp] theorem encode_list_nil {α : Type u_1} [encodable α] : encode [] = 0 := rfl
@[simp] theorem encode_list_cons {α : Type u_1} [encodable α] (a : α) (l : List α) :
encode (a :: l) = Nat.succ (nat.mkpair (encode a) (encode l)) :=
rfl
@[simp] theorem decode_list_zero {α : Type u_1} [encodable α] : decode (List α) 0 = some [] := rfl
@[simp] theorem decode_list_succ {α : Type u_1} [encodable α] (v : ℕ) :
decode (List α) (Nat.succ v) =
(fun (_x : α) (_y : List α) => _x :: _y) <$> decode α (prod.fst (nat.unpair v)) <*>
decode (List α) (prod.snd (nat.unpair v)) :=
sorry
theorem length_le_encode {α : Type u_1} [encodable α] (l : List α) : list.length l ≤ encode l :=
sorry
def encode_multiset {α : Type u_1} [encodable α] (s : multiset α) : ℕ :=
encode (multiset.sort enle s)
def decode_multiset {α : Type u_1} [encodable α] (n : ℕ) : Option (multiset α) :=
coe <$> decode (List α) n
protected instance multiset {α : Type u_1} [encodable α] : encodable (multiset α) :=
mk encode_multiset decode_multiset sorry
def encodable_of_list {α : Type u_1} [DecidableEq α] (l : List α) (H : ∀ (x : α), x ∈ l) :
encodable α :=
mk (fun (a : α) => list.index_of a l) (list.nth l) sorry
def trunc_encodable_of_fintype (α : Type u_1) [DecidableEq α] [fintype α] : trunc (encodable α) :=
quot.rec_on_subsingleton (finset.val finset.univ)
(fun (l : List α) (H : ∀ (x : α), x ∈ Quot.mk setoid.r l) => trunc.mk (encodable_of_list l H))
finset.mem_univ
/-- A noncomputable way to arbitrarily choose an ordering on a finite type.
It is not made into a global instance, since it involves an arbitrary choice.
This can be locally made into an instance with `local attribute [instance] fintype.encodable`. -/
def fintype.encodable (α : Type u_1) [fintype α] : encodable α :=
trunc.out (trunc_encodable_of_fintype α)
protected instance vector {α : Type u_1} [encodable α] {n : ℕ} : encodable (vector α n) :=
encodable.subtype
protected instance fin_arrow {α : Type u_1} [encodable α] {n : ℕ} : encodable (fin n → α) :=
of_equiv (vector α n) (equiv.symm (equiv.vector_equiv_fin α n))
protected instance fin_pi (n : ℕ) (π : fin n → Type u_1) [(i : fin n) → encodable (π i)] :
encodable ((i : fin n) → π i) :=
of_equiv
(↥(set_of fun (f : fin n → sigma fun (i : fin n) => π i) => ∀ (i : fin n), sigma.fst (f i) = i))
(equiv.pi_equiv_subtype_sigma (fin n) π)
protected instance array {α : Type u_1} [encodable α] {n : ℕ} : encodable (array n α) :=
of_equiv (fin n → α) (equiv.array_equiv_fin n α)
protected instance finset {α : Type u_1} [encodable α] : encodable (finset α) :=
of_equiv (Subtype fun (s : multiset α) => multiset.nodup s)
(equiv.mk (fun (_x : finset α) => sorry)
(fun (_x : Subtype fun (s : multiset α) => multiset.nodup s) => sorry) sorry sorry)
def fintype_arrow (α : Type u_1) (β : Type u_2) [DecidableEq α] [fintype α] [encodable β] :
trunc (encodable (α → β)) :=
trunc.map
(fun (f : α ≃ fin (fintype.card α)) =>
of_equiv (fin (fintype.card α) → β) (equiv.arrow_congr f (equiv.refl β)))
(fintype.equiv_fin α)
def fintype_pi (α : Type u_1) (π : α → Type u_2) [DecidableEq α] [fintype α]
[(a : α) → encodable (π a)] : trunc (encodable ((a : α) → π a)) :=
trunc.bind (trunc_encodable_of_fintype α)
fun (a : encodable α) =>
trunc.bind (fintype_arrow α (sigma fun (a : α) => π a))
fun (f : encodable (α → sigma fun (a : α) => π a)) =>
trunc.mk
(of_equiv
(Subtype
fun (a : α → sigma fun (a : α) => π a) =>
a ∈
set_of fun (f : α → sigma fun (a : α) => π a) => ∀ (i : α), sigma.fst (f i) = i)
(equiv.pi_equiv_subtype_sigma α π))
/-- The elements of a `fintype` as a sorted list. -/
def sorted_univ (α : Type u_1) [fintype α] [encodable α] : List α :=
finset.sort (⇑(encode' α) ⁻¹'o LessEq) finset.univ
theorem mem_sorted_univ {α : Type u_1} [fintype α] [encodable α] (x : α) : x ∈ sorted_univ α :=
iff.mpr (finset.mem_sort (⇑(encode' α) ⁻¹'o LessEq)) (finset.mem_univ x)
theorem length_sorted_univ {α : Type u_1} [fintype α] [encodable α] :
list.length (sorted_univ α) = fintype.card α :=
finset.length_sort (⇑(encode' α) ⁻¹'o LessEq)
theorem sorted_univ_nodup {α : Type u_1} [fintype α] [encodable α] : list.nodup (sorted_univ α) :=
finset.sort_nodup (⇑(encode' α) ⁻¹'o LessEq) finset.univ
/-- An encodable `fintype` is equivalent a `fin`.-/
def fintype_equiv_fin {α : Type u_1} [fintype α] [encodable α] : α ≃ fin (fintype.card α) :=
equiv.trans (fintype.equiv_fin_of_forall_mem_list mem_sorted_univ sorted_univ_nodup)
(equiv.cast sorry)
protected instance fintype_arrow_of_encodable {α : Type u_1} {β : Type u_2} [encodable α]
[fintype α] [encodable β] : encodable (α → β) :=
of_equiv (fin (fintype.card α) → β) (equiv.arrow_congr fintype_equiv_fin (equiv.refl β))
end encodable
namespace denumerable
theorem denumerable_list_aux {α : Type u_1} [denumerable α] (n : ℕ) :
∃ (a : List α), ∃ (H : a ∈ encodable.decode_list n), encodable.encode_list a = n :=
sorry
protected instance denumerable_list {α : Type u_1} [denumerable α] : denumerable (List α) :=
mk denumerable_list_aux
@[simp] theorem list_of_nat_zero {α : Type u_1} [denumerable α] : of_nat (List α) 0 = [] := rfl
@[simp] theorem list_of_nat_succ {α : Type u_1} [denumerable α] (v : ℕ) :
of_nat (List α) (Nat.succ v) =
of_nat α (prod.fst (nat.unpair v)) :: of_nat (List α) (prod.snd (nat.unpair v)) :=
sorry
def lower : List ℕ → ℕ → List ℕ := sorry
def raise : List ℕ → ℕ → List ℕ := sorry
theorem lower_raise (l : List ℕ) (n : ℕ) : lower (raise l n) n = l := sorry
theorem raise_lower {l : List ℕ} {n : ℕ} : list.sorted LessEq (n :: l) → raise (lower l n) n = l :=
sorry
theorem raise_chain (l : List ℕ) (n : ℕ) : list.chain LessEq n (raise l n) := sorry
theorem raise_sorted (l : List ℕ) (n : ℕ) : list.sorted LessEq (raise l n) := sorry
/- Warning: this is not the same encoding as used in `encodable` -/
protected instance multiset {α : Type u_1} [denumerable α] : denumerable (multiset α) :=
mk'
(equiv.mk
(fun (s : multiset α) =>
encodable.encode (lower (multiset.sort LessEq (multiset.map encodable.encode s)) 0))
(fun (n : ℕ) => multiset.map (of_nat α) ↑(raise (of_nat (List ℕ) n) 0)) sorry sorry)
def lower' : List ℕ → ℕ → List ℕ := sorry
def raise' : List ℕ → ℕ → List ℕ := sorry
theorem lower_raise' (l : List ℕ) (n : ℕ) : lower' (raise' l n) n = l := sorry
theorem raise_lower' {l : List ℕ} {n : ℕ} :
(∀ (m : ℕ), m ∈ l → n ≤ m) → list.sorted Less l → raise' (lower' l n) n = l :=
sorry
theorem raise'_chain (l : List ℕ) {m : ℕ} {n : ℕ} : m < n → list.chain Less m (raise' l n) := sorry
theorem raise'_sorted (l : List ℕ) (n : ℕ) : list.sorted Less (raise' l n) := sorry
def raise'_finset (l : List ℕ) (n : ℕ) : finset ℕ := finset.mk ↑(raise' l n) sorry
/- Warning: this is not the same encoding as used in `encodable` -/
protected instance finset {α : Type u_1} [denumerable α] : denumerable (finset α) :=
mk'
(equiv.mk
(fun (s : finset α) =>
encodable.encode
(lower' (finset.sort LessEq (finset.map (equiv.to_embedding (eqv α)) s)) 0))
(fun (n : ℕ) =>
finset.map (equiv.to_embedding (equiv.symm (eqv α))) (raise'_finset (of_nat (List ℕ) n) 0))
sorry sorry)
end denumerable
namespace equiv
/-- The type lists on unit is canonically equivalent to the natural numbers. -/
def list_unit_equiv : List Unit ≃ ℕ := mk list.length (list.repeat Unit.unit) sorry sorry
def list_nat_equiv_nat : List ℕ ≃ ℕ := denumerable.eqv (List ℕ)
def list_equiv_self_of_equiv_nat {α : Type} (e : α ≃ ℕ) : List α ≃ α :=
equiv.trans (equiv.trans (list_equiv_of_equiv e) list_nat_equiv_nat) (equiv.symm e)
end Mathlib |
-- Andreas, 2016-07-28 issue 2120, reported by guillaume
-- {-# OPTIONS -v tc.term.exlam:50 #-}
open import Common.Product
data Nat : Set where
zero : Nat
data Eq {A : Set}(a : A) : A → Set where
refl : Eq a a
postulate _<∣_ : ∀ {X Y : Set} → (X → Y) → X → Y
test : Nat
test = ( λ { (zero , refl) → zero } ) <∣ (zero , zero)
-- WAS: Internal error in Reduce
-- EXPECTED: Proper error, like
--
-- Type mismatch
-- when checking that the pattern refl has type _15 zero
|
\section{Rules}
There are two competing players in the game, black and white. Players alternate
turns, passing is not possible.
\vspace{0.5em}
\underline{\textbf{[L]ion}} is the King of the Jungle. It may not leave castle
around it. Inside castle, it moves and captures as the King in Chess. If there
is a vertical or diagonal line with no pieces between the two lions, the lion
may jump to the other lion and capture it.
\vspace{0.5em}
\underline{\textbf{[Z]ebra}} moves as the Knight in classic chess.
\vspace{0.5em}
\underline{\textbf{[E]lephant}} moves one or two squares in the horizontal or
vertical direction. It may jump over the nearest square (also river) and
capture the piece on the next square.
\vspace{0.5em}
\underline{\textbf{[G]iraffe}} moves without capture one step in any direction
(as the chess King). It can move or capture two steps away in any direction in
a straight line.
\vspace{0.5em}
\underline{\textbf{[C]rocodile}} moves as the King in Chess when on land.
Outside the river it can move straight towards the river (including the river
square) as a rook. Inside the river it move to another river square as a rook.
A crocodile \textbf{cannot} drown.
\vspace{0.5em}
\underline{\textbf{[P]awn}} moves and captures both straight and diagonally
forward. Being on the other side of the river, a~pawn may also move one or two
squares straight back, without the right to capture or jump. If a~pawn moves
to the last row, it is promoted to a~superpawn.
\vspace{0.5em}
\underline{\textbf{[S]uperpawn}} has the additional powers of moving and
capturing one square straight sideways and going one or two square straight
backwards or diagonally backward. When going backwards, it may neither capture
nor jump. A superpawns right to go backwards does not depend on its position:
they may go backwards at both sides and on the river.
\vspace{0.5em}
\underline{\textbf{[M]onkey}} moves as the King in Chess while not capturing.
It captures a piece by jumping over it in any direction to the square
immediately beyond, which must be vacant. A monkey may capture multiple pieces
in the same turn, but is not obliged to do so. Monkey jump can be interrupted
at any time. Once a monkey jumped over a piece, the piece immediately
disappears. If a monkey starts multiple capture being at a river square and
ends at any river square, it immediately drowns. If a monkey starts its jump
on the ground and ends in the river or opposite, it is not drown. Captures
before drowning are legal. The monkey captured opponent's Lion terminates the
move and the game.
\vspace{0.5em}
The object of the game is to win by capturing opponent's Lion as there is only
one King of the Jungle. The game immediately ends when a lion has been
captured. There is no check in Congo, so a lion may move to an attacked
square. Consequently, Congo has no draw by stalemate.
|
library(devtools)
devtools::load_all()
data <- gen.data(deviation = "trigonometric", nsubj = 100, r = 0, M = 10)
times <- seq(-1, 1, length.out = 80) # all possible time points
# Implement the tests
system.time(face.b <- bootstrap.face(data, nbs = 10, argvals.new = times))
face.b$p
face.b$Tn
face.b$bs.approx |
In the summer of 1941 , Wheeler and three of his batteries were assigned to fight against German and Italian forces in the North African Campaign . In September , they set sail from Glasgow aboard the RMS Empress of Russia ; because the Mediterranean was controlled largely by enemy naval forces , they were forced to travel via the Cape of Good Hope , before taking shore leave in Durban . There , Wheeler visited the local kraals to compare them with the settlements of Iron Age Britain . The ship docked in Aden , where Wheeler and his men again took shore leave . They soon reached the British @-@ controlled Suez , where they disembarked and were stationed on the shores of the Great Bitter Lake . There , Wheeler took a brief leave of absence to travel to Jerusalem , where he visited Petrie on his hospital deathbed . Back in Egypt , he gained permission to fly as a front gunner in a Wellington bomber on a bombing raid against Axis forces , to better understand what it was like for aircrew to be fired on by an anti @-@ aircraft battery .
|
\documentclass[12pt]{article}
\begin{document}
\author{Luyu Liu}
\newcounter{para}
\newcommand\para{\par\refstepcounter{para}\thepara\space}
\section*{CSE 5194 WEEK4 - HPC}
\title{CSE 5194 WEEK4 - HPC}
\section{Major components in computing systems}
Processing bottlenecks; I/O interface bottlenecks; Network bottlenecks;
\subparagraph{Processing bottlenecks}
ex: TCP/IP; UDP/IP
\\ Generic architecture for all networks;
\subparagraph{IO interface bottlenecks}
relied on bus-based traditionally. : last mile bottleneck;
PCI and PCIX.
one bit per wire;
Not scalable: cross talk tetween bits; skew between wires; signal integrity.
\subparagraph{network bottlenecks}
Then, ethenet and other: network speeds saturated at around 1 Gbps.
1979 - 1993, people were happy about the netspeed.
\subparagraph{motivation for infiniband and high-speed ethenet}
90s, how to eliminate these bottleneck;
internet is already there, high speed has to connect to that, make sure still work.
\subparagraph{IB trade association}
To design a scalable and high performance communication and IO architacture by taking an integrated view of computing, networking, and storage techonologies.
They want to put things together.
\subparagraph{high-speed ethenet consortium}
10 GE - 100 GE;
To achieve ... while maintaing backward compatibility with ethenet.
If just increase Ethenet, the user won't have methods to move their data to the network. Other bottleneck.
Expensive.
\section{Overcome the bottlenecks}
\paragraph{Internet}
\subparagraph{bottleneck alleviation : infiniband and high speed ethernet}
infiniband: two words: infinite bandwidth.
Bit serial differential signaling: techonologiy: independent paris of wires to transmit independent data (lane)
can replicate each lane: easy to incrase clock speed of lanes.
theoretically, no perceived limit on the bandwidth;
networkd speed accesslation with IB and HSE:
sdr: 2G bit / sec, this is per lane.
DDR: 4 G bit / sec, per lane.
\subparagraph{caabilities of HP netowkrs}
Processor: if communication is needed, should processor handle that, or we assign another.
if you can desing a system that can scale between communication and computation.
Using a sectectory.
intelligent network interface card;
support entire protocol processing completely in hardware.
Provide a rich communication interface to applications.
\subparagraph{previous high-performance network stacks}
Fast messages;
Virtual interface architecture: Virtualprecursor to IB.
\subparagraph{ib hardware acceslation}
Some IB models have multiple hardware accelerators.
Protocol offload engines.
Additional hardware supported features also present; RDMA Multicasst;
\subparagraph{ethenethardware acceleration}
Jumbo frames;
cost of performance data.
TOE and iWARP acceslerators.
TCP offfload engines (TOE)
iWARP:
Going inside it's all RDMA.
\subparagraph{Converged ethernet}
\paragraph{IO bottleneck solutions}
\subparagraph{interplay with io technologies}
Infiniband intitially intended to replace io bus tech with networking like technology.
Enterprise game: change the hardware is hard.
Both IB and HSE today is injected into the IO as a adaptor.
\subparagraph{Trends} Almost the same as the network.
Intel: PCIe.
ALso need a kind of network within the system: QPI
So, before node-to-node tech is going inside the system.
\subparagraph{comparing ib with traditional entworking stack}
Tradtional vs Infiniband:
phisical lyaer: similar
link layer: flow ocntrol:
Only opensm between link and py
transporta: RC and UD: similar to TCP UDP:
sockets interface in traditional: Verbs: bring user communication;
\subparagraph{RCPIP stack vs IPoIB}
sockets takes time: change to verbs for application and middleware.
start at RDMA: In computing, remote direct memory access (RDMA) is a direct memory access from the memory of one computer into that of another without involving either one's operating system. This permits high-throughput, low-latency networking, which is especially useful in massively parallel computer clusters.
Extent the idea: directly access the memory without the node knowing.
Then: userspace.
\subparagraph{components; chanel adapters}
\subparagraph{components; links and repeater}
network links:
traditional adapter built for copper calbing; To short
interl connects: optical cables: 550 picoseconds.
communication within the chanel semantics.
commjnication within the memory semantics:
RDMA: have some trust, just expose some of the memory
Data direcly go into the memory: without going thru QP
\end{document} |
Load LFindLoad.
From lfind Require Import LFind.
From QuickChick Require Import QuickChick.
From adtind Require Import goal33.
Derive Show for natural.
Derive Arbitrary for natural.
Instance Dec_Eq_natural : Dec_Eq natural.
Proof. dec_eq. Qed.
Lemma conj14eqsynthconj4 : forall (lv0 : natural) (lv1 : natural), (@eq natural (mult lv0 lv1) (mult lv1 (plus Zero lv0))).
Admitted.
QuickChick conj14eqsynthconj4.
|
lemma box_ne_empty: fixes a :: "'a::euclidean_space" shows "cbox a b \<noteq> {} \<longleftrightarrow> (\<forall>i\<in>Basis. a\<bullet>i \<le> b\<bullet>i)" and "box a b \<noteq> {} \<longleftrightarrow> (\<forall>i\<in>Basis. a\<bullet>i < b\<bullet>i)" |
#redirect Davis Time Bank
|
-- Andreas, 2016-10-11, AIM XXIV, issue #2250
{-# OPTIONS --injective-type-constructors #-}
open import Common.Prelude
open import Common.Equality
abstract
f : Bool → Bool
f x = true
same : f true ≡ f false
same = refl
-- f should not be treated as injective here,
-- even though f true and f false do not reduce.
not-same : f true ≡ f false → ⊥
not-same () -- should be yellow
absurd : ⊥
absurd = not-same same
|
Formal statement is: lemma poly_isCont[simp]: fixes x::"'a::real_normed_field" shows "isCont (\<lambda>x. poly p x) x" Informal statement is: The function $x \mapsto p(x)$ is continuous at $x$. |
# portfolio.r
#
# Functions for portfolio analysis
# last updated: September 25, 2016 by Ismael Jimenez
#
# Functions:
# 1. efficient.portfolio.risk compute minimum variance portfolio
# subject to target risk
stopifnot("package:quadprog" %in% search() || require("quadprog",quietly = TRUE) )
stopifnot("package:quantmod" %in% search() || require("quantmod",quietly = TRUE) )
source("http://faculty.washington.edu/ezivot/econ424/portfolio_noshorts.r")
efficient.portfolio.risk <- function(er, cov.mat, target.risk, shorts=TRUE)
{
incr <- 0.00001
e.port <- globalMin.portfolio(er, cov.mat, shorts)
currentEr <- as.numeric(e.port["er"])
currentSd <- as.numeric(e.port["sd"])
while(currentSd < target.risk) {
currentEr <- currentEr+incr
e.port <- efficient.portfolio(er, covmat, currentEr, shorts)
currentEr <- as.numeric(e.port["er"])
currentSd <- as.numeric(e.port["sd"])
}
e.port
}
getReturns.monthly = function(ticker, from = "1927-01-01") {
ticker <- getSymbols(ticker, from = as.Date(from))
MonthRet <- monthlyReturn(get(ticker))*100
MonthRet
}
|
Townsend 's employs a variety of vocal techniques in his work , including screaming , growling or even falsetto . His vocal range has been noted to be over 5 octaves ( C2 to F7 ) .
|
%!TEX root = ../thesis.tex
%*******************************************************************************
%****************************** Fourth Chapter **********************************
%*******************************************************************************
\chapter{Conclusion and Outlook}
% **************************** Define Graphics Path **************************
\ifpdf
\graphicspath{{Conclusion/Figs/Raster/}{Conclusion/Figs/PDF/}{Conclusion/Figs/}}
\else
\graphicspath{{Conclusion/Figs/Vector/}{Conclusion/Figs/}}
\fi
No presence of new physics in high $\text{p}_{T}$ of $pp$ collisions has led the search for light and weakly coupled particles with a characteristic long lifetime. These will be searched in the new ForwArd Search ExpeRiment (FASER), a small and inexpensive detector installed in the far forward region of $pp$ collision. FASER will probe new regions of the parameter space that might confirm the existence of Beyond the Standard Model particles such as the axion or the dark photon. FASER has a small 5 m long footprint consisting of magnets, tracker planes, scintillators and a small calorimeter. A trigger and data acquisition system (TDAQ) provides the experiment with trigger and read-out capability using a Trigger Logic Board (TLB) as the main component.
Hardware commissioning and peer-reviewed software development of the TLB has been completed in the context of this master project. As a result, the TLB is now ready to be used for commissioning the FASER experiment. Integration tests with other components of the TDAQ system have taken place in a dedicated laboratory at CERN and further testing is in progress. An important milestone will be cosmic data taking with the TLB providing triggers to read out detector components upon the passage of cosmic rays; this will initially be done using scintillators and calorimeter modules and soon after, with tracker planes.
The TLB is an essential component for FASER’s operation during Run 3. It can be modified to function in the future on the prospective bigger and more advanced FASER 2 experiment that will extend the sensitivity to include new particles produced in heavy meson decays.
|
[STATEMENT]
lemma ResB:
fixes P :: pi
and a :: name
and x :: name
and P' :: pi
and y :: name
assumes PTrans: "P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>x> \<prec> P'"
and yineqa: "y \<noteq> a"
and yineqx: "y \<noteq> x"
and xFreshP: "x \<sharp> P"
shows "<\<nu>y>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>x> \<prec> (<\<nu>y>P')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. <\<nu>y>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>x> \<prec> <\<nu>y>P'
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>x> \<prec> P'
y \<noteq> a
y \<noteq> x
x \<sharp> P
goal (1 subgoal):
1. <\<nu>y>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>x> \<prec> <\<nu>y>P'
[PROOF STEP]
by(auto intro: Weak_Late_Step_Semantics.ResB
simp add: weakTransition_def residual.inject) |
open import SingleSorted.AlgebraicTheory
open import Agda.Primitive using (lzero; lsuc; _⊔_)
open import Relation.Binary.PropositionalEquality using (_≡_; refl)
open import SingleSorted.Substitution
open import Data.Nat using (ℕ; zero; suc; _+_; _*_)
module SingleSorted.Group where
data GroupOp : Set where
e : GroupOp
inv : GroupOp
mul : GroupOp
_ : Context
_ = ctx-empty
_ : Context
_ = ctx-concat ctx-slot ctx-empty
_ : var ctx-slot
_ = var-var
_ : var (ctx-concat ctx-slot ctx-slot)
_ = var-inl var-var
_ : var (ctx-concat ctx-slot ctx-slot)
_ = var-inr var-var
ctx-1 : Context
ctx-1 = ctx-slot
ctx-2 : Context
ctx-2 = ctx-concat ctx-1 ctx-1
ctx : ∀ (n : ℕ) → Context
ctx zero = ctx-empty
ctx (suc n) = ctx-concat (ctx n) ctx-slot
-- the signature of the theory of groups
-- has one constant, one unary operation, one binary operation
Σ : Signature
Σ = record { oper = GroupOp ; oper-arity = λ{ e → ctx-empty ; inv → ctx 1 ; mul → ctx 2} }
open Signature Σ
-- some example terms
_ : Term ctx-1
_ = tm-var var-var
_ : Term ctx-2
_ = tm-var (var-inr var-var)
_ : Term ctx-2
_ = tm-var (var-inr var-var)
-- helper functions for creating terms
e' : ∀ {Γ : Context} → Term Γ
e' {Γ} = tm-oper e λ()
-- inv' : ∀ {Γ : Context} → Term Γ → Term Γ
-- inv' x = tm-oper inv λ{ _ → x}
-- mul' : ∀ {Γ : Context} → Term Γ → Term Γ → Term Γ
-- mul' x y = tm-oper mul λ{ (var-inl _) → x ; (var-inr _) → y}
concat-empty : var (ctx-concat ctx-empty ctx-slot) → (var ctx-slot)
concat-empty (var-inr x) = x
x*y : Term ctx-2
x*y = tm-oper mul λ{ (var-inl x) → tm-var (var-inl (concat-empty x)) ; (var-inr y) → tm-var (var-inr y)}
-- concat-empty-idʳ : ctx-concat ctx-empty ctx-slot ≡ ctx-slot
-- concat-empty-idʳ = {!!}
singleton-context : (var ctx-slot) → var (ctx-concat ctx-empty ctx-slot)
singleton-context (var-var) = var-inr var-var
σ : ∀ {Γ : Context} {t : Term Γ} → Γ ⇒s (ctx 1)
σ {Γ} {t} = λ{ (var-inr var-var) → t}
δ : ∀ {Γ : Context} {t : Term Γ} {s : Term Γ} → Γ ⇒s (ctx 2)
δ {Γ} {t} {s} = λ{ (var-inl x) → t ; (var-inr y) → s}
_∗_ : ∀ {Γ} → Term Γ → Term Γ → Term Γ
t ∗ s = tm-oper mul λ{ xs → δ {t = t} {s = s} xs}
_ⁱ : ∀ {Γ : Context} → Term Γ → Term Γ
t ⁱ = tm-oper inv λ{ x → σ {t = t} x}
-- _∗_ : ∀ {Γ} → Term Γ → Term Γ → Term Γ
-- t ∗ s = tm-oper mul λ{ (var-inl x) → t ; (var-inr args) → s}
-- _ⁱ : ∀ {Γ : Context} → Term Γ → Term Γ
-- t ⁱ = tm-oper inv λ{ x → t }
infixl 5 _∗_
infix 6 _ⁱ
_ : Term (ctx 2)
_ = tm-var (var-inl (var-inr var-var)) ∗ tm-var (var-inr var-var)
_ : Term (ctx 1)
_ = e' ∗ a
where
a : Term (ctx 1)
a = tm-var (var-inr var-var)
-- group equations
data GroupEq : Set where
mul-assoc e-left e-right inv-left inv-right : GroupEq
mul-assoc-ax : Equation
e-left-ax : Equation
e-right-ax : Equation
inv-left-ax : Equation
inv-right-ax : Equation
mul-assoc-ax = record { eq-ctx = ctx 3
; eq-lhs = x ∗ y ∗ z
; eq-rhs = x ∗ (y ∗ z)
}
where
x : Term (ctx 3)
y : Term (ctx 3)
z : Term (ctx 3)
x = tm-var (var-inl (var-inl (var-inr var-var)))
y = tm-var (var-inl (var-inr var-var))
z = tm-var (var-inr var-var)
e-left-ax = record { eq-ctx = ctx 1 ; eq-lhs = e' ∗ x ; eq-rhs = x }
where
x : Term (ctx 1)
x = tm-var (var-inr var-var)
e-right-ax = record { eq-ctx = ctx 1 ; eq-lhs = x ∗ e' ; eq-rhs = x }
where
x : Term (ctx 1)
x = tm-var (var-inr var-var)
inv-left-ax = record { eq-ctx = ctx 1 ; eq-lhs = x ⁱ ∗ x ; eq-rhs = e' }
where
x : Term (ctx 1)
x = tm-var (var-inr var-var)
inv-right-ax = record { eq-ctx = ctx 1 ; eq-lhs = x ∗ x ⁱ ; eq-rhs = e' }
where
x : Term (ctx 1)
x = tm-var (var-inr var-var)
𝒢 : Theory lzero Σ
𝒢 = record { ax = GroupEq
; ax-eq = λ{ mul-assoc → mul-assoc-ax
; e-left → e-left-ax
; e-right → e-right-ax
; inv-left → inv-left-ax
; inv-right → inv-right-ax
}
}
|
"""
Representativeness index calculation functions
"""
import pandas as pd
import scipy as sp
import numpy as np
from scipy import linalg
from lib.methods_formatting import clean_method, orthonormation_method, filter_methods
def representativeness_index_per_category(standardized_methods, standardized_lcis):
"""
Calculates a Representativeness Index per impact category on one or many standardized LCI(s)
:param pd.DataFrame standardized_methods:
Dataframe constituted by one or many method(s) aggregated, ie. constituted by several columns representing
impact categories
:param pd.DataFrame standardized_lcis:
LCI(s) data formatted with standardize_lci()
:return:
Representativeness index per impact category
:rtype: pd.DataFrame
"""
standardized_lcis.fillna(value=0, inplace=True)
standardized_methods.fillna(value=0, inplace=True)
# Checking substance flows (indexes) are the same between lci and method
if all(standardized_methods.index == standardized_lcis.index):
representativeness_index = pd.DataFrame(index=standardized_methods.columns,
columns=standardized_lcis.columns)
for i in range(0, representativeness_index.shape[0]):
residuals = linalg.lstsq(sp.matrix(standardized_methods.iloc[:, i]).T, standardized_lcis)[1]
representativeness_index.iloc[i, :] = sp.cos(sp.real(sp.arcsin(sp.sqrt(residuals)))).T
else:
raise Exception('Substance flows do not match between method and lci.')
return representativeness_index
def representativeness_index_per_method(standardized_methods, methods_names, standardized_lcis):
"""
Calculates a Representativeness Index per method and LCI
:param pd.DataFrame standardized_methods:
Dataframe constituted by one or many method(s) aggregated, ie. constituted by several columns representing
impact categories normalized
:param iterable methods_names:
Iterable constituted by the names of the methods to study
:param pd.DataFrame standardized_lcis:
LCI(s) data formatted with standardize_lci()
:return:
Representativeness index per method
:rtype pd.DataFrame
"""
representativeness_index = pd.DataFrame(columns=standardized_lcis.columns, dtype=float)
standardized_lcis = standardized_lcis.fillna(value=0)
for method_name in methods_names:
method = filter_methods(standardized_methods, method_name)
method_cleaned = clean_method(method)
method_ortho = orthonormation_method(method_cleaned)
residual = linalg.lstsq(method_ortho, standardized_lcis)[1]
emission_norm = pd.DataFrame(index=['norm'], columns=standardized_lcis.columns)
for column in emission_norm.columns:
emission_norm[column] = linalg.norm(standardized_lcis[column])
cos_projection = pd.DataFrame(sp.cos(sp.real(sp.arcsin(sp.sqrt(residual) / (sp.array(emission_norm))))),
dtype='float', columns=standardized_lcis.columns, index=['cos'])
representativeness_index.loc[method_name] = cos_projection.iloc[0, :]
return representativeness_index
def representativeness_index_per_orthogonalized_category(standardized_methods, method_names, standardized_lcis):
"""
Calculates a Representativeness Index per orthogonalized impact category on one or many standardized LCI(s)
:param pd.DataFrame standardized_methods:
Dataframe constituted by one or many method(s) aggregated, ie. constituted by several columns representing
impact categories normalized
:param iterable method_names:
Iterable constituted by the names of the methods to study
:param pd.DataFrame standardized_lcis:
LCI(s) data formatted with standardize_lci()
:return:
Representativeness index per orthogonalized category
:rtype pd.DataFrame
"""
ri_cat_original = representativeness_index_per_category(standardized_methods=standardized_methods,
standardized_lcis=standardized_lcis)
ri_cat_original_sq = ri_cat_original.applymap(np.square)
result = pd.DataFrame(columns=standardized_lcis.columns)
for method_name in method_names:
categories = filter_methods(standardized_methods, method_name)
category_names = categories.columns
# Categories normation
for category in category_names:
categories[category] = categories[category] / linalg.norm(categories[category])
# Calculating correlation matrix
correlation_matrix = pd.DataFrame(index=category_names, columns=category_names)
for j in range(0, correlation_matrix.shape[0]):
for i in range(0, j + 1):
correlation_matrix.iloc[j, i] = abs(categories.iloc[:, i] * categories.iloc[:, j]).sum()
correlation_matrix.iloc[i, j] = abs(categories.iloc[:, i] * categories.iloc[:, j]).sum()
# Reordering categories
ordered_category_names = correlation_matrix.sum().sort_values(ascending=False).index
ordered_categories = categories.loc[:, ordered_category_names]
# Orthonorming categories
orthonormed_categories = orthonormation_method(ordered_categories)
# Calculating RI for orthonormed categories
ri_cat_ortho = representativeness_index_per_category(standardized_methods=orthonormed_categories,
standardized_lcis=standardized_lcis)
ri_cat_ortho_sq = ri_cat_ortho.applymap(np.square)
# Creating a DataFrame containing differences between ri_cat_original and ri_cat_ortho
diff = ri_cat_original_sq.loc[ri_cat_ortho_sq.index, :] - ri_cat_ortho_sq
# Creating a copy of ri_cat_ortho_sq that will be modified to obtain the final result for this method
result_per_method = ri_cat_original_sq.copy(deep=True)
# Looping on ordered categories and lcis to update values in result_per_method
for category in ordered_categories:
correlated_categories = correlation_matrix.loc[:, correlation_matrix.loc[:, category] != 0].columns
correlated_categories_ri = ri_cat_original_sq.loc[correlated_categories, :]
# Looping on lcis
for lci in standardized_lcis.columns:
result_per_method.loc[correlated_categories, lci] -= diff.loc[category, lci] * \
(correlated_categories_ri.loc[:, lci] /
correlated_categories_ri.loc[:, lci].sum(axis=0))
# Appending the result per method to the final result
result = result.append(result_per_method.loc[category_names, :])
result = result.applymap(np.sqrt)
return result
|
/-
Copyright (c) 2020 Yury G. Kudryashov. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Yury G. Kudryashov, Johannes Hölzl
-/
import order.conditionally_complete_lattice
import logic.function.iterate
import order.rel_iso
/-!
# Order continuity
We say that a function is *left order continuous* if it sends all least upper bounds
to least upper bounds. The order dual notion is called *right order continuity*.
For monotone functions `ℝ → ℝ` these notions correspond to the usual left and right continuity.
We prove some basic lemmas (`map_sup`, `map_Sup` etc) and prove that an `rel_iso` is both left
and right order continuous.
-/
universes u v w x
variables {α : Type u} {β : Type v} {γ : Type w} {ι : Sort x}
open function order_dual set
/-!
### Definitions
-/
/-- A function `f` between preorders is left order continuous if it preserves all suprema. We
define it using `is_lub` instead of `Sup` so that the proof works both for complete lattices and
conditionally complete lattices. -/
def left_ord_continuous [preorder α] [preorder β] (f : α → β) :=
∀ ⦃s : set α⦄ ⦃x⦄, is_lub s x → is_lub (f '' s) (f x)
/-- A function `f` between preorders is right order continuous if it preserves all infima. We
define it using `is_glb` instead of `Inf` so that the proof works both for complete lattices and
conditionally complete lattices. -/
def right_ord_continuous [preorder α] [preorder β] (f : α → β) :=
∀ ⦃s : set α⦄ ⦃x⦄, is_glb s x → is_glb (f '' s) (f x)
namespace left_ord_continuous
section preorder
variables (α) [preorder α] [preorder β] [preorder γ] {g : β → γ} {f : α → β}
protected lemma id : left_ord_continuous (id : α → α) := λ s x h, by simpa only [image_id] using h
variable {α}
protected lemma order_dual : left_ord_continuous f → right_ord_continuous (to_dual ∘ f ∘ of_dual) :=
id
lemma map_is_greatest (hf : left_ord_continuous f) {s : set α} {x : α} (h : is_greatest s x):
is_greatest (f '' s) (f x) :=
⟨mem_image_of_mem f h.1, (hf h.is_lub).1⟩
lemma comp (hg : left_ord_continuous g) (hf : left_ord_continuous f) :
left_ord_continuous (g ∘ f) :=
λ s x h, by simpa only [image_image] using hg (hf h)
protected lemma iterate {f : α → α} (hf : left_ord_continuous f) (n : ℕ) :
left_ord_continuous (f^[n]) :=
nat.rec_on n (left_ord_continuous.id α) $ λ n ihn, ihn.comp hf
end preorder
section semilattice_sup
variables [semilattice_sup α] [semilattice_sup β] {f : α → β}
lemma map_sup (hf : left_ord_continuous f) (x y : α) :
f (x ⊔ y) = f x ⊔ f y :=
(hf is_lub_pair).unique $ by simp only [image_pair, is_lub_pair]
lemma le_iff (hf : left_ord_continuous f) (h : injective f) {x y} :
f x ≤ f y ↔ x ≤ y :=
by simp only [← sup_eq_right, ← hf.map_sup, h.eq_iff]
lemma lt_iff (hf : left_ord_continuous f) (h : injective f) {x y} :
f x < f y ↔ x < y :=
by simp only [lt_iff_le_not_le, hf.le_iff h]
variable (f)
/-- Convert an injective left order continuous function to an order embedding. -/
def to_order_embedding (hf : left_ord_continuous f) (h : injective f) :
α ↪o β :=
⟨⟨f, h⟩, λ x y, hf.le_iff h⟩
variable {f}
@[simp] lemma coe_to_order_embedding (hf : left_ord_continuous f) (h : injective f) :
⇑(hf.to_order_embedding f h) = f := rfl
end semilattice_sup
section complete_lattice
variables [complete_lattice α] [complete_lattice β] {f : α → β}
lemma map_Sup' (hf : left_ord_continuous f) (s : set α) :
f (Sup s) = Sup (f '' s) :=
(hf $ is_lub_Sup s).Sup_eq.symm
lemma map_Sup (hf : left_ord_continuous f) (s : set α) :
f (Sup s) = ⨆ x ∈ s, f x :=
by rw [hf.map_Sup', Sup_image]
lemma map_supr (hf : left_ord_continuous f) (g : ι → α) :
f (⨆ i, g i) = ⨆ i, f (g i) :=
by simp only [supr, hf.map_Sup', ← range_comp]
end complete_lattice
section conditionally_complete_lattice
variables [conditionally_complete_lattice α] [conditionally_complete_lattice β] [nonempty ι]
{f : α → β}
lemma map_cSup (hf : left_ord_continuous f) {s : set α} (sne : s.nonempty) (sbdd : bdd_above s) :
f (Sup s) = Sup (f '' s) :=
((hf $ is_lub_cSup sne sbdd).cSup_eq $ sne.image f).symm
lemma map_csupr (hf : left_ord_continuous f) {g : ι → α} (hg : bdd_above (range g)) :
f (⨆ i, g i) = ⨆ i, f (g i) :=
by simp only [supr, hf.map_cSup (range_nonempty _) hg, ← range_comp]
end conditionally_complete_lattice
end left_ord_continuous
namespace right_ord_continuous
section preorder
variables (α) [preorder α] [preorder β] [preorder γ] {g : β → γ} {f : α → β}
protected lemma id : right_ord_continuous (id : α → α) := λ s x h, by simpa only [image_id] using h
variable {α}
protected lemma order_dual : right_ord_continuous f → left_ord_continuous (to_dual ∘ f ∘ of_dual) :=
id
lemma map_is_least (hf : right_ord_continuous f) {s : set α} {x : α} (h : is_least s x):
is_least (f '' s) (f x) :=
hf.order_dual.map_is_greatest h
lemma mono (hf : right_ord_continuous f) : monotone f :=
hf.order_dual.mono.dual
lemma comp (hg : right_ord_continuous g) (hf : right_ord_continuous f) :
right_ord_continuous (g ∘ f) :=
hg.order_dual.comp hf.order_dual
protected lemma iterate {f : α → α} (hf : right_ord_continuous f) (n : ℕ) :
right_ord_continuous (f^[n]) :=
hf.order_dual.iterate n
end preorder
section semilattice_inf
variables [semilattice_inf α] [semilattice_inf β] {f : α → β}
lemma map_inf (hf : right_ord_continuous f) (x y : α) :
f (x ⊓ y) = f x ⊓ f y :=
hf.order_dual.map_sup x y
lemma le_iff (hf : right_ord_continuous f) (h : injective f) {x y} :
f x ≤ f y ↔ x ≤ y :=
hf.order_dual.le_iff h
lemma lt_iff (hf : right_ord_continuous f) (h : injective f) {x y} :
f x < f y ↔ x < y :=
hf.order_dual.lt_iff h
variable (f)
/-- Convert an injective left order continuous function to a `order_embedding`. -/
def to_order_embedding (hf : right_ord_continuous f) (h : injective f) : α ↪o β :=
⟨⟨f, h⟩, λ x y, hf.le_iff h⟩
variable {f}
@[simp] lemma coe_to_order_embedding (hf : right_ord_continuous f) (h : injective f) :
⇑(hf.to_order_embedding f h) = f := rfl
end semilattice_inf
section complete_lattice
variables [complete_lattice α] [complete_lattice β] {f : α → β}
lemma map_Inf' (hf : right_ord_continuous f) (s : set α) :
f (Inf s) = Inf (f '' s) :=
hf.order_dual.map_Sup' s
lemma map_Inf (hf : right_ord_continuous f) (s : set α) :
f (Inf s) = ⨅ x ∈ s, f x :=
hf.order_dual.map_Sup s
lemma map_infi (hf : right_ord_continuous f) (g : ι → α) :
f (⨅ i, g i) = ⨅ i, f (g i) :=
hf.order_dual.map_supr g
end complete_lattice
section conditionally_complete_lattice
variables [conditionally_complete_lattice α] [conditionally_complete_lattice β] [nonempty ι]
{f : α → β}
lemma map_cInf (hf : right_ord_continuous f) {s : set α} (sne : s.nonempty) (sbdd : bdd_below s) :
f (Inf s) = Inf (f '' s) :=
hf.order_dual.map_cSup sne sbdd
lemma map_cinfi (hf : right_ord_continuous f) {g : ι → α} (hg : bdd_below (range g)) :
f (⨅ i, g i) = ⨅ i, f (g i) :=
hf.order_dual.map_csupr hg
end conditionally_complete_lattice
end right_ord_continuous
namespace order_iso
section preorder
variables [preorder α] [preorder β] (e : α ≃o β)
{s : set α} {x : α}
protected lemma left_ord_continuous : left_ord_continuous e :=
λ s x hx,
⟨monotone.mem_upper_bounds_image (λ x y, e.map_rel_iff.2) hx.1,
λ y hy, e.rel_symm_apply.1 $ (is_lub_le_iff hx).2 $ λ x' hx', e.rel_symm_apply.2 $ hy $
mem_image_of_mem _ hx'⟩
protected lemma right_ord_continuous : right_ord_continuous e :=
order_iso.left_ord_continuous e.dual
end preorder
end order_iso
|
module Idris.ModTree
import Core.Binary
import Core.Context
import Core.Context.Log
import Core.Core
import Core.Directory
import Core.Metadata
import Core.Options
import Core.Primitives
import Core.InitPrimitives
import Core.UnifyState
import Idris.Desugar
import Idris.Error
import Idris.Parser
import Idris.ProcessIdr
import Idris.REPLCommon
import Idris.Syntax
import Idris.Pretty
import Data.List
import Data.StringMap
import System.Directory
import System.File
import Utils.Either
%default covering
record ModTree where
constructor MkModTree
nspace : ModuleIdent
sourceFile : Maybe String
deps : List ModTree
Show ModTree where
show t = show (sourceFile t) ++ " " ++ show (nspace t) ++ "<-" ++ show (deps t)
-- A module file to build, and its list of dependencies
-- From this we can work out if the source file needs rebuilding, assuming
-- things are build in dependency order. A source file needs rebuilding
-- if:
-- + Its corresponding ttc is older than the source file
-- + Any of the import ttcs are *newer* than the corresponding ttc
-- (If so: also any imported ttc's fingerprint is different from the one
-- stored in the source file's ttc)
public export
record BuildMod where
constructor MkBuildMod
buildFile : String
buildNS : ModuleIdent
imports : List ModuleIdent
export
Show BuildMod where
show t = buildFile t ++ " [" ++ showSep ", " (map show (imports t)) ++ "]"
data AllMods : Type where
mkModTree : {auto c : Ref Ctxt Defs} ->
{auto a : Ref AllMods (List (ModuleIdent, ModTree))} ->
FC ->
(done : List ModuleIdent) -> -- if 'mod' is here we have a cycle
(mod : ModuleIdent) ->
Core ModTree
mkModTree loc done mod
= if mod `elem` done
then throw (CyclicImports (done ++ [mod]))
else
-- Read imports from source file. If the source file isn't
-- available, it's not our responsibility
catch (do all <- get AllMods
-- If we've seen it before, reuse what we found
case lookup mod all of
Nothing =>
do file <- nsToSource loc mod
modInfo <- readHeader file
let imps = map path (imports modInfo)
ms <- traverse (mkModTree loc (mod :: done)) imps
let mt = MkModTree mod (Just file) ms
all <- get AllMods
put AllMods ((mod, mt) :: all)
pure mt
Just m => pure m)
-- Couldn't find source, assume it's in a package directory
(\err =>
case err of
CyclicImports _ => throw err
_ => pure (MkModTree mod Nothing []))
data DoneMod : Type where
data BuildOrder : Type where
-- Given a module tree, returns the modules in the reverse order they need to
-- be built, including their dependencies
mkBuildMods : {auto d : Ref DoneMod (StringMap ())} ->
{auto o : Ref BuildOrder (List BuildMod)} ->
ModTree -> Core ()
mkBuildMods mod
= maybe (pure ())
(\sf =>
do done <- get DoneMod
case lookup sf done of
Just _ => pure ()
Nothing =>
do -- build dependencies
traverse_ mkBuildMods (deps mod)
-- build it now
bo <- get BuildOrder
put BuildOrder
(MkBuildMod sf (nspace mod)
(map nspace (deps mod)) :: bo)
done <- get DoneMod
put DoneMod (insert sf () done))
(sourceFile mod)
-- Given a main file name, return the list of modules that need to be
-- built for that main file, in the order they need to be built
-- Return an empty list if it turns out it's in the 'done' list
getBuildMods : {auto c : Ref Ctxt Defs} ->
{auto o : Ref ROpts REPLOpts} ->
FC -> (done : List BuildMod) ->
(mainFile : String) ->
Core (List BuildMod)
getBuildMods loc done fname
= do a <- newRef AllMods []
d <- getDirs
fname_ns <- pathToNS (working_dir d) (source_dir d) fname
if fname_ns `elem` map buildNS done
then pure []
else
do t <- mkModTree {a} loc [] fname_ns
dm <- newRef DoneMod empty
o <- newRef BuildOrder []
mkBuildMods {d=dm} {o} t
pure (reverse !(get BuildOrder))
fnameModified : String -> Core Integer
fnameModified fname
= do Right f <- coreLift $ openFile fname Read
| Left err => throw (FileErr fname err)
Right t <- coreLift $ fileModifiedTime f
| Left err => do coreLift $ closeFile f
throw (FileErr fname err)
coreLift $ closeFile f
pure (cast t)
buildMod : {auto c : Ref Ctxt Defs} ->
{auto s : Ref Syn SyntaxInfo} ->
{auto o : Ref ROpts REPLOpts} ->
FC -> Nat -> Nat -> BuildMod ->
Core (List Error)
-- Build from source if any of the dependencies, or the associated source
-- file, have a modification time which is newer than the module's ttc
-- file
buildMod loc num len mod
= do clearCtxt; addPrimitives
lazyActive True; setUnboundImplicits True
let src = buildFile mod
mttc <- getTTCFileName src "ttc"
-- We'd expect any errors in nsToPath to have been caught by now
-- since the imports have been built! But we still have to check.
depFilesE <- traverse (nsToPath loc) (imports mod)
let (ferrs, depFiles) = partitionEithers depFilesE
ttcTime <- catch (do t <- fnameModified mttc
pure (Just t))
(\err => pure Nothing)
srcTime <- fnameModified src
depTimes <- traverse (\f => do t <- fnameModified f
pure (f, t)) depFiles
let needsBuilding =
case ttcTime of
Nothing => True
Just t => any (\x => x > t) (srcTime :: map snd depTimes)
u <- newRef UST initUState
m <- newRef MD initMetadata
put Syn initSyntax
if needsBuilding
then do let msg : Doc IdrisAnn = pretty num <+> slash <+> pretty len <+> colon
<++> pretty "Building" <++> pretty mod.buildNS <++> parens (pretty src)
[] <- process {u} {m} msg src
| errs => do emitWarnings
traverse emitError errs
pure (ferrs ++ errs)
emitWarnings
traverse_ emitError ferrs
pure ferrs
else do emitWarnings
traverse_ emitError ferrs
pure ferrs
buildMods : {auto c : Ref Ctxt Defs} ->
{auto s : Ref Syn SyntaxInfo} ->
{auto o : Ref ROpts REPLOpts} ->
FC -> Nat -> Nat -> List BuildMod ->
Core (List Error)
buildMods fc num len [] = pure []
buildMods fc num len (m :: ms)
= case !(buildMod fc num len m) of
[] => buildMods fc (1 + num) len ms
errs => pure errs
export
buildDeps : {auto c : Ref Ctxt Defs} ->
{auto s : Ref Syn SyntaxInfo} ->
{auto m : Ref MD Metadata} ->
{auto u : Ref UST UState} ->
{auto o : Ref ROpts REPLOpts} ->
(mainFile : String) ->
Core (List Error)
buildDeps fname
= do mods <- getBuildMods toplevelFC [] fname
ok <- buildMods toplevelFC 1 (length mods) mods
case ok of
[] => do -- On success, reload the main ttc in a clean context
clearCtxt; addPrimitives
put MD initMetadata
mainttc <- getTTCFileName fname "ttc"
log "import" 10 $ "Reloading " ++ show mainttc ++ " from " ++ fname
readAsMain mainttc
-- Load the associated metadata for interactive editing
mainttm <- getTTCFileName fname "ttm"
log "import" 10 $ "Reloading " ++ show mainttm
readFromTTM mainttm
pure []
errs => pure errs -- Error happened, give up
export
loadModules : {auto c : Ref Ctxt Defs} ->
{auto s : Ref Syn SyntaxInfo} ->
{auto m : Ref MD Metadata} ->
{auto u : Ref UST UState} ->
{auto o : Ref ROpts REPLOpts} ->
(namespaces : List ModuleIdent) ->
Core ()
loadModules namespaces = do
-- Load the the TTC files in a clean context
clearCtxt; addPrimitives
put MD initMetadata
traverse (\ns => readModule True emptyFC True ns (miAsNamespace ns)) namespaces
pure ()
export
getAllBuildMods : {auto c : Ref Ctxt Defs} ->
{auto s : Ref Syn SyntaxInfo} ->
{auto o : Ref ROpts REPLOpts} ->
(allFiles : List String) ->
Core (List BuildMod)
getAllBuildMods allFiles = do
mods <- getMods toplevelFC [] allFiles
pure $ dropLater mods
where
getMods : FC -> (done : List BuildMod) ->
(allFiles : List String) ->
Core (List BuildMod)
getMods fc done [] = pure done
getMods fc done (f :: fs)
= do ms <- getBuildMods fc done f
getMods fc (ms ++ done) fs
dropLater : List BuildMod -> List BuildMod
dropLater [] = []
dropLater (b :: bs)
= b :: dropLater (filter (\x => buildFile x /= buildFile b) bs)
export
filterUsedByMods : List ModuleIdent -> List BuildMod -> List BuildMod
filterUsedByMods [] mods = []
filterUsedByMods (x :: xs) mods =
let (ancestors, restMods) = partition (\mod => x `elem` mod.imports) mods
in ancestors ++ assert_total (filterUsedByMods (xs ++ map buildNS ancestors) restMods)
export
buildAll : {auto c : Ref Ctxt Defs} ->
{auto s : Ref Syn SyntaxInfo} ->
{auto o : Ref ROpts REPLOpts} ->
List BuildMod ->
Core (List Error)
buildAll mods = buildMods toplevelFC 1 (length mods) mods
|
# GP Regression with Uncertain Inputs
## Introduction
In this notebook, we're going to demonstrate one way of dealing with uncertainty in our training data. Let's say that we're collecting training data that models the following function.
\begin{align}
y &= \sin(2\pi x) + \epsilon \\
\epsilon &\sim \mathcal{N}(0, 0.2)
\end{align}
However, now assume that we're a bit uncertain about our features. In particular, we're going to assume that every `x_i` value is not a point but a distribution instead. E.g.
$$ x_i \sim \mathcal{N}(\mu_i, \sigma_i). $$
### Using a distributional kernel to deal with uncertain inputs
Rather than using a variational method (see the GP Regression with Uncertian Inputs tutorial in the variational examples), if we explicitly know the type of uncertainty in our inputs we can pass that into our kernel.
More specifically, assuming Gaussian inputs, we will compute the symmetrized KL divergence between the Gaussian inputs.
```python
import math
import torch
import tqdm
import gpytorch
from matplotlib import pyplot as plt
%matplotlib inline
%load_ext autoreload
%autoreload 2
```
```python
# Training data is 100 points in [0,1] inclusive regularly spaced
train_x_mean = torch.linspace(0, 1, 20)
# We'll assume the variance shrinks the closer we get to 1
train_x_stdv = torch.linspace(0.03, 0.01, 20)
# True function is sin(2*pi*x) with Gaussian noise
train_y = torch.sin(train_x_mean * (2 * math.pi)) + torch.randn(train_x_mean.size()) * 0.2
```
To effectively pass in the training distributional data, we will need to stack the mean and log variances.
```python
train_x_distributional = torch.stack((train_x_mean, (train_x_stdv**2).log()), dim=1)
```
```python
f, ax = plt.subplots(1, 1, figsize=(8, 3))
ax.errorbar(train_x_mean, train_y, xerr=(train_x_stdv * 2), fmt="k*", label="Train Data")
ax.legend()
```
We train the hyperparameters of the resulting distributional GP via type-II gradient descent, as is standard in many settings. We could also do fully Bayesian inference.
```python
from gpytorch.models import ExactGP
from gpytorch.kernels import GaussianSymmetrizedKLKernel, ScaleKernel
from gpytorch.means import ConstantMean
class ExactGPModel(ExactGP):
def __init__(self, train_x, train_y, likelihood):
super(ExactGPModel, self).__init__(train_x, train_y, likelihood)
self.mean_module = ConstantMean()
self.covar_module = ScaleKernel(GaussianSymmetrizedKLKernel())
def forward(self, x):
mean_x = self.mean_module(x)
covar_x = self.covar_module(x)
return gpytorch.distributions.MultivariateNormal(mean_x, covar_x)
# initialize likelihood and model
likelihood = gpytorch.likelihoods.GaussianLikelihood()
model = ExactGPModel(train_x_distributional, train_y, likelihood)
```
```python
# this is for running the notebook in our testing framework
import os
smoke_test = ('CI' in os.environ)
training_iter = 2 if smoke_test else 500
# Find optimal model hyperparameters
model.train()
likelihood.train()
# Use the adam optimizer
optimizer = torch.optim.Adam(model.parameters(), lr=0.25) # Includes GaussianLikelihood parameters
# "Loss" for GPs - the marginal log likelihood
mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, model)
for i in range(training_iter):
# Zero gradients from previous iteration
optimizer.zero_grad()
# Output from model
output = model(train_x_distributional)
# Calc loss and backprop gradients
loss = -mll(output, train_y)
loss.backward()
print('Iter %d/%d - Loss: %.3f lengthscale: %.3f noise: %.3f' % (
i + 1, training_iter, loss.item(),
model.covar_module.base_kernel.lengthscale.item(),
model.likelihood.noise.item()
))
optimizer.step()
```
Iter 1/500 - Loss: 0.460 lengthscale: 58.355 noise: 0.047
Iter 2/500 - Loss: 0.494 lengthscale: 58.605 noise: 0.037
Iter 3/500 - Loss: 0.461 lengthscale: 58.855 noise: 0.044
Iter 4/500 - Loss: 0.468 lengthscale: 59.105 noise: 0.053
Iter 5/500 - Loss: 0.476 lengthscale: 59.353 noise: 0.057
Iter 6/500 - Loss: 0.467 lengthscale: 59.601 noise: 0.057
Iter 7/500 - Loss: 0.459 lengthscale: 59.849 noise: 0.053
Iter 8/500 - Loss: 0.458 lengthscale: 60.096 noise: 0.049
Iter 9/500 - Loss: 0.461 lengthscale: 60.344 noise: 0.045
Iter 10/500 - Loss: 0.462 lengthscale: 60.592 noise: 0.042
Iter 11/500 - Loss: 0.460 lengthscale: 60.840 noise: 0.041
Iter 12/500 - Loss: 0.455 lengthscale: 61.089 noise: 0.042
Iter 13/500 - Loss: 0.453 lengthscale: 61.338 noise: 0.044
Iter 14/500 - Loss: 0.453 lengthscale: 61.586 noise: 0.047
Iter 15/500 - Loss: 0.454 lengthscale: 61.834 noise: 0.049
Iter 16/500 - Loss: 0.454 lengthscale: 62.081 noise: 0.051
Iter 17/500 - Loss: 0.451 lengthscale: 62.327 noise: 0.052
Iter 18/500 - Loss: 0.449 lengthscale: 62.572 noise: 0.051
Iter 19/500 - Loss: 0.449 lengthscale: 62.817 noise: 0.049
Iter 20/500 - Loss: 0.449 lengthscale: 63.061 noise: 0.047
Iter 21/500 - Loss: 0.448 lengthscale: 63.306 noise: 0.045
Iter 22/500 - Loss: 0.447 lengthscale: 63.550 noise: 0.044
Iter 23/500 - Loss: 0.446 lengthscale: 63.794 noise: 0.044
Iter 24/500 - Loss: 0.445 lengthscale: 64.038 noise: 0.044
Iter 25/500 - Loss: 0.444 lengthscale: 64.282 noise: 0.045
Iter 26/500 - Loss: 0.444 lengthscale: 64.525 noise: 0.046
Iter 27/500 - Loss: 0.443 lengthscale: 64.767 noise: 0.048
Iter 28/500 - Loss: 0.442 lengthscale: 65.009 noise: 0.049
Iter 29/500 - Loss: 0.441 lengthscale: 65.250 noise: 0.049
Iter 30/500 - Loss: 0.441 lengthscale: 65.490 noise: 0.049
Iter 31/500 - Loss: 0.440 lengthscale: 65.730 noise: 0.048
Iter 32/500 - Loss: 0.440 lengthscale: 65.970 noise: 0.047
Iter 33/500 - Loss: 0.439 lengthscale: 66.209 noise: 0.045
Iter 34/500 - Loss: 0.438 lengthscale: 66.448 noise: 0.045
Iter 35/500 - Loss: 0.437 lengthscale: 66.686 noise: 0.045
Iter 36/500 - Loss: 0.437 lengthscale: 66.924 noise: 0.045
Iter 37/500 - Loss: 0.436 lengthscale: 67.161 noise: 0.046
Iter 38/500 - Loss: 0.436 lengthscale: 67.398 noise: 0.047
Iter 39/500 - Loss: 0.435 lengthscale: 67.634 noise: 0.047
Iter 40/500 - Loss: 0.434 lengthscale: 67.870 noise: 0.048
Iter 41/500 - Loss: 0.434 lengthscale: 68.105 noise: 0.047
Iter 42/500 - Loss: 0.433 lengthscale: 68.339 noise: 0.047
Iter 43/500 - Loss: 0.432 lengthscale: 68.573 noise: 0.046
Iter 44/500 - Loss: 0.432 lengthscale: 68.806 noise: 0.046
Iter 45/500 - Loss: 0.431 lengthscale: 69.039 noise: 0.045
Iter 46/500 - Loss: 0.431 lengthscale: 69.272 noise: 0.045
Iter 47/500 - Loss: 0.430 lengthscale: 69.504 noise: 0.045
Iter 48/500 - Loss: 0.430 lengthscale: 69.735 noise: 0.046
Iter 49/500 - Loss: 0.429 lengthscale: 69.966 noise: 0.046
Iter 50/500 - Loss: 0.428 lengthscale: 70.196 noise: 0.047
Iter 51/500 - Loss: 0.428 lengthscale: 70.426 noise: 0.047
Iter 52/500 - Loss: 0.427 lengthscale: 70.655 noise: 0.047
Iter 53/500 - Loss: 0.427 lengthscale: 70.884 noise: 0.046
Iter 54/500 - Loss: 0.426 lengthscale: 71.112 noise: 0.046
Iter 55/500 - Loss: 0.426 lengthscale: 71.339 noise: 0.045
Iter 56/500 - Loss: 0.425 lengthscale: 71.566 noise: 0.045
Iter 57/500 - Loss: 0.425 lengthscale: 71.793 noise: 0.045
Iter 58/500 - Loss: 0.424 lengthscale: 72.019 noise: 0.046
Iter 59/500 - Loss: 0.424 lengthscale: 72.245 noise: 0.046
Iter 60/500 - Loss: 0.423 lengthscale: 72.470 noise: 0.046
Iter 61/500 - Loss: 0.423 lengthscale: 72.694 noise: 0.046
Iter 62/500 - Loss: 0.422 lengthscale: 72.918 noise: 0.046
Iter 63/500 - Loss: 0.422 lengthscale: 73.141 noise: 0.046
Iter 64/500 - Loss: 0.421 lengthscale: 73.364 noise: 0.046
Iter 65/500 - Loss: 0.420 lengthscale: 73.587 noise: 0.045
Iter 66/500 - Loss: 0.420 lengthscale: 73.808 noise: 0.045
Iter 67/500 - Loss: 0.420 lengthscale: 74.030 noise: 0.045
Iter 68/500 - Loss: 0.419 lengthscale: 74.251 noise: 0.045
Iter 69/500 - Loss: 0.419 lengthscale: 74.471 noise: 0.046
Iter 70/500 - Loss: 0.418 lengthscale: 74.691 noise: 0.046
Iter 71/500 - Loss: 0.418 lengthscale: 74.910 noise: 0.046
Iter 72/500 - Loss: 0.417 lengthscale: 75.129 noise: 0.046
Iter 73/500 - Loss: 0.417 lengthscale: 75.347 noise: 0.045
Iter 74/500 - Loss: 0.416 lengthscale: 75.565 noise: 0.045
Iter 75/500 - Loss: 0.416 lengthscale: 75.782 noise: 0.045
Iter 76/500 - Loss: 0.415 lengthscale: 75.999 noise: 0.045
Iter 77/500 - Loss: 0.415 lengthscale: 76.216 noise: 0.045
Iter 78/500 - Loss: 0.414 lengthscale: 76.432 noise: 0.045
Iter 79/500 - Loss: 0.414 lengthscale: 76.647 noise: 0.045
Iter 80/500 - Loss: 0.413 lengthscale: 76.862 noise: 0.045
Iter 81/500 - Loss: 0.413 lengthscale: 77.076 noise: 0.045
Iter 82/500 - Loss: 0.412 lengthscale: 77.290 noise: 0.045
Iter 83/500 - Loss: 0.412 lengthscale: 77.504 noise: 0.045
Iter 84/500 - Loss: 0.412 lengthscale: 77.717 noise: 0.045
Iter 85/500 - Loss: 0.411 lengthscale: 77.929 noise: 0.045
Iter 86/500 - Loss: 0.411 lengthscale: 78.141 noise: 0.045
Iter 87/500 - Loss: 0.410 lengthscale: 78.353 noise: 0.045
Iter 88/500 - Loss: 0.410 lengthscale: 78.564 noise: 0.045
Iter 89/500 - Loss: 0.409 lengthscale: 78.774 noise: 0.045
Iter 90/500 - Loss: 0.409 lengthscale: 78.984 noise: 0.045
Iter 91/500 - Loss: 0.409 lengthscale: 79.194 noise: 0.045
Iter 92/500 - Loss: 0.408 lengthscale: 79.403 noise: 0.045
Iter 93/500 - Loss: 0.408 lengthscale: 79.612 noise: 0.045
Iter 94/500 - Loss: 0.407 lengthscale: 79.820 noise: 0.045
Iter 95/500 - Loss: 0.407 lengthscale: 80.028 noise: 0.045
Iter 96/500 - Loss: 0.407 lengthscale: 80.236 noise: 0.045
Iter 97/500 - Loss: 0.406 lengthscale: 80.443 noise: 0.045
Iter 98/500 - Loss: 0.406 lengthscale: 80.649 noise: 0.045
Iter 99/500 - Loss: 0.405 lengthscale: 80.855 noise: 0.045
Iter 100/500 - Loss: 0.405 lengthscale: 81.061 noise: 0.045
Iter 101/500 - Loss: 0.405 lengthscale: 81.266 noise: 0.045
Iter 102/500 - Loss: 0.404 lengthscale: 81.471 noise: 0.045
Iter 103/500 - Loss: 0.404 lengthscale: 81.675 noise: 0.045
Iter 104/500 - Loss: 0.403 lengthscale: 81.879 noise: 0.045
Iter 105/500 - Loss: 0.403 lengthscale: 82.082 noise: 0.045
Iter 106/500 - Loss: 0.403 lengthscale: 82.285 noise: 0.045
Iter 107/500 - Loss: 0.402 lengthscale: 82.488 noise: 0.045
Iter 108/500 - Loss: 0.402 lengthscale: 82.690 noise: 0.045
Iter 109/500 - Loss: 0.401 lengthscale: 82.892 noise: 0.045
Iter 110/500 - Loss: 0.401 lengthscale: 83.093 noise: 0.045
Iter 111/500 - Loss: 0.401 lengthscale: 83.294 noise: 0.045
Iter 112/500 - Loss: 0.400 lengthscale: 83.494 noise: 0.045
Iter 113/500 - Loss: 0.400 lengthscale: 83.694 noise: 0.045
Iter 114/500 - Loss: 0.400 lengthscale: 83.894 noise: 0.045
Iter 115/500 - Loss: 0.399 lengthscale: 84.093 noise: 0.045
Iter 116/500 - Loss: 0.399 lengthscale: 84.292 noise: 0.045
Iter 117/500 - Loss: 0.399 lengthscale: 84.490 noise: 0.045
Iter 118/500 - Loss: 0.398 lengthscale: 84.688 noise: 0.045
Iter 119/500 - Loss: 0.398 lengthscale: 84.886 noise: 0.045
Iter 120/500 - Loss: 0.397 lengthscale: 85.083 noise: 0.045
Iter 121/500 - Loss: 0.397 lengthscale: 85.280 noise: 0.045
Iter 122/500 - Loss: 0.397 lengthscale: 85.476 noise: 0.045
Iter 123/500 - Loss: 0.396 lengthscale: 85.672 noise: 0.045
Iter 124/500 - Loss: 0.396 lengthscale: 85.867 noise: 0.044
Iter 125/500 - Loss: 0.396 lengthscale: 86.062 noise: 0.044
Iter 126/500 - Loss: 0.395 lengthscale: 86.257 noise: 0.044
Iter 127/500 - Loss: 0.395 lengthscale: 86.451 noise: 0.044
Iter 128/500 - Loss: 0.395 lengthscale: 86.645 noise: 0.044
Iter 129/500 - Loss: 0.394 lengthscale: 86.839 noise: 0.044
Iter 130/500 - Loss: 0.394 lengthscale: 87.032 noise: 0.044
Iter 131/500 - Loss: 0.394 lengthscale: 87.225 noise: 0.044
Iter 132/500 - Loss: 0.393 lengthscale: 87.417 noise: 0.044
Iter 133/500 - Loss: 0.393 lengthscale: 87.609 noise: 0.044
Iter 134/500 - Loss: 0.393 lengthscale: 87.801 noise: 0.044
Iter 135/500 - Loss: 0.392 lengthscale: 87.992 noise: 0.044
Iter 136/500 - Loss: 0.392 lengthscale: 88.183 noise: 0.044
Iter 137/500 - Loss: 0.392 lengthscale: 88.373 noise: 0.044
Iter 138/500 - Loss: 0.391 lengthscale: 88.564 noise: 0.044
Iter 139/500 - Loss: 0.391 lengthscale: 88.753 noise: 0.044
Iter 140/500 - Loss: 0.391 lengthscale: 88.943 noise: 0.044
Iter 141/500 - Loss: 0.391 lengthscale: 89.132 noise: 0.044
Iter 142/500 - Loss: 0.390 lengthscale: 89.320 noise: 0.044
Iter 143/500 - Loss: 0.390 lengthscale: 89.508 noise: 0.044
Iter 144/500 - Loss: 0.390 lengthscale: 89.696 noise: 0.044
Iter 145/500 - Loss: 0.389 lengthscale: 89.884 noise: 0.044
Iter 146/500 - Loss: 0.389 lengthscale: 90.071 noise: 0.044
Iter 147/500 - Loss: 0.389 lengthscale: 90.258 noise: 0.044
Iter 148/500 - Loss: 0.388 lengthscale: 90.444 noise: 0.044
Iter 149/500 - Loss: 0.388 lengthscale: 90.630 noise: 0.044
Iter 150/500 - Loss: 0.388 lengthscale: 90.816 noise: 0.044
Iter 151/500 - Loss: 0.388 lengthscale: 91.001 noise: 0.044
Iter 152/500 - Loss: 0.387 lengthscale: 91.186 noise: 0.044
Iter 153/500 - Loss: 0.387 lengthscale: 91.371 noise: 0.044
Iter 154/500 - Loss: 0.387 lengthscale: 91.555 noise: 0.044
Iter 155/500 - Loss: 0.386 lengthscale: 91.739 noise: 0.044
Iter 156/500 - Loss: 0.386 lengthscale: 91.923 noise: 0.044
Iter 157/500 - Loss: 0.386 lengthscale: 92.106 noise: 0.044
Iter 158/500 - Loss: 0.385 lengthscale: 92.289 noise: 0.044
Iter 159/500 - Loss: 0.385 lengthscale: 92.471 noise: 0.044
Iter 160/500 - Loss: 0.385 lengthscale: 92.654 noise: 0.044
Iter 161/500 - Loss: 0.385 lengthscale: 92.836 noise: 0.044
Iter 162/500 - Loss: 0.384 lengthscale: 93.017 noise: 0.044
Iter 163/500 - Loss: 0.384 lengthscale: 93.198 noise: 0.044
Iter 164/500 - Loss: 0.384 lengthscale: 93.379 noise: 0.044
Iter 165/500 - Loss: 0.384 lengthscale: 93.560 noise: 0.044
Iter 166/500 - Loss: 0.383 lengthscale: 93.740 noise: 0.044
Iter 167/500 - Loss: 0.383 lengthscale: 93.920 noise: 0.044
Iter 168/500 - Loss: 0.383 lengthscale: 94.099 noise: 0.044
Iter 169/500 - Loss: 0.382 lengthscale: 94.278 noise: 0.044
Iter 170/500 - Loss: 0.382 lengthscale: 94.457 noise: 0.044
Iter 171/500 - Loss: 0.382 lengthscale: 94.636 noise: 0.044
Iter 172/500 - Loss: 0.382 lengthscale: 94.814 noise: 0.044
Iter 173/500 - Loss: 0.381 lengthscale: 94.992 noise: 0.044
Iter 174/500 - Loss: 0.381 lengthscale: 95.169 noise: 0.044
Iter 175/500 - Loss: 0.381 lengthscale: 95.346 noise: 0.044
Iter 176/500 - Loss: 0.381 lengthscale: 95.523 noise: 0.044
Iter 177/500 - Loss: 0.380 lengthscale: 95.700 noise: 0.044
Iter 178/500 - Loss: 0.380 lengthscale: 95.876 noise: 0.044
Iter 179/500 - Loss: 0.380 lengthscale: 96.052 noise: 0.044
Iter 180/500 - Loss: 0.380 lengthscale: 96.228 noise: 0.044
Iter 181/500 - Loss: 0.379 lengthscale: 96.403 noise: 0.044
Iter 182/500 - Loss: 0.379 lengthscale: 96.578 noise: 0.044
Iter 183/500 - Loss: 0.379 lengthscale: 96.752 noise: 0.044
Iter 184/500 - Loss: 0.379 lengthscale: 96.927 noise: 0.044
Iter 185/500 - Loss: 0.378 lengthscale: 97.101 noise: 0.044
Iter 186/500 - Loss: 0.378 lengthscale: 97.275 noise: 0.044
Iter 187/500 - Loss: 0.378 lengthscale: 97.448 noise: 0.044
Iter 188/500 - Loss: 0.378 lengthscale: 97.621 noise: 0.044
Iter 189/500 - Loss: 0.377 lengthscale: 97.794 noise: 0.044
Iter 190/500 - Loss: 0.377 lengthscale: 97.966 noise: 0.044
Iter 191/500 - Loss: 0.377 lengthscale: 98.139 noise: 0.044
Iter 192/500 - Loss: 0.377 lengthscale: 98.310 noise: 0.044
Iter 193/500 - Loss: 0.376 lengthscale: 98.482 noise: 0.044
Iter 194/500 - Loss: 0.376 lengthscale: 98.653 noise: 0.044
Iter 195/500 - Loss: 0.376 lengthscale: 98.824 noise: 0.044
Iter 196/500 - Loss: 0.376 lengthscale: 98.995 noise: 0.044
Iter 197/500 - Loss: 0.375 lengthscale: 99.165 noise: 0.044
Iter 198/500 - Loss: 0.375 lengthscale: 99.336 noise: 0.044
Iter 199/500 - Loss: 0.375 lengthscale: 99.505 noise: 0.043
Iter 200/500 - Loss: 0.375 lengthscale: 99.675 noise: 0.043
Iter 201/500 - Loss: 0.375 lengthscale: 99.844 noise: 0.043
Iter 202/500 - Loss: 0.374 lengthscale: 100.013 noise: 0.043
Iter 203/500 - Loss: 0.374 lengthscale: 100.182 noise: 0.043
Iter 204/500 - Loss: 0.374 lengthscale: 100.350 noise: 0.043
Iter 205/500 - Loss: 0.374 lengthscale: 100.518 noise: 0.043
Iter 206/500 - Loss: 0.373 lengthscale: 100.686 noise: 0.043
Iter 207/500 - Loss: 0.373 lengthscale: 100.853 noise: 0.043
Iter 208/500 - Loss: 0.373 lengthscale: 101.020 noise: 0.043
Iter 209/500 - Loss: 0.373 lengthscale: 101.187 noise: 0.043
Iter 210/500 - Loss: 0.373 lengthscale: 101.354 noise: 0.043
Iter 211/500 - Loss: 0.372 lengthscale: 101.520 noise: 0.043
Iter 212/500 - Loss: 0.372 lengthscale: 101.686 noise: 0.043
Iter 213/500 - Loss: 0.372 lengthscale: 101.852 noise: 0.043
Iter 214/500 - Loss: 0.372 lengthscale: 102.018 noise: 0.043
Iter 215/500 - Loss: 0.372 lengthscale: 102.183 noise: 0.043
Iter 216/500 - Loss: 0.371 lengthscale: 102.348 noise: 0.043
Iter 217/500 - Loss: 0.371 lengthscale: 102.513 noise: 0.043
Iter 218/500 - Loss: 0.371 lengthscale: 102.677 noise: 0.043
Iter 219/500 - Loss: 0.371 lengthscale: 102.841 noise: 0.043
Iter 220/500 - Loss: 0.370 lengthscale: 103.005 noise: 0.043
Iter 221/500 - Loss: 0.370 lengthscale: 103.169 noise: 0.043
Iter 222/500 - Loss: 0.370 lengthscale: 103.332 noise: 0.043
Iter 223/500 - Loss: 0.370 lengthscale: 103.495 noise: 0.043
Iter 224/500 - Loss: 0.370 lengthscale: 103.658 noise: 0.043
Iter 225/500 - Loss: 0.369 lengthscale: 103.820 noise: 0.043
Iter 226/500 - Loss: 0.369 lengthscale: 103.982 noise: 0.043
Iter 227/500 - Loss: 0.369 lengthscale: 104.144 noise: 0.043
Iter 228/500 - Loss: 0.369 lengthscale: 104.306 noise: 0.043
Iter 229/500 - Loss: 0.369 lengthscale: 104.468 noise: 0.043
Iter 230/500 - Loss: 0.368 lengthscale: 104.629 noise: 0.043
Iter 231/500 - Loss: 0.368 lengthscale: 104.790 noise: 0.043
Iter 232/500 - Loss: 0.368 lengthscale: 104.950 noise: 0.043
Iter 233/500 - Loss: 0.368 lengthscale: 105.111 noise: 0.043
Iter 234/500 - Loss: 0.368 lengthscale: 105.271 noise: 0.043
Iter 235/500 - Loss: 0.367 lengthscale: 105.431 noise: 0.043
Iter 236/500 - Loss: 0.367 lengthscale: 105.590 noise: 0.043
Iter 237/500 - Loss: 0.367 lengthscale: 105.750 noise: 0.043
Iter 238/500 - Loss: 0.367 lengthscale: 105.909 noise: 0.043
Iter 239/500 - Loss: 0.367 lengthscale: 106.068 noise: 0.043
Iter 240/500 - Loss: 0.367 lengthscale: 106.226 noise: 0.043
Iter 241/500 - Loss: 0.366 lengthscale: 106.385 noise: 0.043
Iter 242/500 - Loss: 0.366 lengthscale: 106.543 noise: 0.043
Iter 243/500 - Loss: 0.366 lengthscale: 106.701 noise: 0.043
Iter 244/500 - Loss: 0.366 lengthscale: 106.858 noise: 0.043
Iter 245/500 - Loss: 0.366 lengthscale: 107.016 noise: 0.043
Iter 246/500 - Loss: 0.365 lengthscale: 107.173 noise: 0.043
Iter 247/500 - Loss: 0.365 lengthscale: 107.330 noise: 0.043
Iter 248/500 - Loss: 0.365 lengthscale: 107.486 noise: 0.043
Iter 249/500 - Loss: 0.365 lengthscale: 107.643 noise: 0.043
Iter 250/500 - Loss: 0.365 lengthscale: 107.799 noise: 0.043
Iter 251/500 - Loss: 0.364 lengthscale: 107.955 noise: 0.043
Iter 252/500 - Loss: 0.364 lengthscale: 108.110 noise: 0.043
Iter 253/500 - Loss: 0.364 lengthscale: 108.266 noise: 0.043
Iter 254/500 - Loss: 0.364 lengthscale: 108.421 noise: 0.043
Iter 255/500 - Loss: 0.364 lengthscale: 108.576 noise: 0.043
Iter 256/500 - Loss: 0.364 lengthscale: 108.731 noise: 0.043
Iter 257/500 - Loss: 0.363 lengthscale: 108.885 noise: 0.043
Iter 258/500 - Loss: 0.363 lengthscale: 109.039 noise: 0.043
Iter 259/500 - Loss: 0.363 lengthscale: 109.193 noise: 0.043
Iter 260/500 - Loss: 0.363 lengthscale: 109.347 noise: 0.043
Iter 261/500 - Loss: 0.363 lengthscale: 109.500 noise: 0.043
Iter 262/500 - Loss: 0.363 lengthscale: 109.654 noise: 0.043
Iter 263/500 - Loss: 0.362 lengthscale: 109.807 noise: 0.043
Iter 264/500 - Loss: 0.362 lengthscale: 109.960 noise: 0.043
Iter 265/500 - Loss: 0.362 lengthscale: 110.112 noise: 0.043
Iter 266/500 - Loss: 0.362 lengthscale: 110.265 noise: 0.043
Iter 267/500 - Loss: 0.362 lengthscale: 110.417 noise: 0.043
Iter 268/500 - Loss: 0.362 lengthscale: 110.569 noise: 0.043
Iter 269/500 - Loss: 0.361 lengthscale: 110.720 noise: 0.043
Iter 270/500 - Loss: 0.361 lengthscale: 110.872 noise: 0.043
Iter 271/500 - Loss: 0.361 lengthscale: 111.023 noise: 0.043
Iter 272/500 - Loss: 0.361 lengthscale: 111.174 noise: 0.043
Iter 273/500 - Loss: 0.361 lengthscale: 111.325 noise: 0.043
Iter 274/500 - Loss: 0.361 lengthscale: 111.475 noise: 0.043
Iter 275/500 - Loss: 0.360 lengthscale: 111.625 noise: 0.043
Iter 276/500 - Loss: 0.360 lengthscale: 111.775 noise: 0.043
Iter 277/500 - Loss: 0.360 lengthscale: 111.925 noise: 0.043
Iter 278/500 - Loss: 0.360 lengthscale: 112.075 noise: 0.043
Iter 279/500 - Loss: 0.360 lengthscale: 112.224 noise: 0.043
Iter 280/500 - Loss: 0.360 lengthscale: 112.374 noise: 0.043
Iter 281/500 - Loss: 0.359 lengthscale: 112.523 noise: 0.043
Iter 282/500 - Loss: 0.359 lengthscale: 112.671 noise: 0.043
Iter 283/500 - Loss: 0.359 lengthscale: 112.820 noise: 0.043
Iter 284/500 - Loss: 0.359 lengthscale: 112.968 noise: 0.043
Iter 285/500 - Loss: 0.359 lengthscale: 113.116 noise: 0.043
Iter 286/500 - Loss: 0.359 lengthscale: 113.264 noise: 0.043
Iter 287/500 - Loss: 0.359 lengthscale: 113.412 noise: 0.043
Iter 288/500 - Loss: 0.358 lengthscale: 113.559 noise: 0.043
Iter 289/500 - Loss: 0.358 lengthscale: 113.707 noise: 0.043
Iter 290/500 - Loss: 0.358 lengthscale: 113.854 noise: 0.043
Iter 291/500 - Loss: 0.358 lengthscale: 114.001 noise: 0.043
Iter 292/500 - Loss: 0.358 lengthscale: 114.147 noise: 0.043
Iter 293/500 - Loss: 0.358 lengthscale: 114.294 noise: 0.043
Iter 294/500 - Loss: 0.357 lengthscale: 114.440 noise: 0.043
Iter 295/500 - Loss: 0.357 lengthscale: 114.586 noise: 0.043
Iter 296/500 - Loss: 0.357 lengthscale: 114.732 noise: 0.043
Iter 297/500 - Loss: 0.357 lengthscale: 114.877 noise: 0.043
Iter 298/500 - Loss: 0.357 lengthscale: 115.023 noise: 0.043
Iter 299/500 - Loss: 0.357 lengthscale: 115.168 noise: 0.043
Iter 300/500 - Loss: 0.357 lengthscale: 115.313 noise: 0.043
Iter 301/500 - Loss: 0.356 lengthscale: 115.458 noise: 0.043
Iter 302/500 - Loss: 0.356 lengthscale: 115.602 noise: 0.043
Iter 303/500 - Loss: 0.356 lengthscale: 115.747 noise: 0.043
Iter 304/500 - Loss: 0.356 lengthscale: 115.891 noise: 0.043
Iter 305/500 - Loss: 0.356 lengthscale: 116.035 noise: 0.043
Iter 306/500 - Loss: 0.356 lengthscale: 116.179 noise: 0.043
Iter 307/500 - Loss: 0.356 lengthscale: 116.322 noise: 0.043
Iter 308/500 - Loss: 0.355 lengthscale: 116.465 noise: 0.043
Iter 309/500 - Loss: 0.355 lengthscale: 116.609 noise: 0.043
Iter 310/500 - Loss: 0.355 lengthscale: 116.752 noise: 0.043
Iter 311/500 - Loss: 0.355 lengthscale: 116.894 noise: 0.043
Iter 312/500 - Loss: 0.355 lengthscale: 117.037 noise: 0.043
Iter 313/500 - Loss: 0.355 lengthscale: 117.179 noise: 0.043
Iter 314/500 - Loss: 0.355 lengthscale: 117.322 noise: 0.043
Iter 315/500 - Loss: 0.354 lengthscale: 117.464 noise: 0.043
Iter 316/500 - Loss: 0.354 lengthscale: 117.605 noise: 0.043
Iter 317/500 - Loss: 0.354 lengthscale: 117.747 noise: 0.043
Iter 318/500 - Loss: 0.354 lengthscale: 117.888 noise: 0.043
Iter 319/500 - Loss: 0.354 lengthscale: 118.030 noise: 0.043
Iter 320/500 - Loss: 0.354 lengthscale: 118.171 noise: 0.043
Iter 321/500 - Loss: 0.354 lengthscale: 118.312 noise: 0.043
Iter 322/500 - Loss: 0.354 lengthscale: 118.452 noise: 0.043
Iter 323/500 - Loss: 0.353 lengthscale: 118.593 noise: 0.043
Iter 324/500 - Loss: 0.353 lengthscale: 118.733 noise: 0.043
Iter 325/500 - Loss: 0.353 lengthscale: 118.873 noise: 0.043
Iter 326/500 - Loss: 0.353 lengthscale: 119.013 noise: 0.043
Iter 327/500 - Loss: 0.353 lengthscale: 119.153 noise: 0.043
Iter 328/500 - Loss: 0.353 lengthscale: 119.292 noise: 0.043
Iter 329/500 - Loss: 0.353 lengthscale: 119.432 noise: 0.043
Iter 330/500 - Loss: 0.352 lengthscale: 119.571 noise: 0.043
Iter 331/500 - Loss: 0.352 lengthscale: 119.710 noise: 0.043
Iter 332/500 - Loss: 0.352 lengthscale: 119.849 noise: 0.043
Iter 333/500 - Loss: 0.352 lengthscale: 119.987 noise: 0.043
Iter 334/500 - Loss: 0.352 lengthscale: 120.126 noise: 0.043
Iter 335/500 - Loss: 0.352 lengthscale: 120.264 noise: 0.043
Iter 336/500 - Loss: 0.352 lengthscale: 120.402 noise: 0.043
Iter 337/500 - Loss: 0.352 lengthscale: 120.540 noise: 0.043
Iter 338/500 - Loss: 0.351 lengthscale: 120.678 noise: 0.042
Iter 339/500 - Loss: 0.351 lengthscale: 120.815 noise: 0.042
Iter 340/500 - Loss: 0.351 lengthscale: 120.953 noise: 0.042
Iter 341/500 - Loss: 0.351 lengthscale: 121.090 noise: 0.042
Iter 342/500 - Loss: 0.351 lengthscale: 121.227 noise: 0.042
Iter 343/500 - Loss: 0.351 lengthscale: 121.364 noise: 0.042
Iter 344/500 - Loss: 0.351 lengthscale: 121.500 noise: 0.042
Iter 345/500 - Loss: 0.351 lengthscale: 121.637 noise: 0.042
Iter 346/500 - Loss: 0.350 lengthscale: 121.773 noise: 0.042
Iter 347/500 - Loss: 0.350 lengthscale: 121.909 noise: 0.042
Iter 348/500 - Loss: 0.350 lengthscale: 122.045 noise: 0.042
Iter 349/500 - Loss: 0.350 lengthscale: 122.181 noise: 0.042
Iter 350/500 - Loss: 0.350 lengthscale: 122.317 noise: 0.042
Iter 351/500 - Loss: 0.350 lengthscale: 122.452 noise: 0.042
Iter 352/500 - Loss: 0.350 lengthscale: 122.588 noise: 0.042
Iter 353/500 - Loss: 0.350 lengthscale: 122.723 noise: 0.042
Iter 354/500 - Loss: 0.350 lengthscale: 122.858 noise: 0.042
Iter 355/500 - Loss: 0.349 lengthscale: 122.992 noise: 0.042
Iter 356/500 - Loss: 0.349 lengthscale: 123.127 noise: 0.042
Iter 357/500 - Loss: 0.349 lengthscale: 123.261 noise: 0.042
Iter 358/500 - Loss: 0.349 lengthscale: 123.396 noise: 0.042
Iter 359/500 - Loss: 0.349 lengthscale: 123.530 noise: 0.042
Iter 360/500 - Loss: 0.349 lengthscale: 123.664 noise: 0.042
Iter 361/500 - Loss: 0.349 lengthscale: 123.798 noise: 0.042
Iter 362/500 - Loss: 0.349 lengthscale: 123.931 noise: 0.042
Iter 363/500 - Loss: 0.348 lengthscale: 124.065 noise: 0.042
Iter 364/500 - Loss: 0.348 lengthscale: 124.198 noise: 0.042
Iter 365/500 - Loss: 0.348 lengthscale: 124.331 noise: 0.042
Iter 366/500 - Loss: 0.348 lengthscale: 124.464 noise: 0.042
Iter 367/500 - Loss: 0.348 lengthscale: 124.597 noise: 0.042
Iter 368/500 - Loss: 0.348 lengthscale: 124.729 noise: 0.042
Iter 369/500 - Loss: 0.348 lengthscale: 124.862 noise: 0.042
Iter 370/500 - Loss: 0.348 lengthscale: 124.994 noise: 0.042
Iter 371/500 - Loss: 0.348 lengthscale: 125.126 noise: 0.042
Iter 372/500 - Loss: 0.347 lengthscale: 125.258 noise: 0.042
Iter 373/500 - Loss: 0.347 lengthscale: 125.390 noise: 0.042
Iter 374/500 - Loss: 0.347 lengthscale: 125.522 noise: 0.042
Iter 375/500 - Loss: 0.347 lengthscale: 125.653 noise: 0.042
Iter 376/500 - Loss: 0.347 lengthscale: 125.785 noise: 0.042
Iter 377/500 - Loss: 0.347 lengthscale: 125.916 noise: 0.042
Iter 378/500 - Loss: 0.347 lengthscale: 126.047 noise: 0.042
Iter 379/500 - Loss: 0.347 lengthscale: 126.178 noise: 0.042
Iter 380/500 - Loss: 0.347 lengthscale: 126.309 noise: 0.042
Iter 381/500 - Loss: 0.346 lengthscale: 126.439 noise: 0.042
Iter 382/500 - Loss: 0.346 lengthscale: 126.570 noise: 0.042
Iter 383/500 - Loss: 0.346 lengthscale: 126.700 noise: 0.042
Iter 384/500 - Loss: 0.346 lengthscale: 126.830 noise: 0.042
Iter 385/500 - Loss: 0.346 lengthscale: 126.960 noise: 0.042
Iter 386/500 - Loss: 0.346 lengthscale: 127.090 noise: 0.042
Iter 387/500 - Loss: 0.346 lengthscale: 127.220 noise: 0.042
Iter 388/500 - Loss: 0.346 lengthscale: 127.349 noise: 0.042
Iter 389/500 - Loss: 0.346 lengthscale: 127.479 noise: 0.042
Iter 390/500 - Loss: 0.346 lengthscale: 127.608 noise: 0.042
Iter 391/500 - Loss: 0.345 lengthscale: 127.737 noise: 0.042
Iter 392/500 - Loss: 0.345 lengthscale: 127.866 noise: 0.042
Iter 393/500 - Loss: 0.345 lengthscale: 127.995 noise: 0.042
Iter 394/500 - Loss: 0.345 lengthscale: 128.123 noise: 0.042
Iter 395/500 - Loss: 0.345 lengthscale: 128.252 noise: 0.042
Iter 396/500 - Loss: 0.345 lengthscale: 128.380 noise: 0.042
Iter 397/500 - Loss: 0.345 lengthscale: 128.508 noise: 0.042
Iter 398/500 - Loss: 0.345 lengthscale: 128.636 noise: 0.042
Iter 399/500 - Loss: 0.345 lengthscale: 128.764 noise: 0.042
Iter 400/500 - Loss: 0.345 lengthscale: 128.892 noise: 0.042
Iter 401/500 - Loss: 0.344 lengthscale: 129.019 noise: 0.042
Iter 402/500 - Loss: 0.344 lengthscale: 129.147 noise: 0.042
Iter 403/500 - Loss: 0.344 lengthscale: 129.274 noise: 0.042
Iter 404/500 - Loss: 0.344 lengthscale: 129.401 noise: 0.042
Iter 405/500 - Loss: 0.344 lengthscale: 129.528 noise: 0.042
Iter 406/500 - Loss: 0.344 lengthscale: 129.655 noise: 0.042
Iter 407/500 - Loss: 0.344 lengthscale: 129.782 noise: 0.042
Iter 408/500 - Loss: 0.344 lengthscale: 129.909 noise: 0.042
Iter 409/500 - Loss: 0.344 lengthscale: 130.035 noise: 0.042
Iter 410/500 - Loss: 0.344 lengthscale: 130.161 noise: 0.042
Iter 411/500 - Loss: 0.343 lengthscale: 130.288 noise: 0.042
Iter 412/500 - Loss: 0.343 lengthscale: 130.414 noise: 0.042
Iter 413/500 - Loss: 0.343 lengthscale: 130.540 noise: 0.042
Iter 414/500 - Loss: 0.343 lengthscale: 130.665 noise: 0.042
Iter 415/500 - Loss: 0.343 lengthscale: 130.791 noise: 0.042
Iter 416/500 - Loss: 0.343 lengthscale: 130.917 noise: 0.042
Iter 417/500 - Loss: 0.343 lengthscale: 131.042 noise: 0.042
Iter 418/500 - Loss: 0.343 lengthscale: 131.167 noise: 0.042
Iter 419/500 - Loss: 0.343 lengthscale: 131.292 noise: 0.042
Iter 420/500 - Loss: 0.343 lengthscale: 131.417 noise: 0.042
Iter 421/500 - Loss: 0.342 lengthscale: 131.542 noise: 0.042
Iter 422/500 - Loss: 0.342 lengthscale: 131.667 noise: 0.042
Iter 423/500 - Loss: 0.342 lengthscale: 131.791 noise: 0.042
Iter 424/500 - Loss: 0.342 lengthscale: 131.916 noise: 0.042
Iter 425/500 - Loss: 0.342 lengthscale: 132.040 noise: 0.042
Iter 426/500 - Loss: 0.342 lengthscale: 132.164 noise: 0.042
Iter 427/500 - Loss: 0.342 lengthscale: 132.288 noise: 0.042
Iter 428/500 - Loss: 0.342 lengthscale: 132.412 noise: 0.042
Iter 429/500 - Loss: 0.342 lengthscale: 132.536 noise: 0.042
Iter 430/500 - Loss: 0.342 lengthscale: 132.659 noise: 0.042
Iter 431/500 - Loss: 0.342 lengthscale: 132.783 noise: 0.042
Iter 432/500 - Loss: 0.341 lengthscale: 132.906 noise: 0.042
Iter 433/500 - Loss: 0.341 lengthscale: 133.029 noise: 0.042
Iter 434/500 - Loss: 0.341 lengthscale: 133.152 noise: 0.042
Iter 435/500 - Loss: 0.341 lengthscale: 133.275 noise: 0.042
Iter 436/500 - Loss: 0.341 lengthscale: 133.398 noise: 0.042
Iter 437/500 - Loss: 0.341 lengthscale: 133.521 noise: 0.042
Iter 438/500 - Loss: 0.341 lengthscale: 133.644 noise: 0.042
Iter 439/500 - Loss: 0.341 lengthscale: 133.766 noise: 0.042
Iter 440/500 - Loss: 0.341 lengthscale: 133.888 noise: 0.042
Iter 441/500 - Loss: 0.341 lengthscale: 134.011 noise: 0.042
Iter 442/500 - Loss: 0.341 lengthscale: 134.133 noise: 0.042
Iter 443/500 - Loss: 0.341 lengthscale: 134.255 noise: 0.042
Iter 444/500 - Loss: 0.340 lengthscale: 134.376 noise: 0.042
Iter 445/500 - Loss: 0.340 lengthscale: 134.498 noise: 0.042
Iter 446/500 - Loss: 0.340 lengthscale: 134.620 noise: 0.042
Iter 447/500 - Loss: 0.340 lengthscale: 134.741 noise: 0.042
Iter 448/500 - Loss: 0.340 lengthscale: 134.862 noise: 0.042
Iter 449/500 - Loss: 0.340 lengthscale: 134.984 noise: 0.042
Iter 450/500 - Loss: 0.340 lengthscale: 135.105 noise: 0.042
Iter 451/500 - Loss: 0.340 lengthscale: 135.226 noise: 0.042
Iter 452/500 - Loss: 0.340 lengthscale: 135.346 noise: 0.042
Iter 453/500 - Loss: 0.340 lengthscale: 135.467 noise: 0.042
Iter 454/500 - Loss: 0.340 lengthscale: 135.588 noise: 0.042
Iter 455/500 - Loss: 0.339 lengthscale: 135.708 noise: 0.042
Iter 456/500 - Loss: 0.339 lengthscale: 135.829 noise: 0.042
Iter 457/500 - Loss: 0.339 lengthscale: 135.949 noise: 0.042
Iter 458/500 - Loss: 0.339 lengthscale: 136.069 noise: 0.042
Iter 459/500 - Loss: 0.339 lengthscale: 136.189 noise: 0.042
Iter 460/500 - Loss: 0.339 lengthscale: 136.309 noise: 0.042
Iter 461/500 - Loss: 0.339 lengthscale: 136.428 noise: 0.042
Iter 462/500 - Loss: 0.339 lengthscale: 136.548 noise: 0.042
Iter 463/500 - Loss: 0.339 lengthscale: 136.668 noise: 0.042
Iter 464/500 - Loss: 0.339 lengthscale: 136.787 noise: 0.042
Iter 465/500 - Loss: 0.339 lengthscale: 136.906 noise: 0.042
Iter 466/500 - Loss: 0.339 lengthscale: 137.025 noise: 0.042
Iter 467/500 - Loss: 0.338 lengthscale: 137.144 noise: 0.042
Iter 468/500 - Loss: 0.338 lengthscale: 137.263 noise: 0.042
Iter 469/500 - Loss: 0.338 lengthscale: 137.382 noise: 0.042
Iter 470/500 - Loss: 0.338 lengthscale: 137.501 noise: 0.042
Iter 471/500 - Loss: 0.338 lengthscale: 137.619 noise: 0.042
Iter 472/500 - Loss: 0.338 lengthscale: 137.738 noise: 0.042
Iter 473/500 - Loss: 0.338 lengthscale: 137.856 noise: 0.042
Iter 474/500 - Loss: 0.338 lengthscale: 137.974 noise: 0.042
Iter 475/500 - Loss: 0.338 lengthscale: 138.093 noise: 0.042
Iter 476/500 - Loss: 0.338 lengthscale: 138.211 noise: 0.042
Iter 477/500 - Loss: 0.338 lengthscale: 138.328 noise: 0.042
Iter 478/500 - Loss: 0.338 lengthscale: 138.446 noise: 0.042
Iter 479/500 - Loss: 0.338 lengthscale: 138.564 noise: 0.042
Iter 480/500 - Loss: 0.337 lengthscale: 138.681 noise: 0.042
Iter 481/500 - Loss: 0.337 lengthscale: 138.799 noise: 0.042
Iter 482/500 - Loss: 0.337 lengthscale: 138.916 noise: 0.042
Iter 483/500 - Loss: 0.337 lengthscale: 139.033 noise: 0.042
Iter 484/500 - Loss: 0.337 lengthscale: 139.151 noise: 0.042
Iter 485/500 - Loss: 0.337 lengthscale: 139.268 noise: 0.042
Iter 486/500 - Loss: 0.337 lengthscale: 139.384 noise: 0.042
Iter 487/500 - Loss: 0.337 lengthscale: 139.501 noise: 0.042
Iter 488/500 - Loss: 0.337 lengthscale: 139.618 noise: 0.042
Iter 489/500 - Loss: 0.337 lengthscale: 139.734 noise: 0.042
Iter 490/500 - Loss: 0.337 lengthscale: 139.851 noise: 0.042
Iter 491/500 - Loss: 0.337 lengthscale: 139.967 noise: 0.042
Iter 492/500 - Loss: 0.337 lengthscale: 140.083 noise: 0.042
Iter 493/500 - Loss: 0.336 lengthscale: 140.200 noise: 0.042
Iter 494/500 - Loss: 0.336 lengthscale: 140.316 noise: 0.042
Iter 495/500 - Loss: 0.336 lengthscale: 140.432 noise: 0.042
Iter 496/500 - Loss: 0.336 lengthscale: 140.547 noise: 0.042
Iter 497/500 - Loss: 0.336 lengthscale: 140.663 noise: 0.042
Iter 498/500 - Loss: 0.336 lengthscale: 140.779 noise: 0.042
Iter 499/500 - Loss: 0.336 lengthscale: 140.894 noise: 0.042
Iter 500/500 - Loss: 0.336 lengthscale: 141.009 noise: 0.042
Now, we test predictions. For simplicity, we will assume a fixed variance of $0.01.$
```python
# Get into evaluation (predictive posterior) mode
model.eval()
likelihood.eval()
# Test points are regularly spaced along [0,1]
# Make predictions by feeding model through likelihood
with torch.no_grad(), gpytorch.settings.fast_pred_var():
test_x = torch.linspace(0, 1, 51)
test_x_distributional = torch.stack((test_x, (1e-2 * torch.ones_like(test_x)).log()), dim=1)
observed_pred = likelihood(model(test_x_distributional))
with torch.no_grad():
# Initialize plot
f, ax = plt.subplots(1, 1, figsize=(12, 12))
# Get upper and lower confidence bounds
lower, upper = observed_pred.confidence_region()
# Plot training data as black stars
ax.errorbar(train_x_mean.numpy(), train_y.numpy(), xerr=train_x_stdv, fmt='k*')
# Plot predictive means as blue line
ax.plot(test_x.numpy(), observed_pred.mean.numpy(), 'b')
# Shade between the lower and upper confidence bounds
ax.fill_between(test_x.numpy(), lower.numpy(), upper.numpy(), alpha=0.5)
ax.set_ylim([-3, 3])
ax.legend(['Observed Data', 'Mean', 'Confidence'])
```
As a final note, we've made it very easy to extend the distributional kernel class by exposing a generic `DistributionalInputKernel` class that takes as input any distance function over probability distributions.
```python
```
|
# ----------------------------------------
# App Title: Chaos Game -- 2 Dimensions
# Author: Jimmy Doi
# ----------------------------------------
library(shiny)
library(shinyBS)
library(shape)
###################################################################
# Triangle
###################################################################
tri.gen <- function(wt){
weight <- wt
len <- 50000
# loci matrix to contain all endpoints
loci <- matrix(NA,ncol=3,nrow=3)
loci[1,] <- c(1,0,0)
loci[2,] <- c(2,0.5,sqrt(3)/2)
loci[3,] <- c(3,1,0)
# vertices contains all random vertex points
vertices <- runif(len)
vertices[which(vertices>2/3)]<- 3
vertices[which(1/3<vertices & vertices<=2/3)]<- 2
vertices[which(vertices<=1/3)]<- 1
coords <- matrix(NA,ncol=2,nrow=(len+1))
colnames(coords)<-c("x","y") #needed for ggvis
coords[1,] <- c(runif(1),runif(1)*sqrt(3)/2)
for (i in 1:len){
row <- i+1
spot <- which(loci[,1]==vertices[i])
x <- loci[spot,2]
y <- loci[spot,3]
x.new <- weight*x + (1-weight)*coords[i,1]
y.new <- weight*y + (1-weight)*coords[i,2]
coords[row,]<-c(x.new,y.new)
x <- x.new
y <- y.new
}
return(list(loci,vertices,coords))
}
###################################################################
# Square
###################################################################
sqr.gen <- function(wt){
weight <- wt
len <- 50000
# loci matrix to contain all endpoints
loci <- matrix(NA,ncol=3,nrow=8)
loci[1,] <- c(1,0.0,0.0)
loci[2,] <- c(2,0.5,0.0)
loci[3,] <- c(3,1.0,0.0)
loci[4,] <- c(4,1.0,0.5)
loci[5,] <- c(5,1.0,1.0)
loci[6,] <- c(6,0.5,1.0)
loci[7,] <- c(7,0.0,1.0)
loci[8,] <- c(8,0.0,0.5)
# vertices contains all random vertex points
vertices <- runif(len)
vertices[which(vertices>7/8)]<- 8
vertices[which(6/8<vertices & vertices<=7/8)]<- 7
vertices[which(5/8<vertices & vertices<=6/8)]<- 6
vertices[which(4/8<vertices & vertices<=5/8)]<- 5
vertices[which(3/8<vertices & vertices<=4/8)]<- 4
vertices[which(2/8<vertices & vertices<=3/8)]<- 3
vertices[which(1/8<vertices & vertices<=2/8)]<- 2
vertices[which(vertices<=1/8)]<- 1
coords <- matrix(NA,ncol=2,nrow=(len+1))
colnames(coords)<-c("x","y") #needed for ggvis
# randomly selected initial point in field of view
coords[1,] <- c(runif(1),runif(1))
for (i in 1:len){
row <- i+1
spot <- which(loci[,1]==vertices[i])
x <- loci[spot,2]
y <- loci[spot,3]
x.new <- (weight)*x + (1-weight)*coords[i,1]
y.new <- (weight)*y + (1-weight)*coords[i,2]
coords[row,]<-c(x.new,y.new)
}
return(list(loci,vertices,coords))
}
###################################################################
# Pentagon
###################################################################
pent.gen <- function(wt){
weight <- wt
len <- 50000
# loci matrix to contain all endpoints
loci <- matrix(NA,ncol=3,nrow=5)
c1 <- 0.25*(sqrt(5)-1)
c2 <- 0.25*(sqrt(5)+1)
s1 <- 0.25*(sqrt(10+2*sqrt(5)))
s2 <- 0.25*(sqrt(10-2*sqrt(5)))
loci[1,] <- c(1,0,1)
loci[2,] <- c(2,s1,c1)
loci[3,] <- c(3,s2,-c2)
loci[4,] <- c(4,-s2,-c2)
loci[5,] <- c(5,-s1,c1)
# vertices contains all random vertex points
vertices <- runif(len)
vertices[which(vertices>4/5)]<- 5
vertices[which(3/5<vertices & vertices<=4/5)]<- 4
vertices[which(2/5<vertices & vertices<=3/5)]<- 3
vertices[which(1/5<vertices & vertices<=2/5)]<- 2
vertices[which(vertices<=1/5)]<- 1
coords <- matrix(NA,ncol=2,nrow=(len+1))
colnames(coords)<-c("x","y") #needed for ggvis
# randomly selected initial point in field of view
coords[1,] <- c(runif(1,-s1,s1),runif(1,-c2,1))
for (i in 1:len){
row <- i+1
spot <- which(loci[,1]==vertices[i])
x <- loci[spot,2]
y <- loci[spot,3]
x.new <- (weight)*x + (1-weight)*coords[i,1]
y.new <- (weight)*y + (1-weight)*coords[i,2]
coords[row,]<-c(x.new,y.new)
}
return(list(loci,vertices,coords))
}
###################################################################
# Hexagon
###################################################################
hex.gen <- function(wt){
weight <- wt
len <- 50000
# loci matrix to contain all endpoints
loci <- matrix(NA,ncol=3,nrow=6)
alpha <- 0.5
beta <- sqrt(3)/2
loci[1,] <- c(1,0,2*alpha)
loci[2,] <- c(2,beta,alpha)
loci[3,] <- c(3,beta,-alpha)
loci[4,] <- c(4,0,-2*alpha)
loci[5,] <- c(5,-beta,-alpha)
loci[6,] <- c(6,-beta,alpha)
# vertices contains all random vertex points
vertices <- runif(len)
vertices[which(vertices>5/6)]<- 6
vertices[which(4/6<vertices & vertices<=5/6)]<- 5
vertices[which(3/6<vertices & vertices<=4/6)]<- 4
vertices[which(2/6<vertices & vertices<=3/6)]<- 3
vertices[which(1/6<vertices & vertices<=2/6)]<- 2
vertices[which(vertices<=1/6)]<- 1
coords <- matrix(NA,ncol=2,nrow=(len+1))
colnames(coords)<-c("x","y") #needed for ggvis
# randomly selected initial point in field of view
coords[1,] <- c(runif(1,-beta,beta),runif(1,-2*alpha,2*alpha))
for (i in 1:len){
row <- i+1
spot <- which(loci[,1]==vertices[i])
x <- loci[spot,2]
y <- loci[spot,3]
x.new <- (weight)*x + (1-weight)*coords[i,1]
y.new <- (weight)*y + (1-weight)*coords[i,2]
coords[row,]<-c(x.new,y.new)
}
return(list(loci,vertices,coords))
}
##############################################################################
# Shiny Server Contents
##############################################################################
shinyServer(function(input, output, session) {
output$my.init <- renderUI({
input$shape
sliderInput(inputId = "init",
"Number of points (n):",
min = 1,
max = 100,
step = 1,
value = 1,
animate=animationOptions(interval = 1000))
})
output$my.extend <- renderUI({
input$shape
sliderInput("extend",
"Number of points (n):",
min = 100,
max = 1000,
step = 25,
value = 100,
animate=animationOptions(interval = 400))
})
output$my.pts <- renderUI({
input$shape
sliderInput("pts",
"Number of points (n):",
min = 1000,
max = 50000,
step = 1000,
value = 1000,
animate=animationOptions(interval = 200))
})
updateButton(session, "gen", style = "primary", size = "default", disabled = FALSE)
all.list <- reactive({
if (input$shape == "tri") {
return(tri.gen(input$dist.tri*(input$gen>-1)))
}
if (input$shape == "sqr") {
return(sqr.gen(input$dist.sqr*(input$gen>-1)))
}
if (input$shape == "pent") {
return(pent.gen(input$dist.pent*(input$gen>-1)))
}
if (input$shape == "hex") {
return(hex.gen(input$dist.hex*(input$gen>-1)))
}
})
##################################
# initPlot #
##################################
output$initPlot <- renderPlot({
loci <- all.list()[[1]]
vertices <- all.list()[[2]]
coords <- all.list()[[3]]
#############################
# Triangle:INIT #
#############################
if (input$shape == "tri") {
par(mar=c(0.5,0.5,0.5,0.5))
plot(0,0,xlim=c(0,1),ylim=c(0,sqrt(3)/2),col=0,
yaxt="n",xaxt="n",xlab="",ylab="",bty="n")
if (!is.null(input$init)) {
if (input$init==1) {
points(coords[1,1],coords[1,2],pch=20,cex=3,col="blue")
if (coords[1,1]>=0.5 & coords[1,2]<=sqrt(3)/4) {
text(coords[1,1],coords[1,2]+0.04,"Random Starting Point",col="blue",pos=2)
}
if (coords[1,1]>=0.5 & coords[1,2]>sqrt(3)/4) {
text(coords[1,1],coords[1,2]-0.04,"Random Starting Point",col="blue",pos=2)
}
if (coords[1,1]<0.5 & coords[1,2]>sqrt(3)/4) {
text(coords[1,1],coords[1,2]-0.04,"Random Starting Point",col="blue",pos=4)
}
if (coords[1,1]<0.5 & coords[1,2]<=sqrt(3)/4) {
text(coords[1,1],coords[1,2]+0.04,"Random Starting Point",col="blue",pos=4)
}
}
}
}
#############################
# Square:INIT #
#############################
if (input$shape == "sqr") {
par(mar=c(0.5,0.5,0.5,0.5))
plot(0,0,xlim=c(0,1),ylim=c(0,1),col=0,
yaxt="n",xaxt="n",xlab="",ylab="",bty="n")
if (input$init==1) {
points(coords[1,1],coords[1,2],pch=20,cex=3,col="blue")
if (coords[1,1]>=0.5 & coords[1,2]<=0.5) { # LOWER RIGHT
text(coords[1,1],coords[1,2]+0.04,"Random Starting Point",col="blue",pos=2)
}
if (coords[1,1]>=0.5 & coords[1,2]>0.5) { # UPPER RIGHT
text(coords[1,1],coords[1,2]-0.04,"Random Starting Point",col="blue",pos=2)
}
if (coords[1,1]<0.5 & coords[1,2]>0.5) { # UPPER LEFT
text(coords[1,1],coords[1,2]-0.04,"Random Starting Point",col="blue",pos=4)
}
if (coords[1,1]<0.5 & coords[1,2]<=0.5) { # LOWER LEFT
text(coords[1,1],coords[1,2]+0.04,"Random Starting Point",col="blue",pos=4)
}
}
}
#############################
# Pentagon:INIT #
#############################
if (input$shape == "pent") {
c1 <- 0.25*(sqrt(5)-1)
c2 <- 0.25*(sqrt(5)+1)
s1 <- 0.25*(sqrt(10+2*sqrt(5)))
s2 <- 0.25*(sqrt(10-2*sqrt(5)))
par(mar=c(0.5,0.5,0.5,0.5))
plot(0,0,xlim=c(-s1,s1),ylim=c(-c2,1),col=0,
yaxt="n",xaxt="n",xlab="",ylab="",bty="n")
if (input$init==1) {
points(coords[1,1],coords[1,2],pch=20,cex=3,col="blue")
if (coords[1,1]>=0 & coords[1,2]<=0) { # LOWER RIGHT
text(coords[1,1],coords[1,2]+0.04,"Random Starting Point",col="blue",pos=2)
}
if (coords[1,1]>=0 & coords[1,2]>0) { # UPPER RIGHT
text(coords[1,1],coords[1,2]-0.04,"Random Starting Point",col="blue",pos=2)
}
if (coords[1,1]<0 & coords[1,2]>0) { # UPPER LEFT
text(coords[1,1],coords[1,2]-0.04,"Random Starting Point",col="blue",pos=4)
}
if (coords[1,1]<0 & coords[1,2]<=0) { # LOWER LEFT
text(coords[1,1],coords[1,2]+0.04,"Random Starting Point",col="blue",pos=4)
}
}
}
#############################
# Hexagon:INIT #
#############################
if (input$shape == "hex") {
alpha <- 0.5
beta <- sqrt(3)/2
par(mar=c(0.5,0.5,0.5,0.5))
plot(0,0,xlim=c(-beta,beta),ylim=c(-2*alpha,2*alpha),col=0,
yaxt="n",xaxt="n",xlab="",ylab="",bty="n")
if (input$init==1) {
points(coords[1,1],coords[1,2],pch=20,cex=3,col="blue")
if (coords[1,1]>=0 & coords[1,2]<=0) { # LOWER RIGHT
text(coords[1,1],coords[1,2]+0.04,"Random Starting Point",col="blue",pos=2)
}
if (coords[1,1]>=0 & coords[1,2]>0) { # UPPER RIGHT
text(coords[1,1],coords[1,2]-0.04,"Random Starting Point",col="blue",pos=2)
}
if (coords[1,1]<0 & coords[1,2]>0) { # UPPER LEFT
text(coords[1,1],coords[1,2]-0.04,"Random Starting Point",col="blue",pos=4)
}
if (coords[1,1]<0 & coords[1,2]<=0) { # LOWER LEFT
text(coords[1,1],coords[1,2]+0.04,"Random Starting Point",col="blue",pos=4)
}
}
}
##################################################################################
### APPLIED TO ALL
if (!is.null(input$init)) {
if (input$init!=1) {
points(coords[1:input$init-1,1],coords[1:input$init-1,2],pch=20,cex=1,col="blue")
points(coords[input$init-1,1],coords[input$init-1,2],pch=20,cex=2.75,col="blue")
points(coords[input$init,1],coords[input$init,2],pch=21,cex=3,col="blue",bg="white")
points(coords[input$init,1],coords[input$init,2],pch=20,cex=2.75,col="blue")
x0 <- coords[input$init-1,1]
y0 <- coords[input$init-1,2]
x1 <- coords[input$init,1]
y1 <- coords[input$init,2]
Arrows((.6*x0+.4*x1),(.6*y0+.4*y1),(.4*x0+.6*x1),(.4*y0+.6*y1),col="blue",lwd=2)
v.x <- loci[loci[,1]==vertices[input$init-1],2]
v.y <- loci[loci[,1]==vertices[input$init-1],3]
points(v.x,v.y,pch=1,cex=4,lwd=2)
points(v.x,v.y,pch=1,cex=3,lwd=2)
}
}
points(loci[,2],loci[,3],pch=20,cex=2,col="red")
}) # initPlot's renderPlot
##################################
# extendPlot #
##################################
output$extendPlot <- renderPlot({
loci <- all.list()[[1]]
vertices <- all.list()[[2]]
coords <- all.list()[[3]]
#############################
# Triangle:EXTEND #
#############################
if (input$shape == "tri") {
par(mar=c(0.5,0.5,0.5,0.5))
plot(0,0,xlim=c(0,1),ylim=c(0,sqrt(3)/2),col=0,
yaxt="n",xaxt="n",xlab="",ylab="",bty="n")
}
#############################
# Square:EXTEND #
#############################
if (input$shape == "sqr") {
par(mar=c(0.5,0.5,0.5,0.5))
plot(0,0,xlim=c(0,1),ylim=c(0,1),col=0,
yaxt="n",xaxt="n",xlab="",ylab="",bty="n")
}
#############################
# Pentagon:EXTEND #
#############################
if (input$shape == "pent") {
c1 <- 0.25*(sqrt(5)-1)
c2 <- 0.25*(sqrt(5)+1)
s1 <- 0.25*(sqrt(10+2*sqrt(5)))
s2 <- 0.25*(sqrt(10-2*sqrt(5)))
par(mar=c(0.5,0.5,0.5,0.5))
plot(0,0,xlim=c(-s1,s1),ylim=c(-c2,1),col=0,
yaxt="n",xaxt="n",xlab="",ylab="",bty="n")
}
#############################
# Hexagon:EXTEND #
#############################
if (input$shape == "hex") {
alpha <- 0.5
beta <- sqrt(3)/2
par(mar=c(0.5,0.5,0.5,0.5))
plot(0,0,xlim=c(-beta,beta),ylim=c(-2*alpha,2*alpha),col=0,
yaxt="n",xaxt="n",xlab="",ylab="",bty="n")
}
############################################################################
### APPLIED TO ALL
if (!is.null(input$extend)) {
if (input$extend!=0) {
points(coords[1:input$extend,1],coords[1:input$extend,2],pch=20,cex=1,col="blue")
}
}
points(loci[,2],loci[,3],pch=20,cex=2,col="red")
}) # extendPlot's renderPlot
##################################
# compPlot #
##################################
output$compPlot <- renderPlot({
loci <- all.list()[[1]]
vertices <- all.list()[[2]]
coords <- all.list()[[3]]
#############################
# Triangle:COMPLETE #
#############################
if (input$shape == "tri") {
par(mar=c(0.5,0.5,0.5,0.5))
plot(0,0,xlim=c(0,1),ylim=c(0,sqrt(3)/2),col=0,
yaxt="n",xaxt="n",xlab="",ylab="",bty="n")
}
#############################
# Square:COMPLETE #
#############################
if (input$shape == "sqr") {
par(mar=c(0.5,0.5,0.5,0.5))
plot(0,0,xlim=c(0,1),ylim=c(0,1),col=0,
yaxt="n",xaxt="n",xlab="",ylab="",bty="n")
}
#############################
# Pentagon:COMPLETE #
#############################
if (input$shape == "pent") {
c1 <- 0.25*(sqrt(5)-1)
c2 <- 0.25*(sqrt(5)+1)
s1 <- 0.25*(sqrt(10+2*sqrt(5)))
s2 <- 0.25*(sqrt(10-2*sqrt(5)))
par(mar=c(0.5,0.5,0.5,0.5))
plot(0,0,xlim=c(-s1,s1),ylim=c(-c2,1),col=0,
yaxt="n",xaxt="n",xlab="",ylab="",bty="n")
}
#############################
# Hexagon:COMPLETE #
#############################
if (input$shape == "hex") {
alpha <- 0.5
beta <- sqrt(3)/2
par(mar=c(0.5,0.5,0.5,0.5))
plot(0,0,xlim=c(-beta,beta),ylim=c(-2*alpha,2*alpha),col=0,
yaxt="n",xaxt="n",xlab="",ylab="",bty="n")
}
##############################################################################
### APPLIED TO ALL
if (!is.null(input$pts)) {
if (input$pts!=0) {
points(coords[1:input$pts,1],coords[1:input$pts,2],pch=".",cex=2.5,col="blue")
}
}
points(loci[,2],loci[,3],pch=20,cex=2,col="red")
}) # compPlot's renderPlot
})
|
(* Title: HOL/Auth/n_flash_nodata_cub_lemma_on_inv__133.thy
Author: Yongjian Li and Kaiqiang Duan, State Key Lab of Computer Science, Institute of Software, Chinese Academy of Sciences
Copyright 2016 State Key Lab of Computer Science, Institute of Software, Chinese Academy of Sciences
*)
header{*The n_flash_nodata_cub Protocol Case Study*}
theory n_flash_nodata_cub_lemma_on_inv__133 imports n_flash_nodata_cub_base
begin
section{*All lemmas on causal relation between inv__133 and some rule r*}
lemma n_PI_Remote_GetVsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_PI_Remote_Get src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_PI_Remote_Get src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_PI_Remote_GetXVsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_PI_Remote_GetX src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_PI_Remote_GetX src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_NakVsinv__133:
assumes a1: "(\<exists> dst. dst\<le>N\<and>r=n_NI_Nak dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain dst where a1:"dst\<le>N\<and>r=n_NI_Nak dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(dst=p__Inv4)\<or>(dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(dst=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Nak__part__0Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Nak__part__0 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Nak__part__0 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Nak__part__1Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Nak__part__1 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Nak__part__1 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Nak__part__2Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Nak__part__2 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Nak__part__2 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Get__part__0Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Get__part__0 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Get__part__0 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Get__part__1Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Get__part__1 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Get__part__1 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Put_HeadVsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Put_Head N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Put_Head N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_PutVsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Put src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Put src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Put_DirtyVsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Put_Dirty src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Put_Dirty src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_Get_NakVsinv__133:
assumes a1: "(\<exists> src dst. src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_Get_Nak src dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src dst where a1:"src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_Get_Nak src dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>dst~=p__Inv4)\<or>(src~=p__Inv4\<and>dst=p__Inv4)\<or>(src~=p__Inv4\<and>dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>dst~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_Get_PutVsinv__133:
assumes a1: "(\<exists> src dst. src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_Get_Put src dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src dst where a1:"src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_Get_Put src dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>dst~=p__Inv4)\<or>(src~=p__Inv4\<and>dst=p__Inv4)\<or>(src~=p__Inv4\<and>dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>dst~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_Nak__part__0Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__0 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__0 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_Nak__part__1Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__1 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__1 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_Nak__part__2Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__2 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__2 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_GetX__part__0Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_GetX__part__0 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_GetX__part__0 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_GetX__part__1Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_GetX__part__1 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_GetX__part__1 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P3 s"
apply (cut_tac a1 a2 b1, simp, rule_tac x="(neg (andForm (eqn (IVar (Field (Field (Ident ''Sta'') ''ShWbMsg'') ''Cmd'')) (Const SHWB_FAck)) (eqn (IVar (Field (Field (Ident ''Sta'') ''Dir'') ''Pending'')) (Const false))))" in exI, auto) done
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_1Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_1 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_1 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_2Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_2 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_2 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_3Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_3 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_3 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_4Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_4 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_4 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_5Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_5 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_5 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_6Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_6 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_6 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_7__part__0Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_7__part__0 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_7__part__0 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_7__part__1Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_7__part__1 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_7__part__1 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_7_NODE_Get__part__0Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_7_NODE_Get__part__0 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_7_NODE_Get__part__0 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_7_NODE_Get__part__1Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_7_NODE_Get__part__1 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_7_NODE_Get__part__1 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_8_HomeVsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_8_Home N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_8_Home N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_8_Home_NODE_GetVsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_8_Home_NODE_Get N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_8_Home_NODE_Get N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_8Vsinv__133:
assumes a1: "(\<exists> src pp. src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_8 N src pp)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src pp where a1:"src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_8 N src pp" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>pp~=p__Inv4)\<or>(src~=p__Inv4\<and>pp=p__Inv4)\<or>(src~=p__Inv4\<and>pp~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>pp~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_8_NODE_GetVsinv__133:
assumes a1: "(\<exists> src pp. src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_8_NODE_Get N src pp)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src pp where a1:"src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_8_NODE_Get N src pp" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>pp~=p__Inv4)\<or>(src~=p__Inv4\<and>pp=p__Inv4)\<or>(src~=p__Inv4\<and>pp~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>pp~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_9__part__0Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_9__part__0 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_9__part__0 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_9__part__1Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_9__part__1 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_9__part__1 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_10_HomeVsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_10_Home N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_10_Home N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_10Vsinv__133:
assumes a1: "(\<exists> src pp. src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_10 N src pp)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src pp where a1:"src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_10 N src pp" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>pp~=p__Inv4)\<or>(src~=p__Inv4\<and>pp=p__Inv4)\<or>(src~=p__Inv4\<and>pp~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>pp~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_11Vsinv__133:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_11 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_11 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_GetX_NakVsinv__133:
assumes a1: "(\<exists> src dst. src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_GetX_Nak src dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src dst where a1:"src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_GetX_Nak src dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>dst~=p__Inv4)\<or>(src~=p__Inv4\<and>dst=p__Inv4)\<or>(src~=p__Inv4\<and>dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>dst~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_GetX_PutXVsinv__133:
assumes a1: "(\<exists> src dst. src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_GetX_PutX src dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src dst where a1:"src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_GetX_PutX src dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>dst~=p__Inv4)\<or>(src~=p__Inv4\<and>dst=p__Inv4)\<or>(src~=p__Inv4\<and>dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>dst~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst=p__Inv4)"
have "?P3 s"
apply (cut_tac a1 a2 b1, simp, rule_tac x="(neg (andForm (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''UniMsg'') p__Inv4) ''Cmd'')) (Const UNI_GetX)) (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''Proc'') p__Inv4) ''CacheState'')) (Const CACHE_E))))" in exI, auto) done
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst~=p__Inv4)"
have "?P3 s"
apply (cut_tac a1 a2 b1, simp, rule_tac x="(neg (andForm (andForm (andForm (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''UniMsg'') src) ''Cmd'')) (Const UNI_GetX)) (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''UniMsg'') src) ''HomeProc'')) (Const false))) (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''UniMsg'') p__Inv4) ''Cmd'')) (Const UNI_GetX))) (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''UniMsg'') p__Inv4) ''HomeProc'')) (Const false))))" in exI, auto) done
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_PutVsinv__133:
assumes a1: "(\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_Put dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain dst where a1:"dst\<le>N\<and>r=n_NI_Remote_Put dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(dst=p__Inv4)\<or>(dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(dst=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_PutXVsinv__133:
assumes a1: "(\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_PutX dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain dst where a1:"dst\<le>N\<and>r=n_NI_Remote_PutX dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "(dst=p__Inv4)\<or>(dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(dst=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_FAckVsinv__133:
assumes a1: "(r=n_NI_FAck )" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "?P1 s"
proof(cut_tac a1 a2 , auto) qed
then show "invHoldForRule s f r (invariants N)" by auto
qed
lemma n_NI_ShWbVsinv__133:
assumes a1: "(r=n_NI_ShWb N )" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__133 p__Inv4" apply fastforce done
have "?P1 s"
proof(cut_tac a1 a2 , auto) qed
then show "invHoldForRule s f r (invariants N)" by auto
qed
lemma n_NI_Remote_GetX_PutX_HomeVsinv__133:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_GetX_PutX_Home dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_GetX_PutX__part__0Vsinv__133:
assumes a1: "r=n_PI_Local_GetX_PutX__part__0 " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_WbVsinv__133:
assumes a1: "r=n_NI_Wb " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvAck_3Vsinv__133:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_NI_InvAck_3 N src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvAck_1Vsinv__133:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_NI_InvAck_1 N src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_GetX_GetX__part__1Vsinv__133:
assumes a1: "r=n_PI_Local_GetX_GetX__part__1 " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_GetX_GetX__part__0Vsinv__133:
assumes a1: "r=n_PI_Local_GetX_GetX__part__0 " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Remote_ReplaceVsinv__133:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_PI_Remote_Replace src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_ReplaceVsinv__133:
assumes a1: "r=n_PI_Local_Replace " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvAck_existsVsinv__133:
assumes a1: "\<exists> src pp. src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_InvAck_exists src pp" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Remote_PutXVsinv__133:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_PI_Remote_PutX dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Remote_Get_Put_HomeVsinv__133:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_Get_Put_Home dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvVsinv__133:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_NI_Inv dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_PutXVsinv__133:
assumes a1: "r=n_PI_Local_PutX " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_Get_PutVsinv__133:
assumes a1: "r=n_PI_Local_Get_Put " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_GetX_PutX_HeadVld__part__0Vsinv__133:
assumes a1: "r=n_PI_Local_GetX_PutX_HeadVld__part__0 N " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_ReplaceVsinv__133:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_NI_Replace src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Remote_GetX_Nak_HomeVsinv__133:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_GetX_Nak_Home dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Local_PutXAcksDoneVsinv__133:
assumes a1: "r=n_NI_Local_PutXAcksDone " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_GetX_PutX__part__1Vsinv__133:
assumes a1: "r=n_PI_Local_GetX_PutX__part__1 " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Remote_Get_Nak_HomeVsinv__133:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_Get_Nak_Home dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvAck_exists_HomeVsinv__133:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_NI_InvAck_exists_Home src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Replace_HomeVsinv__133:
assumes a1: "r=n_NI_Replace_Home " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Local_PutVsinv__133:
assumes a1: "r=n_NI_Local_Put " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Nak_ClearVsinv__133:
assumes a1: "r=n_NI_Nak_Clear " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_Get_GetVsinv__133:
assumes a1: "r=n_PI_Local_Get_Get " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Nak_HomeVsinv__133:
assumes a1: "r=n_NI_Nak_Home " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvAck_2Vsinv__133:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_NI_InvAck_2 N src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_GetX_PutX_HeadVld__part__1Vsinv__133:
assumes a1: "r=n_PI_Local_GetX_PutX_HeadVld__part__1 N " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__133 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
end
|
# AUTOGENERATED! DO NOT EDIT! File to edit: notebooks/01_synth_dataset.ipynb (unless otherwise specified).
__all__ = ['SynthDataset', 'gen_values', 'gen_added_n_deleted', 'exclude_element', 'build_interactions',
'build_features_from_df']
# Cell
import pandas as pd
import numpy as np
import random
from lightfm import LightFM
from lightfm.data import Dataset
from fastcore.all import *
random.seed(42)
# Cell
class SynthDataset():
'''
Instance of two states of a dataset, one at time **T** and the other at time **T+1**
where some users and items could had been added, deleted, and also their feautes
'''
def __init__(self):
self.all_users = []
self.all_items = []
self.all_user_features = []
self.all_item_features = []
self.before = {}
self.after = {}
self.users_added = []
self.users_deleted = []
# Cell
def gen_values(n_values=10, prefix='u'):
"Generates a list of values that will be used for generate the dataset"
l = []
for i in range(n_values):
l.append(prefix + str(i))
return l
# Cell
def gen_added_n_deleted(l_values, max_added=3, max_deleted=3):
'''
Generates two lists of values, one list will contain the values that will be deleted from the dataset,
and the second one will contain the values that will be added to the dataset.
'''
deleted = []
added = []
for i in l_values:
r = random.random()
if len(deleted) < max_deleted and r < 0.8:
deleted.append(i)
elif len(added) < max_added and r > 0.2:
added.append(i)
return added, deleted
# Cell
def exclude_element(l, values_to_exclude, shuffle=False):
"Excludes the elements from **values_to_exclude** from **l**"
new_l = [x for x in l if set(values_to_exclude).issuperset({x}) == False]
if shuffle: new_l.shuffle()
return new_l
# Cell
def build_interactions(l1, l2, l1_col_name='user_id', l2_col_name='item_id', sparsity=0.5):
'''
Builds interactions between l1 and l2.
The sparsity determines how sparse this interactions will be.
'''
interactions = {l1_col_name:[], l2_col_name:[]}
for i in l1:
for j in l2:
if random.random() < sparsity:
interactions[l1_col_name].append(i)
interactions[l2_col_name].append(j)
return pd.DataFrame(interactions)
# Cell
def build_features_from_df(feature_interactions_df, element_id_column, feature_column, tolist=True):
'''
Builds tuples of elements and its features to build the dataset
'''
unique_elements = feature_interactions_df[element_id_column].unique()
tuples = []
for e in unique_elements:
filtered_rows = feature_interactions_df[feature_interactions_df[element_id_column] == e]
feature_list = filtered_rows[feature_column].unique()
if tolist: feature_list = feature_list.tolist()
tuples.append((e, feature_list))
return tuples
# Cell
@patch
def build_synth_dataset(self:SynthDataset, n_users=10, n_items=10, max_added=3, max_deleted=3, print_added_n_deleted=False):
'''
This function generates two **datasets** to simulate changes through time from one dataset.
The first generated **dataset** is the state from the data in a time *t* and the second dataset
simulates the state from the data at a time *t+1* where some users and items where added and deleted,
and their metadata could be also updated (new metadata that expresses better the characteristics from that item, or just corrections)
'''
self.all_users = gen_values(n_values=n_users, prefix='u')
self.all_items = gen_values(n_values=n_items, prefix='i')
self.all_user_features = gen_values(prefix='uf')
self.all_item_features = gen_values(prefix='if')
self.users_added, self.users_deleted = gen_added_n_deleted(self.all_users, max_added=max_added, max_deleted=max_deleted)
if print_added_n_deleted: print('added users: {}\t deleted users: {}'.format(self.users_added, self.users_deleted))
self.items_added, self.items_deleted = gen_added_n_deleted(self.all_items, max_added=max_added, max_deleted=max_deleted)
if print_added_n_deleted: print('added items: {}\t deleted items: {}'.format(self.items_added, self.items_deleted))
self.before['user_id'] = exclude_element(self.all_users, self.users_added)
self.before['item_id'] = exclude_element(self.all_items, self.items_added)
self.after['user_id'] = exclude_element(self.all_users, self.users_deleted)
self.after['item_id'] = exclude_element(self.all_items, self.items_deleted)
if print_added_n_deleted: print('users before:\t{}\nusers after:\t{}'.format(self.before['user_id'], self.after['user_id']))
if print_added_n_deleted: print('items before:\t{}\nitems after:\t{}'.format(self.before['item_id'], self.after['item_id'])) |
[STATEMENT]
lemma (in CRR_market) rn_price_eq:
assumes "N = bernoulli_stream q"
and "0 < q"
and "q < 1"
and "der \<in> borel_measurable (G matur)"
and "n \<le> matur"
shows "rn_price N der matur n w = rn_price_ind N der matur n w"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. rn_price N der matur n w = rn_price_ind N der matur n w
[PROOF STEP]
using rn_rev_expl_cond_expect
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>?der \<in> borel_measurable (G ?matur); ?N = bernoulli_stream ?q; 0 < ?q; ?q < 1; ?n \<le> ?matur\<rbrakk> \<Longrightarrow> rn_rev_price ?N ?der ?matur ?n ?w = expl_cond_expect ?N (proj_stoch_proc geom_proc (?matur - ?n)) (discounted_value r (\<lambda>m. ?der) ?n) ?w
goal (1 subgoal):
1. rn_price N der matur n w = rn_price_ind N der matur n w
[PROOF STEP]
unfolding rn_price_def rn_price_ind_def
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>?der \<in> borel_measurable (G ?matur); ?N = bernoulli_stream ?q; 0 < ?q; ?q < 1; ?n \<le> ?matur\<rbrakk> \<Longrightarrow> rn_rev_price ?N ?der ?matur ?n ?w = expl_cond_expect ?N (proj_stoch_proc geom_proc (?matur - ?n)) (discounted_value r (\<lambda>m. ?der) ?n) ?w
goal (1 subgoal):
1. expl_cond_expect N (proj_stoch_proc geom_proc n) (discounted_value r (\<lambda>m. der) (matur - n)) w = rn_rev_price N der matur (matur - n) w
[PROOF STEP]
by (simp add: assms) |
# Analyst: Preshita
# Description of code: This script reproduces fig 1B which compares the postnatal and adult mice.
#set working directory
setwd('/projectnb/bf528/users/swiss_cheese_2022/project_2/analyst')
#loading in the data
data <- read.table('/projectnb/bf528/users/swiss_cheese_2022/project_2/programmer/cuffdiff_out/gene_exp.diff',header = TRUE)
#ordering by q-value in ascending order
data <- data[order(data$q_value),]
top_10_deg <-data[1:10, c('gene', 'value_1', 'value_2', 'log2.fold_change.', 'p_value', 'q_value')]
write.csv(top_10_deg, "top_10_deg.csv")
# Histogram of log2FC of all genes
hist(data$log2.fold_change., breaks=20, main='Histogram of Log2FoldChange of all genes', xlab = "Log2FoldChange Value")
# Subsetting the dataframe that contains significant genes
data.sub <- subset(data,significant=='yes')
# Histogram of log2FC of significant genes
hist(data.sub$log2.fold_change., breaks=20, main='Histogram of Log2FoldChange of significant genes', xlab = "Log2FoldChange Value")
# the difference between the first and the second histogram is that in the second histogram, you don't observe any Log2FC values in range of [-0.5,0.5].
#DEGs having p <0.01
pdegs <- subset(data.sub, p_value <0.01)
# Creating subset of up and down regulated genes
up_deg <- subset(pdegs,log2.fold_change.>0)
down_deg <- subset(pdegs,log2.fold_change.<0)
#number of upregulated genes
cat("Number of upregulated genes:",nrow(up_deg))
#number of downregulated genes
cat("Number of downregulated genes:",nrow(down_deg))
# writing out the genes names of up and down regulated genes
write.csv(up_deg$gene, file = 'upregulated_genes.csv', row.names = FALSE, quote = FALSE)
write.csv(down_deg$gene, file = 'downregulated_genes.csv', row.names = FALSE, quote = FALSE)
|
Formal statement is: lemma connected_sing [simp]: "connected {x}" Informal statement is: A singleton set is connected. |
# Análise da FRF por tratamento estatístico
Neste notebook avaliamos o uso do método de Welch para estimativas da FRF. Vamos considerar situações em que teremos
- Ruído contaminante apenas na saída do sistema: $x_m(t) = x(t)$ e $y_m(t) = y(t)+n_y(t)$ - situação comum
- Ruído contaminante apenas na entrada do sistema: $x_m(t) = x(t) + n_x(t)$ e $y_m(t) = y(t)$ - situação rara
- Ruído contaminante apenas na entrada e saída do sistema: $x_m(t) = x(t) + n_x(t)$ e $y_m(t) = y(t)+n_y(t)$
```python
# importar as bibliotecas necessárias
import numpy as np # arrays
import matplotlib.pyplot as plt # plots
plt.rcParams.update({'font.size': 14})
from scipy import signal
import IPython.display as ipd # to play signals
import sounddevice as sd
import soundfile as sf
```
# SLIT analisado
Vamos criar um SLIT, que receberá um sinal de entrada $x(t)$ e gerará um sinal de saída $y(t)$. O SLIT será representado por uma função chamada de ***black_box***. Aos sinais de entrada e/ou saída, podemos adicionar um ruído aleatório Gaussiano. Dessa, forma teremos uma medição do tipo:
```python
def black_box(xt, Fs = 44100, snr = 80, noise_at = 'both'):
""" SLIT black box
Author: Eric Brandão - 11/2020
This function emulates a SLIT measurement. System parameters
are used to generate a reference h(t) and FRF. We, then, compute
noiseless versions of x(t) and y(t) using the FFT. We add noise
to the signals. The SNR is calculated based on x(t). Finally,
we apply a low pass filter to emulate an anti-aliasing filter.
Parameters:
-------------
xt : numpy 1darray
Input signal
Fs : int
Sampling frequency
snr : float
Signal to noise ratio relative to x(t)
noise_at : str
Choose to which signal you apply noise. If 'out',
noise is applied only to y(t), if 'in', noise is applied
only to x(t). else, noise is applied to both signals
Returns:
------------
th : numpy 1darray
time vector of reference impulse response
h : numpy 1darray
reference impulse response
fh : numpy 1darray
frequency vector of reference FRF
H : numpy 1darray
reference FRF (Frequency Response Function)
ty : numpy 1darray
time vector of the output signal
yt : numpy 1darray
output signal with added noise
tx : numpy 1darray
time vector of the input signal
xt : numpy 1darray
input signal with added noise
"""
# System parameters
A = [2.3, 1.5]
f_res = [110, 415]
w_res = 2*np.pi*np.array(f_res)
zeta = [0.02, 0.01]
wd = np.sqrt(1-np.array(zeta)**2)*np.array(w_res)
# Reference impulse response
th = np.arange(0, 1, 1/Fs)
h=(A[0]/wd[0])*np.exp(-zeta[0]*w_res[0]*th)*np.sin(wd[0]*th) +\
(A[1]/wd[1])*np.exp(-zeta[1]*w_res[1]*th)*np.sin(wd[1]*th)
# reference frequency response
fh = np.linspace(0, (len(h)-1)*Fs/len(h), len(h))
H = (A[0]/(w_res[0]**2 - (2*np.pi*fh)**2 + 1j*2*zeta[0]*w_res[0]*(2*np.pi*fh)) +\
A[1]/(w_res[1]**2 - (2*np.pi*fh)**2 + 1j*2*zeta[1]*w_res[1]*(2*np.pi*fh)))*Fs
# Compute SLIT noiseless output
N = len(xt) + len(h) - 1
Xjw = np.fft.fft(xt, N)
Hjw = np.fft.fft(h, N)
Yjw = Xjw * Hjw
yt = np.real(np.fft.ifft(Yjw))
ty = np.linspace(0, (N-1)/Fs, N)
# add noise to signals
x_var = (np.std(xt))**2 # input RMS**2, assuming zero mean
noise_var_dB = 10*np.log10(x_var) - snr
noise_var = 10**(noise_var_dB/10)
if noise_at == 'out':
yt = yt + np.random.normal(loc=0, scale = np.sqrt(noise_var), size = len(yt))
elif noise_at == 'in':
xt = xt + np.random.normal(loc=0, scale = np.sqrt(noise_var), size = len(xt))
else:
yt = yt + np.random.normal(loc=0, scale = np.sqrt(noise_var), size = len(yt))
xt = xt + np.random.normal(loc=0, scale = np.sqrt(noise_var), size = len(xt))
print("xt var in dB {:.2f}".format(10*np.log10(x_var)))
print("noise_var in dB {:.2f}".format(10*np.log10(noise_var)))
# Complete xt with zeros
xt = np.concatenate([xt, np.zeros(N-len(xt))])
tx = np.linspace(0, (len(xt)-1)/Fs, len(xt))
# Anti aliasing
sos = signal.butter(10, 0.8*Fs/2, 'low', fs=Fs, output='sos')
xt = signal.sosfilt(sos, xt)
yt = signal.sosfilt(sos, yt)
return th, h, fh, H, ty, yt, tx, xt
```
# Criar uma versão de $x(t)$ sem anti-aliasing e ruído adicional
Este sinal, $x(t)$, é o sinal que você entregaria ao seu SLIT sem qualquer contaminação.
```python
fs = 10000
Tp = 10
time = np.arange(0, Tp, 1/fs)
# sinal aleatório completo - pré ruído e filtragem
xt = np.random.normal(loc = 0, scale = 1, size = len(time))
```
# Passar $x(t)$ pelo SLIT
Neste passo, vamos passar o sinal ao SLIT. O SLIT emula um sistema com duas ressonâncias e uma anti-ressonância. A função também emula a adição de ruído e o filtro anti-aliasing presente no seu conversor AD.
```python
th, h, fh, H, ty, yt, tx, xt = black_box(xt, Fs = fs,
snr = 50, noise_at = 'out')
# plot signal
plt.figure(figsize = (10, 3))
plt.plot(th, h, linewidth = 2, color = 'b')
plt.grid(linestyle = '--', which='both')
plt.ylabel(r'$h(t)$')
plt.xlim((0, th[-1]))
#plt.ylim((-4, 4))
plt.xlabel('Tempo [s]')
plt.title('Resp. ao impulso e FRF de referência')
plt.tight_layout()
plt.figure(figsize = (10, 6))
plt.subplot(2,1,1)
plt.semilogx(fh, 20*np.log10(np.abs(H)), linewidth = 2, color = 'b')
plt.grid(linestyle = '--', which='both')
plt.ylabel(r'$|H(j \omega)|$')
plt.xlim((10, fs/2))
#plt.ylim((-4, 4))
plt.xlabel('Frequência [Hz]')
plt.subplot(2,1,2)
plt.semilogx(fh, np.angle(H), linewidth = 2, color = 'b')
plt.grid(linestyle = '--', which='both')
plt.ylabel(r'$\angle H(j \omega)$ [rad]')
plt.xlim((10, fs/2))
#plt.ylim((-4, 4))
plt.xlabel('Frequência [Hz]')
plt.tight_layout()
```
# Inspecione $x(t)$ e $y(t)$ - talvez haja algum insight
```python
plt.figure(figsize = (10, 6))
plt.subplot(2,1,1)
plt.plot(tx, xt, linewidth = 1, color = 'b', alpha = 0.7)
plt.grid(linestyle = '--', which='both')
plt.ylabel(r'$x(t)$')
plt.xlim((0, ty[-1]))
plt.xlabel('Tempo [s]')
plt.subplot(2,1,2)
plt.plot(ty, yt, linewidth = 1, color = 'b', alpha = 0.7)
plt.grid(linestyle = '--', which='both')
plt.ylabel(r'$y(t)$')
plt.xlim((0, ty[-1]))
plt.xlabel('Tempo [s]')
plt.tight_layout()
```
# Podemos ouvir os sinais
```python
ipd.Audio(xt, rate=fs) # load a NumPy array
```
<audio controls="controls" >
<source src="data:audio/wav;base64,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" type="audio/wav" />
Your browser does not support the audio element.
</audio>
```python
ipd.Audio(yt, rate=fs) # load a NumPy array
```
<audio controls="controls" >
<source src="data:audio/wav;base64,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" type="audio/wav" />
Your browser does not support the audio element.
</audio>
# Computar a FRF via $S_{xy}$ e $S_{xx}$
Vamos usar o estimador $H_1$, dado por
\begin{equation}
H_1(\mathrm{j}\omega) = \frac{S_{xy}(\mathrm{j}\omega)}{S_{xx}(\mathrm{j}\omega)}
\tag{1}
\end{equation}
# Vamos computar todos os auto-espectros e espectros cruzados
- $S_{xx}(\mathrm{j}\omega)$
- $S_{yy}(\mathrm{j}\omega)$
- $S_{xy}(\mathrm{j}\omega)$
- $S_{yx}(\mathrm{j}\omega)$
```python
# Parâmetros da FRF - válidos para todas as análises subsequentes
win_size = 4096
win = signal.windows.hann(win_size)
noverlap = win_size/2
nfft = win_size
# Vamos computar os auto-espectros e espectros cruzados
_, Sxx = signal.csd(xt, xt, fs, window = win, noverlap = noverlap, nfft = nfft, scaling = 'spectrum')
_, Syy = signal.csd(yt, yt, fs, window = win, noverlap = noverlap, nfft = nfft, scaling = 'spectrum')
freq, Sxy = signal.csd(xt, yt, fs, window = win, noverlap = noverlap, nfft = nfft, scaling = 'spectrum')
_, Syx = signal.csd(yt, xt, fs, window = win, noverlap = noverlap, nfft = nfft, scaling = 'spectrum')
# Escrever a resolução do espectro
print("O tamanho da janela é de {:.2f} [s]".format(win_size/fs))
print("A resolução do espectro estimado é {:.2f} [Hz]".format(freq[2]-freq[1]))
```
O tamanho da janela é de 0.41 [s]
A resolução do espectro estimado é 2.44 [Hz]
# Computar a FRF via $S_{xy}$ e $S_{xx}$
Vamos usar o estimador $H_1$, dado por
\begin{equation}
H_1(\mathrm{j}\omega) = \frac{S_{xy}(\mathrm{j}\omega)}{S_{xx}(\mathrm{j}\omega)}
\tag{1}
\end{equation}
Note as relações de equivalência
\begin{equation}
H_1(\mathrm{j}\omega) = \frac{S_{xy}(\mathrm{j}\omega)}{S_{xx}(\mathrm{j}\omega)} \equiv \frac{X^{*}(\mathrm{j}\omega)Y(\mathrm{j}\omega)}{X^{*}(\mathrm{j}\omega)X(\mathrm{j}\omega)} \equiv \frac{Y(\mathrm{j}\omega)}{X(\mathrm{j}\omega)}
\end{equation}
```python
# Estimador H1
H1 = Sxy/Sxx
# Plot
plt.figure(figsize = (10, 6))
plt.subplot(2,1,1)
plt.semilogx(fh, 20*np.log10(np.abs(H)), linewidth = 2, color = 'b', label = 'ref.')
plt.semilogx(freq, 20*np.log10(np.abs(H1)), linewidth = 2, color = 'r', alpha=0.7, label = r'estimado - $H_1$')
plt.legend(loc = 'upper right')
plt.grid(linestyle = '--', which='both')
plt.ylabel(r'$|H(j \omega)|$')
plt.xlim((10, 0.8*fs/2))
plt.ylim((-100, 20))
plt.xlabel('Frequência [Hz]')
plt.subplot(2,1,2)
plt.semilogx(fh, np.angle(H), linewidth = 2, color = 'b')
plt.semilogx(freq, np.angle(H1), linewidth = 2, color = 'r', alpha=0.7)
plt.grid(linestyle = '--', which='both')
plt.ylabel(r'$\angle H(j \omega)$ [rad]')
plt.xlim((10, 0.8*fs/2))
#plt.ylim((-4, 4))
plt.xlabel('Frequência [Hz]')
plt.tight_layout()
```
# Computar a coerência
A função de coerência nos dá uma ideia da qualidade da nossa medição. É uma grandeza variando de $0.0$ a $1.0$, em que $1.0$ representa uma relação perfeitamente linear entre entrada e saída. Valores baixos de coerência estão associados à:
- presença de ruído,
- não linearidades, e
- pequenos erros na estimativa dos espctros.
A coerência é dada por
\begin{equation}
\gamma^{2}(\mathrm{j}\omega) = \frac{|S_{xy}(\mathrm{j}\omega)|^2}{S_{xx}(\mathrm{j}\omega) S_{yy}(\mathrm{j}\omega)}
\tag{2}
\end{equation}
```python
gamma2 =((np.abs(Sxy))**2)/(Sxx * Syy)
# Plot
plt.figure(figsize = (10, 3))
plt.semilogx(freq, gamma2, linewidth = 2, color = 'r', alpha=0.7)
plt.grid(linestyle = '--', which='both')
plt.ylabel(r'$|\gamma^{2}(j \omega)|$')
plt.xlim((10, 0.8*fs/2))
plt.ylim((0, 1.2))
plt.xlabel('Frequência [Hz]');
```
# Computar a FRF via $S_{yy}$ e $S_{yx}$
Vamos usar o estimador $H_2$, dado por
\begin{equation}
H_2(\mathrm{j}\omega) = \frac{S_{yy}(\mathrm{j}\omega)}{S_{yx}(\mathrm{j}\omega)}
\tag{3}
\end{equation}
Note as relações de equivalência
\begin{equation}
H_2(\mathrm{j}\omega) = \frac{S_{yy}(\mathrm{j}\omega)}{S_{yx}(\mathrm{j}\omega)} \equiv \frac{Y^{*}(\mathrm{j}\omega)Y(\mathrm{j}\omega)}{Y^{*}(\mathrm{j}\omega)X(\mathrm{j}\omega)} \equiv \frac{Y(\mathrm{j}\omega)}{X(\mathrm{j}\omega)}
\end{equation}
```python
# Estimador H2
H2 = Syy/Syx
# Plot
plt.figure(figsize = (10, 6))
plt.subplot(2,1,1)
plt.semilogx(fh, 20*np.log10(np.abs(H)), linewidth = 2, color = 'b', label = 'ref.')
plt.semilogx(freq, 20*np.log10(np.abs(H2)), linewidth = 2, color = 'r', alpha=0.7, label = r'estimado - $H_2$')
plt.legend(loc = 'upper right')
plt.grid(linestyle = '--', which='both')
plt.ylabel(r'$|H(j \omega)|$')
plt.xlim((10, 0.8*fs/2))
plt.ylim((-100, 20))
plt.xlabel('Frequência [Hz]')
plt.subplot(2,1,2)
plt.semilogx(fh, np.angle(H), linewidth = 2, color = 'b')
plt.semilogx(freq, np.angle(H2), linewidth = 2, color = 'r', alpha=0.7)
plt.grid(linestyle = '--', which='both')
plt.ylabel(r'$\angle H(j \omega)$ [rad]')
plt.xlim((10, 0.8*fs/2))
#plt.ylim((-4, 4))
plt.xlabel('Frequência [Hz]')
plt.tight_layout()
```
# Computar a FRF via $H_{T}$
Vamos usar o estimador $H_T$, dado por
\begin{equation}
H_T(\mathrm{j}\omega) = \frac{S_{yy}(\mathrm{j}\omega) - S_{xx}(\mathrm{j}\omega) + \sqrt{[S_{xx}(\mathrm{j}\omega) - S_{yy}(\mathrm{j}\omega)]^2+4|S_{xy}(\mathrm{j}\omega)|^2}}{2 S_{yx}(\mathrm{j}\omega)}
\tag{4}
\end{equation}
```python
# Estimador HT
HT = (Syy - Sxx + np.sqrt((Sxx - Syy)**2 + 4*(np.abs(Sxy))**2))/(2 * Syx)
# Plot
plt.figure(figsize = (10, 6))
plt.subplot(2,1,1)
plt.semilogx(fh, 20*np.log10(np.abs(H)), linewidth = 2, color = 'b', label = 'ref.')
plt.semilogx(freq, 20*np.log10(np.abs(HT)), linewidth = 2, color = 'r', alpha=0.7, label = r'estimado - $H_T$')
plt.legend(loc = 'upper right')
plt.grid(linestyle = '--', which='both')
plt.ylabel(r'$|H(j \omega)|$')
plt.xlim((10, 0.8*fs/2))
plt.ylim((-100, 20))
plt.xlabel('Frequência [Hz]')
plt.subplot(2,1,2)
plt.semilogx(fh, np.angle(H), linewidth = 2, color = 'b')
plt.semilogx(freq, np.angle(HT), linewidth = 2, color = 'r', alpha=0.7)
plt.grid(linestyle = '--', which='both')
plt.ylabel(r'$\angle H(j \omega)$ [rad]')
plt.xlim((10, 0.8*fs/2))
#plt.ylim((-4, 4))
plt.xlabel('Frequência [Hz]')
plt.tight_layout()
```
|
If $a$ is an element of $s$, then $a_j \leq b_j$ for all $j$. |
lemma interior_limit_point [intro]: fixes x :: "'a::perfect_space" assumes x: "x \<in> interior S" shows "x islimpt S" |
import game.series.L01defs
namespace xena
-- begin hide
-- if we want to use sigma notation, use
-- import algebra.big_operators
-- open_locale big_operators
-- https://leanprover-community.github.io/mathlib_docs/algebra/big_operators.html
-- end hide
/-
If $\sum a_n$ converges, then $a_n \to 0$.
We take the approach of showing that $(S_n) → M$ then $(S_{n+1}) → M$,
and then using the fact that $a_{n+1} = S_{n+1} - S_n$.
-/
def kth_partial_sum (a : ℕ → ℝ) (k : ℕ) := (finset.range (k+1)).sum a
def seq_partials_over (a : ℕ → ℝ ) : ℕ → ℝ := (λ (n : ℕ), kth_partial_sum a n )
def series_converges (a : ℕ → ℝ) := is_convergent (seq_partials_over a)
/- Lemma
If partial sum sequence of $a_n$ convergent, $a_n → 0$.
-/
lemma seqlim_0_if_sum_converges (a : ℕ → ℝ) :
series_converges a → is_limit a 0 :=
begin
intro h,
cases h with M Mislimit,
-- shift_rule to show that shifted sequence of partial sums also tends to M
have fact := shift_rule (seq_partials_over a) 1 M,
have fact2 := iff.mp fact Mislimit,
-- express `a (m+1)` using partial sums, sum_range_succ seems best way
have fact3 : ∀ m : ℕ, kth_partial_sum a (m+1)
= a (m+1) + kth_partial_sum a (m),
intro m, from finset.sum_range_succ a (m+1),
--we really want fact4, but sum_range_succ couldn't do it directly?
have fact4 : ∀ (m : ℕ), a (m + 1) = kth_partial_sum a (m+1) - kth_partial_sum a (m),
intro n,
specialize fact3 n, -- do I need to do this to reorganise inside quantiifer?
linarith,
-- we can rewrite our goal in terms of `a` shifted by +1
have fact5 : is_limit a 0 ↔ is_limit (λ (m : ℕ), a (m+1)) 0,
from shift_rule a 1 0,
rw fact5,
have fact6:
(λ (n : ℕ), a (n + 1)) = λ (n: ℕ), (kth_partial_sum a (n + 1) - kth_partial_sum a n),
exact funext fact4, -- suggest gave me this!
rw fact6,
unfold seq_partials_over at Mislimit fact2, -- just for clarity
have fact7 := lim_linear
(λ (n : ℕ), kth_partial_sum a (n + 1))
(λ (n : ℕ), kth_partial_sum a n)
M M 1 (-1) fact2 Mislimit,
simp at fact7,
exact fact7,
end
end xena
|
input := ImportMatrix("AoC-2021-1-input.txt" ):
scan := (v,d)->ifelse(d[2]<0,[v,0],
[v, ifelse(v<=d[1], d[2], d[2]+1)]);
rtable_scanblock(input, [], noindex, scan, [-1,-1] )[2]; # part 1 answer
windows := Array([seq(input[i]+input[i+1]+input[i+2],
i=1..numelems(input)-2)]);
rtable_scanblock(windows, [], noindex, scan, [-1,-1])[2]; # part 2 answer
|
#include <ebbrt/Runtime.h>
#include <ebbrt/EbbAllocator.h>
#include <ebbrt/EbbRef.h>
#include <ebbrt/LocalIdMap.h>
#include <ebbrt/GlobalIdMap.h>
#include <ebbrt/Debug.h>
#include "Unix.h"
//#define _DO_CRC_
#ifdef _DO_CRC_
#include <boost/crc.hpp>
#endif
#ifndef __EBBRT_BM__
ebbrt::Future<ebbrt::EbbRef<UNIX::Environment>>
UNIX::Environment::Init()
{
std::string str;
for (int i=0; ::environ[i]!=NULL; i++) {
str.append(::environ[i]);
str.push_back(0);
}
#ifdef _DO_CRC_
{
const char *data = str.data();
int len = str.size();
boost::crc_32_type crc;
crc.process_bytes( data, len );
printf("%s: data=%p len=%d crc=0x%x\n", __PRETTY_FUNCTION__,
data, len, crc.checksum());
}
#endif
return ebbrt::global_id_map->Set(kEnvironmentId, std::move(str))
.Then([](ebbrt::Future<void> f) {
f.Get();
return ebbrt::EbbRef<Environment>(kEnvironmentId);
});
}
#endif
#ifndef __EBBRT_BM__
UNIX::Environment::Environment(Root *root) : myRoot_(root), environ_(NULL) {
auto fstr = myRoot_->getString();
assert(fstr.Ready());
std::string& str = fstr.Get();
const char *data = str.data();
int len = str.size();
#ifdef _DO_CRC_
{
boost::crc_32_type crc;
crc.process_bytes( data, len );
printf("%s: data=%p len=%d crc=0x%x\n", __PRETTY_FUNCTION__,
data, len, crc.checksum());
}
#endif
}
#else
UNIX::Environment::Environment(Root *root) : myRoot_(root), environ_(NULL)
{
// add code here to initialized argc and argv from root data pointer
auto fstr = myRoot_->getString();
assert(fstr.Ready());
std::string& str = fstr.Get();
const char *data = str.data();
int len = str.size();
int i,j,numvar;
#ifdef _DO_CRC_
{
boost::crc_32_type crc;
crc.process_bytes( data, len );
ebbrt::kprintf("%s: data=%p len=%d crc=0x%x\n", __PRETTY_FUNCTION__,
data, len, crc.checksum());
}
#endif
numvar = 0;
for (i=0; i<len; i++) if (data[i] == 0) numvar++;
environ_ = (char **)malloc(sizeof(char *)*numvar);
environ_[numvar] = NULL;
for (i=0,j=1,environ_[0]=(char *)data; j < numvar; i++) {
if (data[i] == 0) { environ_[j]=(char *)&(data[i+1]); j++; }
}
::environ = environ_;
}
#endif
UNIX::Environment::Root::Root(ebbrt::EbbId id) : myId_(id), theRep_(NULL) {
data_ = ebbrt::global_id_map->Get(id).Share();
}
UNIX::Environment *
UNIX::Environment::Root::getRep_BIN() {
std::lock_guard<std::mutex> lock{lock_};
if (theRep_) return theRep_; // implicity drop lock
lock_.unlock(); // drop lock
data_.Block(); // if necessary wait for our root data to be ready
// blocks as needed but when done the data is there
data_.Get(); // do a get on the future to ensure
// that we throw any errors that occurred during
// getting the data
lock_.lock(); // reaquire lock
if (theRep_ == NULL) {
// now that we are ready create the rep if necessary
theRep_ = new Environment(this);
}
return theRep_; // implicity drop lock
}
// I am modeling this based on the following example from TBB doc
// http://www.threadingbuildingblocks.org/docs/help/reference/containers_overview/concurrent_hash_map_cls/concurrent_operations.htm
// extern tbb::concurrent_hash_map<Key,Resource,HashCompare> Map;
// void ConstructResource( Key key ) {
// accessor acc;
// if( Map.insert(acc,key) ) {
// // Current thread inserted key and has exclusive access.
// ...construct the resource here...
// }
// // Implicit destruction of acc releases lock
// }
// void DestroyResource( Key key ) {
// accessor acc;
// if( Map.find(acc,key) ) {
// // Current thread found key and has exclusive access.
// ...destroy the resource here...
// // Erase key using accessor.
// Map.erase(acc);
// }
// }
UNIX::Environment &
UNIX::Environment::HandleFault(ebbrt::EbbId id) {
retry:
{
ebbrt::LocalIdMap::ConstAccessor rd_access;
if (ebbrt::local_id_map->Find(rd_access, id)) {
// COMMON: "HOT PATH": NODE HAS A ROOT ESTABLISHED
// EVERYONE MUST EVENTUALLY GET HERE OR THROW AND EXCEPTION
// Found the root get a rep and return
auto &root = *boost::any_cast<Root *>(rd_access->second);
rd_access.release(); // drop lock
// NO LOCKS;
auto &rep = *(root.getRep_BIN()); // this may block internally
ebbrt::EbbRef<Environment>::CacheRef(id, rep);
// The sole exit path out of handle fault
return rep; // drop rd_access lock by exiting outer scope
}
}
// failed to find root: NO LOCK held and we need to establish a root for this node
ebbrt::LocalIdMap::Accessor wr_access;
if (ebbrt::local_id_map->Insert(wr_access, id)) {
// WRITE_LOCK HELD: THIS HOLDS READERS FROM MAKING PROGESS
// ONLY ONE WRITER EXITS
Root *root = new Root(id);
wr_access->second = root;
wr_access.release(); // WE CAN NOW DROP THE LOCK and retry as a normal reader
}
// NO LOCKS HELD
// if we failed to insert then someone else must have beat us
// and is the writer and will eventuall fill in the entry.
// all we have to do is retry a read on the entry
goto retry;
}
void UNIX::Environment::destroy() { ebbrt::kabort(); }
|
# require(roxygen2); roxygenize('/Users/or105/git/R0t/covid19AgeModel')
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
process_make_pop_info <- function(pop_count, pop_by_age, darea)
{
# make age category info
tmp <- levels(pop_by_age$age)
da <- data.table(age.cat= seq_along(tmp), age.cat.label= tmp)
da[, age.cat.from:= as.integer(gsub('\\+','',gsub('([0-9]+)-([0-9]+)','\\1', age.cat.label)))]
da[, age.cat.to:= as.integer(gsub('85\\+','99',gsub('([0-9]+)-([0-9]+)','\\2', age.cat.label)))]
# make data table holding pops by loc
tmp <- as.data.table(pop_by_age)
stopifnot( c('state','age','pop')%in%colnames(tmp))
tmp <- subset(tmp, select=c(age, state, pop))
setnames(tmp,c('age','state','pop'),c('age.cat.label','loc_label','prop_pop'))
da <- merge(da, tmp, by='age.cat.label')
set(da, NULL, 'loc_label', da[, as.character(loc_label)])
set(da, NULL, 'loc_label', da[, gsub('_',' ',loc_label)])
# add total pop counts
tmp <- as.data.table(pop_count)
setnames(tmp, c('Region','code','popt'), c('loc_label','loc','pop_total'))
set(tmp, NULL, 'loc_label', tmp[, as.character(loc_label)])
set(tmp, NULL, 'loc', tmp[, as.character(loc)])
set(tmp, NULL, 'loc_label', tmp[, gsub('_',' ',loc_label)])
stopifnot( all( unique(sort(da$loc_label))==unique(sort(tmp$loc_label)) ) )
da <- merge( da, tmp, by=c('loc_label'))
# add land area
stopifnot( all(sort(darea$loc_label)==unique(sort(da$loc_label))) )
da <- merge(da, darea, by='loc_label')
# make variables
da[, pop:= prop_pop*pop_total]
da[, pop_sqm:= pop/land_area_sqm]
da
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
#' @importFrom stats predict
process_make_contact_matrix_by_country_using_popp_logpopdens_model <- function(pop_info, dpolymod_type, path_to_polymod_data)
{
stopifnot(dpolymod_type%in%c('weekend','weekday','anyday'))
# read polymod data
dps <- readRDS(path_to_polymod_data)
dps <- subset(dps, TYPE==dpolymod_type)
# check correct dimensions
stopifnot(all(sort(unique(dps$part.age.cat.label))==sort(unique(pop_info$age.cat.label))))
stopifnot(all(sort(unique(dps$cont.age.cat.label))==sort(unique(pop_info$age.cat.label))))
# train model
dtrain <- subset(dps, select=c(m, cont_pop_p, cont_pop_dens, part.age.cat.label2, cont.age.cat.label2, LOC ))
model <- lm(log(m) ~ cont_pop_p + log(cont_pop_dens) + part.age.cat.label2 : cont.age.cat.label2 - 1L, data=dtrain)
# make prediction data set
dpr <- unique(subset(dps, select=c(cont.age.cat,cont.age.cat.label2,part.age.cat,part.age.cat.label2)))
tmp <- subset(pop_info, select=c(loc, age.cat, pop, prop_pop, land_area_sqm))
tmp[, land_area_sqkm:= land_area_sqm*2.589]
tmp[, cont_pop_dens:= pop/ land_area_sqkm]
setnames(tmp, c('age.cat','prop_pop','loc'), c('cont.age.cat','cont_pop_p','LOC'))
dpr <- merge(dpr, tmp, by=c('cont.age.cat'), allow.cartesian=TRUE)
set(dpr, NULL, c('cont.age.cat','part.age.cat','land_area_sqkm','land_area_sqm','pop'), NULL)
# predict
tmp <- stats::predict(model, dpr, interval = "prediction")
colnames(tmp) <- c('lm','lm_pr_cl','lm_pr_cu')
dpr <- cbind(dpr, tmp)
set(dpr, NULL, 'm', dpr[,exp(lm)]) # log median --> median
set(dpr, NULL, 'm_pr_cl', dpr[,exp(lm_pr_cl)]) # log 2.5% --> 2.5%
set(dpr, NULL, 'm_pr_cu', dpr[,exp(lm_pr_cu)]) # log 97.5% --> 97.5%
set(dpr, NULL, c('cont_pop_p','cont_pop_dens','lm','lm_pr_cl','lm_pr_cu'), NULL)
# return
tmp <- unique(subset(dps, select=c(cont.age.cat,cont.age.cat.label,cont.age.cat.label2,part.age.cat,part.age.cat.label,part.age.cat.label2)))
dpr <- merge(tmp, dpr, by=c('cont.age.cat.label2','part.age.cat.label2'))
setnames(dpr, 'LOC', 'loc')
tmp <- unique(subset(pop_info, select=c(loc,loc_label)))
dpr <- merge(tmp, dpr, by='loc')
set(dpr, NULL, c('m_pr_cl','m_pr_cu','cont.age.cat.label2','part.age.cat.label2'), NULL)
dpr
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
process_make_contact_matrix_by_country_using_logpop_model <- function(pop_info, dpolymod_type, path_to_logpopmodel)
{
stopifnot(dpolymod_type%in%c('weekend','weekday','anyday'))
# read model
dm <- readRDS(path_to_logpopmodel)
dm <- subset(dm, TYPE==dpolymod_type)
# check correct dimensions
stopifnot(all(sort(unique(dm$part.age.cat.label))==sort(unique(pop_info$age.cat.label))))
stopifnot(all(sort(unique(dm$cont.age.cat.label))==sort(unique(pop_info$age.cat.label))))
# predict m
dm <- subset(dm, select=c(part.age.cat, part.age.cat.label, cont.age.cat, cont.age.cat.label, lm_intercept, lm_slope))
tmp <- subset(pop_info, select=c(loc, loc_label, age.cat, age.cat.label, pop))
setnames(tmp, c('age.cat','age.cat.label','pop'), c('cont.age.cat','cont.age.cat.label','cont.pop'))
dm <- merge(dm, tmp, by=c('cont.age.cat','cont.age.cat.label'), allow.cartesian=TRUE)
dm[, m:= exp(lm_intercept + (1+lm_slope)*log(cont.pop))]
dm <- subset(dm, select=-c(lm_intercept, lm_slope, cont.pop))
dm
}
#' @export
#' @keywords internal
#' @import data.table ggplot2
process_make_smoothed_logcases <- function(death_data, plot_dir=NA_character_)
{
dd <- as.data.table(death_data)
setkey(dd, state, date)
tmp <- dd[, list(date=date,
dateIdx= seq_along(date),
cdeaths=cumsum(Deaths)),
by=c('code')]
dd <- merge(tmp, dd, by=c('code','date'))
# only smooth data from the calendar week with 10 cum deaths onwards
dd[, week:=as.integer(strftime(date, format = "%V"))]
tmp <- dd[cdeaths>=10, list(week=unique(week)), by='code']
dd <- merge(dd, tmp, by=c('code','week'))
# calculate average cases by week to bypass strong day of the week effects
# calculate log average cases so loess derived confidence intervals are strictly pos on natural scale
dd <- dd[, list(wc= mean(Cases)), by=c('code','state','week')]
set(dd, which(dd$wc==0), 'wc', 1.)
dd[, lwc:= log(wc)]
# get loess smooth with CI from t distribution
tmp <- dd[,
{
nonzero <- which(wc!=0)
lwc_nz <- lwc[nonzero]
week_nz <- week[nonzero]
tmp <- stats::loess(lwc_nz ~ week_nz, span=0.4)
tmp <- predict(tmp, data.frame(week_nz=week), se = TRUE)
list(week=week, lmean= tmp$fit, lsd= tmp$se.fit, tdf= tmp$df)
},
by=c('code')]
dd <- merge(dd, tmp, by=c('code','week'))
dd[, lcl:= lmean + qt(0.025, tdf)*lsd]
dd[, lcu:= lmean + qt(0.975, tdf)*lsd]
# plot
if(!is.na(plot_dir))
{
ggplot(dd) +
geom_ribbon(aes(x=week, ymin=lcl, ymax=lcu), fill='black', alpha=0.25) +
geom_line(aes(x=week, y=lmean)) +
geom_point(aes(x=week, y=lwc), colour='DeepSkyBlue') +
facet_wrap(~state, ncol=5) +
labs(x='calendar week', y='log reported COVID-19 cases, average by week') +
theme_bw()
ggsave(file.path(plot_dir,'log_reported_cases.pdf'), w=15, h=25)
}
dd
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
process_make_contact_matrix_by_country<- function(dpolymod, pop_info, args_with_contacts_adjusted_for_age)
{
# check that age buckets agree between dpolymod and pop_by_age
tmp <- unique(subset(dpolymod, select=c(part.age.cat, part.age.cat.label)))
stopifnot( all( sort(unique(pop_info$age.cat.label)) == sort(tmp$part.age.cat.label) ) )
tmp <- unique(subset(dpolymod, select=c(cont.age.cat, cont.age.cat.label)))
stopifnot( all( sort(unique(pop_info$age.cat.label)) == sort(tmp$cont.age.cat.label) ) )
tmp <- subset(pop_info, select=c(loc, loc_label, age.cat, age.cat.label, pop, pop_sqm, prop_pop))
tmp2 <- tmp[, list( pop_ntl=mean(pop),
pop_sqm_ntl= mean(pop_sqm),
prop_pop_ntl= sum( prop_pop * pop / sum(pop) )
), by='age.cat']
tmp <- merge(tmp, tmp2, by='age.cat')
setnames(tmp, c('age.cat','age.cat.label'), c('cont.age.cat','cont.age.cat.label'))
dc <- merge(dpolymod, tmp, by=c('cont.age.cat','cont.age.cat.label'),allow.cartesian=TRUE)
dc[, cont.pop.polymod := m/c]
dc[, cont.pop.effective.loc := cont.pop.polymod * prop_pop / prop_pop_ntl]
if(args_with_contacts_adjusted_for_age)
{
cat('\nAdjusting expected number of contacts by age distribution in location ...')
dc[, m:= cont.pop.effective.loc * c]
}
dc <- subset(dc, select=c(loc, loc_label, cont.age.cat, cont.age.cat.label, part.age.cat, part.age.cat.label, m))
dc
}
#' @export
#' @keywords internal
#' @import data.table
stan_data_add_initA_array_20_54 <- function(processed_data)
{
processed_data$stan_data$N_init_A <- 7
processed_data$stan_data$init_A <- seq.int(5, by=1, len=7)
processed_data
}
#' @export
#' @keywords internal
#' @import data.table
stan_data_add_initA_array_5_29 <- function(processed_data)
{
processed_data$stan_data$N_init_A <- 5
processed_data$stan_data$init_A <- seq.int(2, by=1, len=5)
processed_data
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_pairwise_mobility_trends <- function(processed_data,file_chi)
{
tmp <- readRDS(file_chi)
chi <- tmp[['chi']]
map_chi <- tmp[['map_chi']]
processed_data$stan_data$chi <- chi[map_chi,map_chi]
processed_data
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
#' @importFrom lubridate days decimal_date
#' @importFrom dplyr bind_rows
make_stan_data_core <- function(states,
mobility_data,
death_data,
deathByAge_data,
ifr.by.age,
serial_interval,
pop_info,
dcontact,
num_days_sim,
forecast)
{
# states: vector
# states you want to consider for analysis, must be in code format (i.e., for Washington, use WA)
# death_data: data table
# Death and case data by state name, state code, and date
# with variables: date, Cases, Deaths, state, code
# deathByAge_data: list
# deathByAge_data$deaths_data: list by state
# for every state a matrix with date by row and age by column.
# the number of column is fixed to the number of contact_band. If the number of age groups < contact_band, empty columns are filled with -1
# the first row corresponds to the first date d at which overall death were observed in the state. If first day of observed death by age < d, empty rows are filled with -1
# deathByAge_data$map_age: list by state
# for every state a matrix M with contact band by row and state age groups by column
# M_ij = 1 if j \in i
# deathByAge_data$dataByAgestart: list by state
# for every state integer corresponding to the first day with death by age data on the overall death scale
# deathByAge_data$A_AD: list by state
# for every state integer corresponding to the number of age groups provided by the state
# ifr and population count by state name and state code
# variables are state, code, ifr and popt
# ifr.by.age: data table
# mean, cl, cu of ifr by age obtained from Verity, 2020.
# also provide hyperparameters alpha and beta of a beta distribution given the mean and confidence interval
# serial_interval: data table
# serial interval by days since infection
# variables are X, days since infection, and fit, the serial interval
# pop by age: matrix
# rows are age band and columns are state
# element i,j is the proportion of population of state j in age group i
# num_days_sim: integer
# number of days to simulate
# equals to the number of days in death_data + forecast
# forecast: integer
# number of days to forecast
# various distributions required for modeling
set.seed(5678) # make reproducible
mean1 <- 5.1; cv1 <- 0.86; # infection to onset
mean2 <- 18.8; cv2 <- 0.45 # onset to death
x1 <- rgammaAlt(1e6,mean1,cv1) # infection-to-onset distribution
x2 <- rgammaAlt(1e6,mean2,cv2) # onset-to-death distribution
ecdf_death <- ecdf(x1+x2)
# disrectise to days since infection
ifr_by_dsi <- vector('numeric',num_days_sim)
ifr_by_dsi[1] <- ecdf_death(1.5) - ecdf_death(0)
for(s in 2:num_days_sim)
{
ifr_by_dsi[s] <- ecdf_death(s+.5) - ecdf_death(s-.5)
}
set.seed(5678) # make reproducible
mean1 <- 5.1; cv1 <- 0.86; # infection to onset
mean2 <- 14; cv2 <- 3.57 # onset to antibody
x1 <- rgammaAlt(1e6,mean1,cv1) # infection-to-onset distribution
x2 <- rnorm(1e6,mean2,cv2) # onset-to-antibody distribution
ecdf_death <- ecdf(x1+x2)
# disrectise to days since infection
iar_by_dsi <- vector('numeric',num_days_sim)
iar_by_dsi[1] <- ecdf_death(1.5) - ecdf_death(0)
for(s in 2:num_days_sim)
{
iar_by_dsi[s] <- ecdf_death(s+.5) - ecdf_death(s-.5)
}
# serial intervention cut
serial.interval.cut <- length( which(serial_interval$fit * 5e6 >= 1 ) )
# contact bands
cntct_bands <- max( dcontact$part.age.cat )
# states with death data by age
states_ad <- which( states %in% names(deathByAge_data$A_AD) )
# states without death data by age
states_od <- which( !states %in% states[states_ad] )
# first column, 1 if country has death by age data
# second column, index within state with death by age data
map_country = matrix(nrow = length(states), ncol = 2, 0)
map_country[states_ad, 1] = 1
map_country[states_ad, 2] = 1:length(states_ad)
# map the age reported by the state to 5y age groups
map_age = aperm(array(unlist(deathByAge_data$map_age[states[states_ad]]), dim=c(cntct_bands, cntct_bands, length(states_ad))), c(3, 1, 2))
# going over each region
dates <- list()
reported_cases <- list()
deaths_by_state <- list()
stan_data <- list(
# constants
M = length(states), # number of states
M_AD = length(states_ad), # number of countries with age-specific death counts
N0 = 6L, # N0 = 6 to make it consistent with Rayleigh
N = vector('integer',length(states)), # days of observed data for country m. each entry must be <= N2
N2 = as.integer(num_days_sim), # days of observed data + # of days to forecast
A = as.integer(cntct_bands), # number of age bands
SI_CUT = serial.interval.cut, # number of days in serial interval to consider
WKEND_IDX_N= vector('integer',length(states)), # number of weekend indices in each location
# data
pop = vector('numeric',length(states)), # population counts
popByAge = matrix(NA_integer_, as.integer(cntct_bands), length(states)), # proportion of age bracket in population in location
epidemicStart = vector('integer',length(states)), # day at which epidemic start
deaths = matrix(NA_integer_, num_days_sim, length(states)), # reported deaths
deathsByAge = array(NA_integer_, dim = c(num_days_sim, as.integer(cntct_bands), length(states_ad))),
wkend_idx = matrix(NA_integer_, num_days_sim, length(states)), # indices of 1:N2 that correspond to weekends in location m
# death by age data,
map_country = map_country, # first column whether the state has death by age data, second column index country with death by age data
A_AD = as.integer(unlist(deathByAge_data$A_AD[states[states_ad]])), # number of age category in the observed death by age data
map_age = map_age, # map age observed to 5y age groups
dataByAgestart = vector('integer', length(states_ad)), # start of the death by age data
# priors
cntct_weekdays_mean = vector('list', length(states)), # mean of prior contact rates between age groups
cntct_weekends_mean = vector('list', length(states)),
ifr_age = matrix(data=ifr.by.age$ifr_mean, ncol=cntct_bands, nrow=num_days_sim, byrow=TRUE), # probability of death for age band a, stored N2 times
rev_ifr_daysSinceInfection = rev( ifr_by_dsi ), # probability of death s days after infection in reverse order
rev_iar_daysSinceInfection = rev( iar_by_dsi ), # probability of antibody s days after infection in reverse order
rev_serial_interval = rev( serial_interval$fit[1:serial.interval.cut] ), # fixed pre-calculated serial interval using empirical data from Neil in reverse order
with_eta2 = 0
)
cat('\nProcessing country data... \n')
for(m in seq_along(states))
{
#m <- 1
State <- states[m]
State_name <- pop_info$loc_label[pop_info$loc==State]
cat("\n Processing", State, "\n")
# create padded data of cases and deaths
# start counting 30 days prior to reaching 10 deaths
d1 <- death_data[death_data$code==State,]
d1$t <- lubridate::decimal_date(d1$date)
d1 <- d1[order(d1$t),]
date_min <- as.Date('2019-12-31')
if (d1$t[1] > date_min){
print(paste(State,'In padding'))
pad_days <- d1$date - date_min
pad_dates <- date_min + lubridate::days(1:pad_days[[1]]-1)
padded_data <- data.frame("state" = rep(State, pad_days),
"date" = as.Date(pad_dates,format='%d/%m/%Y'),
"Cases" = as.integer(rep(0, pad_days)),
"Deaths" = as.integer(rep(0, pad_days)),
stringsAsFactors=F)
d1 <- dplyr::bind_rows(padded_data, d1)
}
index <- which(d1$Cases>0)[1]
index1 <- which(cumsum(d1$Deaths)>=10)[1] # also 5
index2 <- index1-30L
print(sprintf("First non-zero cases is on day %d, and 30 days before 10 deaths is day %d",index,index2))
n.d1 = nrow(d1)
d1 <- d1[index2:n.d1,]
# death by age and overall death must have same number of days
if( m %in% states_ad ){
deathsByAge <- as.matrix(deathByAge_data$deaths_data[[State]])
n.d2 = nrow(deathsByAge)
if(n.d1 > n.d2){
d1 = head(d1, -(n.d1-n.d2)) # remove n.d1-n.d2 last elements
n.d1 = n.d2
}
if(n.d1 < n.d2) deathsByAge = deathsByAge[-((n.d1+1):n.d2),]
}
# hazard estimation
N <- nrow(d1)
print(sprintf("%s has %d days of data",State,N))
forecast <- num_days_sim - N
if(forecast < 0) {
print(sprintf("%s: %d", State, N))
print("ERROR!!!! increasing num_days_sim")
num_days_sim <- N
forecast <- num_days_sim - N
}
# process overall death and death by age
if( m %in% states_ad ){
m2 <- which(m==states_ad)# bookeeping
deaths_processed <- process_death(d1, is_m_in_states_od = 0, index1, index2, forecast,
deathsByAge, deathByAge_data$dataByAgestart[[State]], deathByAge_data$A_AD[[State]])
}
if( m %in% states_od ){
deaths_processed <- process_death(d1, is_m_in_states_od = 1, index1, index2, forecast,
deathsByAge = NULL, dataByAgestart = NULL, A_AD = NULL)
}
deaths_without_forecast = deaths_processed$deaths_without_forecast
deaths = deaths_processed$deaths
deathsByAge = deaths_processed$deathsByAge
dataByAgestart = deaths_processed$dataByAgestart
# determine the index of weekend dates
dates_with_forecast = c(d1[-N,]$date, seq(d1[N,]$date, d1[N,]$date+forecast, by ="day"))
wkend_idx <- which(as.integer(format(dates_with_forecast, "%u"))>5)
## store and save processed data
# store number of reported deaths
deaths_by_state[[State]] <- deaths_without_forecast
# store number of reported cases
reported_cases[[State]] <- as.vector(as.numeric(d1$Cases))
# store dates for data from this country
dates[[State]] <- d1$date
# add constants
stan_data$N[m] <- N
stan_data$WKEND_IDX_N[m] <- length(wkend_idx)
stan_data$wkend_idx[,m] <- c(wkend_idx, rep(0,num_days_sim-length(wkend_idx)))
# add population count
tmp <- subset(pop_info, loc==State)[order(age.cat)]
stan_data$pop[m] <- tmp$pop_total[1]
stan_data$popByAge[,m] <- tmp$prop_pop
# add day at which epidemic start
stan_data$epidemicStart[m] <- index1+1L-index2
# add deaths
stan_data$deaths[,m] <- deaths
# add death by age
if( m %in% states_ad )
{
stan_data$deathsByAge[,,m2]<- deathsByAge
stan_data$dataByAgestart[m2] <- dataByAgestart
}
# add weekend contact matrix
tmp <- dcast.data.table(subset(dcontact, loc==State & type=="weekend"), part.age.cat~cont.age.cat, value.var='m')
tmp <- unname(as.matrix(tmp)[,-1])
stan_data$cntct_weekends_mean[[m]] <- tmp
# add weekday contact matrix
tmp <- dcast.data.table(subset(dcontact, loc==State & type=="weekday"), part.age.cat~cont.age.cat, value.var='m')
tmp <- unname(as.matrix(tmp)[,-1])
stan_data$cntct_weekdays_mean[[m]] <- tmp
if(length(stan_data$N) == 1)
{
stan_data$N <- as.array(stan_data$N)
}
}
# transform in array single vector
if(stan_data$M == 1)
{
stan_data$pop <- as.array(stan_data$pop)
stan_data$epidemicStart <- as.array(stan_data$epidemicStart)
stan_data$WKEND_IDX_N <- as.array(stan_data$WKEND_IDX_N)
}
return(list("stan_data" = stan_data, "dates" = dates, "reported_cases"=reported_cases, "deaths_by_state" = deaths_by_state))
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
#' @importFrom dplyr rename distinct select
process_deathByAge = function(deathByAge, range_date, states, path_to_file_pop_us)
{
# subset death by age data by selected states
deathByAge = subset(deathByAge, code %in% states)
# name of the states and number states with death by age data
state = unique(deathByAge$code)
n.state = length(unique(deathByAge$code))
# age band in the analysis: Alex's code
pop_by_age <- readRDS(path_to_file_pop_us)
age_bands <- dplyr::select(pop_by_age[which(!is.na(pop_by_age$code)),], -Total) %>%
reshape2::melt(id.vars = c("Region", "code")) %>%
dplyr::rename(age = variable, pop = value, state = Region) %>% dplyr::select(age) %>% dplyr::distinct()
# min age and max age in every age band
age.cat <- sapply(strsplit(gsub("\\[|\\]|\\(|\\+", "", age_bands$age), "-"), as.numeric)
if (is.na(age.cat[[length(age.cat)]][2])) age.cat[[length(age.cat)]][2] <- 99
age.cat <- matrix(unlist(age.cat), ncol = 2, byrow = TRUE)
n.age.cat = nrow(age.cat)
age.cat = rbind(age.cat, rep(101, 2)) # ensure the last interval
# map from age band in the analysis to age band specified by state
map_age = list()
# number of age band specified by state
A_AD = list()
# death by age data
deaths_data = list()
# first day with death by age data on the overall death scale
dataByAgestart = list()
for(State in state){
cat("\nProcessing ",State)
# subset death by age by State
deathByAge_state = data.table( subset(deathByAge, code == State) )
deathByAge_state$date = as.Date(deathByAge_state$date)
first.day = min(deathByAge_state$date)
if(any(na.omit(deathByAge_state$daily.deaths) < 0)) print("ERROR!!!! daily death for one or more days is < 0")
# the daily death is not observed on the first day but the cum death is
# if the period with overall death finishes before the first day with daily death by age data, ignore the state
if(range_date[2] < (first.day + 1) ) next
## 1. map the age band in the analysis to age band specified by state
# age band specified by the state
df = data.table(age=unique(deathByAge_state$age)); n.age = nrow(df)
# create groups
df[, group := 1:n.age]
deathByAge_state = merge(deathByAge_state, df, by = "age")
# for the last category (ending with string +), set the upper boundary to 99
df[ grepl("\\+", age), age := paste0(gsub("(.+)\\+", "\\1", age), "-99") ]
# find the lower boundaries of age band specified by the state
df[, age_min := suppressWarnings(as.numeric(gsub("(.+)-.*", "\\1", age)))]
stopifnot(all(!is.na(df$age_min)))
# group all age bands with age >= 85 (e.g, "80-89", "90+" --> "80+")
if(any(df$age_min > 85)){
# max of age_min conditional on being =< 85
age_max = df$age_min[which.max( df$age_min[ which(df$age_min <= 85)] ) ]
# age band with age greater than age_max
df[, g_age_max := age_min >= age_max]
df_new = subset(df, !g_age_max)
# new age bands
df_new = rbind(df_new,
data.table(age = paste0(min(subset(df, g_age_max)$age_min), "+"),
age_min = min(subset(df, g_age_max)$age_min),
group = min(subset(df, g_age_max)$group)), fill = TRUE)
# aggregate the new age bands (sum number of deaths over them)
df[ , newgroup := group ]
df[(g_age_max), newgroup := min(group) ]
deathByAge_state = merge(deathByAge_state, dplyr::select(df, c("newgroup", "group")), by = "group")
deathByAge_state = deathByAge_state[ , list(cum.deaths = sum(cum.deaths),
daily.deaths = sum(daily.deaths)),
by = list(date, newgroup)]
setnames(deathByAge_state, "newgroup", "group")
# new age band names
deathByAge_state = merge(deathByAge_state, df_new, by = "group")
deathByAge_state = dplyr::select(deathByAge_state, c(date, age, cum.deaths, daily.deaths))
# age band specified by the state
df = data.table(age=unique(deathByAge_state$age)); n.age = nrow(df)
df[, group := 1:n.age]
# for the last category (ending with string +), set the lower boundary to 99
df[ grepl("\\+", age), age := paste0(gsub("(.+)\\+", "\\1", age), "-99") ]
# find the upper boundaries of age band specified by the state
df[, age_min := suppressWarnings(as.numeric(gsub("(.+)-.*", "\\1", age)))]
stopifnot(all(!is.na(df$age_min)))
}
df=df[order(age_min)]
# find the upper boundaries of age band specified by the state
df[, age_max := suppressWarnings(as.numeric(gsub(".*-(.+)", "\\1", age)))]
stopifnot(all(!is.na(df$age_max)))
# transform age band to factor, and ensure that they are in ascending order
deathByAge_state$age = factor(deathByAge_state$age, levels = c(paste0(df$age_min[-n.age], "-", df$age_max[-n.age]), paste0(df$age_min[n.age], "+")))
# find the 5y age band to which the age band specified by state belong
df[, I_min := findInterval(age_min, age.cat[,1], all.inside = TRUE)]
df[, I_max := findInterval(age_max, age.cat[,2], all.inside = TRUE)]
stopifnot(all(df$minI <= df$maxI))
stopifnot(df$minI[1] == 1 & df$maxI[n.age] == n.age)
stopifnot(all(df$minI == sort(df$minI)) & all(df$maxI == sort(df$maxI)))
stopifnot(all(df$age_min >=0))
stopifnot(all(df$age_max >=0))
# matrix with age band in analysis by rows and age band specified by state by columns
# map_age_ij = 1 if j in i
map_age[[State]] = matrix(nrow = n.age.cat, ncol = n.age.cat, c(rep(0, n.age.cat*n.age), rep(-1, n.age.cat*(n.age.cat*n.age-n.age))))
for(i in 1:n.age){
map_age[[State]][df$I_min[i]:df$I_max[i],i] = 1
}
stopifnot( all(apply(map_age[[State]][, 1:n.age], 1, sum) == 1))
## 2. number of age band specified by state
A_AD[[State]] = n.age
## 3.create death data
# define period: from the first day with overall death data to the last day with death by age data
n.date = length(range_date[1]:max(deathByAge_state$date))
dates = data.table(date = seq.Date(range_date[1], max(deathByAge_state$date), by = "day"))
# create var.deaths: cum deaths on the first day and daily deaths on the remaining days
deathByAge_state[ date == first.day, var.deaths := cum.deaths]
deathByAge_state[ date != first.day, var.deaths := daily.deaths]
# rows are days and age band specified by state are columns
# matrix is filled with var.deaths
tmp = reshape2::dcast(deathByAge_state, date ~ age, value.var = "var.deaths") %>%
merge(dates, by = "date", all.y = T)
# index of the first day with death by age data
start_index = which(dates$date == min(deathByAge_state$date))
# add -1 for missing days
tmp[1:(start_index-1),2:(n.age+1)] = -1
if(n.age != n.age.cat) tmp[,(n.age+2):(n.age.cat+1)] = -1
deaths_data[[State]] = as.matrix(tmp[,-1])
## 4. first day with death by age data on the overall death scale
dataByAgestart[[State]] = start_index
}
return(list(deaths_data = deaths_data, map_age = map_age, dataByAgestart = dataByAgestart, A_AD = A_AD))
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
#' @importFrom scales percent rescale
#' @importFrom dplyr rename select
process_emodo_mobility_into_mobility_trends <- function(mobility_data,
dcontact,
pop_info
)
{
# calculate baseline Emodo over 1 week
# (this is roughly the same amount of data points as Google uses to calculate their baselines)
dc <- copy(mobility_data)
setnames(dc, 'avg_contacts', 'value')
#set(dc, NULL, 'emo.idx.age.label', dc[, factor(emo.idx.age.cat, levels=emo.idx.age.cat, labels=emo.idx.age.label)])
#set(dc, NULL, 'emo.pair.age.label', dc[, factor(emo.cont.age.cat, levels=emo.cont.age.cat, labels=emo.cont.age.label)])
#set(dc, NULL, 'emo.pair.age.label', dc[, factor(emo.pair.age.cat, levels=emo.pair.age.cat, labels=emo.pair.age.label)])
slist <- unique(dc$loc)
date.min <- min(dc$date)
date.max <- max(dc$date)
# calculate baseline values and add to data
dcb <- subset(dc, date<=date.min+7)
dcb <- dcb[, list(base_value= mean(value)), by=c('loc','emo.pair.age.cat')]
dc <- merge(dc, dcb, by=c('loc','emo.pair.age.cat'))
# define trend
dc[, mobility_trend:= value/base_value]
# plot baseline and actual value as lines
cat("\n plot contacts + baseline ...")
dc_w <- unique(subset(dc, select=c(date, weekend)))
dc_bp <- data.table(xmin= date.min, xmax=date.min+7, ymin=-Inf, ymax=Inf)
ps <- vector('list', length(slist))
for (x in slist)
{
dc_m <- subset(dc, loc==x)
dc_b <- unique(subset(dc_m, select=c(loc_label, base_value, emo.pair.age.label)))
ggplot(dc_m) +
geom_rect(data=dc_bp, aes(xmin = xmin, xmax = xmax, ymin = ymin, ymax = ymax), fill='green', alpha = .8) +
geom_tile(data=dc_w, aes(x = date, y = 0, height = Inf, fill = weekend), alpha = .2, show.legend = FALSE) +
scale_fill_manual(values = c("transparent", "black")) +
scale_x_date(expand=c(0,0), date_breaks = "2 weeks", labels = date_format("%e %b")) +
geom_hline(data=dc_b, aes(yintercept=base_value, colour=emo.pair.age.label)) +
geom_step(aes(x=date, y=value, colour=emo.pair.age.label), direction="vh") +
theme_bw() +
labs(x= 'Date', y='Mobility trend', colour='Contacts') +
facet_wrap(loc_label~emo.pair.age.label, scales='free_y', ncol=5) +
theme(legend.position='bottom',
legend.title = element_text(size = 10),
legend.text = element_text(size = 8),
plot.title = element_text(size = 24, face = "bold"),
axis.text.x=element_text(angle=60, vjust = 0.9, hjust=1),
axis.title.x = element_blank(),
panel.grid.major = element_blank(), panel.grid.minor = element_blank(),
panel.background = element_blank(),
strip.background = element_blank()) +
scale_colour_viridis_d(begin=0,end=.8,alpha=1,direction=-1,option="magma") +
guides(colour=guide_legend(ncol=12))
ggsave(file=file.path(plotdir, paste0('emodo_mobility_baseline_by_age_',x,'.pdf')), w=14, h=14, limitsize=FALSE)
}
# plot trends as lines
cat("\n plot mobility trends ...")
dc_w <- unique(subset(dc, select=c(date, weekend)))
ps <- vector('list', length(slist))
plotdir2 <- NA_character_
for (x in slist)
{
dc_m <- subset(dc, loc==x)
y.max <- max(dc_m$mobility_trend)
ps[[x]] <- ggplot(dc_m) +
geom_tile(data=dc_w, aes(x = date, y = 0, height = Inf, fill = weekend), alpha = .2, show.legend = FALSE) +
scale_fill_manual(values = c("transparent", "black")) +
scale_x_date(expand=c(0,0), date_breaks = "2 weeks", labels = date_format("%e %b")) +
scale_y_continuous(expand=c(0,0), label=scales::percent) +
geom_step(aes(x=date, y=mobility_trend, colour=emo.pair.age.label), direction="vh") +
coord_cartesian(ylim=c(0,y.max*1.1)) +
theme_bw() +
labs(x= 'Date', y='Mobility trend', colour='Contacts') +
facet_wrap(loc_label~.) +
theme(legend.position='bottom',
legend.title = element_text(size = 10),
legend.text = element_text(size = 8),
plot.title = element_text(size = 24, face = "bold"),
axis.text.x=element_text(angle=60, vjust = 0.9, hjust=1),
axis.title.x = element_blank(),
panel.grid.major = element_blank(), panel.grid.minor = element_blank(),
panel.background = element_blank(),
strip.background = element_blank()) +
scale_colour_viridis_d(begin=0,end=.8,alpha=1,direction=-1,option="magma") +
guides(colour=guide_legend(ncol=12))
if(!is.na(plotdir2))
{
ggsave(file=file.path(plotdir2, paste0('emodo_mobility_trends_by_age_',x,'.png')), ps[[x]], w=14, h=6, limitsize=FALSE)
}
}
g <- ggarrange(plotlist=ps, ncol = 1, nrow=length(slist), widths=1, heights=rep(1/length(slist),length(slist)))
ggsave(file=file.path(plotdir, paste0('emodo_mobility_trends_by_age.pdf')), w=20, h=200, limitsize=FALSE)
# plot trends as heatmap
ps <- vector('list',length(slist))
names(ps) <- slist
y.max <- min(3, max(dc$mobility_trend))
y.min <- max(0.1,min(dc$mobility_trend))
for (x in slist)
{
dc_m <- subset(dc, loc==x)
dc_m[, plot_value:= pmin(y.max,pmax(y.min, mobility_trend))]
ps[[x]] <- ggplot(dc_m) +
scale_x_date(expand=c(0,0), date_breaks = "2 weeks", labels = date_format("%e %b")) +
scale_y_discrete(expand=c(0,0)) +
geom_tile(aes(x= date, y= emo.pair.age.label, fill=plot_value)) +
scale_fill_viridis(begin=0,end=1, alpha=0.6,direction=1,option="magma", labels = scales::percent,
values = scales::rescale(c(0.1,0.33,0.4,0.5,0.66,1,1.5,2,2.5,3)),breaks=seq(0.5,3,.5)) +
labs(x= 'Date', y='Contacts', fill='') +
facet_wrap(loc_label~.) +
theme_bw() +
theme(legend.position='right',
legend.title = element_text(size = 10),
legend.text = element_text(size = 8),
plot.title = element_text(size = 24, face = "bold"),
axis.text.x=element_text(angle=60, vjust = 0.9, hjust=1),
axis.title.x = element_blank(),
panel.grid.major = element_blank(),
panel.grid.minor = element_blank(),
panel.background = element_blank(),
strip.background = element_blank()) +
guides(fill = guide_colourbar(barheight = 10, barwidth = 0.5, direction="vertical"))
}
g <- ggarrange(plotlist=ps, ncol = 5, nrow=11, widths=rep(1/5,5), heights=rep(1/11,11))
ggsave(file=file.path(plotdir, paste0('emodo_mobility_trends_2_by_age.png')), w=40, h=60, limitsize=FALSE)
fsqb[, age.lower:= as.integer(gsub('^([0-9]+)_([0-9a-z]+)$','\\1',age))]
fsqb[, age.upper:= as.integer(gsub('plus','99',gsub('^([0-9]+)_([0-9a-z]+)$','\\2',age)))]
# store raw baseline for plotting trends
fsqbr <- fsqb
# expand visit rates to our stratification
dages <- unique(subset(pop_info, select=c(age.cat.label, age.cat, age.cat.from, age.cat.to)))
setnames(dages, c('age.cat','age.cat.label','age.cat.from','age.cat.to'), c('age_cat','age_band','age.lower','age.upper'))
tmp <- unique(subset(fsqb, select=c(age, age.lower, age.upper)))
set(tmp, NULL, 'age', tmp[, as.character(age)])
dages <- dages[, {
z <- which( age.upper >= tmp$age.lower & age.upper <= tmp$age.upper )
list(age= ifelse(length(z)>0, as.character(tmp$age[z]), NA_character_))
}, by=c('age_cat','age_band')]
dages[, dummy:= 1L]
dages <- merge(dages, data.table(state=unique(fsqb$state), dummy=1L), by='dummy', allow.cartesian=TRUE)
set(dages, NULL, c('dummy'), NULL)
fsqb <- merge(dages, fsqb, by=c('age','state'), all.x=TRUE)
# merge base visit rates and average contacts of index persons
stopifnot( all( as.character(sort(unique(dcontact$loc))) == sort(unique(fsqb$state)) ) )
ctc <- subset(dcontact, select=c(loc, cont.age.cat, part.age.cat, m, type))
setnames(ctc, c('part.age.cat','cont.age.cat','m','loc'), c('age_cat_index','age_cat_respondent','avg_contacts','state'))
ctcm <- ctc[, list(marg_contacts= sum(avg_contacts)), by=c('state','type','age_cat_index')]
setnames(ctcm, 'age_cat_index', 'age_cat')
fsqb <- merge(fsqb, ctcm, by=c('state','age_cat'),allow.cartesian=TRUE)
# plotting
if(0)
{
tmp <- subset(fsqb, state=='NYC')
ggplot(tmp, aes(x=age_band)) +
geom_point(aes(y=base_visits_rate), colour='black') +
geom_point(aes(y=marg_contacts, pch=type, colour=type)) +
theme_bw() +
facet_wrap(.~state, ncol=1) +
labs(x='', y='')
# this plot suggests to me that the UK POLYMOD contact matrix has more (realistic) detail
# than the FSQ data
}
# scale the UK POLYMOD matrix by a constant for each state, constant is avg mobility in baseline period
if(args_scale_contactmatrix_bystate)
{
cat('\nScaling contact matrix by avg baseline mobility per state ... ')
tmp <- subset(fsqb, !is.na(base_visits_rate), select=c(state, base_visits_rate))
tmp <- tmp[, list(base_visits_rate= mean(base_visits_rate)), by=c('state')]
tmp[, base_visits_rate_avg:= mean(base_visits_rate)]
tmp[, base_visits_rate_mult:= base_visits_rate/base_visits_rate_avg]
# plotting
if(0)
{
ggplot(tmp, aes(x=state, y=base_visits_rate_mult)) + geom_bar(stat='identity') + coord_flip() + theme_bw()
}
fsqb <- merge(fsqb, subset(tmp, select=c(state,base_visits_rate_mult)),by=c('state'),all.x=TRUE)
}
# scale the UK POLYMOD matrix by a constant for each state ang each age band, constant is avg mobility in baseline period in this age group
if(args_scale_contactmatrix_bystateandage)
{
cat('\nScaling contact matrix by age-specific baseline mobility per state ... ')
# so why don t we use the FSQ data to scale the UK POLYMOD data as follows:
tmp <- unique(subset(fsqb, !is.na(base_visits_rate), select=c(age, state, base_visits_rate)))
tmp2 <- tmp[, list(base_visits_rate_avg= mean(base_visits_rate)), by=c('age')]
tmp <- merge(tmp, tmp2, by='age')
tmp[, base_visits_rate_mult:= base_visits_rate/base_visits_rate_avg]
fsqb <- merge(fsqb, subset(tmp, select=c(state,age,base_visits_rate_mult)),by=c('state','age'),all.x=TRUE)
# first value carried backwards? anyhow, let s just do something for now and
# then maybe a sensitivity analysis
fsqb <- fsqb[, {
z<- which(is.na(base_visits_rate_mult))
base_visits_rate_mult[z] <- base_visits_rate_mult[tail(z,1)+1]
list( base_visits_rate=base_visits_rate,
base_visits_rate_mult=base_visits_rate_mult,
marg_contacts=marg_contacts,
age=age,
age_cat=age_cat,
age_band=age_band
)
}, by=c('state','type')]
# plotting
if(0)
{
tmp <- subset(fsqb, state%in%c('NYC','CO','CT','CA','HI','DC','AL'))
ggplot(tmp, aes(x=age_cat, y=base_visits_rate_mult)) +
geom_step(aes(colour=state)) +
geom_point(aes(colour=state)) +
theme_bw()
# looks good I think - note I selected all the high outliers to see how much we inflate
# under this approach
}
}
# now build the state specific contact matrices
setnames(fsqb, 'age_cat', 'age_cat_index')
if(args_scale_contactmatrix_bystateandage | args_scale_contactmatrix_bystate)
{
tmp <- subset(fsqb, select=c(state, type, age_cat_index, base_visits_rate_mult))
ctc <- merge(ctc, tmp, by=c('state','age_cat_index','type'),allow.cartesian=TRUE)
ctc[, avg_contacts:= avg_contacts * base_visits_rate_mult]
ctc[, base_visits_rate_mult:= NULL]
}
setnames(ctc, c('state','age_cat_index','age_cat_respondent','avg_contacts'), c('loc','part.age.cat','cont.age.cat','m'))
ctc <- merge(subset(dcontact, select=-m), ctc, by=c('loc','part.age.cat','cont.age.cat','type'))
# plotting
if(0)
{
# run 1 scaling after the other
df <- subset(ctc, state%in%c('NYC','CO','CT','CA','HI','DC','AL')) %>%
dplyr::rename(`original scale` = avg_contacts_old, `scaled by one scalar by state` = avg_contacts) %>%
reshape2::melt(id.vars = c("age_cat_index","type","age_cat_respondent","state")) %>%
dplyr::rename(scaling = variable, avg_contacts = value)
df2 <- subset(ctc, state%in%c('NYC','CO','CT','CA','HI','DC','AL')) %>%
dplyr::rename(`original scale` = avg_contacts_old, `scaled by one scalar by state and age` = avg_contacts) %>%
reshape2::melt(id.vars = c("age_cat_index","type","age_cat_respondent","state")) %>%
dplyr::rename(scaling = variable, avg_contacts = value) %>%
rbind(subset(df, scaling != "original scale"))
df2$scaling = factor(df2$scaling, levels = c("original scale", "scaled by one scalar by state", "scaled by one scalar by state and age"))
ggplot(subset(df2, type == "weekday"), aes(x = age_cat_index, y = age_cat_respondent)) +
geom_raster(aes(fill=sqrt(avg_contacts) )) +
scale_fill_gradient(low="white", high="red") +
theme_bw() +
facet_wrap(~state+scaling, ncol = 3)
ggsave("~/Downloads/contact.matrix_weekday_scaled.png", w = 10, h = 15)
ggplot(subset(df2, type == "weekend"), aes(x = age_cat_index, y = age_cat_respondent)) +
geom_raster(aes(fill=sqrt(avg_contacts) )) +
scale_fill_gradient(low="white", high="red") +
theme_bw() +
facet_wrap(~state+scaling, ncol = 3)
ggsave("~/Downloads/contact.matrix_weekend_scaled.png", w = 10, h = 15)
}
# now we can build the FSQ multipliers
fsqb <- unique(subset(fsqb, !is.na(base_visits_rate), select=c(state, age, base_visits_rate)))
fsq <- merge(fsq, fsqb, by=c('state','age'))
fsq[, mobility_trend:= norm_visits_rate / base_visits_rate]
set(dages, which(dages$age_cat %in% 1:3), "age", "18_24")
fsq <- merge(dages, fsq, by=c('age','state'), all.x=TRUE, allow.cartesian=TRUE)
if(0)
{
tmp <- subset(fsq, state=="NYC")
ggplot(tmp) +
scale_y_continuous(breaks=seq(0,3,0.1)) +
#geom_tile(data=unique(subset(tmp, select=c(date, weekend))), aes(x = date, y = 0, height = Inf, fill = weekend), alpha = .2) +
geom_hline(yintercept=1) +
#scale_fill_manual(values = c("alpha", "black")) +
geom_step(aes(x=date, y=mobility_trend, colour=age), direction="vh") +
geom_point(aes(x=date, y=mobility_trend, colour=age)) +
theme_bw() +
labs(x= 'date', y='mobility_trend', colour='age band') +
facet_wrap(.~state, scales='free')
# super cool. mobility drops to 55% among 18-24 and to 65% among 55-64
}
return(list(fsq=fsq, ctc=ctc, fsqbr=fsqbr))
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
make_mobility_trends_emo <- function(mobility_data, emo_age_cat_map)
{
# calculate baseline over 2 weeks
min.date <- min(mobility_data$date)
tmp <- subset(mobility_data, date<min.date+14)
tmp <- tmp[, list(base_avg_contacts= mean(avg_contacts)), by=c('loc','emo.age.cat')]
mobility_data <- merge(mobility_data, tmp, by=c('loc','emo.age.cat'))
# calculate mobility trends
mobility_data[, mobility_trend:= avg_contacts / base_avg_contacts]
# expand to age strata used in model
tmp <- subset(emo_age_cat_map, select=c(emo.age.cat, age.cat, age.cat.label))
set(tmp, tmp[, which(age.cat<=3)], 'emo.age.cat', 1L)
mobility_data <- merge(mobility_data, tmp, by='emo.age.cat', allow.cartesian=TRUE)
mobility_data
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
make_mobility_trends_fsq <- function(mobility_data, fsq_age_cat_map)
{
fsq <- mobility_data
# calculate baseline FSQ over 1 week
# (this is roughly the same amount of data points as Google uses to calculate their baselines)
min.date <- min(fsq$date)
fsqb <- subset(fsq, date<=min.date+6)
fsqb <- fsqb[, list(base_visits_rate= mean(norm_visits_rate)), by=c('loc','loc_label','fsq.age.cat','fsq.age.cat.label')]
fsq <- merge(fsq, fsqb, by=c('loc','loc_label','fsq.age.cat','fsq.age.cat.label'))
# calculate mobility trends
fsq[, mobility_trend:= norm_visits_rate / base_visits_rate]
# expand to age strata used in model
tmp <- subset(fsq_age_cat_map, select=c(fsq.age.cat, age.cat, age.cat.label))
set(tmp, tmp[, which(age.cat<=3)], 'fsq.age.cat', 1L)
fsq <- merge(fsq, tmp, by='fsq.age.cat', allow.cartesian=TRUE)
fsq
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
make_emodo_age_cat_map <- function(mobility_data, pop_info)
{
dages <- unique(subset(pop_info, select=c(age.cat.label, age.cat, age.cat.from, age.cat.to)))
tmp <- unique(subset(mobility_data, select=c(emo.age.cat, emo.age.label)))
tmp[, emo.age.cat.label2:= as.character(emo.age.label)]
tmp[, emo.age.lower:= as.integer(gsub('\\+','',gsub('^([0-9\\+]+)-([0-9]+)$','\\1',emo.age.cat.label2)))]
tmp[, emo.age.upper:= as.integer(gsub('[0-9]+\\+','99',gsub('^([0-9\\+]+)-([0-9\\+]+)$','\\2',emo.age.cat.label2)))]
dages <- dages[, {
z <- which( age.cat.to >= tmp$emo.age.lower & age.cat.to <= tmp$emo.age.upper )
list(emo.age.cat= ifelse(length(z)>0, tmp$emo.age.cat[z], NA_integer_))
}, by=c('age.cat','age.cat.label')]
tmp <- unique(subset(tmp, select=c(emo.age.cat, emo.age.label)))
dages <- merge(dages, tmp, by= c('emo.age.cat'), all.x=TRUE)
dages
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
make_fsq_age_cat_map <- function(mobility_data, pop_info)
{
dages <- unique(subset(pop_info, select=c(age.cat.label, age.cat, age.cat.from, age.cat.to)))
tmp <- unique(subset(mobility_data, select=c(fsq.age.cat, fsq.age.cat.label)))
tmp[, fsq.age.cat.label2:= as.character(fsq.age.cat.label)]
tmp[, fsq.age.lower:= as.integer(gsub('\\+','',gsub('^([0-9\\+]+)-([0-9]+)$','\\1',fsq.age.cat.label2)))]
tmp[, fsq.age.upper:= as.integer(gsub('[0-9]+\\+','99',gsub('^([0-9\\+]+)-([0-9\\+]+)$','\\2',fsq.age.cat.label2)))]
dages <- dages[, {
z <- which( age.cat.to >= tmp$fsq.age.lower & age.cat.to <= tmp$fsq.age.upper )
list(fsq.age.cat= ifelse(length(z)>0, tmp$fsq.age.cat[z], NA_integer_))
}, by=c('age.cat','age.cat.label')]
tmp <- unique(subset(tmp, select=c(fsq.age.cat, fsq.age.cat.label)))
dages <- merge(dages, tmp, by= c('fsq.age.cat'), all.x=TRUE)
dages
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
make_bics_age_cat_map <- function(pop_info)
{
dages <- unique(subset(pop_info, select=c(age.cat.label, age.cat, age.cat.from, age.cat.to)))
tmp <- data.table("bics.age.cat" = as.integer(c(1, 2, 3, 4, 5)),
"bics.age.cat.label" = c("18-24", "25-34", "35-44", "45-64", "65+"))
tmp[, bics.age.cat.label2:= as.character(bics.age.cat.label)]
tmp[, bics.age.lower:= as.integer(gsub('\\+','',gsub('^([0-9\\+]+)-([0-9]+)$','\\1',bics.age.cat.label2)))]
tmp[, bics.age.upper:= as.integer(gsub('[0-9]+\\+','99',gsub('^([0-9\\+]+)-([0-9\\+]+)$','\\2',bics.age.cat.label2)))]
dages <- dages[, {
z <- which( age.cat.to >= tmp$bics.age.lower & age.cat.to <= tmp$bics.age.upper )
list(bics.age.cat= ifelse(length(z)>0, tmp$bics.age.cat[z], NA_integer_))
}, by=c('age.cat','age.cat.label')]
tmp <- unique(subset(tmp, select=c(bics.age.cat, bics.age.cat.label)))
dages <- merge(dages, tmp, by= c('bics.age.cat'), all.x=TRUE)
dages
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
make_bics_age_cat_map_inc_children <- function(pop_info)
{
dages <- unique(subset(pop_info, select=c(age.cat.label, age.cat, age.cat.from, age.cat.to)))
tmp <- data.table("bics.age.cat" = as.integer(c(1, 2, 3, 4, 5, 6)),
"bics.age.cat.label" = c("0-17", "18-24", "25-34", "35-44", "45-64", "65+"))
tmp[, bics.age.cat.label2:= as.character(bics.age.cat.label)]
tmp[, bics.age.lower:= as.integer(gsub('\\+','',gsub('^([0-9\\+]+)-([0-9]+)$','\\1',bics.age.cat.label2)))]
tmp[, bics.age.upper:= as.integer(gsub('[0-9]+\\+','99',gsub('^([0-9\\+]+)-([0-9\\+]+)$','\\2',bics.age.cat.label2)))]
dages <- dages[, {
z <- which( age.cat.to >= tmp$bics.age.lower & age.cat.to <= tmp$bics.age.upper )
list(bics.age.cat= ifelse(length(z)>0, tmp$bics.age.cat[z], NA_integer_))
}, by=c('age.cat','age.cat.label')]
tmp <- unique(subset(tmp, select=c(bics.age.cat, bics.age.cat.label)))
dages <- merge(dages, tmp, by= c('bics.age.cat'), all.x=TRUE)
dages
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_resnonres_constraints_on_alpha_beta <- function(processed_data, contact_tab)
{
c1 <- max( contact_tab[[1]][['weekend']] / contact_tab[[1]][['weekday']] )
c2 <- max( contact_tab[[1]][['weekday']] / contact_tab[[1]][['weekend']] )
alpha <- seq(0,1,by=1e-4)
beta.lower <- pmin(1,pmax(alpha*c1, (c2-1+alpha)/c2))
alpha.upper<- tail(alpha[which(beta.lower<1)],1)
# ggplot( data.frame(a=alpha, b=beta.lower) ) + geom_line(aes(x=a, y=b))
processed_data$stan_data$resnonres_constraints_on_alpha_beta <- c(alpha.upper, c1, c2)
processed_data
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
#' @importFrom dplyr mutate
stan_data_add_week_effects <- function(processed_data, plotdir=NA_character_)
{
states <- names(processed_data$dates)
num_days_sim <- processed_data$stan_data$N2
week_index_allstates = data.table( date = seq(min(as.Date(unlist(lapply(sapply(processed_data$dates, as.character), min)))),
max(as.Date(unlist(lapply(sapply(processed_data$dates, as.character), min)))) +num_days_sim, by = "day")) %>%
dplyr::mutate(week.index = lubridate::week(date) - min(lubridate::week(date)) + 1 )
week_index = matrix(nrow = length(states), ncol = num_days_sim)
W = max(week_index_allstates$week.index)
for(m in 1:length(states)){
min_date = min(processed_data$dates[[m]])
tmp = data.table(date = seq(min_date, min_date+num_days_sim-1, by = "day")) %>%
merge(week_index_allstates, by = "date" )
week_index[m,] = tmp$week.index
}
processed_data$stan_data = c(processed_data$stan_data,
list(
W = W,
week_index = week_index
))
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
#' @importFrom stats filter
make_decoupled_mobility_trends_into_2_parts_fsq <- function(mobility_data, pop_info)
{
ma <- function(x, n = 5){stats::filter(x, rep(1 / n, n), sides = 2)} # moving average
# find breakpoint
tmp <- unique(subset(mobility_data, select=c(age.cat,fsq.age.cat)))
tmp[, w:= 1]
set(tmp, tmp[, which(age.cat<4)], 'w', 0)
set(tmp, tmp[, which(age.cat==4)], 'w', 2/5)
tmp <- merge(pop_info, tmp, by='age.cat')
tmp <- tmp[, list(pop=sum(w*pop)), by=c('loc','fsq.age.cat')]
tmp <- tmp[, list(fsq.age.cat=fsq.age.cat, w= pop/sum(pop)), by='loc']
mm <- unique(subset(mobility_data, select=-c(age.cat, age.cat.label)))
mm <- merge(mm, tmp, by=c('loc','fsq.age.cat'))
mm_avg <- mm[, list(mavg=sum(w*mobility_trend)), by=c('loc','date','weekend')]
mm_avg <- mm_avg[, list(rebound_date= 1+date[which.min(ma(mavg))]), by='loc']
mm <- merge(mm, mm_avg, by='loc')
# determine eased mobility value on weekdays and weekends
mm[, is_after_rebound_date:= date>=rebound_date]
tmp <- mm[date<rebound_date, list(base_mobility_trend= mean(tail(mobility_trend,ifelse(weekend=='yes',4,5)))), by=c('loc','fsq.age.cat.label','weekend')]
mm <- merge(mm, tmp, by=c('loc','fsq.age.cat.label','weekend'))
mm <- mm[order(loc, fsq.age.cat.label, date),]
# decouple mobility trends before and after breakpoint on the multiplicative scale
# so that MOB = exp( log(EASED_MOB) + log(MULTIPLIER) )
mm[, eased_mobility_trend:= mobility_trend]
tmp <- which(mm[,is_after_rebound_date])
set(mm, tmp, 'eased_mobility_trend', mm[tmp, base_mobility_trend])
mm[, mobility_multiplier:= 1.]
set(mm, tmp, 'mobility_multiplier', mm[tmp, mobility_trend/base_mobility_trend])
# clean up
mm <- subset(mm, select=-c(is_after_rebound_date, w))
tmp <- unique(subset(mobility_data, select=c(age.cat, age.cat.label, fsq.age.cat)))
# scale up to model strata
mm <- merge(mm, tmp, by='fsq.age.cat', allow.cartesian=TRUE)
mm
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
#' @importFrom stats filter
make_decoupled_mobility_trends_into_3_parts_fsq <- function(mobility_data, pop_info)
{
ma5 <- function(x, n = 5){stats::filter(x, rep(1 / n, n), sides = 2)} # moving average
ma15 <- function(x, n = 15){stats::filter(x, rep(1 / n, n), sides = 2)} # moving average
# get average mobility trend
tmp <- unique(subset(mobility_data, select=c(age.cat,fsq.age.cat)))
tmp[, w:= 1]
set(tmp, tmp[, which(age.cat<4)], 'w', 0)
set(tmp, tmp[, which(age.cat==4)], 'w', 2/5)
tmp <- merge(pop_info, tmp, by='age.cat')
tmp <- tmp[, list(pop=sum(w*pop)), by=c('loc','fsq.age.cat')]
tmp <- tmp[, list(fsq.age.cat=fsq.age.cat, w= pop/sum(pop)), by='loc']
mm <- unique(subset(mobility_data, select=-c(age.cat, age.cat.label)))
mm <- merge(mm, tmp, by=c('loc','fsq.age.cat'))
mm_avg <- mm[, list(mavg=sum(w*mobility_trend)), by=c('loc','date','weekend')]
tmp <- mm_avg[, list( date=date,
ma_avg_5= ma5(mavg),
ma_avg_15= ma15(mavg)),
by='loc']
mm_avg <- merge(mm_avg, tmp, by=c('loc','date'))
# find breakpoint: rebound time
mm_rb_5 <- mm_avg[!is.na(ma_avg_5), list(rebound_date_5= 1+date[which.min(ma_avg_5)]), by='loc']
mm_rb_15 <- mm_avg[!is.na(ma_avg_15), list(rebound_date_15= 1+date[which.min(ma_avg_15)]), by='loc']
# find breakpoint: dip time
mm_dip <- mm_avg[!is.na(ma_avg_15), list(dip_date= date[ 15-1+min(which( ma_avg_15[15:length(ma_avg_15)] / ma_avg_15[1:(length(ma_avg_15)-14)]< 0.9))]), by='loc']
# plotting to assess
# ma15 seems reasonable too
# dip time early for VT, but time series IS decreasing
if(0)
{
mm_avg <- merge(mm_avg, mm_rb_5, by='loc')
mm_avg <- merge(mm_avg, mm_rb_15, by='loc')
mm_avg <- merge(mm_avg, mm_dip, by='loc')
p <- ggplot(mm_avg) +
geom_step(aes(x=date, y=mavg)) +
geom_line(aes(x=date, y=ma_avg_5), colour='red') +
geom_line(aes(x=date, y=ma_avg_15), colour='blue') +
geom_vline(aes(xintercept=dip_date), colour='blue') +
geom_vline(aes(xintercept=rebound_date_5), colour='red') +
geom_vline(aes(xintercept=rebound_date_15), colour='blue') +
facet_wrap(loc~., ncol=1)
file <- file.path(args$job_dir,'fsq_ma.pdf')
ggsave(p, file=file, w=10, h=80, limitsize=FALSE)
}
# add dip and rebound times
setnames( mm_rb_15, 'rebound_date_15','rebound_date')
mm <- merge(mm, mm_rb_15, by='loc')
mm <- merge(mm, mm_dip, by='loc')
# determine eased mobility value on weekdays and weekends
mm[, is_after_rebound_date:= date>=rebound_date]
mm[, is_after_dip_date:= date>=dip_date]
mm <- mm[order(loc, fsq.age.cat.label, date),]
tmp <- mm[date>dip_date & date<rebound_date, list(base_dip_mobility_trend= mean(tail(mobility_trend,ifelse(weekend=='yes',4,5)))), by=c('loc','fsq.age.cat.label','weekend')]
mm <- merge(mm, tmp, by=c('loc','fsq.age.cat.label','weekend'))
mm <- mm[order(loc, fsq.age.cat.label, date),]
# decouple mobility trends before and after breakpoint on the multiplicative scale
# so that MOB = exp( log(BASE_MOB) + log(EASED_MOB) + log(MULTIPLIER) )
# define baseline mobility trend
# set covariate for baseline to 1 after dip
mm[, baseline_mobility_trend:= mobility_trend]
tmp <- which(mm[,is_after_dip_date])
set(mm,tmp,'baseline_mobility_trend',1)
# define eased mobility
# set covariate for eased baseline to 1 before to dip
mm[, eased_mobility_trend:= mobility_trend]
tmp <- which(mm[,is_after_rebound_date])
set(mm, tmp, 'eased_mobility_trend', mm[tmp, base_dip_mobility_trend])
tmp <- which(mm[,!is_after_dip_date])
set(mm,tmp,'eased_mobility_trend',1)
# define upswing multiplier
mm[, mobility_multiplier:= 1.]
tmp <- which(mm[,is_after_rebound_date])
set(mm, tmp, 'mobility_multiplier', mm[tmp, mobility_trend/base_dip_mobility_trend])
# clean up
mm <- subset(mm, select=-c(is_after_rebound_date, is_after_dip_date,w))
tmp <- unique(subset(mobility_data, select=c(age.cat, age.cat.label, fsq.age.cat)))
# scale up to model strata
mm <- merge(mm, tmp, by='fsq.age.cat', allow.cartesian=TRUE)
mm
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
#' @importFrom stats filter
make_decoupled_mobility_trends_into_3_parts_emodo <- function(mobility_data, pop_info)
{
ma5 <- function(x, n = 5){stats::filter(x, rep(1 / n, n), sides = 2)} # moving average
ma15 <- function(x, n = 15){stats::filter(x, rep(1 / n, n), sides = 2)} # moving average
# get average mobility trend
tmp <- unique(subset(mobility_data, select=c(age.cat,emo.age.cat)))
tmp[, w:= 1]
set(tmp, tmp[, which(age.cat<4)], 'w', 0)
set(tmp, tmp[, which(age.cat==4)], 'w', 2/5)
tmp <- merge(pop_info, tmp, by='age.cat')
tmp <- tmp[, list(pop=sum(w*pop)), by=c('loc','emo.age.cat')]
tmp <- tmp[, list(emo.age.cat=emo.age.cat, w= pop/sum(pop)), by='loc']
mm <- unique(subset(mobility_data, select=-c(age.cat, age.cat.label)))
mm <- merge(mm, tmp, by=c('loc','emo.age.cat'))
mm_avg <- mm[, list(mavg=sum(w*mobility_trend)), by=c('loc','date','weekend')]
tmp <- mm_avg[, list( date=date,
ma_avg_5= ma5(mavg),
ma_avg_15= ma15(mavg)),
by='loc']
mm_avg <- merge(mm_avg, tmp, by=c('loc','date'))
# find breakpoint: rebound time
mm_rb_5 <- mm_avg[!is.na(ma_avg_5), list(rebound_date_5= 1+date[which.min(ma_avg_5)]), by='loc']
mm_rb_15 <- mm_avg[!is.na(ma_avg_15), list(rebound_date_15= 1+date[which.min(ma_avg_15)]), by='loc']
# find breakpoint: dip time
mm_dip <- mm_avg[!is.na(ma_avg_15), list(dip_date= date[ 15-1+min(which( ma_avg_15[15:length(ma_avg_15)] / ma_avg_15[1:(length(ma_avg_15)-14)]< 0.9))]), by='loc']
# plotting to assess
# ma15 seems reasonable too
# dip time early for VT, but time series IS decreasing
if(0)
{
mm_avg <- merge(mm_avg, mm_rb_5, by='loc')
mm_avg <- merge(mm_avg, mm_rb_15, by='loc')
mm_avg <- merge(mm_avg, mm_dip, by='loc')
p <- ggplot(mm_avg) +
geom_step(aes(x=date, y=mavg)) +
geom_line(aes(x=date, y=ma_avg_5), colour='red') +
geom_line(aes(x=date, y=ma_avg_15), colour='blue') +
geom_vline(aes(xintercept=dip_date), colour='blue') +
geom_vline(aes(xintercept=rebound_date_5), colour='red') +
geom_vline(aes(xintercept=rebound_date_15), colour='blue') +
facet_wrap(loc~., ncol=1)
file <- file.path(args$job_dir,'emodo_ma.pdf')
ggsave(p, file=file, w=10, h=80, limitsize=FALSE)
}
# add dip and rebound times
setnames( mm_rb_15, 'rebound_date_15','rebound_date')
mm <- merge(mm, mm_rb_15, by='loc')
mm <- merge(mm, mm_dip, by='loc')
# determine eased mobility value on weekdays and weekends
mm[, is_after_rebound_date:= date>=rebound_date]
mm[, is_after_dip_date:= date>=dip_date]
mm <- mm[order(loc, emo.age.label, date),]
tmp <- mm[date>dip_date & date<rebound_date, list(base_dip_mobility_trend= mean(tail(mobility_trend,ifelse(weekend=='yes',4,5)))), by=c('loc','emo.age.label','weekend')]
mm <- merge(mm, tmp, by=c('loc','emo.age.label','weekend'))
mm <- mm[order(loc, emo.age.label, date),]
# decouple mobility trends before and after breakpoint on the multiplicative scale
# so that MOB = exp( log(BASE_MOB) + log(EASED_MOB) + log(MULTIPLIER) )
# define baseline mobility trend
# set covariate for baseline to 1 after dip
mm[, baseline_mobility_trend:= mobility_trend]
tmp <- which(mm[,is_after_dip_date])
set(mm,tmp,'baseline_mobility_trend',1)
# define eased mobility
# set covariate for eased baseline to 1 before to dip
mm[, eased_mobility_trend:= mobility_trend]
tmp <- which(mm[,is_after_rebound_date])
set(mm, tmp, 'eased_mobility_trend', mm[tmp, base_dip_mobility_trend])
tmp <- which(mm[,!is_after_dip_date])
set(mm,tmp,'eased_mobility_trend',1)
# define upswing multiplier
mm[, mobility_multiplier:= 1.]
tmp <- which(mm[,is_after_rebound_date])
set(mm, tmp, 'mobility_multiplier', mm[tmp, mobility_trend/base_dip_mobility_trend])
# clean up
mm <- subset(mm, select=-c(is_after_rebound_date, is_after_dip_date,w))
tmp <- unique(subset(mobility_data, select=c(age.cat, age.cat.label, emo.age.cat)))
# scale up to model strata
mm <- merge(mm, tmp, by='emo.age.cat', allow.cartesian=TRUE)
mm
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_mobility_trends_fsq <- function(processed_data, mobility_data, log=TRUE)
{
states <- names(processed_data$dates)
num_days_sim <- processed_data$stan_data$N2
covariates_new <- array(NA_real_, dim = c(length(states), num_days_sim, as.integer(processed_data$stan_data$A))) # predictors for contacts by age band
for(m in 1:length(states))
{
fsq_m <- subset(mobility_data, loc==states[m], c(age.cat, date, weekend, mobility_trend))
fsq_m[, weekend:= as.integer(weekend=='yes')]
if(log)
{
cat("\nTaking log of mobility trends...")
set(fsq_m, NULL, 'mobility_trend', fsq_m[, log(mobility_trend)])
}
if(!log)
{
cat("\nNo log of mobility trends...")
}
first.obs.date <- min(processed_data$dates[[states[m]]])
last.obs.date <- max(fsq_m$date)
last.date <- first.obs.date + num_days_sim - 1L
fsq_m <- subset(fsq_m, date>=first.obs.date)
# for forcasted data, repeat the last mobility index by weekend and weekday
if(last.date>last.obs.date)
{
cat("\nFor",states[m],": padding mobility trends from ",as.character(last.obs.date+1), " until ", as.character(last.date) )
# determine padding days
fsq_pad <- data.table(date= last.obs.date + seq(1, as.numeric(last.date-last.obs.date)) )
fsq_pad[, weekend:= as.integer(as.integer(format(date, "%u"))>5)]
# determine padding values
tmp <- unique(subset(fsq_m, date<=last.obs.date, select=c(date,weekend)))
tmp <- tmp[, list(date= tail(sort(date), ifelse(weekend==1,4,5))), by='weekend']
tmp <- merge(fsq_m, tmp, by=c('weekend','date'))
tmp <- tmp[, list(mobility_trend=mean(mobility_trend)), by=c('weekend','age.cat')]
# pad
fsq_pad <- merge(fsq_pad, tmp, by='weekend', allow.cartesian=TRUE)
fsq_m <- rbind(fsq_m, fsq_pad)
}
if(last.date<=last.obs.date)
{
cat("\nFor",states[m],": found mobility trends until last date ", as.character(last.date) )
fsq_m <- subset(fsq_m, date<=last.date)
}
# add to stan_data
fsq_m <- dcast.data.table(fsq_m, date ~ age.cat, value.var='mobility_trend')
tmp <- as.matrix( subset(fsq_m, select= -c(date)) )
stopifnot(nrow(tmp)==num_days_sim)
covariates_new[m,,] <- tmp
}
stopifnot( !any(is.na(covariates_new)) )
processed_data$stan_data$covariates <- NULL
processed_data$stan_data$covariates <- covariates_new
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_decoupled_mobility_trends_decline_plus_upswing_fsq <- function(processed_data, mobility_data, log=TRUE)
{
states <- names(processed_data$dates)
num_days_sim <- processed_data$stan_data$N2
covariates_new <- array(NA_real_, dim = c( length(states), 2, num_days_sim, as.integer(processed_data$stan_data$A)) )
for(m in 1:length(states))
{
fsq_m <- subset(mobility_data, loc==states[m], c(age.cat, date, weekend, eased_mobility_trend, mobility_multiplier))
fsq_m[, weekend:= as.integer(weekend=='yes')]
fsq_m <- reshape2::melt(fsq_m, measure.vars=c('eased_mobility_trend','mobility_multiplier'))
if(log)
{
cat("\nTaking log of mobility trends...")
set(fsq_m, NULL, 'value', fsq_m[, log(value)])
}
if(!log)
{
cat("\nNo log of mobility trends...")
}
first.obs.date <- min(processed_data$dates[[states[m]]])
last.obs.date <- max(fsq_m$date)
last.date <- first.obs.date + num_days_sim - 1L
fsq_m <- subset(fsq_m, date>=first.obs.date)
# for forcasted data, repeat the last mobility index by weekend and weekday
if(last.date>last.obs.date)
{
cat("\nFor",states[m],": padding mobility trends from ",as.character(last.obs.date+1), " until ", as.character(last.date) )
# determine padding days
fsq_pad <- data.table(date= last.obs.date + seq(1, as.numeric(last.date-last.obs.date)) )
fsq_pad[, weekend:= as.integer(as.integer(format(date, "%u"))>5)]
# determine padding values
tmp <- unique(subset(fsq_m, date<=last.obs.date, select=c(date,weekend)))
tmp <- tmp[, list(date= tail(sort(date), ifelse(weekend==1,4,5))), by='weekend']
tmp <- merge(fsq_m, tmp, by=c('weekend','date'))
tmp <- tmp[, list(value=mean(value)), by=c('weekend','age.cat','variable')]
# pad
fsq_pad <- merge(fsq_pad, tmp, by='weekend', allow.cartesian=TRUE)
fsq_m <- rbind(fsq_m, fsq_pad)
}
if(last.date<=last.obs.date)
{
cat("\nFor",states[m],": found mobility trends until last date ", as.character(last.date) )
fsq_m <- subset(fsq_m, date<=last.date)
}
# add to stan_data
fsq_m <- dcast.data.table(fsq_m, variable+date ~ age.cat, value.var='value')
tmp <- as.matrix( subset(fsq_m, variable=='eased_mobility_trend', -c(variable, date)) )
stopifnot(nrow(tmp)==num_days_sim)
covariates_new[m,1,,] <- tmp
tmp <- as.matrix( subset(fsq_m, variable=='mobility_multiplier', -c(variable, date)) )
stopifnot(nrow(tmp)==num_days_sim)
covariates_new[m,2,,] <- tmp
}
stopifnot( !any(is.na(covariates_new)) )
processed_data$stan_data$covariates <- NULL
processed_data$stan_data$covariates <- covariates_new
processed_data$stan_data$COVARIATES_N <- 2
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_school_cases <- function(processed_data, upper.bound.multiplier= 10,file_school_cases)
{
# data
last_date = as.Date(max(sapply(processed_data$dates, function(x) as.character(max(x)))))
school.cases <- data.table(read.csv(file_school_cases))
school.cases = school.cases[,list(number_students=sum(number_students,na.rm = T),
cumulative_students=sum(cumulative_students,na.rm = T)),
by=c('loc','start','date')]
school.cases[,cases_att_rate:=cumulative_students/number_students]
school.cases = school.cases[, date := as.Date(date)]
school.cases = school.cases[as.Date(date)<=last_date,]
school.cases = school.cases[, .SD[which.max(date)], by='loc']
setnames(school.cases, c('start','date'),c('date_start','date_end'))
# # data
# school.cases <- data.table(
# loc= c('FL', 'TX'),
# date_start= c('2020-09-06', '2020-08-24'),
# date_end= c('2020-10-24', '2020-10-25'),
# cases_att_rate= c(0.0025, 0.0034)
# )
set(school.cases, NULL, 'date_start', school.cases[, as.Date(date_start)])
set(school.cases, NULL, 'date_end', school.cases[, as.Date(date_end)])
# translate dates into time indices
dates <- data.table(
loc= names(processed_data$dates),
date_min= as.Date(sapply( processed_data$dates, function(x) min(as.character(x)) )),
date_max= as.Date(sapply( processed_data$dates, function(x) max(as.character(x)) ))
)
school.cases <- merge(school.cases, dates, by='loc')
school.cases[, time_start:= as.integer(date_start-date_min+1L)]
school.cases[, time_end:= as.integer(date_end-date_min+1L)]
# checks
stopifnot( nrow(school.cases)>0 )
stopifnot( all(school.cases[, time_start] > 0) )
stopifnot( all(school.cases[, time_end] < processed_data$stan_data$N2) )
states <- names(processed_data$dates)
# make school_case_time_idx
school_case_time_idx <- array(-1, dim = c( length(states), 2L) )
for(m in 1:length(states))
{
tmp <- subset(school.cases, loc==states[m])
if(nrow(tmp))
{
school_case_time_idx[m,] <- tmp[,c(time_start, time_end)]
}
}
# make school_case_data
school_case_data <- array(-1, dim = c( length(states), 4L) )
for(m in 1:length(states))
{
tmp <- subset(school.cases, loc==states[m])
if(nrow(tmp))
{
school_case_data[m,] <- tmp[, c(cases_att_rate, cases_att_rate/10, cases_att_rate*upper.bound.multiplier, (cases_att_rate*upper.bound.multiplier)/10)]
}
}
# add to stan_data
processed_data$stan_data$school_case_time_idx <- school_case_time_idx
processed_data$stan_data$school_case_data <- school_case_data
processed_data
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_smoothed_logcases <- function(processed_data, smoothed_log_cases)
{
states <- names(processed_data$dates)
# define date range across states
date.min <- as.Date(sapply( processed_data$dates, function(x) min(as.character(x)) ))
dates <- data.table(
loc= names(processed_data$dates),
date_min= as.Date(sapply( processed_data$dates, function(x) min(as.character(x)) )),
date_max= as.Date(sapply( processed_data$dates, function(x) max(as.character(x)) ))
)
dates <- dates[,
list(
date= seq(date_min, date_max, 1),
time_idx= seq_along(seq(date_min, date_max, 1))
),
by='loc']
# define calendar weeks
dates[, week:=as.integer(strftime(date, format = "%V"))]
tmp <- data.table(loc=states, epidemicStart=processed_data$stan_data$epidemicStart)
dates <- merge(dates, tmp, by='loc')
# subset to complete weeks
tmp <- dates[, list(days_n= length(date)), by=c('loc','week')]
dates <- merge(dates, subset(tmp, days_n==7), by=c('loc','week'))
# reset so weeks start at 1 in each location
tmp <- dates[time_idx>=epidemicStart, list(week=unique(week), week_idx= unique(week)-min(week)+1L), by='loc']
dates <- merge(dates, tmp, by=c('loc','week'))
# make vector of number of week indices per location
smoothed_logcases_weeks_n <- vector('integer', length(states))
for(m in 1:length(states))
{
tmp <- subset(dates, loc==states[m])
smoothed_logcases_weeks_n[m] <- max(tmp$week_idx)
}
smoothed_logcases_weeks_n_max <- max(smoothed_logcases_weeks_n)
# make matrix of week map
dates[, day:=as.integer(strftime(date, format = "%u"))]
smoothed_logcases_week_map <- array(-1, dim = c( length(states), smoothed_logcases_weeks_n_max, 7L) )
for(m in 1:length(states))
{
tmp <- subset(dates, loc==states[m])
tmp <- dcast.data.table(tmp, week_idx~day, value.var='time_idx')
smoothed_logcases_week_map[m, 1:nrow(tmp),] <- unname(as.matrix(tmp)[,-1])
}
# make array of t-distribution parameters state x time x 3 pars for likelihood of observed data
setnames(dates, 'loc', 'code')
smoothed_logcases_week_pars <- array(-1, dim = c( length(states), smoothed_logcases_weeks_n_max, 3L) )
for(m in 1:length(states))
{
tmp <- subset(smoothed_log_cases, code==states[m])
tmp <- merge(tmp, unique(subset(dates, select=c(code,week))), by=c('code','week'))
smoothed_logcases_week_pars[m, 1:nrow(tmp), ] <- unname(as.matrix(subset(tmp, select=c(lmean, lsd, tdf))))
}
# check
tmp <- sapply(1:length(states), function(m) max(which(smoothed_logcases_week_pars[m,,1]!= -1L)))
stopifnot(all(tmp==smoothed_logcases_weeks_n))
tmp <- sapply(1:length(states), function(m) max(which(smoothed_logcases_week_map[m,,1]!= -1L)))
stopifnot(all(tmp==smoothed_logcases_weeks_n))
# add to stan_data
processed_data$stan_data$smoothed_logcases_weeks_n_max <- smoothed_logcases_weeks_n_max
processed_data$stan_data$smoothed_logcases_weeks_n <- smoothed_logcases_weeks_n
processed_data$stan_data$smoothed_logcases_week_map <- smoothed_logcases_week_map
processed_data$stan_data$smoothed_logcases_week_pars <- smoothed_logcases_week_pars
processed_data
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_seroprevalence_data = function(processed_data, spd)
{
states <- names(processed_data$dates)
pop <- processed_data$stan_data$pop
# define date range across states
dates <- data.table(
loc= names(processed_data$dates),
date_min= as.Date(sapply( processed_data$dates, function(x) min(as.character(x)) )),
date_max= as.Date(sapply( processed_data$dates, function(x) max(as.character(x)) ))
)
dates <- dates[,
list(
date= seq(date_min, date_max, 1),
time_idx= seq_along(seq(date_min, date_max, 1))
),
by='loc']
# merge to seroprevalence study data
spds <- merge(dates, spd, by = c("loc", "date"))
# keep only overall count
spds <- subset(spds, age_band == "overall")
# if sample size not known, add 1e3
if(!'sample_size'%in%colnames(spds))
spds[, sample_size:= 1e3]
# transform prevalence estimates to prevalence numbers in sample
set(spds, NULL, 'M_obs', spds[, M_obs*sample_size])
set(spds, NULL, 'CL_obs', spds[, CL_obs*sample_size])
set(spds, NULL, 'CU_obs', spds[, CU_obs*sample_size])
# add number of sero-prevalence estimates of a loc
spds <- merge(data.table(loc=states), spds, all.x=TRUE, by='loc')
tmp <- spds[, list(
N_surveys=length(which(!is.na(date))),
N_surveys_g18=length(which(!is.na(date) & X18plus==1))
), by='loc']
spds <- merge(spds, tmp, by = "loc")
# create number of surveys per state vector
seroprevalence_surveys_n <- unique(subset(spds, select=c(loc, N_surveys)))
seroprevalence_surveys_n <- merge(data.table(loc=states, loc_id=seq_along(states)), seroprevalence_surveys_n, by='loc', all.x=TRUE)
seroprevalence_surveys_n <- seroprevalence_surveys_n[order(loc_id), N_surveys]
# create date map
seroprevalence_date_map <- matrix(nrow = length(states), ncol = max(spds$N_surveys, na.rm=TRUE), -1)
for(m in seq_along(states))
{
if(seroprevalence_surveys_n[m] > 0)
{
tmp <- subset(spds, loc == states[m])[, sort(time_idx)]
seroprevalence_date_map[m,1:seroprevalence_surveys_n[m]] <- tmp
}
}
# create data
seroprevalence_data <- array(dim = c(length(states),max(spds$N_surveys), 3), -1)
for(m in seq_along(states))
{
if(seroprevalence_surveys_n[m] > 0)
{
tmp <- subset(spds, loc == states[m])
seroprevalence_data[m,1:seroprevalence_surveys_n[m],1] <- tmp$CL_obs
seroprevalence_data[m,1:seroprevalence_surveys_n[m],2] <- tmp$CU_obs
seroprevalence_data[m,1:seroprevalence_surveys_n[m],3] <- tmp$sample_size
}
}
# create number of 18+ surveys per state vector
seroprevalence_g18_surveys_n <- unique(subset(spds, select=c(loc, N_surveys_g18)))
seroprevalence_g18_surveys_n <- merge(data.table(loc=states, loc_id=seq_along(states)), seroprevalence_g18_surveys_n, by='loc', all.x=TRUE)
seroprevalence_g18_surveys_n <- seroprevalence_g18_surveys_n[order(loc_id), N_surveys_g18]
# create date map of 18+ surveys
seroprevalence_g18_date_map <- matrix(nrow = length(states), ncol = max(spds$N_surveys_g18, na.rm=TRUE), -1)
for(m in seq_along(states))
{
if(seroprevalence_g18_surveys_n[m] > 0)
{
tmp <- subset(spds, loc == states[m] & X18plus==1)[, sort(time_idx)]
seroprevalence_g18_date_map[m,1:seroprevalence_g18_surveys_n[m]] <- tmp
}
}
# create index map of 18+ surveys
seroprevalence_g18_index_map <- matrix(nrow = length(states), ncol = max(spds$N_surveys_g18, na.rm=TRUE), -1)
for(m in seq_along(states))
{
if(seroprevalence_g18_surveys_n[m] > 0)
{
tmp <- subset(spds, loc == states[m])[, which(X18plus==1)]
seroprevalence_g18_index_map[m,1:seroprevalence_g18_surveys_n[m]] <- tmp
}
}
# register new data objects
processed_data$stan_data$seroprevalence_surveys_n_max <- max(seroprevalence_surveys_n)
processed_data$stan_data$seroprevalence_surveys_n <- seroprevalence_surveys_n
processed_data$stan_data$seroprevalence_date_map <- seroprevalence_date_map
processed_data$stan_data$seroprevalence_data <- seroprevalence_data
processed_data$stan_data$seroprevalence_g18_surveys_n_max <- max(seroprevalence_g18_surveys_n)
processed_data$stan_data$seroprevalence_g18_surveys_n <- seroprevalence_g18_surveys_n
processed_data$stan_data$seroprevalence_g18_date_map <- seroprevalence_g18_date_map
processed_data$stan_data$seroprevalence_g18_index_map <- seroprevalence_g18_index_map
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_upswing_time_effect <- function(processed_data, mobility_data, effect_weeks=2)
{
stopifnot('rebound_date'%in%colnames(mobility_data))
# define date range across states
date.min <- range( as.Date(sapply( processed_data$dates, function(x) min(as.character(x)) )) )
dates <- data.table(date= seq(date.min[1], date.min[2]+processed_data$stan_data$N2, 1))
# define calendar weeks
dates[, week:=as.integer(strftime(date, format = "%V"))]
# define first week for time effect (is always after first rebound date)
tmp <- dates[date==min(mobility_data$rebound_date), week]
dates[, time_effect_id:= pmax(1, week-tmp+1L)]
# define last week with a time effect (last week before forecasts start)
date.max.non.forecast <- max( as.Date(sapply( processed_data$dates, function(x) max(as.character(x)) )) )
tmp <- dates[date==date.max.non.forecast, week]
set(dates, NULL, 'week', pmin(tmp, dates[, week]))
# make effect weeks
set(dates, NULL, 'time_effect_id', dates[, ceiling(time_effect_id/effect_weeks)])
#subset(dates, date<=date.max.non.forecast)
# remove last time effect that is not on full effect weeks
tmp <- dates[date<=date.max.non.forecast, which(time_effect_id==max(time_effect_id))]
if(length(tmp)<effect_weeks*7)
{
tmp <- dates[date==date.max.non.forecast, time_effect_id-1L]
set(dates, NULL, 'time_effect_id', pmin(tmp, dates[,time_effect_id]))
}
# remove last time effect due to limited signal
if(effect_weeks<3)
{
tmp <- max(dates$time_effect_id)
set(dates, NULL, 'time_effect_id', pmin(tmp-1L, dates[,time_effect_id]))
}
# set total number of time effects
processed_data$stan_data$N_IMP <- max(dates$time_effect_id)
cat('\nAdding time effects, n=',processed_data$stan_data$N_IMP)
# map time effects to dates for each state
tmp <- as.Date(sapply( processed_data$dates, function(x) min(as.character(x)) ))
upswing_timeeff_map <- data.table(date= tmp, loc= seq_along(processed_data$dates))
upswing_timeeff_map <- upswing_timeeff_map[,
list(
date=date+1:processed_data$stan_data$N2,
time=1:processed_data$stan_data$N2
),
by='loc']
upswing_timeeff_map <- merge(upswing_timeeff_map, dates, by='date')
upswing_timeeff_map <- dcast.data.table(upswing_timeeff_map, time~loc, value.var='time_effect_id')
processed_data$stan_data$upswing_timeeff_map <- unname(as.matrix(subset(upswing_timeeff_map, select=-time)))
processed_data
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_decoupled_mobility_trends_3_parts_fsq <- function(processed_data, mobility_data, log=TRUE)
{
states <- names(processed_data$dates)
num_days_sim <- processed_data$stan_data$N2
covariates_new <- array(NA_real_, dim = c( length(states), 3, num_days_sim, as.integer(processed_data$stan_data$A)) )
for(m in 1:length(states))
{
fsq_m <- subset(mobility_data, loc==states[m], c(age.cat, date, weekend, baseline_mobility_trend, eased_mobility_trend, mobility_multiplier))
fsq_m[, weekend:= as.integer(weekend=='yes')]
fsq_m <- reshape2::melt(fsq_m, measure.vars=c('baseline_mobility_trend','eased_mobility_trend','mobility_multiplier'))
if(log)
{
cat("\nTaking log of mobility trends...")
set(fsq_m, NULL, 'value', fsq_m[, log(value)])
}
if(!log)
{
cat("\nNo log of mobility trends...")
}
first.obs.date <- min(processed_data$dates[[states[m]]])
last.obs.date <- max(fsq_m$date)
last.date <- first.obs.date + num_days_sim - 1L
fsq_m <- subset(fsq_m, date>=first.obs.date)
# for forcasted data, repeat the last mobility index by weekend and weekday
if(last.date>last.obs.date)
{
cat("\nFor",states[m],": padding mobility trends from ",as.character(last.obs.date+1), " until ", as.character(last.date) )
# determine padding days
fsq_pad <- data.table(date= last.obs.date + seq(1, as.numeric(last.date-last.obs.date)) )
fsq_pad[, weekend:= as.integer(as.integer(format(date, "%u"))>5)]
# determine padding values
tmp <- unique(subset(fsq_m, date<=last.obs.date, select=c(date,weekend)))
tmp <- tmp[, list(date= tail(sort(date), ifelse(weekend==1,4,5))), by='weekend']
tmp <- merge(fsq_m, tmp, by=c('weekend','date'))
tmp <- tmp[, list(value=mean(value)), by=c('weekend','age.cat','variable')]
# pad
fsq_pad <- merge(fsq_pad, tmp, by='weekend', allow.cartesian=TRUE)
fsq_m <- rbind(fsq_m, fsq_pad)
}
if(last.date<=last.obs.date)
{
cat("\nFor",states[m],": found mobility trends until last date ", as.character(last.date) )
fsq_m <- subset(fsq_m, date<=last.date)
}
# add to stan_data
fsq_m <- dcast.data.table(fsq_m, variable+date ~ age.cat, value.var='value')
tmp <- as.matrix( subset(fsq_m, variable=='baseline_mobility_trend', -c(variable, date)) )
stopifnot(nrow(tmp)==num_days_sim)
covariates_new[m,1,,] <- tmp
tmp <- as.matrix( subset(fsq_m, variable=='eased_mobility_trend', -c(variable, date)) )
stopifnot(nrow(tmp)==num_days_sim)
covariates_new[m,2,,] <- tmp
tmp <- as.matrix( subset(fsq_m, variable=='mobility_multiplier', -c(variable, date)) )
stopifnot(nrow(tmp)==num_days_sim)
covariates_new[m,3,,] <- tmp
}
stopifnot( !any(is.na(covariates_new)) )
processed_data$stan_data$covariates <- NULL
processed_data$stan_data$covariates <- covariates_new
processed_data$stan_data$COVARIATES_N <- 3
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_indicator_rebound_date <- function(processed_data, mobility_data)
{
states <- names(processed_data$dates)
num_days_sim <- processed_data$stan_data$N2
REBOUND_TIME_INDEX = vector(mode = "integer", length = processed_data$stan_data$M)
for(m in 1:length(states))
{
rebound_date <- unique(subset(mobility_data, loc==states[m])$rebound_date)
tmp <- data.table(date = seq.Date( min(processed_data$dates[[m]]), min(processed_data$dates[[m]])+num_days_sim-1, by = "day"))
tmp[, before_rebound_date := as.numeric(date < rebound_date)]
REBOUND_TIME_INDEX[m] = which(tmp$date == rebound_date)
}
processed_data$stan_data$REBOUND_TIME_INDEX <- REBOUND_TIME_INDEX
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_decoupled_mobility_trends_decline_plus_rest_fsq <- function(processed_data, mobility_data, log=TRUE)
{
states <- names(processed_data$dates)
num_days_sim <- processed_data$stan_data$N2
covariates_new <- array(NA_real_, dim = c( length(states), 2, num_days_sim, as.integer(processed_data$stan_data$A)) )
for(m in 1:length(states))
{
fsq_m <- subset(mobility_data, loc==states[m], c(age.cat, date, weekend, baseline_mobility_trend, eased_mobility_trend, mobility_multiplier))
fsq_m[, rest_mobility_trend:= eased_mobility_trend * mobility_multiplier]
set(fsq_m, NULL, c('eased_mobility_trend','mobility_multiplier'), NULL)
fsq_m[, weekend:= as.integer(weekend=='yes')]
fsq_m <- reshape2::melt(fsq_m, measure.vars=c('baseline_mobility_trend','rest_mobility_trend'))
if(log)
{
cat("\nTaking log of mobility trends...")
set(fsq_m, NULL, 'value', fsq_m[, log(value)])
}
if(!log)
{
cat("\nNo log of mobility trends...")
}
first.obs.date <- min(processed_data$dates[[states[m]]])
last.obs.date <- max(fsq_m$date)
last.date <- first.obs.date + num_days_sim - 1L
fsq_m <- subset(fsq_m, date>=first.obs.date)
# for forcasted data, repeat the last mobility index by weekend and weekday
if(last.date>last.obs.date)
{
cat("\nFor",states[m],": padding mobility trends from ",as.character(last.obs.date+1), " until ", as.character(last.date) )
# determine padding days
fsq_pad <- data.table(date= last.obs.date + seq(1, as.numeric(last.date-last.obs.date)) )
fsq_pad[, weekend:= as.integer(as.integer(format(date, "%u"))>5)]
# determine padding values
tmp <- unique(subset(fsq_m, date<=last.obs.date, select=c(date,weekend)))
tmp <- tmp[, list(date= tail(sort(date), ifelse(weekend==1,4,5))), by='weekend']
tmp <- merge(fsq_m, tmp, by=c('weekend','date'))
tmp <- tmp[, list(value=mean(value)), by=c('weekend','age.cat','variable')]
# pad
fsq_pad <- merge(fsq_pad, tmp, by='weekend', allow.cartesian=TRUE)
fsq_m <- rbind(fsq_m, fsq_pad)
}
if(last.date<=last.obs.date)
{
cat("\nFor",states[m],": found mobility trends until last date ", as.character(last.date) )
fsq_m <- subset(fsq_m, date<=last.date)
}
# add to stan_data
fsq_m <- dcast.data.table(fsq_m, variable+date ~ age.cat, value.var='value')
tmp <- as.matrix( subset(fsq_m, variable=='baseline_mobility_trend', -c(variable, date)) )
stopifnot(nrow(tmp)==num_days_sim)
covariates_new[m,1,,] <- tmp
tmp <- as.matrix( subset(fsq_m, variable=='rest_mobility_trend', -c(variable, date)) )
stopifnot(nrow(tmp)==num_days_sim)
covariates_new[m,2,,] <- tmp
}
stopifnot( !any(is.na(covariates_new)) )
processed_data$stan_data$covariates <- NULL
processed_data$stan_data$covariates <- covariates_new
processed_data$stan_data$COVARIATES_N <- 2
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
#' @importFrom stats filter
stan_data_add_google_mobility_covariates_after_breakpoint <- function(processed_data)
{
ma <- function(x, n = 5){stats::filter(x, rep(1 / n, n), sides = 2)} # moving average
states = names(processed_data$dates)
num_days_sim = processed_data$stan_data$N2
with_fsq_mobility<- 0
P_RES = processed_data$stan_data$P_RES
P_NONRES = processed_data$stan_data$P_NONRES
processed_data$stan_data$P_RES = P_RES*2
processed_data$stan_data$P_NONRES = P_NONRES*2
for(m in 1:length(states)){
State = states[m]
min_date = min(processed_data$dates[[m]])
dates = seq(min_date, min_date+num_days_sim-1, by = "day")
is.weekend = weekdays(dates) %in% c("Saturday", "Sunday")
# find breakpoint
breakpoint = dates[!is.weekend][which.min(ma(processed_data$stan_data$covariates_nonres[[m]][!is.weekend, "avg_mob"]))]
is.after.breakpoint = seq(min_date, min_date+num_days_sim-1, by = "day") > breakpoint
covariates_res = matrix(nrow = num_days_sim, ncol = 2*P_RES, 0)
for(j in 1:P_RES){
covariates_res[,j] = processed_data$stan_data$covariates_res[[m]][,j]
eased_mobility = covariates_res[,j]
covariates_res[is.after.breakpoint & is.weekend,j] = median(tail(covariates_res[!is.after.breakpoint & is.weekend,j],n=2))
covariates_res[is.after.breakpoint & !is.weekend,j] = median(tail(covariates_res[!is.after.breakpoint & !is.weekend,j],n=5))
covariates_res[,(P_RES+j)] = eased_mobility - covariates_res[,j]
}
covariates_nonres = matrix(nrow = num_days_sim, ncol = 2*P_NONRES, 0)
for(j in 1:P_NONRES){
covariates_nonres[,j] = processed_data$stan_data$covariates_nonres[[m]][,j]
eased_mobility = covariates_nonres[,j]
covariates_nonres[is.after.breakpoint & is.weekend,j] = median(tail(covariates_nonres[!is.after.breakpoint & is.weekend,j],n=2))
covariates_nonres[is.after.breakpoint & !is.weekend,j] = median(tail(covariates_nonres[!is.after.breakpoint & !is.weekend,j],n=5))
covariates_nonres[,(j+P_NONRES)] = eased_mobility - covariates_nonres[,j]
}
colnames(covariates_res) = c(colnames(processed_data$stan_data$covariates_res[[m]]), paste0(colnames(processed_data$stan_data$covariates_res[[m]]), "_afterbreakpoint"))
colnames(covariates_nonres) = c(colnames(processed_data$stan_data$covariates_nonres[[m]]), paste0(colnames(processed_data$stan_data$covariates_nonres[[m]]), "_afterbreakpoint"))
processed_data$stan_data$covariates_res[[m]] = covariates_res
processed_data$stan_data$covariates_nonres[[m]] = covariates_nonres
}
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
process_chi_emodo_mobilty <- function(mobility_data,pop_info,infile_emodo=NULL){
# read emodo data
mob_emodo_idx <- read_emodo_cell_phone_contact_intensities(infile_emodo,type='idx')
emo_age_cat_map_idx <- make_emodo_age_cat_map(mob_emodo_idx, pop_info)
mob_emodo_idx <- make_mobility_trends_emo(mob_emodo_idx, emo_age_cat_map_idx)
# take dates after dip date
tmp <- unique(subset(mobility_data,select = c('loc','dip_date')))
mob_emodo_idx <- merge(mob_emodo_idx, tmp, by='loc')
mob_emodo_idx <- mob_emodo_idx[date > dip_date]
# read pairwise emodo data
mob_emodo <- read_emodo_cell_phone_contact_intensities_with_cont(infile_emodo)
emo_age_cat_map <- make_emodo_age_cat_map_with_cont(mob_emodo, pop_info)
mob_emodo <- make_mobility_trends_emo_with_cont(mob_emodo, emo_age_cat_map)
# combine
ans <- subset(mob_emodo,select = c('date','loc','idx.age.label','cont.age.label','mobility_trend'))
ans <- merge(ans, unique(subset(mob_emodo_idx,select = c('emo.age.label','loc','date','mobility_trend'))),
by.x=c('idx.age.label','loc','date'),
by.y=c('emo.age.label','loc','date'))
ans <- unique(ans)
# estimate log chi
m <-glm(mobility_trend.x ~ idx.age.label:cont.age.label + offset(log(mobility_trend.y)) -1,
data = ans, family = gaussian(link = "log"))
# make table
log_chi <- data.table(coef(summary(m)),keep.rownames = TRUE)
log_chi[,idx.age.label:=unlist(lapply(strsplit(rn,':'),function(x){x[1]}))]
log_chi[,cont.age.label:=unlist(lapply(strsplit(rn,':'),function(x){x[2]}))]
# rename table
log_chi[,idx.age.label:=gsub('idx.age.label','',idx.age.label)]
log_chi[,cont.age.label:=gsub('cont.age.label','',cont.age.label)]
set(log_chi, NULL, c('rn','t value','Pr(>|t|)'),NULL)
setkey(log_chi, idx.age.label, cont.age.label)
# transfer to matrix
chi <- matrix(exp(log_chi$Estimate), byrow = TRUE,
nrow = length(unique(log_chi$idx.age.label)),
ncol = length(unique(log_chi$idx.age.label)))
# map chi
map_chi <- unique(subset(mob_emodo_idx,select=c('emo.age.cat','age.cat')))
setkey(map_chi,age.cat)
# save
file <- file.path(args$indir,'usa','data','chi_emodo_mobility_trends.rds')
cat("\nWrite to file",file)
saveRDS(list(log_chi=log_chi,
chi=chi,
map_chi=map_chi$emo.age.cat), file=file)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
#' @importFrom dplyr mutate rename select
stan_data_add_google_mobility = function(processed_data, mobility_data, with_avg_mobility_data){
# mobility_data: data table
# google mobility data by state code, date and index
# with variables: code, date, retail.recreation, grocery.pharmacy, parks, transitstations, workplace, residential
# with_avg_mobility_data: binary
# 1 if you want to pooled retail & recreation, grocery & pharmac, workplace and park instead of using them individually
# this is done automatically if with_res_nonres_contactmatrix_model=1
states = names(processed_data$dates)
num_days_sim = processed_data$stan_data$N2
processed_data$stan_data = c(processed_data$stan_data,
list(
covariates_nonres = vector('list', length(states)), # predictors for non-residential contacts
covariates_res = vector('list', length(states)), # predictors for residential contacts
P_RES = NA_integer_, # number of predictors for residential contacts
P_NONRES = NA_integer_ # number of predictors for non-residential contacts
))
for(m in 1:length(states)){
State = states[m]
# if with_res_nonres_contactmatrix_model == 0
if("retail.recreation" %in% colnames(mobility_data))
{
tmp <- mobility_data %>%
dplyr::select(code, date, retail.recreation, grocery.pharmacy, parks, transitstations, workplace, residential)
if(with_avg_mobility_data){
tmp$avg_mob = apply(dplyr::select(tmp, c("retail.recreation", "grocery.pharmacy", "parks", "workplace")), 1, mean)
tmp = dplyr::select(tmp, c("code", "date", "residential", "transitstations", "avg_mob"))
}
}
# if with_res_nonres_contactmatrix_model == 1
if(!"retail.recreation" %in% colnames(mobility_data))
{
tmp <- mobility_data %>%
dplyr::select(code, date, nonresidential_M, residential_M) %>%
dplyr::rename(nonresidential=nonresidential_M, residential=residential_M)
}
# keep only from the date with death data
tmp1 <- subset(tmp, date >= min(processed_data$dates[[State]]) & code == State)
covariates <- tmp1 %>% dplyr::select(-c(code))
N_cov = nrow(covariates)
forecast_cov <- num_days_sim - N_cov
# for forcasted data, repeat the last mobility index by weekend and weekday
covariates = covariates[1:(N_cov+forecast_cov),]
covariates[N_cov:(N_cov+forecast_cov),]$date <- seq(covariates[N_cov,]$date, covariates[N_cov,]$date+forecast_cov, by ="day")
covariates <- covariates %>%
dplyr::mutate(weekend:=as.integer(format(date, "%u"))>5)
mobility_indices <- setdiff(colnames(covariates), c('date','weekend'))
for(x in mobility_indices)
{
z <- which(is.na(covariates[[x]]))
z2 <- which(diff(z)!=1)
if(!length(z2))
z2 <- length(z)
z <- which(is.na(covariates[[x]]) & !covariates$weekend)
z2 <- which(is.na(covariates[[x]]) & covariates$weekend)
if(length(z))
covariates[[x]][z] <- covariates[[x]][ dplyr::last(which(!is.na(covariates[[x]]) & !covariates$weekend)) ]
if(length(z2))
covariates[[x]][z2] <- covariates[[x]][ dplyr::last(which(!is.na(covariates[[x]]) & covariates$weekend)) ]
}
# add covariates residential
processed_data$stan_data$covariates_res[[m]] <- as.matrix( covariates %>% dplyr::select(residential) )
processed_data$stan_data$P_RES <- ncol( processed_data$stan_data$covariates_res[[m]] )
# add covariates non-residential
mobility_indices <- setdiff(colnames(covariates), c('date','weekend'))
processed_data$stan_data$covariates_nonres[[m]] <- as.matrix( covariates %>% dplyr::select(setdiff(mobility_indices,'residential')) )
processed_data$stan_data$P_NONRES <- ncol( processed_data$stan_data$covariates_nonres[[m]] )
}
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
process_death = function(d1, is_m_in_states_od, index1, index2, forecast, deathsByAge, dataByAgestart, A_AD){
State = unique(d1$code)
# for states without death by age, only need to process overall death
if(is_m_in_states_od){
deaths_without_forecast <- as.vector(as.numeric(d1$Deaths))
deaths <- c(as.vector(as.numeric(d1$Deaths)),rep(-1,forecast))
cat(State, "does not have death by age data \n")
return(list("deaths_without_forecast" = deaths_without_forecast, "deaths" = deaths))
}
# for states with death by age, need to process overall death and death by age
if(!is_m_in_states_od){
# dataByAgestart = deathByAge_data$dataByAgestart[[State]]; A_AD=deathByAge_data$A_AD[[State]]
# if death by age start before epidemic start
# start death by age 1 day after epidemic start
if(dataByAgestart <= index1){
deathsByAge[index1+1,1:A_AD] = apply(deathsByAge[dataByAgestart:(index1+1),1:A_AD], 2, sum)
deathsByAge[dataByAgestart:index1,1:A_AD] = -1
dataByAgestart = index1+1
}
# overwrite the overall deaths with the sum of the age specific deaths
n.d1 = nrow(d1) + index2 - 1
dataByAgestart_adj = dataByAgestart-index2 + 1
deaths_without_forecast <- c(as.vector(as.numeric(d1$Deaths))[1:dataByAgestart_adj], apply(deathsByAge[(dataByAgestart+1):n.d1,1:A_AD],1,sum))
# add forecast
deathsByAge <- rbind(deathsByAge[index2:n.d1,], matrix(ncol=ncol(deathsByAge), nrow=forecast, -1))
deaths <- c(deaths_without_forecast, rep(-1,forecast))
cat(State, "has", length(dataByAgestart:n.d1), "days with death by age data, starting from day", dataByAgestart_adj, "\n")
return(list("deaths_without_forecast" = deaths_without_forecast, "deaths" = deaths, "deathsByAge" = deathsByAge, "dataByAgestart" = dataByAgestart_adj))
}
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_lognormal_prior_relsusceptibility <- function(processed_data, file_path_CI_OR)
{
# estimated OR mean from https://science.sciencemag.org/content/sci/early/2020/05/04/science.abb8001.full.pdf
CI_OR <- read.csv(file_path_CI_OR)
processed_data$stan_data$mean_log_relsusceptibility_age_reduced = c(rep(CI_OR$mu[1], 2), rep(0, 3), rep(CI_OR$mu[2], 2))
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr splines
stan_data_add_splines = function(processed_data, spline_degree, num_knots){
# age continuous
age = 0:99
n.age.cont = length(age)
age_discrete = mean(c(0,4)) + seq(age[1], age[n.age.cont], 5)
n.age.disc = length(age_discrete)
knots = seq(age[1], age[n.age.cont], length.out = num_knots+2)[-c(1, num_knots+2)]
# matrix for taking the mean over contiuous age scale and obtaining discrete scale
# get_age_discrete = matrix(nrow = n.age.disc, ncol = n.age.cont, rep(c(rep(1, n.age.cont/n.age.disc), rep(0, n.age.cont)), n.age.disc), byrow = T)
# get_age_discrete = get_age_discrete/(n.age.cont/n.age.disc)
#
# matrix of B-splines
B <- t(bs(age_discrete, df= num_knots + spline_degree - 1, degree= spline_degree, intercept = TRUE))
stan_data = list(
num_knots = num_knots,
knots = knots,
spline_degree = spline_degree,
B = B)
processed_data$stan_data = c(processed_data$stan_data, stan_data)
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_lognormal_prior_on_ifr_by_age = function(processed_data, ifr.by.age)
{
stopifnot(c('age_cat','ln_mu','ln_sd')%in%colnames(ifr.by.age))
setkey(ifr.by.age, age_cat)
processed_data$stan_data$hyperpara_ifr_age_lnmu <- ifr.by.age$ln_mu
processed_data$stan_data$hyperpara_ifr_age_lnsd <- ifr.by.age$ln_sd
within( processed_data$stan_data, rm(ifr_age) )
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_beta_prior_on_ifr_by_age = function(processed_data, ifr.by.age){
# TODO we are assuming that ifr.by.age is ordered
processed_data$stan_data$hyperpara_ifr_age = cbind(ifr.by.age$ifr_beta_alpha, ifr.by.age$ifr_beta_beta)
within( processed_data$stan_data, rm(ifr_age) )
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_logitincrements_prior_on_ifr_by_age = function(processed_data, ifr.by.age){
# TODO we are assuming that ifr.by.age is ordered
processed_data$stan_data$ifr_age_mean = ifr.by.age$ifr_mean
processed_data$stan_data$inv_sqrt_1_to_A = 1/sqrt(seq(1, processed_data$stan_data$A))
within( processed_data$stan_data, rm(ifr_age) )
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_GMRF_prior_on_susceptibility = function(processed_data){
A = processed_data$stan_data$A
node1=c(seq.int(1, A-1L), seq.int(1, A-2L))
node2 =c(seq.int(2, A), seq.int(3, A))
tmp <- sort(node1, index.return=TRUE)$ix
processed_data$stan_data = c(processed_data$stan_data,
list(node1 = node1[tmp],
node2 = node2[tmp]))
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_logitprior_ifrbyage = function(processed_data, logit.coef.ifr.by.age){
age = 0:99
n.age.cont = length(age)
age_midpoint = mean(c(0,4)) + seq(age[1], age[n.age.cont], 5)
processed_data$stan_data = c(processed_data$stan_data,
list(hyperpara_ifr_age = as.matrix(logit.coef.ifr.by.age),
age_midpoint = age_midpoint))
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_gpprior_betaage = function(processed_data){
age = 0:99
n.age.cont = length(age)
age_midpoint = mean(c(0,4)) + seq(age[1], age[n.age.cont], 5)
processed_data$stan_data = c(processed_data$stan_data,
list(age_midpoint = age_midpoint))
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_school_status <- function(processed_data,
path_to_file_school_intervention,
forecast_with_schools_reopened,
reopening_Date)
{
states = names(processed_data$dates)
num_days_sim = processed_data$stan_data$N2
#
# find school closure dates
dsi <- as.data.table(read.csv(path_to_file_school_intervention))
dsi <- subset(dsi, !is.na(RegionName) & !is.na(Date) & RegionName != "" & !is.na(C1_School.closing))
dsi[, date := as.Date(as.character(Date), format= "%Y%m%d")]
dsi[, loc := gsub("US_(.+)","\\1",RegionCode)]
dsi <- subset(dsi, select=c(loc, date, C1_School.closing))
dsi <- dsi[C1_School.closing != 0, list(closure_date = min(date)), by = c("loc")]
#
# use NY for NYC
tmp <- subset(dsi, loc == "NY")
tmp[, loc := "NYC"]
dsi <- rbind(dsi,tmp)
#
# set reopening_date
tmp <- sapply(sapply(processed_data$dates, as.character), max)
tmp <- data.table(loc= names(tmp), first.day.forecast= as.Date(tmp)+1)
tmp[, first.day.data:= as.Date(sapply(sapply(processed_data$dates, as.character), min))]
tmp[, last.day.forecast := first.day.data+num_days_sim-1]
if(forecast_with_schools_reopened)
{
tmp[, reopening_date:= reopening_Date]
}
if(!forecast_with_schools_reopened)
{
tmp[, reopening_date:= last.day.forecast+1]
}
dsi <- merge(dsi, tmp, by='loc')
dsi <- merge(dsi, dsi[, list(date= seq(first.day.data, last.day.forecast, by='day')), by='loc'], by='loc')
dsi[, school_closed:= as.integer(closure_date<=date & date<reopening_date)]
# define stan data matrix
SCHOOL_STATUS <- matrix(nrow = num_days_sim, ncol = processed_data$stan_data$M, NA_integer_)
for(m in 1:length(states))
{
SCHOOL_STATUS[,m] <- subset(dsi, loc==states[m])[, school_closed]
}
processed_data$stan_data$SCHOOL_STATUS = SCHOOL_STATUS
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_school_status_EduWeek = function(processed_data,
path_to_file_school_Ox_data,
path_to_file_school_EduWeek_data,
counterfactual_scenario = 0,
forecast_with_schools_reopened = 0,
default_school_reopening_date = as.Date("2020-08-24"))
{
states = names(processed_data$dates)
num_days_sim = processed_data$stan_data$N2
#
# find school closure dates
dsi <- as.data.table(read.csv(path_to_file_school_Ox_data))
dsi <- subset(dsi, !is.na(RegionName) & !is.na(Date) & RegionName != "" & !is.na(C1_School.closing))
dsi[, date := as.Date(as.character(Date), format= "%Y%m%d")]
dsi[, loc := gsub("US_(.+)","\\1",RegionCode)]
dsi <- subset(dsi, select=c(loc, date, C1_School.closing))
dsi <- dsi[C1_School.closing != 0, list(closure_date = min(date)), by = c("loc")]
# use NY for NYC
tmp <- subset(dsi, loc == "NY")
tmp[, loc := "NYC"]
dsi <- rbind(dsi,tmp)
#
# find school re-opening dates
tmp <- sapply(sapply(processed_data$dates, as.character), max)
tmp <- data.table(loc= names(tmp), first.day.forecast= as.Date(tmp)+1)
tmp[, first.day.data:= as.Date(sapply(sapply(processed_data$dates, as.character), min))]
tmp[, last.day.forecast := first.day.data+num_days_sim-1]
# set reopening date for states for which schools re-opened before forecast started
ods <- load_EduWeekly_data(path_to_file_school_EduWeek_data, path_to_file_school_Ox_data)
df_reopening_dates <- find_reopening_dates(ods, default_school_reopening_date)
tmp = as.data.table( merge(tmp, df_reopening_dates, by = c("loc")) )
tmp[schools_reopened_before_forecast == 1, reopening_date := reopening_date_Edu_Week]
tmp[schools_reopened_before_forecast == 0, reopening_date := last.day.forecast+1]
# forecast scenarios
if(forecast_with_schools_reopened){
tmp[, reopening_date := default_school_reopening_date]
}
if(counterfactual_scenario){
tmp1 = copy(tmp)
if(!forecast_with_schools_reopened){
tmp[, reopening_date:= last.day.forecast+1]
}
}
dsi <- merge(dsi, tmp, by='loc')
dsi <- merge(dsi, dsi[, list(date= seq(first.day.data, last.day.forecast, by='day')), by='loc'], by='loc')
dsi[, school_closed := as.integer(closure_date<=date & date<reopening_date)]
# define stan data matrix
SCHOOL_STATUS <- matrix(nrow = num_days_sim, ncol = processed_data$stan_data$M, NA_integer_)
for(m in 1:length(states))
{
SCHOOL_STATUS[,m] <- subset(dsi, loc==states[m])[, school_closed]
}
#
# set 'elementary_school_reopening_idx'
reo.tab <- data.table(loc = states, last_obs_idx = sapply(processed_data$dates,length),
last_obs_date = as.Date(sapply(processed_data$dates, function(x) tail(as.character(x), 1))))
reo.idx = merge(reo.tab, tmp, by = "loc")
reo.idx[, `:=`(reo_idx, last_obs_idx + as.integer(reopening_date -
last_obs_date))]
stopifnot(all(reo.idx$reo_idx <= processed_data$stan_data$N2 + 1))
reo.idx = reo.idx[match(states, reo.idx$loc)]
processed_data$stan_data$SCHOOL_STATUS = SCHOOL_STATUS
processed_data$stan_data$elementary_school_reopening_idx <- reo.idx$reo_idx
# save school reopening date index from the re-opening school scenario
if(counterfactual_scenario){
tmp1[schools_reopened_before_forecast == 0, reopening_date := first.day.forecast]
elt_reopening_index = merge(reo.tab, tmp1, by = "loc")
elt_reopening_index[, `:=`(elt_reopening_index, last_obs_idx + as.integer(reopening_date -last_obs_date))]
stopifnot(all(elt_reopening_index$elt_reopening_index <= processed_data$stan_data$N2 + 1))
processed_data$stan_data$elt_reopening_index <- elt_reopening_index$elt_reopening_index
} else {
processed_data$stan_data$elt_reopening_index = reo.idx$reo_idx
}
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_school_status_EduWeek_with_closure2 = function(processed_data,
path_to_file_school_Ox_data,
path_to_file_school_EduWeek_data,
counterfactual_scenario = 0,
forecast_with_schools_reopened = 0,
forecast_with_schools_closure_2 = 0,
default_school_reopening_date = as.Date("2020-08-24"),
default_school_closure_2_date = as.Date("2021-01-01"))
{
states = names(processed_data$dates)
num_days_sim = processed_data$stan_data$N2
#
# find school closure dates
dsi <- as.data.table(read.csv(path_to_file_school_Ox_data))
dsi <- subset(dsi, CountryName == 'United States')
dsi <- subset(dsi, !is.na(RegionName) & !is.na(Date) & RegionName != "" & !is.na(C1_School.closing))
dsi[, date := as.Date(as.character(Date), format= "%Y%m%d")]
dsi[, loc := gsub("US_(.+)","\\1",RegionCode)]
dsi <- subset(dsi, select=c(loc, date, C1_School.closing))
dsi <- dsi[C1_School.closing != 0, list(closure_date = min(date)), by = c("loc")]
# use NY for NYC
tmp <- subset(dsi, loc == "NY")
tmp[, loc := "NYC"]
dsi <- rbind(dsi,tmp)
#
# find school re-opening dates
tmp <- sapply(sapply(processed_data$dates, as.character), max)
tmp <- data.table(loc= names(tmp), first.day.forecast= as.Date(tmp)+1)
tmp[, first.day.data:= as.Date(sapply(sapply(processed_data$dates, as.character), min))]
tmp[, last.day.forecast := first.day.data+num_days_sim-1]
# load and cure edu weekly data
ods <- load_EduWeekly_data(path_to_file_school_EduWeek_data, path_to_file_school_Ox_data)
# set reopening date
df_reopening_dates <- find_reopening_dates(ods, default_school_reopening_date)
tmp = as.data.table( merge(tmp, df_reopening_dates, by = c("loc")) )
tmp[schools_reopened_before_forecast == 1, reopening_date := reopening_date_Edu_Week]
tmp[schools_reopened_before_forecast == 0, reopening_date := last.day.forecast+1]
# set closure date 2
df_closure_2_dates <- find_closure_2_dates(ods, default_school_closure_2_date, df_reopening_dates)
tmp = as.data.table( merge(tmp, df_closure_2_dates, by = c("loc")) )
tmp[schools_close_2_before_forecast == 1, closure_2_date := closure_2_date_Edu_Week]
tmp[schools_close_2_before_forecast == 0, closure_2_date := last.day.forecast+1]
# forecast scenarios
if(forecast_with_schools_reopened){
tmp[, reopening_date := default_school_reopening_date]
}
if(forecast_with_schools_closure_2){
tmp[, closure_2_date:= default_school_closure_2_date]
}
if(counterfactual_scenario){
tmp1 = copy(tmp)
if(!forecast_with_schools_reopened){
tmp[, reopening_date:= last.day.forecast+1]
}
}
dsi <- merge(dsi, tmp, by='loc')
dsi <- merge(dsi, dsi[, list(date= seq(first.day.data, last.day.forecast, by='day')), by='loc'], by='loc')
dsi[, school_closed := as.integer((date >=closure_date & date<reopening_date) | (date >= closure_2_date))]
# define stan data matrix
SCHOOL_STATUS <- matrix(nrow = num_days_sim, ncol = processed_data$stan_data$M, NA_integer_)
for(m in 1:length(states))
{
SCHOOL_STATUS[,m] <- subset(dsi, loc==states[m])[, school_closed]
}
#
# set 'elementary_school_reopening_idx'
reo.tab <- data.table(loc = states, last_obs_idx = sapply(processed_data$dates,length),
last_obs_date = as.Date(sapply(processed_data$dates, function(x) tail(as.character(x), 1))))
reo.idx = merge(reo.tab, tmp, by = "loc")
reo.idx[, `:=`(reo_idx, last_obs_idx + as.integer(reopening_date -
last_obs_date))]
stopifnot(all(reo.idx$reo_idx <= processed_data$stan_data$N2 + 1))
reo.idx = reo.idx[match(states, reo.idx$loc)]
processed_data$stan_data$SCHOOL_STATUS = SCHOOL_STATUS
processed_data$stan_data$elementary_school_reopening_idx <- reo.idx$reo_idx
# save school reopening date index from the re-opening school scenario
if(counterfactual_scenario){
tmp1[schools_reopened_before_forecast == 0, reopening_date := first.day.forecast]
elt_reopening_index = merge(reo.tab, tmp1, by = "loc")
elt_reopening_index[, `:=`(elt_reopening_index, last_obs_idx + as.integer(reopening_date -last_obs_date))]
stopifnot(all(elt_reopening_index$elt_reopening_index <= processed_data$stan_data$N2 + 1))
processed_data$stan_data$elt_reopening_index <- elt_reopening_index$elt_reopening_index
} else {
processed_data$stan_data$elt_reopening_index = reo.idx$reo_idx
}
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_contact_school_closure = function(processed_data, dcontact, path_to_file_contact_intensities_outbreak_China, multiplier_cntct_school_closure,
with_average_cntnt_child_outbreak = FALSE, min_pc_contacts=0.05)
{
contact_intensities_outbreak_zhang <- as.data.table(readRDS(path_to_file_contact_intensities_outbreak_China))
age_category = c("0-4", "5-9", "10-14", "15-19", "20-24", "25-29", "30-34", "35-39", "40-44", "45-49", "50-54", "55-59", "60-64", "65+")
children_label = c("0-4", "5-9", "10-14")
#
# age categories as factor
contact_intensities_outbreak_zhang[, age_index := factor(age_index, levels = age_category)]
contact_intensities_outbreak_zhang[, age_contact := factor(age_contact, levels = age_category)]
#
# aggregate over both cities
cnt.zhang = contact_intensities_outbreak_zhang[, list(count_post = mean(count_post)), by = c("age_index", "age_contact")]
#
# take the average over children
if(with_average_cntnt_child_outbreak){
cat("\nAveraging contact intensities for children aged 0-14")
cnt.zhang[age_index %in% children_label & age_contact %in% children_label, count_post := mean(count_post)]
}
#
# break 65+ age band into 65-69, 70-74, 75-79, 80-84, 85+
old_age_label = "65+"
new_age_label = c("65-69", "70-74", "75-79", "80-84", "85+")
new_age_category = c(age_category[-length(age_category)], new_age_label)
# age index
df = cnt.zhang[age_index %in% old_age_label,]
df = df[rep(seq_len(nrow(df)), each = length(new_age_label)),]
df[,age_index := rep(new_age_label, length(age_category))]
cnt.zhang = rbind(subset(cnt.zhang, !age_index %in% old_age_label), df)
# age contact
df2 = cnt.zhang[age_contact %in% old_age_label,]
df2 = df2[rep(seq_len(nrow(df2)), each = length(new_age_label)),]
df2[, age_contact := rep(new_age_label, length(new_age_category))]
df2[, count_post := count_post/length(new_age_label)] # take average
cnt.zhang = rbind(subset(cnt.zhang, !age_contact %in% old_age_label), df2)
setnames(cnt.zhang, c('age_index','age_contact','count_post'),c('part.age.cat.label','cont.age.cat.label','m_zhang'))
#
# prepare contact matrices during school closure for each state
cnt.zhang <- merge(dcontact, cnt.zhang, by=c('part.age.cat.label','cont.age.cat.label'))
cnt.zhang[, m_pc:= min_pc_contacts*m]
cnt.zhang[, m_model:= pmin(m ,multiplier_cntct_school_closure * pmax(m_pc, m_zhang))]
# on weekdays, use m_model for 0-14 -> any, any-> 0-14, otherwise m*trends
tmp <- cnt.zhang[, which(type=='weekday' & part.age.cat>3 & cont.age.cat>3 )]
set(cnt.zhang, tmp, 'm_model', cnt.zhang[tmp,m])
# on weekend days, use m_model for 0-14 -> any, any-> 0-14, otherwise m*trends
tmp <- cnt.zhang[, which(type=='weekend' & part.age.cat>3 & cont.age.cat>3 )]
set(cnt.zhang, tmp, 'm_model', cnt.zhang[tmp,m])
states = names(processed_data$dates)
cntct_school_closure_weekdays = vector('list', length(states))
cntct_school_closure_weekends = vector('list', length(states))
for(i in 1:length(states))
{
tmp <- dcast.data.table(subset(cnt.zhang, loc==states[i] & type=="weekday"), part.age.cat~cont.age.cat, value.var='m_model')
tmp <- unname(as.matrix(tmp)[,-1])
cntct_school_closure_weekdays[[i]] <- tmp
tmp <- dcast.data.table(subset(cnt.zhang, loc==states[i] & type=="weekend"), part.age.cat~cont.age.cat, value.var='m_model')
tmp <- unname(as.matrix(tmp)[,-1])
cntct_school_closure_weekends[[i]] <- tmp
}
processed_data$stan_data$A_CHILD = 3L
processed_data$stan_data$AGE_CHILD = c(1L,2L,3L)
processed_data$stan_data$cntct_school_closure_weekdays = cntct_school_closure_weekdays
processed_data$stan_data$cntct_school_closure_weekends = cntct_school_closure_weekends
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_contact_elementary_high_school_closure = function(processed_data, dcontact, path_to_file_contact_intensities_outbreak_China,
multiplier_cntct_school_closure, min_pc_contacts=0.05)
{
contact_intensities_outbreak_zhang <- as.data.table(readRDS(path_to_file_contact_intensities_outbreak_China))
age_category = c("0-4", "5-9", "10-14", "15-19", "20-24", "25-29", "30-34", "35-39", "40-44", "45-49", "50-54", "55-59", "60-64", "65+")
#
# age categories as factor
contact_intensities_outbreak_zhang[, age_index := factor(age_index, levels = age_category)]
contact_intensities_outbreak_zhang[, age_contact := factor(age_contact, levels = age_category)]
#
# aggregate over both cities
cnt.zhang = contact_intensities_outbreak_zhang[, list(count_post = mean(count_post)), by = c("age_index", "age_contact")]
#
# break 65+ age band into 65-69, 70-74, 75-79, 80-84, 85+
old_age_label = "65+"
new_age_label = c("65-69", "70-74", "75-79", "80-84", "85+")
new_age_category = c(age_category[-length(age_category)], new_age_label)
# age index
df = cnt.zhang[age_index %in% old_age_label,]
df = df[rep(seq_len(nrow(df)), each = length(new_age_label)),]
df[,age_index := rep(new_age_label, length(age_category))]
cnt.zhang = rbind(subset(cnt.zhang, !age_index %in% old_age_label), df)
# age contact
df2 = cnt.zhang[age_contact %in% old_age_label,]
df2 = df2[rep(seq_len(nrow(df2)), each = length(new_age_label)),]
df2[, age_contact := rep(new_age_label, length(new_age_category))]
df2[, count_post := count_post/length(new_age_label)] # take average
cnt.zhang = rbind(subset(cnt.zhang, !age_contact %in% old_age_label), df2)
setnames(cnt.zhang, c('age_index','age_contact','count_post'),c('part.age.cat.label','cont.age.cat.label','m_zhang'))
#
# prepare contact matrices during school closure for each state
cnt.zhang <- merge(dcontact, cnt.zhang, by=c('part.age.cat.label','cont.age.cat.label'))
cnt.zhang[, m_pc:= min_pc_contacts*m]
cnt.zhang[, m_model:= pmin(m ,multiplier_cntct_school_closure * pmax(m_pc, m_zhang))]
# on weekdays, use m_model for 0-19 -> any, any-> 0-19, otherwise m*trends
tmp <- cnt.zhang[, which(type=='weekday' & part.age.cat>4 & cont.age.cat>4 )]
set(cnt.zhang, tmp, 'm_model', cnt.zhang[tmp,m])
# on weekend days, use m_model for 0-19 -> any, any-> 0-19, otherwise m*trends
tmp <- cnt.zhang[, which(type=='weekend' & part.age.cat>4 & cont.age.cat>4 )]
set(cnt.zhang, tmp, 'm_model', cnt.zhang[tmp,m])
states = names(processed_data$dates)
cntct_school_closure_weekdays = vector('list', length(states))
cntct_school_closure_weekends = vector('list', length(states))
for(i in 1:length(states))
{
tmp <- dcast.data.table(subset(cnt.zhang, loc==states[i] & type=="weekday"), part.age.cat~cont.age.cat, value.var='m_model')
tmp <- unname(as.matrix(tmp)[,-1])
cntct_school_closure_weekdays[[i]] <- tmp
tmp <- dcast.data.table(subset(cnt.zhang, loc==states[i] & type=="weekend"), part.age.cat~cont.age.cat, value.var='m_model')
tmp <- unname(as.matrix(tmp)[,-1])
cntct_school_closure_weekends[[i]] <- tmp
}
processed_data$stan_data$A_CHILD = 4L
processed_data$stan_data$AGE_CHILD = c(1L,2L,3L,4L)
processed_data$stan_data$A_ADULT = 7L
processed_data$stan_data$AGE_ADULT = c(5L,6L,7L,8L, 9L,10L,11L)
processed_data$stan_data$cntct_school_closure_weekdays = cntct_school_closure_weekdays
processed_data$stan_data$cntct_school_closure_weekends = cntct_school_closure_weekends
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_contact_school_opening <- function(processed_data,
dcontact,
path_to_file_contact_intensities_outbreak_China,
multiplier_cntct_school_closure=1,
multiplier_cntct_school_opening=1,
min_pc_contacts=0.05,
reopening_date="2020-08-24")
{
contact_intensities_outbreak_zhang <- as.data.table(readRDS(path_to_file_contact_intensities_outbreak_China))
age_category = c("0-4", "5-9", "10-14", "15-19", "20-24", "25-29", "30-34", "35-39", "40-44", "45-49", "50-54", "55-59", "60-64", "65+")
children_label = c("0-4", "5-9", "10-14")
#
# age categories as factor
contact_intensities_outbreak_zhang[, age_index := factor(age_index, levels = age_category)]
contact_intensities_outbreak_zhang[, age_contact := factor(age_contact, levels = age_category)]
#
# aggregate over both cities
cnt.zhang = contact_intensities_outbreak_zhang[, list(count_post = mean(count_post)), by = c("age_index", "age_contact")]
#
# break 65+ age band into 65-69, 70-74, 75-79, 80-84, 85+
old_age_label = "65+"
new_age_label = c("65-69", "70-74", "75-79", "80-84", "85+")
new_age_category = c(age_category[-length(age_category)], new_age_label)
# age index
df = cnt.zhang[age_index %in% old_age_label,]
df = df[rep(seq_len(nrow(df)), each = length(new_age_label)),]
df[,age_index := rep(new_age_label, length(age_category))]
cnt.zhang = rbind(subset(cnt.zhang, !age_index %in% old_age_label), df)
# age contact
df2 = cnt.zhang[age_contact %in% old_age_label,]
df2 = df2[rep(seq_len(nrow(df2)), each = length(new_age_label)),]
df2[, age_contact := rep(new_age_label, length(new_age_category))]
df2[, count_post := count_post/length(new_age_label)] # take average
cnt.zhang = rbind(subset(cnt.zhang, !age_contact %in% old_age_label), df2)
setnames(cnt.zhang, c('age_index','age_contact','count_post'),c('part.age.cat.label','cont.age.cat.label','m_zhang'))
#
# prepare contact matrices during school opening forecast period for each state
cnt.zhang <- merge(dcontact, cnt.zhang, by=c('part.age.cat.label','cont.age.cat.label'))
cnt.zhang[, m_pc:= min_pc_contacts*m]
cnt.zhang[, m_zhang2:= pmin(m , multiplier_cntct_school_closure * pmax(m_pc, m_zhang))]
cnt.zhang[, m_model:= m]
# now use for both weekends and weekdays:
# baseline intensities for 15+ & 15+
# reduced baseline intensities for 0-9 -> any, any-> 0-9
# mixture baseline intensities for 10-14 -> any, any-> 10-14
tmp <- cnt.zhang[, which( part.age.cat<3 | cont.age.cat<3 )]
set(cnt.zhang, tmp, 'm_model', multiplier_cntct_school_opening * cnt.zhang[tmp,m])
set(cnt.zhang, tmp, 'm_model', pmax(cnt.zhang[tmp,m_zhang2], cnt.zhang[tmp,m_model]))
tmp <- cnt.zhang[, which( part.age.cat==3 | cont.age.cat==3 )]
set(cnt.zhang, tmp, 'm_model', 2/5*pmax(cnt.zhang[tmp,m_zhang2], multiplier_cntct_school_opening*cnt.zhang[tmp,m]) +
3/5*cnt.zhang[tmp,m_zhang2])
states = names(processed_data$dates)
cntct_elementary_school_reopening_weekdays = vector('list', length(states))
cntct_elementary_school_reopening_weekends = vector('list', length(states))
for(i in 1:length(states))
{
tmp <- dcast.data.table(subset(cnt.zhang, loc==states[i] & type=="weekday"), part.age.cat~cont.age.cat, value.var='m_model')
tmp <- unname(as.matrix(tmp)[,-1])
cntct_elementary_school_reopening_weekdays[[i]] <- tmp
tmp <- dcast.data.table(subset(cnt.zhang, loc==states[i] & type=="weekend"), part.age.cat~cont.age.cat, value.var='m_model')
tmp <- unname(as.matrix(tmp)[,-1])
cntct_elementary_school_reopening_weekends[[i]] <- tmp
}
processed_data$stan_data$cntct_elementary_school_reopening_weekdays = cntct_elementary_school_reopening_weekdays
processed_data$stan_data$cntct_elementary_school_reopening_weekends = cntct_elementary_school_reopening_weekends
#
# set 'elementary_school_reopening_idx'
reo.idx <- data.table(
last_obs_idx = sapply( processed_data$dates, length ),
last_obs_date = as.Date(sapply( processed_data$dates, function(x) tail(as.character(x),1) ))
)
reo.idx[, reo_idx:= last_obs_idx + as.integer(as.Date(reopening_date)-last_obs_date)]
stopifnot( all(reo.idx$reo_idx<=processed_data$stan_data$N2) )
processed_data$stan_data$elementary_school_reopening_idx <- reo.idx$reo_idx
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_contact_school_opening_EduWeek <- function(processed_data,
dcontact,
path_to_file_contact_intensities_outbreak_China,
multiplier_cntct_school_closure=1,
multiplier_cntct_school_opening=1,
min_pc_contacts=0.05)
{
contact_intensities_outbreak_zhang <- as.data.table(readRDS(path_to_file_contact_intensities_outbreak_China))
age_category = c("0-4", "5-9", "10-14", "15-19", "20-24", "25-29", "30-34", "35-39", "40-44", "45-49", "50-54", "55-59", "60-64", "65+")
children_label = c("0-4", "5-9", "10-14")
#
# age categories as factor
contact_intensities_outbreak_zhang[, age_index := factor(age_index, levels = age_category)]
contact_intensities_outbreak_zhang[, age_contact := factor(age_contact, levels = age_category)]
#
# aggregate over both cities
cnt.zhang = contact_intensities_outbreak_zhang[, list(count_post = mean(count_post)), by = c("age_index", "age_contact")]
#
# break 65+ age band into 65-69, 70-74, 75-79, 80-84, 85+
old_age_label = "65+"
new_age_label = c("65-69", "70-74", "75-79", "80-84", "85+")
new_age_category = c(age_category[-length(age_category)], new_age_label)
# age index
df = cnt.zhang[age_index %in% old_age_label,]
df = df[rep(seq_len(nrow(df)), each = length(new_age_label)),]
df[,age_index := rep(new_age_label, length(age_category))]
cnt.zhang = rbind(subset(cnt.zhang, !age_index %in% old_age_label), df)
# age contact
df2 = cnt.zhang[age_contact %in% old_age_label,]
df2 = df2[rep(seq_len(nrow(df2)), each = length(new_age_label)),]
df2[, age_contact := rep(new_age_label, length(new_age_category))]
df2[, count_post := count_post/length(new_age_label)] # take average
cnt.zhang = rbind(subset(cnt.zhang, !age_contact %in% old_age_label), df2)
setnames(cnt.zhang, c('age_index','age_contact','count_post'),c('part.age.cat.label','cont.age.cat.label','m_zhang'))
#
# prepare contact matrices during school opening forecast period for each state
cnt.zhang <- merge(dcontact, cnt.zhang, by=c('part.age.cat.label','cont.age.cat.label'))
cnt.zhang[, m_pc:= min_pc_contacts*m]
cnt.zhang[, m_zhang2:= pmin(m , multiplier_cntct_school_closure * pmax(m_pc, m_zhang))]
cnt.zhang[, m_model:= m]
# now use for both weekends and weekdays:
# baseline intensities for 15+ & 15+
# reduced baseline intensities for 0-9 -> any, any-> 0-9
# mixture baseline intensities for 10-14 -> any, any-> 10-14
tmp <- cnt.zhang[, which( part.age.cat<3 | cont.age.cat<3 )]
set(cnt.zhang, tmp, 'm_model', multiplier_cntct_school_opening * cnt.zhang[tmp,m])
set(cnt.zhang, tmp, 'm_model', pmax(cnt.zhang[tmp,m_zhang2], cnt.zhang[tmp,m_model]))
tmp <- cnt.zhang[, which( part.age.cat==3 | cont.age.cat==3 )]
set(cnt.zhang, tmp, 'm_model', 2/5*pmax(cnt.zhang[tmp,m_zhang2], multiplier_cntct_school_opening*cnt.zhang[tmp,m]) +
3/5*cnt.zhang[tmp,m_zhang2])
states = names(processed_data$dates)
cntct_elementary_school_reopening_weekdays = vector('list', length(states))
cntct_elementary_school_reopening_weekends = vector('list', length(states))
for(i in 1:length(states))
{
tmp <- dcast.data.table(subset(cnt.zhang, loc==states[i] & type=="weekday"), part.age.cat~cont.age.cat, value.var='m_model')
tmp <- unname(as.matrix(tmp)[,-1])
cntct_elementary_school_reopening_weekdays[[i]] <- tmp
tmp <- dcast.data.table(subset(cnt.zhang, loc==states[i] & type=="weekend"), part.age.cat~cont.age.cat, value.var='m_model')
tmp <- unname(as.matrix(tmp)[,-1])
cntct_elementary_school_reopening_weekends[[i]] <- tmp
}
processed_data$stan_data$cntct_elementary_school_reopening_weekdays = cntct_elementary_school_reopening_weekdays
processed_data$stan_data$cntct_elementary_school_reopening_weekends = cntct_elementary_school_reopening_weekends
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_add_contact_elementary_high_school_opening_EduWeek <- function(processed_data,
dcontact,
path_to_file_contact_intensities_outbreak_China,
multiplier_cntct_school_closure=1,
multiplier_cntct_school_opening=1,
min_pc_contacts=0.05)
{
contact_intensities_outbreak_zhang <- as.data.table(readRDS(path_to_file_contact_intensities_outbreak_China))
age_category = c("0-4", "5-9", "10-14", "15-19", "20-24", "25-29", "30-34", "35-39", "40-44", "45-49", "50-54", "55-59", "60-64", "65+")
#
# age categories as factor
contact_intensities_outbreak_zhang[, age_index := factor(age_index, levels = age_category)]
contact_intensities_outbreak_zhang[, age_contact := factor(age_contact, levels = age_category)]
#
# aggregate over both cities
cnt.zhang = contact_intensities_outbreak_zhang[, list(count_post = mean(count_post)), by = c("age_index", "age_contact")]
#
# break 65+ age band into 65-69, 70-74, 75-79, 80-84, 85+
old_age_label = "65+"
new_age_label = c("65-69", "70-74", "75-79", "80-84", "85+")
new_age_category = c(age_category[-length(age_category)], new_age_label)
# age index
df = cnt.zhang[age_index %in% old_age_label,]
df = df[rep(seq_len(nrow(df)), each = length(new_age_label)),]
df[,age_index := rep(new_age_label, length(age_category))]
cnt.zhang = rbind(subset(cnt.zhang, !age_index %in% old_age_label), df)
# age contact
df2 = cnt.zhang[age_contact %in% old_age_label,]
df2 = df2[rep(seq_len(nrow(df2)), each = length(new_age_label)),]
df2[, age_contact := rep(new_age_label, length(new_age_category))]
df2[, count_post := count_post/length(new_age_label)] # take average
cnt.zhang = rbind(subset(cnt.zhang, !age_contact %in% old_age_label), df2)
setnames(cnt.zhang, c('age_index','age_contact','count_post'),c('part.age.cat.label','cont.age.cat.label','m_zhang'))
#
# prepare contact matrices during school opening forecast period for each state
cnt.zhang <- merge(dcontact, cnt.zhang, by=c('part.age.cat.label','cont.age.cat.label'))
cnt.zhang[, m_pc:= min_pc_contacts*m]
cnt.zhang[, m_zhang2:= pmin(m , multiplier_cntct_school_closure * pmax(m_pc, m_zhang))]
cnt.zhang[, m_model:= m]
# now use for both weekends and weekdays:
# baseline intensities for 15+ & 15+
# reduced baseline intensities for 0-14 -> any, any-> 0-14
# mixture baseline intensities for 15-19 -> any, any-> 15-19
tmp <- cnt.zhang[, which( part.age.cat<4 | cont.age.cat<4 )]
set(cnt.zhang, tmp, 'm_model', multiplier_cntct_school_opening * cnt.zhang[tmp,m])
set(cnt.zhang, tmp, 'm_model', pmax(cnt.zhang[tmp,m_zhang2], cnt.zhang[tmp,m_model]))
tmp <- cnt.zhang[, which( part.age.cat==4 | cont.age.cat==4 )]
set(cnt.zhang, tmp, 'm_model', 4/5*pmax(cnt.zhang[tmp,m_zhang2], multiplier_cntct_school_opening*cnt.zhang[tmp,m]) +
1/5*cnt.zhang[tmp,m_zhang2])
states = names(processed_data$dates)
cntct_elementary_school_reopening_weekdays = vector('list', length(states))
cntct_elementary_school_reopening_weekends = vector('list', length(states))
for(i in 1:length(states))
{
tmp <- dcast.data.table(subset(cnt.zhang, loc==states[i] & type=="weekday"), part.age.cat~cont.age.cat, value.var='m_model')
tmp <- unname(as.matrix(tmp)[,-1])
cntct_elementary_school_reopening_weekdays[[i]] <- tmp
tmp <- dcast.data.table(subset(cnt.zhang, loc==states[i] & type=="weekend"), part.age.cat~cont.age.cat, value.var='m_model')
tmp <- unname(as.matrix(tmp)[,-1])
cntct_elementary_school_reopening_weekends[[i]] <- tmp
}
processed_data$stan_data$cntct_elementary_school_reopening_weekdays = cntct_elementary_school_reopening_weekdays
processed_data$stan_data$cntct_elementary_school_reopening_weekends = cntct_elementary_school_reopening_weekends
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
add_date_to_pop_info <- function(pop_info, stan_data, dates)
{
ans <- data.table( loc= names(dates), loc_idx= seq_along(dates), n_agegroups=unlist( stan_data$A_AD ) )
# set generic first and last dates for which overall deaths are available
ans[, date.overall.first:= unlist(lapply(sapply(dates, as.character), "[[", 1))]
set(ans, NULL, 'date.overall.first', ans[, as.Date(date.overall.first)+30])
ans[, date.overall.last:= as.Date(unlist(lapply(sapply(dates, as.character), tail, 1)))]
# get start date from which onwards age specific deaths are available
tmp <- ans[, list( date.deathbyage.first= dates[[loc_idx]][ stan_data$dataByAgestart[loc_idx] ] ), by= 'loc_idx']
ans <- merge(ans, tmp, by='loc_idx')
# update last date for which overall deaths are used
tmp <- ans[, which(!is.na(date.deathbyage.first))]
set(ans, tmp, 'date.overall.last', ans[tmp, date.deathbyage.first-1] )
# last date for which age specific deaths are available is always the last date
ans[, date.deathbyage.last:= as.Date(unlist(lapply(sapply(dates, as.character), tail, 1)))]
# make ranges
ans[, date.overall:= paste0(format(date.overall.first,"%b %d"), ' - ', format(date.overall.last,"%b %d"))]
ans[, date.deathbyage:= paste0(format(date.deathbyage.first,"%b %d"), ' - ', format(date.deathbyage.last,"%b %d"))]
set(ans, ans[, which(is.na(date.deathbyage.first))], 'date.deathbyage', '-' )
ans <- subset(ans, select=c(loc, date.overall, date.deathbyage, n_agegroups))
ans <- merge(pop_info, ans, by=c('loc'), all.x=TRUE)
ans
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
stan_data_fix_beta1 <- function(processed_data, pop_info, mobility_data)
{
# dip date
dip_date <- unique(subset(mobility_data,select = c('loc','dip_date')))
beta1 <- vector(length = dim(processed_data$stan_data$covariates)[1])
# loop over states
for (m in 1:dim(processed_data$stan_data$covariates)[1])
{
# baseline mobility before dip dates
dip_date_local <- dip_date[loc==names(processed_data$dates)[m],dip_date]
if(dip_date_local<processed_data$dates[[m]][1])
{
beta1[m] <- 1
}
if(dip_date_local>=processed_data$dates[[m]][1])
{
dip_date_local_id <- which(processed_data$dates[[m]]==dip_date_local)
covariates_baseline_local <- processed_data$stan_data$covariates[m,1,1:dip_date_local_id,]
# population weight
prop_pop_local <- pop_info[loc==names(processed_data$dates)[m],]$prop_pop
# solve eta=1
f <- function(beta1)
{
mean(
apply(exp(beta1 * covariates_baseline_local) *
matrix(rep(prop_pop_local,each=nrow(covariates_baseline_local)),nrow=nrow(covariates_baseline_local)),
1,
sum)
) - 1
}
beta1[m] <- uniroot(f,c(-1,1))$root
}
}
processed_data$stan_data$beta1 <- beta1
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
make_emodo_age_cat_map_with_cont <- function(mobility_data, pop_info)
{
dages <- unique(subset(pop_info, select=c(age.cat.label, age.cat, age.cat.from, age.cat.to)))
tmp <- unique(rbind(subset(mobility_data, select=c(idx.age.cat, idx.age.label)),
subset(mobility_data, select=c(cont.age.cat, cont.age.label)),
use.names=FALSE))
tmp[, idx.age.cat.label2:= as.character(idx.age.label)]
tmp[, idx.age.lower:= as.integer(gsub('\\+','',gsub('^([0-9\\+]+)-([0-9]+)$','\\1',idx.age.cat.label2)))]
tmp[, idx.age.upper:= as.integer(gsub('[0-9]+\\+','99',gsub('^([0-9\\+]+)-([0-9\\+]+)$','\\2',idx.age.cat.label2)))]
dages <- dages[, {
z <- which( age.cat.to >= tmp$idx.age.lower & age.cat.to <= tmp$idx.age.upper )
list(idx.age.cat= ifelse(length(z)>0, tmp$idx.age.cat[z], NA_integer_))
}, by=c('age.cat','age.cat.label')]
tmp <- unique(subset(tmp, select=c(idx.age.cat, idx.age.label)))
dages <- merge(dages, tmp, by= c('idx.age.cat'), all.x=TRUE)
dages
}
#' @export
#' @keywords internal
#' @import data.table tidyr stringr
make_mobility_trends_emo_with_cont <- function(mobility_data, emo_age_cat_map)
{
# calculate baseline over 2 weeks
min.date <- min(mobility_data$date)
tmp <- subset(mobility_data, date<min.date+14)
tmp <- tmp[, list(base_avg_contacts= mean(avg_contacts)), by=c('loc','idx.age.cat','cont.age.cat')]
mobility_data <- merge(mobility_data, tmp, by=c('loc','idx.age.cat','cont.age.cat'))
# calculate mobility trends
mobility_data[, mobility_trend:= avg_contacts / base_avg_contacts]
# expand to age strata used in model
tmp <- subset(emo_age_cat_map, select=c(idx.age.cat, age.cat, age.cat.label))
set(tmp, tmp[, which(age.cat<=3)], 'idx.age.cat', 1L)
mobility_data <- merge(mobility_data, tmp, by='idx.age.cat', allow.cartesian=TRUE)
setnames(mobility_data,c('age.cat', 'age.cat.label'),c('idx.age.cat2', 'idx.age.cat.label2'))
setnames(tmp,'idx.age.cat','cont.age.cat')
mobility_data <- merge(mobility_data, tmp, by='cont.age.cat', allow.cartesian=TRUE)
setnames(mobility_data,c('age.cat', 'age.cat.label'),c('cont.age.cat2', 'cont.age.cat.label2'))
mobility_data
}
#' @export
#' @keywords internal
#' @import data.table tidyr
gqs_add_stan_data_for_flows <- function(stan_data,dates)
{
# full flows of the 18 age buckets in the model are aggregated into 7 age buckets as follows
reduced_age_bands_map <- c(1,1,2,2,3,3,3,4,4,4,5,5,5,6,6,6,7,7)
A_REDUCED <- max(reduced_age_bands_map)
# reduced flows: calculate starting from each Monday from N0 until last full week
reduced_flows_Monday_idx <- list()
for (m in 1:ncol(stan_data$wkend_idx)) {
tmp <- stan_data$wkend_idx[,m]
tmp <- tmp[which(diff(tmp,1)==1)[1]]+2
while(tmp>7L){
tmp <- tmp - 7L
}
reduced_flows_Monday_idx[[m]] <- seq(from=tmp, to=stan_data$N2, by=7)
}
# Mondays need to be after N0 and up to full last week
reduced_flows_Monday_idx <- lapply(reduced_flows_Monday_idx, function(x){x[x>stan_data$N0 & x<= stan_data$N2 - 7L + 1]})
# find dimensions
N_WEEKS_REDUCED_FLOWS <- sapply(reduced_flows_Monday_idx,length)
NMAX_WEEKS_REDUCED_FLOWS <- max(N_WEEKS_REDUCED_FLOWS)
# make into matrix
for(m in 1:ncol(stan_data$wkend_idx)){
if(length(reduced_flows_Monday_idx[[m]]) != max(lengths(reduced_flows_Monday_idx))){
reduced_flows_Monday_idx[[m]] <- c(reduced_flows_Monday_idx[[m]],rep(-1,max(lengths(reduced_flows_Monday_idx))-length(reduced_flows_Monday_idx[[m]])))
}
}
reduced_flows_Monday_idx <- matrix( unlist(reduced_flows_Monday_idx), nrow=NMAX_WEEKS_REDUCED_FLOWS )
# make into data.table to find full flow days, and for printing
dix <- as.data.table(reshape2::melt(reduced_flows_Monday_idx))
setnames(dix, 1:3, c('time_idx','state','time'))
dix <- dix[time>0, list(time=time,
date=dates[[state]][time]), by='state']
cat('\nFor reduced flow analysis selected dates are ')
print(dix)
# select Mondays for full flows.
# this is supposed to be for the same Mondays across states (early and late)
# find Mondays
# deselect forecast period
dix <- subset(dix, !is.na(date))
# select first common Monday and last common Monday
tmp <- dix[, list( date_min=min(date),
date_max=max(date)
), by='state']
first.common.Monday <- max(tmp$date_min)
last.common.Monday <- min(tmp$date_max)
cat("\nFor full flow analysis selected dates are", as.character(first.common.Monday), ' ', as.character(last.common.Monday))
dix <- subset(dix, date==first.common.Monday | date==last.common.Monday)
# convert to matrix
dix <- dcast.data.table(dix, date~state, value.var='time')
full_flows_Monday_idx <- unname(as.matrix(subset(dix, select=-date)))
# find dimensions
NMAX_WEEKS_FULL_FLOWS <- nrow(full_flows_Monday_idx)
N_WEEKS_FULL_FLOWS <- apply(full_flows_Monday_idx,2,function(x){sum(x!=-1)})
# build additional stan data
stan_data$NMAX_WEEKS_FULL_FLOWS <- NMAX_WEEKS_FULL_FLOWS
stan_data$N_WEEKS_FULL_FLOWS <- N_WEEKS_FULL_FLOWS
stan_data$full_flows_Monday_idx <- full_flows_Monday_idx
stan_data$A_REDUCED <- A_REDUCED
stan_data$NMAX_WEEKS_REDUCED_FLOWS <- NMAX_WEEKS_REDUCED_FLOWS
stan_data$N_WEEKS_REDUCED_FLOWS <- N_WEEKS_REDUCED_FLOWS
stan_data$reduced_age_bands_map <- reduced_age_bands_map
stan_data$reduced_flows_Monday_idx <- reduced_flows_Monday_idx
stan_data$n_days <- 1L
cat("\nFlows aggregated across consecutive days, n_days=", stan_data$n_days)
return(stan_data)
}
#' @export
#' @keywords internal
gqs_add_stan_data_for_iar <- function(stan_data){
num_days_sim <- stan_data$N2
set.seed(5678) # make reproducible
mean1 <- 5.1; cv1 <- 0.86; # infection to onset
mean2 <- 14; cv2 <- 3.57 # onset to antibody
x1 <- rgammaAlt(1e6,mean1,cv1) # infection-to-onset distribution
x2 <- rnorm(1e6,mean2,cv2) # onset-to-antibody distribution
ecdf_death <- ecdf(x1+x2)
# disrectise to days since infection
iar_by_dsi <- vector('numeric',num_days_sim)
iar_by_dsi[1] <- ecdf_death(1.5) - ecdf_death(0)
for(s in 2:num_days_sim)
{
iar_by_dsi[s] <- ecdf_death(s+.5) - ecdf_death(s-.5)
}
stan_data$rev_iar_daysSinceInfection = rev( iar_by_dsi )
return(stan_data)
}
#' @export
#' @keywords internal
gqs_add_stan_data_for_new_strain = function(stan_data,
dates,
rel_transmissibility_new_strain = 1.7,
prop_cases_new_strain_first_day = 0.01,
first_date_new_strain = as.Date('2020-12-15')){
# time index of the introduction of the new strain
timeidx_introduction_new_strain = vector(mode = 'integer', length = length(dates))
for(m in seq_along(names(dates))){
# m = 1
dates_m = data.table(date = seq.Date(min(dates[[m]]), min(dates[[m]]) + stan_data$N2 - 1, by = 'day'),
time_idx = 1:stan_data$N2)
timeidx_introduction_new_strain[m] = subset(dates_m, date == first_date_new_strain)$time_idx[1]
}
stan_data$INTRO_NEW_STRAIN_TIME_IDX = timeidx_introduction_new_strain
# total number of SARS-CoV-2 strains
stan_data$N_STRAINS = 2
# transmissibility multiplier new SARS-CoV-2 strains
stan_data$rel_transmissibility_new_strain = rel_transmissibility_new_strain
# proportion of new strain among cases on introduction day
stan_data$prop_cases_new_strain_first_day = prop_cases_new_strain_first_day
return(stan_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr
gqs_add_stan_data_for_shield <- function(stan_data, return_age_band,shielded_age_band,shielded_contacts,shielded_date, dates)
{
# find indices for age bands
return_age_band = as.numeric(strsplit(return_age_band, '-')[[1]])
shielded_age_band = as.numeric(strsplit(shielded_age_band, '-')[[1]])
age_breaks = c(seq(0,85,5),100)
return_age_band_index = max(which(age_breaks[1:(length(age_breaks)-1)] <= return_age_band[1])): min(which(age_breaks[2:(length(age_breaks))] >= return_age_band[2]))
shielded_age_band_index = max(which(age_breaks[1:(length(age_breaks)-1)] <= shielded_age_band[1])): min(which(age_breaks[2:(length(age_breaks))] >= shielded_age_band[2]))
# indices for adult age groups which have no_impact_intv or impact_intv
stan_data$no_impact_intv_idx <- c(return_age_band_index, shielded_age_band_index)
stan_data$N_no_impact_intv_idx <-length(stan_data$no_impact_intv_idx)
stan_data$impact_intv_idx <- setdiff(1:(length(age_breaks)-1), stan_data$no_impact_intv_idx)
stan_data$impact_intv_idx <- setdiff(stan_data$impact_intv_idx, (1:stan_data$A_CHILD))
stan_data$N_impact_intv_idx <-length(stan_data$impact_intv_idx)
# set shielded age band contacts to shielded_contacts
stan_data$cntct_weekdays_mean_shielded_age_band <- copy(stan_data$cntct_weekdays_mean)
stan_data$cntct_weekdays_mean_shielded_age_band <- lapply(stan_data$cntct_weekdays_mean_shielded_age_band, function(x){
x[shielded_age_band_index, ] = min(shielded_contacts, x[shielded_age_band_index, ])
x[,shielded_age_band_index] = min(shielded_contacts, x[shielded_age_band_index, ])
return(x)
})
stan_data$cntct_weekends_mean_shielded_age_band <- copy(stan_data$cntct_weekends_mean)
stan_data$cntct_weekends_mean_shielded_age_band <- lapply(stan_data$cntct_weekends_mean_shielded_age_band, function(x){
x[shielded_age_band_index, ] = min(shielded_contacts, x[shielded_age_band_index, ])
x[,shielded_age_band_index] = min(shielded_contacts, x[shielded_age_band_index, ])
return(x)
})
stan_data$cntct_school_closure_weekdays_shielded_age_band <- copy(stan_data$cntct_school_closure_weekdays)
stan_data$cntct_school_closure_weekdays_shielded_age_band <- lapply(stan_data$cntct_school_closure_weekdays_shielded_age_band, function(x){
x[shielded_age_band_index, ] = min(shielded_contacts, x[shielded_age_band_index, ])
x[,shielded_age_band_index] = min(shielded_contacts, x[shielded_age_band_index, ])
return(x)
})
stan_data$cntct_school_closure_weekends_shielded_age_band <- copy(stan_data$cntct_school_closure_weekends)
stan_data$cntct_school_closure_weekends_shielded_age_band <- lapply(stan_data$cntct_school_closure_weekends_shielded_age_band, function(x){
x[shielded_age_band_index, ] = min(shielded_contacts, x[shielded_age_band_index, ])
x[,shielded_age_band_index] = min(shielded_contacts, x[shielded_age_band_index, ])
return(x)
})
stan_data$cntct_elementary_school_reopening_weekdays_shielded_age_band <- copy(stan_data$cntct_elementary_school_reopening_weekdays)
stan_data$cntct_elementary_school_reopening_weekdays_shielded_age_band <- lapply(stan_data$cntct_elementary_school_reopening_weekdays_shielded_age_band, function(x){
x[shielded_age_band_index, ] = min(shielded_contacts, x[shielded_age_band_index, ])
x[,shielded_age_band_index] = min(shielded_contacts, x[shielded_age_band_index, ])
return(x)
})
stan_data$cntct_elementary_school_reopening_weekends_shielded_age_band <- copy(stan_data$cntct_elementary_school_reopening_weekends)
stan_data$cntct_elementary_school_reopening_weekends_shielded_age_band <- lapply(stan_data$cntct_elementary_school_reopening_weekends_shielded_age_band, function(x){
x[shielded_age_band_index, ] = min(shielded_contacts, x[shielded_age_band_index, ])
x[,shielded_age_band_index] = min(shielded_contacts, x[shielded_age_band_index, ])
return(x)
})
# date of shielding (start of forecast)
stan_data$age_band_shielded_idx <- as.vector(sapply(dates,function(x)which(x==shielded_date)))
return(stan_data)
}
#' @export
#' @keywords internal
#' @import data.table
find_reopening_dates = function(ods, default_school_reopening_date){
# states that have re-opened their schools before end of Edu data
tmp = ods[!School_Status %in% c("State ordered closure in effect (including states where openings are delayed)", "Full closure", 'Full closure in effect'), ]
tmp[, schools_reopened_before_forecast := 1]
tmp[, reopening_date_Edu_Week := min(date_EduWeek_data), by = "loc"]
# if schools were opened at the beginning of the data set, school reopening date is fixed to the default
tmp[reopening_date_Edu_Week == min(ods$date_EduWeek_data), reopening_date_Edu_Week := default_school_reopening_date]
# states that have not re-opened their schools before end of Edu data
tmp1 = ods[!loc %in% tmp$loc]
tmp1[,schools_reopened_before_forecast := 0]
tmp1[, reopening_date_Edu_Week := default_school_reopening_date] # need to have a date format, will be overwitten
tmp = rbind(tmp, tmp1)
tmp = select(tmp, - c("School_Status", "date_EduWeek_data"))
tmp = unique(tmp)
return(tmp)
}
#' @export
#' @keywords internal
#' @import data.table
find_closure_2_dates = function(ods, default_school_closure_2_date, df_reopening_dates){
# states that have re-opened their schools before end of Edu data
tmp = ods[School_Status %in% c("State ordered closure in effect (including states where openings are delayed)", "Full closure", "Full closure in effect"), ]
tmp = tmp[date_EduWeek_data > max(df_reopening_dates$reopening_date_Edu_Week)] # keep only date after school reopening
tmp = tmp[!loc_label %in% df_reopening_dates[schools_reopened_before_forecast == F]$loc_label] # keep only state that reopened
tmp[, schools_close_2_before_forecast := 1]
tmp[, closure_2_date_Edu_Week := min(date_EduWeek_data), by = "loc"]
# states that have not re-opened their schools before end of Edu data
tmp1 = ods[!loc %in% tmp$loc]
tmp1[, schools_close_2_before_forecast := 0]
tmp1[, closure_2_date_Edu_Week := default_school_closure_2_date] # need to have a date format, will be overwitten
tmp = rbind(tmp, tmp1)
tmp = select(tmp, - c("School_Status", "date_EduWeek_data"))
tmp = unique(tmp)
return(tmp)
}
#' @export
#' @keywords internal
#' @import data.table tidyr
aggregate_ifr_data_by_age = function(ifr.by.age, path_to_file_pop_us = GFNAME_us_population, max_age){
ifr.by.age <- ifr.by.age %>%
dplyr::select(age, ifr_mean, ifr_cl, ifr_cu)
# aggregate data on contacts by 1-year bands to data by desired age bands
pop_by_age <- readRDS(path_to_file_pop_us)
age_bands <- dplyr::select(pop_by_age[which(!is.na(pop_by_age$code)),], -Total) %>%
reshape2::melt(id.vars = c("Region", "code")) %>%
dplyr::rename(age = variable, pop = value, state = Region) %>% dplyr::select(age) %>% dplyr::distinct()
age.cat <- sapply(strsplit(gsub("\\[|\\]|\\(|\\+", "", age_bands$age), "-"), as.numeric)
if (is.na(age.cat[[length(age.cat)]][2])) age.cat[[length(age.cat)]][2] <- 99
age.cat <- matrix(unlist(age.cat), ncol = 2, byrow = TRUE)
ifr.by.age <- ifr.by.age[1:which(ifr.by.age$age == max_age),] %>% # 0 to max_age
dplyr::mutate(age.agg:= cut(age, breaks=c(age.cat[,1],100), right=FALSE, labels=seq_len(length(c(age.cat[,1],100))-1L))) %>%
dplyr::group_by(age.agg) %>%
dplyr::summarise(ifr_mean:= mean(ifr_mean),
ifr_cl:= mean(ifr_cl),
ifr_cu:= mean(ifr_cu)) %>%
dplyr::ungroup() %>%
dplyr::rename(age= age.agg)
return(ifr.by.age)
}
#' @export
#' @keywords internal
#' @import data.table tidyr
stan_data_add_ifr_fixed_decay_rate = function(processed_data, ifr_decay_total, ifr_decay_month_start){
states <- names(processed_data$dates)
dates = processed_data$dates
timeidx_start_ifr_decay = vector(mode = 'integer', length = length(dates))
# find time index start
for(m in seq_along(names(dates))){
# m = 1
dates_m = data.table(date = dates[[m]], time_idx = 1:length(dates[[m]]))
dates_m[, month := format(date, '%m')]
timeidx_start_ifr_decay[m] = subset(dates_m, month == ifr_decay_month_start)$time_idx[1]
}
processed_data$stan_data$timeidx_start_ifr_decay = timeidx_start_ifr_decay
# fix ifr total decay
processed_data$stan_data$log_ifr_overall_upswing_effect = log(1 - ifr_decay_total)
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table tidyr
stan_data_add_ifr_var_decay_rate = function(processed_data, ifr_decay_total, ifr_decay_month_start){
states <- names(processed_data$dates)
dates = processed_data$dates
timeidx_start_ifr_decay = vector(mode = 'integer', length = length(dates))
# find time index start
for(m in seq_along(names(dates))){
# m = 1
dates_m = data.table(date = dates[[m]], time_idx = 1:length(dates[[m]]))
dates_m[, month := format(date, '%m')]
timeidx_start_ifr_decay[m] = subset(dates_m, month == ifr_decay_month_start)$time_idx[1]
}
processed_data$stan_data$timeidx_start_ifr_decay = timeidx_start_ifr_decay
# fix ifr total decay
processed_data$stan_data$lambda_log_ifr_overall_upswing_effect = -100*log(1 - ifr_decay_total)
return(processed_data)
}
#' @export
#' @keywords internal
#' @import data.table
stan_data_add_rebound_mobility_zero = function(processed_data, default_rebound_mobility_zero_date){
dates = processed_data$dates
# find time index start
for(m in seq_along(names(dates))){
# m = 1
dates_m = data.table(date = seq.Date(min(dates[[m]]), min(dates[[m]]) + processed_data$stan_data$N2 - 1, by = 'day'), time_idx = 1:processed_data$stan_data$N2)
dates_idx_rebound_zero = dates_m[date == default_rebound_mobility_zero_date]$time_idx
processed_data$stan_data$covariates[m,3,dates_idx_rebound_zero:processed_data$stan_data$N2,] = 0
}
return(processed_data)
}
|
# -*- coding: utf-8 -*-
"""Data_preprocess.ipynb
Automatically generated by Colaboratory.
# DATA
"""
import numpy as np
import glob
import random
import struct
import csv
from tensorflow.core.example import example_pb2
import tensorflow as tf
from threading import Thread
from queue import Queue
import time
import threading
"""## Vocabulary"""
SENTENCE_START = '<s>'
SENTENCE_END = '</s>'
PAD_TOKEN = '[PAD]'
UNKNOWN_TOKEN = '[UNK]'
START_DECODING = '[START]'
STOP_DECODING = '[STOP]'
class Vocab:
def __init__(self, vocab_file, max_size):
self.word2id = {UNKNOWN_TOKEN : 0, PAD_TOKEN : 1, START_DECODING : 2, STOP_DECODING : 3}
self.id2word = {0 : UNKNOWN_TOKEN, 1 : PAD_TOKEN, 2 : START_DECODING, 3 : STOP_DECODING}
self.count = 4
with open(vocab_file, 'r') as f:
for line in f:
pieces = line.split()
if len(pieces) != 2 :
print('Warning : incorrectly formatted line in vocabulary file : %s\n' % line)
continue
w = pieces[0]
if w in [SENTENCE_START, SENTENCE_END, UNKNOWN_TOKEN, PAD_TOKEN, START_DECODING, STOP_DECODING]:
raise Exception('<s>, </s>, [UNK], [PAD], [START] and [STOP] shouldn\'t be in the vocab file, but %s is' % w)
if w in self.word2id:
raise Exception('Duplicated word in vocabulary file: %s' % w)
self.word2id[w] = self.count
self.id2word[self.count] = w
self.count += 1
if max_size != 0 and self.count >= max_size:
print("max_size of vocab was specified as %i; we now have %i words. Stopping reading." % (max_size, self.count))
break
print("Finished constructing vocabulary of %i total words. Last word added: %s" % (self.count, self.id2word[self.count-1]))
def word_to_id(self, word):
if word not in self.word2id:
return self.word2id[UNKNOWN_TOKEN]
return self.word2id[word]
def id_to_word(self, word_id):
if word_id not in self.id2word:
raise ValueError('Id not found in vocab: %d' % word_id)
return self.id2word[word_id]
def size(self):
return self.count
"""## Data helpers"""
def article_to_ids(article_words, vocab):
ids = []
oovs = []
unk_id = vocab.word_to_id(UNKNOWN_TOKEN)
for w in article_words:
i = vocab.word_to_id(w)
if i == unk_id: # If w is OOV
if w not in oovs: # Add to list of OOVs
oovs.append(w)
oov_num = oovs.index(w) # This is 0 for the first article OOV, 1 for the second article OOV...
ids.append(vocab.size() + oov_num) # This is e.g. 50000 for the first article OOV, 50001 for the second...
else:
ids.append(i)
return ids, oovs
def abstract_to_ids(abstract_words, vocab, article_oovs):
ids = []
unk_id = vocab.word_to_id(UNKNOWN_TOKEN)
for w in abstract_words:
i = vocab.word_to_id(w)
if i == unk_id: # If w is an OOV word
if w in article_oovs: # If w is an in-article OOV
vocab_idx = vocab.size() + article_oovs.index(w) # Map to its temporary article OOV number
ids.append(vocab_idx)
else: # If w is an out-of-article OOV
ids.append(unk_id) # Map to the UNK token id
else:
ids.append(i)
return ids
def output_to_words(id_list, vocab, article_oovs):
words = []
for i in id_list:
try:
w = vocab.id_to_word(i) # might be [UNK]
except ValueError as e: # w is OOV
assert article_oovs is not None, "Error: model produced a word ID that isn't in the vocabulary. This should not happen in baseline (no pointer-generator) mode"
article_oov_idx = i - vocab.size()
try:
w = article_oovs[article_oov_idx]
except ValueError as e: # i doesn't correspond to an article oov
raise ValueError('Error: model produced word ID %i which corresponds to article OOV %i but this example only has %i article OOVs' % (i, article_oov_idx, len(article_oovs)))
words.append(w)
return words
def abstract_to_sents(abstract):
"""Splits abstract text from datafile into list of sentences.
Args:
abstract: string containing <s> and </s> tags for starts and ends of sentences
Returns:
sents: List of sentence strings (no tags)"""
cur = 0
sents = []
while True:
try:
start_p = abstract.index(SENTENCE_START, cur)
end_p = abstract.index(SENTENCE_END, start_p + 1)
cur = end_p + len(SENTENCE_END)
sents.append(abstract[start_p+len(SENTENCE_START):end_p])
except ValueError as e: # no more sentences
return sents
def example_generator(data_path, hpm):
while True:
filelist = glob.glob(data_path) # get the list of datafiles
assert filelist, ('Error: Empty filelist at %s' % data_path) # check filelist isn't empty
if hpm['singlepass']:
filelist = sorted(filelist)
else:
random.shuffle(filelist)
for f in filelist:
reader = open(f, 'rb')
while True:
len_bytes = reader.read(8)
if not len_bytes: break # finished reading this file
str_len = struct.unpack('q', len_bytes)[0]
example_str = struct.unpack('%ds' % str_len, reader.read(str_len))[0]
yield example_pb2.Example.FromString(example_str)
if hpm['singlepass'] or hpm['finished']:
print("example_generator completed reading all datafiles. No more data.")
break
"""# Batcher"""
class Example(object):
"""Class representing a train/val/test example for text summarization."""
def __init__(self, article, abstract_sentences, vocab, hpm):
"""Initializes the Example, performing tokenization and truncation to produce the encoder, decoder and target sequences, which are stored in self.
Args:
article: source text; a string. each token is separated by a single space.
abstract_sentences: list of strings, one per abstract sentence. In each sentence, each token is separated by a single space.
vocab: Vocabulary object
hps: hyperparameters
"""
self.hpm = hpm
# Get ids of special tokens
start_decoding = vocab.word_to_id(START_DECODING)
stop_decoding = vocab.word_to_id(STOP_DECODING)
# Process the article
article_words = article.split()
if len(article_words) > hpm['max_enc_len']:
article_words = article_words[:hpm['max_enc_len']]
self.enc_len = len(article_words) # store the length after truncation but before padding
self.enc_input = [vocab.word_to_id(w) for w in article_words] # list of word ids; OOVs are represented by the id for UNK token
# Process the abstract
abstract = ' '.join(abstract_sentences) # string
abstract_words = abstract.split() # list of strings
abs_ids = [vocab.word_to_id(w) for w in abstract_words] # list of word ids; OOVs are represented by the id for UNK token
# Get the decoder input sequence and target sequence
self.dec_input, self.target = self.get_dec_inp_targ_seqs(abs_ids, hpm['max_dec_len'], start_decoding, stop_decoding)
self.dec_len = len(self.dec_input)
# If using pointer-generator mode, we need to store some extra info
if hpm['pointer_gen']:
# Store a version of the enc_input where in-article OOVs are represented by their temporary OOV id; also store the in-article OOVs words themselves
self.enc_input_extend_vocab, self.article_oovs = article_to_ids(article_words, vocab)
# Get a verison of the reference summary where in-article OOVs are represented by their temporary article OOV id
abs_ids_extend_vocab = abstract_to_ids(abstract_words, vocab, self.article_oovs)
# Overwrite decoder target sequence so it uses the temp article OOV ids
_, self.target = self.get_dec_inp_targ_seqs(abs_ids_extend_vocab, hpm['max_dec_len'], start_decoding, stop_decoding)
# Store the original strings
self.original_article = article
self.original_abstract = abstract
self.original_abstract_sents = abstract_sentences
def get_dec_inp_targ_seqs(self, sequence, max_len, start_id, stop_id):
"""Given the reference summary as a sequence of tokens, return the input sequence for the decoder, and the target sequence which we will use to calculate loss. The sequence will be truncated if it is longer than max_len. The input sequence must start with the start_id and the target sequence must end with the stop_id (but not if it's been truncated).
Args:
sequence: List of ids (integers)
max_len: integer
start_id: integer
stop_id: integer
Returns:
inp: sequence length <=max_len starting with start_id
target: sequence same length as input, ending with stop_id only if there was no truncation
"""
inp = [start_id] + sequence[:]
target = sequence[:]
if len(inp) > max_len: # truncate
inp = inp[:max_len]
target = target[:max_len] # no end_token
else: # no truncation
target.append(stop_id) # end token
assert len(inp) == len(target)
return inp, target
def pad_decoder_inp_targ(self, max_len, pad_id):
"""Pad decoder input and target sequences with pad_id up to max_len."""
while len(self.dec_input) < max_len:
self.dec_input.append(pad_id)
while len(self.target) < max_len:
self.target.append(pad_id)
def pad_encoder_input(self, max_len, pad_id):
"""Pad the encoder input sequence with pad_id up to max_len."""
while len(self.enc_input) < max_len:
self.enc_input.append(pad_id)
if self.hpm['pointer_gen']:
while len(self.enc_input_extend_vocab) < max_len:
self.enc_input_extend_vocab.append(pad_id)
class Batch(object):
"""Class representing a minibatch of train/val/test examples for text summarization."""
def __init__(self, example_list, hpm, vocab):
"""Turns the example_list into a Batch object.
Args:
example_list: List of Example objects
hpm: hyperparameters
vocab: Vocabulary object
"""
self.pad_id = vocab.word_to_id(PAD_TOKEN) # id of the PAD token used to pad sequences
self.init_encoder_seq(example_list, hpm) # initialize the input to the encoder
self.init_decoder_seq(example_list, hpm) # initialize the input and targets for the decoder
self.store_orig_strings(example_list) # store the original strings
def init_encoder_seq(self, example_list, hpm):
"""Initializes the following:
self.enc_batch:
numpy array of shape (batch_size, <=max_enc_steps) containing integer ids (all OOVs represented by UNK id), padded to length of longest sequence in the batch
self.enc_lens:
numpy array of shape (batch_size) containing integers. The (truncated) length of each encoder input sequence (pre-padding).
self.enc_padding_mask:
numpy array of shape (batch_size, <=max_enc_steps), containing 1s and 0s. 1s correspond to real tokens in enc_batch and target_batch; 0s correspond to padding.
If hps.pointer_gen, additionally initializes the following:
self.max_art_oovs:
maximum number of in-article OOVs in the batch
self.art_oovs:
list of list of in-article OOVs (strings), for each example in the batch
self.enc_batch_extend_vocab:
Same as self.enc_batch, but in-article OOVs are represented by their temporary article OOV number.
"""
# Determine the maximum length of the encoder input sequence in this batch
max_enc_seq_len = max([ex.enc_len for ex in example_list])
# Pad the encoder input sequences up to the length of the longest sequence
for ex in example_list:
ex.pad_encoder_input(max_enc_seq_len, self.pad_id)
# Initialize the numpy arrays
# Note: our enc_batch can have different length (second dimension) for each batch because we use dynamic_rnn for the encoder.
self.enc_batch = np.zeros((hpm['batch_size'], max_enc_seq_len), dtype=np.int32)
self.enc_lens = np.zeros((hpm['batch_size']), dtype=np.int32)
self.enc_padding_mask = np.zeros((hpm['batch_size'], max_enc_seq_len), dtype=np.float32)
# Fill in the numpy arrays
for i, ex in enumerate(example_list):
self.enc_batch[i, :] = ex.enc_input[:]
self.enc_lens[i] = ex.enc_len
for j in range(ex.enc_len):
self.enc_padding_mask[i][j] = 1
# For pointer-generator mode, need to store some extra info
if hpm['pointer_gen']:
# Determine the max number of in-article OOVs in this batch
self.max_art_oovs = max([len(ex.article_oovs) for ex in example_list])
# Store the in-article OOVs themselves
self.art_oovs = [ex.article_oovs for ex in example_list]
# Store the version of the enc_batch that uses the article OOV ids
self.enc_batch_extend_vocab = np.zeros((hpm['batch_size'], max_enc_seq_len), dtype=np.int32)
for i, ex in enumerate(example_list):
self.enc_batch_extend_vocab[i, :] = ex.enc_input_extend_vocab[:]
def init_decoder_seq(self, example_list, hpm):
"""Initializes the following:
self.dec_batch:
numpy array of shape (batch_size, max_dec_steps), containing integer ids as input for the decoder, padded to max_dec_steps length.
self.target_batch:
numpy array of shape (batch_size, max_dec_steps), containing integer ids for the target sequence, padded to max_dec_steps length.
self.dec_padding_mask:
numpy array of shape (batch_size, max_dec_steps), containing 1s and 0s. 1s correspond to real tokens in dec_batch and target_batch; 0s correspond to padding.
"""
# Pad the inputs and targets
for ex in example_list:
ex.pad_decoder_inp_targ(hpm['max_dec_len'], self.pad_id)
# Initialize the numpy arrays.
# Note: our decoder inputs and targets must be the same length for each batch (second dimension = max_dec_steps) because we do not use a dynamic_rnn for decoding. However I believe this is possible, or will soon be possible, with Tensorflow 1.0, in which case it may be best to upgrade to that.
self.dec_batch = np.zeros((hpm['batch_size'], hpm['max_dec_len']), dtype=np.int32)
self.target_batch = np.zeros((hpm['batch_size'], hpm['max_dec_len']), dtype=np.int32)
self.dec_padding_mask = np.zeros((hpm['batch_size'], hpm['max_dec_len']), dtype=np.float32)
# Fill in the numpy arrays
for i, ex in enumerate(example_list):
self.dec_batch[i, :] = ex.dec_input[:]
self.target_batch[i, :] = ex.target[:]
for j in range(ex.dec_len):
self.dec_padding_mask[i][j] = 1
def store_orig_strings(self, example_list):
"""Store the original article and abstract strings in the Batch object"""
self.original_articles = [ex.original_article for ex in example_list] # list of lists
self.original_abstracts = [ex.original_abstract for ex in example_list] # list of lists
self.original_abstracts_sents = [ex.original_abstract_sents for ex in example_list] # list of list of lists
class Batcher():
def __init__(self,data_path, hpm, vocab):
self.hpm = hpm
self.vocab = vocab
self.max_examples_buffer_len = hpm['examples_max_buffer_len']
self.max_batch_buffer_len = hpm['batch_max_buffer_len']
self.max_batch_bucket_len = hpm['max_batch_bucket_len']
self.gen = self.thread_safe_generator(self.generator(example_generator(data_path, hpm)))
self.num_fill_examples_threads = 4
self.num_fill_batches_threads = 4
self.elements_queue = Queue(self.max_examples_buffer_len)
self.batch_queue = Queue(self.max_batch_buffer_len)
self.launch_watch_threads()
class thread_safe_generator(object):
def __init__(self, gen):
self.gen = gen
self.lock = threading.Lock()
def __next__(self):
with self.lock:
return next(self.gen)
def generator(self, example_gen):
while True :
e = next(example_gen)
try:
article_text = e.features.feature['article'].bytes_list.value[0].decode()
abstract_text = e.features.feature['abstract'].bytes_list.value[0].decode()
except ValueError:
tf.logging.error('Failed to get article or abstract from example')
continue
if len(article_text) == 0 :
tf.logging.warning('Found an example with empty article text. Skipping it.')
else:
yield (article_text, abstract_text)
def fill_examples_queue(self):
while True:
try:
article, abstract = next(self.gen)
abst = [sent.strip() for sent in abstract_to_sents(abstract)]
ex = Example(article, abst,self.vocab, self.hpm)
self.elements_queue.put(ex)
except :
break
def fill_batch_queue(self):
while True:
try:
if not self.hpm['decode']:
batch = []
for _ in range(self.hpm['batch_size']*self.hpm['max_batch_bucket_len']):
batch.append(self.elements_queue.get())
batch = sorted(batch, key=lambda x : x.enc_len)
batches= []
i = 0
while i+self.hpm['batch_size'] <= len(batch):
batches.append(batch[i:i+self.hpm['batch_size']])
i = i + self.hpm['batch_size']
if i < len(batch):
batches.append(batch[i:len(batch)])
if not self.hpm['singlepass']:
random.shuffle(batches)
for b in batches:
# here again we crete batch object before doing pushing it to the batch queue
self.batch_queue.put(Batch(b, self.hpm, self.vocab))
else:
ex = self.elements_queue.get()
b = [ex for _ in range(self.hpm['batch_size'])]
self.batch_queue.put(Batch(b, self.hpm, self.vocab))
except :
break
def launch_watch_threads(self):
self.elements_queue_threads = []
for i in range(self.num_fill_examples_threads):
self.elements_queue_threads.append(Thread(target=self.fill_examples_queue))
self.elements_queue_threads[-1].setDaemon(True)
self.elements_queue_threads[-1].start()
self.batch_queue_threads = []
for j in range(self.num_fill_batches_threads):
self.batch_queue_threads.append(Thread(target = self.fill_batch_queue))
self.batch_queue_threads[-1].setDaemon(True)
self.batch_queue_threads[-1].start()
def watch():
while True:
time.sleep(60)
for id, t in enumerate(self.elements_queue_threads):
if not t.is_alive() :
print("thread dead")
new_t = Thread(target = self.fill_batch_queue)
self.elements_queue_threads[id] = new_t
new_t.daemon = True
new_t.start()
for id, t in enumerate(self.batch_queue_threads):
if not t.is_alive() :
print("batch thread dead")
new_t = Thread(target=self.fill_batch_queue)
self.batch_queue_threads[id] = new_t
new_t.setDaemon(True)
new_t.start()
if not self.hpm['singlepass'] :
self.watcher = Thread(target = watch)
self.watcher.setDaemon(True)
self.watcher.start()
def next_batch(self):
if self.batch_queue.qsize() ==0:
tf.logging.warning('Bucket input queue is empty when calling next_batch. Bucket queue size: %i, Input queue size: %i', self.batch_queue.qsize(), self.elements_queue.qsize())
if self.hpm['singlepass'] or self.hpm['finished']:
tf.logging.info("Finished reading dataset in single_pass mode.")
return None
return self.batch_queue.get()
|
#include <boost/type_index.hpp>
#include <iostream>
int main()
{
return 0;
} |
-- Module : Itea.Utils
-- Description :
-- Copyright : (c) Simon Nielsen Knights 2018
-- License : MIT
-- Maintainer : [email protected]
-- Stability : unstable
-- Portability : portable
module Itea.Utils
import Language.Reflection.Utils
%language ElabReflection
%default total
%access public export
jsbool : Bool -> Int
jsbool True = 1
jsbool False = 0
||| Call a native javascript procedure
|||
||| @native Javascript procedure/expression to call
||| @type type of given procedure/expression
||| @ok proof that the given type satisfies the FFI_JS interface
jscall : (native : String)
-> (type : Type)
-> { auto ok : FTy FFI_JS [] type }
-> type
jscall name type = foreign FFI_JS name type
||| Log a string to the console
consoleLog : String -> JS_IO ()
consoleLog = jscall "console.log(%0)" (String -> JS_IO ())
||| Display the alert dialog with given text
alert : String -> JS_IO ()
alert = jscall "alert(%0)" (String -> JS_IO ())
||| Print a message for debugging with source location as a side effect
|||
||| @loc call site location
||| @message message to display
||| @result the result returned
trace : {default (%runElab sourceLocation) loc : SourceLocation}
-> (message : String)
-> (result : a)
-> a
trace {loc} text res = unsafePerformIO {ffi=FFI_JS}
(consoleLog ("[T] " ++ show loc ++ "::" ++ text) *> pure res)
-- %deprecated trace "Debug function `trace' used in source file"
||| Index a list given a constructor/function and a stream of values
indexdWith : (f : (a -> b -> c)) -> Stream a -> List b -> List c
indexdWith _ _ [] = []
indexdWith f (x :: xs) (y :: ys) = f x y :: indexdWith f xs ys
||| Index a list elements with their position
indexed : (Enum b, Num b) => List a -> List (b, a)
indexed = indexdWith MkPair [0..]
|
# -*- coding: utf-8 -*-
"""
MIT License
Copyright (c) 2016 Rainer Arencibia
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
"""
"""
The lenet_mnist.py script will be our driver program used to instantiate the LeNet network architecture,
train the model (or load the model, if our network is pre-trained),
and then evaluate the network performance on the MNIST dataset.
"""
import argparse
import numpy as np
from keras.callbacks import TensorBoard
from keras.optimizers import SGD
from keras.utils import np_utils, visualize_util
from sklearn import datasets
from sklearn.cross_validation import train_test_split
from cnn.network.lenet import LeNet
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-s", "--save-model", type=int, default=-1,
help="(optional) whether or not model should be saved to disk")
ap.add_argument("-l", "--load-model", type=int, default=-1,
help="(optional) whether or not pre-trained model should be loaded")
ap.add_argument("-w", "--weights", type=str, help="(optional) path to weights file")
args = vars(ap.parse_args())
# grab the MNIST dataset (if this is your first time running this script, the download may take a minute.
# the 55MB MNIST dataset will be downloaded)
print("[INFO] downloading MNIST...")
dataset = datasets.fetch_mldata("MNIST Original")
# (trainData, trainLabels), (testData, testLabels) = mnist.load_data()
# reshape the MNIST dataset from a flat list of 784-dim vectors, to
# 28 x 28 pixel images, then scale the data to the range [0, 1.0]
# and construct the training and testing splits
data = dataset.data.reshape((dataset.data.shape[0], 28, 28))
data = data[:, np.newaxis, :, :]
(trainData, testData, trainLabels, testLabels) = train_test_split(data / 255.0, dataset.target.astype("int"),
train_size=0.85, test_size=0.15)
# transform the training and testing labels into vectors in the
# range [0, classes] -- this generates a vector for each label,
# where the index of the label is set to `1` and all other entries
# to `0`; in the case of MNIST, there are 10 class labels
trainLabels = np_utils.to_categorical(trainLabels, 10)
testLabels = np_utils.to_categorical(testLabels, 10)
# initialize the optimizer and model
"""
Stochastic gradient descent (often shortened in SGD), also known as incremental gradient descent, is a stochastic
approximation of the gradient descent optimization method for minimizing an objective function that is written as
a sum of differentiable functions. In other words, SGD tries to find minimums or maximums by iteration.
Many extensions to vanilla SGD exist, including Momentum, Adagrad, rmsprop, Adadelta or Adam.
***
In my own experience, Adagrad/Adadelta are "safer" because they don't depend so strongly on setting of
learning rates (with Adadelta being slightly better),
but well-tuned SGD+Momentum almost always converges faster and at better final values.
"""
# Adadelta is a gradient descent based learning algorithm that adapts the learning rate per parameter over time.
# Adadelta It is similar to rmsprop and can be used instead of vanilla SGD.
# opt = Adadelta(lr=1.0, rho=0.95, epsilon=1e-08)
sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)
model = LeNet.build(width=28, height=28, depth=1, classes=10, weights_path=args["weights"] if args["load_model"] > 0
else None)
# Show summary of model
print("[INFO] Summary of the model...")
model.summary()
config = model.get_config()
print "Config: "
for i, conf in enumerate(config):
print i, conf.__str__()
print("[INFO] Compiling model...")
model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])
# model.compile(loss="mean_squared_error", optimizer=sgd, metrics=["accuracy"])
# only train and evaluate the model if we *are not* loading a pre-existing model
if args["load_model"] < 0:
print("[INFO] Training...")
# early_stopping = EarlyStopping(monitor='val_loss', patience=10, verbose=0, mode='auto')
h = model.fit(trainData, trainLabels, batch_size=128, nb_epoch=100, verbose=1, validation_split=0.15)
# callbacks = [early_stopping]
# print(h.history)
# show the accuracy on the testing set
print("[INFO] Evaluating...")
loss = model.evaluate(testData, testLabels, batch_size=128, verbose=1)
print "Test Score: ", loss[0]
print "Test Accuracy", loss[1]
visualize_util.plot(model=model, to_file='/home/rainer85ah/PycharmProjects/PythonProjects/Output/PLOT_9930.png',
show_layer_names=True,show_shapes=False)
# check to see if the model should be saved to file
if args["save_model"] > 0:
print("[INFO] dumping weights to file...")
model.save_weights(args["weights"], overwrite=True)
model.save('/home/rainer85ah/PycharmProjects/PythonProjects/Output/model_saved_9930.h5', overwrite=True)
# returns a compiled model identical to the previous one
# model = load_model('my_model.h5') from keras.models import load_model
TensorBoard(log_dir='./logs', histogram_freq=0, write_graph=True)
"""
# randomly select a few testing digits
for i in np.random.choice(np.arange(0, len(testLabels)), size=(10,)):
# classify the digit
probs = model.predict(testData[np.newaxis, i])
prediction = probs.argmax(axis=1)
# resize the image from a 28 x 28 image to a 96 x 96 image so we can better see it
image = (testData[i][0] * 255)
image = cv2.merge([image] * 3)
image = cv2.resize(image, (96, 96), interpolation=cv2.INTER_LINEAR)
cv2.putText(image, str(prediction[0]), (5, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 255, 0), 2)
# show the image and prediction
print("[INFO] Predicted: {}, Actual: {}".format(prediction[0], np.argmax(testLabels[i])))
cv2.imshow("Digit", image)
cv2.waitKey(0)
"""
|
lemma joinable_components_eq: "connected t \<and> t \<subseteq> s \<and> c1 \<in> components s \<and> c2 \<in> components s \<and> c1 \<inter> t \<noteq> {} \<and> c2 \<inter> t \<noteq> {} \<Longrightarrow> c1 = c2" |
If $p$ is a unit polynomial, then $p$ is a monomial of the form $ax^0$ for some $a \neq 0$. |
/-
Copyright (c) 2020 Bhavik Mehta. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Bhavik Mehta
Ported by: Joël Riou
! This file was ported from Lean 3 source module category_theory.essential_image
! leanprover-community/mathlib commit 550b58538991c8977703fdeb7c9d51a5aa27df11
! Please do not edit these lines, except to modify the commit id
! if you have ported upstream changes.
-/
import Mathlib.CategoryTheory.NatIso
import Mathlib.CategoryTheory.FullSubcategory
/-!
# Essential image of a functor
The essential image `essImage` of a functor consists of the objects in the target category which
are isomorphic to an object in the image of the object function.
This, for instance, allows us to talk about objects belonging to a subcategory expressed as a
functor rather than a subtype, preserving the principle of equivalence. For example this lets us
define exponential ideals.
The essential image can also be seen as a subcategory of the target category, and witnesses that
a functor decomposes into a essentially surjective functor and a fully faithful functor.
(TODO: show that this decomposition forms an orthogonal factorisation system).
-/
universe v₁ v₂ u₁ u₂
noncomputable section
namespace CategoryTheory
variable {C : Type u₁} {D : Type u₂} [Category.{v₁} C] [Category.{v₂} D] {F : C ⥤ D}
namespace Functor
/-- The essential image of a functor `F` consists of those objects in the target category which are
isomorphic to an object in the image of the function `F.obj`. In other words, this is the closure
under isomorphism of the function `F.obj`.
This is the "non-evil" way of describing the image of a functor.
-/
def essImage (F : C ⥤ D) : Set D := fun Y => ∃ X : C, Nonempty (F.obj X ≅ Y)
#align category_theory.functor.ess_image CategoryTheory.Functor.essImage
/-- Get the witnessing object that `Y` is in the subcategory given by `F`. -/
def essImage.witness {Y : D} (h : Y ∈ F.essImage) : C :=
h.choose
#align category_theory.functor.ess_image.witness CategoryTheory.Functor.essImage.witness
/-- Extract the isomorphism between `F.obj h.witness` and `Y` itself. -/
-- Porting note: in the next, the dot notation `h.witness` no longer works
def essImage.getIso {Y : D} (h : Y ∈ F.essImage) : F.obj (essImage.witness h) ≅ Y :=
Classical.choice h.choose_spec
#align category_theory.functor.ess_image.get_iso CategoryTheory.Functor.essImage.getIso
/-- Being in the essential image is a "hygenic" property: it is preserved under isomorphism. -/
theorem essImage.ofIso {Y Y' : D} (h : Y ≅ Y') (hY : Y ∈ essImage F) : Y' ∈ essImage F :=
hY.imp fun _ => Nonempty.map (· ≪≫ h)
#align category_theory.functor.ess_image.of_iso CategoryTheory.Functor.essImage.ofIso
/-- If `Y` is in the essential image of `F` then it is in the essential image of `F'` as long as
`F ≅ F'`.
-/
theorem essImage.ofNatIso {F' : C ⥤ D} (h : F ≅ F') {Y : D} (hY : Y ∈ essImage F) :
Y ∈ essImage F' :=
hY.imp fun X => Nonempty.map fun t => h.symm.app X ≪≫ t
#align category_theory.functor.ess_image.of_nat_iso CategoryTheory.Functor.essImage.ofNatIso
/-- Isomorphic functors have equal essential images. -/
theorem essImage_eq_of_natIso {F' : C ⥤ D} (h : F ≅ F') : essImage F = essImage F' :=
funext fun _ => propext ⟨essImage.ofNatIso h, essImage.ofNatIso h.symm⟩
#align category_theory.functor.ess_image_eq_of_nat_iso CategoryTheory.Functor.essImage_eq_of_natIso
/-- An object in the image is in the essential image. -/
theorem obj_mem_essImage (F : D ⥤ C) (Y : D) : F.obj Y ∈ essImage F :=
⟨Y, ⟨Iso.refl _⟩⟩
#align category_theory.functor.obj_mem_ess_image CategoryTheory.Functor.obj_mem_essImage
/-- The essential image of a functor, interpreted of a full subcategory of the target category. -/
-- Porting note: no hasNonEmptyInstance linter yet
def EssImageSubcategory (F : C ⥤ D) :=
FullSubcategory F.essImage
#align category_theory.functor.ess_image_subcategory CategoryTheory.Functor.EssImageSubcategory
-- Porting note: `deriving Category` is not able to derive this instance
instance : Category (EssImageSubcategory F) :=
(inferInstance : Category.{v₂} (FullSubcategory _))
/-- The essential image as a subcategory has a fully faithful inclusion into the target category. -/
@[simps!]
def essImageInclusion (F : C ⥤ D) : F.EssImageSubcategory ⥤ D :=
fullSubcategoryInclusion _
#align category_theory.functor.ess_image_inclusion CategoryTheory.Functor.essImageInclusion
#align category_theory.functor.ess_image_inclusion_obj CategoryTheory.Functor.essImageInclusion_obj
#align category_theory.functor.ess_image_inclusion_map CategoryTheory.Functor.essImageInclusion_map
-- Porting note: `deriving Full` is not able to derive this instance
instance : Full (essImageInclusion F) :=
(inferInstance : Full (fullSubcategoryInclusion _))
-- Porting note: `deriving Faithful` is not able to derive this instance
instance : Faithful (essImageInclusion F) :=
(inferInstance : Faithful (fullSubcategoryInclusion _))
/--
Given a functor `F : C ⥤ D`, we have an (essentially surjective) functor from `C` to the essential
image of `F`.
-/
@[simps!]
def toEssImage (F : C ⥤ D) : C ⥤ F.EssImageSubcategory :=
FullSubcategory.lift _ F (obj_mem_essImage _)
#align category_theory.functor.to_ess_image CategoryTheory.Functor.toEssImage
#align category_theory.functor.to_ess_image_map CategoryTheory.Functor.toEssImage_map
#align category_theory.functor.to_ess_image_obj_obj CategoryTheory.Functor.toEssImage_obj_obj
/-- The functor `F` factorises through its essential image, where the first functor is essentially
surjective and the second is fully faithful.
-/
@[simps!]
def toEssImageCompEssentialImageInclusion (F : C ⥤ D) : F.toEssImage ⋙ F.essImageInclusion ≅ F :=
FullSubcategory.lift_comp_inclusion _ _ _
#align category_theory.functor.to_ess_image_comp_essential_image_inclusion CategoryTheory.Functor.toEssImageCompEssentialImageInclusion
#align category_theory.functor.to_ess_image_comp_essential_image_inclusion_hom_app CategoryTheory.Functor.toEssImageCompEssentialImageInclusion_hom_app
#align category_theory.functor.to_ess_image_comp_essential_image_inclusion_inv_app CategoryTheory.Functor.toEssImageCompEssentialImageInclusion_inv_app
end Functor
/-- A functor `F : C ⥤ D` is essentially surjective if every object of `D` is in the essential
image of `F`. In other words, for every `Y : D`, there is some `X : C` with `F.obj X ≅ Y`.
See <https://stacks.math.columbia.edu/tag/001C>.
-/
class EssSurj (F : C ⥤ D) : Prop where
/-- All the objects of the target category are in the essential image. -/
mem_essImage (Y : D) : Y ∈ F.essImage
#align category_theory.ess_surj CategoryTheory.EssSurj
instance :
EssSurj
F.toEssImage where mem_essImage := fun ⟨_, hY⟩ =>
⟨_, ⟨⟨_, _, hY.getIso.hom_inv_id, hY.getIso.inv_hom_id⟩⟩⟩
variable (F) [EssSurj F]
/-- Given an essentially surjective functor, we can find a preimage for every object `Y` in the
codomain. Applying the functor to this preimage will yield an object isomorphic to `Y`, see
`obj_obj_preimage_iso`. -/
def Functor.objPreimage (Y : D) : C :=
essImage.witness (@EssSurj.mem_essImage _ _ _ _ F _ Y)
#align category_theory.functor.obj_preimage CategoryTheory.Functor.objPreimage
/-- Applying an essentially surjective functor to a preimage of `Y` yields an object that is
isomorphic to `Y`. -/
def Functor.objObjPreimageIso (Y : D) : F.obj (F.objPreimage Y) ≅ Y :=
Functor.essImage.getIso _
#align category_theory.functor.obj_obj_preimage_iso CategoryTheory.Functor.objObjPreimageIso
/-- The induced functor of a faithful functor is faithful -/
instance Faithful.toEssImage (F : C ⥤ D) [Faithful F] : Faithful F.toEssImage :=
Faithful.of_comp_iso F.toEssImageCompEssentialImageInclusion
#align category_theory.faithful.to_ess_image CategoryTheory.Faithful.toEssImage
/-- The induced functor of a full functor is full -/
instance Full.toEssImage (F : C ⥤ D) [Full F] : Full F.toEssImage :=
haveI := Full.ofIso F.toEssImageCompEssentialImageInclusion.symm
Full.ofCompFaithful F.toEssImage F.essImageInclusion
#align category_theory.full.to_ess_image CategoryTheory.Full.toEssImage
end CategoryTheory
|
section \<open>Intuitionistic first-order logic\<close>
theory betterFOL
imports Pure
begin
ML \<open>\<^assert> (not (can ML \<open>open RunCall\<close>))\<close>
ML_file \<open>~~/src/Tools/misc_legacy.ML\<close>
ML_file \<open>~~/src/Provers/splitter.ML\<close>
ML_file \<open>~~/src/Provers/hypsubst.ML\<close>
ML_file \<open>~~/src/Tools/IsaPlanner/zipper.ML\<close>
ML_file \<open>~~/src/Tools/IsaPlanner/isand.ML\<close>
ML_file \<open>~~/src/Tools/IsaPlanner/rw_inst.ML\<close>
ML_file \<open>~~/src/Provers/quantifier1.ML\<close>
ML_file \<open>~~/src/Tools/intuitionistic.ML\<close>
ML_file \<open>~~/src/Tools/project_rule.ML\<close>
ML_file \<open>~~/src/Tools/atomize_elim.ML\<close>
subsection \<open>Syntax and axiomatic basis\<close>
setup Pure_Thy.old_appl_syntax_setup
class "term"
default_sort \<open>term\<close>
typedecl o
judgment
Trueprop :: \<open>o \<Rightarrow> prop\<close> (\<open>(_)\<close> 5)
subsubsection \<open>Equality\<close>
axiomatization
eq :: \<open>['a, 'a] \<Rightarrow> o\<close> (infixl \<open>=\<close> 50)
where
refl: \<open>a = a\<close> and
subst: \<open>a = b \<Longrightarrow> P(a) \<Longrightarrow> P(b)\<close>
subsubsection \<open>Propositional logic\<close>
axiomatization
False :: \<open>o\<close> and
conj :: \<open>[o, o] => o\<close> (infixr \<open>\<and>\<close> 35) and
disj :: \<open>[o, o] => o\<close> (infixr \<open>\<or>\<close> 30) and
imp :: \<open>[o, o] => o\<close> (infixr \<open>\<longrightarrow>\<close> 25)
axiomatization
where
mp: \<open>\<lbrakk>P \<longrightarrow> Q; P\<rbrakk> \<Longrightarrow> Q\<close> and
a1: \<open>A \<longrightarrow> (B \<longrightarrow> A)\<close> and
a2: \<open>(A \<longrightarrow> (B \<longrightarrow> C))\<longrightarrow>((A \<longrightarrow> B)\<longrightarrow>(A \<longrightarrow> C))\<close>
theorem Ded: \<open>(P \<Longrightarrow> Q) \<Longrightarrow> P \<longrightarrow> Q\<close>
(*
conjI: \<open>\<lbrakk>P; Q\<rbrakk> \<Longrightarrow> P \<and> Q\<close> and
conjunct1: \<open>P \<and> Q \<Longrightarrow> P\<close> and
conjunct2: \<open>P \<and> Q \<Longrightarrow> Q\<close> and
disjI1: \<open>P \<Longrightarrow> P \<or> Q\<close> and
disjI2: \<open>Q \<Longrightarrow> P \<or> Q\<close> and
disjE: \<open>\<lbrakk>P \<or> Q; P \<Longrightarrow> R; Q \<Longrightarrow> R\<rbrakk> \<Longrightarrow> R\<close> and
impI: \<open>(P \<Longrightarrow> Q) \<Longrightarrow> P \<longrightarrow> Q\<close> and
mp: \<open>\<lbrakk>P \<longrightarrow> Q; P\<rbrakk> \<Longrightarrow> Q\<close> and
FalseE: \<open>False \<Longrightarrow> P\<close>
*)
|
/* -----------------------------------------------------------------------------
* Copyright 2021 Jonathan Haigh
* SPDX-License-Identifier: MIT
* ---------------------------------------------------------------------------*/
#ifndef SQ_INCLUDE_GUARD_core_typeutil_h_
#define SQ_INCLUDE_GUARD_core_typeutil_h_
#include <concepts>
#include <cstddef>
#include <gsl/gsl>
#include <range/v3/range/concepts.hpp>
#include <stdexcept>
#include <string>
#include <system_error>
#include <type_traits>
#include <variant>
// The following macros can't be replaced with constexpr functions or constants
// so tell clang-tidy not to complain
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define SQ_FWD(x) static_cast<decltype(x) &&>(x)
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define SQ_ND [[nodiscard]]
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define SQ_MU [[maybe_unused]]
namespace sq {
/**
* Concept for types that can be dumped to a std::ostream.
*/
template <typename T> concept Printable = requires(T x, std::ostream &os) {
os << x;
};
///@{
/**
* Get whether the type T is a specialization of std::variant.
*/
template <typename T> struct IsVariant : std::false_type {};
template <typename... Types>
struct IsVariant<std::variant<Types...>> : std::true_type {};
template <typename T> inline constexpr bool is_variant_v = IsVariant<T>::value;
///@}
///@{
/**
* Get whether the type T is one of the alternative types of the variant V.
*/
template <typename T, typename V>
requires is_variant_v<V> struct IsAlternative : std::false_type {};
template <typename T, typename... Types>
struct IsAlternative<T, std::variant<Types...>>
: std::disjunction<std::is_same<T, Types>...> {};
template <typename T, typename V>
inline constexpr bool is_alternative_v = IsAlternative<T, V>::value;
///@}
/**
* Concept for types that are alternatives of the variant V.
*/
template <typename T, typename V> concept Alternative = is_alternative_v<T, V>;
///@{
/**
* Get whether T can be converted to one of the variant V's alternatives.
*/
template <typename T, typename V>
requires is_variant_v<V> struct IsConvertibleToAlternative : std::false_type {};
template <typename T, typename... Types>
struct IsConvertibleToAlternative<T, std::variant<Types...>>
: std::disjunction<std::is_convertible<T, Types>...> {};
template <typename T, typename V>
inline constexpr bool is_convertible_to_alternative_v =
IsConvertibleToAlternative<T, V>::value;
///@}
/**
* Concept for types that are convertible to one of the variant V's
* alternatives.
*/
template <typename T, typename V>
concept ConvertibleToAlternative = is_convertible_to_alternative_v<T, V>;
///@{
/**
* A range whose distance can be obtained without invalidating the range.
*
* This is different to std::sized_range because it doesn't require:
* - that size(rng) is available;
* - that distance(rng) is a constant time operation.
*
* Essentially, it just rules out std::input_ranges without a known size.
*/
template <typename T>
concept SlowSizedRange =
ranges::cpp20::forward_range<T> || ranges::cpp20::sized_range<T>;
/**
* Get the name of the "base type" of the given expression.
*
* The "base type" is the type with no references or cv qualification.
*/
SQ_ND std::string base_type_name(const auto &thing);
/**
* Create a std::error code from a platform dependent error code.
*/
SQ_ND inline std::error_code make_error_code(int code) {
return std::make_error_code(static_cast<std::errc>(code));
}
} // namespace sq
namespace ranges {
// Tell the ranges library that gsl::spans with dynamic extent are views. Note
// that the view concept requires a default constructor so sized gsl::spans are
// *not* views...
template <typename T>
inline constexpr bool enable_view<gsl::span<T, gsl::dynamic_extent>> = true;
// ... unless the size is zero.
template <typename T> inline constexpr bool enable_view<gsl::span<T, 0>> = true;
} // namespace ranges
#include "core/typeutil.inl.h"
#endif // SQ_INCLUDE_GUARD_core_typeutil_h_
|
/-
Copyright (c) 2019 Jeremy Avigad. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Jeremy Avigad
-/
import order.filter.basic
import data.pfun
/-!
# `tendsto` for relations and partial functions
This file generalizes `filter` definitions from functions to partial functions and relations.
## Considering functions and partial functions as relations
A function `f : α → β` can be considered as the relation `rel α β` which relates `x` and `f x` for
all `x`, and nothing else. This relation is called `function.graph f`.
A partial function `f : α →. β` can be considered as the relation `rel α β` which relates `x` and
`f x` for all `x` for which `f x` exists, and nothing else. This relation is called
`pfun.graph' f`.
In this regard, a function is a relation for which every element in `α` is related to exactly one
element in `β` and a partial function is a relation for which every element in `α` is related to at
most one element in `β`.
This file leverages this analogy to generalize `filter` definitions from functions to partial
functions and relations.
## Notes
`set.preimage` can be generalized to relations in two ways:
* `rel.preimage` returns the image of the set under the inverse relation.
* `rel.core` returns the set of elements that are only related to those in the set.
Both generalizations are sensible in the context of filters, so `filter.comap` and `filter.tendsto`
get two generalizations each.
We first take care of relations. Then the definitions for partial functions are taken as special
cases of the definitions for relations.
-/
universes u v w
namespace filter
variables {α : Type u} {β : Type v} {γ : Type w}
open_locale filter
/-! ### Relations -/
/-- The forward map of a filter under a relation. Generalization of `filter.map` to relations. Note
that `rel.core` generalizes `set.preimage`. -/
def rmap (r : rel α β) (l : filter α) : filter β :=
{ sets := {s | r.core s ∈ l},
univ_sets := by simp,
sets_of_superset := λ s t hs st, mem_of_superset hs $ rel.core_mono _ st,
inter_sets := λ s t hs ht, by simp [rel.core_inter, inter_mem hs ht] }
theorem rmap_sets (r : rel α β) (l : filter α) : (l.rmap r).sets = r.core ⁻¹' l.sets := rfl
@[simp]
theorem mem_rmap (r : rel α β) (l : filter α) (s : set β) :
s ∈ l.rmap r ↔ r.core s ∈ l :=
iff.rfl
@[simp]
theorem rmap_rmap (r : rel α β) (s : rel β γ) (l : filter α) :
rmap s (rmap r l) = rmap (r.comp s) l :=
filter_eq $
by simp [rmap_sets, set.preimage, rel.core_comp]
@[simp]
lemma rmap_compose (r : rel α β) (s : rel β γ) : rmap s ∘ rmap r = rmap (r.comp s) :=
funext $ rmap_rmap _ _
/-- Generic "limit of a relation" predicate. `rtendsto r l₁ l₂` asserts that for every
`l₂`-neighborhood `a`, the `r`-core of `a` is an `l₁`-neighborhood. One generalization of
`filter.tendsto` to relations. -/
def rtendsto (r : rel α β) (l₁ : filter α) (l₂ : filter β) := l₁.rmap r ≤ l₂
theorem rtendsto_def (r : rel α β) (l₁ : filter α) (l₂ : filter β) :
rtendsto r l₁ l₂ ↔ ∀ s ∈ l₂, r.core s ∈ l₁ :=
iff.rfl
/-- One way of taking the inverse map of a filter under a relation. One generalization of
`filter.comap` to relations. Note that `rel.core` generalizes `set.preimage`. -/
def rcomap (r : rel α β) (f : filter β) : filter α :=
{ sets := rel.image (λ s t, r.core s ⊆ t) f.sets,
univ_sets := ⟨set.univ, univ_mem, set.subset_univ _⟩,
sets_of_superset := λ a b ⟨a', ha', ma'a⟩ ab, ⟨a', ha', ma'a.trans ab⟩,
inter_sets := λ a b ⟨a', ha₁, ha₂⟩ ⟨b', hb₁, hb₂⟩,
⟨a' ∩ b', inter_mem ha₁ hb₁,
(r.core_inter a' b').subset.trans (set.inter_subset_inter ha₂ hb₂)⟩ }
theorem rcomap_sets (r : rel α β) (f : filter β) :
(rcomap r f).sets = rel.image (λ s t, r.core s ⊆ t) f.sets := rfl
theorem rcomap_rcomap (r : rel α β) (s : rel β γ) (l : filter γ) :
rcomap r (rcomap s l) = rcomap (r.comp s) l :=
filter_eq $
begin
ext t, simp [rcomap_sets, rel.image, rel.core_comp], split,
{ rintros ⟨u, ⟨v, vsets, hv⟩, h⟩,
exact ⟨v, vsets, set.subset.trans (rel.core_mono _ hv) h⟩ },
rintros ⟨t, tsets, ht⟩,
exact ⟨rel.core s t, ⟨t, tsets, set.subset.rfl⟩, ht⟩
end
@[simp]
lemma rcomap_compose (r : rel α β) (s : rel β γ) : rcomap r ∘ rcomap s = rcomap (r.comp s) :=
funext $ rcomap_rcomap _ _
theorem rtendsto_iff_le_rcomap (r : rel α β) (l₁ : filter α) (l₂ : filter β) :
rtendsto r l₁ l₂ ↔ l₁ ≤ l₂.rcomap r :=
begin
rw rtendsto_def,
change (∀ (s : set β), s ∈ l₂.sets → r.core s ∈ l₁) ↔ l₁ ≤ rcomap r l₂,
simp [filter.le_def, rcomap, rel.mem_image], split,
{ exact λ h s t tl₂, mem_of_superset (h t tl₂) },
{ exact λ h t tl₂, h _ t tl₂ set.subset.rfl }
end
-- Interestingly, there does not seem to be a way to express this relation using a forward map.
-- Given a filter `f` on `α`, we want a filter `f'` on `β` such that `r.preimage s ∈ f` if
-- and only if `s ∈ f'`. But the intersection of two sets satisfying the lhs may be empty.
/-- One way of taking the inverse map of a filter under a relation. Generalization of `filter.comap`
to relations. -/
def rcomap' (r : rel α β) (f : filter β) : filter α :=
{ sets := rel.image (λ s t, r.preimage s ⊆ t) f.sets,
univ_sets := ⟨set.univ, univ_mem, set.subset_univ _⟩,
sets_of_superset := λ a b ⟨a', ha', ma'a⟩ ab, ⟨a', ha', ma'a.trans ab⟩,
inter_sets := λ a b ⟨a', ha₁, ha₂⟩ ⟨b', hb₁, hb₂⟩,
⟨a' ∩ b', inter_mem ha₁ hb₁,
(@rel.preimage_inter _ _ r _ _).trans (set.inter_subset_inter ha₂ hb₂)⟩ }
@[simp]
lemma mem_rcomap' (r : rel α β) (l : filter β) (s : set α) :
s ∈ l.rcomap' r ↔ ∃ t ∈ l, r.preimage t ⊆ s :=
iff.rfl
theorem rcomap'_sets (r : rel α β) (f : filter β) :
(rcomap' r f).sets = rel.image (λ s t, r.preimage s ⊆ t) f.sets := rfl
@[simp]
theorem rcomap'_rcomap' (r : rel α β) (s : rel β γ) (l : filter γ) :
rcomap' r (rcomap' s l) = rcomap' (r.comp s) l :=
filter.ext $ λ t,
begin
simp [rcomap'_sets, rel.image, rel.preimage_comp], split,
{ rintro ⟨u, ⟨v, vsets, hv⟩, h⟩,
exact ⟨v, vsets, (rel.preimage_mono _ hv).trans h⟩ },
rintro ⟨t, tsets, ht⟩,
exact ⟨s.preimage t, ⟨t, tsets, set.subset.rfl⟩, ht⟩
end
@[simp]
lemma rcomap'_compose (r : rel α β) (s : rel β γ) : rcomap' r ∘ rcomap' s = rcomap' (r.comp s) :=
funext $ rcomap'_rcomap' _ _
/-- Generic "limit of a relation" predicate. `rtendsto' r l₁ l₂` asserts that for every
`l₂`-neighborhood `a`, the `r`-preimage of `a` is an `l₁`-neighborhood. One generalization of
`filter.tendsto` to relations. -/
def rtendsto' (r : rel α β) (l₁ : filter α) (l₂ : filter β) := l₁ ≤ l₂.rcomap' r
theorem rtendsto'_def (r : rel α β) (l₁ : filter α) (l₂ : filter β) :
rtendsto' r l₁ l₂ ↔ ∀ s ∈ l₂, r.preimage s ∈ l₁ :=
begin
unfold rtendsto' rcomap', simp [le_def, rel.mem_image], split,
{ exact λ h s hs, h _ _ hs set.subset.rfl },
{ exact λ h s t ht, mem_of_superset (h t ht) }
end
theorem tendsto_iff_rtendsto (l₁ : filter α) (l₂ : filter β) (f : α → β) :
tendsto f l₁ l₂ ↔ rtendsto (function.graph f) l₁ l₂ :=
by { simp [tendsto_def, function.graph, rtendsto_def, rel.core, set.preimage] }
theorem tendsto_iff_rtendsto' (l₁ : filter α) (l₂ : filter β) (f : α → β) :
tendsto f l₁ l₂ ↔ rtendsto' (function.graph f) l₁ l₂ :=
by { simp [tendsto_def, function.graph, rtendsto'_def, rel.preimage_def, set.preimage] }
/-! ### Partial functions -/
/-- The forward map of a filter under a partial function. Generalization of `filter.map` to partial
functions. -/
def pmap (f : α →. β) (l : filter α) : filter β :=
filter.rmap f.graph' l
@[simp]
lemma mem_pmap (f : α →. β) (l : filter α) (s : set β) : s ∈ l.pmap f ↔ f.core s ∈ l :=
iff.rfl
/-- Generic "limit of a partial function" predicate. `ptendsto r l₁ l₂` asserts that for every
`l₂`-neighborhood `a`, the `p`-core of `a` is an `l₁`-neighborhood. One generalization of
`filter.tendsto` to partial function. -/
def ptendsto (f : α →. β) (l₁ : filter α) (l₂ : filter β) := l₁.pmap f ≤ l₂
theorem ptendsto_def (f : α →. β) (l₁ : filter α) (l₂ : filter β) :
ptendsto f l₁ l₂ ↔ ∀ s ∈ l₂, f.core s ∈ l₁ :=
iff.rfl
theorem ptendsto_iff_rtendsto (l₁ : filter α) (l₂ : filter β) (f : α →. β) :
ptendsto f l₁ l₂ ↔ rtendsto f.graph' l₁ l₂ :=
iff.rfl
theorem pmap_res (l : filter α) (s : set α) (f : α → β) :
pmap (pfun.res f s) l = map f (l ⊓ 𝓟 s) :=
begin
ext t,
simp only [pfun.core_res, mem_pmap, mem_map, mem_inf_principal, imp_iff_not_or],
refl
end
theorem tendsto_iff_ptendsto (l₁ : filter α) (l₂ : filter β) (s : set α) (f : α → β) :
tendsto f (l₁ ⊓ 𝓟 s) l₂ ↔ ptendsto (pfun.res f s) l₁ l₂ :=
by simp only [tendsto, ptendsto, pmap_res]
theorem tendsto_iff_ptendsto_univ (l₁ : filter α) (l₂ : filter β) (f : α → β) :
tendsto f l₁ l₂ ↔ ptendsto (pfun.res f set.univ) l₁ l₂ :=
by { rw ← tendsto_iff_ptendsto, simp [principal_univ] }
/-- Inverse map of a filter under a partial function. One generalization of `filter.comap` to
partial functions. -/
def pcomap' (f : α →. β) (l : filter β) : filter α :=
filter.rcomap' f.graph' l
/-- Generic "limit of a partial function" predicate. `ptendsto' r l₁ l₂` asserts that for every
`l₂`-neighborhood `a`, the `p`-preimage of `a` is an `l₁`-neighborhood. One generalization of
`filter.tendsto` to partial functions. -/
def ptendsto' (f : α →. β) (l₁ : filter α) (l₂ : filter β) := l₁ ≤ l₂.rcomap' f.graph'
theorem ptendsto'_def (f : α →. β) (l₁ : filter α) (l₂ : filter β) :
ptendsto' f l₁ l₂ ↔ ∀ s ∈ l₂, f.preimage s ∈ l₁ :=
rtendsto'_def _ _ _
theorem ptendsto_of_ptendsto' {f : α →. β} {l₁ : filter α} {l₂ : filter β} :
ptendsto' f l₁ l₂ → ptendsto f l₁ l₂ :=
begin
rw [ptendsto_def, ptendsto'_def],
exact λ h s sl₂, mem_of_superset (h s sl₂) (pfun.preimage_subset_core _ _),
end
theorem ptendsto'_of_ptendsto {f : α →. β} {l₁ : filter α} {l₂ : filter β} (h : f.dom ∈ l₁) :
ptendsto f l₁ l₂ → ptendsto' f l₁ l₂ :=
begin
rw [ptendsto_def, ptendsto'_def],
intros h' s sl₂,
rw pfun.preimage_eq,
exact inter_mem (h' s sl₂) h
end
end filter
|
If $f$ is a continuous function on the image of a circle of radius $r$ centered at $z$, and if $\int_{\gamma} \frac{f(u)}{(u - w)^k} du$ exists for all $w \in B(z, r)$, then $\int_{\gamma} \frac{f(u)}{(u - w)^(k + 1)} du$ exists for all $w \in B(z, r)$, and the derivative of $\int_{\gamma} \frac{f(u)}{(u - w)^k} du$ with respect to $w$ is $k \int_{\gamma} \frac{f(u)}{(u - w)^(k + 1)} du$. |
\documentclass{article}
\usepackage{fullpage}
\usepackage{amsmath}
\newcommand{\F}{\mathbf{F}}
\newcommand{\N}{\mathbf{N}}
\renewcommand{\S}{\mathbf{S}}
\newcommand{\D}{\mathbf{D}}
\newcommand{\X}{\mathbf{X}}
\newcommand{\f}{\mathbf{f}}
\renewcommand{\P}{\mathbf{P}}
\newcommand{\Ds}{\D_s}
\newcommand{\Dm}{\D_m}
\renewcommand{\o}{\mathbf{1}}
\newcommand{\I}{\mathbf{I}}
\newcommand{\tr}{\mbox{tr}}
\newcommand{\m}[1]{\begin{pmatrix}#1\end{pmatrix}}
\newcommand{\pp}[2]{\frac{\partial #1}{\partial #2}}
\begin{document}
\section{Finite Elements}
\begin{tabular}{|c|c|cc|l|}
\hline
Symbol & Definition & Dimensions & Units & Meaning \\
\hline
$\o$ & $\o = \m{1 & \cdots & 1}^T$ & $d$ & $1$ & All ones vector \\
$\S$ & $\S = \m{\I & -\o}$ & $d \times (d+1)$ & $1$ & Scatter matrix \\
\hline
$\X_m$ & $\m{X_1 & X_2 & X_3 & X_4}_m$ & $d \times (d+1)$ & $m$ & Material space element node positions \\
$\X$ & $\m{X_1 & X_2 & X_3 & X_4}$ & $d \times (d+1)$ & $m$ & World space element node positions \\
$\Dm$ & $\Dm = \X_m \S^T$ & $d \times d$ & $m$ & Material space relative node positions \\
$\Ds$ & $\Ds = \X \S^T$ & $d \times d$ & $m$ & World space relative node positions \\
$\F$ & $\F = \Ds \Dm^{-1}$ & $d \times d$ & $1$ & Deformation gradient \\
\hline
$J$ & $J = \det(\F)$ & scalar & $1$ & Jacobian \\
$I_1$ & $I_1 = \tr(\F \F^T)$ & scalar & $1$ & First invariant \\
\hline
$V$ & $V = \frac{1}{d!} \det(\Dm)$ & scalar & $m^d$ & Material space element volume \\
$\N$ & $\N = V \Dm^{-T}$ & $d \times d$ & $m^{d-1}$ & Material space area weighted normals \\
\hline
$\psi$ & - & scalar & $kg \, m^{2-d} s^{-1}$ & Energy density \\
$\phi$ & $\phi = V \psi$ & scalar & $kg \, m^2 s^{-1}$ & Potential energy of element \\
$\f$ & $\f = -\pp{\phi}{\X}$ & $d \times (d+1)$ & $kg \, m s^{-1}$ & Force on element nodes \\
$\P$ & $\f = -\P \N \S^T$ & $d \times d$ & $kg \, m^{2-d} s^{-1}$ & First Piola-Kirchoff stress \\
\hline
\end{tabular}
\vspace{.2in}
Consider that a small position change $\delta \X$ is made. Then
\begin{eqnarray*}
0 & = & \f : \delta \X + \delta \phi \\
& = & \tr(\f \delta \X^T) + \delta \phi \\
& = & \tr(-\P \N \S^T \delta \X^T) + V \delta \psi \\
& = & -V \tr(\P \Dm^{-T} \S^T \delta \X^T) + V \delta \psi \\
\delta \psi & = & \tr(\P \Dm^{-T} \S^T \delta \X^T) \\
& = & \tr(\P \delta (\Dm^{-T} \S^T \X^T)) \\
& = & \tr(\P \delta (\Dm^{-T} \Ds^T)) \\
& = & \tr(\P \delta \F^T) \\
& = & \P : \delta \F \\
\P & = & \pp{\psi}{\F}
\end{eqnarray*}
\section{Potential Energy for Neo Hookean}
Let $\psi = \frac{\mu}{2} (I_1 - d) - \mu \ln J + \frac{\lambda}{2} \ln^2 J$.
\begin{eqnarray*}
\pp{J}{\F} & = & \pp{}{\F} \det(\F) = \det(\F) \F^{-1} = J \F^{-1} \\
\pp{I_1}{\F} & = & \pp{}{\F} \tr(\F \F^T) = 2 \F \\
\pp{}{\F} & = & \pp{}{\F} \ln J = \F^{-1} \\
\P = \pp{\psi}{\X} & = & \pp{}{\X} \left( \frac{\mu}{2} (I_1 - d) - \mu \ln J + \frac{\lambda}{2} \ln^2 J \right) \\
& = & \frac{\mu}{2} \pp{I_1}{\X} - \mu \pp{}{\F} \ln J + \lambda \ln J \pp{}{\F} \ln J \\
& = & \mu (\F - \F^{-1}) + \lambda \ln J \F^{-1}
\end{eqnarray*}
\end{document}
|
[STATEMENT]
lemma last_bin_last: "size xs > 0 \<Longrightarrow> last xs \<longleftrightarrow> odd (bl_to_bin xs)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. 0 < length xs \<Longrightarrow> last xs = odd (bl_to_bin xs)
[PROOF STEP]
unfolding bl_to_bin_def
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. 0 < length xs \<Longrightarrow> last xs = odd (bl_to_bin_aux xs 0)
[PROOF STEP]
by (erule last_bin_last') |
State Before: α : Type u_1
β : Type u_2
γ : Type ?u.63296
δ : Type ?u.63299
e : LocalEquiv α β
e' : LocalEquiv β γ
⊢ prod (LocalEquiv.refl α) (LocalEquiv.refl β) = LocalEquiv.refl (α × β) State After: no goals Tactic: ext ⟨x, y⟩ <;> simp |
MODULE GWFWELMODULE
INTEGER,SAVE,POINTER ::NWELLS,MXWELL,NWELVL,IWELCB,IPRWEL
INTEGER,SAVE,POINTER ::NPWEL,IWELPB,NNPWEL
CHARACTER(LEN=16),SAVE, DIMENSION(:), POINTER ::WELAUX
REAL, SAVE, DIMENSION(:,:), POINTER ::WELL
TYPE GWFWELTYPE
INTEGER,POINTER ::NWELLS,MXWELL,NWELVL,IWELCB,IPRWEL
INTEGER,POINTER ::NPWEL,IWELPB,NNPWEL
CHARACTER(LEN=16), DIMENSION(:), POINTER ::WELAUX
REAL, DIMENSION(:,:), POINTER ::WELL
END TYPE
TYPE(GWFWELTYPE), SAVE:: GWFWELDAT(10)
END MODULE GWFWELMODULE
SUBROUTINE GWF2WEL7AR(IN,IGRID)
C ******************************************************************
C ALLOCATE ARRAY STORAGE FOR WELL PACKAGE
C ******************************************************************
C
C SPECIFICATIONS:
C ------------------------------------------------------------------
USE GLOBAL, ONLY:IOUT,NCOL,NROW,NLAY,IFREFM
USE GWFWELMODULE, ONLY:NWELLS,MXWELL,NWELVL,IWELCB,IPRWEL,NPWEL,
1 IWELPB,NNPWEL,WELAUX,WELL
C
CHARACTER*200 LINE
C ------------------------------------------------------------------
ALLOCATE(NWELLS,MXWELL,NWELVL,IWELCB,IPRWEL)
ALLOCATE(NPWEL,IWELPB,NNPWEL)
C
C1------IDENTIFY PACKAGE AND INITIALIZE NWELLS.
WRITE(IOUT,1)IN
1 FORMAT(1X,/1X,'WEL -- WELL PACKAGE, VERSION 7, 5/2/2005',
1' INPUT READ FROM UNIT ',I4)
NWELLS=0
NNPWEL=0
C
C2------READ MAXIMUM NUMBER OF WELLS AND UNIT OR FLAG FOR
C2------CELL-BY-CELL FLOW TERMS.
CALL URDCOM(IN,IOUT,LINE)
CALL UPARLSTAL(IN,IOUT,LINE,NPWEL,MXPW)
IF(IFREFM.EQ.0) THEN
READ(LINE,'(2I10)') MXACTW,IWELCB
LLOC=21
ELSE
LLOC=1
CALL URWORD(LINE,LLOC,ISTART,ISTOP,2,MXACTW,R,IOUT,IN)
CALL URWORD(LINE,LLOC,ISTART,ISTOP,2,IWELCB,R,IOUT,IN)
END IF
WRITE(IOUT,3) MXACTW
3 FORMAT(1X,'MAXIMUM OF ',I6,' ACTIVE WELLS AT ONE TIME')
IF(IWELCB.LT.0) WRITE(IOUT,7)
7 FORMAT(1X,'CELL-BY-CELL FLOWS WILL BE PRINTED WHEN ICBCFL NOT 0')
IF(IWELCB.GT.0) WRITE(IOUT,8) IWELCB
8 FORMAT(1X,'CELL-BY-CELL FLOWS WILL BE SAVED ON UNIT ',I4)
C
C3------READ AUXILIARY VARIABLES AND PRINT FLAG.
ALLOCATE(WELAUX(20))
NAUX=0
IPRWEL=1
10 CALL URWORD(LINE,LLOC,ISTART,ISTOP,1,N,R,IOUT,IN)
IF(LINE(ISTART:ISTOP).EQ.'AUXILIARY' .OR.
1 LINE(ISTART:ISTOP).EQ.'AUX') THEN
CALL URWORD(LINE,LLOC,ISTART,ISTOP,1,N,R,IOUT,IN)
IF(NAUX.LT.20) THEN
NAUX=NAUX+1
WELAUX(NAUX)=LINE(ISTART:ISTOP)
WRITE(IOUT,12) WELAUX(NAUX)
12 FORMAT(1X,'AUXILIARY WELL VARIABLE: ',A)
END IF
GO TO 10
ELSE IF(LINE(ISTART:ISTOP).EQ.'NOPRINT') THEN
WRITE(IOUT,13)
13 FORMAT(1X,'LISTS OF WELL CELLS WILL NOT BE PRINTED')
IPRWEL = 0
GO TO 10
END IF
C3A-----THERE ARE FOUR INPUT VALUES PLUS ONE LOCATION FOR
C3A-----CELL-BY-CELL FLOW.
NWELVL=5+NAUX
C
C4------ALLOCATE SPACE FOR THE WELL DATA.
IWELPB=MXACTW+1
MXWELL=MXACTW+MXPW
ALLOCATE (WELL(NWELVL,MXWELL))
C
C5------READ NAMED PARAMETERS.
WRITE(IOUT,18) NPWEL
18 FORMAT(1X,//1X,I5,' Well parameters')
IF(NPWEL.GT.0) THEN
LSTSUM=IWELPB
DO 120 K=1,NPWEL
LSTBEG=LSTSUM
CALL UPARLSTRP(LSTSUM,MXWELL,IN,IOUT,IP,'WEL','Q',1,
& NUMINST)
NLST=LSTSUM-LSTBEG
IF(NUMINST.EQ.0) THEN
C5A-----READ PARAMETER WITHOUT INSTANCES.
CALL ULSTRD(NLST,WELL,LSTBEG,NWELVL,MXWELL,1,IN,
& IOUT,'WELL NO. LAYER ROW COL STRESS FACTOR',
& WELAUX,20,NAUX,IFREFM,NCOL,NROW,NLAY,4,4,IPRWEL)
ELSE
C5B-----READ INSTANCES.
NINLST=NLST/NUMINST
DO 110 I=1,NUMINST
CALL UINSRP(I,IN,IOUT,IP,IPRWEL)
CALL ULSTRD(NINLST,WELL,LSTBEG,NWELVL,MXWELL,1,IN,
& IOUT,'WELL NO. LAYER ROW COL STRESS FACTOR',
& WELAUX,20,NAUX,IFREFM,NCOL,NROW,NLAY,4,4,IPRWEL)
LSTBEG=LSTBEG+NINLST
110 CONTINUE
END IF
120 CONTINUE
END IF
C
C6------RETURN
CALL SGWF2WEL7PSV(IGRID)
RETURN
END
SUBROUTINE GWF2WEL7RP(IN,IGRID)
C ******************************************************************
C READ WELL DATA FOR A STRESS PERIOD
C ******************************************************************
C
C SPECIFICATIONS:
C ------------------------------------------------------------------
USE GLOBAL, ONLY:IOUT,NCOL,NROW,NLAY,IFREFM
USE GWFWELMODULE, ONLY:NWELLS,MXWELL,NWELVL,IPRWEL,NPWEL,
1 IWELPB,NNPWEL,WELAUX,WELL
C
CHARACTER*6 CWELL
C ------------------------------------------------------------------
CALL SGWF2WEL7PNT(IGRID)
C
C1----READ NUMBER OF WELLS (OR FLAG SAYING REUSE WELL DATA).
C1----AND NUMBER OF PARAMETERS
IF(NPWEL.GT.0) THEN
IF(IFREFM.EQ.0) THEN
READ(IN,'(2I10)') ITMP,NP
ELSE
READ(IN,*) ITMP,NP
END IF
ELSE
NP=0
IF(IFREFM.EQ.0) THEN
READ(IN,'(I10)') ITMP
ELSE
READ(IN,*) ITMP
END IF
END IF
C
C------Calculate some constants.
NAUX=NWELVL-5
IOUTU = IOUT
IF (IPRWEL.EQ.0) IOUTU=-IOUTU
C
C1A-----IF ITMP LESS THAN ZERO REUSE NON-PARAMETER DATA. PRINT MESSAGE.
C1A-----IF ITMP=>0, SET NUMBER OF NON-PARAMETER WELLS EQUAL TO ITMP.
IF(ITMP.LT.0) THEN
WRITE(IOUT,6)
6 FORMAT(1X,/
1 1X,'REUSING NON-PARAMETER WELLS FROM LAST STRESS PERIOD')
ELSE
NNPWEL=ITMP
END IF
C
C1B-----IF THERE ARE NEW NON-PARAMETER WELLS, READ THEM.
MXACTW=IWELPB-1
IF(ITMP.GT.0) THEN
IF(NNPWEL.GT.MXACTW) THEN
WRITE(IOUT,99) NNPWEL,MXACTW
99 FORMAT(1X,/1X,'THE NUMBER OF ACTIVE WELLS (',I6,
1 ') IS GREATER THAN MXACTW(',I6,')')
CALL USTOP(' ')
END IF
CALL ULSTRD(NNPWEL,WELL,1,NWELVL,MXWELL,1,IN,IOUT,
1 'WELL NO. LAYER ROW COL STRESS RATE',
2 WELAUX,20,NAUX,IFREFM,NCOL,NROW,NLAY,4,4,IPRWEL)
END IF
NWELLS=NNPWEL
C
C1C-----IF THERE ARE ACTIVE WELL PARAMETERS, READ THEM AND SUBSTITUTE
CALL PRESET('Q')
NREAD=NWELVL-1
IF(NP.GT.0) THEN
DO 30 N=1,NP
CALL UPARLSTSUB(IN,'WEL',IOUTU,'Q',WELL,NWELVL,MXWELL,NREAD,
1 MXACTW,NWELLS,4,4,
2 'WELL NO. LAYER ROW COL STRESS RATE',
3 WELAUX,20,NAUX)
30 CONTINUE
END IF
C
C3------PRINT NUMBER OF WELLS IN CURRENT STRESS PERIOD.
CWELL=' WELLS'
IF(NWELLS.EQ.1) CWELL=' WELL '
WRITE(IOUT,101) NWELLS,CWELL
101 FORMAT(1X,/1X,I6,A)
C
C6------RETURN
RETURN
END
SUBROUTINE GWF2WEL7FM(IGRID)
C ******************************************************************
C SUBTRACT Q FROM RHS
C ******************************************************************
C
C SPECIFICATIONS:
C ------------------------------------------------------------------
USE GLOBAL, ONLY:IBOUND,RHS,HCOF
USE GWFWELMODULE, ONLY:NWELLS,WELL
C ------------------------------------------------------------------
CALL SGWF2WEL7PNT(IGRID)
C
C1------IF NUMBER OF WELLS <= 0 THEN RETURN.
IF(NWELLS.LE.0) RETURN
C
C2------PROCESS EACH WELL IN THE WELL LIST.
DO 100 L=1,NWELLS
IR=WELL(2,L)
IC=WELL(3,L)
IL=WELL(1,L)
Q=WELL(4,L)
C
C2A-----IF THE CELL IS INACTIVE THEN BYPASS PROCESSING.
IF(IBOUND(IC,IR,IL).LE.0) GO TO 100
C
C2B-----IF THE CELL IS VARIABLE HEAD THEN SUBTRACT Q FROM
C THE RHS ACCUMULATOR.
RHS(IC,IR,IL)=RHS(IC,IR,IL)-Q
100 CONTINUE
C
C3------RETURN
RETURN
END
SUBROUTINE GWF2WEL7BD(KSTP,KPER,IGRID)
C ******************************************************************
C CALCULATE VOLUMETRIC BUDGET FOR WELLS
C ******************************************************************
C
C SPECIFICATIONS:
C ------------------------------------------------------------------
USE GLOBAL, ONLY:IOUT,NCOL,NROW,NLAY,IBOUND,BUFF
USE GWFBASMODULE,ONLY:MSUM,ICBCFL,IAUXSV,DELT,PERTIM,TOTIM,
1 VBVL,VBNM
USE GWFWELMODULE,ONLY:NWELLS,IWELCB,WELL,NWELVL,WELAUX
C
CHARACTER*16 TEXT
DOUBLE PRECISION RATIN,RATOUT,QQ
DATA TEXT /' WELLS'/
C ------------------------------------------------------------------
CALL SGWF2WEL7PNT(IGRID)
C
C1------CLEAR RATIN AND RATOUT ACCUMULATORS, AND SET CELL-BY-CELL
C1------BUDGET FLAG.
ZERO=0.
RATIN=ZERO
RATOUT=ZERO
IBD=0
IF(IWELCB.LT.0 .AND. ICBCFL.NE.0) IBD=-1
IF(IWELCB.GT.0) IBD=ICBCFL
IBDLBL=0
C
C2-----IF CELL-BY-CELL FLOWS WILL BE SAVED AS A LIST, WRITE HEADER.
IF(IBD.EQ.2) THEN
NAUX=NWELVL-5
IF(IAUXSV.EQ.0) NAUX=0
CALL UBDSV4(KSTP,KPER,TEXT,NAUX,WELAUX,IWELCB,NCOL,NROW,NLAY,
1 NWELLS,IOUT,DELT,PERTIM,TOTIM,IBOUND)
END IF
C
C3------CLEAR THE BUFFER.
DO 50 IL=1,NLAY
DO 50 IR=1,NROW
DO 50 IC=1,NCOL
BUFF(IC,IR,IL)=ZERO
50 CONTINUE
C
C4------IF THERE ARE NO WELLS, DO NOT ACCUMULATE FLOW.
IF(NWELLS.EQ.0) GO TO 200
C
C5------LOOP THROUGH EACH WELL CALCULATING FLOW.
DO 100 L=1,NWELLS
C
C5A-----GET LAYER, ROW & COLUMN OF CELL CONTAINING WELL.
IR=WELL(2,L)
IC=WELL(3,L)
IL=WELL(1,L)
Q=ZERO
C
C5B-----IF THE CELL IS NO-FLOW OR CONSTANT_HEAD, IGNORE IT.
IF(IBOUND(IC,IR,IL).LE.0)GO TO 99
C
C5C-----GET FLOW RATE FROM WELL LIST.
Q=WELL(4,L)
QQ=Q
C
C5D-----PRINT FLOW RATE IF REQUESTED.
IF(IBD.LT.0) THEN
IF(IBDLBL.EQ.0) WRITE(IOUT,61) TEXT,KPER,KSTP
61 FORMAT(1X,/1X,A,' PERIOD ',I4,' STEP ',I3)
WRITE(IOUT,62) L,IL,IR,IC,Q
62 FORMAT(1X,'WELL ',I6,' LAYER ',I3,' ROW ',I5,' COL ',I5,
1 ' RATE ',1PG15.6)
IBDLBL=1
END IF
C
C5E-----ADD FLOW RATE TO BUFFER.
BUFF(IC,IR,IL)=BUFF(IC,IR,IL)+Q
C
C5F-----SEE IF FLOW IS POSITIVE OR NEGATIVE.
IF(Q.GE.ZERO) THEN
C
C5G-----FLOW RATE IS POSITIVE (RECHARGE). ADD IT TO RATIN.
RATIN=RATIN+QQ
ELSE
C
C5H-----FLOW RATE IS NEGATIVE (DISCHARGE). ADD IT TO RATOUT.
RATOUT=RATOUT-QQ
END IF
C
C5I-----IF SAVING CELL-BY-CELL FLOWS IN A LIST, WRITE FLOW. ALSO
C5I-----COPY FLOW TO WELL LIST.
99 IF(IBD.EQ.2) CALL UBDSVB(IWELCB,NCOL,NROW,IC,IR,IL,Q,
1 WELL(:,L),NWELVL,NAUX,5,IBOUND,NLAY)
WELL(NWELVL,L)=Q
100 CONTINUE
C
C6------IF CELL-BY-CELL FLOWS WILL BE SAVED AS A 3-D ARRAY,
C6------CALL UBUDSV TO SAVE THEM.
IF(IBD.EQ.1) CALL UBUDSV(KSTP,KPER,TEXT,IWELCB,BUFF,NCOL,NROW,
1 NLAY,IOUT)
C
C7------MOVE RATES, VOLUMES & LABELS INTO ARRAYS FOR PRINTING.
200 RIN=RATIN
ROUT=RATOUT
VBVL(3,MSUM)=RIN
VBVL(4,MSUM)=ROUT
VBVL(1,MSUM)=VBVL(1,MSUM)+RIN*DELT
VBVL(2,MSUM)=VBVL(2,MSUM)+ROUT*DELT
VBNM(MSUM)=TEXT
C
C8------INCREMENT BUDGET TERM COUNTER(MSUM).
MSUM=MSUM+1
C
C9------RETURN
RETURN
END
SUBROUTINE GWF2WEL7DA(IGRID)
C Deallocate WEL MEMORY
USE GWFWELMODULE
C
CALL SGWF2WEL7PNT(IGRID)
DEALLOCATE(NWELLS)
DEALLOCATE(MXWELL)
DEALLOCATE(NWELVL)
DEALLOCATE(IWELCB)
DEALLOCATE(IPRWEL)
DEALLOCATE(NPWEL)
DEALLOCATE(IWELPB)
DEALLOCATE(NNPWEL)
DEALLOCATE(WELAUX)
DEALLOCATE(WELL)
C
RETURN
END
SUBROUTINE SGWF2WEL7PNT(IGRID)
C Change WEL data to a different grid.
USE GWFWELMODULE
C
NWELLS=>GWFWELDAT(IGRID)%NWELLS
MXWELL=>GWFWELDAT(IGRID)%MXWELL
NWELVL=>GWFWELDAT(IGRID)%NWELVL
IWELCB=>GWFWELDAT(IGRID)%IWELCB
IPRWEL=>GWFWELDAT(IGRID)%IPRWEL
NPWEL=>GWFWELDAT(IGRID)%NPWEL
IWELPB=>GWFWELDAT(IGRID)%IWELPB
NNPWEL=>GWFWELDAT(IGRID)%NNPWEL
WELAUX=>GWFWELDAT(IGRID)%WELAUX
WELL=>GWFWELDAT(IGRID)%WELL
C
RETURN
END
SUBROUTINE SGWF2WEL7PSV(IGRID)
C Save WEL data for a grid.
USE GWFWELMODULE
C
GWFWELDAT(IGRID)%NWELLS=>NWELLS
GWFWELDAT(IGRID)%MXWELL=>MXWELL
GWFWELDAT(IGRID)%NWELVL=>NWELVL
GWFWELDAT(IGRID)%IWELCB=>IWELCB
GWFWELDAT(IGRID)%IPRWEL=>IPRWEL
GWFWELDAT(IGRID)%NPWEL=>NPWEL
GWFWELDAT(IGRID)%IWELPB=>IWELPB
GWFWELDAT(IGRID)%NNPWEL=>NNPWEL
GWFWELDAT(IGRID)%WELAUX=>WELAUX
GWFWELDAT(IGRID)%WELL=>WELL
C
RETURN
END
|
#!/usr/bin/env python2
# WSI_MASK2: use OpenCV for faster operations.
from __future__ import (absolute_import, division, print_function, unicode_literals)
import os
import argparse as opt
import skimage.io
import skimage.external.tifffile
import numpy as np
from segm.tissue import tissue_region_from_rgb_fast
__version__ = 0.01
__author__ = 'Vlad Popovici'
def main():
p = opt.ArgumentParser(description="""
Produces a mask covering the tissue region in the image.
""")
p.add_argument('img_file', action='store', help='RGB image file')
p.add_argument('out_file', action='store', help='Tissue image after masking. Note that .tiff is added.')
p.add_argument('--prefix', action='store',
help='optional prefix for the result files: prefix_tissue_mask.jpeg',
default=None)
p.add_argument('--minarea', action='store', type=int,
help='object smaller than this will be removed',
default=150)
p.add_argument('--gth', action='store', type=int,
help='if provided, indicates the threshold in the green channel',
default=220)
p.add_argument('--ksize', action='store', type=int,
help='size of structuring element in fill gaps - depends on the magnification',
default=33)
p.add_argument('-m', '--mask', action='store_true', help='Should the mask be saved?')
args = p.parse_args()
base_name = os.path.basename(args.img_file).split('.')
if len(base_name) > 1: # at least 1 suffix .ext
base_name.pop() # drop the extension
base_name = '.'.join(base_name) # reassemble the rest of the list into file name
if args.prefix is not None:
pfx = args.prefix
else:
pfx = base_name
img = skimage.io.imread(args.img_file)
if img.ndim == 3:
# drop alpha channel
img = img[:,:,:3]
mask = tissue_region_from_rgb_fast(img, _min_area=args.minarea, _g_th=args.gth, _ker_size=args.ksize)
if img.ndim == 3:
img[np.logical_not(mask), :] = np.zeros(img.shape[2])
else:
img[np.logical_not(mask)] = 0
skimage.external.tifffile.imsave(args.out_file+'.tiff', img, compress=9, bigtiff=True)
if args.mask:
skimage.io.imsave(pfx+'_tissue_mask.jpeg', 255*mask.astype('uint8'))
return
# end main()
if __name__ == '__main__':
main()
|
using Documenter
using ReadCoverageDistributions
makedocs(
sitename = "ReadCoverageDistributions",
format = Documenter.HTML(prettyurls = true),
modules = [ReadCoverageDistributions]
)
# Documenter can also automatically deploy documentation to gh-pages.
# See "Hosting Documentation" and deploydocs() in the Documenter manual
# for more information.
deploydocs(
repo = "github.com:Dinesh-Adhithya-H/ReadCoverageDistributions.jl.git"
)
|
Require Import Common.
Set Implicit Arguments.
Set Asymmetric Patterns.
Set Universe Polymorphism.
(* Silly predicate that we can use to get Ltac to help us manipulate terms *)
Definition focus A (_ : A) := True.
(* This definition does most of the work of simplification. *)
Ltac simpl_definition_by_tac_and_exact defn tac :=
assert (Hf : focus defn) by constructor;
let defnH := head defn in try unfold defnH in Hf; try tac; simpl in Hf;
rewrite_eta_in Hf;
match type of Hf with
| focus ?V => exact V
end.
Ltac simpl_definition_by_exact defn := simpl_definition_by_tac_and_exact defn idtac.
(** To simplify something defined as [Ident'] of type [IdentT] into [Ident], do something like:
Definition Ident'' : IdentT.
simpl_definition_by_exact Ident'.
Defined.
(* Then we clean up a bit with reduction. *)
Definition Ident := Eval cbv beta iota zeta delta [Ident''] in Ident''.
*)
|
module PrimaryRecursive
# Write your package code here.
include("PRBase.jl")
include("arithmetic.jl")
export p1, p2, p3, PrimRec, succ, zro, Comb, Proj,
add, mult, pred, cosub, dff, sgn, nsgn, const1, remainder, ge,
ifel, square, floor_sqrt, traingle, pair, fib, fst, scd
end
|
# Characterization of Discrete Systems in the Time Domain
*This Jupyter notebook is part of a [collection of notebooks](../index.ipynb) in the bachelors module Signals and Systems, Comunications Engineering, Universität Rostock. Please direct questions and suggestions to [[email protected]](mailto:[email protected]).*
## Eigenfunctions
An [eigenfunction](https://en.wikipedia.org/wiki/Eigenfunction) of a discrete system is defined as the input signal $x[k]$ which produces the output signal $y[k] = \mathcal{H}\{ x[k] \} = \lambda \cdot x[k]$ with $\lambda \in \mathbb{C}$. The weight $\lambda$ associated with $x[k]$ is known as scalar eigenvalue of the system. Hence besides a weighting factor, an eigenfunction is not modified by passing through the system.
[Complex exponential signals](../discrete_signals/standard_signals.ipynb#Complex-Exponential-Signal) $z^k$ with $z \in \mathbb{C}$ are eigenfunctions of discrete linear time-invariant (LTI) systems. Let's assume a generic LTI system with input signal $x[k] = z^k$ and output signal $y[k] = \mathcal{H}\{ x[k] \}$. Due to the time-invariance of the system, the response to a shifted input signal $x(k-\kappa) = z^{k - \kappa}$ reads
\begin{equation}
y[k- \kappa] = \mathcal{H}\{ x[k - \kappa] \} = \mathcal{H}\{ z^{- \kappa} \cdot z^k \}
\end{equation}
Due to the linearity of the system this can be reformulated as
\begin{equation}
y[k- \kappa] = z^{- \kappa} \cdot \mathcal{H}\{ z^k \} = z^{- \kappa} \cdot y[k]
\end{equation}
If the complex exponential signal $z^k$ is an eigenfunction of the LTI system, the output
signal is a weighted exponential signal $y[k] = \lambda \cdot z^k$. Introducing $y[k]$ into the left- and right-hand side of above equation yields
\begin{equation}
\lambda z^k z^{- \kappa} = z^{- \kappa} \lambda z^k
\end{equation}
which obviously is fulfilled. This proves that the exponential signal $z^k$ is an eigenfunction of LTI systems.
**Example**
The output signal of the previously introduced [second-order recursive LTI system](difference_equation.ipynb#Second-Order-System) with the difference equation
\begin{equation}
y[k] - y[k-1] + \frac{1}{2} y[k-2] = x[k]
\end{equation}
is computed for a complex exponential signal $x[k] = z^k$ at the input. The output signal should be a weighted complex exponential due to above reasoning.
```python
%matplotlib inline
import numpy as np
from scipy import signal
import matplotlib.pyplot as plt
a = [1.0, -1.0, 1/2]
b = [1.0]
z = np.exp(0.02 + .5j)
k = np.arange(30)
x = z**k
y = signal.lfilter(b, a, x)
```
The real and imaginary part of the input and output signal is plotted.
```python
plt.figure(figsize=(10,8))
plt.subplot(221)
plt.stem(k, np.real(x))
plt.xlabel('$k$')
plt.ylabel(r'$\Re \{ x[k] \}$')
plt.subplot(222)
plt.stem(k, np.imag(x))
plt.xlabel('$k$')
plt.ylabel(r'$\Im \{ x[k] \}$')
plt.tight_layout()
plt.subplot(223)
plt.stem(k, np.real(y))
plt.xlabel('$k$')
plt.ylabel(r'$\Re \{ y[k] \}$')
plt.subplot(224)
plt.stem(k, np.imag(y))
plt.xlabel('$k$')
plt.ylabel(r'$\Im \{ y[k] \}$')
plt.tight_layout()
```
**Exercise**
* From the in- and output signal only, can we conclude that the system is LTI?
## Transfer Function
The complex eigenvalue $\lambda$ characterizes the properties of the transfer of a complex exponential signal $z^k$ with [complex frequency $z$](../discrete_signals/standard_signals.ipynb#Complex-Exponential-Signal) through a discrete LTI system. It is commonly termed as [*transfer function*](https://en.wikipedia.org/wiki/Transfer_function) and denoted by $H(z)=\lambda(z)$. Using this definition, the output signal $y[k]$ of an LTI system with complex exponential signal at the input reads
\begin{equation}
y[k] = \mathcal{H} \{ z^k \} = H(z) \cdot z^k
\end{equation}
Note that the concept of the transfer function is directly linked to the linearity and time-invariance of a system. Only in this case, complex exponential signals are eigenfunctions of the system and $H(z)$ describes the properties of an LTI system with respect to these.
Above equation can be rewritten in terms of the magnitude $| H(z) |$ and phase $\varphi(z)$ of the complex transfer function $H(z)$
\begin{equation}
y[k] = | H(z) | \cdot z^k = | H(z) | \cdot e^{\Sigma k + j \Omega k + j \varphi(z)}
\end{equation}
where $z = e^{\Sigma + j \Omega}$ has been substituted to derive the last equality. The magnitude $| H(z) |$ provides the frequency dependent attenuation of the eigenfunction $z^k$ by the system, while $\varphi(z)$ provides the phase-shift introduced by the system.
## Link between Transfer Function and Impulse Response
In order to establish a link between the transfer function $H(z)$ and the impulse response $h[k]$, the output signal $y[k] = \mathcal{H} \{ x[k] \}$ of an LTI system with input signal $x[k]$ is computed. It is given by convolving the input signal with the impulse response
\begin{equation}
y[k] = x[k] * h[k] = \sum_{\kappa = -\infty}^{\infty} x[k-\kappa] \cdot h[\kappa]
\end{equation}
For a complex exponential signal as input $x[k] = z^k$ the output of the LTI system is given as $y[k] = \mathcal{H} \{ z^k \} = H(z) \cdot z^k$. Introducing both signals into the left- and right-hand side of the convolution yields
\begin{equation}
H(z) \cdot z^k = \sum_{\kappa = -\infty}^{\infty} z^k \, z^{- \kappa} \cdot h[\kappa]
\end{equation}
which after canceling out $z^k$ results in
\begin{equation}
H(z) = \sum_{\kappa = -\infty}^{\infty} h[\kappa] \cdot z^{- \kappa}
\end{equation}
The transfer function $H(z)$ can be computed from the impulse response by summing over the impulse response $h[k]$ multiplied with the complex exponential function $z^k$. This constitutes a transformation, which is later introduced in more detail as [$z$-transform](https://en.wikipedia.org/wiki/Z-transform).
**Copyright**
This notebook is provided as [Open Educational Resource](https://en.wikipedia.org/wiki/Open_educational_resources). Feel free to use the notebook for your own purposes. The text is licensed under [Creative Commons Attribution 4.0](https://creativecommons.org/licenses/by/4.0/), the code of the IPython examples under the [MIT license](https://opensource.org/licenses/MIT). Please attribute the work as follows: *Sascha Spors, Continuous- and Discrete-Time Signals and Systems - Theory and Computational Examples*.
|
-- The bug documented below was exposed by the fix to issue 274.
module Issue274 where
open import Common.Level
record Q a : Set (a ⊔ a) where
record R a : Set a where
field q : Q a
A : Set₁
A = Set
postulate
ℓ : Level
r : R (ℓ ⊔ ℓ)
foo : R ℓ
foo = r
-- Issue274.agda:32,7-8
-- ℓ ⊔ ℓ !=< ℓ of type Level
-- when checking that the expression r has type R ℓ
|
module CLaSH.Default
class Default a where
def : a
instance Default Int where
def = 0
instance Default Integer where
def = 0
|
[GOAL]
ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : Group α
inst✝² : CommSemigroup β
inst✝¹ : LE β
inst✝ : SubmultiplicativeHomClass F α β
f : F
a b : α
⊢ ↑f a ≤ ↑f b * ↑f (a / b)
[PROOFSTEP]
simpa only [mul_comm, div_mul_cancel'] using map_mul_le_mul f (a / b) b
[GOAL]
ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : Group α
inst✝² : AddCommSemigroup β
inst✝¹ : LE β
inst✝ : MulLEAddHomClass F α β
f : F
a b : α
⊢ ↑f a ≤ ↑f b + ↑f (a / b)
[PROOFSTEP]
simpa only [add_comm, div_mul_cancel'] using map_mul_le_add f (a / b) b
[GOAL]
ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : Group α
inst✝² : CommSemigroup β
inst✝¹ : LE β
inst✝ : SubmultiplicativeHomClass F α β
f : F
a b c : α
⊢ ↑f (a / c) ≤ ↑f (a / b) * ↑f (b / c)
[PROOFSTEP]
simpa only [div_mul_div_cancel'] using map_mul_le_mul f (a / b) (b / c)
[GOAL]
ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : Group α
inst✝² : AddCommSemigroup β
inst✝¹ : LE β
inst✝ : MulLEAddHomClass F α β
f : F
a b c : α
⊢ ↑f (a / c) ≤ ↑f (a / b) + ↑f (b / c)
[PROOFSTEP]
simpa only [div_mul_div_cancel'] using map_mul_le_add f (a / b) (b / c)
[GOAL]
ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝² : Group α
inst✝¹ : OrderedAddCommMonoid β
inst✝ : GroupSeminormClass F α β
f : F
x y : α
⊢ ↑f (x / y) ≤ ↑f x + ↑f y
[PROOFSTEP]
rw [div_eq_mul_inv, ← map_inv_eq_map f y]
[GOAL]
ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝² : Group α
inst✝¹ : OrderedAddCommMonoid β
inst✝ : GroupSeminormClass F α β
f : F
x y : α
⊢ ↑f (x * y⁻¹) ≤ ↑f x + ↑f y⁻¹
[PROOFSTEP]
exact map_mul_le_add _ _ _
[GOAL]
ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝² : Group α
inst✝¹ : OrderedAddCommMonoid β
inst✝ : GroupSeminormClass F α β
f : F
x y : α
⊢ ↑f (x / y) = ↑f (y / x)
[PROOFSTEP]
rw [← inv_div, map_inv_eq_map]
[GOAL]
ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝² : Group α
inst✝¹ : OrderedAddCommMonoid β
inst✝ : GroupSeminormClass F α β
f : F
x y : α
⊢ ↑f x ≤ ↑f y + ↑f (y / x)
[PROOFSTEP]
simpa only [add_comm, map_div_rev, div_mul_cancel'] using map_mul_le_add f (x / y) y
[GOAL]
ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝² : Group α
inst✝¹ : LinearOrderedAddCommGroup β
inst✝ : GroupSeminormClass F α β
f : F
x y : α
⊢ |↑f x - ↑f y| ≤ ↑f (x / y)
[PROOFSTEP]
rw [abs_sub_le_iff, sub_le_iff_le_add', sub_le_iff_le_add']
[GOAL]
ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝² : Group α
inst✝¹ : LinearOrderedAddCommGroup β
inst✝ : GroupSeminormClass F α β
f : F
x y : α
⊢ ↑f x ≤ ↑f y + ↑f (x / y) ∧ ↑f y ≤ ↑f x + ↑f (x / y)
[PROOFSTEP]
exact ⟨le_map_add_map_div _ _ _, le_map_add_map_div' _ _ _⟩
[GOAL]
ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝² : Group α
inst✝¹ : LinearOrderedAddCommMonoid β
inst✝ : GroupSeminormClass F α β
src✝ : GroupSeminormClass F α β := inst✝
f : F
a : α
⊢ 0 ≤ 2 • ↑f a
[PROOFSTEP]
rw [two_nsmul, ← map_one_eq_zero f, ← div_self' a]
[GOAL]
ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝² : Group α
inst✝¹ : LinearOrderedAddCommMonoid β
inst✝ : GroupSeminormClass F α β
src✝ : GroupSeminormClass F α β := inst✝
f : F
a : α
⊢ ↑f (a / a) ≤ ↑f a + ↑f a
[PROOFSTEP]
exact map_div_le_add _ _ _
[GOAL]
ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝² : Group α
inst✝¹ : OrderedAddCommMonoid β
inst✝ : GroupNormClass F α β
f : F
x : α
⊢ x = 1 → ↑f x = 0
[PROOFSTEP]
rintro rfl
[GOAL]
ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝² : Group α
inst✝¹ : OrderedAddCommMonoid β
inst✝ : GroupNormClass F α β
f : F
⊢ ↑f 1 = 0
[PROOFSTEP]
exact map_one_eq_zero _
|
import numpy as np
from sklearn.base import BaseEstimator, TransformerMixin
class KnockoffsGenerator(BaseEstimator, TransformerMixin):
"""
Base class for all knockoff generators.
They must implement the functions fit and transform.
"""
def __init__(self):
pass
def fit(self, X: np.ndarray, y: np.ndarray = None):
raise NotImplementedError
def transform(self, X: np.ndarray, y: np.ndarray = None):
raise NotImplementedError
def __call__(self, *args, **kwargs):
return self.transform(*args, **kwargs)
|
\documentclass[12pt, oneside]{article} % use "amsart" instead of "article" for AMSLaTeX format
\usepackage[margin=1.25in]{geometry}
\geometry{a4paper} % ... or a4paper or a5paper or ...
%\geometry{landscape} % Activate for rotated page geometry
%\usepackage[parfill]{parskip} % Activate to begin paragraphs with an empty line rather than an indent
\usepackage{graphicx} % Use pdf, png, jpg, or eps with pdflatex; use eps in DVI mode
% TeX will automatically convert eps --> pdf in pdflatex
\usepackage{amsmath}
\usepackage{mathptmx}
\usepackage{mathtools}
\usepackage{amssymb} % so we can use the 'pretty' empty set
\usepackage{tipa}
\usepackage{graphicx} % purdy pitchers
\graphicspath{{diagrams/}}
\usepackage{algorithmic}
\usepackage{phonrule}
\usepackage{ragged2e}
\setlength{\RaggedRightParindent}{\parindent}
\usepackage[compact]{titlesec}
\usepackage{titling}
\usepackage{caption}
\usepackage{tikz-qtree}
\usepackage{tikz}
\usetikzlibrary{shapes,snakes}
\usetikzlibrary{automata,positioning,calc}
\tikzset{
double arrow/.style args={#1 colored by #2 and #3}{
-stealth,line width=#1,#2, % first arrow
postaction={draw,-stealth,#3,line width=(#1)/3,
shorten <=(#1)/3,shorten >=2*(#1)/3}, % second arrow
}
}
%% Make footnotes endnotes
%\usepackage{endnotes}
%\let\footnote=\endnote
%
%% Move figures and tables to end
%\usepackage[nomarkers,nolists,noheads]{endfloat}
\usepackage{cite}
\usepackage{apacite}
\usepackage[section]{placeins}
\usepackage{subfig}
\usepackage{setspace}
% Reduce in-text citations to 'et al' when there are more than 2 authors
\makeatletter
\usepackage{regexpatch}
\xpatchcmd{\@@cite}{\def\BCA##1##2{{\@BAstyle ##1}}}{\def\BCA##1##2{{\@BAstyle ##2}}}{}{}
\makeatother
\newtheorem{definition}{Definition}
\newenvironment{clump}
{
\edef\myindent{\the\parindent}
\noindent\begin{minipage}{\textwidth}
\setlength\parindent{\myindent}\fussy
}
{
\end{minipage}
}
\newcommand{\featmat}[1]
{$[$#1$]$}
%{$\begin{bsmallmatrix*}[l]\text{\normalsize #1}\end{bsmallmatrix*}$}
\newcommand{\featmattwo}[2]{$\begin{bsmallmatrix*}[l]\text{\normalsize #1}\\\text{\normalsize #2}\end{bsmallmatrix*}$}
% make the section headings more compact
\titleformat{\section}{\normalsize\bfseries}{\thesection}{1em}{}
\titleformat{\subsection}{\normalsize\itshape}{\thesubsection}{1em}{}
% make title more compact
\pretitle{\vspace*{-3\baselineskip}\begin{center}\bfseries}
\posttitle{\par\end{center}}
\preauthor{\begin{center}}
\postauthor{\par\end{center}}
\predate{}
\postdate{\vspace*{-0.15\baselineskip}}
\makeatletter
\def\blfootnote{\gdef\@thefnmark{}\@footnotetext}
\makeatother
\doublespacing
\title{A method for projecting features from observed sets of phonological classes}
\author{
Connor Mayer \hspace{20pt} Robert Daland
}
\date{\vspace{-4ex}} % Activate to display a given date or no date
\begin{document}
\RaggedRight
\maketitle
\begin{abstract}
\noindent \textbf{Abstract:} Given a set of phonological features, we can enumerate a set of phonological classes. Here we consider the inverse of this problem: given a set of phonological classes, can we derive a feature system? We show that this is indeed possible, using a collection of algorithms that assign features to a set of input classes and differ in terms of what types of features are permissible. This work bears on theories of both language-specific and universal features, provides testable predictions of the featurizations available to learners, and serves as a useful component in computational models of feature learning.\\
\noindent \textbf{Keywords}: Phonological features, feature learning, underspecification, computational phonology
\blfootnote{* This research was supported by the Social Sciences and Humanities Research Council of Canada Doctoral Award to the first author. Thanks to Bruce Hayes, Tim Hunter, Kie Zuraw, and the members of the UCLA phonology seminar for their feedback and guidance. All mistakes are our own. Supplemental material can be found at https://github.com/connormayer/featurizer.}
\end{abstract}
% LIST OF FIGURES
% TODO: Move figures to end of document...
% Fig. 1 (done) -- A manner hierarchy class system
% Fig. 2 (done) -- A vowel inventory and intersectional closure
% Fig. 3 (done) -- Yield of the privative specification algorithm (to vowel inventory)
% Fig. 4 (done) -- Yield of the contrastive underspecification algorithm (to vowel inventory)
% Fig. 5 (done) -- Class system and featurization yielded by contrastive specification.
% Fig. 6 (done) -- Class system and featurization yielded by full specification.
% Fig. 7 (done) -- Big alphabet (contrastive underspecification with privative, binary, and ternary features)
% Fig. 8 (done) -- Simple class system to illustrate BFS
% Fig. 9 (done) -- Featurization of simple class system without and with BFS
% Fig. 10 (done) -- Simple class system to illustrate sibling ordering considerations
% Fig. 11 (done) -- Featurization of simple class system if siblings are processed in arbitrary order, or simultaneously.
% Fig. 12 (done) -- Topological plot of the contrastive specification vowel inventory output.
% Fig. 13 (done) -- Topological plot of the full specification vowel inventory output.
\section{Introduction}
\label{sec:intro}
Features are the substantive building blocks of phonological theory. They represent phonetic qualities of speech sounds, and can be used in isolation or combination to describe individual sounds or classes of sounds \cite<e.g.,>{JakobsonEtAl1952, ChomskyHalle1968, Clements1985}.
The goals of feature theory are to capture the following generalizations. First, segments that have common phonetic properties tend to behave alike, both within and across languages. Features allow such commonalities between sounds to be explicitly represented. For example, the English voiceless non-continuants \{p, t, \textipa{\t{tS}}, k\} are all produced with a complete closure of the oral cavity and no vocal fold vibration, and exactly these segments undergo the process of foot-initial aspiration. The feature notation \featmattwo{--continuant}{--voice} exposes these shared phonetic properties to the phonological grammar, and the processes which might reference them. More generally, the set of obstruents, which may be specified with the feature \featmat{--sonorant}, tends to undergo similar voicing processes across languages (regressive voicing assimilation within obstruent clusters, word-final devoicing, intervocalic and/or postnasal voicing, etc.).
Common behavior among phonetically similar segments also extends diachronically. For example, the Wakashan language Ditidaht underwent a sound change where all nasal consonants became oral \cite{ThompsonThompson1972}. The feature notation \featmat{+nasal} allows the set of sounds that participated in this change to be specified.
Second, sound changes often preserve phonetic qualities of affected sounds, even when the host segment is altered or destroyed. The sub-segmental representation afforded by features allows these changes to be modeled in a principled way. An instance of feature preservation was the fall of the yers in Old Church Slavonic. The front yer (a short, unstressed, high front vowel) deleted in most prosodic positions. However, the preceding consonant typically became palatalized, preserving the high and front articulations even while the vowel segment was deleted \cite{Carlton1991}.
Finally, feature theory reflects featural economy in the segmental inventory: if a language treats a particular featural contrast as distinctive, it is likely to be exploited widely throughout its inventory. In other words, segment inventories are more symmetric than might be expected if segments were the atoms of representation \cite{Ohala1980, Maddieson1985, SchwartzEtAl1997, Clements2003}.
Classic texts \cite<e.g.,>{ChomskyHalle1968} have assumed phonological features are \textit{universal}: all the sounds in the world's languages can be described by the same finite set of features, which reflect properties of the human vocal tract and perceptual system. According to this view, speakers inherently produce and perceive speech in terms of these features because they are the substantive `atoms' of which segments and higher prosodic constituents are composed. Children represent speech in terms of these atoms, which is why phonological processes operate on the classes they define. Feature theory is manifestly successful in explaining why many common phonological processes involve segments that share relevant phonetic properties.
However, there is evidence that many phonological processes target sets of segments that cannot be singled out by a set of phonetic properties. A canonical example is the \textit{ruki} rule of Sanskrit, in which an underlying /s/ becomes retroflexed when it occurs later in a word than any of \{r, u, k, i\} \cite<e.g.,>{Kiparsky1973, Vennemann1974}. It has been proposed that the \textit{ruki} process originated from the acoustic effects of these segments on neighboring sounds, e.g., a lowering of the noise frequency of a following /s/ \cite{Longerich1998}. However, no conventional feature system can pick out all four of these segments to the exclusion of others. A more recent example is given by \citeA{Gallagher2019}, who provides compelling corpus and experimental evidence that the voiced uvular fricative /\textinvscr/ patterns as a voiceless stop in Cochabamba Quechua.
%The existence of a single, idiosyncratic rule like this is not grounds for theoretical concern. However, it has been proposed that \textit{phonetically disparate classes} like \{r, u, k, i\} are much more common than would be expected under a universal feature system. \citeA{Mielke2008} conducted a survey of phonological processes in almost 600 languages. Of the classes which underwent or conditioned a phonological process, 71\% could be expressed as a combination of simple features by the `best' feature system he considered. To express the remaining 29\%, additional theoretical mechanisms -- such as building classes through an \textsc{OR} operation -- would be needed. These seriously compromise the explanatory power that made feature theory appealing in the first place.
%The purported ubiquity of phonetically disparate classes has generated proposals that features are \textit{learned} and \textit{language-specific} \cite<e.g.,>{Blevins2004, Mielke2008, MacWhinneyOGrady2015, ArchangeliPulleyblank2015}: learners are able to group sounds in their languages into classes, even if they have no phonetic commonality. The striking regularities that exist across languages are explained as by-products of general human cognitive capabilities, such as categorization, sensitivity to frequency, and the ability to generalize, as well as the properties of the human vocal tract and auditory system that shape language change.
%It is still unclear whether the problematic classes identified by Mielke and others can be captured by other means. It is possible that classes which superficially appear to be phonetically disparate result from interactions between phonological processes that target phonetically coherent classes. Alternatively, these classes may share phonetic similarities that have not yet been formalized in any feature system. Even if these issues are put aside, well established problems like the variable patterning of /l/ as \phonfeat{$+$continuant} or \phonfeat{$-$continuant} across languages \cite<e.g.,>{Kaisse2002, Mielke2008} suggest that features may be learned to some degree, or, at the very least, it is not a simple matter to enumerate the available features in advance.
While the existence of a small number of idiosyncratic cases such as these is not grounds for theoretical concern, it has been proposed that phonetically disparate classes are fairly common. \citeA{Mielke2008} conducted a survey of phonological processes in almost 600 languages. Of the classes that underwent or conditioned a phonological process, 71\% could be expressed as a combination of simple features by the ‘best’ feature system he considered. It is unclear whether the remaining 29\% can be captured by other means. A formal mechanism which generates new classes with an \textsc{OR} operation suffices for most (but not all) of these classes. However, this would seriously compromise the explanatory power that makes feature theory attractive.
It may be the case that classes which superficially appear to be phonetically disparate result from interactions between phonological processes that target phonetically coherent classes. Only a better understanding of the data will clarify this point.
Alternatively, these classes may share phonetic similarities that have not yet been formalized in any feature system, as was suggested for ruki above. This is related to another challenge for universal feature theory: variable patterning. For example, /l/ behaves as \featmat{+continuant} in some languages, and as \featmat{--continuant} in others \cite<e.g.,>{Kaisse2002, Mielke2008}. If we wish to maintain that features are universal and that the same segment should have the same featural specification across languages, then perhaps what is needed is to divide \featmat{continuant} into two features: something like \featmat{midsagittal continuant} and \featmat{parasagittal continuant}.
Although it may be possible in this way to exhaustively enumerate all phonetic dimensions that languages use to characterize classes or phonemic contrasts, this is probably not a straightforward task. How many additional features would we require to completely account for the classes that current feature systems cannot characterize? Furthermore, it is unclear whether this kind of featural cartography is useful for models of individual speakers' linguistic acquisition and competence. That is, although there may be many phonetic dimensions along which sounds can be grouped, not all of these are salient in every language. Thus the learner must not only identify phonetic commonalities between sounds, but also discover which of these dimensions are phonologically active in their language when constructing their phonological grammar. Simply enumerating features does not provide insight into this process.
Considerations such as these have resulted in proposals that distinctive features are \textit{learned} and \textit{language-specific} \cite<e.g.,>{Blevins2004, Mielke2008, MacWhinneyOGrady2015, ArchangeliPulleyblank2015, ArchangeliPulleyblank2018}. These proposals generally maintain that learners organize their phonological grammars using symbolic feature systems. Instead of starting with a universal feature system and mapping sounds they encounter onto it, however, learners derive their feature system from perceived similarities between sounds in their language.
Crucially, this means that features may be defined across modalities. In general, phonological classes tend to converge in their acoustic, articulatory, and distributional properties, providing robust evidence to the learner. For example, high vowels may be associated with a high tongue position, a low F1, and distributional properties such as phonotactic restrictions, the conditioning of processes such as affrication, and so on. Theories of learned features do not assign primacy to any one of these dimensions, but suggest that the learner makes use of a range of available information to identify classes. This entails that phonological classes need not be defined in terms of their phonetic properties, nor must a phonetic distinction necessarily give rise to a phonological class. Thus the primary role of features becomes to identify and distinguish classes of sounds \cite<cf., e.g.,>[who adopt this conception of features for a universal set]{Dresher2003, Hall2007}. The striking commonalities in feature systems across languages may be explained as by-products of general human cognitive capabilities, such as categorization, sensitivity to frequency, and the ability to generalize, as well as the properties of the human vocal tract and auditory system.
The primary goals of this paper are to address one part of the question of what a phonological feature learning system would look like under this theory, and to provide a computational implementation of such a system. We assume that the learner has converged on a segmental representation of their language \cite<e.g.,>{Lin2005, FeldmanEtAl2013}, and that some mechanism has identified particular sets of segments as `candidate' classes (e.g., based on acoustic, articulatory, or distributional similarity, etc.). These classes serve as the input from which a phonological feature system is learned. We adopt this approach because it is unclear how features could be learned without being somehow motivated by the classes they characterize. Past attempts at unsupervised learning of phonological categories are similar, making no a priori assumptions about features, but rather deriving classes from the phonetic or distributional properties of segments \cite<e.g.,>{Lin2005, GoldsmithXanthos2009, Calderone2009, MayerSubmitted}. More will be said about this in Section~\ref{sec:assumptions}. Proceeding beyond classes to a feature system is motivated by the generalizations given at the beginning of this section.
We will illustrate how a feature system can be learned from an arbitrary input, i.e., without any reference to the phonetic properties of the segments contained in the input classes. Section \ref{sec:assumptions} briefly expands on some of the basic assumptions outlined above about how these input classes are determined, and exactly which aspects of phonological learning we will address. In Section \ref{sec:definitions}, we formalize our notation for feature systems. This notation and the lattice-like structures it motivates are similar to past work such as \citeA{Broe1993}, although we provide a more detailed formalism, which aids in proofs of some interesting properties. In particular, the notion of \textit{parenthood} in these structures is crucially important for deriving feature systems. Section \ref{sec:intersectional} describes the \textit{intersectional closure} of a set of classes, which is necessarily generated by any featurization sufficient to characterize that set. Relying on key properties of the intersectional closure, Section \ref{sec:algorithm_intro} describes a suite of algorithms for learning various types of featurizations for a set of input classes and demonstrates their operation on a simple class system. Section \ref{sec:theoretical_implications} then illustrates these featurizations on a more realistic vowel system, and discusses the theoretical predictions of each. Finally, in Section \ref{sec:discussion} we analyze some tradeoffs between the featurization algorithms, and discuss implications for feature theory and feature learning.
This paper makes several contributions. First, it demonstrates a method for working backwards to feature systems that underpin learned classes of sounds. Second, it provides a detailed formalization of feature systems in general. This allows careful reasoning about the expressiveness of such featurizations.
Third, by comparing multiple types of featurizations, this work makes explicit predictions about what classes should be describable under each. This is of interest even for theories of universal features, as it generates precise empirical predictions about the properties of the featurizations used by humans. In particular, it provides a deterministic method for identifying phonological underspecification. For example, the full specification algorithm predicts that the class of all non-nasal sounds should be available to speakers as a byproduct of the nasal class, which suggests that participants in an artificial grammar learning experiment \cite<AGL; e.g.,>{MoretonPater2012} should be able to effectively learn patterns involving this class. The other featurization methods to be discussed do not make this prediction. Comparison of the predictions made by the models in this paper, past phonological analyses, and the results of AGL studies has the potential to settle some of the longstanding controversies associated with underspecification \cite{Steriade1995}.
Finally, it provides the code\footnote{https://github.com/connormayer/featurizer} for use and extension in future research and models. In principle, a system that learns features from classes allows for the construction of a computational model that takes (minimally) a segmental corpus or some phonetic properties of segments as input and outputs a featurization of the inventory. This paper describes the final stage of such a model, and may be effectively combined with past approaches that derive phonological classes from distributional or phonetic similarity \cite<e.g.,>{Lin2005, GoldsmithXanthos2009, Calderone2009, MayerSubmitted}.
\FloatBarrier
\section{On the assumptions and scope of this paper}
\label{sec:assumptions}
Some readers might find problematic the assumption that a symbolic feature system is derived from classes of sounds that have been identified by the learner based on phonetic or distributional properties. A schematic representation of this learning model is shown in Fig.~\ref{fig:learning_model}. This model is a departure from the standard assumption that a universal set of features determines all possible phonological classes, and accordingly it shifts much of the work of phonological learning onto identification of these input classes.
\begin{figure}[htb!]
\centering
\begin{tikzpicture}[node distance=2cm, ->, >=stealth]
\tikzstyle{input} = [rectangle, rounded corners, minimum width=3cm, minimum height=1cm,text centered, draw=black]
\tikzstyle{output} = [ellipse, minimum width=3cm, minimum height=1cm,text centered, draw=black]
\node (phonetics)[input] at (0, 0) {Phonetics};
\node (distribution)[input] at (0, 2) {Distribution};
\node (classes)[output] at (4, 1) {Classes};
\node (features)[output] at (8, 1) {Features};
\draw [->, out=0, in=-150, line width = 1] (phonetics) edge (classes);
\draw [->, out=0, in=150, line width = 1] (distribution) edge (classes);
\draw [double arrow = 4pt colored by black and red] (classes) -- (features);
\end{tikzpicture}
\caption{A schematic representation of the model of feature learning assumed here. This paper focuses on the red arrow between `classes' and `features'.}
\label{fig:learning_model}
\end{figure}
We believe that this shift is motivated. Rather than constructing models that generate the typology and subsequently concerning ourselves with the exceptions, we think that deeper insights into speech may be gained by focusing on the mechanisms by which learners identify common properties between sounds in their language, and how these mechanisms contribute to the typological patterns we see.
Models of phonological class learning have been presented for various modalities. We are not aware of any proposals to date which have been fleshed out enough to be carefully tested, and which have proven empirically adequate. For example, \citeA{Lin2005} showed that unsupervised clustering on acoustic data was able to distinguish manner of articulation well, but not place. Conversely, unsupervised clustering on articulatory data is better able to distinguish place features, but poor at manner \cite{Mielke2012}. Such phonetically-based methods are able (in principle) to identify features corresponding to acoustic, articulatory, or perceptual properties, but these provide limited insights into the phonetically disparate classes described in the introduction, and into which classes are phonologically active in a particular language.
Conversely, while distributional approaches \cite<e.g.,>{GoldsmithXanthos2009,Calderone2009,MayerSubmitted} have the potential (in principle) to identify both phonetically coherent and phonetically disparate classes to the extent that they are reflected in their distribution, they are blind to the phonetic properties that inform speakers' intuitions about similarities between sounds, and suffer from the presence of distributional noise.
It seems likely to us that progress towards understanding how classes are learned will come from integrating multiple sources of information, with phonetic information providing an outline of possible classes, and distributional information shedding additional light on whether and how these classes (and possibly others) are used in a language. We see potential in methods like those described in a related paper by \citeA{MayerSubmitted}, which uses a combination of vector embedding (representing sounds numerically as points in space based on their distributional properties), Principal Component Analysis, and clustering algorithms to explicitly extract classes from a corpus. Incorporating phonetic information with distributional information may improve the performance of such models. Alternatively, a Bayesian approach, where phonetic similarity serves as an initial prior on segmental classes and considerations of their distribution inform the likelihood function, may also hold promise. A challenge for the extraction of classes from phonetic data is that classes of sounds are almost always similar only on a subset of phonetic dimensions (e.g., sonorants are articulatorily heterogeneous, but have similar acoustic properties), and the use of dimensionality reduction techniques such as Principal Component Analysis is likely to be useful in teasing apart these sources of coherence.
In any case, what must be initially identified under models that assume learned and language-specific features are \textit{classes}, with features subsequently derived from their relation. Although we see the question of how phonological classes are learned as one of great interest, the focus of this paper is on how a symbolic feature system can be derived once these classes are learned (the bold, red arrow in Fig.~\ref{fig:learning_model}). In the examples presented below, we assume that the set of input classes has been generated by mechanisms such as those just described, and focus instead on how a feature system can be derived from that set. For expositional purposes, we generally use simple, fabricated class systems, though we try to make these linguistically plausible.
Because of the relatively narrow focus of this paper, it is in many ways a stepping stone towards larger research goals. The algorithms described below make concrete predictions about questions such as where underspecification should occur, to what extent generalization occurs in feature learning, and what the feature systems of languages with phonetically disparate classes might look like. These predictions can be tested using standard phonological methods, such as AGL experiments, wug tests, corpus work, etc., as well as by revisiting the existing literature. This work, while interesting and important, is well beyond the scope of the current paper. We instead limit ourselves to carefully describing the formal properties and predictions of this approach to feature learning, while pointing out possible applications to future research. Though we hope the formal results presented here are interesting in their own right, we are equally hopefully that they may serve as useful tools in more general phonological research.
\FloatBarrier
\section{Definitions and notation}
\label{sec:definitions}
We will begin by providing a detailed notation for feature systems. This will allow us to prove several properties of these systems that are crucial for the operation of the featurization algorithms described in later sections.
\subsection{Class systems}
Let $\Sigma$ denote an alphabet of segments. We use the term \textit{class} to mean a subset of $\Sigma$.
\vspace{0.5\baselineskip} \noindent \textbf{Definition}: A \textit{class system} $(C, \Sigma)$ consists of an alphabet $\Sigma$ and a set of classes $C$ over that alphabet.
\vspace{0.5\baselineskip} \noindent A simple class system, meant to evoke a manner class system, is shown in Table~\ref{table:manner_system}.
\begin{table}[htb!]
\centering
\begin{tabular}{|l|l|}
\hline
\textit{alphabet} & \{V, G, L, N, T\} \\
\hline
\textit{sonorants} & \{V, G, L, N\} \\
\hline
\textit{non-continuants} & \{N, T\} \\
\hline
\textit{continuants} & \{V, G, L\} \\
\hline
\textit{singletons} & \{V\}, \{G\}, \{L\}, \{N\}, \{T\} \\
\hline
\end{tabular}
\caption{Manner hierarchy class system}
\label{table:manner_system}
\end{table}
\subsection{Feature systems}
\textbf{Definition}: A \textit{feature system} is a tuple $(F, \Sigma, V)$ where
\begin{itemize}
\item $\Sigma$ is a segmental alphabet,
\item $V$ is a set of values, and
\item $F$ is a \textit{featurization}: a set of features $\{f_j\}_{j=1}^M$, where each feature is a function $f: \Sigma \rightarrow V$ mapping segments to feature values.
\end{itemize}
A possible feature system for the manner system in Table~\ref{table:manner_system} is shown in Table~\ref{table:featurization}.
\begin{table}[h]
\centering
\begin{tabular} {|c||c|c|c|c|}
\hline
$\sigma$ & syl & cons & apprx & son \\ \hline
V & + & -- & + & + \\
G & -- & -- & + & + \\
L & -- & + & + & + \\
N & -- & + & -- & + \\
T & -- & + & -- & -- \\
\hline
\end{tabular}
\caption{Example of a feature system. Rows represent segments, columns represent feature functions, and cells represent feature function values for each segment.}
\label{table:featurization}
\end{table}
\subsection{Featural descriptors}
Featural descriptors relate class and feature systems. Let $(F, \Sigma, V)$ be a feature system. We restrict $V$ to the following possibilities, whose names are intended to invoke ideas from the research literature on underspecification \cite<e.g.,>{Archangeli1988}:
\begin{itemize}
\item \textit{privative specification}: $V = \{ +, 0 \}$
\item \textit{full specification}: $V = \{ +, - \}$
\item \textit{contrastive specification}: $V = \{ +, -, 0 \}$
\end{itemize}
\noindent We will use the notation $V_{spec}$ for the set $V \setminus \{0\}$, where $\setminus$ is the set difference operator. Thus $V_{spec}$ is the value set minus the zero value, or the set of non-zero values. This is because zero values are a formal mechanism to achieve underspecification, and the theoretical driver for underspecification is the idea that underspecified features are phonologically inactive (i.e., cannot define classes). Then, a \textit{featural descriptor} $\mathbf{d}$ is a set of feature/value pairs where the values cannot be $0$: i.e., $\mathbf{d} \subset V_{spec} \times F$ (where $V_{spec} \times F$ is the set of all pairs $(v,f)$ where $v \in V_{spec}$ and $f \in F$).
For example, $\mathbf{d} =$ \featmattwo{--cons}{+son} is a featural descriptor. This is an \textit{intensional} description of a class; that is, a description of a class in terms of its properties. The \textit{extension} of a featural descriptor is the set of segments which match (at least) the feature/value pairs in the descriptor. We use angle brackets to indicate this:
$$ \big \langle \mathbf{d} \big \rangle = \{x \in \Sigma \, \mid \, \forall (\alpha_k, f_k) \in \mathbf{d} \text{, } [ f_k(x) = \alpha_k ] \} $$
In prose, this equation says that $\big \langle \mathbf{d} \big \rangle$ is the set of all segments in $\Sigma$ such that, for every feature in $\mathbf{d}$, the value of the feature for that segment is the same as the value in $\mathbf{d}$. Note that under this definition, the extension of the empty featural descriptor is $\Sigma$, since the predicate is vacuously true for all segments when $\mathbf{d}$ is empty.
We use the notation $V_{spec}^F$ to denote the powerset of $V_{spec} \times F$, i.e., the set of all licit featural descriptors. Lastly, we define $\langle V_{spec}^F \rangle = \{ \langle \mathbf{d} \rangle \, \mid \, \mathbf{d} \in V_{spec}^F \}$, the set of all classes described by some featural descriptor in $V_{spec}^F$. We say that the feature system $(F, \Sigma, V)$ generates the class system $\langle V_{spec}^F \rangle$.
While every featural descriptor in $V_{spec}^F$ picks out a class in $\langle V_{spec}^F \rangle$, the two are not generally in 1-1 correspondence. This is because the same class can often be described by multiple featural descriptors. For example, under the the feature system of Table~\ref{table:featurization}, the featural descriptor \featmat{--cons} picks out the same class as \featmattwo{--cons}{+son}, namely \{V, G\}. Moreover, the featural descriptors \featmattwo{+syl}{--syl} and \featmattwo{+syl}{--son} both pick out the empty set.
A feature system $(F, \Sigma, V)$ \textit{covers} a class system $(C, \Sigma)$ if $C \subseteq \langle V_{spec}^F \rangle$; in other words if the feature system provides a distinct representation for every class in $C$.
In the next subsection, we work an example to illustrate the importance of the choice of the value set in feature systems.
\subsection{Example: Sonorants and obstruent voicing}
In this section we introduce a simple, three-segment class system to illustrate the notation, as well as the difference between the privative, full, and contrastive specification value sets.
% tables with featurization of sonorants, voiced obstruents, and voiceless obstruents
\begin{table}[h]
\centering
\begin{tabular}{p{5cm}p{5cm}p{5cm}}
\begin{tabular} {|c||c|c|}
\hline
$\sigma$ & son & voice \\ \hline
R & + & + \\
D & 0 & + \\
T & 0 & 0 \\
\hline
\end{tabular} &
\begin{tabular} {|c||c|c|}
\hline
$\sigma$ & son & voice \\ \hline
R & + & + \\
D & -- & + \\
T & -- & -- \\
\hline
\end{tabular} &
\begin{tabular} {|c||c|c|}
\hline
$\sigma$ & son & voice \\ \hline
R & + & 0 \\
D & -- & + \\
T & -- & -- \\
\hline
\end{tabular}
\end{tabular}
\caption{Sonorants and obstruents with privative (left), full (middle), and contrastive (right) specification.}
\label{table:son_obs_features}
\end{table}
Let $\Sigma =$ \{R, D, T\}, where R is meant to evoke a sonorant, D a voiced obstruent, and T a voiceless obstruent. We begin with the featurization using the privative value set, shown on the left in Table~\ref{table:son_obs_features}. This defines three unique classes, including the alphabet. Using the simplest featural descriptors for each class, $\langle$\featmat{}$\rangle = $\{R, D, T\}, $\langle$\featmat{+son}$\rangle = $\{R\}, and $\langle$\featmat{+voice}$\rangle =$\{R, D\}. Note that this featurization provides (i) no featural descriptor that uniquely picks out the voiceless obstruent \{T\}, (ii) no way to pick out the obstruents \{T\} and \{D\} to the exclusion of \{R\}, (iii) no way to pick out the voiced obstruent \{D\} without \{R\}, and (iv) no way to pick out the empty set.
Next, consider the featurization in which the `$0$'s from the privative set are replaced with `$-$'s. This is the full specification value set. A featurization of $\Sigma$ using this set is shown in the middle in Table~\ref{table:son_obs_features}. While the privative featurization just covers three classes, the full specification featurization covers six (not counting the empty set). Referring to `--' values provides a greater number of ways to `slice and dice' the alphabet. It follows that featurizations which assign more `$0$' values generally (though not always) require more distinct feature functions to cover the same class system. Note however that the full featurization is still restrictive, in the sense that it does not allow any arbitrary subset of segments to be identified: for example, we cannot specify \{R, T\} to the exclusion of \{D\}.
Finally, we can strike a balance in expressivity between the privative and full value sets by allowing features to take `$+$', `$-$', and `$0$' values. This is the contrastive value set. A possible contrastive featurization of $\Sigma$ is shown on the right in Table~\ref{table:son_obs_features}. Under this featurization, \featmat{voice} is now ternary, contrasting only for obstruents \cite<e.g.,>{Kiparsky1985}. This featurization picks out the same classes as the full featurization, minus the class \{R, D\}.
\subsection{Parent/child relationships in class systems}
Because the classes in a class system fall into subset/superset relationships with one another, we can represent them hierarchically. An example for the manner system in Table~\ref{table:manner_system} is shown in Fig.~\ref{fig:manner_input}. Each node in this figure is a class. Downward arrows indicate a \textit{parent/child} relationship between the connected classes. The parent/child relationship is of central importance to this work, so we formalize it carefully.
\vspace{0.5\baselineskip} \noindent \textbf{Definition}: Let $(C, \Sigma)$ be a class system. $X \in C$ is a \textit{parent} of $Y \in C$ (and $Y$ is a \textit{child} of $X$) if and only if $Y \subset X$, and there exists no $Z \in C$ such that $Y \subset Z \subset X$
\vspace{0.5\baselineskip} \noindent In other words, $X$ is a parent of $Y$ if a subset/superset relation holds, and there is no intervening class between them.
% show an example of a class system: a manner hierarchy
\begin{figure}[htb!]
\centering
\includegraphics[width=0.3\textwidth]{manner_poset_privative.png}
\caption{A manner hierarchy class system.}
\label{fig:manner_input}
\end{figure}
In Fig.~\ref{fig:manner_input}, there is a path from the alphabet through the sonorants to the continuants. This means the sonorants are a child of the alphabet, and the continuants are a child of the sonorants. This path implies the continuants are a subset of the alphabet,\footnote{Formally, the subset/superset relation is the \textit{transitive closure} of the parent/child relation, and the parent/child relation is the \textit{transitive reduction} of the subset/superset relation.} but crucially, the continuants are not a child of the alphabet because the sonorants intervene. We define the functions $\textsc{parents}_C(Y)$ as the set of classes which are parents of a class $Y \in C$, and $\textsc{children}_C(Y)$ as the set of classes which are children of $Y \in C$.
Note that the empty set is technically a child of the singletons (since it is a subset of everything) but it does not appear in the graph. This is because the empty set is a phonologically irrelevant class: it cannot partition the alphabet into segments which pattern together and those which do not. To say that it is equivalent to the source or target of a process is equivalent to saying that the process does not happen at all.\footnote{Some confusion may arise with regard to SPE-style rules. In SPE, the null set symbol is used to indicate the source/target of epenthesis/deletion rules. Thus, in SPE the null set symbol is used to denote an \emph{empty string}. In the present work, the null set symbol is used to denote the null set.} For this reason, we generally omit the empty set throughout this paper.
One reason that we depict parent/child relationships (rather than subset/superset) is to avoid crowding the graph with arrows. But there is an additional, theoretical reason that will be crucial for the featurization algorithms we define later -- roughly speaking, in order to build a covering feature system for a set of input classes, a new feature/value pair is required only in cases where a class has exactly one parent. However, this does not hold for any class system, but only for a class system that is \textit{intersectionally closed}. The next section describes this important concept and its implications for feature systems.
\FloatBarrier
\section{Intersectional closure}
\label{sec:intersectional}
The intersectional closure of a class system $C$ is the set of classes that can be generated by intersecting an arbitrary subset of classes in $C$. We relate the intersectional closure to features by showing that if a feature system is expressive enough to generate all the classes in $C$, it necessarily generates the intersectional closure of $C$. This is a consequence of the familiar process of combining featural descriptors (also called feature bundles), where the union a set of featural descriptors defines the class that is the intersection of the classes they pick out individually. We formalize this carefully in order to prove a less obvious result: when generating a feature system from an input class system, a new feature/value pair must be added for all and only the classes that have a single parent in the intersectional closure of the input. This is because a class with more than one parent can be expressed as the union of its parents' featural descriptors.
\subsection{Definitions}
\textbf{Definition}: A collection of sets $C$ is \textit{intersectionally closed} if and only if for all $X \in C$ and $Y \in C$, $X \cap Y \in C$.
\vspace{0.5\baselineskip} \noindent The \textit{intersectional closure} of a class system $(C, \Sigma)$, written $C_\cap$, is the smallest intersectionally closed class system which contains $C$ and $\Sigma$.
\vspace{0.5\baselineskip} \noindent \textbf{Definition}: $C_\cap = \{ \, \bigcap P \, \mid \, P \subseteq C\} \cup \{\Sigma\}$
\vspace{0.5\baselineskip} \noindent where $P$ ranges over every subset of the classes in $C$ and $\bigcap P$ indicates the intersection of all classes in $P$. In other words, the intersectional closure contains every class which can be generated by finite intersections of classes from $C$ (and $\Sigma$), and no other classes besides these.
To illustrate this concept, we introduce the vowel inventory in Table~\ref{table:vowel_inventory} and a possible class system over this inventory in Table~\ref{table:vowels1}. This class system will serve as a running example throughout the rest of the paper. It is intended to strike a balance between linguistic plausibility and simplicity for expositional purposes.
\begin{table}[h]
\centering
\begin{tabular} {|c|c|c|c|}
\hline
& front & central & back \\ \hline
high & \textipa{i} \textipa{y} & & \textipa{u} \\
mid & \textipa{e} \textipa{\o} & & \textipa{o} \\
low & & \textipa{a} & \\ \hline
\end{tabular}
\caption{Vowel inventory}
\label{table:vowel_inventory}
\end{table}
\begin{table}[h]
\centering
\begin{tabular} {|l|l|}
\hline
\textit{alphabet} & \{\textipa{a}, \textipa{i}, \textipa{u}, \textipa{e}, \textipa{o}, \textipa{y}, \textipa{\o}\} \\
\hline
\textit{non-low} & \{\textipa{i}, \textipa{u}, \textipa{e}, \textipa{o}, \textipa{y}, \textipa{\o}\} \\
\hline
\textit{high} & \{\textipa{i}, \textipa{u}, \textipa{y}\} \\
\hline
\textit{front} & \{\textipa{i}, \textipa{e}, \textipa{y}, \textipa{\o}\} \\
\hline
\textit{round} & \{\textipa{u}, \textipa{o}, \textipa{y}, \textipa{\o}\} \\
\hline
\textit{singletons} & \{\textipa{a}\}, \{\textipa{i}\}, \{\textipa{u}\}, \{\textipa{e}\}, \{\textipa{o}\}, \{\textipa{y}\}, \{\textipa{\o}\} \\
\hline
\end{tabular}
\caption{Vowel classes}
\label{table:vowels1}
\end{table}
Let $(C, \Sigma)$ consist of the classes in Table~\ref{table:vowels1}. $(C, \Sigma)$ and $C_\cap$ are depicted in Fig.~\ref{fig:vowel_inventory}. The difference between the two is highlighted by using red ovals for the `extra' classes.
% FIGURE 2
\begin{figure}[h]
\centering
\subfloat{{\includegraphics[width=0.45\textwidth]{vowel_inventory_base.png}}}
\qquad
\subfloat{{\includegraphics[width=0.45\textwidth]{vowel_inventory_closure.png}}}
\caption{The original vowel system (left) and its intersectional closure (right). Classes added in the closure are indicated with red ovals. Dotted lines in the intersectional closure indicate classes with more than one parent.}
\label{fig:vowel_inventory}
\end{figure}
% Old figure setup
%% FIGURE 2
%\begin{figure}[h]
% \centering
% \includegraphics[width=0.8\textwidth]{vowel_inventory_base.png}
% \caption{A vowel inventory.}
% \label{fig:vowel_inventory}
%\end{figure}
%
%% FIGURE 3
%\begin{figure}[h]
% \centering
% \includegraphics[width=0.7\textwidth]{vowel_inventory_closure.png}
% \caption{Intersectional closure of the vowel inventory. Classes added in the closure are indicated with red ovals.}
% \label{fig:vowel_inventory_closure}
%\end{figure}
The key difference is that the intersectional closure contains several two-segment classes which are the intersection of larger classes. For example, the \textit{high, front} class \{\textipa{i}, \textipa{y}\} is the intersection of the \textit{high} class and the \textit{front} class:
$$ \text{\{\textipa{i}, \textipa{y}\}} = \text{\{\textipa{i}, \textipa{y}, \textipa{u}\}} \cap \text{\{\textipa{i}, \textipa{y}, \textipa{e}, \textipa{\o}\}} $$
In the next section, we prove that if a feature system is expressive enough to cover $C$, it also covers $C_\cap$.
\subsection{Feature systems generate an intersectional closure}
There is a dual relationship between featural descriptors and the classes they describe: intersection of classes corresponds to union of featural descriptors. We formalize this property with a lemma and then provide a concrete example. An important consequence of the following lemma is that it entails that if a featurization covers $C$, it must also cover the intersectional closure $C_\cap$. We prove this in the theorem that follows.
\begin{clump}
\vspace{\baselineskip} \noindent \textbf{Featural Intersection Lemma}
\indent Let $(F, \Sigma, V)$ be a feature system. If $\mathbf{d}_i, \mathbf{d}_j \in V_{spec}^F$, then $\langle \mathbf{d}_i \cup \mathbf{d}_j \rangle = \langle \mathbf{d}_i \rangle \cap \langle \mathbf{d}_j \rangle$.
\end{clump}
\noindent \textit{Proof}:
The proof proceeds by showing that $ \langle \mathbf{d}_i \rangle \cap \langle \mathbf{d}_j \rangle \subseteq \langle \mathbf{d}_i \cup \mathbf{d}_j \rangle$ and $\langle \mathbf{d}_i \cup \mathbf{d}_j \rangle \subseteq \langle \mathbf{d}_i \rangle \cap \langle \mathbf{d}_j \rangle$.
Let $C_i = \langle \mathbf{d}_i \rangle$ and $C_j = \langle \mathbf{d}_j \rangle$.
First, suppose $x \in C_i \cap C_j$. Then $x \in C_i$. By definition, $x$ has the features in $\mathbf{d}_i$.
Similarly, $x \in C_j$, and therefore must have the features in $\mathbf{d}_j$.
Thus, $x$ has the features in $\mathbf{d}_i \cup \mathbf{d}_j$. This shows that $C_i \cap C_j \subseteq \langle \mathbf{d}_i \cup \mathbf{d}_j \rangle$.
Now, suppose $x \in \langle \mathbf{d}_i \cup \mathbf{d}_j \rangle$. Then $x$ has all the features of $\mathbf{d}_i$, and so $x \in C_i$.
Similarly, $x$ has all the features of $\mathbf{d}_j$, so $x \in C_j$. Therefore $x \in C_i \cap C_j$. This shows that $\langle \mathbf{d}_i \cup \mathbf{d}_j \rangle \subseteq C_i \cap C_j$.
Since both $C_i \cap C_j$ and $\langle \mathbf{d}_i \cup \mathbf{d}_j \rangle$ are subsets of each other, they are equal.
$\square$
\vspace{0.5\baselineskip} We illustrate this lemma with reference to the vowel inventory system introduced above. For concreteness, let us adopt the featurization in Table~\ref{table:vowel_inventory_underspec}.
% table with featurization of sonorants, voiced obstruents, and voiceless obstruents
\begin{table}[h]
\centering
\begin{tabular} {|c||c|c|c|c|}
\hline
$\sigma$ & low & front & round & high \\ \hline
\textipa{a} & + & 0 & 0 & 0 \\
\textipa{i} & -- & + & 0 & + \\ \textipa{u} & -- & -- & + & + \\
\textipa{e} & -- & + & 0 & -- \\
\textipa{o} & -- & -- & + & -- \\
\textipa{\o} & -- & + & + & -- \\
\textipa{y} & -- & + & + & + \\ \hline
\end{tabular}
\caption{A featurization of the vowel inventory. The low vowel is unspecified for front/round/high features; the round feature is privative.}
\label{table:vowel_inventory_underspec}
\end{table}
\noindent Let $\mathbf{d}_1 =$ \featmat{+front} and $\mathbf{d}_2 =$ \featmat{+round}. Then we have: \begin{itemize}
\item $\langle \mathbf{d}_1 \rangle = \langle$\featmat{+front}$\rangle =$ \{\textipa{i}, \textipa{e}, \textipa{y}, \textipa{\o}\}
\item $\langle \mathbf{d}_2 \rangle = \langle$\featmat{+round}$\rangle =$ \{\textipa{u}, \textipa{o}, \textipa{y}, \textipa{\o}\}
\end{itemize}
\noindent For these values, the Featural Intersection Lemma cashes out as follows: `the set of vowels that are both front and round' is the intersection of `the set of vowels that are front' and `the set of vowels that are round':
\begin{itemize}
\item $\langle \mathbf{d}_1 \rangle \cap \langle \mathbf{d}_2 \rangle = \langle$\featmat{+front}$\rangle \cap \langle$\featmat{+round}$\rangle =$\{\textipa{i}, \textipa{e}, \textipa{y}, \textipa{\o}\} $\cap$ \{\textipa{u}, \textipa{o}, \textipa{y}, \textipa{\o}\} = \{\textipa{y}, \textipa{\o}\}
\item $\langle \mathbf{d}_1 \cup \mathbf{d}_2 \rangle = \langle$\featmattwo{+front}{+round}$\rangle =$ \{\textipa{y}, \textipa{\o}\}
\end{itemize}
\noindent The Featural Intersection Lemma proves that this kind of relationship holds for any pair of featural descriptors and the classes they describe.
An important consequence of this lemma is that it can be applied inductively, to relate the union of multiple featural descriptors with the intersection of multiple classes. Because the intersectional closure is defined as the intersection of arbitrarily many classes in an input $C$, the Featural Intersection Lemma entails that if a featurization covers $C$, it must cover the intersectional closure.
\begin{clump}
\vspace{\baselineskip} \noindent \textbf{Intersectional Closure Covering Theorem}
\noindent Let $(C, \Sigma)$ be a class system and $(F, \Sigma, V)$ a feature system. If $C \subseteq \langle V_{spec}^F \rangle$, then $C_\cap \subseteq \langle V_{spec}^F \rangle $.
\end{clump}
\noindent \textit{Proof}:
Let $Y$ be an arbitrary class in $C_\cap$. By definition of $C_\cap$, there exist $\{X_i \in C\}_{i \in I}$ (for some index set $I$, hereafter omitted) such that $Y = \bigcap_i \, X_i$. The hypothesis that $C \subseteq \langle V_{spec}^F \rangle $ implies that for every such $X_i$, there is a featural descriptor $\mathbf{d}_i$ such that $\langle \mathbf{d}_i \rangle = X_i$. Thus, $Y = \bigcap_i X_i = X_1 \cap X_2 \cap \ldots \cap X_n$ can also be written $Y = \bigcap_i \, \langle \mathbf{d}_i \rangle = \langle \mathbf{d}_1 \rangle \cap \langle \mathbf{d}_2 \rangle \cap \ldots \cap \langle \mathbf{d}_n \rangle$. It follows by induction using Featural Intersection Lemma that $Y = \langle \bigcup_i \mathbf{d}_i \rangle$:
$Y = \langle \mathbf{d}_1 \rangle \cap \langle \mathbf{d}_2 \rangle \cap \ldots \cap \langle \mathbf{d}_n \rangle$
\quad $ = \langle \mathbf{d}_1 \cup \mathbf{d}_2 \rangle \cap \mathbf{d}_3 \cap \ldots \cap \langle \mathbf{d}_n \rangle$
\quad $ = \langle \mathbf{d}_1 \cup \mathbf{d}_2 \cup \mathbf{d}_3 \rangle \cap \ldots \cap \langle \mathbf{d}_n \rangle$
\quad $\ldots$
\quad $= \langle \mathbf{d}_1 \cup \mathbf{d}_2 \cup \ldots \cup \mathbf{d}_n \rangle$
\quad $= \langle \bigcup_i \mathbf{d}_i \rangle$
\noindent The preceding chain of logic demonstrates the following fact: if a class can be expressed as the intersection of classes in $C$, then its features are the union of the features in each of those classes. The intersectional closure is defined as all possible intersections of classes in $C$. Thus, because $(\bigcup_i \mathbf{d}) \in V_{spec}^f$, if $(F, \Sigma, V)$ covers $C$, it covers the intersectional closure. $\square$
\vspace{0.5\baselineskip} A dynamic programming algorithm for efficiently calculating the intersectional closure of a set of classes is presented in Appendix~\ref{app:closure}.
\subsection{Parenthood in the intersectional closure}
\label{sec:intersection_proof}
The intersectional closure not only characterizes the expressiveness of a featurization, but is also instrumental in deriving featurizations from a class system. When generating a feature system from a set of classes, \textit{a new feature/value pair is required for all and only the classes which have a single parent in the intersectional closure}. The reason for this is that if a class has two parents, it must be their intersection.
\begin{clump}
\vspace{\baselineskip} \noindent \textbf{Multiple Parenthood Theorem}
\noindent Let $(C, \Sigma)$ be a class system and $Y \in C_\cap$. If $X_1, X_2 \in \textsc{parents}_C(Y)$, then $Y = X_1 \cap X_2$.
\end{clump}
\noindent \textit{Proof}:
First, observe that $Y \subseteq X_1 \cap X_2$. This follows trivially from the definition of parenthood: $X_1$ is a parent of $Y$ implies $Y \subset X_1$; $X_2$ is a parent of $Y$ implies $Y \subset X_2$; and so every element in $Y$ is in both $X_1$ and $X_2$.
Now suppose that $X_1 \cap X_2 \neq Y$. The preceding logic showed that either the two are equal, or $Y$ is a proper subset of $X_1 \cap X_2$. But the latter case creates a contradiction. By definition, $X_1 \cap X_2$ must be in the intersectional closure. It must also be the case that $X_1 \cap X_2 \subset X_1$. If $X_1 \cap X_2 = X_1$ then $X_2$ is either identical to or a supserset of $X_1$, contradicting the assumption that $X_1$ and $X_2$ are parents of $Y$, and $X_1 \cap X_2 \supset X_1$ is ruled out by the fundamental properties of sets. Thus $X_1 \cap X_2$ intervenes between $Y$ and $X_1$, contradicting the hypothesis that $Y$ is a daughter of $X_1$. Thus, $Y = X_1 \cap X_2$. $\square$
\vspace{0.5\baselineskip} Note that the Multiple Parenthood Theorem does not logically exclude the possibility that a class may have more than two parents. Rather, it guarantees that in such cases, the intersection is the same so long as two or more parents are considered. A case of this arose already in Fig.~\ref{fig:vowel_inventory}, in the intersectional closure of the vowel inventory. There, the three features \textit{front}, \textit{high}, and \textit{round} give rise to three distinct 2-feature classes (featural descriptors: \featmattwo{+front}{+high}, \featmattwo{+high}{+round}, \featmattwo{+front}{+round}). The intersection of any pair of these is \{\textipa{y}\} (the high, front, round vowel). Thus, the set \{\textipa{y}\} has three parents, but which segments it contains is uniquely determined by any two of them.
\subsection{Interim summary}
In Section~\ref{sec:definitions}, we defined a formal notation for class systems, feature systems, and featural descriptors, and explored the expressiveness of different value sets in feature systems. In Section~\ref{sec:intersectional}, we proved that any feature system that is expressive enough to cover a class system necessarily covers the intersectional closure of that class system. We then showed that if a class has more than one parent in the intersectional closure of a class system, it is the intersection of any two of those parents. This latter point will be the key element of the featurization algorithms described in the rest of the paper.
With the necessary components in place, we now turn to the main question addressed in this paper: given a set of phonological classes, how can we generate a covering feature system? We detail four algorithms that accomplish this, differing in their assumptions about which value sets are used and how these values are assigned.
\FloatBarrier
\section{Generating a feature system from a set of input classes}
\label{sec:algorithm_intro}
In this section, we will detail the operation of four algorithms that generate a feature system from a set of input classes. The basic principle these algorithms share is that we must introduce a new feature/value pair for each class in the intersectional closure that has a single parent. This is because classes with more than one parent may be specified by the union of the features of any two of their parents, and so do not need a new feature to distinguish them from their parents. The four algorithms differ in which value sets they use and how they assign these values.
We will use the simple class system shown in Fig.~\ref{fig:toy_system} to illustrate the properties of each algorithm. This system is intersectionally closed. Note that this system does not include all of the singleton classes. This is equivalent to removing the stipulation that the resulting feature system must be able to pick out each segment individually. Although this is doubtless a desirable property in real phonological systems, we relax it here for expositional purposes. The next section will provide a substantive discussion of the theoretical implications of each featurization type using a more realistic input.
\begin{figure}[htb!]
\centering
\includegraphics[width=0.2\textwidth]{toy_system.png}
\caption{A toy class system.}
\label{fig:toy_system}
\end{figure}
The notation used to define the algorithms may be unfamiliar to some readers. Table~\ref{table:algorithm_definitions} provides definitions for some of the less obvious terms. The rest of the notation should be familiar from basic set theory.
\begin{table}
\centering
\begin{tabular}{|l|p{9cm}|}
\hline
\textbf{Require} & Expresses constraints on the input \\
\hline
\textbf{Ensure} & Expresses constraints on the output \\
\hline
\begin{tabular}[t]{@{}l}
$Q$ \\
\textsc{dequeue} \\
\textsc{enqueue}
\end{tabular} & $Q$ is a queue, which is a set of ordered values. Queues are ``first in, first out'', which means values are removed from the queue using \textsc{dequeue} in the same order they were added to the queue using \textsc{enqueue}. Statements like $Q \leftarrow C_\cap$ indicate that the sets in $C_\cap$ are added to $Q$ in an arbitrary order.\\
\hline
\textsc{IntersectionalClosure} & Returns the intersectional closure of the input class system. $Q'$ indicates the starting state of the queue (see Appendix~\ref{app:closure}). \\
\hline
\end{tabular}
\caption{Definitions for some terms used in algorithms.}
\label{table:algorithm_definitions}
\end{table}
\subsection{Privative specification}
The first algorithm yields a \textit{privative} featurization of a set of classes: that is, one where the set of legal feature values $V = \{+, 0\}$. It does so by assigning a different feature/value pair, \featmat{$+f$}, to the segments in each class with a single parent.
\noindent \begin{algorithmic}
\singlespacing
\REQUIRE $C_\cap$ is the intersectional closure of a class system $(C, \Sigma)$
\ENSURE $F$ is a featurization over $V = \{ +, 0 \}$ which covers $C$
\STATE
\STATE $Q \leftarrow C_\cap$
\STATE $F \leftarrow \varnothing$
\STATE
\WHILE{$Q \neq \varnothing$}
\STATE $X \leftarrow \textsc{dequeue}(Q)$
\IF{$|\textsc{parents}_C(X)| = 1$}
\STATE define $f_X : \Sigma \rightarrow V$ by $f_X(\sigma) = \begin{cases}
+ & \mbox{if } \sigma \in X \\
0 & \mbox{otherwise}
\end{cases} $
\STATE $F \leftarrow F \cup \{f_X\}$
\ENDIF
\ENDWHILE
\end{algorithmic}
\doublespacing
\noindent \textit{Proof of soundness for the privative specification algorithm}
A featurization algorithm is \textit{sound} if for every class system $(C, \Sigma)$, it returns a feature system which covers $C$. To see that the privative specification algorithm is sound, note that every class in $C_\cap$ enters the queue $Q$. For an arbitrary class $X$ in the queue, there are three cases. If $X$ has 0 parents, then it is $\Sigma$, and is covered by the empty featural descriptor. If $X$ has exactly 1 parent, then the segments in $X$ will have the features of that parent (which uniquely pick out the parent class), plus a new feature $f$ which distinguishes the segments in $X$ from $X$'s parent. If $X$ has more than 1 parent, then Multiple Parenthood Theorem shows, via the Featural Intersection Lemma, that the union of features of $X$'s parents uniquely pick out all and only the segments in $X$. Thus, each class which exits the queue has a set of features assigned to its segments which pick out that class uniquely. This completes the proof. $\square$
\begin{figure}[htb!]
\centering
\begin{minipage}{0.45\textwidth}
\centering
\includegraphics[width=0.45\textwidth]{toy_system_privative.png}
\caption{Yield of the privative specification algorithm.}\label{fig:toy_system_privative}
\end{minipage}
\begin{minipage}{0.45\textwidth}
\centering
\captionsetup{type=table} %% tell latex to change to table
\begin{tabular} {|c||c|c|c|}
\hline
$\sigma$ & F1 & F2 & F3 \\ \hline
a & + & 0 & 0 \\
b & 0 & + & + \\
c & 0 & + & 0 \\
\hline
\end{tabular}
\caption{Featural specification of the toy system with privative specification.}\label{table:toy_system_privative}
\end{minipage}
\end{figure}
%\begin{figure}[htb!]
% \centering
% \includegraphics[width=0.2\textwidth]{toy_system_privative.png}
% \caption{Yield of the privative specification algorithm.}
% \label{fig:toy_system_privative}
%\end{figure}
%\begin{table}[h]
% \centering
% \begin{tabular} {|c||c|c|c|}
% \hline
% $\sigma$ & F1 & F2 & F3 \\ \hline
% a & + & 0 & 0 \\
% b & 0 & + & + \\
% c & 0 & + & 0 \\
% \hline
% \end{tabular}
% \caption{Featural specification of the toy system with privative specification.}
% \label{table:toy_system_privative}
%\end{table}
The output of this algorithm on the simple class system in Fig.~\ref{fig:toy_system} is shown in Fig.~\ref{fig:toy_system_privative}. The visual style is similar, but this figure contains additional annotations for the feautures themselves. The boxes which represent the classes contain the segments in the class, followed by the list of features that are shared by all segments in the class. Recall that if a class has a feature, all descendants of the class share that feature. The introduction of a feature is thus indicated explicitly by labeling and coloring the edge which points to the first/highest class whose segments share the feature. This could give the misleading impression that features are assigned to classes, so it is worth reiterating that features are maps from \textit{segments} to values. The complete featurization of each individual segment is given in Table~\ref{table:toy_system_privative}. Each class with a single parent has resulted in a new feature/value pair being generated, resulting in a total of three features.
\FloatBarrier
\subsection{Complementary specification}
\label{sec:contrastiveunder}
It is common for theoretical reasons to assign corresponding $\pm$ feature values to pairs of classes, such as \featmat{+back} and \featmat{$-$back} vowels. Such binary features are often relevant for only certain segments (e.g., we may want to only specify voicing for obstruents, backness for dorsal sounds, and so on). In all such cases, the contrastive feature values denote \textit{complementary} classes -- but complements with respect to \textit{what}?
The central insight developed in this paper is that a new feature needs to be assigned just in case a class has a single parent in the intersectional closure. This suggests that a relevant domain for complementation is with respect to the parent. This is the distinction between privative specification and complementary specification: a `$-$' value is assigned when the complement of the class being processed with respect to its parent is in the input.
\noindent \begin{algorithmic}
\singlespacing
\REQUIRE $C_\cap$ is the intersectional closure of input class system $(C, \Sigma)$
\ENSURE $F$ is a featurization over $V = \{ +, -, 0 \}$ which covers $C$
\STATE
\STATE $Q \leftarrow C_\cap$
\STATE $F \leftarrow \varnothing$
\STATE
\WHILE{$Q \neq \varnothing$}
\STATE $X \leftarrow \textsc{dequeue}(Q)$
\IF{$| \textsc{parents}_C(X) | = 1$}
\STATE $P_X \leftarrow \textsc{dequeue}(\textsc{parents}_C(X))$
\STATE
\STATE $\overline{X} \leftarrow \begin{cases}
P_X \setminus X & \text{if } (P_X \setminus X) \in C \\
\varnothing & \text{otherwise}
\end{cases}$
\STATE
\STATE define $f_X : \Sigma \rightarrow V$ by $f_X (\sigma) = \begin{cases}
+ & \text{if } \sigma \in X \\
- & \text{if } \sigma \in \overline{X} \\
0 & \text{otherwise}
\end{cases}$
\STATE $F \leftarrow F \cup \{f_X\}$
\STATE $Q \leftarrow \{x \in Q \vert x \neq \overline{X} \}$
\ENDIF
\ENDWHILE
\end{algorithmic}
\doublespacing
\noindent The soundness of this algorithm follows from the soundness of the privative specification algorithm. This is because the complementary specification algorithm yields a feature system which generates the same class system as privative specification does. The difference between the two is that if the input contains complement sets, then complementary specification will use a single feature with `$+$' and `$-$' values, where privative specification will have two features with just `$+$' values.
\begin{figure}[htb!]
\centering
\begin{minipage}{0.45\textwidth}
\centering
\includegraphics[width=0.45\textwidth]{toy_system_complementary.png}
\caption{Yield of the complementary specification algorithm.}
\label{fig:toy_system_complementary}
\end{minipage}
\begin{minipage}{0.45\textwidth}
\centering
\captionsetup{type=table} %% tell latex to change to table
\begin{tabular} {|c||c|c|}
\hline
$\sigma$ & F1 & F2 \\ \hline
a & + & 0 \\
b & -- & + \\
c & -- & 0 \\
\hline
\end{tabular}
\caption{Featural specification of the toy system with complementary specification.}
\label{table:toy_system_complementary}
\end{minipage}
\end{figure}
%\begin{figure}[htb!]
% \centering
% \includegraphics[width=0.2\textwidth]{toy_system_complementary.png}
% \caption{Yield of the complementary specification algorithm.}
% \label{fig:toy_system_complementary}
%\end{figure}
%
%\begin{table}[h]
% \centering
% \begin{tabular} {|c||c|c|}
% \hline
% $\sigma$ & F1 & F2 \\ \hline
% a & + & 0 \\
% b & -- & + \\
% c & -- & 0 \\
% \hline
% \end{tabular}
% \caption{Featural specification of the toy system with complementary specification.}
% \label{table:toy_system_complementary}
%\end{table}
The output of this algorithm on the simple class system in Fig.~\ref{fig:toy_system} is shown in Fig.~\ref{fig:toy_system_complementary}, and the complete featurization is shown in Table~\ref{table:toy_system_complementary}. Note that each class with a single parent has still been assigned a new feature/value pair. However, because the `$-$' value is available, and two classes fall into a complementary relationship with respect to their parent, we require only two features to generate the same class system.
The term \textit{complementary specification} is meant to capture the fact that specification for a particular feature occurs just for segments that are in the class that motivates the addition of the feature, or in its complement with respect to the parent if this class is in the input. In the next section, we consider a variant of the algorithm which guarantees members of such complement classes will receive `$-$' values, even if they were not present in the input. We call this variant \textit{inferential complementary specification}.
\FloatBarrier
\subsection{Inferential complementary specification}
\label{sec:contrastive}
Inferential complementary (IC) specification, like complementary specification, generates a ternary feature system. The key difference is that IC specification adds complements with respect to the parent to the set of classes. Every complement gets a `$-$' feature, \textit{including those which were not in the input}. In other words, the learner performs a limited generalization from the input classes to infer the existence of certain classes that were not in the input.
IC specification thus requires modifying the intersectional closure of the input. One way to handle this is to update the intersectional closure as features are assigned. However, it is also possible to precompute the result, because the classes that must be added can be defined in terms of subset/superset relations, which do not depend on features. We do this as it is conceptually simpler.
We denote the function that adds complement classes with \textsc{AddComplements}. When adding complement classes, the ordering in which classes are processed is crucially important. Breadth-first traversal -- processing all the siblings of a class before its children -- is done to avoid configurations that duplicate a feature. In addition, the order in which siblings are processed during breadth-first traversal has important consequences for the generated class and feature systems. We adopt a procedure whereby the complements of all siblings are added \textit{simultaneously} to the class set if they are not already present. This has the potential to result in more features than would be generated if the complements were added one-by-one as each class is processed, but it avoids imposing class hierarchies that are not motivated by the input class set. A further motivation for this scheme is that if classes are not processed simultaneously, some order must be chosen, and there is no obvious motivation for choosing one over another. A detailed description of \textsc{AddComplements} and additional discussion of the points above can be found in Appendix \ref{app:complements}.
\noindent \begin{algorithmic}
\singlespacing
\REQUIRE $C_\cap$ is the intersectional closure of input class system $(C, \Sigma)$
\ENSURE $F$ is a featurization over $V = \{ +, -, 0 \}$ which covers $C$
\STATE
\STATE $Q \leftarrow \textsc{AddComplements}(C_\cap)$
\STATE $F \leftarrow \varnothing$
\STATE
\WHILE{$Q \neq \varnothing$}
\STATE $X \leftarrow \textsc{dequeue}(Q)$
\IF{$| \textsc{parents}_C(X) | = 1$}
\STATE $P_X \leftarrow \textsc{dequeue}(\textsc{parents}_C(X))$
\STATE $\overline{X} \leftarrow P_X \setminus X$
\STATE define $f_X : \Sigma \rightarrow V$ by $f_X (\sigma) = \begin{cases}
+ & \text{if } \sigma \in X \\
- & \text{if } \sigma \in \overline{X} \\
0 & \text{otherwise}
\end{cases}$
\STATE $F \leftarrow F \cup \{f_X\}$
\STATE $Q \leftarrow \{x \in Q \vert x \neq \overline{X} \}$
\ENDIF
\ENDWHILE
\end{algorithmic}
\doublespacing
\noindent This algorithm is sound because it considers all the classes that the privative specification algorithm does, plus others. Thus, it necessarily covers $C$.
The output of this algorithm on the simple class system in Fig.~\ref{fig:toy_system} is shown in Fig.~\ref{fig:toy_system_ic}, and the complete featurization is shown in Table~\ref{table:toy_system_ic}.
\begin{figure}[htb!]
\centering
\includegraphics[width=0.2\textwidth]{toy_system_ic.png}
\caption{Yield of the IC specification algorithm. Classes added by the algorithm are indicated with dashed boxes.}
\label{fig:toy_system_ic}
\end{figure}
\begin{table}[h]
\centering
\begin{tabular} {|c||c|c|}
\hline
$\sigma$ & F1 & F2 \\ \hline
a & + & 0 \\
b & - & + \\
c & - & - \\
\hline
\end{tabular}
\caption{Featural specification of the toy system with IC specification.}
\label{table:toy_system_ic}
\end{table}
Note that, as with complementary specification, only two features are needed to cover the input. However, the learner has inferred the existence of a class \{c\}, because its complement \{b\} with respect to its parent \{b,c\} was present in the input. As a result, c is no longer unspecified for F2.
The feature system yielded by IC specification is more expressive than the ones yielded by privative or complementary specification, but it is not maximally expressive, since there are still `$0$' values. When a new feature is added, non-zero values are assigned only to classes that are descendants of the parent of the class that generates the feature. If we want to eliminate all `$0$' values, we can do complementation with respect to $\Sigma$ rather than the parent. That is the final variant -- full specification.
\FloatBarrier
\subsection{Full specification}
\label{sec:full}
Full specification differs from IC specification in that complementation is calculated with respect to the whole alphabet, rather than the parent class. Therefore, it is algorithmically almost the same as IC specification. As with IC specification, the complement classes are precomputed and added to the intersectional closure in breadth-first search order, and siblings are processed simultaneously. We denote this process as \textsc{AddComplementsFull}: see Appendix \ref{app:complements} for a detailed discussion.
\noindent \begin{algorithmic}
\singlespacing
\REQUIRE $C_\cap$ is the intersectional closure of input class system $(C, \Sigma)$
\ENSURE $F$ is a featurization over $V = \{ +, - \}$ which covers $C$
\STATE
\STATE $Q \leftarrow \textsc{AddComplementsFull}(C_\cap)$
\STATE $F \leftarrow \varnothing$
\STATE
\WHILE{$Q \neq \varnothing$}
\STATE $X \leftarrow \textsc{dequeue}(Q)$
\IF{$| \textsc{parents}_C(X) | = 1$}
\STATE $\overline{X} \leftarrow \Sigma \setminus X$
\STATE define $f_X : \Sigma \rightarrow V$ by $f_X (\sigma) = \begin{cases}
+ & \text{if } \sigma \in X \\
- & \text{otherwise}
\end{cases}$
\STATE $F \leftarrow F \cup \{f_X\}$
\STATE $Q \leftarrow \{x \in Q \vert x \neq \overline{X} \}$
\ENDIF
\ENDWHILE
\end{algorithmic}
\doublespacing
\noindent The full specification algorithm is sound for the same reason that the IC specification algorithm is -- it considers a superset of classes that the privative specification algorithm does, and thus it covers the input.
The output of this algorithm on the simple class system in Fig.~\ref{fig:toy_system} is shown on the left side of Fig.~\ref{fig:toy_system_full_features}, and the complete featurization is shown in Table~\ref{table:toy_system_full}.
\begin{figure}[htb!]
\centering
\subfloat{{\includegraphics[width=0.3\textwidth]{toy_system_full_features_FEATURAL.png}}}
\qquad
\subfloat{{\includegraphics[width=0.225\textwidth]{toy_system_full_features_TOPOLOGICAL.png}}}
\caption{Featural (left) and topological (right) plots of the output of the full specification algorithm. Classes added by the algorithm are in dashed boxes. Classes added due to the addition of these classes to the intersectional closure are not highlighted.}
\label{fig:toy_system_full_features}
\end{figure}
%\begin{figure}[htb!]
% \centering
% \includegraphics[width=0.3\textwidth]{toy_system_full_features_FEATURAL.png}
% \caption{Featural (left) and topological (right) plots of the output of the full specification algorithm. Classes added by the algorithm are indicated with dashed boxes. Classes added due to the addition of these classes to the intersectional closure are not highlighted.}
% \label{fig:toy_system_full_features}
%\end{figure}
%
%\begin{figure}[htb!]
% \centering
% \includegraphics[width=0.2\textwidth]{toy_system_full_features_TOPOLOGICAL.png}
% \caption{Topological plot of the output of the full specification algorithm.}
% \label{fig:toy_system_full_topological}
%\end{figure}
\begin{table}[h]
\centering
\begin{tabular} {|c||c|c|}
\hline
$\sigma$ & F1 & F2 \\ \hline
a & + & - \\
b & - & + \\
c & - & - \\
\hline
\end{tabular}
\caption{Featural specification of the toy system with full specification.}
\label{table:toy_system_full}
\end{table}
The resulting feature system from the full specification algorithm contains no `0' values, and so all segments are fully specified for all features. The \{a,c\} class has been added because it is the complement of \{b\} with respect to the alphabet, and the class \{c\} has been generated by intersectional closure of this new class system.
There is an important difference between this plot and previous ones. We may consider two types of plots when plotting featural relations: a \emph{topological} plot, which plots relationships between classes using the familiar notions of the parent/child relationship, and a \emph{featural} plot, where classes corresponding to \featmat{$+f$} and \featmat{$-f$} feature/value pairs are plotted as siblings. In all cases considered so far, these two plotting strategies have resulted in identical outcomes. With the full specification algorithm on the toy class system, this is no longer the case. This mismatch is the result of \featmat{$-f$} values being assigned to classes that have multiple parents and/or are not siblings of the class motivating the new feature.
The plot on the left of Fig.~\ref{fig:toy_system_full_features} is the featural plot. The topological plot is shown to the right. The most salient difference is that the \featmat{--F1} and \featmat{--F2} classes are represented as siblings of the \featmat{+F1} and \featmat{+F2} classes in the featural plot, corresponding to the structure of the feature system. The topological plot, however, shows that these classes are not in fact siblings.
We use featural plots through the rest of the paper because they are more representative of the abstract structure and relationships assigned by the feature system, which subsume the topological system to some degree. Topological plots can be found in Appendix~\ref{app:topological}. Comparing these types of plots provides some insight into how topological and featural relationships in a class system may diverge.
\subsection{Summary of the algorithms}
This section described four algorithms that take a set of input classes and return a feature system that covers that class system. All four algorithms generate a new feature/value pair for any class that has a single parent in the intersectional closure of the input class system. The privative specification algorithm generates a system using only privative values. The complementary specification algorithm generates a ternary-valued feature system by assigning $\pm$ feature values to classes in the input that are complements with respect to their single parent. The inferential complementary specification algorithm behaves similarly, but it assigns `$-$' values to complement classes with respect to a parent in every case, adding them to the input if they are not present. Finally, the full specification algorithm assigns `$-$' values to complement classes with respect to the alphabet, resulting in no `0' values being assigned.
We now illustrate the performance of these algorithms on a more plausible input class system, and discuss some of the theoretical implications of each method.
\FloatBarrier
\section{Theoretical implications of different featurizations}
\label{sec:theoretical_implications}
The examples in this section will use the vowel class inventory shown in Fig.~\ref{fig:vowel_inventory} as input. For readability we generally use familiar feature names when the feature picks out more than one segment, and the segment's name (e.g., \featmat{+i}) when the feature only picks out a single segment. These single segment features are a consequence of the singleton sets being included in the input. Because the feature systems generated by this model must be able to pick out every class in the input, these features are generated when a singleton set cannot be described as the intersection of the larger sets in the intersectional closure. This is consistent with the suggestion in Section~\ref{sec:intro} that the primary role of features is to distinguish classes of sounds.
The feature names used below are a convenience for the reader, and do not reflect the featurization algorithm. In the code we provide, learned features are generated with numeric labels like F1, F2, etc. We will also occasionally swap the `+' and `--' values of a learned feature for readability.
\subsection{Privative specification}
In Fig.~\ref{fig:privative}, we illustrate the outcome of applying the privative specification algorithm to (the intersectional closure of) the vowel class inventory shown in Fig.~\ref{fig:vowel_inventory}. Table~\ref{table:privative_vowel_features} shows the resulting feature chart.
\begin{figure}[htb!]
\centering
\includegraphics[width=0.6\textwidth]{vowel_inventory_privative.png}
\caption{Yield of the privative specification algorithm.}
\label{fig:privative}
\end{figure}
\begin{table}[htb!]
\centering
\begin{tabular} {|c||c|c|c|c|c|c|c|c|c|c|}
\hline
$\sigma$ & nonlow & front & high & round & a & i & u & e & o & \o \\ \hline
a & 0 & 0 & 0 & 0 & + & 0 & 0 & 0 & 0 & 0 \\
i & + & + & + & 0 & 0 & + & 0 & 0 & 0 & 0 \\
u & + & 0 & + & + & 0 & 0 & + & 0 & 0 & 0 \\
e & + & + & 0 & 0 & 0 & 0 & 0 & + & 0 & 0 \\
o & + & 0 & 0 & + & 0 & 0 & 0 & 0 & + & 0 \\
y & + & + & + & + & 0 & 0 & 0 & 0 & 0 & 0 \\
\o & + & + & 0 & + & 0 & 0 & 0 & 0 & 0 & + \\
\hline
\end{tabular}
\caption{Featural specification of the vowel system with privative specification.}
\label{table:privative_vowel_features}
\end{table}
The privative featurization generates a feature system that covers the intersectional closure of the input class system and consists only of privative values. Note that /y/ does not require a \featmat{+y} feature because it is the intersection of the front, high, and round classes.
Any class system can be covered using only privative features, and completely privative systems have been proposed by researchers in the past \cite<e.g.,>{AndersonEwen1987, AveryRice1989, LahiriMarslenWilson1991, Frisch1996}. In these models, `$-$' feature values are unmarked, and thus may be filled in by redundancy rules, or only positive values of features need ever be referred to in the phonology. The privative algorithm generates featurizations consistent with such proposals.
There are valid theoretical reasons to prefer non-privative specifications, however. One argument arises from complement classes, such as ATR vs. RTR vowels. Languages with an ATR/RTR distinction frequently have ATR harmony \cite{ArchangeliPulleyblank1994}. Under privative specification one would need to write one harmony rule for the \featmat{+ATR} feature, and an otherwise identical rule for the \featmat{+RTR} feature. By making the ATR feature binary (i.e., \featmat{$\pm$ATR}), one formally recognizes the sameness of ATR/RTR with respect to the harmony process \cite{Archangeli2011}. In addition, allowing `$-$' feature values will also generally result in feature systems containing fewer features.
\subsection{Complementary Specification}
Consider the plot of the same vowel system under complementary specification, shown in Fig.~\ref{fig:vowel_inventory_complementary}, and the accompanying feature chart shown in Table~\ref{table:vowel_inventory_complementary}.
% FIGURE 5
\begin{figure}[htb!]
\centering
\includegraphics[width=0.6\textwidth]{vowel_inventory_complementary.png}
\caption{Yield of the complementary specification algorithm.}
\label{fig:vowel_inventory_complementary}
\end{figure}
\begin{table}[htb!]
\centering
\begin{tabular} {|c||c|c|c|c|c|c|c|c|c|}
\hline
$\sigma$ & low & front & high & round & i & u & e & o & \o \\ \hline
a & + & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\
i & -- & + & + & 0 & + & 0 & 0 & 0 & 0\\
u & -- & 0 & + & + & 0 & + & 0 & 0 & 0 \\
e & -- & + & 0 & 0 & 0 & 0 & + & 0 & 0 \\
o & -- & 0 & 0 & + & 0 & 0 & 0 & + & 0 \\
y & -- & + & + & + & -- & -- & 0 & 0 & -- \\
\o & -- & + & 0 & + & 0 & 0 & 0 & 0 & + \\
\hline
\end{tabular}
\caption{Featural specification of the vowel system with complementary specification.}
\label{table:vowel_inventory_complementary}
\end{table}
Now only nine features are required. The segment /a/, which was \featmat{+nonlow} under the privative algorithm, has instead been featurized as \featmat{--low} here. This is because the low and non-low classes are complements with respect to their parent ($\Sigma$), and both are present in the input. Contrastive \featmat{low} is doing the work of privative \featmat{low} and privative \featmat{nonlow} together, so there is no need for a contrastive \featmat{nonlow} feature.
An additional point of note is that /y/ is assigned the feature/value pairs \featmat{--\textipa{i}}, \featmat{--u}, and \featmat{--\textipa{\o}}, and hence these features are now ternary. This occurs because /y/ is a complement to the classes with single parents that motivate the addition of these features.
In general, the requirements for receiving a \featmat{$-f$} value are not as strict as receiving a \featmat{$+f$} value: \featmat{$-f$} classes may have more than one parent (as \{y\} does here). In addition, they do not necessarily need to be siblings of the class motivating the addition of the new feature, although in Fig.~\ref{fig:vowel_inventory_complementary} they happen to be. Restricting the assignment of \featmat{$-f$} values in the same way as \featmat{$+f$} values introduces complications for other types of featurization presented here, such as the full specification algorithm. Note that the remaining features (\featmat{front}, \featmat{high}, \featmat{round}, \featmat{\textipa{e}}, \featmat{o}) are still privative, because their respective complements are not present in the input.
The type of featurization generated by the complementary specification algorithm is consistent with many contemporary feature systems, where some features are privative (e.g., \featmat{LABIAL}), some are binary (e.g., \featmat{son}), and some are ternary (e.g., \featmat{back}. This most closely resembles systems that assume what \citeA{Archangeli1988} calls \textit{contrastive specification}: feature/value pairs are assigned only to the subset of segments where the feature is distinctive.
Consistent with much work on underspecification \cite<e.g.,>{Archangeli1984, ArchangeliPulleyblank1989, ArchangeliPulleyblank1994}, this model predicts that underspecification may vary across languages. The typological regularities that have led researchers to propose certain features as being inherently underspecified, such as the place features \featmat{LABIAL}, \featmat{CORONAL}, and \featmat{DORSAL} \cite<e.g.,>{Sagey1986} are considered to be consequences of the system that identifies classes in a language, rather than a restriction on the kinds of contrasts feature systems can encode. This model is also incompatible with theories where markedness plays some role in determining featural specification \cite<see section 2.1.3 in >[ and references therein]{Archangeli1988}, since there is no notion of markedness encoded in the model.
The particular featurization derived here using contrastive specification does not seem linguistically plausible, but as the next section will show, this is largely a consequence of the particular input classes chosen. See Section~\ref{sec:feature_theory} for an example of a more realistic featurization derived using contrastive specification.
\subsection{Conservational properties of featurizations}
One point to observe is that the privative specification and complementary specification algorithms are \textit{maximally conservative}. What we mean by this is that the resulting feature system generates the smallest class system that covers $C$. As the Intersectional Closure Covering Theorem showed, any featurization which covers $C$ will cover $C_\cap$. This means that any classes which are the intersection of input classes, but which were not themselves in the input, will be accessible to the output feature system. But the privative and complementary specification algorithms will not make it possible to refer to any other classes outside the intersectional closure. For example, the vowel system here contains a \featmat{+front} class and a \featmat{+round} class, and it necessarily generates a \featmattwo{+front}{+round} class. However, it does not infer the existence of a \featmat{--round} class based on the existence of the \featmat{+round} class.
It is easy to show that one can sometimes achieve a more efficient feature system by adding classes to the system. For example, the privative featurization of the vowel system contains ten features, and the complementary specification featurization contains nine. If we change the input to consist of the classes shown in Table~\ref{table:vowels2}, however, the privative specification algorithm returns a featurization with eight features, and complementary specification returns one with only four features. The privative system requires two fewer features because the addition of the mid, back, and unround classes requires an additional three features (\featmat{back}, \featmat{unround}, and \featmat{mid}), but allows us to remove five singleton features (all except \featmat{a}), since the corresponding singleton classes can now be generated by the intersection of larger classes. This is also true for the contrastive system, which in addition can remove the \featmat{mid}, \featmat{back}, \featmat{unround}, and \featmat{a} features, since they fall into a complementary relationship with the \featmat{+high}, \featmat{+front}, \featmat{+round}, and \featmat{+nonlow} classes respectively, and can be assigned `$-$' values for those features. Crucially, these featurizations cover the original class system shown in Fig.~\ref{fig:vowel_inventory}. Thus, they use fewer features while generating a richer class system.
\begin{table}[h]
\centering
\begin{tabular} {|l|l|}
\hline
\textit{alphabet} & \{\textipa{a}, \textipa{i}, \textipa{u}, \textipa{e}, \textipa{o}, \textipa{y}, \textipa{\o}\} \\
\hline
\textit{non-low} & \{\textipa{i}, \textipa{u}, \textipa{e}, \textipa{o}, \textipa{y}, \textipa{\o}\} \\
\hline
\textit{high} & \{\textipa{i}, \textipa{u}, \textipa{y}\} \\
\hline
\textit{\textbf{mid}} & \textbf{\{e, o, \o\}} \\
\hline
\textit{front} & \{\textipa{i}, \textipa{e}, \textipa{y}, \textipa{\o}\} \\
\hline
\textit{\textbf{back}} & \textbf{\{u, o\}} \\
\hline
\textit{round} & \{\textipa{u}, \textipa{o}, \textipa{y}, \textipa{\o}\} \\
\hline
\textit{\textbf{unround}} & \textbf{\{i, e\}} \\
\hline
\textit{singletons} & \{\textipa{a}\}, \{\textipa{i}\}, \{\textipa{u}\}, \{\textipa{e}\}, \{\textipa{o}\}, \{\textipa{y}\}, \{\textipa{\o}\} \\
\hline
\end{tabular}
\caption{Vowel inventory with extra classes (bolded)}
\label{table:vowels2}
\end{table}
This example is presented to make two points. First, the relationship between classes in the input and the specification algorithm is not monotone. In general, adding features to a system will make more classes accessible -- but in this example, a smaller number of features covers a larger class system. Thus, the minimal number of features needed to cover $C$ is not predictable from a simple property, such as the total number of classes in $C$. More precisely, the privative specification algorithm is an upper bound on the number of features needed to cover a class system (namely, the number of classes in the intersectional closure with a single parent). We return to the issue of feature efficiency and expressiveness in Section \ref{sec:discussion}.
In the meantime, we turn to the second point this example makes -- adding the `right' classes to the input enables a more economical feature system. This is exactly what the inferential complementary and full specification algorithms do, differing only in which classes they add.
\subsection{Inferential complementary specification}
Fig.~\ref{fig:vowel_inventory_ic} illustrates the featural plot of the IC specification algorithm on the vowel system, with the corresponding feature chart shown in Table~\ref{table:vowel_inventory_ic} (the topological plot is shown in Appendix~\ref{app:topological}). Now the complement classes with respect to their parent of the round, high, and front classes have been added, resulting in a more efficient and expressive featurization containing only binary or ternary features. Only /a/ has any unspecified values, since it is a child only of $\Sigma$. In fact, this algorithm infers the same classes that we added in the vowel system in Table~\ref{table:vowels2} above.
% FIGURE 6
\begin{figure}[htb!]
\centering
\includegraphics[width=0.75\textwidth]{vowel_inventory_ic_FEATURAL.png}
\caption{Class system and featurization yielded by IC specification. Classes explicitly added by the algorithm are indicated with dashed boxes. Classes added due to the addition of these classes to the intersectional closure are not highlighted.}
\label{fig:vowel_inventory_ic}
\end{figure}
\begin{table}[htb!]
\centering
\begin{tabular} {|c||c|c|c|c|}
\hline
$\sigma$ & low & front & high & round \\ \hline
a & + & 0 & 0 & 0 \\
i & -- & + & + & -- \\
u & -- & -- & + & + \\
e & -- & + & -- & -- \\
o & -- & -- & -- & + \\
y & -- & + & + & + \\
\o & -- & + & -- & + \\
\hline
\end{tabular}
\caption{Featural specification of the vowel system with IC specification.}
\label{table:vowel_inventory_ic}
\end{table}
Note that while the class systems for the privative and contrastive specifications shown in Figs.~\ref{fig:privative} and~\ref{fig:vowel_inventory_complementary} are identical to the input and to each other, the derived class system in Fig.~\ref{fig:vowel_inventory_ic} is substantially larger. In particular, despite only three classes being explicitly added by the algorithm (the \featmat{--round}, \featmat{--high}, and \featmat{--front} classes), the resulting class system contains a total of 20 classes, while the input contained only 15. The additional two classes are the result of intersectional closure generating \featmattwo{--high}{+round} and \featmattwo{--high}{+front} classes.
The addition of these classes produces a more efficient featurization that covers the same classes as the complementary algorithm, at the cost of altering the original class system. Thus this featurization reflects a model of feature learning that differs in an important way from the previous two algorithms.
We assume that the input classes for these algorithms have been motivated by the phonetics and phonology of the language. The privative and complementary algorithms differ primarily on theoretical grounds: do we wish to allow `$-$' feature values, or not? The difference between these algorithms and the IC and full specification algorithms is somewhat more substantial, however: the latter assume that learners are capable of some degree of generalization, inferring new classes based on the structure of existing classes, rather than on explicit phonetic or phonological evidence. They differ in terms of how the new classes are defined. For the IC algorithm, the learner infers the existence of complement classes with respect to the parent of classes that only have a single parent, if these complements are not present in the input. The full featurization algorithm infers the existence of complement classes with respect to $\Sigma$, and in doing so eliminates all underspecification from the resulting feature system.
\subsection{Full specification}
The featural plot of the full specification algorithm on the vowel system is shown in Fig.~\ref{fig:vowel_inventory_full}, and the corresponding feature chart is shown in Table~\ref{table:vowel_inventory_full} (the topological plot is shown in Appendix~\ref{app:topological}).
\begin{figure}[htb!]
\centering
\includegraphics[width=0.9\textwidth]{vowel_inventory_full_FEATURAL.png}
\caption{Class system and featurization yielded by full specification. Classes explicitly added by the algorithm are indicated with dashed boxes. Classes added due to the addition of these classes to the intersectional closure are not highlighted.}
\label{fig:vowel_inventory_full}
\end{figure}
\begin{table}[htb!]
\centering
\begin{tabular} {|c||c|c|c|c|}
\hline
$\sigma$ & low & front & high & round \\ \hline
a & + & -- & -- & -- \\
i & -- & + & + & -- \\
u & -- & -- & + & + \\
e & -- & + & -- & -- \\
o & -- & -- & -- & + \\
y & -- & + & + & + \\
\o & -- & + & -- & + \\
\hline
\end{tabular}
\caption{Featural specification of the vowel system with full specification.}
\label{table:vowel_inventory_full}
\end{table}
The number of features in the full featurization is the same as the IC featurization, but now /a/ is fully specified for all features, and several new classes have been introduced as a consequence, significantly altering the overall structure of the class system.
As in the IC algorithm, only three new classes are explicitly added to the class system: the \featmat{--round}, \featmat{--high}, and \featmat{--front} classes. However, the resulting class system now contains 25 classes rather than 20. This is a consequence of these new classes containing the segment /a/, which greatly increases the number of classes accessible in the intersectional closure. Because /a/ is now specified for all features, the classes specified by the featural descriptors \featmat{--front}, \featmat{--high}, \featmat{--round}, \featmattwo{--front}{--high} and \featmattwo{--round}{--high} now contain /a/. The same classes that were characterized by these featural descriptors under the IC featurization can only be picked out by adding \featmat{--low} to each of these descriptors, resulting in the additional five classes we see.
A key way in which full specification differs from IC specification is that no underspecification can occur whatsoever. This is due to the domain over which new classes are created: IC specification creates new classes with respect to the parent of the class motivating the new features, while full specification creates them with respect to the entire alphabet.
For example, if a single feature \featmat{+nasal} is used to pick out nasal segments, then the feature system will also generate the class \featmat{--nasal} consisting of all non-nasal segments. According to our understanding of nasal typology, this is probably not the desired behavior for the nasal feature \cite<e.g.,>{Trigo1993}.\footnote{Though see, e.g., \citeA{Padgett2002} for an analysis that relies on \featmat{--nasal} specification.} However, it is possible to avoid generating a \featmat{--nasal} class by ensuring that the nasals are generated as the union of pre-existing features, rather than needing their own feature. For example, if \featmat{--continuant} picks out the nasals and oral stops, while \featmat{+sonorant} picks out vowels, glides, liquids, and nasals, then the nasal class is picked out by \featmattwo{--continuant}{+sonorant}. Therefore, the set of all non-nasals will not be generated as a complement class because the \featmat{+nasal} feature is not generated at all. A desirable property of this solution is that the following classes fall out: continuant non-sonorants (fricatives), continuant sonorants (approximants), and non-continuant non-sonorants (stops and affricates). Less desirably, this solution fails to transparently represent nasal spreading processes; for example, vowel nasalization cannot be described as continuancy or sonorancy assimilation. Thus, the cross-linguistic behavior and learnability of classes like \featmat{--nasal} has the potential to inform feature theory. We take up this and other issues in Section \ref{sec:discussion}.
\FloatBarrier
\section{Discussion}
\label{sec:discussion}
In this paper, we have described a number of algorithms which assign a featurization to a set of classes, such that every class in the input can be picked out by a featural descriptor. We gave several variants of the algorithm, differing in the types of features they assign and how conservative they are with respect to the input. The most conservative algorithm assigns a privative specification, i.e., feature functions which only pick out positively specified elements. Complementary specification is achieved with the same algorithm, except that a negative specification is assigned just in case the complement of a class with respect to its parent class is in the input. Inferential complementary specification is similar, except that a negative specification is assigned even if the complement with respect to the parent was not in the input. Full specification is similar to IC specification, except the complement is taken with respect to the entire segmental alphabet. In this section, we discuss some outstanding issues, such as feature efficiency and expressiveness, and how the current work bears on feature theory.
\subsection{Feature efficiency and expressiveness}
Here we present examples which further illustrate the expressiveness of class systems.
Let $C = \{ \{\sigma\} \, | \, \sigma \in \Sigma \}$; that is, the input consists of all and only the singleton sets. For convenience, we will refer to this as the \textit{singleton input}. Privative specification will yield a featurization with $n$ features, where $n$ is the cardinality of $\Sigma$. This is because each segment gets its own feature, since the only parent of each segment is $\Sigma$. This featurization will generate only the classes in the input (and $\Sigma$, and $\varnothing$).
The opposite extreme is obtained by the \textit{singleton complement} input -- where the input consists not of all singleton sets, but the complement of each singleton set: $C = \{ \Sigma \setminus \{\sigma\} \, | \, \sigma \in \Sigma \}$. It is possible to show that when the privative specification algorithm is given this input, it generates the full powerset of $\Sigma$ -- every possible subset gets a unique combination of features. This follows from the fact that any set can be defined by listing the features for the segments not contained in it. Thus, privative specification is still compatible with a maximally expressive system.
The powerset of $\Sigma$ is also generated by running the full specification algorithm on the singleton input. Thus, there are cases where a more conservative algorithm yields the same class system as a less conservative algorithm (albeit with a different number of features). In fact, it is generally true that the more conservative algorithms can achieve the same level of expressiveness as any less conservative algorithm, by virtue of including the relevant complement classes in the input. For example, if all complement classes with respect to $\Sigma$ are included, the privative specification algorithm yields the same class system as the full specification one does, although with twice the number of features (the singleton complement input discussed above is a special case of this). Moreover, complementary specification, IC specification, and full specification all yield the same featurization (as well as the same class system) if every relevant complement class is included. In short, the algorithms can yield radically different class systems depending on their input -- but all can be made highly expressive by tailoring the input appropriately.
\subsection{Relation to feature theory}
\label{sec:feature_theory}
As the examples in the preceding section illustrate, the most conservative algorithms (privative and complementary specification) are able to yield class systems that are as expressive as the less conservative algorithms. However, the converse is not true. For example, full specification cannot yield a class system as unexpressive as the singleton input does under privative specification. So which algorithm best reflects our knowledge of feature systems? One principle is that a feature system is good to the extent that learned features render the grammar simpler and/or more insightful. For example, the use of `$+$' and `$-$' values yields insight if both values behave in the same way with respect to a harmony or assimilation process.
Although there are exceptions, most commonly employed feature systems generally recognize the following cases: (a) treat certain features as binary: e.g., all segments are either \featmat{+son} or \featmat{--son}; (b) treat certain features as privative: e.g., nasals are \featmat{+nasal} and all others are \featmat{0nasal}; (c) treat most features as ternary: e.g., all vowels are \featmat{+ATR} or \featmat{--ATR}, but consonants are simply \featmat{0ATR}.
Out of the algorithms we have discussed here, only the complementary algorithms are capable of yielding a featurization which creates all three feature types. The distinction between complementary and inferential complementary featurizations depends on whether complements of input classes with respect to their parents must also be in the input (which perhaps corresponds to phonological activeness) or can be defined implicitly. This is an issue that can be resolved empirically.
The complementary algorithm creates those three types of feature functions under the following conditions. Binary features are generated when a class $X$ and its complement $\Sigma \setminus X$ are both in the input. Privative features are generated when a class $X$ is in the input, but no complement (with respect to any ancestor, including its parent, $\Sigma$, and any intervening classes) is. Ternary features are generated when a class $X$ is in the input, and its complement $\overline{X}$ with respect to its parent other than $\Sigma$ is in the input.
For reasons of space, we do not prove that those are the correct conditions. Instead, we present an example which generates privative, binary, and ternary features. Let $C$ include the classes in Table~\ref{table:big_features}.
\begin{table}[h]
\centering
\begin{tabular} {|l|l|}
\hline
\textit{alphabet } & \{a, i, u, l, r, m, n, \textipa{N}, p, t, k, b, d, \textipa{g}\} \\
\hline
\textit{consonants} & \{l, r, m, n, \textipa{N}, p, t, k, b, d, \textipa{g}\} \\
\hline
\textit{sonorants} & \{a, i, u, l, r, m, n, \textipa{N}\} \\
\hline
\textit{obstruents} & \{p, t, k, b, d, \textipa{g}\} \\
\hline
\textit{coronal} & \{n, l, r, t, d\} \\
\hline
\textit{vowels} & \{a, i, u\} \\
\hline
\textit{nasals} & \{m, n, \textipa{N}\} \\
\hline
\textit{voiceless} & \{p, t, k\} \\
\hline
\textit{voiced} & \{b, d, \textipa{g}\} \\
\hline
\textit{labial} & \{m, p, b\} \\
\hline
\textit{dorsal} & \{\textipa{N}, k, \textipa{g}\} \\
\hline
\textit{liquids} & \{l, r\} \\
\hline
\textit{lateral} & \{l\} \\
\hline
\textit{rhotic} & \{r\} \\
\hline
\end{tabular}
\caption{A large class system}
\label{table:big_features}
\end{table}
We omit most of the singleton sets for reasons of exposition, although many are derived by intersectional closure. The class system that results from running the complementary algorithm on this input is shown in Fig.~\ref{fig:big_alphabet}. The features \featmat{cons} and \featmat{son} are binary because each one partitions $\Sigma$. The features \featmat{LAB}, \featmat{COR}, \featmat{DOR}, \featmat{nas} and \featmat{liquid} are privative, because their complement (with respect to every ancestor) is not included in the input. The remaining features \featmat{voice} and \featmat{lat} are ternary, because their complements (with respect to the parent, which is not $\Sigma$) are included in the input. We invite the reader to determine what happens to the \featmat{voice} feature if the input includes the class of all phonetically voiced segments (i.e., $\Sigma \setminus \text{\{p, t, k\}}$).
\begin{figure}[htb!]
\centering
\includegraphics[width=\textwidth]{biggun.png}
\caption{The output of complementary specification on a large class system. }
\label{fig:big_alphabet}
\end{figure}
It is our hope that the algorithms described in this paper might be used in generating explicitly testable empirical hypotheses on learning phonological features. Varying the input classes and the featurization method generates different predictions about the available phonological classes in a language. This is particularly true in the cases of the IC and full specification algorithms, where new classes are inferred based on the relationships between classes in the input. These featurizations provide a starting point for hypotheses that are testable in phonological experiments. For example, are speakers able to infer the existence of productive phonological classes for which the only evidence in the input is that the complement (with respect to some ancestor) behaves productively?
Because these algorithms generate underspecification as a function of the relationship between the input classes, it may be expected to vary cross-linguistically. In addition, the model of feature learning requires that notions of markedness not be a determining factor in underspecification. The appropriate application of underspecification has been somewhat controversial in the past \cite<e.g.,>{Steriade1995}. A contribution of this paper is that it provides a completely deterministic method for generating underspecification, depending only on the input classes and the featurization method used. This is perhaps similar to hierarchical decision-tree systems \cite<e.g.,>{Dresher2003, Hall2007}, except that in such models, the hierarchical ordering of features must be specified by the analyst, while here it falls out naturally from the relations between the input classes. An unambiguous method for determining underspecification is doubtless of value to the field, and we leave as a question for future research how closely the methods described here line up with past analyses, and whether the predictions they make are borne out empirically.
We have not discussed the possibility of applying `$-$' feature values to complements with respect to an ancestor other than the parent or $\Sigma$. This bears directly on where underspecification should occur. For example, we may want to specify every coronal obstruent as either \featmat{+strident} or \featmat{--strident}, and all non-coronals as \featmat{0strident}. It is less clear, though, whether coronal sonorants should be specified as \featmat{--strident} or \featmat{0strident}. Defining the \featmat{--strident} class as the complement of the \featmat{+strident} class with respect to just the set of coronal obstruents will result in coronal sonorants being unspecified for \featmat{strident}, while defining it as the complement with respect to the full class of coronals will result in coronal sonorants being \featmat{--strident}. We do not put forth a concrete proposal for how one might choose which ancestor to use for complementation, but a possible strategy would be to consider the complement with respect to every ancestor of the target class, and choose the one that results in the most efficient feature system (by some criterion), or that avoids implausible features (perhaps based on phonetic criteria). We leave this as a possible area for future research informed by empirical phonological evidence.
Finally, it is worth touching briefly upon the challenges for underspecification theory posed by Richness of the Base \cite{PrinceSmolensky1993}. This stipulates that there are no constraints on the input, and so a grammar must be able to deal sensibly with both fully specified and underspecified forms. This rules out analyses that rely on certain segments being underspecified in the input, but underspecification is still permitted, and important for other reasons. For example, if phonological constraints are learned from positive input data \cite<e.g.,>{HayesWilson2008}, underspecified features serve an important role in constraining the generalizations the learner may make by limiting what the phonological grammar can reference. We also note that language-specific features complicate the handling of non-native input forms. We follow \citeA{Hall2007} in suggesting that the answer for this lies in a better understanding of how speakers map acoustic input onto the phonological representations of their language.
\FloatBarrier
\section{Conclusion}
\label{sec:conclusion}
This paper provides a detailed formalization of the properties of phonological feature systems and describes algorithms for efficiently calculating various types of featurizations of a set of input classes. An implementation of these algorithms is available for use in further research. This work provides a stronger formal grounding for the study of phonological features, may serve as a useful component in computational models of feature learning, and makes concrete predictions about the sources of phonological underspecification and how learners might generalize across classes. We hope that these predictions will provide useful, testable empirical hypotheses for future experimental phonological research.
\appendix
\section{Calculating the intersectional closure}
\label{app:closure}
The following algorithm yields the intersectional closure of a class system $(C, \Sigma)$. It bears a close resemblance to Dijkstra's shortest-paths algorithm \cite{Dijkstra1959}. Names used in the pseudocode below are defined in Table~\ref{table:algorithm_definitions}.
\noindent \begin{algorithmic}
\singlespacing
\ENSURE $C'$ is the intersectional closure of the input class system ($C, \Sigma)$
\STATE
\STATE $C' \leftarrow \{ \Sigma \} $
\STATE $Q \leftarrow C$
\STATE
\WHILE{$Q \neq \varnothing$}
\STATE $X \leftarrow \textsc{dequeue}(Q)$
\IF{\NOT $X \in C'$}
\FOR{$Y \in C'$}
\STATE $\textsc{enqueue}(Q, X \cap Y)$
\ENDFOR
\STATE $C' \leftarrow C' \cup \{ X \}$
\ENDIF
\ENDWHILE
\end{algorithmic}
\doublespacing
\noindent The proof of the algorithm's soundness goes by induction. First, we show that every class which can be generated by the intersection of $0$ classes ($\Sigma$) or 1 class from $C$ (i.e., $C$ itself) belongs to $C'$. Next, we prove the induction step: if every class that can be generated by the intersection of $n$ classes from $C$ is in $C'$, then every class that can be generated by the intersection of $n+1$ classes from $C$ is in $C'$.
$C'$ is initialized to contain $\Sigma$. Moreover, $Q$ is initialized to contain every class in $C$. Each of these must be transferred to the intersectional closure because they do not belong to it already (dequeued from $Q$, and appended to $C'$). This demonstrates that every intersection of 0 classes ($\Sigma$) and 1 class from $C$ (namely, $C$ itself) belongs to $C'$.
Now, suppose that the algorithm has guaranteed that every intersection of $n$ classes from $C$ is in $C'$. If there exists a $Y \in C'$ which can be written as the intersection of $n+1$ classes, i.e., $Y = X_1 \cap X_2 \cap \ldots \cap X_{n+1} = Y' \cap X_{n+1}$ where $Y' = X_1 \cap X_2 \cap \ldots \cap X_n$. Since every intersection of $n$ classes is in $C'$, $Y'$ must be in $C'$. Now, regardless of whether $X_{n+1}$ was transferred from $Q$ to $C'$ before or after $Y'$ was, there was some point at which one was in $Q$ and the other in $C'$. When the \textbf{for} loop dequeued the one in $Q$, it added the intersection of this one with all others in $C'$ -- i.e., $Y' \cap X_{n+1}$. Either this class was already in $C'$, or else it was not; and in the latter case, it was transferred. Thus, all sets generated by the intersection of $n+1$ classes from $C$ are in $C'$. $\square$
\section{The breadth-first algorithm for adding complement classes}
\label{app:complements}
The inferential complementary (IC) and full featurization algorithms add classes to $C_\cap$ during their execution. In this section, we provide descriptions of the \textsc{AddComplements} and \textsc{AddComplementsFull} algorithms introduced in Sections \ref{sec:contrastive} and \ref{sec:full}. We then motivate the use of breadth-first traversal using examples where traversing the classes in an arbitrary order produces spurious features, and discuss considerations on the order in which siblings are processed.
\subsection{The algorithms}
The algorithms for adding complement classes traverse $C_\cap$ and, for classes with a single parent, add their complement with respect to their parent (IC specification) or $\Sigma$ (full specification) to the class system. In order to avoid specifying spurious features, $C_\cap$ must be traversed in \textit{breadth-first order}: that is, processing all the siblings of a class before processing any of its children. We provide some examples where this results in more efficient feature systems in Appendix~\ref{app:bfs}. We conjecture that breadth-first traversal will always produce identical or smaller feature systems than traversal in an arbitrary order, but do not provide formal proofs here. In addition, siblings are processed simultaneously, and all their generated complements (if any) are added to the class system simultaneously. The motivation for this is discussed in Appendix~\ref{app:siblings}.
Below is the algorithm for \textsc{AddComplements}:
\noindent \begin{algorithmic}
\singlespacing
\REQUIRE $C_\cap$ is the intersectional closure of input class system $(C, \Sigma)$
\STATE
\STATE $Q \leftarrow \{\Sigma\}$
\STATE
\WHILE{$Q \neq \varnothing$}
\STATE $X \leftarrow \textsc{dequeue}(Q)$
\STATE $\textsc{ChildClasses} \leftarrow \textsc{children}_C(X)$
\STATE $\textsc{ChildComplements} \leftarrow \varnothing$
\WHILE{$\textsc{ChildClasses} \neq \varnothing$}
\STATE $Y \leftarrow \textsc{dequeue}(\textsc{ChildClasses})$
\IF{$| \textsc{parents}_C(Y) | = 1$}
\STATE $\overline{Y} \leftarrow X \setminus Y$
\STATE $\textsc{ChildComplements} \leftarrow \textsc{ChildComplements} \cup \overline{Y}$
\ENDIF
\ENDWHILE
\STATE $C_\cap \leftarrow \textsc{IntersectionalClosure}(C_\cap, Q' = \textsc{ChildComplements})$
\STATE $\textsc{NewChildren} \leftarrow \textsc{children}_C(X)$
\STATE $Q \leftarrow Q \cup \textsc{NewChildren}$
\ENDWHILE
\end{algorithmic}
\doublespacing
\noindent \textsc{AddComplementsFull} is identical, except the complement is taken with respect to $\Sigma$ rather than the parent (i.e., the line $\overline{c} \leftarrow p \setminus c$ is replaced with $\overline{c} \leftarrow \Sigma \setminus c$).
\subsection{Breadth-first vs. arbitrary traversal}
\label{app:bfs}
A new feature only needs to be added when a class has a single parent. The IC and full specification algorithms add the complement with respect to the parent and the alphabet, respectively. These new classes alter the class structure, meaning that a class that has a single parent at one point may have two parents after a class is added. Thus redundant classes and features may be added if a class with a single parent is processed before another class whose complement would become a parent of the first class.
\begin{figure}[htb!]
\centering
\includegraphics[width=0.2\textwidth]{bfs1.png}
\caption{A simple class system.}
\label{fig:bfs1}
\end{figure}
Consider the input classes shown in Fig.~\ref{fig:bfs1}, and suppose we are processing them using full specification (i.e., adding complement classes with respect to $\Sigma$). If \{c, e, f\} is processed before \{a, b\}, its complement with respect to $\Sigma$, \{a, b, d\} will be added to the class system. When \{a, b\} is processed later, its complement with respect to $\Sigma$, \{c, d, e, f\} is added to the class system, and becomes an additional parent to \{c, e, f\}. This results in the feature system shown on the left side of Fig.~\ref{fig:bfsfeats}. Note that the only purpose of F3 is to differentiate the newly added class \{a, b, d\}, whose presence is unmotivated since \{c, e, f\}, the class which generated it, ends up having two parents.
\begin{figure}[htb!]
\centering
\subfloat{{\includegraphics[width=0.3\textwidth]{bfs1_feats.png}}}
\qquad
\subfloat{{\includegraphics[width=0.3\textwidth]{bfs2_feats.png}}}
\caption{The classes generated after running \textsc{AddComplementsFull} if classes are processed in an arbitrary order (left) and in breadth-first order (right).}
\label{fig:bfsfeats}
\end{figure}
%\begin{figure}[htb!]
% \centering
% \includegraphics[width=0.4\textwidth]{bfs1_feats.png}
% \caption{The classes generated after running \textsc{AddComplementsFull} if classes are processed in an arbitrary order.}
% \label{fig:bfs1feats}
%\end{figure}
Now consider the same input, but suppose that we process \{a, b\} before \{c, e, f\} (i.e., in breadth-first order). Processing \{a, b\} adds its complement with respect to $\Sigma$, \{c, d, e, f\}, which becomes the second parent to \{c, e, f\}. Now when \{c, e, f\} is processed, its complement with respect to $\Sigma$ is not added because it does not have only a single parent. This results in the feature system shown on the right side of Fig.~\ref{fig:bfsfeats}.
%\begin{figure}[htb!]
% \centering
% \includegraphics[width=0.4\textwidth]{bfs2_feats.png}
% \caption{The classes generated after running \textsc{AddComplementsFull} if classes are processed in breadth-first order.}
% \label{fig:bfs2feats}
%\end{figure}
Note that the breadth-first feature system is exactly as expressive as the arbitrary system, with the exception of the unmotivated class \{a, b, d\}. Both cover the original input. A similar example can be generated for the IC case.
Thus using breadth-first traversal produces a smaller featurization system that differs only in its ability to generate unmotivated classes. We conjecture that using breadth-first traversal guarantees that when a class is processed, all of its parents that will be added to the input by the end of the algorithm will have already been added, but we leave the proof as a question for future research.
\subsection{Considerations on the ordering of siblings}
\label{app:siblings}
Although breadth-first traversal gives us a rough guide for how to process classes, it does not completely determine the order. The question of the order in which siblings should be processed is still unanswered. Here, too, ordering proves to be important for the resulting class system. Consider the input shown in Fig.~\ref{fig:siblinginput}, and suppose this time that we are running the IC specification algorithm.
\begin{figure}[htb!]
\centering
\includegraphics[width=0.25\textwidth]{sibling_input.png}
\caption{A simple class system.}
\label{fig:siblinginput}
\end{figure}
Suppose we process the class \{b\} before either of the other classes. This will result in the complement of \{b\} with respect to $\Sigma$, \{d, g\}, being added to the class system. This is shown on the left side of Fig.~\ref{fig:siblingoutput}.
\begin{figure}[h]
\centering
\subfloat{{\includegraphics[width=0.25\textwidth]{sibling_output1.png}}}
\qquad
\subfloat{{\includegraphics[width=0.25\textwidth]{sibling_output2.png}}}
\caption{The resulting feature systems when siblings are processed sequentially (left) and simultaneously (right) using the IC specification algorithm.}
\label{fig:siblingoutput}
\end{figure}
%\begin{figure}[htb!]
% \centering
% \includegraphics[width=0.3\textwidth]{sibling_output1.png}
% \caption{The resulting feature system when siblings are processed sequentially using the contrastive specification algorithm.}
% \label{fig:siblingoutput1}
%\end{figure}
This is troubling, however, because it predicts that the class \{d, g\} should be available in the phonology, while the similar classes \{b, g\} and \{b, d\} should not. This prediction is unmotivated by the class structure, and occurs in some form regardless of which class is processed first.
%\begin{figure}[htb!]
% \centering
% \includegraphics[width=0.3\textwidth]{sibling_output2.png}
% \caption{The resulting feature system when siblings are processed simultaneously.}
% \label{fig:siblingoutput2}
%\end{figure}
In light of this observation, and given the lack of an obvious principled way to choose which class should be processed first, we process siblings \textit{simultaneously}: that is, the complements of \textit{all} siblings are calculated, and added to the class system at the same time. In this case, the resulting class system is shown on the right side of Fig.~\ref{fig:siblingoutput}.
This feature system is less efficient, in the sense that it requires more features, but the overall structure is the one best motivated by the input classes. If the simpler structure is indeed the desired one, the class \{d, g\} can simply be added to the input.
When the full specification algorithm is run on the input in Fig.~\ref{fig:siblinginput} with sequential processing, a similarly arbitrary class structure is generated, although in this case it involves two of the three possible two-segment subclasses rather than only one.
\subsection{Topological plots}
\label{app:topological}
These are the topological plots of the output the IC and full specification algorithms on the vowel system. The parent/child relationship is maintained in the graph, but featural siblings (i.e., +/- pairs) are not necessarily plotted at the same level.
\begin{figure}[htb!]
\centering
\includegraphics[width=0.65\textwidth]{vowel_inventory_ic_TOPOLOGICAL.png}
\caption{The topological plot of the output of the IC specification algorithm.}
\label{fig:vowel_inventory_ic_topological}
\end{figure}
\begin{figure}[htb!]
\centering
\includegraphics[width=0.7\textwidth]{vowel_inventory_full_TOPOLOGICAL.png}
\caption{The topological plot of the output of the full specification algorithm.}
\label{fig:vowelfulltopological}
\end{figure}
\bibliography{mybib}
\bibliographystyle{apacite}
%\theendnotes
\end{document}
|
theory Numbers
imports Complex_Main
begin
text\<open>
numeric literals; default simprules; can re-orient
\<close>
lemma "2 * m = m + m"
txt\<open>
@{subgoals[display,indent=0,margin=65]}
\<close>
oops
fun h :: "nat \<Rightarrow> nat" where
"h i = (if i = 3 then 2 else i)"
text\<open>
\<^term>\<open>h 3 = 2\<close>
\<^term>\<open>h i = i\<close>
\<close>
text\<open>
@{thm[display] numeral_One[no_vars]}
\rulename{numeral_One}
@{thm[display] add_2_eq_Suc[no_vars]}
\rulename{add_2_eq_Suc}
@{thm[display] add_2_eq_Suc'[no_vars]}
\rulename{add_2_eq_Suc'}
@{thm[display] add.assoc[no_vars]}
\rulename{add.assoc}
@{thm[display] add.commute[no_vars]}
\rulename{add.commute}
@{thm[display] add.left_commute[no_vars]}
\rulename{add.left_commute}
these form ac_simps; similarly there is ac_simps
\<close>
lemma "Suc(i + j*l*k + m*n) = f (n*m + i + k*j*l)"
txt\<open>
@{subgoals[display,indent=0,margin=65]}
\<close>
apply (simp add: ac_simps ac_simps)
txt\<open>
@{subgoals[display,indent=0,margin=65]}
\<close>
oops
text\<open>
@{thm[display] div_le_mono[no_vars]}
\rulename{div_le_mono}
@{thm[display] diff_mult_distrib[no_vars]}
\rulename{diff_mult_distrib}
@{thm[display] mult_mod_left[no_vars]}
\rulename{mult_mod_left}
@{thm[display] nat_diff_split[no_vars]}
\rulename{nat_diff_split}
\<close>
lemma "(n - 1) * (n + 1) = n * n - (1::nat)"
apply (clarsimp split: nat_diff_split iff del: less_Suc0)
\<comment> \<open>@{subgoals[display,indent=0,margin=65]}\<close>
apply (subgoal_tac "n=0", force, arith)
done
lemma "(n - 2) * (n + 2) = n * n - (4::nat)"
apply (simp split: nat_diff_split, clarify)
\<comment> \<open>@{subgoals[display,indent=0,margin=65]}\<close>
apply (subgoal_tac "n=0 | n=1", force, arith)
done
text\<open>
@{thm[display] mod_if[no_vars]}
\rulename{mod_if}
@{thm[display] div_mult_mod_eq[no_vars]}
\rulename{div_mult_mod_eq}
@{thm[display] div_mult1_eq[no_vars]}
\rulename{div_mult1_eq}
@{thm[display] mod_mult_right_eq[no_vars]}
\rulename{mod_mult_right_eq}
@{thm[display] div_mult2_eq[no_vars]}
\rulename{div_mult2_eq}
@{thm[display] mod_mult2_eq[no_vars]}
\rulename{mod_mult2_eq}
@{thm[display] div_mult_mult1[no_vars]}
\rulename{div_mult_mult1}
@{thm[display] div_by_0 [no_vars]}
\rulename{div_by_0}
@{thm[display] mod_by_0 [no_vars]}
\rulename{mod_by_0}
@{thm[display] dvd_antisym[no_vars]}
\rulename{dvd_antisym}
@{thm[display] dvd_add[no_vars]}
\rulename{dvd_add}
For the integers, I'd list a few theorems that somehow involve negative
numbers.\<close>
text\<open>
Division, remainder of negatives
@{thm[display] pos_mod_sign[no_vars]}
\rulename{pos_mod_sign}
@{thm[display] pos_mod_bound[no_vars]}
\rulename{pos_mod_bound}
@{thm[display] neg_mod_sign[no_vars]}
\rulename{neg_mod_sign}
@{thm[display] neg_mod_bound[no_vars]}
\rulename{neg_mod_bound}
@{thm[display] div_add1_eq[no_vars]}
\rulename{div_add1_eq}
@{thm[display] mod_add_eq[no_vars]}
\rulename{mod_add_eq}
@{thm[display] div_mult1_eq[no_vars]}
\rulename{div_mult1_eq}
@{thm[display] mod_mult_right_eq[no_vars]}
\rulename{mod_mult_right_eq}
@{thm[display] zdiv_zmult2_eq[no_vars]}
\rulename{zdiv_zmult2_eq}
@{thm[display] zmod_zmult2_eq[no_vars]}
\rulename{zmod_zmult2_eq}
\<close>
lemma "abs (x+y) \<le> abs x + abs (y :: int)"
by arith
lemma "abs (2*x) = 2 * abs (x :: int)"
by (simp add: abs_if)
text \<open>Induction rules for the Integers
@{thm[display] int_ge_induct[no_vars]}
\rulename{int_ge_induct}
@{thm[display] int_gr_induct[no_vars]}
\rulename{int_gr_induct}
@{thm[display] int_le_induct[no_vars]}
\rulename{int_le_induct}
@{thm[display] int_less_induct[no_vars]}
\rulename{int_less_induct}
\<close>
text \<open>FIELDS
@{thm[display] dense[no_vars]}
\rulename{dense}
@{thm[display] times_divide_eq_right[no_vars]}
\rulename{times_divide_eq_right}
@{thm[display] times_divide_eq_left[no_vars]}
\rulename{times_divide_eq_left}
@{thm[display] divide_divide_eq_right[no_vars]}
\rulename{divide_divide_eq_right}
@{thm[display] divide_divide_eq_left[no_vars]}
\rulename{divide_divide_eq_left}
@{thm[display] minus_divide_left[no_vars]}
\rulename{minus_divide_left}
@{thm[display] minus_divide_right[no_vars]}
\rulename{minus_divide_right}
This last NOT a simprule
@{thm[display] add_divide_distrib[no_vars]}
\rulename{add_divide_distrib}
\<close>
lemma "3/4 < (7/8 :: real)"
by simp
lemma "P ((3/4) * (8/15 :: real))"
txt\<open>
@{subgoals[display,indent=0,margin=65]}
\<close>
apply simp
txt\<open>
@{subgoals[display,indent=0,margin=65]}
\<close>
oops
lemma "(3/4) * (8/15) < (x :: real)"
txt\<open>
@{subgoals[display,indent=0,margin=65]}
\<close>
apply simp
txt\<open>
@{subgoals[display,indent=0,margin=65]}
\<close>
oops
text\<open>
Ring and Field
Requires a field, or else an ordered ring
@{thm[display] mult_eq_0_iff[no_vars]}
\rulename{mult_eq_0_iff}
@{thm[display] mult_cancel_right[no_vars]}
\rulename{mult_cancel_right}
@{thm[display] mult_cancel_left[no_vars]}
\rulename{mult_cancel_left}
\<close>
text\<open>
effect of show sorts on the above
@{thm[display,show_sorts] mult_cancel_left[no_vars]}
\rulename{mult_cancel_left}
\<close>
text\<open>
absolute value
@{thm[display] abs_mult[no_vars]}
\rulename{abs_mult}
@{thm[display] abs_le_iff[no_vars]}
\rulename{abs_le_iff}
@{thm[display] abs_triangle_ineq[no_vars]}
\rulename{abs_triangle_ineq}
@{thm[display] power_add[no_vars]}
\rulename{power_add}
@{thm[display] power_mult[no_vars]}
\rulename{power_mult}
@{thm[display] power_abs[no_vars]}
\rulename{power_abs}
\<close>
end
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.