Datasets:
AI4M
/

text
stringlengths
0
3.34M
[STATEMENT] lemma extendsE: assumes "extends R r" obtains "r \<subseteq> R" "asym_factor r \<subseteq> asym_factor R" [PROOF STATE] proof (prove) goal (1 subgoal): 1. (\<lbrakk>r \<subseteq> R; asym_factor r \<subseteq> asym_factor R\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis [PROOF STEP] using assms [PROOF STATE] proof (prove) using this: extends R r goal (1 subgoal): 1. (\<lbrakk>r \<subseteq> R; asym_factor r \<subseteq> asym_factor R\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis [PROOF STEP] unfolding extends_def [PROOF STATE] proof (prove) using this: r \<subseteq> R \<and> asym_factor r \<subseteq> asym_factor R goal (1 subgoal): 1. (\<lbrakk>r \<subseteq> R; asym_factor r \<subseteq> asym_factor R\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis [PROOF STEP] by blast
(* Title: HOL/Auth/n_germanish_lemma_inv__3_on_rules.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_germanish Protocol Case Study*} theory n_germanish_lemma_inv__3_on_rules imports n_germanish_lemma_on_inv__3 begin section{*All lemmas on causal relation between inv__3*} lemma lemma_inv__3_on_rules: assumes b1: "r \<in> rules N" and b2: "(\<exists> p__Inv0 p__Inv2. p__Inv0\<le>N\<and>p__Inv2\<le>N\<and>p__Inv0~=p__Inv2\<and>f=inv__3 p__Inv0 p__Inv2)" shows "invHoldForRule s f r (invariants N)" proof - have c1: "(\<exists> i. i\<le>N\<and>r=n_t1 i)\<or> (\<exists> i. i\<le>N\<and>r=n_t2 i)\<or> (\<exists> i. i\<le>N\<and>r=n_t3 i)\<or> (\<exists> i. i\<le>N\<and>r=n_t4 i)\<or> (\<exists> i. i\<le>N\<and>r=n_t5 i)\<or> (\<exists> i. i\<le>N\<and>r=n_t6 N i)" apply (cut_tac b1, auto) done moreover { assume d1: "(\<exists> i. i\<le>N\<and>r=n_t1 i)" have "invHoldForRule s f r (invariants N)" apply (cut_tac b2 d1, metis n_t1Vsinv__3) done } moreover { assume d1: "(\<exists> i. i\<le>N\<and>r=n_t2 i)" have "invHoldForRule s f r (invariants N)" apply (cut_tac b2 d1, metis n_t2Vsinv__3) done } moreover { assume d1: "(\<exists> i. i\<le>N\<and>r=n_t3 i)" have "invHoldForRule s f r (invariants N)" apply (cut_tac b2 d1, metis n_t3Vsinv__3) done } moreover { assume d1: "(\<exists> i. i\<le>N\<and>r=n_t4 i)" have "invHoldForRule s f r (invariants N)" apply (cut_tac b2 d1, metis n_t4Vsinv__3) done } moreover { assume d1: "(\<exists> i. i\<le>N\<and>r=n_t5 i)" have "invHoldForRule s f r (invariants N)" apply (cut_tac b2 d1, metis n_t5Vsinv__3) done } moreover { assume d1: "(\<exists> i. i\<le>N\<and>r=n_t6 N i)" have "invHoldForRule s f r (invariants N)" apply (cut_tac b2 d1, metis n_t6Vsinv__3) done } ultimately show "invHoldForRule s f r (invariants N)" by satx qed end
The female Seba`s Short-tailed Bats give birth about twice a year. The newborn babies weigh only about five grams and are completely dependent on their mothers. Like all mammals, they only drink their mother’s milk at first. When about three weeks old, the young bats start trying to fly by themselves. After eight weeks they get weaned and have to hunt for their own food. They have to eat a lot to acquire their final weight of 18-19 grams, which they reach when they are ten weeks old. Giving birth and raising Pim was too much for his mother, so she died when he was only a few weeks old. On March 12, 2011, the keepers found little Pim lying on the floor of the bat enclosure. He was so starved and weak that he was trembling all over and couldn’t hang from the ceiling by himself. Banana pulp was needed! Patiently, the little nursling was fed and cared for. With each day, Pim grew stronger and livelier. A few weeks later the day had come when the little youngster could be put into the enclosure with the other bats. At first, the change from banana pulp to whole fruit and a lot of flying around was very hard on Pim; quite a few times the keeper saw him just hanging there, taking a rest. Meanwhile, though, he has settled in and gets along fine with his fellows. Still, he remembers his keeper well. Sometimes he lands on her hand just like he used to when this was the place where he got his daily banana pulp. Like all mammals, baby bats depend on their mothers at first. They get fed, cleaned and protected. When the mothers hunt for food, the little ones come along, holding tight to their mother’s belly.
\section{Slot}\label{s:slot}
module CTL.Modalities.AF where open import FStream.Core open import Library -- Certainly sometime : s₀ ⊧ φ ⇔ ∀ s₀ R s₁ R ... ∃ i . sᵢ ⊧ φ -- TODO Unclear whether this needs sizes data AF' {ℓ₁ ℓ₂} {C : Container ℓ₁} (props : FStream' C (Set ℓ₂)) : Set (ℓ₁ ⊔ ℓ₂) where alreadyA : head props → AF' props notYetA : A (fmap AF' (inF (tail props))) → AF' props open AF' public AF : ∀ {ℓ₁ ℓ₂} {C : Container ℓ₁} → FStream C (Set ℓ₂) → Set (ℓ₁ ⊔ ℓ₂) AF props = APred AF' (inF props) mutual AFₛ' : ∀ {i ℓ₁ ℓ₂} {C : Container ℓ₁} → FStream' C (Set ℓ₂) → FStream' {i} C (Set (ℓ₁ ⊔ ℓ₂)) head (AFₛ' props) = AF' props tail (AFₛ' props) = AFₛ (tail props) AFₛ : ∀ {i ℓ₁ ℓ₂} {C : Container ℓ₁} → FStream C (Set ℓ₂) → FStream {i} C (Set (ℓ₁ ⊔ ℓ₂)) inF (AFₛ props) = fmap AFₛ' (inF props)
Formal statement is: lemma sum_Suc_reindex: fixes f :: "nat \<Rightarrow> 'a::ab_group_add" shows "sum f {0..n} = f 0 - f (Suc n) + sum (\<lambda>i. f (Suc i)) {0..n}" Informal statement is: For any function $f$ from the natural numbers to an abelian group, we have $\sum_{i=0}^n f(i) = f(0) - f(n+1) + \sum_{i=0}^n f(i+1)$.
\documentclass[12pt]{article} \usepackage{float} \usepackage{wrapfig} \input{def} \graphicspath{{figs/}} \begin{document} \title{Causal inference for process understanding in Earth sciences} \author{Adam Massmann\thanks{Corresponding author: [email protected]}, Pierre Gentine, Jakob Runge} \maketitle \begin{abstract} There is growing interest in the study of causal methods in the Earth sciences. However, most applications have focused on causal discovery, i.e. inferring the causal relationships and causal structure from data. This paper instead examines causality through the lens of causal {\it inference} and how expert-defined causal graphs, a fundamental from causal theory, can be used to clarify assumptions, identify tractable problems, and aid interpretation of results and their causality in Earth science research. We apply causal theory to generic graphs of the Earth system to identify where causal inference may be most tractable and useful to address problems in Earth science, and avoid potentially incorrect conclusions. Specifically, causal inference may be useful when: (1) the effect of interest is only causally affected by the observed portion of the state space; or: (2) the cause of interest can be assumed to be independent of the evolution of the system’s state; or: (3) the state space of the system is reconstructable from lagged observations of the system. However, we also highlight through examples that causal graphs can be used to explicitly define and communicate assumptions and hypotheses, and help to structure analyses, even if causal inference is ultimately challenging given the data availability, limitations and uncertainties. \end{abstract} \paragraph{Note:} We will update this manuscript as our understanding of causality's role in Earth science research evolves. Comments, feedback, and edits are enthusiastically encouraged, and we will add acknowledgments and/or coauthors as we receive community contributions. To edit the manuscript directly (recommended) you can fork the project's repository and submit a pull request at \url{https://github.com/massma/causality-earth-science}, or you can alternatively email us comments, questions, and suggestions and we will try to incorporate them into the manuscript. \section{Introduction} There is growing interest in the study of causal inference methods in the Earth sciences \citep[e.g.,][]{salvucci2002, ebert-uphoff2012, kretschmer2016,Green_2017,barnes-2019, samarasinghe2020,runge-causal-timeseries,runge2019inferring,goodwell-causality-2020}. However, most of this work focuses on causal discovery, or the inference (using data) of causal structure: i.e., the ``links'' and directions between variables. In some cases, causal discovery can be used to estimate the structure of a causal graph and the relationships between variables when the graph is not known a priori. However in many if not most Earth system applications, the causal graph is already known based on physical insights. For instance the impact of El Ni\~{n}o on West American rainfall is known to be causal and the graph does not need to be discovered (even though using causal discovery for this problem is a useful sanity check of the method's ability). This paper looks at causality through a different, but complementary, lens to causal discovery and examines how assumed causal graphs \citep{pearl1995causal}, a fundamental from causal theory, can be used to clarify assumptions, identify tractable problems, and aid interpretation of results in Earth science research. Our goal is to distill \citep[e.g.,][]{olah2017} the basics of the graphical approach to causality in a way that is relatable for Earth scientists, \textbf{hopefully motivating more widespread use and adoption of causal graphs to organize analyses and communicate assumptions}. These tools are relevant now more than ever, as the abundance of new data and novel analysis methods have inevitably led to more opaque results and barriers to the communication of assumptions. Beyond their usefulness as communication tools, if certain conditions are met, causal graphs can be used to estimate, from data, the generalized functional form of relationships between Earth science variables \citep{pearl2009causality}. Ultimately, deriving generalized functional relationships is a primary goal of science. While we know the functional relationships between some variables a priori, there are many relationships we do not know \citep[e.g., ecosystem scale water and carbon fluxes;][]{massmann2019, zhou2019arid, zhou2019feedback, grossiord2020}, or that we do know but are computationally intractable to calculate \citep[e.g., clouds and microphysics at the global scale:][]{randall2003, gentine2018, zadra2018, gagne2020emulation}. In these types of applications, causal graphs give us a path toward new scientific knowledge and hypothesis testing: generalized functional relationships that were inaccessible with traditional tools. The main contribution of this paper is to demonstrate how causal graphs, a fundamental tool of causal inference discussed in Section \ref{sec:what-caus-caus}, can be used to communicate assumptions, organize analyses and hypotheses, and ultimately improve scientific understanding and reproducibility. We want to emphasize that almost any study could benefit from inclusion of a causal graph in terms of communication and clarification of hypotheses, even if in the end the results cannot be interpreted causally. Causal graphs also encourage us to think deeply in the initial stages of analysis about hypotheses and how the system is structured, and can identify infeasible studies early in the research process before time is spent on analysis, acquiring data, building/running models, etc. These points require some background and discussion, so the paper is divided into the following sections: \begin{itemize} \item Section \ref{sec:what-caus-caus}: Introduces and discusses causal graphs within the general philosophy of causality and its application in Earth science. \item Section \ref{sec:causal-graphs-pearls}: Using a simple relatable example we explain the problem of confounders and how causal graphs can be used to isolate the functional mapping between interventions on some variable(s) to their effect on other variable(s). \item Section \ref{sec:causal-graphs-as}: We draw on a real example that benefits from inclusion of a causal graph, in terms of communicating assumptions, and organizing and justifying analyses. \item Section \ref{sec:necess-cond-caus}: We turn to more generic examples of graphs that are generally consistent with a wide variety of systems in Earth science, to highlight some of the difficulties we confront when using causal inference in Earth science and how we may be able to overcome these challenges. \end{itemize} Throughout the discussion key terms will be emphasized in italics. \section{The graphical perspective to causality and its usefulness in the Earth sciences}\label{sec:what-caus-caus} \begin{wrapfigure}{L}{0.35\textwidth} \includegraphics[]{cloud-aerosol.pdf} \caption{A toy graph example to demonstrate basic causal theory, involving cloud (C), aerosol (A), and surface solar radiation (S).} \label{fig:toy} \end{wrapfigure} While there are many different definitions and interpretations of ``causality'', for this manuscript we view causality through the lens of causal graphs, as introduced in \citet{pearl1995causal} and discussed more extensively in \citet{pearl2009causality}. We take this perspective because we believe causal graphs are useful in Earth science, rather than because of any particular philosophical argument for causal graphs as the ``true'' representation of causality. Causal graphs are Directed Acyclic Graphs (\emph{DAG}s) that encode our assumptions about the causal dependencies of a system. To make a causal graph, a domain expert simply draws directed edges (i.e. arrows) from variables that are causes to effects. In other words, to make a causal graph you draw a diagram summarizing the assumed causal links and directions between variables (e.g., Figure \ref{fig:toy}). Causal graphs are useful tools because they can be drawn by domain experts with no required knowledge of maths or probability, but they also represent formal mathematical objects. Specifically, underlying each causal graph are a set of equations called \emph{structural causal models}: each node corresponds to a generating function for that variable, and the inputs to that function are the node's parents. Parents are the other nodes in the graph that point to a node of interest (e.g., in the most simple graph $X \to Y$; $X$ is a parent of $Y$). So in reality, drawing arrows from ``causes'' to ``effects'' is synonymous with drawing arrows from function inputs to generating functions. In this way, drawing a causal graph is another way to visualize and reason about a complicated system of equations, which is a very useful tool for the Earth scientist: we deal with complicated interacting systems of equations and welcome tools that help us understand and reason about their collective behavior. In some cases we may know a priori (from physics) the equations for a given function in a causal graph. However, in practice we often either do not know all of the functions a priori \citep[e.g., plant stomata response to VPD;][]{massmann2019, zhou2019arid, zhou2019feedback, grossiord2020}, or some functions are computationally intractable to compute \citep[e.g., turbulence, moist convection, and cloud microphysics in large scale models;][]{zadra2018,gentine2018}. In these scenarios the benefits of causal graphs are fully realized: based on the causal graph we can calculate from data, using the \textit{do-}calculus \citep{pearl-1994-do-calculus}, the response of target variables (i.e. effects) to \textit{interventions} on any other variables in the graph (i.e. causes). When combined with statistical modeling (i.e., regression), one can estimate the functional relationship between interventions on causes and effects \citep{pearl2009,shalizi2013,shi2019adapting,mao2020generative}. By viewing causal graphs through this pragmatic lens of calculating the functional form of relationships that we do not know a priori, we simultaneously identify causal graphs' value for Earth scientists while also side stepping philosophical arguments about the meaning of causality. Causal graphs are pragmatic because in the Earth sciences we often need to estimate how the system responds to \emph{interventions} (prescribed changes to variables of interest, or ``causes''). For example, sub-grid physical parameterizations in Earth system models (e.g., turbulence) require estimates of the time tendencies' response to \emph{interventions} on the large scale state and environment. We also may desire to calculate experiments: for example how changing land cover from forest to grasslands affects (the statistics of) surface temperature. \textit{Do-}calculus is a method to calculate this response to interventions without relying on approximate numerical models or real world experimentation, which can be infeasible or unethical \citep[as is the case for geoengineering; e.g., unilateral decisions to seed the oceans with iron, or spray aerosols in the atmosphere,][]{hamilton2013no}. While we want to maintain this emphasis on causality as a method for calculating the generalized response to intervention (possibly using regression to calculate the functional form of that response), for consistency with the causal literature we will call the response variables ``effects'', and the intervened-upon variables ``causes''. For some, it may not be clear how the functional response to \emph{interventions} is different from naive regression between observed variables. We will demonstrate in Section \ref{sec:causal-graphs-pearls} how uninformed regression is just a functional mapping of associations between variables, and how this differs from the response to interventions, i.e. a causal mechanism. This is the problem that \textit{do-}calculus solves: it identifies which data are needed and how we can use those data to calculate the response to \emph{interventions}, rather than just associations that may be attributable to other processes entirely. Because we know the response to the intervention is attributable to the intervention and not other processes, we have greater confidence in the generalizability of the response to interventions. This generalizability of the response to interventions makes \textit{do-}calculus especially relevant for scientists and engineers. Working through an example will clarify some of these claims. \section{A Toy Example: the problem of confounding and the necessity of \textit{do-}calculus for calculating interventions} \label{sec:causal-graphs-pearls} % intro causal graphs} To demonstrate the problem of \textit{confounding} and the necessity of causal graphs/\textit{do-}calculus, we use a simple toy example involving clouds, aerosols, and surface solar radiation/sunlight. As shown in Figure \ref{fig:toy}, the causal graph consists of: \begin{enumerate} \item An edge from aerosols to clouds because aerosols serve as cloud condensation nuclei or ice nucleating particles, which affect the probability of water vapor conversion to cloud (condensates). \item An edge from aerosols to surface solar radiation, because aerosols can reflect sunlight back to space and reduce sunlight at the surface. \item An edge from clouds to sunlight, because clouds also reflect sunlight back to space and can reduce sunlight at the surface. \end{enumerate} Causal graphs encode our assumptions about how the system behaves, and the nodes and edges that are \textit{missing} from the graph often represent strong assumptions about the lack of functional dependence. For example, in the cloud-aerosol-sunlight example, clouds also affect aerosols; e.g., by increasing the likelihood that aerosol will be scavenged from the atmosphere during precipitation \citep[e.g.,][]{radke-scavenge-1980, jurado2008, blanco-alegre2018}. By not including an edge from cloud to aerosol, we are making the assumption that we are neglecting the effect of clouds on aerosols, and also preventing the graph from containing any cycles (a path from a variable to itself) which is a requirement of the theory: graphs must by acyclic. This acyclic requirement may raise concerns for the reader; many problems in Earth science contain feedbacks that introduce cycles. However, any feedback can be represented as an acyclic graph by explicitly resolving the time evolution of the feedback in the graph (Section \ref{sec:necess-cond-caus} contains examples of such graphs). Considering this example is intended to be pedagogical for introducing causal theory to the readers, we will continue with the graph as drawn in Figure \ref{fig:toy} (we refer the reader to \cite{gryspeerdt-2019} for a more realistic treatment of aerosols and clouds). Even though mathematical reasoning is not required to construct a causal graph, the resulting graph encodes specific causal meaning based on qualitative physical understanding of the system. Implicitly, the graph corresponds to a set of underlying functions, called a structural causal model, for each variable: \begin{align} \label{eq:2} aerosol &\leftarrow f_{aerosol} (U_{aerosol}) \\ cloud &\leftarrow f_{cloud} (aerosol, U_{cloud})\\ sunlight &\leftarrow f_{sunlight} (aerosol, cloud, U_{sunlight}) \end{align} where $U$ are random variables due to all the factors not represented explicitly in the causal graph, and $f$ are deterministic functions that generate each variable in the graph from their parents and corresponding $U$. The presence of the random variables $U$ introduces a third meaning to the causal graph: they induce a factorization of the joint distribution between variables into conditional and marginal factors: \begin{equation} P(A, C, S) = P(S \, | \,C, A) \, P(C \, | \, A) \, P(A), \end{equation} where $A$ represents aerosol, $C$ represents cloud, $S$ represents surface solar radiation, and $P($C$ | $A$)$ denotes conditional probability of $C$ given $A$ (Appendix \ref{prob-theory} describes the notation used in this paper and a brief introduction to probability theory for unfamiliar readers). The inclusion of randomness in causal graphs is a key tool: by positing a causal graph, we are not stating that the variables in the graph are the only processes in the system nor that the relationships are deterministic. Instead, we are stating that all other processes not included in the graph induce variations in the graph's variables that are \emph{independent} of each other (e.g., all $U_{\cdot}$ in Equation (\ref{eq:2}) are independent). For example, sources of aerosol variability not considered in Figure \ref{fig:toy} include anthropogenic aerosol emission, the biosphere, fires, volcanoes, etc. \citep[e.g.,][]{Boucher2015}. For cloud, this includes synoptic forcing or atmospheric humidity, etc. \citep[e.g.,][]{wallace2006atmospheric}. For radiation, this includes variability of top of atmosphere radiation, etc. \citep[e.g.,][]{hartmann2015global}. Figure \ref{fig:toy} states that all these external, or \textit{exogenous}, sources of variability are independent of each other \citep[in very technical terms, this means the graph is ``\textit{Markovian},''][]{pearl2009causality}). We can now apply causal inference theory \citep[e.g.,][]{pearl1995causal,tian2002general,shpitser2006} to the assumptions encoded in our causal graph to identify which distributions must be estimated from data in order to calculate the response of effect(s) (e.g. of sunlight) to an experimental intervention on the cause(s) (e.g. presence or absence of a cloud). The goal of causal inference is to derive the response to the intervention in terms of only observed distributions. This process of identifying the necessary observed distributions is formally termed \emph{causal identification} \citep[][, Ch. 3]{pearl2009causality}. If a causal effect is not identifiable (\emph{un}-identifiable), for example if calculating a causal effect requires distributions of variables that we do not observe, then we cannot use causal inference to calculate a causal effect, even with an infinite sample of data. A necessary condition for \emph{unidentifiability} is the presence of an unblocked \emph{backdoor path} from cause to effect \citep[][, Ch. 3]{pearl2009causality}. Backdoor paths are any paths going through parents of the cause to the effect. We can block these paths by selectively observing variables such that no information passes through them \citep{geiger-d-sep}. If observations are not available for the variables required to block the path, the path will be \emph{unblocked}. However, if we can observe variables along the backdoor paths such that all backdoor paths are blocked, then we have satisfied the \emph{back-door criterion} \citep{pearl2009} and we can calculate unbiased causal effects from data. Understanding backdoor paths and the backdoor criterion is helped by an example. Returning to our toy example (Figure \ref{fig:toy}), we attempt to calculate the causal effect of clouds on sunlight. In other words, we want to isolate the variability of sunlight due to the causal link from cloud to sunlight (Figure \ref{fig:toy}). However, aerosols affect both cloud and sunlight (i.e., there is a backdoor path from cloud to aerosol to sunlight), so if we naively calculate a "causal" effect using correlations between sunlight and cloud, we obtain a biased estimate. To demonstrate this, consider simulated cloud, aerosol, and sunlight data from a set of underlying equations consistent with Figure \ref{fig:toy} and Equation (\ref{eq:2}): \begin{align} \begin{split} \text{aerosol} =& \; U_{aerosol}; \; U_{aerosol} \sim \text{uniform (0, 1]}\\ \text{cloud} =& \; \text{Cloudy if } U_{cloud} + \text{aerosol} > 1; \; U_{cloud} \sim \text{uniform (0, 1]}\\ \text{sunlight} =& \begin{cases} \text{Cloudy} &: 0.6 \cdot \text{downwelling clear sky radiation} \\ \text{Clear} &: \text{downwelling clear sky radiation} \end{cases} \label{eq:1} \end{split} \end{align} where: \begin{equation*} \text{downwelling clear sky radiation} = U_{sunlight} \cdot (1 - aerosol); \; U_{sunlight} \sim \text{Normal(340 W m$^{-2}$, 30 \, W m$^{-2}$)} \end{equation*} \begin{figure} \centering \includegraphics[]{naiveCloudSunlight.pdf} \caption{A naive approach to estimating the ``effect'' of clouds on sunlight: bin observations by cloudy and clear day, and compare the values of sunlight. This approach yields an average difference of 157.74 W m$^{-2}$ between cloudy and clear days, and is a large overestimation of the true causal effect of clouds on sunlight (-68.0 W m$^{-2}$) in these synthetic data.} \label{fig:naive-cloud-sunlight} \end{figure} Now, consider not knowing the underlying generative processes, but instead just passively observing cloud and sunlight. If one were interested in calculating the effect of cloud on sunlight, and aerosol data were not available or one were not aware that aerosol could have an impact on clouds and aerosol, one direct but incorrect approach would be to bin the data by cloudy and clear conditions and compare the amount of sunlight between cloudy and clear observations (Figure \ref{fig:naive-cloud-sunlight}). This approach would suggest that clouds reduce sunlight by, on average, 158 W m$^{-2}$; this is is a strong overestimation of the true average effect of clouds (-68 W m$^{-2}$), derived from Equation (\ref{eq:1}). This overestimation is due to aerosol-induced co-variability between cloud and sunlight that is unrelated to the causal link from cloud to sunlight. However if aerosols were constant (e.g. observed or not varying), any co-variability between cloud and sunlight would be attributable to the causal edge between cloud and sunlight (Figure \ref{fig:toy}). In other words, conditional on aerosol, all co-variability between cloud and sunlight is only due to the causal effect of cloud on sunlight. We can mathematically encode this requirement that we must condition on aerosol to isolate the causal effect of cloud on radiation, and doing so derives the causal effect of cloud on sunlight by satisfying the backdoor criterion with \textit{adjustment} on aerosol: \begin{equation} P(S | do(C = c)) = \int_{a} P(S \, | \, C = c, A=a) \, P(A=a) \; da, \label{eq:3} \end{equation} where the \textit{do}-expression ($P(S \, | \, do(C\, = \,c))$) represents the probability of sunlight if we did an experiment where we intervened and set cloud to a value of our choosing (in this case $c$, which could be ``True'' for the presence of a cloud, or ``False'' for no cloud). In the case that observations of aerosols are not available, our causal effect is not identifiable and we cannot generally use causal inference without further assumptions, no matter how large the sample size is of our data. Causal graphs are therefore powerful analysis tools: after encoding our domain knowledge in a causal graph, we can analyze the available observations to determine whether a causal calculation is possible, \textit{without needing to collect, download, or manipulate any data}. For more complicated graphs, causal identification can be automated \citep[][ and \url{http://www.dagitty.net/}, \url{https://causalfusion.net}]{tian2002general,shpitser2006,huang2006identifiability,Bareinboim7345, textor2017}. We later use this theory to assess assumptions that lead to tractable causal analyses for generic Earth science scenarios (Section \ref{sec:necess-cond-caus}). Once we have established that a causal effect is identifiable from data, we must estimate the required observational distributions (Equation (\ref{eq:3})) from data. Often it may be more computationally tractable to calculate an average causal effect, rather than the full causal distribution $P(S | do(C=c))$, which might be difficult to estimate. Returning to our toy example (Figure \ref{fig:toy}), the average effect is defined as: \begin{equation} \mathbb{E}(S | do(C = c)) = \int_{s} s \, P(S = s | do(C=c)) \, ds, \label{eq:4} \end{equation} where $\mathbb{E}$ is the expected value. Substituting Equation (\ref{eq:3}) into Equation (\ref{eq:4}), and rearranging gives: \begin{equation} \mathbb{E}(S | do(C = c)) = \int_{a} P(A=a) \; \mathbb{E}(S \, | \, C=c, A=a) \, d a, \label{eq:5} \end{equation} Where $\mathbb{E}(S \, | \, C=c, A=a)$ is just a regression of sunlight on cloud and aerosol. Estimating the marginal $P(A)$ is difficult, but if we assume that our observations are independent and identically distributed (IID) and we have a large enough sample, we can use the law of large numbers to approximate Equation (\ref{eq:5}) as \citep{shalizi2013} : \begin{equation} \mathbb{E}(S | do(C = c)) \approx \frac{1}{n} \sum_{i=1}^n \mathbb{E}(S \, | \, C=c, A=a_i). \label{eq:6} \end{equation} Data or prior knowledge can inform the estimate of $\mathbb{E}(S | C=c, A=a_i)$, but whatever regression method is used, it should be checked to ensure it is representative of the data and there is sufficient signal to noise ratio to robustly estimate the regression. It is important to note how this estimate is different from the naive association of $\mathbb{E}(S | C=c)$; in $\mathbb{E}(S | C=c, A=a_i)$ we are controlling for the impact of aerosol on sunlight by conditioning on $A$ and including aerosol in the regression. As we will see, using the \textit{do}-calculus estimate results in an estimate of the effect of cloud on aerosol that is very different from the naive association, and close to the true effect. \begin{figure} \centering \includegraphics[]{aerosolSunlight.pdf} \caption{A linear relationship between aerosol and sunlight, conditional on cloud. If we use this regression to calculate the average causal effect of cloud on sunlight, as in Equation (\ref{eq:6}), our result is very close to the true causal effect of -68.0 W m$^{-2}$.} \label{fig:linear} \end{figure} In our simple example, a linear model conditional on cloud is a suitable choice for the regression function $\mathbb{E}(S | C=c, A=a_i)$ (Figure \ref{fig:linear}). However, many problems in Earth science require non-linear approximation methods like neural networks and/or advanced machine learning methods; for examples of such machine learning methods, we refer readers to \citep{bishop2006pattern}. The causal effect of clouds on sunlight as calculated using Equation (\ref{eq:6})) (e.g. $\mathbb{E}(S | do(C = \text{cloudy})) - \mathbb{E}(S | do(C = \text{clear}))$) is -67.69 W m$^{-2}$, which closely matches the true causal effect from Equation (\ref{eq:1}) of -68 W m$^{-2}$. This example demonstrates how causal inference and theory can be used to calculate unbiased average effects using regression, subject to the assumptions clearly encoded in the causal graph. Further, causal inference can be used to justify and communicate assumptions in any observational analyses employing regression. In the best case, the causal effect is identifiable from the available observations, and the regression analysis can be framed as an average causal effect. In the worst case that identification is not possible from the available observations, one may present the regression as observed associations between variables. However, presentation of a causal graph still aids the reader: the reader can see from the causal graph what the confounders and unobserved sources of covariability are between the predictors and the output. In all cases, the presentation of a causal graph makes explicit the assumptions about the causal dependencies of the system. Wherever possible, we recommend including causal graphs with any observation-based analyses. In summary of the main points of this introduction to causal graphical models and \textit{do-}calculus: \begin{itemize} \item Graphical causal models encode our assumptions about causal dependencies in a system (edges are drawn \emph{from} causes \emph{to} effects). ``Causal dependencies'' really just refer to functional dependencies between inputs (causes) and outputs (effect), which are useful in the Earth sciences to reason about graphically . \item In order to calculate an unbiased causal effect from data, we must isolate the covariability between cause and effect that is due to the directed causal path from cause to effect. The presence of non-causal dependencies between the cause and effect can be deduced from the causal graph: the presence of an \textit{unblocked backdoor path} from the cause to the effect leads to non-causal dependencies (and co-variation). \item The \emph{backdoor criterion} identifies the variables that we must condition on in order to block all backdoor paths, remove non-causal dependence between the cause and effect, and calculate an unbiased causal effect from data. \item The \emph{average} causal effect can be reliably approximated with a regression (Equation (\ref{eq:6})) derived from the backdoor criterion. In this scenario, causal theory and graphs identify the variables that should be included in the regression in order to calculate an unbiased causal effect (however researchers should still ensure their choice of regression model is appropriate for the data). While not demonstrated by our example, causal theory and graphs also identify the variables that \textit{should not} be included in the regression \citep{pearl2009}: we can also bias a causal effect by including too many variables in a regression . \item The do-calculus and identification theory provide a flexible tool to determine whether an effect is identifiable and, if so, which distributions should be estimated from data, while making no assumptions about the forms of the underlying functions and distributions. However, parametric assumptions can be applied to make the calculation of those distributions from data more computationally tractable. \end{itemize} Here we focused on the \emph{backdoor criterion} to block backdoor paths. An unblocked backdoor path from the cause to the effect is a necessary condition for unidentifiability. However, an unblocked backdoor path from the cause to the effect is not a sufficient condition for unidentifiability: there are other identification strategies like the front door criterion \citep[see Section 3.5.2 in][]{pearl2009causality} and instrumental variables \citep[see Chapter 8 in][]{pearl2009causality} that do not rely on observing variables along the backdoor path, and can be used in some cases where observations are not available to satisfy the backdoor criterion (also see \citet{tian2002general} for more discussion on sufficient conditions for unidentifiability). These are examples of how the \textit{do-}calculus admits any strategy that frames the response to interventions in terms of observed distributions. We focus on the backdoor criterion because it is the most fundamental and direct method for adjusting for confounding, the most intuitive for an introduction to causality, and is the most relevant for the generic temporal systems present in the Earth sciences (Figure \ref{fig:generic} in Section \ref{sec:necess-cond-caus}). However, causal identification through other methods like instrumental variables and the front door criterion can also be automated; we refer the reader to \citet{pearl2009causality} for further discussion and software tools like \url{http://www.dagitty.net/} and \url{http://www.causalfusion.net} for interactive exploration. \section{Beyond toys: causal graphs as communicators, organizers, and time-savers}\label{sec:causal-graphs-as} In Section \ref{sec:causal-graphs-pearls} we used a toy example to demonstrate a causal analysis starting with drawing a graph and ending with the successful calculation of the average response of sunlight (the effect) to an intervention on cloud (the cause). However, often we may not be able to ultimately estimate the causal effects from the available data. In many cases there are serious challenges due to unobserved confounding in generic Earth science problems (Section \ref{sec:necess-cond-caus}), and for other cases we may lack enough samples, or samples could be too systematically biased, to estimate the necessary distributions (or regressions; e.g., Equation (\ref{eq:6})) with sufficient certainty. However, we want to emphasize that even if calculating a causal effect might in some cases be impossible, drawing a causal graph at the beginning of an analysis still offers tremendous benefits in terms of organization and scientific communication. Investing time to reason about the functional structure of the problem at the outset can save scientists time in the long term, forcing us to clarify our thinking early, expose potential challenges, and identify intractable approaches. Additionally, once the causal graph is drawn, we can use it as a communication tool and include it in presentations, papers, and discussions of our results. Making our assumptions about dependencies in the system explicit greatly improves the interpretability and reproducibility of our results. Perhaps our analysis and graph meet the standards for a causal interpretation, but even if they do not, the causal graph helps the rest of the community asses the sources of confounding in the graph that were not controlled for, and understand if their conceptualization of the graph structure matches the authors' hypotheses. Often in research there are more assumptions being made than are communicated, and even when they are communicated, the assumptions do not always get discussed in a precise way. Including a causal graph allows the assumptions to be clearly known, and discussed in a precise and rigorous way \citep[e.g.,][]{hannart-da}. To support the idea that many analyses would benefit from a causal graph, we will detail how a past project benefits from a causal graph. This example also moves beyond the toy example of Section \ref{sec:causal-graphs-pearls}, and demonstrates causal graphs' applicability to real problems in Earth science. \subsection{Causal graphs' utility in a real example} In \citet{massmann2017}, the lead author of this manuscript participated in a field campaign designed to study the impact of microphysical rain regime (specifically the presence of ice from aloft falling into orographic clouds) on orographic enhancement of precipitation. This field campaign and analysis benefits from a causal graph and is a real-world example argument for the more common use of causal graphs as research tools. Our retrospective causal graph of orographic enhancement in the Nahuelbuta mountains under steady conditions clearly communicates our assumptions about the system (Figure \ref{fig:ccope}). \begin{figure} \includegraphics[]{ccope.pdf} \caption{A graph representing steady conditions for orographic enhancement during the Chilean Coastal Orographic Precipitation Experiment \citep[CCOPE,][]{massmann2017}. The field campaign attempted to quantify the effect of ``rain regime'' on ``orographic enhancement.'' Observed quantities are represented by solid nodes, while unobserved quantities are represented by dashed nodes. Variables that must be observed to block all backdoor paths are shaded. The effect of rain regime on orographic enhancement is identifiable through adjustment on these shaded variables.} \label{fig:ccope} \end{figure} Many of the variables in the graph, such as ``synoptic forcing'', ``wind'', and ``orographic flow'', are quite general quantities. Keeping quantities general can lead to more intuitive and interpretable graphs by limiting the number of details and nodes that one must consider. However, if logic needs clarifying, the graph can become more explicit (e.g., differentiating wind into speed, direction, and spatial distribution, both horizontally and vertically). We also include unobserved variables explicitly in the graph, so we can reason about processes' impact on the system even if they are not observed. As graphs become more complicated, one can leverage interactive visualization software, or use static graph abstractions like plates \citep{bishop2006pattern}, which are particularly well suited to representing repeated structure common to spatiotemporal systems. While the exact details of the graph and the assumptions it encodes are interesting (e.g., ``wind'', ``stability'', and ``atmospheric moisture'' all refer to upwind conditions, and we assume that these upwind conditions are the relevant ``boundary condition'' for the downwind orographic clouds and precipitation), the noteworthy feature of the graph is that the field campaign's effect of interest, rain regime on orographic enhancement, is identifiable from the field campaign's observations. This is subject to the assumptions encoded in the graph, but those assumptions are explicitly represented and communicated by the graph. The causal graph helps interpret the field campaign's results, and in some sense proves that the design of the field campaign is sound. Therefore, for field campaigns, causal graphs are particularly useful at the planning and proposal stage. Such a causal graph could be included in any field campaign proposal, improving communication about the system and also rigorously justifying the campaign’s observations as necessary for calculating the desired effect(s). Even before the proposal, one could start with a causal graph, and then analyze it to determine which observations are needed to meet the campaign’s goals. Building on this idea, one could attach costs associated with observing each variable in the graph, and automatically determine the set of observations that minimizes cost while still allowing us to calculate our effect(s) of interest. While this is just one example, it demonstrates that causal graphs are useful beyond toy problems in the Earth system. Additionally, as we will see in Section \ref{sec:necess-cond-caus}, we can draw quite general graphs that are representative of many problems in Earth science. We hope the reader considers drawing a causal graph as a first step in their next project; they help structure, organize, and clarify our analysis and its assumptions. \section{Overcoming unobserved confounding and partial observation of Earth system state} \label{sec:necess-cond-caus} So far we have focused on toy (Section \ref{sec:causal-graphs-pearls}) and specific (Section \ref{sec:causal-graphs-as}) examples. We now turn our attention to more general and generic problems in Earth science systems, the common challenges we may encounter when attempting causal inference, and how we can overcome these challenges. Earth science systems and their components are (typically) dynamical systems evolving through time according to an underlying system state \citep{lorenz-1963,lorenz1996predictability,majda-state}. This offers both opportunities and challenges for causal inference. When constructing causal graphs we may benefit from the temporal ordering of events \citep{runge2019inferring}: we know that future events can have no causal effect on the past. We can also use the time dimension to explicitly resolve feedbacks in the system, and transform cyclic graphs with feedbacks into directed acyclic graphs (DAGs) required for causal inference. While handling feedbacks and avoiding cyclic graphs is a challenge of causal inference in Earth science, resolving the time dimension is a generic path to overcome this challenge when observations of sufficient resolution are available. However, confounding due to incomplete observation of the system's state variables also introduces challenges; challenges that are not unique to this paper's causal lens: incomplete observation of the system precludes the use of many ``causal discovery'' algorithms as well (see \citet{runge2019inferring} for a detailed review). Causal identification and tractable causal inference in Earth science requires assumptions about the unobserved portions of the state space that introduce this confounding, and how the unobserved portions of the state space affect observed variables. Without such assumptions the unobserved portions of the state space will introduce confounding for any causal effect of interest (Figure \ref{fig:generic}). For example, we generally do not observe the state space at every time (e.g. $S(t-1/2)$, Figure \ref{fig:generic}), and at any given time, we do not observe the state space at all locations and for all state variables (e.g. $S(t)$ and $S(t-1)$ in Figure \ref{fig:generic}). In other words, despite our impressive and growing array of satellite, remote sensing, and in situ observation systems, we are still very far from observing every relevant state variable at every location in time and space. So, if we are interested in the causal effect of any state variable at time $t$ on some variable at time $t+1$ (e.g., $E$ in Figure \ref{fig:generic}), then the causal effect will be confounded by the unobserved portions of the state space, and calculating a causal effect will be impossible (un-identifiable) without additional assumptions. However, there are assumptions we can make that may be reasonable for many generic applications, which remove this problem of unobserved confounding due to partial observation of the state space. We elaborate upon these assumptions in the following sections, and for each assumption, we draw a graph, briefly discuss the scenario and assumptions, present the identification formula and how average effects can be estimated (for example, using regression to estimate $\mathbb{E}(\cdot )$), and include some strategies for testing the assumption(s) with data. \begin{figure} \centering \input{figs/generic-graph.tex} \caption{A generic graph of the Earth system state sequence. Unobserved nodes are outlined by dashed lines. We only observe the state space at certain times (e.g., no observations at $S(t-1/2)$), and at times with observations, we only partially observe the full state ($S(t)$, $S(t-1)$). In the scenario that we are interested in calculating the causal effect of any portion of the state space at time $t$ on some effect ($E$) at time $t+1$, the causal effect will be confounded by the unobserved portions of the state space, and calculating the causal effect is impossible (un-identifiable) without additional assumptions.} \label{fig:generic} \end{figure} \newpage \paragraph{Assumption: we observe all state variables that impact our effect(s) of interest} \begin{figure}[H] \centering \includegraphics[]{observe-everything.pdf} \caption{A generic graph for the assumption that we observe all state variables that impact our effect(s) of interest. $C(t)$ is the cause of interest, $E(t+1)$ is the future effect of interest, and $O(t)$ are all observations not including $C(t)$. The full state $S(t-1)$ is not observed (dashed node). Observing $O(t)$ (grey shading) blocks the backdoor path from $C(t)$ to $E(t+1)$.} \label{fig:observe-everything} \end{figure} \begin{itemize} \item \textbf{Discussion:} While we may not observe the entire state of the system, sometimes it is reasonable to assume that we observe the portion of the state space that affects our specific effect of interest ($E(t+1)$ in Figure \ref{fig:observe-everything}). In this case, we can calculate causal effects by blocking backdoor paths with the observed portion of the state space. \item \textbf{Identification formula:} \begin{equation*} P(E(t+1) \, | \, do(C(t) = c)) = \int_{o} P(E(t+1) \, | \, C(t) = c, O(t) = o) \, P(O(t)=o) \; d o, \end{equation*} \item \textbf{Average causal effect:} \begin{equation*} \mathbb{E}(E(t+1) \, | \, do(C(t) = c)) \approx \frac{1}{n} \sum_{i=1}^n \mathbb{E}(E(t+1) \, | \, C(t)=c, O(t)=o_i), \end{equation*} where $C(t)$ is the cause of interest, $E(t+1)$ is the effect of interest, and $O(t)$ are all observed variables not including $C(t)$. \item \textbf{Check:} There is no way to check this assumption with data. Therefore, this assumption requires strong physical justification well supported by the literature. Care is also required to insure that there are no interactions between $C(t)$ and $O(t)$; e.g., the observations at a given time are truly ``simultaneous'' and cannot causally affect each other. \end{itemize} \newpage \paragraph{Assumption: We can reconstruct the state at any given time using lagged observations of the system} \begin{figure}[H] \centering \includegraphics[]{reconstruction.pdf} \caption{A generic graph for the assumption that we can reconstruct the state at any given time using lagged observations of the system \citep{takens1981detecting}. $C(t)$ is the cause of interest, $E(t+1)$ is the future effect of interest, $O(t)$ are all observations not including $C(t)$, and $S'(t-1)$ is the reconstructed state. Observing $S'(t-1)$ (grey shading) blocks all backdoor paths from $C(t)$ to $E(t+1)$.} \label{fig:reconstruction} \end{figure} \begin{itemize} \item \textbf{Discussion:} While we may not observe the entire state space, in some cases we may be able to reconstruct the state at any given time using lagged observations of the system \citep[see Takens' theorem,][]{takens1981detecting}. In this case, we can use the reconstructed state to block backdoor paths and examine the effect of any observed variable ($C(t)$) on future variables ($E(t+1)$ in Figure \ref{fig:reconstruction}). Note that additionally controlling for $O(t)$ can also make the effect estimate more reliable. More generally, there may be more than one suitable set of adjustment co-variates and current research is targeted at finding optimal ones that yield the lowest estimation error \citep[e.g.,][]{witte2020efficient}. \item \textbf{Identification formula:} \begin{equation*} P(E(t+1) \, | \, do(C(t) = c)) = \int_{s} P(E(t+1) \, | \, C(t) = c, S'(t-1) = s) \, P(S'(t-1)=s) \; d s. \end{equation*} \item \textbf{Average causal effect:} \begin{equation*} \mathbb{E}(E(t+1) \, | \, do(C(t) = c)) \approx \frac{1}{n} \sum_{i=1}^n \mathbb{E}(E(t+1) \, | \, C(t)=c, S'(t-1)=s_i), \end{equation*} where $C(t)$ is the cause of interest, $E(t+1)$ is the effect of interest, and $S'(t-1)$ is the reconstructed state using lagged observations. \item \textbf{Check:} One check on the success of the state space reconstruction is to test whether the observed variables are conditionally independent given the reconstructed state variable. This approach bears similarity to the deconfounder approach introduced by \cite{yixin-2019}, which argues that causal effects can be calculated for many problems when we can infer a latent variable that renders the (multiple) causes conditionally independent given the latent variable. \end{itemize} \paragraph{Assumption: the cause of interest is independent of the systems' state evolution} \begin{figure} \includegraphics[]{forcing-graph.pdf} \centering \caption{A generic graph asserting an assumption that there are forcings external to the evolution of the state-space.} \label{fig:forcing} \end{figure} \begin{itemize} \item \textbf{Discussion:} In some cases, we may assume that the cause of interest is independent of the systems' state evolution (Figure \ref{fig:forcing}). While not generally true, in some cases a variable may behave independent of the system's state while still causally affecting that state. For example, some human behavior may be approximated as independent of the climate state (e.g., city planning and land use decisions). \item \textbf{Identification formula:} \begin{equation*} P(E(t+1) \, | \, do(C = c)) = P(E(t+1) \, | \, C = c) \end{equation*} \item \textbf{Average causal effect:} \begin{equation*} \mathbb{E}(E(t+1) \, | \, do(C = c)) = \mathbb{E}(E(t+1) \, | \, C=c) \end{equation*} \item \textbf{Check:} To check this assumption, we can test if the cause/forcing is independent of the past state. If the cause is independent of the past state, we have stronger confidence that the assumption holds. \end{itemize} While this list of assumptions is certainly not exhaustive, it presents some approaches that may apply to many scenarios in Earth science. Also while the provided checks might identify when assumptions break down, there is no general way to ``validate'' assumptions using data. Physical and science-based justification and reasoning are ultimately always required. \section{Conclusions} In summary, causal graphs and causal inference are powerful tools to reason about problems in the Earth system, whether in models or observations. Specifically, this review aimed at showing that: \begin{itemize} \item Causal graphs concisely and clearly encode physical assumptions about causal/functional dependencies between processes. Including a causal graph benefits any observational or modeling analysis, including those that use regression. \item Whether a causal effect can be calculated from data is determined by the causal graph. Thus the tractability of a causal analysis, or the strength of assumptions necessary to make the analysis tractable, is determined and assessed before collecting, generating, or manipulating data (which can cost a tremendous amount in terms of researchers' time or computational resources). We recommend early causal analysis to determine tractability during a project's conception, before resources are spent obtaining or analyzing data. \item Calculated causal effects measure the response of target variables (i.e. effects) to \textit{interventions} on other variables in the system (i.e. causes). With statistical modeling (i.e., regression) one can estimate the functional relationship between interventions on causes and effects. These functional relationships \textit{generalize} because they map \textit{interventions} onto the response: unlike observed associations (e.g., naive regression), we know the response is attributable to the function's input, and not to some other process in the system (e.g., an unobserved common cause). This causal approach opens up a new path to calculate generalized functional relationships when we either do not know the functional form a priori, or it is too computationally intractable to calculate from models. \item Because the Earth system and its constituents are dynamical systems evolving through time, we can construct broadly applicable, generic Earth system causal graphs. We can use these graphs to calculate generalized functional relationships between processes of interest, which would not be possible with associations, correlations or simple regressions. However, causal inference in the Earth sciences also presents challenges as we only partially observe the state space of the system. \item These challenges can be alleviated by applying causal theory to generic causal graphs of the Earth system and identifying the assumptions that allow for causal inference from data (Section \ref{sec:necess-cond-caus}). \end{itemize} Here we focus on the fundamentals of calculating causal effects from data. However, causal inference is a thriving, active area of research, and there are many other causal inference techniques and abstractions that could benefit the Earth system research community. For example, there are techniques for representing variables observed under selection bias in the causal graph and analyzing whether a causal effect can be calculated (i.e. identified) given that selection bias \citep[e.g.,][]{bareinboim2014recovering,correa2018generalized}. Selection bias, defined as a preferential sampling of data according to some underlying mechanism, is very relevant in Earth sciences. For example, satellite observations are almost always collected under selection bias (e.g. clouds obscure surface data, satellites sample at certain local times of the day which is connected to top of atmosphere solar forcing, or the sensors themselves could have a bias). Additionally, transportability \citep[e.g.,][]{bareinboim2012transportability,Bareinboim7345,lee2019general} identifies whether one can calculate a causal effect in a passively observed system called the ``target domain'', by merging experiments from other systems, called ``source domains'', that may differ from the target domain. A potential application for transportability in Earth sciences would be to merge numerical model experiments (e.g., Earth system models) and formally transport their results to the real world. In this case, numerical models are the source domains that differ from the target domain (``real world'') due to approximations and different resolutions. However, because these developments in causal theory are relatively new, applied domains have yet to establish these recent theoretical developments' utility for applied analysis. While we encourage applied scientists to explore how these developments may apply to their domains, we recognize that many scientists prefer tools with established utility. To that end, we believe that the use of causal graphs to organize and structure analyses is mature and directly applicable to many projects, and can serve as a gateway to applying these more recent causal developments. We hope that drawing and including causal graphs in Earth science research becomes more common in our field, and that this manuscript provides some of the necessary foundation for readers to attempt using causal graphs in their future research. \paragraph{Acknowledgments} The authors want to thank Elias Bareinboim, Beth Tellman, James Doss-Gollin, David Farnham, and Masa Haraguchi for thoughtful feedback and comments that greatly improved an earlier version of this manuscript. \bibliography{references.bib} \appendix \section{Basic probability and syntax} \label{prob-theory} In this paper we use capital letters to represent random variables (e.g., ``$X$''). For example, $P(X)$ is the marginal probability distribution of a random variable $X$. $P(X)$ is a function of one variable that outputs a probability (or density, in the case of continuous variables) given a specific value for $X$. We represent specific values that a random variable can take with lowercase letters (e.g., $x$ in the case of $X$). $P(X)$ is shorthand; a more descriptive but less concise way to write $P(X)$ is $P(X=x)$ which represents the fact that $P(X)$ is a function of a specific value of $X$, represented by $x$. We use both notations, and $P(X)$ has the same meaning as $P(X=x)$. For the unfamiliar reader, there are a few basic rules and definitions in probability that provide relatively complete foundations for building deeper understanding of probability. These are the \textbf{sum rule}: \begin{equation} P(X=x) = \sum_Y P(X=x,\, Y=y) \label{eq:sum} \end{equation} and the \textbf{product rule}: \begin{equation} P(X=x, \, Y=y) = P(X = x \, | \, Y=y ) P(Y=y) = P(Y = y \, | \, X=x ) P(X=x) \label{eq:product} \end{equation} The \textit{joint probability distribution} ($P(X=x,Y=y)$) is the probability that the random variable $X$ equals some value $x$ \emph{and} the random variable $Y$ equals $y$. The joint distribution is a function of two variables, $x$ and $y$ which are values in the domains of the random variables $X$ and $Y$ respectively. The \textit{conditional probability distribution} ($p(X = x \, | \, Y=y )$) is also a function of two variables $x$ and $y$, but it is the probability of observing $X$ equal to $x$, given that we have observed $Y$ equal to $y$. In other words, if we filter our domain to only values where $Y=y$, then $p(X = x \, | \, Y=y )$ is the probability of observing $X=x$ in this sub-domain where $Y=y$. The \textit{marginal probability distribution} ($P(Y=y)$) is just the probability that $Y$ equals some value $y$, and is a function of only $y$. We can calculate the marginal probability from the joint distribution by summing over all possible values values of the other random variables in the joint (the ``sum rule'' - Equation (\ref{eq:sum})). Additionally, the joint distribution can factorize into a product of conditional and marginal distributions (``the product rule'' - Equation (\ref{eq:product})). These two simple rules can be used to build much of the theory and applications of probability theory (e.g., Bayes' theorem $P(Y|X) =\frac{P(X|Y) P(Y)}{P(X)}$). While Equations (\ref{eq:sum}) deals with probability distributions of discrete random variables, there is also a sum rule analog for continuous random variables and probability density functions (the syntax of the product rule is the same): \begin{equation*} P(X=x) = \int_Y P(X=x,\, Y=y) \, dy \end{equation*} where $\int_{Y}$ represents an integral over the domain of $Y$ (e.g., $\int_{-\infty}^{\infty}$ if $Y$ is a Gaussian random variable). \end{document}
A subset $S$ of a topological space $T$ is open in $T$ if and only if $S$ is a subset of $T$ and for every $x \in S$, there exists an open ball around $x$ that is contained in $S$.
A subset $S$ of a topological space $T$ is open in $T$ if and only if $S$ is a subset of $T$ and for every $x \in S$, there exists an open ball around $x$ that is contained in $S$.
\chapter{pybern} \label{ch:pybern} \emph{pybern}\index{pybern} is the core part of the analysis platform. It is actually a Python module (aka a software library) that contains definitions and functions used throught the programs used for the processing. Its development is performed in the relevant \href{https://github.com/DSOlab/autobern}{github repository}. Currently (\today), the servers running the software use (by default) Python 2.7, so we must always make sure the module is compatible with this version. However, the module should also run without problems with Python 3.x. \section{Installation} \label{sec:pybern-installation} \emph{pybern} needs to be installed on your system for everything to work. It also needs to be re-installed every time any of its files changes. To install the module, you need to: \begin{itemize} \item got to the module's top directory, aka where the \verb|setup.py| is \item run (with root privilages) the command \verb|$>sudo python setup.py install| \item all done! \end{itemize}
{-# OPTIONS --without-K --safe #-} module Data.Empty.Base where open import Level data ⊥ : Type where infix 4.5 ¬_ ¬_ : Type a → Type a ¬ A = A → ⊥ ⊥-elim : ⊥ → A ⊥-elim ()
-- From AT: This approach could work, but seems too complicated for now. -- I have opted to use the comparison lemma instead. -- See the folder `condensed/extr/`. /- import topology.category.Profinite import for_mathlib.Profinite.disjoint_union open category_theory namespace Profinite universe u /- The following three lemmas are used below to help speed up some proofs. -/ @[simp] lemma pullback.fst_apply {A B C : Profinite.{u}} (f : A ⟶ C) (g : B ⟶ C) (a : A) (b : B) (h : f a = g b) : Profinite.pullback.fst f g ⟨(a,b),h⟩ = a := rfl @[simp] lemma pullback.snd_apply {A B C : Profinite.{u}} (f : A ⟶ C) (g : B ⟶ C) (a : A) (b : B) (h : f a = g b) : Profinite.pullback.snd f g ⟨(a,b),h⟩ = b := rfl @[simp] lemma pullback.lift_apply {A B C D : Profinite.{u}} (f : A ⟶ C) (g : B ⟶ C) (a : D ⟶ A) (b : D ⟶ B) (w : a ≫ f = b ≫ g) (d : D) : Profinite.pullback.lift f g a b w d = ⟨(a d, b d), by { change (a ≫ f) d = _, rw w, refl }⟩ := rfl structure prepresentation (B : Profinite.{u}) := (G : Profinite.{u}) (π : G ⟶ B) (hπ : function.surjective π) (R : Profinite.{u}) (r : R ⟶ Profinite.pullback π π) (hr : function.surjective r) def prepresentation.fst {B : Profinite.{u}} (P : B.prepresentation) : P.R ⟶ P.G := P.r ≫ Profinite.pullback.fst _ _ def prepresentation.snd {B : Profinite.{u}} (P : B.prepresentation) : P.R ⟶ P.G := P.r ≫ Profinite.pullback.snd _ _ lemma prepresentation.fst_surjective {B : Profinite.{u}} (P : B.prepresentation) : function.surjective P.fst := begin apply function.surjective.comp _ P.hr, intros x, exact ⟨⟨⟨x,x⟩,rfl⟩,rfl⟩, end lemma prepresentation.snd_surjective {B : Profinite.{u}} (P : B.prepresentation) : function.surjective P.snd := begin apply function.surjective.comp _ P.hr, intros x, exact ⟨⟨⟨x,x⟩,rfl⟩,rfl⟩, end def prepresentation.base {B : Profinite.{u}} (P : B.prepresentation) : P.R ⟶ B := P.snd ≫ P.π @[simp, reassoc, elementwise] lemma prepresentation.base_fst {B : Profinite.{u}} (P : B.prepresentation) : P.fst ≫ P.π = P.base := by { dsimp [prepresentation.fst, prepresentation.snd, prepresentation.base], simp [Profinite.pullback.condition] } @[simp, reassoc, elementwise] lemma prepresentation.base_snd {B : Profinite.{u}} (P : B.prepresentation) : P.snd ≫ P.π = P.base := rfl lemma prepresentation.base_surjective {B : Profinite.{u}} (P : B.prepresentation) : function.surjective P.base := function.surjective.comp P.hπ P.snd_surjective structure prepresentation.hom_over {B₁ B₂ : Profinite.{u}} (X₁ : B₁.prepresentation) (X₂ : B₂.prepresentation) (f : B₁ ⟶ B₂) := (g : X₁.G ⟶ X₂.G) (hg : g ≫ X₂.π = X₁.π ≫ f) (r : X₁.R ⟶ X₂.R) (fst : r ≫ X₂.fst = X₁.fst ≫ g) (snd : r ≫ X₂.snd = X₁.snd ≫ g) attribute [simp, reassoc, elementwise] prepresentation.hom_over.hg prepresentation.hom_over.fst prepresentation.hom_over.snd local attribute [simp, elementwise] Profinite.pullback.condition Profinite.pullback.condition_assoc def prepresentation.hom_over.comp {B₁ B₂ B₃ : Profinite.{u}} {X₁ : B₁.prepresentation} {X₂ : B₂.prepresentation} {X₃ : B₃.prepresentation} {f₁ : B₁ ⟶ B₂} {f₂ : B₂ ⟶ B₃} (e₁ : X₁.hom_over X₂ f₁) (e₂ : X₂.hom_over X₃ f₂) : X₁.hom_over X₃ (f₁ ≫ f₂) := { g := e₁.g ≫ e₂.g, hg := by simp, r := e₁.r ≫ e₂.r, fst := by simp, snd := by simp } def prepresentation.pullback_G {X B : Profinite} (f : X ⟶ B) (hf : function.surjective f) (P : B.prepresentation) : X.prepresentation := { G := Profinite.pullback f P.π, π := Profinite.pullback.fst _ _, hπ := begin intros x, obtain ⟨y,hy⟩ := P.hπ (f x), exact ⟨⟨⟨x,y⟩,hy.symm⟩,rfl⟩, end, R := Profinite.pullback f P.base, r := Profinite.pullback.lift _ _ (Profinite.pullback.lift _ _ (Profinite.pullback.fst _ _) (Profinite.pullback.snd _ _ ≫ P.fst) $ by simp) (Profinite.pullback.lift _ _ (Profinite.pullback.fst _ _) (Profinite.pullback.snd _ _ ≫ P.snd) $ by simp) $ by simp, hr := begin rintros ⟨⟨⟨⟨a,b₁⟩,h₁⟩,⟨⟨a₂,b₂⟩,h₂⟩⟩,(rfl : a = a₂)⟩, dsimp at h₁ h₂, let c : Profinite.pullback P.π P.π := ⟨⟨b₁,b₂⟩,_⟩, swap, { dsimp, rw [← h₁, ← h₂] }, obtain ⟨d,hd⟩ := P.hr c, refine ⟨⟨⟨a,d⟩,_⟩,_⟩, { dsimp only [prepresentation.base, prepresentation.snd], dsimp, rwa hd }, { dsimp [prepresentation.fst, prepresentation.snd], congr, { simp [hd] }, { simp [hd] } }, end } . def presentation.pullback_R {X B : Profinite} (f : X ⟶ B) (hf : function.surjective f) (P : B.prepresentation) : (Profinite.pullback f f).prepresentation := { G := Profinite.pullback (Profinite.pullback.snd f f ≫ f) P.π, π := Profinite.pullback.lift _ _ (Profinite.pullback.fst _ _ ≫ Profinite.pullback.fst _ _) (Profinite.pullback.fst _ _ ≫ Profinite.pullback.snd _ _) $ by simp, hπ := begin rintros ⟨⟨a,b⟩,h⟩, dsimp at h, obtain ⟨c,hc⟩ := P.hπ (f b), refine ⟨⟨⟨⟨⟨a,b⟩,h⟩,c⟩,hc.symm⟩,_⟩, refl, end, R := Profinite.pullback (Profinite.pullback.snd f f ≫ f) P.base, r := Profinite.pullback.lift _ _ (Profinite.pullback.lift _ _ (Profinite.pullback.fst _ _) (Profinite.pullback.snd _ _ ≫ P.fst) $ by simp) (Profinite.pullback.lift _ _ (Profinite.pullback.fst _ _) (Profinite.pullback.snd _ _ ≫ P.snd) $ by simp) $ by { apply Profinite.pullback.hom_ext; simp }, hr := begin rintros ⟨⟨⟨⟨⟨⟨a₁,a₁'⟩,h₁'⟩,b₁⟩,h₁⟩,⟨⟨⟨⟨a₂,a₂'⟩,h₂'⟩,b₂⟩,h₂⟩⟩,h⟩, change f a₁' = (P.π) b₁ at h₁, change f a₂' = (P.π) b₂ at h₂, change f a₁ = f a₁' at h₁', change f a₂ = f a₂' at h₂', change _ = _ at h, have hfst := h, have hsnd := h, apply_fun (λ a, a.1.1) at hfst, apply_fun (λ a, a.1.2) at hsnd, change a₁ = a₂ at hfst, change a₁' = a₂' at hsnd, let e : Profinite.pullback f f := ⟨⟨a₁,a₁'⟩, h₁'⟩, let w₀ : Profinite.pullback P.π P.π := ⟨⟨b₁,b₂⟩,_⟩, swap, { change _ = _, rw [← h₁, ← h₂, hsnd] }, obtain ⟨w₁,hw₁⟩ := P.hr w₀, let w : Profinite.pullback (pullback.snd f f ≫ f) P.base := ⟨⟨e,w₁⟩,_⟩, swap, { change _ = _, change f _ = P.π (pullback.snd _ _ _), erw hw₁, dsimp only [pullback.fst_apply, e, pullback.snd_apply], rw hsnd, exact h₂ }, use w, dsimp only [w, e, pullback.fst_apply, pullback.snd_apply, pullback.lift_apply], congr, { dsimp [prepresentation.fst], rw hw₁, refl }, { congr' 2 }, { dsimp [prepresentation.snd], rw hw₁, refl }, end } . def prepresentation.pullback_π {X B : Profinite} (f : X ⟶ B) (hf : function.surjective f) (P : B.prepresentation) : (P.pullback_G f hf).hom_over P f := { g := Profinite.pullback.snd _ _, hg := begin dsimp [prepresentation.pullback_G], simp, end, r := Profinite.pullback.snd _ _, fst := begin dsimp [prepresentation.pullback_G, prepresentation.fst], simp, end, snd := begin dsimp [prepresentation.pullback_G, prepresentation.snd], simp, end } lemma prepresentation.pullback_π_g_surjective {X B : Profinite} (f : X ⟶ B) (hf : function.surjective f) (P : B.prepresentation) : function.surjective (P.pullback_π f hf).g := begin intros x, obtain ⟨y,hy⟩ := hf (P.π x), exact ⟨⟨⟨y,x⟩,hy⟩,rfl⟩, end lemma prepresentation.pullback_π_r_surjective {X B : Profinite} (f : X ⟶ B) (hf : function.surjective f) (P : B.prepresentation) : function.surjective (P.pullback_π f hf).r := begin intros x, obtain ⟨y,hy⟩ := hf (P.base x), exact ⟨⟨⟨y,x⟩,hy⟩,rfl⟩ end end Profinite -/
Several people , telling amazing stories to those who would listen , passed themselves off as the " sole survivor " in the years following the slide . The most common such tale is that of an infant girl said to have been the only survivor of the slide . Her real name unknown , the girl was called " Frankie Slide " . Several stories were told of her miraculous escape : she was found in a bale of hay , lying on rocks , under the collapsed roof of her house or in the arms of her dead mother . The legend was based primarily on the story of Marion Leitch , who was thrown from her home into a pile of hay when the slide enveloped her home . Her sisters also survived ; they were found unharmed under a collapsed ceiling joist . Her parents and four brothers died . Influencing the story was the survival of two @-@ year @-@ old Gladys Ennis , who was found outside her home in the mud . The last survivor of the slide , she died in 1995 . In total , 23 people in the path of the slide survived , in addition to the 17 miners who escaped from the tunnels under Turtle Mountain . A ballad by Ed McCurdy featuring the story of Frankie Slide was popular in parts of Canada in the 1950s . The slide has formed the basis of other songs , including " How the Mountain Came Down " by Stompin ' Tom Connors , and more recently , " Frank , AB " by The Rural Alberta Advantage . The Frank Slide has been the subject of several books , both historical and fictional .
(* Title: HOL/Auth/n_german_lemma_on_inv__46.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_german Protocol Case Study*} theory n_german_lemma_on_inv__46 imports n_german_base begin section{*All lemmas on causal relation between inv__46 and some rule r*} lemma n_RecvReqVsinv__46: assumes a1: "(\<exists> i. i\<le>N\<and>r=n_RecvReq N i)" and a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4)" shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s") proof - from a1 obtain i where a1:"i\<le>N\<and>r=n_RecvReq N i" apply fastforce done from a2 obtain p__Inv3 p__Inv4 where a2:"p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4" apply fastforce done have "(i=p__Inv4)\<or>(i=p__Inv3)\<or>(i~=p__Inv3\<and>i~=p__Inv4)" apply (cut_tac a1 a2, auto) done moreover { assume b1: "(i=p__Inv4)" have "?P3 s" apply (cut_tac a1 a2 b1, simp, rule_tac x="(neg (andForm (eqn (IVar (Ident ''CurCmd'')) (Const Empty)) (eqn (IVar (Field (Para (Ident ''Chan2'') p__Inv3) ''Cmd'')) (Const Inv))))" in exI, auto) done then have "invHoldForRule s f r (invariants N)" by auto } moreover { assume b1: "(i=p__Inv3)" have "?P3 s" apply (cut_tac a1 a2 b1, simp, rule_tac x="(neg (andForm (eqn (IVar (Ident ''CurCmd'')) (Const Empty)) (eqn (IVar (Field (Para (Ident ''Chan2'') p__Inv3) ''Cmd'')) (Const Inv))))" in exI, auto) done then have "invHoldForRule s f r (invariants N)" by auto } moreover { assume b1: "(i~=p__Inv3\<and>i~=p__Inv4)" have "?P3 s" apply (cut_tac a1 a2 b1, simp, rule_tac x="(neg (andForm (eqn (IVar (Ident ''CurCmd'')) (Const Empty)) (eqn (IVar (Field (Para (Ident ''Chan2'') p__Inv3) ''Cmd'')) (Const Inv))))" 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_SendInvEVsinv__46: assumes a1: "(\<exists> i. i\<le>N\<and>r=n_SendInvE i)" and a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4)" shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s") proof - from a1 obtain i where a1:"i\<le>N\<and>r=n_SendInvE i" apply fastforce done from a2 obtain p__Inv3 p__Inv4 where a2:"p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4" apply fastforce done have "(i=p__Inv4)\<or>(i=p__Inv3)\<or>(i~=p__Inv3\<and>i~=p__Inv4)" apply (cut_tac a1 a2, auto) done moreover { assume b1: "(i=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: "(i=p__Inv3)" have "?P1 s" proof(cut_tac a1 a2 b1, auto) qed then have "invHoldForRule s f r (invariants N)" by auto } moreover { assume b1: "(i~=p__Inv3\<and>i~=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_SendInvSVsinv__46: assumes a1: "(\<exists> i. i\<le>N\<and>r=n_SendInvS i)" and a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4)" shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s") proof - from a1 obtain i where a1:"i\<le>N\<and>r=n_SendInvS i" apply fastforce done from a2 obtain p__Inv3 p__Inv4 where a2:"p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4" apply fastforce done have "(i=p__Inv4)\<or>(i=p__Inv3)\<or>(i~=p__Inv3\<and>i~=p__Inv4)" apply (cut_tac a1 a2, auto) done moreover { assume b1: "(i=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: "(i=p__Inv3)" have "?P3 s" apply (cut_tac a1 a2 b1, simp, rule_tac x="(neg (andForm (andForm (eqn (IVar (Ident ''CurCmd'')) (Const ReqS)) (eqn (IVar (Field (Para (Ident ''Chan3'') p__Inv4) ''Cmd'')) (Const InvAck))) (eqn (IVar (Para (Ident ''InvSet'') p__Inv3)) (Const true))))" in exI, auto) done then have "invHoldForRule s f r (invariants N)" by auto } moreover { assume b1: "(i~=p__Inv3\<and>i~=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_SendInvAckVsinv__46: assumes a1: "(\<exists> i. i\<le>N\<and>r=n_SendInvAck i)" and a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4)" shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s") proof - from a1 obtain i where a1:"i\<le>N\<and>r=n_SendInvAck i" apply fastforce done from a2 obtain p__Inv3 p__Inv4 where a2:"p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4" apply fastforce done have "(i=p__Inv4)\<or>(i=p__Inv3)\<or>(i~=p__Inv3\<and>i~=p__Inv4)" apply (cut_tac a1 a2, auto) done moreover { assume b1: "(i=p__Inv4)" have "?P3 s" apply (cut_tac a1 a2 b1, simp, rule_tac x="(neg (andForm (andForm (eqn (IVar (Field (Para (Ident ''Chan2'') p__Inv3) ''Cmd'')) (Const Inv)) (eqn (IVar (Ident ''CurCmd'')) (Const ReqS))) (eqn (IVar (Field (Para (Ident ''Chan2'') p__Inv4) ''Cmd'')) (Const Inv))))" in exI, auto) done then have "invHoldForRule s f r (invariants N)" by auto } moreover { assume b1: "(i=p__Inv3)" have "?P1 s" proof(cut_tac a1 a2 b1, auto) qed then have "invHoldForRule s f r (invariants N)" by auto } moreover { assume b1: "(i~=p__Inv3\<and>i~=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_RecvInvAckVsinv__46: assumes a1: "(\<exists> i. i\<le>N\<and>r=n_RecvInvAck i)" and a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4)" shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s") proof - from a1 obtain i where a1:"i\<le>N\<and>r=n_RecvInvAck i" apply fastforce done from a2 obtain p__Inv3 p__Inv4 where a2:"p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4" apply fastforce done have "(i=p__Inv4)\<or>(i=p__Inv3)\<or>(i~=p__Inv3\<and>i~=p__Inv4)" apply (cut_tac a1 a2, auto) done moreover { assume b1: "(i=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: "(i=p__Inv3)" have "?P2 s" proof(cut_tac a1 a2 b1, auto) qed then have "invHoldForRule s f r (invariants N)" by auto } moreover { assume b1: "(i~=p__Inv3\<and>i~=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_SendGntSVsinv__46: assumes a1: "(\<exists> i. i\<le>N\<and>r=n_SendGntS i)" and a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4)" shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s") proof - from a1 obtain i where a1:"i\<le>N\<and>r=n_SendGntS i" apply fastforce done from a2 obtain p__Inv3 p__Inv4 where a2:"p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4" apply fastforce done have "(i=p__Inv4)\<or>(i=p__Inv3)\<or>(i~=p__Inv3\<and>i~=p__Inv4)" apply (cut_tac a1 a2, auto) done moreover { assume b1: "(i=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: "(i=p__Inv3)" have "?P1 s" proof(cut_tac a1 a2 b1, auto) qed then have "invHoldForRule s f r (invariants N)" by auto } moreover { assume b1: "(i~=p__Inv3\<and>i~=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_SendGntEVsinv__46: assumes a1: "(\<exists> i. i\<le>N\<and>r=n_SendGntE N i)" and a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4)" shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s") proof - from a1 obtain i where a1:"i\<le>N\<and>r=n_SendGntE N i" apply fastforce done from a2 obtain p__Inv3 p__Inv4 where a2:"p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4" apply fastforce done have "(i=p__Inv4)\<or>(i=p__Inv3)\<or>(i~=p__Inv3\<and>i~=p__Inv4)" apply (cut_tac a1 a2, auto) done moreover { assume b1: "(i=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: "(i=p__Inv3)" have "?P1 s" proof(cut_tac a1 a2 b1, auto) qed then have "invHoldForRule s f r (invariants N)" by auto } moreover { assume b1: "(i~=p__Inv3\<and>i~=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_RecvGntSVsinv__46: assumes a1: "(\<exists> i. i\<le>N\<and>r=n_RecvGntS i)" and a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4)" shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s") proof - from a1 obtain i where a1:"i\<le>N\<and>r=n_RecvGntS i" apply fastforce done from a2 obtain p__Inv3 p__Inv4 where a2:"p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4" apply fastforce done have "(i=p__Inv4)\<or>(i=p__Inv3)\<or>(i~=p__Inv3\<and>i~=p__Inv4)" apply (cut_tac a1 a2, auto) done moreover { assume b1: "(i=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: "(i=p__Inv3)" have "?P1 s" proof(cut_tac a1 a2 b1, auto) qed then have "invHoldForRule s f r (invariants N)" by auto } moreover { assume b1: "(i~=p__Inv3\<and>i~=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_RecvGntEVsinv__46: assumes a1: "(\<exists> i. i\<le>N\<and>r=n_RecvGntE i)" and a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4)" shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s") proof - from a1 obtain i where a1:"i\<le>N\<and>r=n_RecvGntE i" apply fastforce done from a2 obtain p__Inv3 p__Inv4 where a2:"p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4" apply fastforce done have "(i=p__Inv4)\<or>(i=p__Inv3)\<or>(i~=p__Inv3\<and>i~=p__Inv4)" apply (cut_tac a1 a2, auto) done moreover { assume b1: "(i=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: "(i=p__Inv3)" have "?P1 s" proof(cut_tac a1 a2 b1, auto) qed then have "invHoldForRule s f r (invariants N)" by auto } moreover { assume b1: "(i~=p__Inv3\<and>i~=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_StoreVsinv__46: assumes a1: "\<exists> i d. i\<le>N\<and>d\<le>N\<and>r=n_Store i d" and a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4)" shows "invHoldForRule s f r (invariants N)" apply (rule noEffectOnRule, cut_tac a1 a2, auto) done lemma n_SendReqESVsinv__46: assumes a1: "\<exists> i. i\<le>N\<and>r=n_SendReqES i" and a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4)" shows "invHoldForRule s f r (invariants N)" apply (rule noEffectOnRule, cut_tac a1 a2, auto) done lemma n_SendReqSVsinv__46: assumes a1: "\<exists> j. j\<le>N\<and>r=n_SendReqS j" and a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4)" shows "invHoldForRule s f r (invariants N)" apply (rule noEffectOnRule, cut_tac a1 a2, auto) done lemma n_SendReqEIVsinv__46: assumes a1: "\<exists> i. i\<le>N\<and>r=n_SendReqEI i" and a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__46 p__Inv3 p__Inv4)" shows "invHoldForRule s f r (invariants N)" apply (rule noEffectOnRule, cut_tac a1 a2, auto) done end
#pragma once #include <boost/multi_index/tag.hpp> namespace mira{ namespace multi_index{ namespace detail{ using boost::multi_index::detail::tag_marker; template<typename T> using is_tag = boost::multi_index::detail::is_tag< T >; } /* namespace multi_index::detail */ template< typename T > using tag = boost::multi_index::tag< T >; } /* namespace multi_index */ } /* namespace mira */
<a href="https://colab.research.google.com/github/BachiLi/A-Tour-of-Computer-Animation/blob/main/A_Tour_of_Computer_Animation_2_Lagrangian_Mechanics_and_Pendulums.ipynb" target="_parent"></a> Last time we briefly discussed the Newtonian mechanics, where the position of each object is governed by the forces applied on them ($F=ma$). This is a very general model and covers all phenomonon in classical mechanics. However, in some scenarios, Newtonian mechanics can be a bit cumbersome for deriving the equations of motion. For example, what if our object is a pendulum affected by gravity (see the figure below)? The gravity force pulls the object downwards, but the pendulum wire applies another force to make the object goes towards the tangent direction. Deriving the pendulum wire force is a little bit annoying. Can we do better? The trick is to reformulate Newtonian mechanics. Instead of considering the local impact of forces to an object, we consider the whole *trajectory* of the motion. Consider the following scenario: given an initial position $x_0$ at time $t_0$, and an end position at $x_1$ at time $t_1$. There are infinitely many trajectories an object can take to go from $x_0$ to $x_1$. In reality, can we predict which trajectory the object will take? The principle for selecting the actual trajectory is called the [stationary action principle](https://en.wikipedia.org/wiki/Stationary_Action_Principle). Feynman explained this concept much better than me in his [lecture](https://www.feynmanlectures.caltech.edu/II_19.html), but I'll still try to explain it here. Before I start, note that the stationary action principle is asking a different problem compared to the Newtonian mechanics we introduced last time: in Newtonian mechanics, we are given an initial position and an initial velocity, and are asked to solve an [*initial value problem*](https://en.wikipedia.org/wiki/Initial_value_problem). Here we are asked to solve a [*boundary value problem*](https://en.wikipedia.org/wiki/Boundary_value_problem): given the endpoints (without the velocity), can we solve the intermediate motions? However, this point of view makes the stationary action principle a historically controversial law, philosophically: does an object somehow know where it is going in advance, then it decides the path in between? It turns out, mathematically, as I will show later, these two laws lead to the exact same motions in classical mechanics. So we will just use the stationary action principle as a convienent mathematical tool for deriving motions. We will leave the philosophical debate as an excersice to the readers. : ) The stationary action principle thinks in terms of energies instead of forces. The idea is that in a physical system, there is a magical quantity called energy, which is a sum of multiple components, that is kept as a constant. In classical mechanics, the energy is the sum of two components: kinetic energy $K$ and potential energy $U$. The kinetic energy represents how fast the object is moving, and the potential energy represents how much *potential* does the object have to become even faster. In classical mechanics, all motions are trade-offs between the kinetic energy and potential energy: when an object becomes faster, it is converting potential energy into kinetic energy, and vice versa. The kinetic energy $K$ is defined as: $$K = \frac{1}{2} m \dot{x}^2$$ where $m$ is the mass of the object (so far we've assumed the mass to be 1). The potential energy $U$ is defined as the integration of force $F$: $$\nabla_{x} U = -F$$ For example, in the case of a stone falling to the earth, the potential energy is $U = 9.8 m x$ where $x$ is the height (recall that $F = -9.8 m$). A magical conjecture is that the sum of kinetic energy and potential energy is a constant over time: $K + U = \text{const}$, if the force $F$ is [*conservative*](https://en.wikipedia.org/wiki/Conservative_force). A conservative force means that the force is only a function of the position, and does not depend on time or velocity. We can verify this in the stone falling case: we know the motion is $x = -\frac{9.8}{2} t^2 + \dot{x}(0)t + x(0)$. So $K + U = -\frac{1}{2} m (-9.8t + \dot{x}(0))^2 + 9.8 m (-\frac{9.8}{2} t^2 + \dot{x}(0)t + x(0)) = -\frac{1}{2} m \dot{x}(0)^2 + 9.8 m x(0)$ (notice that all the $t$ and $t^2$ terms cancel out). This is actually pretty easy to prove for the general case using $F=ma$: we can look at the time derivative of $K + U$: $$\frac{d}{dt}(K+U) = m\dot{x}\ddot{x} + \frac{dU}{dx} \dot{x} = \dot{x} \left( m \ddot{x} - F \right) = 0$$ (note that we use the conservative force assumption in the first equation: $\frac{dU}{dt} = \frac{dU}{dx}\dot{x}$ only if $U$ does not directly depend on time) Instead of the summation $K+U$, the stationary action principle looks at the difference of them $L=K-U$. The difference is called the *Lagrangian* (probably because [Lagrange](https://en.wikipedia.org/wiki/Joseph-Louis_Lagrange) was the first person who tried to do this. By the way, the sum $H=K+U$ is called the Hamiltonian and is crucial to the [*Hamiltonian mechanics*](https://en.wikipedia.org/wiki/Hamiltonian_mechanics) -- yet another formulation of classical mechanics. We may or may not get to Hamiltonian mechanics in the future). We define an *action* $S$ which is an integral over the Lagrangian $L$ over time: $$S(x) = \int_{t=t_0}^{t_1} L(x, \dot{x}, t) = \int_{t=t_0}^{t_1} K - U$$ Note that the domain of $S$ is the set of all possible paths $x$. This makes $S$ a *functional*: it is a meta function that takes a function and outputs a real number. What does the action $S$ mean intuitively? At each point of time, we are measuring the amount of movement $K$ plus the amount of integrated force (recall $\nabla_{x} U = -F$) applied on the object. This is why this is called an action: it is measuring how much the object is moving, plus how much force is applied. The stationary action principle claims that the motions in the nature will be the local extrema of the action $S(x)$ (most of the time it will be the global minimum -- nature is lazy and will minimize actions). To find the extrema of the action $S$, we need to first define the derivative of $S$ -- remember that $S$ is a *functional* -- what does it mean to differentiate a function whose input is a function? For the rigorous math the readers should consult [calculus of variation](https://en.wikipedia.org/wiki/Calculus_of_variations). We can roughly define the derivative $\delta S$ as the changes of $S$ when we apply a perturbation $\delta_x$ of $x$: $$\delta S(x) = \frac{S(x + \delta_x) - S(x)}{|\delta_x|}$$ So the stationary action principle can be mathematically stated as $\delta S(x) = 0$: we want to find trajectories $x$ that satisfy this equation. Let's verify this using our stone falling to earth example again. We have $L(x, \dot{x}, t) = \frac{1}{2}m\dot{x}^2 - 9.8 m x$. We want to figure out the motion between time $t_0 = 0, t_1 = 1$, and we know $x(0)$ and $x(1)$. To solve for the motion, let's *guess* that it's going to be a qudratic function over time: $x(t) = At^2 + Bt + C$. Our goal is to solve for the parameters $A, B, $ and $C$. Our boundary constraints tells us $x(0) = C$ and $x(1) = A + B + x(0)$. The action integral is $$S(A, B) = \int_{t=t_0}^{t_1} \frac{1}{2} m (2At+B)^2 - 9.8m(At^2+Bt+x(0))$$ With a little bit of algebra we can actually solve the action integral in closed form: $$S(A, B) = m \left( (2A^2 - 9.8A) t^2 + (2AB - 9.8B) t + \frac{1}{2}B^2 - 9.8 x(0) \right)$$ To solve for the extrema of $S(A, B)$ under our constraints $A+B = x(1) - x(0)$, we use a trick called the [Lagrange multiplier](https://en.wikipedia.org/wiki/Lagrange_multiplier) (yes it's the same Lagrange): we solve for the extrema of $G(A, B, \lambda) = S(A, B) + \lambda (A+B+x(0)-x(1))$, where $\lambda$ is a free variable. Setting the derivative of $G$ to zero we get three equations with three unknowns ($A, B, \lambda$). Solving for the system we get $A = -\frac{9.8}{2}$ and $B=x(1)-x(0)-\frac{9.8}{2}$. Compare the motion equation $x(t) = -\frac{9.8}{2}t^2 + (x(1)-x(0)-\frac{9.8}{2})t + x(0)$ to the equation from our last chapter $x(t) -\frac{9.8}{2}t^2 + \dot{x}(0)t + x(0)$, we know that if we set our initial velocity $\dot{x}(0)$ as $x(1)-x(0)-\frac{9.8}{2}$, we will arrive at $x(1)$ at time $1$. **Exercise**: we can state a different version of stationary action principle assuming we only know $x(0)$ and $\dot{x}(0)$, instead of $x(0)$ and $x(1)$. Does this different version predict the same motion? In practice, we don't always want to assume a parametric form of our motion trajectory. What can we do in that case? It turns out that the least action principle is a very strong constraint: even though we are imposing a constraint on an integral over some time, it ends up constraining each point in the time (intuitively, since $x$ is an infinite-dimensional function, taking its derivative and setting it to zero gives us infinitely many constraints). The constraint is called the [Euler-Lagrange equation](https://en.wikipedia.org/wiki/Euler%E2%80%93Lagrange_equation) (Euler proposed a first version of this, and Lagrange refined it to the current form), and can be written as follows: $$\frac{\partial L}{\partial x} = \frac{d}{dt} \frac{\partial L}{\partial \dot{x}}$$ For example, if $L(x, \dot{x}, t) = \frac{1}{2}m\dot{x}^2 - 9.8 m x$, then the corresponding Euler-Langrange equation is $$ \begin{split} \frac{\partial{L}}{\partial x} &= -9.8m \\ \frac{\partial L}{\partial \dot{x}} &= m\dot{x} \\ \frac{d}{dt} \frac{\partial L}{\partial \dot{x}} &= m\ddot{x} \\ \frac{\partial L}{\partial x} &= \frac{d}{dt} \frac{\partial L}{\partial \dot{x}} \rightarrow \ddot{x} = -9.8 \end{split} $$ We recover the equation of motion from Newtonian mechanics we had from our last chapter! In fact, the Euler-Lagrange equation is usually just a different way of writing $F=ma$. If we look at it closely, since the kinetic energy is always $\frac{1}{2}m\dot{x}^2$, $\frac{\partial L}{\partial x} = -\frac{\partial U}{\partial x} = F$, and if the potential energy $U$ does not depend on the velocity $\dot{x}$, $\frac{d}{dt} \frac{\partial L}{\partial \dot{x}} = m \ddot{x}$. The derivation of the Euler-Lagrange equation from the stationary action principle can be found online: I recommend the proof from [Preetum Nakkiran](https://preetum.nakkiran.org/lagrange.html) which is geometric and very intuitive. [Wikipedia](https://en.wikipedia.org/wiki/Euler%E2%80%93Lagrange_equation#Statement) also has the standard proof using integration by parts. I also like the derivation from [Jason Gross](https://web.mit.edu/~jgross/Public/least_action/Principle%20of%20Least%20Action%20with%20Derivation.html). The Euler-Lagrange equation connects the stationary action principle and Newtonian mechanics. Remember we set up the problem formulation as a *boundary value problem*. However, Newtonian mechanics predicts an *initial value problem*. Interestingly, since the stationary action principle puts a constraint on every single time instance, **no matter where the particle is going eventually, they need to follow the stationary action principle and Euler-Lagrange equation all the time**. So, what have we gained over all this crazy math? Let's go back to the example at the beginning, where we have a pendulum. The trick is to use something called the *generalized coordinates*. Instead of specifying the Cartesian position $x$ of the pendulum in 2D, we use a coordinate $q$ based on the angle of the pendulum. We have the relation $x(q) = (r \sin(q), r \cos(q))$ where $r$ is the length of the wire. Recall that, earlier, we parametrize the trajectory of a stone falling to earth using a quadratic $At^2+Bt+C$, and the sationary principle helps us solve the quadratic parameters. We are doing to same thing here: we "parametrize" the trajector $x$ using the angle $q$, and solve for q instead. Our Lagrangian is now: $$L(q, \dot{q}, t) = \frac{1}{2} m \dot{x}(q)^2 - 9.8 m (r - x(q)) = \frac{1}{2} m r^2 \dot{q}^2 - 9.8m r (1 - \cos(q))$$ (since $x$ is a vector, $\dot{x}(q) = -r \sin(q) \dot{q}, r \cos(q) \dot{q}$, $\dot{x}(q)^2 = \dot{x}(q) \cdot \dot{x}(q) = r^2 \dot{q}^2$) The cool thing is that the Euler-Lagrange equation still holds: $$ \begin{split} \frac{\partial L}{\partial q} &= \frac{d}{dt} \frac{\partial L}{\partial \dot{q}} \\ \frac{\partial L}{\partial q} &= - 9.8mr \sin(q) \\ \frac{\partial L}{\partial \dot{q}} &= m r^2 \dot{q} \\ \frac{d}{dt} \frac{\partial L}{\partial \dot{q}} &= mr^2 \ddot{q} \\ - 9.8mr \sin(q) &= mr^2 \ddot{q} \\ &\downarrow \\ \ddot{q} &= \frac{-9.8}{r} \sin(q) \\ \end{split} $$ We get a simple second-order ODE! In fact you can derive the same thing using Newtonian mechanics (see [here](https://www.acs.psu.edu/drussell/Demos/Pendulum/Pendula.html)), however it requires you to factor out the forces and constraints -- something that demands a bit of cleverness. Lagrangian mechanics allows us to do things in a very mechanical, automatic way: it's all basic algebra. Interestingly, despite its simplicity, this ODE does not have a known closed form. Let's try to visualize it using forward Euler method (finally some code!!): ```python import math import matplotlib.pyplot as plt from matplotlib import animation from IPython.display import HTML fps = 20 q0 = math.pi / 4 v0 = 0.0 r = 20.0 ts = 0.01 def pendulum_forward_euler(t, q, v): ct = 0 while True: nq = q + ts * v nv = v - ts * (9.8 / r) * math.sin(q) q = nq v = nv ct += ts if ct >= t: break return ct, q, v def visualize(ode_solver): fig = plt.figure(figsize=(8, 4)) ax = plt.axes(xlim=(-25, 25), ylim=(-25, 0)) line, = ax.plot([], [], '-', lw=2) point, = ax.plot([], [], 'g.', ms=20) t = 0 q = q0 v = v0 def animate(i): nonlocal t, q, v dt, q, v = ode_solver(1.0/fps, q, v) x = r * math.sin(q) y = -r * math.cos(q) t += dt line.set_data([0, x], [0, y]) point.set_data([x], [y]) return point, plt.close() return animation.FuncAnimation(fig, animate, frames=400, interval=fps, blit=True) anim = visualize(pendulum_forward_euler) HTML(anim.to_html5_video()) ``` **Exercise**: can you modify the pendulum to handle the collision with the ceiling? We'll close this chapter by deriving the Lagrangian mechanics for a double pendulum. The derivation is pretty messy, so we will use sympy to help us deriving the equations. The first mass on the pendulum is parametrized by $x_0 = (r_0 \sin(q_0), -r_0\cos(q_0))$, the second mass is parametrized by $x_1 = x_0 + (r_1 \sin(q_1), -r_1 \cos(q_1))$. Our Lagrangian is: $$L(q,\dot{q},t) = \frac{1}{2} m_0 r_0^2 \dot{q}_0^2 + \frac{1}{2} m_1 \left( r_0^2 \dot{q}_0^2 + 2 r_0 r_1 \dot{q}_0 \dot{q}_1 \cos(q_0 - q_1) + r_1^2 \dot{q}_1^2 \right) - g \left(m_0 r_0 (- \cos(q_0)) + m_1 \left( r_0 (- \cos(q_0)) + r_1 (- \cos(q_1)) \right) \right)$$ (we finally replace the 9.8 magic constant with g) Let's define it in sympy: ```python import sympy sympy.init_printing() # printing latex t, m0, r0, m1, r1, g = sympy.symbols('t, m0, r0, m1, r1, g') q0 = sympy.Function('q0')(t) q1 = sympy.Function('q1')(t) v0 = q0.diff(t) # \dot{q}_0 v1 = q1.diff(t) # \dot{q}_1 half = sympy.Rational(1, 2) # Lagrangian K = half * m0 * r0 * r0 * v0 * v0 + \ half * m1 * (r0 * r0 * v0 * v0 + 2 * r0 * r1 * v0 * v1 * sympy.cos(q0 - q1) + r1 * r1 * v1 * v1) U = g * (m0 * r0 * (- sympy.cos(q0)) + m1 * (r0 * (- sympy.cos(q0)) + r1 * (- sympy.cos(q1)))) L = sympy.simplify(K - U) L ``` Next we use sympy to derive the Euler-Lagrange equation (sympy has a function [euler_equations](https://docs.sympy.org/latest/modules/calculus/index.html) for this purpose, but we'll do it manually just for this time): ```python dLdq0 = L.diff(q0).simplify() dLdq1 = L.diff(q1).simplify() dLdv0 = L.diff(v0).simplify() dLdv1 = L.diff(v1).simplify() dLdv0dt = dLdv0.diff(t).simplify() dLdv1dt = dLdv1.diff(t).simplify() eq0 = sympy.simplify(dLdq0 - dLdv0dt) # this should be 0 eq1 = sympy.simplify(dLdq1 - dLdv1dt) # this should be 0 ``` ```python eq0 ``` sympy's equation solver didn't do what I wanted. So we'll have to manually arrange the equations. ```python # simplify eq0 manually eq0 = -eq0 / r0 eq0.args ``` ```python eq0 = sympy.simplify(eq0.args[0] + eq0.args[1]) + sympy.simplify(eq0.args[2] + eq0.args[3]) + eq0.args[4] + eq0.args[5] eq0.args ``` ```python eq1 ``` ```python # simplify eq1 manually eq1 = -eq1 / (m1 * r1) eq1.args ``` ```python # eliminate a1 a0 = (eq0 - eq1 * m1 * sympy.cos(q0 - q1)).expand() a0.args ``` ```python # manually simplify a0 a0 = sympy.simplify(a0.args[0] + a0.args[1]) + sympy.simplify(a0.args[2] + a0.args[3] + a0.args[6]) + a0.args[4] + a0.args[5] + a0.args[7] a0.args ``` ```python # r0 (m0 - m1 cos^2(q0 - q1) + m1) = r0 (m0 + m1 sin^2(q0 - q1)) s = sympy.sin(q0 - q1) # minus sign for moving d^2 dq0/dt^2 to the other side of the equation a0solve = -(a0.args[0] + sum(a0.args[2:])) / (r0 * (m0 + m1 * s * s)) a0solve ``` ```python # eliminate a0 a1 = (eq0 * sympy.cos(q0 - q1) - eq1 * (m0 + m1)).expand() a1.args ``` ```python # manually simplify a1 a1 = sympy.simplify(a1.args[0] + a1.args[1]) + sympy.simplify(a1.args[2] + a1.args[3] + a1.args[8]) + sympy.simplify(a1.args[4] + a1.args[5]) + sympy.simplify(a1.args[6] + a1.args[7]) + a1.args[9] a1.args ``` ```python # r1 (-m0 + m1 cos^2(q0 - q1) - m1) = -r1 (m0 + m1 sin^2(q0 - q1)) # a minus sign for the denominator, another minus sign for moving d^2 dq1/dt^2 to the other side of the equation a1solve = sum(a1.args[1:]) / (r1 * (m0 + m1 * s * s)) a1solve ``` ```python sympy.Eq(q0.diff(t).diff(t), a0solve) ``` ```python sympy.Eq(q1.diff(t).diff(t), a1solve) ``` Above is our velocity update formula. Let's try to implement this! ```python import math import matplotlib.pyplot as plt from matplotlib import animation from IPython.display import HTML fps = 20 g = 9.8 q0_init = math.pi v0_init = 0.0 q1_init = -math.pi / 4 v1_init = 0.0 r0 = 20.0 r1 = 20.0 m0 = 1 m1 = 1 ts = 0.001 def double_pendulum_forward_euler(t, q0, v0, q1, v1): ct = 0 while True: nq0 = q0 + ts * v0 nq1 = q1 + ts * v1 s0 = math.sin(q0) s1 = math.sin(q1) sd = math.sin(q0 - q1) cd = math.cos(q0 - q1) nv0 = v0 + ts * (g * m1 * s1 * cd - g * (m0 + m1) * s0 - m1 * r0 * sd * cd * v0 * v0 - m1 * r1 * sd * v1 * v1) / (r0 * (m0 + m1 * sd * sd)) nv1 = v1 + ts * (g * (m0 + m1) * s0 * cd - g * (m0 + m1) * s1 + m1 * r1 * sd * cd * v1 * v1 + r0 * (m0 + m1) * sd * v0 * v0) / (r1 * (m0 + m1 * sd * sd)) q0 = nq0 q1 = nq1 v0 = nv0 v1 = nv1 ct += ts if ct >= t: break return ct, q0, v0, q1, v1 def visualize(ode_solver): fig = plt.figure(figsize=(8, 8)) ax = plt.axes(xlim=(-55, 55), ylim=(-55, 55)) line, = ax.plot([], [], '-', lw=2) point, = ax.plot([], [], 'g.', ms=20) t = 0 q0 = q0_init v0 = v0_init q1 = q1_init v1 = v1_init def animate(i): nonlocal t, q0, v0, q1, v1 dt, q0, v0, q1, v1 = ode_solver(1.0/fps, q0, v0, q1, v1) x0 = r0 * math.sin(q0) y0 = -r0 * math.cos(q0) x1 = x0 + r1 * math.sin(q1) y1 = y0 - r1 * math.cos(q1) t += dt line.set_data([0, x0, x1], [0, y0, y1]) point.set_data([x0, x1], [y0, y1]) return point, plt.close() return animation.FuncAnimation(fig, animate, frames=800, interval=fps, blit=True) anim = visualize(double_pendulum_forward_euler) HTML(anim.to_html5_video()) ``` **Exercise**: can you implement the collision between the masses and the wires? This actually already allows us to do some fun character animations! Imagine the double pendulum above being an arm of a character. You can setup an articulated character and derive its dynamics yourself using the Lagrangian mechanics. In summary, we have learned a very powerful way, called Lagrangian mechanics, to derive equations of motion. The usual process to set up a computer animation, is to specify our animation in a generalized coordinates $q$ and their mapping to the Cartesian coordinates $x$. We then derive our Lagrangian $L$: the kinetic energy $K$ is always $\frac{1}{2} m v^2$, the potential energy $U$ depends on the interactions you want to have between the objects and user inputs. We then solve the sationary action principle or the Euler-Lagrange equation to compute the animation at certain time. This process is very mechanical and mostly involving just doing some algebra, and importantly, it enables us to design physically-based animation with great flexibility! In the next chapter, we will analyze the discretization we've been doing to the differential equation: Are there better way to do it other than the forward Euler method? (yes) What are the different desirable criteria for a discretization?
• Teaching Openings in Taiwan: The Department of Education in every city or country will post the jobs on their website, and the graduates/teachers can find the information through these websites. • Industrial Technology Education Association of Taiwan, R.O.C. This department was originally founded in February 1953, focused on the preparation of secondary school Industrial Arts teachers as well as conducting researches related to Industrial Arts Education. In August 1994 its name was changed to the Department of Industrial Technology Education, aimed at preparing of secondary school technology teachers as well as the professionals for human resource development in business and industry. In August 2009, the name was formally changed to the Department of Technology Application and Human Resource Development, fully devotes to prepare the professionals for human resource development in technology and industries. At present, the department has undergraduate, master, and PhD programs.
{-# OPTIONS --rewriting #-} open import Agda.Primitive open import Agda.Builtin.Equality open import Agda.Builtin.Equality.Rewrite variable ℓ ℓ' : Level A : Set ℓ B : Set ℓ' x y z : A sym : x ≡ y → y ≡ x sym refl = refl _∙_ : x ≡ y → y ≡ z → x ≡ z refl ∙ refl = refl leftId : (p : x ≡ y) → refl ∙ p ≡ p leftId refl = refl rightId : (p : x ≡ y) → p ∙ refl ≡ p rightId refl = refl transport : (P : A → Set ℓ') → x ≡ y → P x → P y transport _ refl px = px ap : (f : A → B) → x ≡ y → f x ≡ f y ap _ refl = refl apd : (P : A → Set ℓ') → (f : (a : A) → P a) → (p : x ≡ y) → transport P p (f x) ≡ f y apd _ _ refl = refl postulate Size : Set base : Size next : Size → Size inf : Size lim : next inf ≡ inf postulate elim : (P : Size → Set ℓ) → (pb : P base) → (pn : (s : Size) → P s → P (next s)) → (pi : P inf) → -- (elim P pb pn pi pl (next inf)) = (elim P pb pn pi pl inf) (pl : transport P lim (pn inf pi) ≡ pi) → (s : Size) → P s elim-base : (P : Size → Set ℓ) → (pb : P base) → (pn : (s : Size) → P s → P (next s)) → (pi : P inf) → (pl : transport P lim (pn inf pi) ≡ pi) → elim P pb pn pi pl base ≡ pb elim-next : (P : Size → Set ℓ) → (pb : P base) → (pn : (s : Size) → P s → P (next s)) → (pi : P inf) → (pl : transport P lim (pn inf pi) ≡ pi) → (s : Size) → elim P pb pn pi pl (next s) ≡ pn s (elim P pb pn pi pl s) elim-inf : (P : Size → Set ℓ) → (pb : P base) → (pn : (s : Size) → P s → P (next s)) → (pi : P inf) → (pl : transport P lim (pn inf pi) ≡ pi) → elim P pb pn pi pl inf ≡ pi {-# REWRITE elim-base elim-next elim-inf #-} postulate elim-lim : (P : Size → Set ℓ) → (pb : P base) → (pn : (s : Size) → P s → P (next s)) → (pi : P inf) → (pl : transport P lim (pn inf pi) ≡ pi) → apd P (elim P pb pn pi pl) lim ≡ pl {-# REWRITE elim-lim #-} -- postulate lim-refl : transport (λ s → s ≡ inf) lim lim ≡ refl absurd : ∀ {A s} → base ≡ next s → A absurd {A} p = let discr : Size → Set discr = elim (λ _ → Set) Size (λ _ _ → A) A (apd (λ _ → Set) (λ _ → A) lim) in transport discr p base inj : ∀ {s t} → next s ≡ next t → s ≡ t inj {s} {t} p = let pred : Size → Size pred = elim (λ _ → Size) base (λ s _ → s) inf (apd (λ _ → Size) (λ s → inf) lim) in ap pred p data Nat : Size → Set where zero : (s : Size) → Nat (next s) succ : (s : Size) → Nat s → Nat (next s) prev : (P : Size → Set ℓ') → P (next inf) → P inf prev P pni = transport P lim pni double' : ∀ s → Nat s → Nat inf double' _ (zero _) = prev Nat (zero inf) double' _ (succ s n) = prev Nat (succ inf (prev Nat (succ inf (double' s n)))) -- pn inf pi ≡ pi -- zero: zero = ?pi -- next: succ _ (succ _ ?pi) = ?pi double : ∀ s → Nat s → Nat inf double = elim (λ s → Nat s → Nat inf) {! !} {! !} {! !} {! !}
%******************************************************************** % Appendix %******************************************************* % If problems with the headers: get headings in appendix etc. right %\markboth{\spacedlowsmallcaps{Appendix}}{\spacedlowsmallcaps{Appendix}} \begin{comment} \chapter{Appendix} \section{Scheme Ratings} \subsection{Context-Aware Authentication} \todo[inline]{Revisit this section} \citet{bardram2003context} puts forward a prototype and authentication protocol for secure and usable authentication for physicians in hospitals. The system is comprised of a personal smart-card that can be inserted at the hospital computers to access the computers, and a context-aware subsystem that as minimum is location-aware. If the practitioners try to access a computer using their keycard, and their location is the same as the work stations, then they're authenticated without further interaction. If the location differs then they're asked to type their password. When a new keycard is initialized it generates a public/private keypair and sends the public key to the central server. The keycard uses a one-way authentication protocol and the users password is only known to the keycard. We grant the system \textit{Quasi-Memorywise-Effortless} as the user is still required to remember the keycard password. It is \textit{Scalable-for-Users} as the card could easily submit the same public-key to many verifiers. It is not \textit{Noting-to-Carry}, although, in the hospital setup where it is applied, the staff is required to carry their identity card, and it could qualify for a \textit{Quasi-Noting-to-Carry} is some scenarios. It is both \textit{Easy-to-Learn}, \textit{Efficient-to-Use} and \textit{Infrequent-Errors} (Assuming that the context-aware service works most of the time). It is not \textit{Easy-Recovery-from-Loss} as a new card needs to be issued, and a new public-private key-pair needs to be created and submitted to verifies. As it is a prototype Deployability is less interesting, however we grant it \textit{Accessible} and \textit{Non-Propritary}. The system is not \textit{Negligible-Cost-per-User} as the setup is very infrastructure heavy. The system is not built to access web services and is therefore neither \textit{Browser-Compatible} nor \textit{Server-Compatible}. However, it could easily be used for web services by transmitting the users public key to every verifier, or even generate a new key-pair for every verifier. It would however still not be compatible. On the security aspects we deem it to be \textit{Quasi-Resilient-to-Physical-Observation} as the user only rarely types the password. However, if the keycard is stolen and the password is known the adversary he has full access, and we therefore grant it \textit{Quasi-Resilient-to-Theft}. It is not \textit{Resilient-to-Phishing} as man-in-the-middle attacks are possible. It is not \textit{Resilient-to-Throttled-Guessing} nor \textit{Resilient-to-Unthrottled-Guessing}, however, the adversary would have to steal the keycard to start guessing. Whether it is \textit{Unlinkable} depends on if it uses separate key-pairs or not. We assume the later and grant it \textit{Unlinkable}. It is \textit{Quasi-Continuous} as there is no continuous authentication per say, but the user is logged-out as soon as the keycard is removed from the bay. \subsection{Wearable Authentication} \todo[inline]{Revisit this section} \citet{ojala2008wearable} presents a prototype for transparent and continuous authentication with work stations. The system is comprised of three components. A ZigBee enabled wearable wrist device that monitors the wearers vitals, a ZigBee receiver and the workstation. When the user puts on the watch it starts to monitor his vitals. The user can now use a fingerprint reader to authenticate with the system. The user remains authenticated for as long as he is wearing the watch. If he takes off the watch, or his vitals stops, then he will be logged-out after 10 seconds. While the user is authenticated he can approach any work station (that has a receiver) and without further interaction start using the machine. As soon as he leaves the machine he is logged out. We grant the system \textit{Memorywise-Effortless}, \textit{Scalable-for-Users}, \textit{Easy-to-Learn}, \textit{Efficient-to-Use} and \textit{Infrequent-Errors}. We deem it \textit{Quasi-Nothing-to-Carry} as a watch is something that most users always carry, just like a smartphone. It is not \textit{Easy-Recovery-from-Loss} as loosing the watch means having to get a new one, that should then be authorized. As the system, much like two previous is a prototype that is not built for web-services, we grant it the same scores for deployability. On the security side it is \textit{Resilient-to-Physical-Observation}, \textit{Resilient-to-Targeted-Impersonation}, \textit{Resilient-to-Throttled-Guessing}, \textit{Resilient-to-Un\-throttled-Guessing}, \textit{Resilient-to-Theft} and \textit{Continuous}. It is \textit{Quasi-Requiring-Explicit-Consent} as the user only gives explicit consent once when using the fingerprint reader. Other security aspects are not known due to the simplicity of the prototype and is therefore left out of consideration, although we deem them feasible to include. \end{comment} \chapter{Android Cryptography Implementation} \lstinputlisting[language=Java, basicstyle=\scriptsize\ttfamily, numberstyle=\scriptsize\ttfamily, label=lst:distEl]{code/DistributedElgamal.java} \chapter{Server Cryptography Implementation} \lstinputlisting[language=Java, basicstyle=\scriptsize\ttfamily, numberstyle=\scriptsize\ttfamily, label=lst:chalService]{code/ChallengeService.java} \chapter{Server JWT Implementation} \lstinputlisting[language=Java, basicstyle=\scriptsize\ttfamily, numberstyle=\scriptsize\ttfamily, label=lst:tokenService]{code/TokenService.java} \chapter{Tamarin Model}\label{ch:tamarin} \lstinputlisting[language=spthy, basicstyle=\scriptsize\ttfamily, numberstyle=\scriptsize\ttfamily]{code/cta.spthy} \chapter{Strong Internal Observation Attack}\label{ch:attack} \begin{figure}[h] \centering \begin{wide} \includegraphics[width=\linewidth]{gfx/attack} \end{wide} \caption[Tamarin trace of SIO attack]{The tamarin trace of the Strong Internal Observation Attack} \label{fig:my_label} \end{figure}
Parameter object : Type. Definition PN : Type := object. Definition VP : Type := object -> Prop. Definition NP : Type := VP -> Prop . (* NP := (PN -> Prop) -> Prop *) Definition UsePN : PN -> NP := fun pn vp => vp pn. Definition Cl : Type := Prop . Definition PredVP : NP -> VP -> Cl := fun np vp => np vp. Definition V : Type := object -> Prop. Definition UseV : V -> VP := fun v => v. Definition S : Type := Prop . Definition Pol : Type := Prop -> Prop . Definition Pos : Pol := fun p => p. Definition Neg : Pol := fun p => not p. Definition UseCl : Pol -> Cl -> S := fun pol c => pol c. Parameter AP : Type. Parameter A : Type. Parameter CN : Type. Parameter Det : Type. Parameter N : Type. Parameter V2 : Type. Parameter AdA : Type. Parameter Conj : Type. Parameter ComplV2 : V2 -> NP -> VP. Parameter DetCN : Det -> CN -> NP. Parameter ModCN : AP -> CN -> CN. Parameter CompAP : AP -> VP. Parameter AdAP : AdA -> AP -> AP. Parameter ConjS : Conj -> S -> S -> S. Parameter ConjNP : Conj -> NP -> NP -> NP. Parameter UseN : N -> CN. Parameter UseA : A -> AP. Parameter some_Det : Det. Parameter every_Det : Det. Parameter we_NP : NP. Parameter you_NP : NP. Parameter very_AdA : AdA. Parameter and_Conj : Conj. Parameter or_Conj : Conj. Parameter man_N : N. Parameter woman_N : N . Parameter house_N : N. Parameter tree_N : N . Parameter big_A : A . Parameter small_A : A . Parameter green_A : A . Parameter walk_V : V . Parameter arrive_V : V . Parameter love_V2 : V2 . Parameter please_V2 : V2 . Parameter john_PN : PN . Parameter mary_PN : PN. Definition everyoneNP : NP := fun vp => forall x, vp x. Theorem everyone: everyoneNP walk_V-> walk_V john_PN. cbv. intros. apply H. Qed.
module CombinatoryLogic.Syntax where open import Data.String using (String; _++_) open import Relation.Binary.PropositionalEquality using (_≡_; refl) -- Kapitel 1, Abschnitt C, §4 (Symbolische Festsetzungen), Def. 1 infixl 6 _∙_ data Combinator : Set where -- Kapitel 1, Abschnitt C, §3 (Die formalen Grundbegriffe) B C W K Q Π P ∧ : Combinator -- Kapitel 1, Abschnitt C, §2, c (Anwendung) _∙_ : (X Y : Combinator) → Combinator -- NOTE: for the (intensional) equality defined by Kapitel 1, Abschnitt C, §4 -- (Symbolische Festsetzungen), Festsetzung 2, we use the propositional equality -- _≡_. toString : Combinator → String toString (X ∙ Y@(_ ∙ _)) = toString X ++ "(" ++ toString Y ++ ")" toString (X ∙ Y) = toString X ++ toString Y toString B = "B" toString C = "C" toString W = "W" toString K = "K" toString Q = "Q" toString Π = "Π" toString P = "P" toString ∧ = "∧" _ : toString (K ∙ Q ∙ (W ∙ C)) ≡ "KQ(WC)" _ = refl _ : toString (K ∙ ∧ ∙ (Q ∙ Π) ∙ (W ∙ C)) ≡ "K∧(QΠ)(WC)" _ = refl _ : toString (K ∙ ∧ ∙ ((Q ∙ Π) ∙ (W ∙ C))) ≡ "K∧(QΠ(WC))" _ = refl _ : toString (K ∙ K ∙ K) ≡ "KKK" _ = refl infix 5 _==_ -- Kapitel 1, Abschnitt C, §4 (Symbolische Festsetzungen), Def. 2 _==_ : (X Y : Combinator) → Combinator X == Y = Q ∙ X ∙ Y -- Kapitel 1, Abschnitt C, §4 (Symbolische Festsetzungen), Def. 3 I : Combinator I = W ∙ K
@testset "RepeatPartitionIterator" begin @testset "RepeatPartitionIterator basic" begin bitr = RepeatPartitionIterator(1:20, 5) for (itr, exp) in zip(bitr, [1:5, 6:10, 11:15, 16:20]) @test collect(itr) == exp @test collect(itr) == exp @test collect(itr) == exp end end @testset "RepeatPartitionIterator partition" begin bitr = RepeatPartitionIterator(Iterators.partition(1:20, 5), 2) for (itr, exp) in zip(bitr, [[1:5, 6:10], [11:15, 16:20]]) @test collect(itr) == exp @test collect(itr) == exp @test collect(itr) == exp end end @testset "RepeatPartitionIterator repeated partition" begin import IterTools: ncycle bitr = RepeatPartitionIterator(ncycle(Iterators.partition(1:20, 5), 3), 2) cnt = 0; for (itr, exp) in zip(bitr, [[1:5, 6:10], [11:15, 16:20],[1:5, 6:10], [11:15, 16:20],[1:5, 6:10], [11:15, 16:20]]) @test collect(itr) == exp @test collect(itr) == exp @test collect(itr) == exp cnt += 1 end end end @testset "SeedIterator" begin rng = MersenneTwister(123) testitr = SeedIterator(Iterators.map(x -> x * rand(rng, Int), ones(10)); rng=rng, seed=12) @test collect(testitr) == collect(testitr) rng = MersenneTwister(1234) nesteditr = SeedIterator(Iterators.map(x -> x * rand(rng, Int), testitr); rng=rng, seed=1) @test collect(nesteditr) == collect(nesteditr) end @testset "GpuIterator" begin dorg = 1:100; itr = GpuIterator(zip([view(dorg,1:10)], [dorg])) d1,d2 = first(itr) |> cpu @test !isa(d1, SubArray) @test d1 == dorg[1:10] @test d2 == dorg end @testset "BatchIterator" begin @testset "Single array" begin itr = BatchIterator(collect(reshape(1:2*3*4*5,2,3,4,5)), 2) for (i, batch) in enumerate(itr) @test size(batch) == (2,3,4,i==3 ? 1 : 2) end @test "biter: $itr" == "biter: BatchIterator(size=(2, 3, 4, 5), batchsize=2, shuffle=false)" end @testset "Tuple data shuffle=$shuffle" for shuffle in (true, false) itr = BatchIterator((collect([1:10 21:30]'), 110:10:200), 3; shuffle) for (i, (x, y)) in enumerate(itr) expsize = i == 4 ? 1 : 3 @test size(x) == (2, expsize) @test size(y) == (expsize,) end end @testset "BatchIterator singleton" begin itr = BatchIterator(Singleton([1,3,5,7,9,11]), 2) for (i, b) in enumerate(itr) @test b == [1,3] .+ 4(i-1) end end @testset "BatchIterator shuffle basic" begin @test reduce(vcat, BatchIterator(1:20, 3; shuffle=true)) |> sort == 1:20 itr = BatchIterator(ones(2,3,4), 4; shuffle=MersenneTwister(2)) @test "siter: $itr" == "siter: BatchIterator(size=(2, 3, 4), batchsize=4, shuffle=true)" end @testset "BatchIterator shuffle ndims $(length(dims))" for dims in ((5), (3,4), (2,3,4), (2,3,4,5), (2,3,4,5,6), (2,3,4,5,6,7)) sitr = BatchIterator(collect(reshape(1:prod(dims),dims...)), 2;shuffle=MersenneTwister(12)) bitr = BatchIterator(collect(reshape(1:prod(dims),dims...)), 2) sall, nall = Set{Int}(), Set{Int}() for (sb, nb) in zip(sitr, bitr) @test sb != nb @test size(sb) == size(nb) push!(sall, sb...) push!(nall, nb...) end @test sall == nall end end @testset "RepeatPartitionIterator and ShuffleIterator" begin import IterTools: ncycle @testset "Single epoch small" begin ritr = RepeatPartitionIterator(BatchIterator(1:20, 3; shuffle=MersenneTwister(123)), 4) for itr in ritr @test collect(itr) == collect(itr) end end @testset "Multi epoch small" begin sitr = BatchIterator(1:20, 3;shuffle=MersenneTwister(123)) citr = ncycle(sitr, 2) ritr = RepeatPartitionIterator(SeedIterator(citr; rng=sitr.rng), 4) for itr in ritr @test collect(itr) == collect(itr) end end @testset "Multi epoch big" begin sitr = BatchIterator(1:20, 3;shuffle= MersenneTwister(123)) citr = ncycle(sitr, 4) ritr = RepeatPartitionIterator(SeedIterator(citr; rng=sitr.rng), 10) for (i, itr) in enumerate(ritr) @test collect(itr) == collect(itr) end end end @testset "StatefulGenerationIter" begin import NaiveGAflux: itergeneration, StatefulGenerationIter ritr = RepeatPartitionIterator(BatchIterator(1:20, 3), 4) sitr = RepeatPartitionIterator(BatchIterator(1:20, 3), 4) |> StatefulGenerationIter for (i, itr) in enumerate(ritr) @test collect(itr) == collect(itergeneration(sitr, i)) end end @testset "TimedIterator" begin @testset "No stopping accumulate = $acc" for (acc, exp) in ( (true, 7), (false, 0) ) timeoutcnt = 0 titer = TimedIterator(;timelimit=0.1, patience=2, timeoutaction = () -> timeoutcnt += 1, accumulate_timeouts=acc, base=1:10) @test collect(titer) == 1:10 @test timeoutcnt === 0 # Or else we'll have flakey tests... for i in titer if iseven(i) sleep(0.11) # Does not matter here if overloaded CI VM takes longer than this to get back to us end end # When accumulating timeouts: after 1,2,3,4 our patience is up, call timeoutaction for 4,5,6,7,8,9,10 # When not accumulating: We never reach patience level @test timeoutcnt == exp end @testset "Stop iteration at timeout" begin # also test that we really timeout when not accumulating here titer = TimedIterator(;timelimit=0.1, patience=4, timeoutaction = () -> TimedIteratorStop, accumulate_timeouts=false, base=1:10) last = 0 for i in titer last = i if i > 2 sleep(0.11) # Does not matter here if overloaded CI VM takes longer than this to get back to us end end @test last === 6 # Sleep after 2, then 4 patience end end
lemma connected_linear_image: fixes f :: "'a::euclidean_space \<Rightarrow> 'b::real_normed_vector" assumes "linear f" and "connected s" shows "connected (f ` s)"
The complex conjugate of a negative number is the negative of the complex conjugate of the number.
Address(Orchard Park Drive) runs north south in the north west corner of core campus. Starting at the north end it passes between student housing complexes. Then it crosses Orchard Road and passes the domes and greenhouses. Next is the student farm and the Colleges at La Rue.
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 conj2synthconj5 : forall (lv0 : natural) (lv1 : natural), (@eq natural (lv0) (plus lv0 lv1)). Admitted. QuickChick conj2synthconj5.
= Plain maskray =
[STATEMENT] lemma crsp_step_in: assumes layout: "ly = layout_of ap" and compile: "tp = tm_of ap" and crsp: "crsp ly (as, lm) (s, l, r) ires" and fetch: "abc_fetch as ap = Some ins" shows "\<exists> stp>0. crsp ly (abc_step_l (as, lm) (Some ins)) (steps (s, l, r) (ci ly (start_of ly as) ins, start_of ly as - 1) stp) ires" [PROOF STATE] proof (prove) goal (1 subgoal): 1. \<exists>stp>0. crsp ly (abc_step_l (as, lm) (Some ins)) (steps (s, l, r) (ci ly (start_of ly as) ins, start_of ly as - 1) stp) ires [PROOF STEP] using assms [PROOF STATE] proof (prove) using this: ly = layout_of ap tp = tm_of ap crsp ly (as, lm) (s, l, r) ires abc_fetch as ap = Some ins goal (1 subgoal): 1. \<exists>stp>0. crsp ly (abc_step_l (as, lm) (Some ins)) (steps (s, l, r) (ci ly (start_of ly as) ins, start_of ly as - 1) stp) ires [PROOF STEP] apply(cases ins, simp_all) [PROOF STATE] proof (prove) goal (3 subgoals): 1. \<And>x1. \<lbrakk>crsp (layout_of ap) (as, lm) (s, l, r) ires; ins = Inc x1; ly = layout_of ap; tp = tm_of ap; abc_fetch as ap = Some (Inc x1)\<rbrakk> \<Longrightarrow> \<exists>stp>0. crsp (layout_of ap) (abc_step_l (as, lm) (Some (Inc x1))) (steps (s, l, r) (ci (layout_of ap) (start_of (layout_of ap) as) (Inc x1), start_of (layout_of ap) as - Suc 0) stp) ires 2. \<And>x21 x22. \<lbrakk>crsp (layout_of ap) (as, lm) (s, l, r) ires; ins = Dec x21 x22; ly = layout_of ap; tp = tm_of ap; abc_fetch as ap = Some (Dec x21 x22)\<rbrakk> \<Longrightarrow> \<exists>stp>0. crsp (layout_of ap) (abc_step_l (as, lm) (Some (Dec x21 x22))) (steps (s, l, r) (ci (layout_of ap) (start_of (layout_of ap) as) (Dec x21 x22), start_of (layout_of ap) as - Suc 0) stp) ires 3. \<And>x3. \<lbrakk>crsp (layout_of ap) (as, lm) (s, l, r) ires; ins = Goto x3; ly = layout_of ap; tp = tm_of ap; abc_fetch as ap = Some (Goto x3)\<rbrakk> \<Longrightarrow> \<exists>stp>0. crsp (layout_of ap) (abc_step_l (as, lm) (Some (Goto x3))) (steps (s, l, r) (ci (layout_of ap) (start_of (layout_of ap) as) (Goto x3), start_of (layout_of ap) as - Suc 0) stp) ires [PROOF STEP] apply(rule crsp_step_inc, simp_all) [PROOF STATE] proof (prove) goal (2 subgoals): 1. \<And>x21 x22. \<lbrakk>crsp (layout_of ap) (as, lm) (s, l, r) ires; ins = Dec x21 x22; ly = layout_of ap; tp = tm_of ap; abc_fetch as ap = Some (Dec x21 x22)\<rbrakk> \<Longrightarrow> \<exists>stp>0. crsp (layout_of ap) (abc_step_l (as, lm) (Some (Dec x21 x22))) (steps (s, l, r) (ci (layout_of ap) (start_of (layout_of ap) as) (Dec x21 x22), start_of (layout_of ap) as - Suc 0) stp) ires 2. \<And>x3. \<lbrakk>crsp (layout_of ap) (as, lm) (s, l, r) ires; ins = Goto x3; ly = layout_of ap; tp = tm_of ap; abc_fetch as ap = Some (Goto x3)\<rbrakk> \<Longrightarrow> \<exists>stp>0. crsp (layout_of ap) (abc_step_l (as, lm) (Some (Goto x3))) (steps (s, l, r) (ci (layout_of ap) (start_of (layout_of ap) as) (Goto x3), start_of (layout_of ap) as - Suc 0) stp) ires [PROOF STEP] apply(rule crsp_step_dec, simp_all) [PROOF STATE] proof (prove) goal (1 subgoal): 1. \<And>x3. \<lbrakk>crsp (layout_of ap) (as, lm) (s, l, r) ires; ins = Goto x3; ly = layout_of ap; tp = tm_of ap; abc_fetch as ap = Some (Goto x3)\<rbrakk> \<Longrightarrow> \<exists>stp>0. crsp (layout_of ap) (abc_step_l (as, lm) (Some (Goto x3))) (steps (s, l, r) (ci (layout_of ap) (start_of (layout_of ap) as) (Goto x3), start_of (layout_of ap) as - Suc 0) stp) ires [PROOF STEP] apply(rule_tac crsp_step_goto, simp_all) [PROOF STATE] proof (prove) goal: No subgoals! [PROOF STEP] done
```python from gio import GIO import numpy as np ##Data from Chan et al. (2018)'s Example 1## #Notice that we have numpy arrays here. A = np.array([[2,5],[2,-3],[2,1],[-2,-1]]) b = np.array([[10],[-6],[4],[-10]]) x0 = np.array([[2.5],[3]]) ##Creating the GIO object and Generating all of the x^0-ep* for all GIO Models## #.GIO_all_measures() calls all of the GIO methods gio_testing = GIO(A,b,x0) gio_testing.GIO_all_measures() print("This is x^0-ep* for p=1: ",gio_testing.x0_epsilon_p[0]) print("This is x^0-ep* for p=2: ",gio_testing.x0_epsilon_p[1]) print("This is x^0-ep* for p='inf': ",gio_testing.x0_epsilon_p[2]) print("This is x^0-ep* for absolute duality: ",gio_testing.x0_epsilon_a) print("This is x^0-ep* for relative duality: ",gio_testing.x0_epsilon_r) ``` This is x^0-ep* for p=1: [[ 2.5 ] [ 3.66666667]] This is x^0-ep* for p=2: [[ 2.19230769] [ 3.46153846]] This is x^0-ep* for p='inf': [[ 2.1] [ 3.4]] This is x^0-ep* for absolute duality: [array([[ 2.1], [ 3.4]])] This is x^0-ep* for relative duality: [array([[ 3.16666667], [ 3.66666667]])] ```python ##Because we are storing the calculated attributes in lists, we see that, ##for the last two print statements in the previous cell, a list was returned ##with an array inside of it. We can solve this problem by add an index element [0] print("This is x^0-ep* for absolute duality: ",gio_testing.x0_epsilon_a[0]) print("This is x^0-ep* for relative duality: ",gio_testing.x0_epsilon_r[0]) ``` This is x^0-ep* for absolute duality: [[ 2.1] [ 3.4]] This is x^0-ep* for relative duality: [[ 3.16666667] [ 3.66666667]] ```python ##The GIO class also handles cases when you might minimally project onto multiple ##hyperplanes. The class will put the multiple istar indices into the .istar_multi ##attribute but will choose the first istar index as the one to continue calculations. ##The class will also output a message to the user to let the user know that ##this has occurred. A_1 = np.array([[-1,-1],[1,-1],[1,1],[-1,1]]) b_1 = np.array([[-1],[-1],[-1],[-1]]) x0_1 = np.array([[0],[0.7]]) ``` The corresponding feasible region set up for the above $A$ and $b$ is as follows: \begin{equation} -x_1 - x_2 \geq -1 \end{equation} \begin{equation} x_1 - x_2 \geq -1 \end{equation} \begin{equation} x_1 + x_2 \geq -1 \end{equation} \begin{equation} -x_1 + x_2 \geq -1 \end{equation} We can then demonstrate the feasible region using the image below (with approximate placement of $x^0$ below). The numbering corresponds to the order of the constraints below (and then the 0 indexing of Python). ```python ##We will create another GIO object to find the optimal epsilon* under the p=1 norm. ##Due to the position of x0_1 and the properties of the p=1 norm, we know that this ##will result into a projection onto multiple hyperplanes #We will need to bring in everything again because we had a break in the code #cells (with the markup cell above) from gio import GIO import numpy as np A_1 = np.array([[-1,-1],[1,-1],[1,1],[-1,1]]) b_1 = np.array([[-1],[-1],[-1],[-1]]) x0_1 = np.array([[0],[0.7]]) gio_multi_project_testing = GIO(A_1,b_1,x0_1) gio_multi_project_testing.GIO_p(1,'F') ``` Under the inf dual norm, x^0 has been projected onto multiple hyperplanes. For now, we will choose the first i index and will put the rest of the indices in the istar_multi attribute. ```python ##As we can see, a message is printed to the user when x^0 is projected onto multiple ##hyperplanes. ##We can see the multiple istar if we print the .istar_multi attribute print(gio_multi_project_testing.istar_multi) ``` [array([0, 1], dtype=int64)] ```python ##To obtain the raw indices, index into the list print("Raw Indices: ", gio_multi_project_testing.istar_multi[0]) ##To obtain only one of the indices, do a double index print("Single index: ",gio_multi_project_testing.istar_multi[0][0]) ``` Raw Indices: [0 1] Single index: 0 ```python ##We see though that only one epsilon* is calculated and thus only one x^0-epsilon* ##is also calculated print("This is the epsilon* for p=1: ",gio_multi_project_testing.epsilon_p) print("This is the (x^0 - epsilon*): ",gio_multi_project_testing.x0_epsilon_p) ``` This is the epsilon* for p=1: [array([[-0.3], [-0. ]])] This is the (x^0 - epsilon*): [array([[ 0.3], [ 0.7]])] ```python ###Calculating rho values### from gio import GIO import numpy as np ##Chan et al. (2018)'s Example 1## ##We have changed x0 to demonstrate the rho_p_approx <= rho_p relationship A = np.array([[2,5],[2,-3],[2,1],[-2,-1]]) b = np.array([[10],[-6],[4],[-10]]) x0 = np.array([[4],[1]]) GIO_rho_test = GIO(A,b,x0) GIO_rho_test.calculate_rho_p(2) #notice that we did not #have to specify if_append='F' because #we set a default value in the code GIO_rho_test.calculate_rho_p_approx(2) print("This is rho_p exact:",GIO_rho_test.rho_p) print("This is rho_p - rho_p_approx:",(GIO_rho_test.rho_p[0] - GIO_rho_test.rho_p_approx[0])) GIO_rho_test.calculate_rho_a() print("This is rho_a:",GIO_rho_test.rho_a) GIO_rho_test.calculate_rho_r() print("This is rho_r:",GIO_rho_test.rho_r) ``` This is rho_p exact: [0.73886235873548278] This is rho_p - rho_p_approx: 0.0232038316283 This is rho_a: [0.7119341563786008] This is rho_r: [0.8851674641148326] ```python ###Testing some values for Validating rho_r##### from gio import GIO import numpy as np ##Chan et al. (2018)'s Example 1## A = np.array([[2,5],[2,-3],[2,1],[-2,-1]]) b = np.array([[10],[-6],[4],[-10]]) x0_1 = np.array([[3],[2]]) x0_2 = np.array([[4],[1]]) x0_3 = np.array([[2],[2]]) validate_rho_r = GIO(A,b,x0_1) validate_rho_r.calculate_rho_r() print("This is rho_r for x0_1:",validate_rho_r.rho_r) validate_rho_r = GIO(A,b,x0_2) validate_rho_r.calculate_rho_r() print("This is rho_r for x0_2:",validate_rho_r.rho_r) validate_rho_r = GIO(A,b,x0_3) validate_rho_r.calculate_rho_r() print("This is rho_r for x0_3:",validate_rho_r.rho_r) ``` This is rho_r for x0_1: [0.71428571428571441] This is rho_r for x0_2: [0.8851674641148326] Under the b dual norm, x^0 has been projected onto multiple hyperplanes. For now, we will choose the first i index and will put the rest of the indices in the istar_multi attribute. This is rho_r for x0_3: [0.18644067796610142] ```python ###Structural Considerations for GIO Models### from gio import GIO import numpy as np import pyomo.environ as pyo A = np.array([[2,5],[2,-3],[2,1],[-2,-1]]) b = np.array([[10],[-6],[4],[-10]]) x0 = np.array([[2.5],[3]]) structural_ep_gio_test = GIO(A,b,x0) #instigating the GIO object ###Step 1: Create the Base Model### #The attribute where the model is stored is called GIO_struc_ep, which is #the Pyomo model. structural_ep_gio_test.GIO_structural_epsilon_setup() ### Step 2: If desired, Add constraints on Epsilon ### ### to GIO_struc_ep ### ### The variable for epsilon is called ep ### ### The index set for variables is varindex ### def ep_constraint(model): #should provide the details of the index sets and the numvar parameters return model.ep[1] <= model.ep[2] #specifically did not ID the epsilon as nonnegative in gio.py structural_ep_gio_test.GIO_struc_ep.constraint_ep = pyo.Constraint(rule=ep_constraint) def neg_ep(model,i): return model.ep[i] <= 0 structural_ep_gio_test.GIO_struc_ep.neg_ep = pyo.Constraint(\ structural_ep_gio_test.GIO_struc_ep.varindex,rule=neg_ep) ### Step 3: Solve the Model ### #You can specify p as p=1,2,infty #The solver will generate some output letting you know about infeasibility #but we also produce output too, letting you know which constraint number #in terms of Python indexing that, when forced to be an equality, #results in infeasibility structural_ep_gio_test.GIO_structural_epsilon_solve(2) print("*************************************************") print("The c vector found by this workflow is:",structural_ep_gio_test.c_p[0]) ########################################################################################### #We can also generate the same results as the close form solution structural_ep_no_added_constraints_test = GIO(A,b,x0) structural_ep_no_added_constraints_test.GIO_structural_epsilon_setup() structural_ep_no_added_constraints_test.GIO_structural_epsilon_solve(2) print("The c vector found by this workflow (not adding epsilon constraints) is:",\ structural_ep_no_added_constraints_test.c_p[0]) ``` WARNING: Loading a SolverResults object with a warning status into model=unknown; message from solver=Ipopt 3.11.1\x3a Converged to a locally infeasible point. Problem may be infeasible. We have infeasibility for constraint= 0 . Putting FLAG in the container_for_obj_vals vector WARNING: Loading a SolverResults object with a warning status into model=unknown; message from solver=Ipopt 3.11.1\x3a Converged to a locally infeasible point. Problem may be infeasible. We have infeasibility for constraint= 1 . Putting FLAG in the container_for_obj_vals vector WARNING: Loading a SolverResults object with a warning status into model=unknown; message from solver=Ipopt 3.11.1\x3a Converged to a locally infeasible point. Problem may be infeasible. We have infeasibility for constraint= 2 . Putting FLAG in the container_for_obj_vals vector ************************************************* The c vector found by this workflow is: [[-0.66666667] [-0.33333333]] The c vector found by this workflow (not adding epsilon constraints) is: [[ 0.4] [-0.6]] ```python ```
module Inigo.Async.Fetch import Data.Buffer import Extra.Buffer import Inigo.Async.Base import Inigo.Async.Promise import Inigo.Async.Util %foreign (promisifyPrim "(url)=>new Promise((resolve,reject)=>(url.startsWith('https')?require('https'):require('http')).get(url,(r)=>{let d='';r.on('data',(c)=>{d+=c;});r.on('end',()=>{resolve(d)});}).on('error',(e)=>{reject(e);}))") fetch__prim : String -> promise String %foreign (promisifyPrim "(url)=>new Promise((resolve,reject)=>(url.startsWith('https')?require('https'):require('http')).get(url,(r)=>{let cs=[];r.on('data',(c)=>{cs.push(Buffer.from(c))});r.on('end',()=>{resolve(Buffer.concat(cs))});}).on('error',(e)=>{reject(e);}))") fetchBuf__prim : String -> promise Buffer %foreign (promisifyPrim ("(url,method,data,headers)=>new Promise((resolve,reject)=>{"++ toObject ++";let u=new URL(url);let port=u.port!==''?u.port:u.protocol==='https:'?443:80;let opts={hostname:u.hostname,port,path:u.pathname,method,headers:toObject(headers)};let req=(u.protocol==='https:'?require('https'):require('http')).request(opts,(r)=>{let cs=[];r.on('data',(c)=>{cs.push(Buffer.from(c))});r.on('end',()=>{resolve(__prim_js2idris_array([Buffer.from(r.statusCode.toString(), 'utf-8'), Buffer.concat(cs)]))});}).on('error',(e)=>reject(e));req.on('error',(e)=>reject(e));req.write(data);req.end();})")) request__prim : String -> String -> Buffer -> List (String, String) -> promise (List Buffer) export fetch : String -> Promise String fetch url = promisify (fetch__prim url) export fetchBuf : String -> Promise Buffer fetchBuf url = promisify (fetchBuf__prim url) convertStatusCode : List Buffer -> Promise (Int, Buffer) convertStatusCode lb = case lb of statusBuf :: buf :: [] => do status <- liftIO $ readAll statusBuf pure (cast status, buf) _ => reject "Invalid response" export requestBuf : String -> String -> Buffer -> List (String, String) -> Promise (Int, Buffer) requestBuf url method body headers = do res <- promisify (request__prim url method body headers) convertStatusCode res export request : String -> String -> String -> List (String, String) -> Promise (Int, Buffer) request url method body headers = do buf <- liftIO $ fromString body res <- promisify (request__prim url method buf headers) convertStatusCode res
[STATEMENT] lemma finite_field_factorization_int: assumes sq: "poly_mod.square_free_m p f" and result: "finite_field_factorization_int p f = (c,fs)" shows "poly_mod.unique_factorization_m p f (c, mset fs) \<and> c \<in> {0 ..< p} \<and> (\<forall> fi \<in> set fs. set (coeffs fi) \<subseteq> {0 ..< p})" [PROOF STATE] proof (prove) goal (1 subgoal): 1. unique_factorization_m f (c, mset fs) \<and> c \<in> {0..<p} \<and> (\<forall>fi\<in>set fs. set (coeffs fi) \<subseteq> {0..<p}) [PROOF STEP] using finite_field_factorization_main_integer[OF _ sq, of c fs] finite_field_factorization_main_uint32[OF _ _ sq, of c fs] finite_field_factorization_main_uint64[OF _ _ sq, of c fs] result[unfolded finite_field_factorization_int_def] [PROOF STATE] proof (prove) using this: finite_field_factorization_main p (finite_field_ops_integer (integer_of_int p)) f = (c, fs) \<Longrightarrow> unique_factorization_m f (c, mset fs) \<and> c \<in> {0..<p} \<and> (\<forall>fi\<in>set fs. set (coeffs fi) \<subseteq> {0..<p}) \<lbrakk>p \<le> 65535; finite_field_factorization_main p (finite_field_ops32 (uint32_of_int p)) f = (c, fs)\<rbrakk> \<Longrightarrow> unique_factorization_m f (c, mset fs) \<and> c \<in> {0..<p} \<and> (\<forall>fi\<in>set fs. set (coeffs fi) \<subseteq> {0..<p}) \<lbrakk>p \<le> 4294967295; finite_field_factorization_main p (finite_field_ops64 (uint64_of_int p)) f = (c, fs)\<rbrakk> \<Longrightarrow> unique_factorization_m f (c, mset fs) \<and> c \<in> {0..<p} \<and> (\<forall>fi\<in>set fs. set (coeffs fi) \<subseteq> {0..<p}) (if p \<le> 65535 then finite_field_factorization_main p (finite_field_ops32 (uint32_of_int p)) else if p \<le> 4294967295 then finite_field_factorization_main p (finite_field_ops64 (uint64_of_int p)) else finite_field_factorization_main p (finite_field_ops_integer (integer_of_int p))) f = (c, fs) goal (1 subgoal): 1. unique_factorization_m f (c, mset fs) \<and> c \<in> {0..<p} \<and> (\<forall>fi\<in>set fs. set (coeffs fi) \<subseteq> {0..<p}) [PROOF STEP] by (auto split: if_splits)
SUBROUTINE G0DIVS(IAXIS,DIVLEN) C C ------------------------------------------------ C ROUTINE NO. ( 231) VERSION (A8.8) 01:MAR:93 C ------------------------------------------------ C C THIS FINDS THE POSITIONS OF THE INTERVALS ON THE GIVEN AXIS C (FOR LIN. SCALING) WHICH LIE WITHIN THE CURRENT WINDOW AREA, C AND ALSO SETS THE MOST SUITABLE AXIS ANNOTATION FORMAT. C C C <IAXIS> GIVES THE REQUIRED AXIS BY ITS MODULUS: C = 1, THE X-AXIS IS TAKEN, OR C = 2, THE Y-AXIS IS TAKEN. C <DIVLEN> GIVES THE REQUIRED INTERVAL LENGTH. C C C THE FOLLOWING ARGUMENTS ARE SUPPLIED THROUGH COMMON: C C <X1WND0> THE COORDINATES C <X2WND0> OF C <Y1WND0> THE C <Y2WND0> WINDOW RECTANGLE. C C <AXPOSX> THE POSITION OF THE X-AXIS ALONG Y. C <AXPOSY> THE POSITION OF THE Y-AXIS ALONG X. C <NOTATA> IF ZERO, NO ANNOTATION IS REQUIRED, C IF NON-ZERO, ANNOT. FORMAT MUST BE CALCULATED. C C C THE FOLLOWING ARGUMENTS ARE RETURNED THROUGH COMMON: C (ONLY THE ARGS. RELEVANT TO THE GIVEN AXIS ARE CHANGED): C C <KTYPEX> IS THE X-AXIS TYPE (= 1 FOR LIN. AXIS). C <KTYPEY> IS THE Y-AXIS TYPE (= 1 FOR LIN. AXIS). C <DIVLX> IS THE X-AXIS SUB-INTERVAL LENGTH. C <DIVLY> IS THE Y-AXIS SUB-INTERVAL LENGTH. C <NSKIPX> IS THE NO. OF SUB-INTERVALS PER MAJOR INTERVAL IN X. C <NSKIPY> IS THE NO. OF SUB-INTERVALS PER MAJOR INTERVAL IN Y. C <NTIKLX> IS THE MARKING START-POINT FOR THE X-AXIS. C <NTIKLY> IS THE MARKING START-POINT FOR THE Y-AXIS. C <NTIKHX> IS THE MARKING END- POINT FOR THE X-AXIS. C <NTIKHY> IS THE MARKING END- POINT FOR THE Y-AXIS. C <NDECSX> IS THE X-AXIS ANNOTATION BASIS-EXPONENT. C <NDECSY> IS THE Y-AXIS ANNOTATION BASIS-EXPONENT. C <NCHRSX> IS THE NO. OF CHARS. IN X-AXIS ANNOTATION. C <NCHRSY> IS THE NO. OF CHARS. IN Y-AXIS ANNOTATION. C <NAFTPX> IS THE NO. OF CHARS. AFTER THE DEC. PT. IN X. C <NAFTPY> IS THE NO. OF CHARS. AFTER THE DEC. PT. IN Y. C <KANNX> GIVES THE X-AXIS ANNOTATION TYPE, AND C <KANNY> GIVES THE Y-AXIS ANNOTATION TYPE, AS FOLLOWS: C = 1, IT IS INTEGER C = 2, IT IS REAL, C = 3, IT IS INTEGER WITH MULT. FACTOR. C = 4, IT IS REAL WITH MULT. FACTOR. C <KAXIS> IS SET BY <IAXIS> FOR SUBSEQUENT USE. C C LOGICAL DONE C COMMON /T0AARG/ KAXIS COMMON /T0ADIX/ DIVLX,NTIKLX,NTIKHX COMMON /T0ADIY/ DIVLY,NTIKLY,NTIKHY COMMON /T0ANOX/ KANNX,NCHRSX,NAFTPX COMMON /T0ANOY/ KANNY,NCHRSY,NAFTPY COMMON /T0ASKX/ NSKIPX,NDECSX COMMON /T0ASKY/ NSKIPY,NDECSY COMMON /T0ATIC/ MTICKS COMMON /T0ATYP/ KTYPEX,KTYPEY COMMON /T0NOTA/ NOTATA COMMON /T0WNDO/ X1WND0,X2WND0,Y1WND0,Y2WND0 C DATA LIMSIG /5/ C C C THE AXIS TYPE IS SET AND THE END POINTS ARE FOUND. C KAXIS= IAXIS IF (IABS(KAXIS).EQ.1) THEN ENDMIN= AMIN1(X1WND0,X2WND0) ENDMAX= AMAX1(X1WND0,X2WND0) ELSE ENDMIN= AMIN1(Y1WND0,Y2WND0) ENDMAX= AMAX1(Y1WND0,Y2WND0) ENDIF C C THE NO. OF STEPS IN THE WINDOW AT THE GIVEN INTERVAL SIZE C IS FOUND, AND IF THIS IS > 1000, THE INTERVAL LENGTH IS C INCREASED BY A SUITABLE FACTOR OF 10 TO GIVE < 999 STEPS. C A LIMIT OF 100 SUB-INTERVALS IS THEN SET, AND THE ACTUAL C SUB-INTERVAL LENGTH TO BE USED IS HENCE CALCULATED. IF C THE GIVEN STEP SIZE IS ZERO, A START INTERVAL-LENGTH OF C A SUITABLE POWER OF 10 IS CHOSEN TO GIVE APPROX. 15 SUB- C DIVISIONS, AND THE SUB-INTERVAL LIMIT IS SET ALSO AT 15. C DIVSIZ= ABS(DIVLEN) IF (DIVSIZ.GT.0.0) THEN STEPS= (ENDMAX-ENDMIN)/DIVSIZ IF (STEPS.GE.1.0E3) THEN EXP= ALOG10(STEPS) IF (EXP.LT.0.0) EXP= EXP-1.0 C DIVSIZ= DIVSIZ*(10.0**(INT(EXP)-2)) ENDIF C LIMIT= 100 ELSE DIVSIZ= (ENDMAX-ENDMIN)/MTICKS EXP= ALOG10(DIVSIZ) IF (EXP.LT.0.0) EXP= EXP-1.0 C DIVSIZ= 10.0**INT(EXP) LIMIT= MTICKS ENDIF C C THIS SECTION CALCULATES THE INITIAL EDGE POINTS, C ROUNDING-OFF ALWAYS IN THE CORRECT DIRECTION. C ROUND= 0.999 IF (ENDMIN.LT.0.0) ROUND= -0.001 C NLO= (ENDMIN/DIVSIZ)+ROUND ROUND= -0.999 IF (ENDMAX.GT.0.0) ROUND= 0.001 C NHI= (ENDMAX/DIVSIZ)+ROUND IDIV= 1 IDEC= 1 DONE= .FALSE. C C THIS PART INCREASES THE INTERVAL SIZE BY FACTORS OF C 2, 5, 10, ETC. UNTIL THE GIVEN LIMIT IS SATISFIED. C 1 IFACT= IDIV*IDEC NLONOW= NLO IF (NLO.GT.0) NLONOW= NLONOW+IFACT-1 C NLONOW= NLONOW/IFACT NHINOW= NHI IF (NHI.LT.0) NHINOW= NHINOW-IFACT+1 C NHINOW= NHINOW/IFACT IF ((NHINOW-NLONOW).LE.LIMIT) THEN C C WHEN THE SUB-INTERVAL LIMIT HAS BEEN SATISFIED, THE C NEW VALUES ARE STORED, AND THE PROCESS IS REPEATED C WITH A LIMIT VALUE OF 15 TO FIND THE MAJOR INTERVALS. C IF (DONE) THEN GO TO 2 ELSE DONE= .TRUE. NLO= NLONOW NHI= NHINOW DIVSIZ= DIVSIZ*IFACT IDIV= 1 IDEC= 1 LIMIT= MTICKS ENDIF ELSE IF (IDIV.EQ.1) THEN IDIV=2 ELSE IF (IDIV.EQ.2) THEN IDIV=5 ELSE IDIV= 1 IDEC= IDEC*10 ENDIF C GO TO 1 C C ONCE THE VALUES HAVE BEEN FOUND, THEY ARE PLACED C INTO THE APPROPRIATE VARIABLES IN THE COMMON BLOCK. C 2 IF (IABS(KAXIS).EQ.1) THEN KTYPEX= 1 DIVLX= DIVSIZ NTIKLX= NLO NTIKHX= NHI NSKIPX= IFACT ELSE KTYPEY= 1 DIVLY= DIVSIZ NTIKLY= NLO NTIKHY= NHI NSKIPY= IFACT ENDIF C C IF <NOTATA> IS NON-ZERO AND THERE ARE TICK MARKS C TO ANNOTATE, THE NUMBER FORMAT IS CALCULATED BELOW: C IF (NOTATA.EQ.0) RETURN NCHARS= 1 KANNOT= 1 IF (NHI-NLO.GE.0) THEN C C FIRST THE MAJOR INTERVAL SIZE IS CALCULATED, THEN C THE MAXIMUM AND MINIMUM POSITION VALUES ARE FOUND. C STPSIZ= DIVSIZ*IFACT TIKMAX= ABS((NHI/IFACT)*STPSIZ) TIKMIN= ABS((NLO/IFACT)*STPSIZ) IF (TIKMAX.LT.TIKMIN) THEN TIKMAX= TIKMIN TIKMIN= ABS((NHI/IFACT)*STPSIZ) ENDIF IF (TIKMIN.LT.STPSIZ) TIKMIN= STPSIZ IF (NLO.GT.0.AND.NHI.LT.0) TIKMIN= STPSIZ IF (NLO.LT.0.AND.NHI.GT.0) TIKMIN= STPSIZ C C THE EXPONENT AND NO. OF SIG. DIGITS ARE FOUND FOR C BOTH THE LARGEST VALUE AND THE INTERVAL, AND C THESE ARE COMBINED TO GIVE THE NUMBER CONSTANTS. C IF NUMSIG > LIMSIG, THE NUMBER IS TRUNCATED; C IF NUMEXP >= LIMSIG, OVERFLOW HAS OCCURRED; C IF NAFTDP > LIMSIG, UNDERFLOW HAS OCCURRED; C IF NAFTDP <= 0, THE FORMAT IS INTEGER. C CALL G0SIZS(TIKMAX,LIMSIG,MAXEXP,MAXSIG) INTEXP= MAXEXP INTSIG= 0 IF (STPSIZ.LE.TIKMAX) CALL G0SIZS(STPSIZ,LIMSIG,INTEXP,INTSIG) C NAFTDP= INTSIG-INTEXP NUMEXP= MAXEXP NUMSIG= MAXSIG IF (NAFTDP.GT.MAXSIG-MAXEXP) NUMSIG= NUMEXP+NAFTDP IF (NUMSIG.GT.LIMSIG) NUMSIG= LIMSIG C NAFTDP= NUMSIG-NUMEXP-1 IF (NAFTDP.LT.0) NAFTDP= 0 C NCHARS= NUMSIG+2 IF ((NUMEXP.GE.LIMSIG).OR. & (NAFTDP.GT.LIMSIG)) THEN C C THE FOLLOWING SECTIONS SET ANNOTATION TYPES C INTEGER AND REAL RESP., WITH A SCALING FACTOR. C THIS FACTOR IS GIVEN BY THE EXPONENT OF THE C MINIMUM (NON-ZERO) ABSOLUTE POSITION VALUE. C CALL G0SIZS(TIKMIN,LIMSIG,MINEXP,MINSIG) NDECS= MINEXP NAFTDP= MINEXP-NUMEXP+NUMSIG-1 IF (NAFTDP.GT.0) THEN KANNOT= 4 ELSE NCHARS= MAXEXP-MINEXP+2 NAFTDP= 0 KANNOT= 3 ENDIF ELSE NDECS= 0 C C THE FOLLOWING SECTIONS SET ANNOTATION TYPES C INTEGER AND REAL RESP., WITHOUT SCALING FACTOR. C IF (NAFTDP.LE.0) THEN NCHARS= MAXEXP+2 NAFTDP= 0 KANNOT= 1 ELSE IF (NUMEXP.LT.0) NCHARS= NAFTDP+3 C KANNOT= 2 ENDIF ENDIF ENDIF C C THE APPROPRIATE VALUES IN THE COMMON BLOCK C ARE THEN UPDATED, AND THE SUBROUTINE ENDS. C IF (IABS(KAXIS).EQ.1) THEN NCHRSX= NCHARS NAFTPX= NAFTDP KANNX= KANNOT NDECSX= NDECS ELSE NCHRSY= NCHARS NAFTPY= NAFTDP KANNY= KANNOT NDECSY= NDECS ENDIF C RETURN END
function [ X ] = X_Solver_first(D,rho) [U,S,V] = svd(D); S0 = diag(S); r = length(S0); P = [ones(r,1), 1-S0, 1/2/rho-S0]; rt = zeros(r,1); for t = 1:r p = P(t,:); Delta = p(2)^2-4*p(1)*p(3); if Delta <= 0 rt(t) = 0; else rts = roots(p); rts = sort(rts); if rts(1)*rts(2)<=0 rt(t) = rts(2); elseif rts(2)<0 rt(t) = 0; else funval = log(1+rts(2))+rho*(rts(2)-S0(t)).^2; if funval>log(1+0)+rho*(0-S0(t)).^2; rt(t) = 0; end end end end SSS = diag(rt); [m,n] = size(D); sig = zeros(m,n); sig(1:min(m,n),1:min(m,n)) = SSS; X = U*sig*V'; end
A complex-valued function is continuous if and only if its real and imaginary parts are continuous.
/* stable/stable_fit.c * * Functions employed by different methods of estimation implemented * in Libstable. * * Copyright (C) 2013. Javier Royuela del Val * Federico Simmross Wattenberg * * 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; version 3 of the License. * * 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 should have received a copy of the GNU General Public License * along with this program; If not, see <http://www.gnu.org/licenses/>. * * * Javier Royuela del Val. * E.T.S.I. Telecomunicación * Universidad de Valladolid * Paseo de Belén 15, 47002 Valladolid, Spain. * [email protected] */ #include "stable.h" #include "mcculloch.h" #include <gsl/gsl_complex.h> #include <gsl/gsl_vector.h> #include <gsl/gsl_errno.h> #include <gsl/gsl_sf_erf.h> #include <gsl/gsl_randist.h> #include <gsl/gsl_multimin.h> #include <gsl/gsl_fft_real.h> void stable_fft(double *data, const unsigned int length, double * y) { //int i; memcpy ( (void *)y, (const void *) data, length*sizeof(double)); gsl_fft_real_radix2_transform (y, 1, length); return; } double stable_loglikelihood(StableDist *dist, double *data, const unsigned int length) { double *pdf=NULL; double l=0.0; int i; pdf=(double*)malloc(sizeof(double)*length); stable_pdf(dist,data,length,pdf,NULL); for(i=0;i<length;i++) { if (pdf[i]>0.0) l+=log(pdf[i]); } free(pdf); return l; } double stable_loglike_p(stable_like_params *params) { double *pdf; double l=0.0; int i; pdf=(double*)malloc(sizeof(double)*(params->length)); stable_pdf(params->dist,params->data,params->length,pdf,NULL); for(i=0;i<params->length;i++) { if (pdf[i]>0.0) {l+=log(pdf[i]);} } free(pdf); return l; } double stable_minusloglikelihood(const gsl_vector * theta, void * p) { /* Cost function to minimize, with the estimation of sigma and mu given by McCulloch at each iteration*/ double alpha=1, beta=0, sigma=1.0, mu=0.0; double minusloglike=0; stable_like_params * params = (stable_like_params *) p; alpha = gsl_vector_get(theta,0); beta = gsl_vector_get(theta,1); /* Update sigma and mu with McCulloch. It needs nu_c nu_z*/ czab(alpha, beta, params->nu_c, params->nu_z, &sigma, &mu); /* Check that the parameters are valid */ if(stable_setparams(params->dist, alpha, beta, sigma, mu, 0) < 0) { return GSL_NAN; } else minusloglike = -stable_loglike_p(params); if (isinf(minusloglike) || isnan(minusloglike)) minusloglike=GSL_NAN; return minusloglike; } int compare (const void * a, const void * b) { /* qsort compare function */ return ((*(double *)b < *(double *)a) - (*(double *)a < *(double *)b)); } inline void get_original(const gsl_vector *s,double *a,double *b,double *c,double *m) { *a = M_2_PI*atan(gsl_vector_get(s,0))+1.0; *b = M_2_PI*atan(gsl_vector_get(s,1)); *c = exp(gsl_vector_get(s,2)); *m = gsl_vector_get(s,3); } inline void set_expanded(gsl_vector *s,const double a,const double b,const double c,const double m) { gsl_vector_set(s,0,tan(M_PI_2*(a-1.0))); gsl_vector_set(s,1,tan(M_PI_2*b)); gsl_vector_set(s,2,log(c)); gsl_vector_set(s,3,m); } double stable_minusloglikelihood_whole(const gsl_vector * theta, void * p) { /* Whole cost function to minimize in a 4D parameter space */ double alpha=1, beta=0, sigma=1.0, mu=0.0; double minusloglike=0; stable_like_params * params = (stable_like_params *) p; get_original(theta,&alpha,&beta,&sigma,&mu); /* Check that the parameters are valid */ if(stable_setparams(params->dist, alpha, beta, sigma, mu, 0) < 0) { perror("setparams error"); return GSL_NAN; } else minusloglike = -stable_loglike_p(params); if (isinf(minusloglike) || isnan(minusloglike)) minusloglike=GSL_NAN; return minusloglike; } void stable_fit_init(StableDist *dist, const double * data, const unsigned int length, double *pnu_c,double *pnu_z) { /* McCulloch estimation */ double *sorted=NULL; double alpha0, beta0, sigma0, mu0; /* We need to sort the data to get percentiles */ sorted = (double*)malloc(length*sizeof(double)); memcpy ( (void *)sorted, (const void *) data, length*sizeof(double)); qsort ( sorted, length, sizeof(double), compare); /* Estimate the parameters. */ stab((const double *) sorted,length,0,&alpha0,&beta0,&sigma0,&mu0); /* Set parameters in the distribution */ if(stable_setparams(dist,alpha0,beta0,sigma0,mu0, 0)<0) { perror("INITIAL ESTIMATED PARAMETER ARE NOT VALID"); return; } /* Get pnu_c and pnu_z needed for mle2d estimation */ cztab(sorted, length, pnu_c, pnu_z); free(sorted); return; } int stable_fit_iter(StableDist *dist, const double * data, const unsigned int length,const double nu_c,const double nu_z) { const gsl_multimin_fminimizer_type *T; gsl_multimin_fminimizer *s; gsl_multimin_function likelihood_func; gsl_vector *theta, *ss; unsigned int iter = 0; int status=0; double size=0; double a=1,b=0.0,c=1,m=0.0; stable_like_params par; par.dist=dist; par.data=(double *)data; par.length=length; par.nu_c=nu_c; par.nu_z=nu_z; /* Inicio: Debe haberse inicializado dist con alpha y beta de McCulloch */ theta=gsl_vector_alloc(2); gsl_vector_set (theta, 0, dist->alpha); gsl_vector_set (theta, 1, dist->beta); #ifdef DEBUG printf("%lf, %lf\n",gsl_vector_get (theta, 0),gsl_vector_get (theta, 1)); #endif /* Saltos iniciales */ ss = gsl_vector_alloc (2); gsl_vector_set_all (ss, 0.01); /* Funcion a minimizar */ likelihood_func.n = 2; // Dimension 2 (alpha y beta) likelihood_func.f = &stable_minusloglikelihood; likelihood_func.params = (void *) (&par); // Parametros de la funcion /* Creacion del minimizer */ T = gsl_multimin_fminimizer_nmsimplex2rand; s = gsl_multimin_fminimizer_alloc (T, 2); /* Dimension 2*/ /* Poner funcion, estimacion inicial, saltos iniciales */ gsl_multimin_fminimizer_set (s, &likelihood_func, theta, ss); #ifdef DEBUG printf("5\n"); #endif /* Iterar */ do { iter++; status = gsl_multimin_fminimizer_iterate(s); // if (status!=GSL_SUCCESS) { // printf("Minimizer warning: %s\n",gsl_strerror(status)); // fflush(stdout); // } size = gsl_multimin_fminimizer_size (s); status = gsl_multimin_test_size (size, 0.02); /* if (status == GSL_SUCCESS) { printf (" converged to minimum at\n"); } printf ("%5d %1.5f %1.5f %1.5f %1.5f f() = %1.8e size = %.5f\n", (int)iter, gsl_vector_get (s->x, 0), gsl_vector_get (s->x, 1), p->dist->sigma, p->dist->mu_1, s->fval, size); //} */ } while (status == GSL_CONTINUE && iter < 200); // if (status!=GSL_SUCCESS) // { // printf("Minimizer warning: %s\n",gsl_strerror(status)); // fflush(stdout); // } /* Se recupera la estimacion alpha y beta */ gsl_vector_free(theta); /* theta = gsl_multimin_fminimizer_x (s); a = gsl_vector_get (theta, 0); b = gsl_vector_get (theta, 1); */ a = gsl_vector_get (s->x, 0); b = gsl_vector_get (s->x, 1); /* Y se estima sigma y mu para esos alpha y beta */ czab(a, b, nu_c, nu_z, &c, &m); //printf("%5d %10.3e %10.3e %10.3e %10.3e\n",(int)iter,a,b,c,m); // Se almacena el punto estimado en la distribucion, comprobando que es valido if (stable_setparams(dist,a,b,c,m,0)<0) { perror("FINAL ESTIMATED PARAMETER ARE NOT VALID\n"); } gsl_vector_free(ss); gsl_multimin_fminimizer_free (s); return status; } int stable_fit(StableDist *dist, const double *data, const unsigned int length) { double nu_c=0.0,nu_z=0.0; int status = 0; stable_fit_init(dist,data,length,&nu_c,&nu_z); status=stable_fit_iter(dist,data,length,nu_c,nu_z); return status; } int stable_fit_iter_whole(StableDist *dist, const double * data, const unsigned int length) { const gsl_multimin_fminimizer_type *T; gsl_multimin_fminimizer *s; gsl_multimin_function likelihood_func; gsl_vector *theta, *ss; unsigned int iter = 0; int status=0; double size=0; double a=1,b=0.0,c=1,m=0.0; stable_like_params par; par.dist=dist; par.data=(double *)data; par.length=length; par.nu_c=0; par.nu_z=0; /* Inital params (with McCulloch) */ theta=gsl_vector_alloc(4); set_expanded(theta,dist->alpha,dist->beta,dist->sigma,dist->mu_1); #ifdef DEBUG printf("%lf, %lf, %lf, %lf\n",gsl_vector_get (theta, 0),gsl_vector_get (theta, 1),gsl_vector_get (theta, 2),gsl_vector_get (theta, 3)); #endif /* Initial steps */ ss = gsl_vector_alloc (4); gsl_vector_set_all (ss, 0.01); /* Cost function to minimize */ likelihood_func.n = 4; // 4 Dimensions (alpha, beta, sigma, mu_0) likelihood_func.f = &stable_minusloglikelihood_whole; likelihood_func.params = (void *) (&par); // Cost function arguments /* Minimizer creation */ T = gsl_multimin_fminimizer_nmsimplex2rand; s = gsl_multimin_fminimizer_alloc (T, 4); /* 4 dimensions */ /* Set cost function, initial guess and initial steps */ gsl_multimin_fminimizer_set (s, &likelihood_func, theta, ss); #ifdef DEBUG printf("5\n"); #endif /* Start iterations */ do { iter++; status = gsl_multimin_fminimizer_iterate(s); if (status!=GSL_SUCCESS) { perror("Minimizer warning:\n"); } size = gsl_multimin_fminimizer_size (s); status = gsl_multimin_test_size (size, 0.002); /* printf(" %03d\t size = %f a_ = %f b_ = %f c_ = %f m_ = %f f_ = %f \n",iter,size,gsl_vector_get (s->x, 0),gsl_vector_get (s->x, 1), gsl_vector_get (s->x, 2),gsl_vector_get (s->x, 3), gsl_multimin_fminimizer_minimum(s)); */ } while (status == GSL_CONTINUE && iter < 200); if (status!=GSL_SUCCESS) { perror("Minimizer warning"); } /* Get last estimation */ gsl_vector_free(theta); theta = gsl_multimin_fminimizer_x (s); get_original(theta,&a,&b,&c,&m); /* Set estimated parameters to the distribution and check if their have valid values*/ if (stable_setparams(dist,a,b,c,m,0)<0) { perror("FINAL ESTIMATED PARAMETER ARE NOT VALID\n"); } gsl_vector_free(ss); gsl_multimin_fminimizer_free (s); return status; } int stable_fit_whole(StableDist *dist, const double *data, const unsigned int length) { // double nu_c=0.0,nu_z=0.0; int status=0; // stable_fit_init(dist,data,length,&nu_c,&nu_z); // printf("McCulloch %d sampless: %f %f %f %f\n",length,dist->alpha,dist->beta,dist->sigma,dist->mu_1); status = stable_fit_iter_whole(dist,data,length); return status; } double * load_rand_data(char * filename, int N) { FILE * f_data; double * data; int i; if ((f_data = fopen(filename,"rt")) == NULL) { perror("Error when opening file with random data"); } data=(double*)malloc(N*sizeof(double)); for(i=0;i<N;i++) { if (EOF==fscanf(f_data,"%le\n",data+i)) { perror("Error when reading data"); } } return data; } int stable_fit_mle(StableDist *dist, const double *data, const unsigned int length) { return stable_fit_whole(dist,data,length); } int stable_fit_mle2d(StableDist *dist, const double *data, const unsigned int length) { return stable_fit(dist,data,length); }
module model_mnph_artificial_viscosity #include <messenger.h> use mod_kinds, only: rk use mod_constants, only: HALF, THREE, TWO, ONE, ZERO use mod_io, only: h_field_dimension use mod_fluid use type_model, only: model_t use type_chidg_worker, only: chidg_worker_t use DNAD_D use mod_interpolate, only: interpolate_from_vertices use ieee_arithmetic implicit none !> Int. J. Numer. Meth. Fluids 2016; 82:398–416 !! Dilation-based shock capturing for high-order methods !! Presmoothed h !! Model Fields: !! - Smoothed Artifical Viscosity !! !! @author Eric M. Wolf !! @date 07/11/2018 !! !--------------------------------------------------------------------------------------- type, extends(model_t) :: mnph_artificial_viscosity_t real(rk) :: av_constant = 1.5_rk logical :: elem_avg = .false. contains procedure :: init procedure :: compute end type mnph_artificial_viscosity_t !*************************************************************************************** contains !> !! !! !! @author Eric M. Wolf !! @date 07/11/2018 !! !-------------------------------------------------------------------------------- subroutine init(self) class(mnph_artificial_viscosity_t), intent(inout) :: self integer :: unit, msg logical :: file_exists, use_lift, elem_avg namelist /av_options/ elem_avg call self%set_name('MNPH Artificial Viscosity') call self%set_dependency('f(Grad(Q))') call self%add_model_field('Artificial Viscosity') call self%add_model_field('Artificial Viscosity - 1') call self%add_model_field('Artificial Viscosity - 2') call self%add_model_field('Artificial Viscosity - 3') !! !! Check if input from 'models.nml' is available. !! 1: if available, read and set self%mu !! 2: if not available, do nothing and mu retains default value !! !inquire(file='models.nml', exist=file_exists) !if (file_exists) then ! open(newunit=unit,form='formatted',file='models.nml') ! read(unit,nml=mnph_artificial_viscosity_unsmoothed_ani,iostat=msg) ! if (msg == 0) self%av_constant = av_constant ! close(unit) !end if inquire(file='artificial_viscosity.nml', exist=file_exists) if (file_exists) then open(newunit=unit,form='formatted',file='artificial_viscosity.nml') read(unit,nml=av_options,iostat=msg) if (msg == 0) self%elem_avg = elem_avg close(unit) end if end subroutine init !*************************************************************************************** !> !! !! !! @author Eric M. Wolf !! @date 07/11/2018 !! !-------------------------------------------------------------------------------- subroutine compute(self,worker) class(mnph_artificial_viscosity_t), intent(in) :: self type(chidg_worker_t), intent(inout) :: worker type(AD_D), dimension(:), allocatable :: & density, vel1, vel2, vel3, T, c, wave_speed, sensor, av, av1, av2, av3, avtemp, temp_av real(rk), dimension(:) :: h(3) real(rk) :: hmin real(rk) :: Pr_star = 0.9_rk integer(ik) :: p, ii, nvertex, inode, ivertex, idom, ielem, idom_g, inode_g real(rk), allocatable :: eval_node1(:), eval_node2(:), eval_node3(:), nodes(:,:), h_field(:,:), h_scalar(:) real(rk) :: eval_node(3), center(3), radius(3), vert_vals_hmin(8) real(rk), allocatable, dimension(:) :: weights, jinv idom = worker%element_info%idomain_l ielem = worker%element_info%ielement_l idom_g = worker%element_info%idomain_g h_field = worker%h_smooth() select case (trim(h_field_dimension)) case('2D','2d') h_scalar = (h_field(:,1) + h_field(:,2))/TWO case('3D','3d') h_scalar = (h_field(:,1) + h_field(:,2) + h_field(:,3))/THREE case default call chidg_signal(FATAL,'mnph_artificial_viscosity: invalid input for h_field_dimension (2D,3D).') end select !h_scalar = (h_field(:,1)*h_field(:,2)*h_field(:,3))**(ONE/THREE) !h_scalar = ONE p = worker%solution_order('interior') if (p == 0) p = 1 h_scalar = h_scalar/real(p, rk) h_field = h_field/real(p,rk) sensor = worker%get_field('MNPH Shock Sensor', 'value') density = worker%get_field('Density','value') vel1 = worker%get_field('Momentum-1','value') vel2 = worker%get_field('Momentum-2','value') vel3 = worker%get_field('Momentum-3','value') vel1 = vel1/(density) vel2 = vel2/(density) vel3 = vel3/(density) c = worker%get_field('Pressure', 'value') wave_speed = c c = (gam*wave_speed/(density)) c = c*sin_ramp(c, ZERO, ONE) wave_speed = sqrt(vel1**TWO+vel2**TWO+vel3**TWO+c) av = 1.0_rk*(1.5_rk*h_scalar)*wave_speed*sensor !avtemp = av !av = sin_ramp2(avtemp,0.01_rk*1.5_rk*h_scalar*wave_speed, 1.5_rk*h_scalar*wave_speed) !if (self%elem_avg) then ! if (worker%interpolation_source == 'element') then ! weights = worker%quadrature_weights('element') ! jinv = worker%inverse_jacobian('element') ! temp_av = av ! temp_av = sum(weights*jinv*av)/sum(weights*jinv) ! av = temp_av ! else ! weights = worker%quadrature_weights('face') ! jinv = worker%inverse_jacobian('face') ! temp_av = av ! temp_av = sum(weights*jinv*av)/sum(weights*jinv) ! av = temp_av ! end if !end if if (any(ieee_is_nan(av(:)%x_ad_))) print *, 'unsmoothed av is nan' if (any(ieee_is_nan(av(:)%x_ad_))) print *, worker%interpolation_source av1 = 1.5_rk*(h_field(:,1))*wave_speed*sensor av2 = 1.5_rk*(h_field(:,2))*wave_speed*sensor av3 = 1.5_rk*(h_field(:,3))*wave_speed*sensor !av1 = 1.0_rk*(1.5_rk*h_field(:,1))*wave_speed*sensor !av2 = 1.0_rk*(1.5_rk*h_field(:,2))*wave_speed*sensor !av3 = 1.0_rk*(1.5_rk*h_field(:,3))*wave_speed*sensor !print *, 'unsmoothed av: ', av(1)%x_ad_ !! Average to improve robustness !if (worker%interpolation_source == 'element') then ! weights = worker%quadrature_weights('element') ! jinv = worker%inverse_jacobian('element') ! av2 = av ! av = sum(weights*jinv*av2)/sum(weights*jinv) !else ! weights = worker%quadrature_weights('face') ! jinv = worker%inverse_jacobian('face') ! av2 = av ! av = sum(weights*jinv*av2)/sum(weights*jinv) !end if ! ! Contribute laminar viscosity ! call worker%store_model_field('Artificial Viscosity', 'value', av) call worker%store_model_field('Artificial Viscosity - 1', 'value', av1) call worker%store_model_field('Artificial Viscosity - 2', 'value', av2) call worker%store_model_field('Artificial Viscosity - 3', 'value', av3) end subroutine compute !*************************************************************************************** end module model_mnph_artificial_viscosity
lemma square_norm_one: fixes x :: "'a::real_normed_div_algebra" assumes "x\<^sup>2 = 1" shows "norm x = 1"
module Vehicle.Data.Tensor where open import Level using (Level) open import Data.Empty.Polymorphic using (⊥) open import Data.Nat.Base using (ℕ; zero; suc) open import Data.List.Base using (List; []; _∷_) open import Data.Vec.Functional using (Vector) private variable a : Level A : Set a n : ℕ Tensor : Set a → List ℕ → Set a Tensor A [] = ⊥ Tensor A (n ∷ []) = Vector A n Tensor A (m ∷ n ∷ ns) = Vector (Tensor A (n ∷ ns)) m
[STATEMENT] lemma project_preserves_I: "G \<in> preserves (v o f) ==> project h C G \<in> preserves v" [PROOF STATE] proof (prove) goal (1 subgoal): 1. G \<in> preserves (v \<circ> f) \<Longrightarrow> project h C G \<in> preserves v [PROOF STEP] by (auto simp add: preserves_def project_stable_I extend_set_eq_Collect)
[STATEMENT] lemma absolutely_integrable_spike_set: fixes f :: "'a::euclidean_space \<Rightarrow> 'b::euclidean_space" assumes f: "f absolutely_integrable_on S" and neg: "negligible {x \<in> S - T. f x \<noteq> 0}" "negligible {x \<in> T - S. f x \<noteq> 0}" shows "f absolutely_integrable_on T" [PROOF STATE] proof (prove) goal (1 subgoal): 1. f absolutely_integrable_on T [PROOF STEP] using absolutely_integrable_spike_set_eq f neg [PROOF STATE] proof (prove) using this: \<lbrakk>negligible {x \<in> ?S - ?T. ?f x \<noteq> (0::?'b)}; negligible {x \<in> ?T - ?S. ?f x \<noteq> (0::?'b)}\<rbrakk> \<Longrightarrow> (?f absolutely_integrable_on ?S) = (?f absolutely_integrable_on ?T) f absolutely_integrable_on S negligible {x \<in> S - T. f x \<noteq> (0::'b)} negligible {x \<in> T - S. f x \<noteq> (0::'b)} goal (1 subgoal): 1. f absolutely_integrable_on T [PROOF STEP] by blast
using Random; export contour_block_SS """ contour_block_SS([eltype,] nep [,mintegrator];[tol,][logger,][σ,][radius,][linsolvercreator,][N,][neigs,][k,][L]) This is an implementation of the block_SS contour integral method which is based on the computation of higher order moments. The contour is an ellipse centered at `σ` with radii given in `radius`, or if only one `radius` is given, the contour is a circle. The numerical quadrature method is specified in `mintegrator`, which is a type inheriting from `MatrixIntegrator`, by default `MatrixTrapezoidal`. For a parallell implementation of the integrator use `MatrixTrapezoidalParallel`. The integer `k` specifies size of the probe subspace. `N` corresponds to the number of quadrature points. The integer L specifies the number of moments. Ellipses are the only supported contours. The `linsolvercreator` must create a linsolver that can handle (rectangular) matrices as right-hand sides, not only vectors. We integrate in complex arithmetic so `eltype` must be complex type. # Example ```julia-repl julia> nep=SPMF_NEP([[0 1 ; 1 1.0], [1 0 ; 0 0]], [s->one(s),s->exp(1im*s^2)]); julia> λ,V=contour_assu(nep,radius=3,neigs=6) julia> @show λ 6-element Array{Complex{Float64},1}: 4.496403249731884e-15 + 2.506628274630998im -2.506628274631 - 2.8727020762175925e-15im 3.219972424519104e-16 - 2.5066282746310034im 2.5066282746310096 - 1.1438072192922029e-15im -2.3814273710772784e-7 - 7.748469160458366e-8im 2.381427350935646e-7 + 7.748467479992284e-8im ``` # References * Asakura, Sakurai, Tadano, Ikegami, Kimura, A numerical method for nonlinear eigenvalue problems using contour integrals, JSIAM Letters, 2009 Volume 1 Pages 52-55 * Van Beeumen, Meerbergen, Michiels. Connections between contour integration and rational Krylov methods for eigenvalue problems, 2016, TW673, https://lirias.kuleuven.be/retrieve/415487/ """ contour_block_SS(nep::NEP;params...)=contour_block_SS(ComplexF64,nep;params...); contour_block_SS(nep::NEP,MIntegrator;params...)=contour_block_SS(ComplexF64,nep,MIntegrator;params...); function contour_block_SS( ::Type{T}, nep::NEP, ::Type{MIntegrator}=MatrixTrapezoidal; tol::Real=sqrt(eps(real(T))), # Note tol is quite high for this method σ::Number=zero(complex(T)), logger=0, linsolvercreator=BackslashLinSolverCreator(), neigs=Inf, # Number of wanted eigvals (currently unused) k::Integer=3, # Columns in matrix to integrate radius::Union{Real,Tuple,Array}=1, # integration radius N::Integer=1000, # Nof quadrature nodes K::Integer=3, # Nof moments errmeasure::ErrmeasureType = DefaultErrmeasure(nep), sanity_check=true, Shat_mode=:native, # native or JSIAM-mode rank_drop_tol=tol # Used in sanity checking )where{T<:Number, MIntegrator<:MatrixIntegrator} @parse_logger_param!(logger) n = size(nep,1); # Notation: L in JSIAM-paper corresponds to k in Beyn's paper. # Input params the same as contourbeyn, but # the code is like JSIAM-paper L=k Random.seed!(10); # Reproducability (not really) U = rand(T,n,L); V = rand(T,n,L); function local_linsolve(λ::TT,V::Matrix{TT}) where {TT<:Number} local M0inv::LinSolver = create_linsolver(linsolvercreator, nep, λ+σ); # This requires that lin_solve can handle rectangular # matrices as the RHS return lin_solve(M0inv,V); end # The step-references refer to the JSIAM-paper push_info!(logger,"Computing integrals") local Shat push_info!(logger,"Forming Mhat and Shat") Shat = zeros(T,n,L,2*K) Mhat = zeros(T,L,L,2*K) length(radius)==1 ? radius1=(radius,radius) : radius1=radius if (Shat_mode==:JSIAM) # This is the way the JSIAM-paper proposes to compute Shat if (length(radius)>1) error("JSIAM Shat_mode does not support ellipses"); end # Quadrature points: Only circle supported w = exp.(2im*pi*(0.5 .+ (0:(N-1)))/N); omega = radius*w; push_info!(logger,"Forming all linear systems F(s)^{-1}V:", continues=true) # Step 2: Precompute all the linear systems FinvV =zeros(T,n,L,N); for k = 1:N FinvV[:,:,k]=local_linsolve(omega[k],V); end push_info!(logger,""); # Step 3-4: Compute all the integrals and store in Shat ( for k=0:(2*K-1) for j=0:N-1 d=((omega[j+1])/radius)^(k+1) Shat[:,:,k+1] += d*FinvV[:,:,j+1]/N; end end elseif (Shat_mode==:native) # This deviates from the JSIAM-paper description, since # we do not precompute linear systems, but instead # compute linear system in combination with the quadrature. # It handles the scaling differently. # This version is also more extendable. g(t) = complex(radius1[1]*cos(t),radius1[2]*sin(t)) # ellipse gp(t) = complex(-radius1[1]*sin(t),radius1[2]*cos(t)) # derivative Tv(λ) = local_linsolve(T(λ),V) f(t) = Tv(g(t))*gp(t)/(2im*pi) gv=Vector{Function}(undef,2*K) for k=0:(2*K-1) gv[k+1]= s -> g(s)^k; end # Call the integrator Shat=integrate_interval(MIntegrator, ComplexF64, f,gv,0,2*pi,N,logger ) else error("Unknown Shat_mode: $Shat_mode") end for k=0:(2*K-1) Mhat[:,:,k+1]=U'*Shat[:,:,k+1] # Step 4: Mhat=U'*Shat end # Construct H-matrices: push_info!(logger,"Computing Hhat and Hhat^{<}") m=K*L; Hhat=zeros(T,m,m) # Hhat Hhat2=zeros(T,m,m) # Hhat^{<} for i=1:K for j=1:K Hhat[(i-1)*L .+ (1:L), (j-1)*L .+ (1:L)] = Mhat[:,:,i+j-2+1]; Hhat2[(i-1)*L .+ (1:L), (j-1)*L .+ (1:L)] = Mhat[:,:,i+j-1+1]; end end # Extraction more similar to Algorithm 1 # in https://arxiv.org/pdf/1510.02572.pdf push_info!(logger,"Computing SVD prepare for eigenvalue extraction ",continues=true) F=svd(Hhat) UU=F.U; SS=F.S; VV=F.V # rank_drop_tol = δ in reference pp = count( SS/SS[1] .> rank_drop_tol); mprime=pp; # To make closer to notation in paper push_info!(logger," mprime=$mprime"); # Pick relevant eigvecs UU_H1 = UU[:,1:mprime] VV_H1 = VV[:,1:mprime] # Step 7: Project the moment matrices: Hhat_mprime = UU_H1'*Hhat*VV_H1; Hhat2_mprime = UU_H1'*Hhat2*VV_H1; # Step 8: (xi,X)=eigen(Hhat2_mprime,Hhat_mprime) # Step 10: Extract eigpair # Compute S-matrix (by reshaping parts of Shat-tensor) S=zeros(T,n,L*K) for j=0:(K-1) S[:,j*L .+ (1:L)]=Shat[:,:,j+1] end V=S*VV_H1*X; # Reverse the shift Shat_mode == :JSIAM ? factor=radius : factor=1 λ=σ .+ factor*xi return λ,V end
! test_balanced_tree.f90 -- ! Test program for balanced trees, as well as a demonstration of how ! the include file can be used ! ! TODO: ! - delete_key ! module my_data type, public :: point2d real :: x, y end type point2d type, public :: point3d real :: x, y, z end type point3d end module my_data ! ! Define a module for trees that hold 2D points ! module balanced_trees_2d_points use my_data, tree_data => point2d implicit none public :: print_tree include "balanced_tree.f90" ! Extra: ! Debug routine to test the implementation ! recursive subroutine print_tree( tree, indent ) class(balanced_tree), intent(inout) :: tree character(len=*), intent(in) :: indent write(*,'(2a,i0,'' - '',2f10.2)') indent, 'Tree: ', tree%key, tree%data write(*,'(2a,l)') indent, ' Left: ', associated(tree%left) write(*,'(2a,l)') indent, ' Right: ', associated(tree%right) if ( associated(tree%left) ) then call print_tree(tree%left, indent // ' ') endif if ( associated(tree%right) ) then call print_tree(tree%right, indent // ' ') endif end subroutine print_tree end module balanced_trees_2d_points ! ! Define a module for trees that hold 3D points ! No need for a print routine ! module balanced_trees_3d_points use my_data, tree_data => point3d implicit none include "balanced_tree.f90" end module balanced_trees_3d_points ! ! Define an overall module so that we have convenient ! names ! module balanced_trees use balanced_trees_2d_points, btree_2d => balanced_tree, point2d => tree_data use balanced_trees_3d_points, btree_3d => balanced_tree, point3d => tree_data end module balanced_trees ! Test program ! program test_balanced_trees use balanced_trees implicit none integer :: key type(point2d) :: p2d type(point3d) :: p3d ! Not actually used, just an illustration type(btree_2d) :: tree type(btree_3d) :: tree3d ! Ditto logical :: success key = 30 p2d%x = 1 p2d%y = 30 call tree%add_data(key, p2d) key = 10 p2d%y = 10 call tree%add_data(key, p2d) key = 20 p2d%y = 20 call tree%add_data(key, p2d) key = 40 p2d%y = 40 call tree%add_data(key, p2d) key = 35 p2d%y = 35 call tree%add_data(key, p2d) key = 20 p2d%y = 40 call tree%add_data(key, p2d) call print_tree(tree, '' ) write(*,*) 'Key 30? ', tree%has_key(30) write(*,*) 'Key 31? ', tree%has_key(31) key = 35 p2d%y = 40 ! Should be changed call tree%get_data( key, p2d, success ) write(*,*) 'Key 35: ', success, ' - ', p2d%y key = 31 p2d%y = 33 ! Should be NOT changed call tree%get_data( key, p2d, success ) write(*,*) 'Key 31: ', success, ' - ', p2d%y ! ! Now print the contents ! call tree%traverse( print_p2d ) call tree%destroy contains subroutine print_p2d( key, p2d ) integer, intent(in) :: key type(point2d), intent(in) :: p2d write(*,*) 'Key: ', key write(*,*) ' Data X: ', p2d%x write(*,*) ' Data Y: ', p2d%y end subroutine print_p2d end program test_balanced_trees
= Voyage : Inspired by Jules Verne =
import numpy as np from videoreader import VideoReader from napari_plugin_engine import napari_hook_implementation from dask import delayed import cv2 class VideoReaderNP(VideoReader): """VideoReader posing as numpy array.""" def __init__(self, filename: str, remove_leading_singleton: bool = True): """ Args: filename (str): filename of the video remove_leading_singleton (bool, optional): Remove leading singleton dimension when returning single frames. Defaults to True. """ super().__init__(filename) self.remove_leading_singleton = remove_leading_singleton def __getitem__(self, index): # numpy-like slice imaging into arbitrary dims of the video # ugly.hacky but works frames = None if isinstance(index, int): # single frame ret, frames = self.read(index) if frames.shape[2]==3: frames = cv2.cvtColor(frames, cv2.COLOR_BGR2RGB) elif isinstance(index, slice): # slice of frames frames = np.stack([self[ii] for ii in range(*index.indices(len(self)))]) elif isinstance(index, range): # range of frames frames = np.stack([self[ii] for ii in index]) elif isinstance(index, tuple): # unpack tuple of indices if isinstance(index[0], slice): indices = range(*index[0].indices(len(self))) elif isinstance(index[0], (np.integer, int)): indices = int(index[0]) else: indices = None if indices is not None: frames = self[indices] # index into pixels and channels for cnt, idx in enumerate(index[1:]): if isinstance(idx, slice): ix = range(*idx.indices(self.shape[cnt+1])) elif isinstance(idx, int): ix = range(idx-1, idx) else: continue if frames.ndim==4: # ugly indexing from the back (-1,-2 etc) cnt = cnt+1 frames = np.take(frames, ix, axis=cnt) if self.remove_leading_singleton and frames is not None: if frames.shape[0] == 1: frames = frames[0] return frames @property def dtype(self): return np.uint8 @property def shape(self): return (self.number_of_frames, *self.frame_shape) @property def ndim(self): return len(self.shape)+1 @property def size(self): return np.product(self.shape) def min(self): return 0 def max(self): return 255 def video_file_reader(path): array = VideoReaderNP(path, remove_leading_singleton=True) return [(array, {'name': path}, 'image')] @napari_hook_implementation def napari_get_reader(path): # remember, path can be a list, so we check it's type first... if isinstance(path, str) and any([path.endswith(ext) for ext in [".mp4", ".mov", ".avi"]]): # If we recognize the format, we return the actual reader function return video_file_reader # otherwise we return None. return None
lemma chain: "a \<in> s \<Longrightarrow> b \<in> s \<Longrightarrow> a \<le> b \<or> b \<le> a"
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9. Copyright (c) 2021, Oracle and/or its affiliates. Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl -} open import Util.Prelude module LibraBFT.Impl.OBM.ECP-LBFT-OBM-Diff.ECP-LBFT-OBM-Diff-0 where enabled : Bool enabled = true
% INTERNAL FUNCTION: multikronecker % % :: % % C=kronall(A1,A2,...,An) % % Args: % % - **Ai** [matrix]: input for the kronecker product % % Returns: % : % % - **C** [matrix]: kron(A1,kron(A2,kron(A3,...))) % % See also: % tensorperm % %
-- Pruebas de la distributiva del producto sobre sumas -- =================================================== import data.nat.basic open nat open list variables {α : Type*} {β : Type*} variable (x : α) variables (xs : list α) variable (n : ℕ) variable (ns : list ℕ) -- ---------------------------------------------------- -- Nota. Se usará la función aplica y sus propiedades -- estudiadas anteriormente. -- ---------------------------------------------------- def aplica : (α → β) → list α → list β | f [] := [] | f (x :: xs) := (f x) :: aplica f xs @[simp] lemma aplica_nil (f : α → β) : aplica f [] = [] := rfl @[simp] lemma aplica_cons (f : α → β) : aplica f (x :: xs) = (f x) :: aplica f xs := rfl -- ---------------------------------------------------- -- Ejercicio 1. Definir la función -- suma : list ℕ → ℕ -- tal que (suma xs) es la suma de los elementos de -- xs. Por ejemplo, -- suma [3,2,5] = 10 -- ---------------------------------------------------- def suma : list ℕ → ℕ | [] := 0 | (n :: ns) := n + suma ns -- #eval suma [3,2,5] -- ---------------------------------------------------- -- Ejercicio 2. Demostrar los siguientes lemas -- + suma_nil : -- suma ([] : list ℕ) = 0 := -- + suma_cons : -- suma (n :: ns) = n + suma ns := -- ---------------------------------------------------- @[simp] lemma suma_nil : suma ([] : list ℕ) = 0 := rfl @[simp] lemma suma_cons : suma (n :: ns) = n + suma ns := rfl -- ---------------------------------------------------- -- Ejercicio 3. (p. 45) Demostrar que -- suma (aplica (λ x, 2*x) ns) = 2 * (suma ns) -- ---------------------------------------------------- -- 1ª demostración example : suma (aplica (λ x, 2*x) ns) = 2 * (suma ns) := begin induction ns with m ms HI, { rw aplica_nil, rw suma_nil, rw nat.mul_zero, }, { rw aplica_cons, rw suma_cons, rw HI, rw suma_cons, rw mul_add, }, end -- 2ª demostración example : suma (aplica (λ x, 2*x) ns) = 2 * (suma ns) := begin induction ns with m ms HI, { calc suma (aplica (λ (x : ℕ), 2 * x) []) = suma [] : by rw aplica_nil ... = 0 : by rw suma_nil ... = 2 * 0 : by rw nat.mul_zero ... = 2 * suma [] : by rw suma_nil, }, { calc suma (aplica (λ x, 2 * x) (m :: ms)) = suma (2 * m :: aplica (λ x, 2 * x) ms) : by rw aplica_cons ... = 2 * m + suma (aplica (λ x, 2 * x) ms) : by rw suma_cons ... = 2 * m + 2 * suma ms : by rw HI ... = 2 * (m + suma ms) : by rw mul_add ... = 2 * suma (m :: ms) : by rw suma_cons, }, end -- 3ª demostración example : suma (aplica (λ x, 2*x) ns) = 2 * (suma ns) := begin induction ns with m ms HI, { simp, }, { simp [HI, mul_add], }, end -- 4ª demostración example : suma (aplica (λ x, 2*x) ns) = 2 * (suma ns) := by induction ns ; simp [*, mul_add] -- 5ª demostración lemma suma_aplica : ∀ ns, suma (aplica (λ x, 2*x) ns) = 2 * (suma ns) | [] := by simp | (m :: ms) := by simp [suma_aplica ms, mul_add] -- Comentarios sobre las funciones sum y map: -- + Son equivalentes a las funciones suma y aplica. -- + Para usarla hay que importar la librería -- data.list.basic y abrir el espacio de nombre -- list escribiendo al principio del fichero -- import data.list.basic -- open list -- + Se puede evaluar. Por ejemplo, -- #eval sum [3,2,5] -- #eval map (λx, 2*x) [3,2,5] -- #eval map ((*) 2) [3,2,5] -- #eval map ((+) 2) [3,2,5]
Sign up to Lineout to stay up to date with all of the latest RUPA news / Thanks for subscribing! With Rugby World Cup (“RWC”) underway the eyes of the world are on our sport. One of the most topical debates across all contact sports is the issue of concussion management. All stakeholders will be looking forward to a RWC in which players, medical personnel and team support staff play their part in managing this important aspect of player welfare. Rugby is making significant progress in the detection and management of concussion and it will be important that other professional rugby competitions move to adopt the standards set for RWC 2015. Rugby should not see the management of concussion as a risk at RWC, but an opportunity to demonstrate how far the game has come in recent times. The International Rugby Players Association (“IRPA”) is constantly thinking about what more can be done to further improve the games ability to manage the issues associated with concussion. Effective from 1st August 2015 after a successful global trial period at elite level, World Rugby has now formally introduced a temporary substitution rule. This applies to any player who is removed from the field of play to undertake a Head Injury Assessment (HIA) when it is unclear if that player has a suspected concussion. Having the ability to remove a player from the action and from the cauldron of a packed stadium, to undertake a thorough clinical assessment and video review of an incident, in a private controlled environment, makes good practical sense. Previously players in this situation would often go untreated, or be checked over briefly on field using questionable methods. World Rugby and other key stakeholders are leading a real culture shift amongst professional players, coaches and medical personnel in relation to peer pressure to play. Recent statistics back this up. Research has underpinned the HIA process throughout. Prior to the temporary substitution trial, 56 per cent of players with a confirmed concussion remained on the field following their injury. Now that figure is less than 12 per cent (British Journal of Sports Medicine, 2014) and the hope is that following continued refinement of the HIA process we will see further improvement in 2015 and beyond. A key point lost on many but one that IRPA believes is fundamental to a conservative management approach is that a player is now removed once the attending medics confirm a diagnosis of suspected concussion. This takes the pressure off trying to make a definitive diagnosis of concussion during a high-pressured game. That does mean players will be removed who have not suffered a concussion, but better the conservative approach. Thankfully the message is getting through and along with World Rugby’s #RecogniseAndRemove campaign, the games stakeholders are realising that it is not just the player’s responsibility but its coaches, referees, and team support staffs obligation to step in if they suspect a concussion has occurred. Whilst IRPA see this as a positive step, it is one that needs to be continually developed and filtered down to the community game where awareness and education on the subject is not yet at the same level. Medical specialist in concussion monitoring individual cases. Additionally, IRPA is very supportive and engaged on the work that is being undertaken on the laws of the game to ensure the risks of on-field instances that result in serious injury, including concussive events, are minimised. There is much conjecture on if rugby, and concussions sustained playing the game, lead to long-term cognitive health issues. From a player’s perspective IRPA does not want that debate to be a distraction from making sure the right thing is done by the players now. IRPA believes that the game should be doing all it can to ensure the welfare and health of the player is an ongoing priority. So what of the future and in particular the debate of using new technologies to take human error out of the equation? One such advancement that may justify further research and refinement is the use of sensors to help aide team doctors with real-time data. It could provide insight into accelerations and forces that they may not have seen first-hand particularly where the player has either not recognised a head knock, chosen not to seek medical assistance or suffered signs and symptoms post game. The sensor does not diagnose a concussion but rather provides accurate previously unavailable live information which combined with testing (HIA) and baseline data can aid in a clinical diagnosis. In the same way team support staff use other data like heart rates and GPS data, the sensor can provide data to assist medical personnel make informed decisions regarding concussion management. From a player welfare perspective, IRPA believes the pressure put on players to return to play to preserve their contracts and the rehabilitative support provided to players recovering from a concussion are areas that should be looked at further. Ensuring a players contractual terms and conditions are supportive during times of serious injury is fundamental. It allows the player the opportunity to fully recover without the added pressure or threat of having his or her salary or match payments stopped, or worse, the contract terminated. In this respect physical injuries are more obvious and certain, concussion in its very nature is obscure and invisible. Currently there are no set guidelines around minimum standards for players’ contractual terms and conditions. IRPA feels that the time is right to address this, not just because of the issues around concussion, but to maintain the integrity and reputation of the game. For those players who endure concussion complications either as part of their return to play process, or following a decision to stop playing, there seems little available to aide recovery beyond rest and time – which for an active professional athlete can be a very uncertain and sometimes depressing experience. IRPA would support more research into identifying rehabilitation techniques and programs to help in the resilience building and recovery process, and to ensure they are readily understood and available throughout the game. World leading player welfare standards are a priority in building the legacy of our sport. It is fundamental to the integrity of the game and to those who participate in it. IRPA is looking forward to continuing to work with World Rugby to bring about the culture change and to enhance the education and regulatory framework that ensures rugby leads the way on concussion management globally. The Rugby Union Players' Association (RUPA) will continue to take a proactive and collaborative approach to concussion prevention and management in Australia sport, as part of its involvement with the Australian Athletes' Alliance (AAA). Every week, RUPA collates five of the best features from the week’s Rugby media and bring them to you in the one convenient location. Charlie Fetoai: Jack of all trades; master of plenty! Former Reds centre Charlie Fetoai was seriously injured in 2009 and told he could never play Rugby again. He spoke to RUPA about what he's been up to since, and the importance of planning for life after Rugby.
[STATEMENT] lemma EQI: "a=b \<Longrightarrow> EQ a b" [PROOF STATE] proof (prove) goal (1 subgoal): 1. a = b \<Longrightarrow> EQ a b [PROOF STEP] by (simp add: EQ_def)
If two loops are homotopic, then their continuous images are homotopic.
theory RA_seL4 imports Main begin datatype PC = P0 | P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11 | P12 | P13 | P14 | Idle datatype PC_SETUP = L1 | L2 | L3 | L4 type_synonym Time = nat type_synonym Process = nat type_synonym MRange = "nat \<times> nat" type_synonym Mac = nat datatype Cap = CSCap Process | VSCap Process | TCBCap Process | TCap | KeyCap | EPCap | GrantCap | IQCap | NetCap | SendCap | ReceiveCap | BadgeCap Process datatype Object = P Process | INITTIME | KEY | IRQ | NONCE | MEM datatype Predicate = Read | Write | Grant | Control | AsyncSend | Receive consts Policy :: "(Process \<times> Predicate \<times> Object) set" consts P\<^sub>A :: Process consts P\<^sub>1 :: Process consts P\<^sub>N :: Process definition "P_distinct \<equiv> P\<^sub>A \<noteq> P\<^sub>1 \<and> P\<^sub>A \<noteq> P\<^sub>N \<and> P\<^sub>N \<noteq> P\<^sub>1" datatype Message = Req Time Mac MRange Process | Res Time Mac Mac | Empty fun isReq :: "Message \<Rightarrow> bool" where "isReq (Req _ _ _ _) = True" | "isReq _ = False" fun isRes :: "Message \<Rightarrow> bool" where "isRes (Res _ _ _) = True" | "isRes _ = False" fun getMTime :: "Message \<Rightarrow> Time " where "getMTime (Req t _ _ _) = t" | "getMTime (Res t _ _) = t" | "getMTime _ = 0 " fun getMProcess :: "Message \<Rightarrow> Process option" where "getMProcess (Req _ _ _ p) = Some p" | "getMProcess (Res _ _ _) = None" | "getMProcess _ = None " fun getMRange :: "Message \<Rightarrow> MRange option" where "getMRange (Req _ _ r _) = Some r" | "getMRange (Res _ _ _) = None" | "getMRange _ = None " fun getFMac :: "Message \<Rightarrow> Mac " where "getFMac (Req _ fm _ _) = fm" | "getFMac (Res _ fm _) = fm" | "getFMac _ = 0 " fun getSMac :: "Message \<Rightarrow> Mac option" where "getSMac (Req _ _ _ _) = None" | "getSMac (Res _ _ sm) = Some sm" | "getSMac _ = None " record Message_req = time_req :: Time (*Treq, Tres, ...*) mac_req :: nat mrang_req :: MRange (*a'b'*) proc_req :: Process (*Pa, P1, ...*) record Message_resp = time_resp :: Time (*Treq, Tres, ...*) (*proc_resp :: Process Pa, P1, ...*) mac1_resp :: nat mac2_resp :: nat record CSpace_rec = Caps :: "Cap set" EP :: Message record TCB_rec = VSpace :: nat CSpace :: CSpace_rec record Proc_rec = TCB :: TCB_rec Mem :: MRange Priority :: nat Time :: nat Parent :: nat record State = Procs :: "Process set" ProcRec :: "Process \<Rightarrow> Proc_rec" TInit :: nat Key :: nat Nonce :: nat irq :: bool pc :: PC policy :: "(Process \<times> Predicate \<times> Object) set" (*Local*) rval :: "Message" l_time :: nat l_mac1 :: nat l_mac2 :: nat ep :: Message definition "P_attest_prop s \<equiv> P\<^sub>A\<in>Procs s \<and> Priority ((ProcRec s) P\<^sub>A) = 0 \<and> Time ((ProcRec s) P\<^sub>A) = TInit s \<and> Parent ((ProcRec s) P\<^sub>A) = 0 \<and> Caps (CSpace (TCB ((ProcRec s) P\<^sub>A))) = {VSCap P\<^sub>A, CSCap P\<^sub>A, TCBCap P\<^sub>A, TCap, KeyCap , EPCap, GrantCap, IQCap, SendCap,BadgeCap P\<^sub>A, BadgeCap P\<^sub>N}" definition "Spawned_prop p s \<equiv> p \<noteq> P\<^sub>A \<and> p \<in> Procs s \<and> Priority ((ProcRec s) p) > 0 \<and> Time ((ProcRec s) p) > TInit s \<and> Caps (CSpace (TCB ((ProcRec s) p))) = {VSCap p, CSCap p, TCBCap p}" definition "Net_prop p s \<equiv> p \<noteq> P\<^sub>A \<and> p \<in> Procs s \<and> Priority ((ProcRec s) p) > 0 \<and> Time ((ProcRec s) p) > TInit s \<and> Caps (CSpace (TCB ((ProcRec s) p))) = {VSCap p, CSCap p, TCBCap p, NetCap, ReceiveCap, BadgeCap P\<^sub>N, BadgeCap P\<^sub>A}" record SetupState = ss_pc :: PC_SETUP definition "CreateProcess tcb mem pri t par\<equiv> \<lparr> TCB = tcb, Mem = mem, Priority = pri, Time = t, Parent = par \<rparr>" definition "CreateProcessTCB vs cs\<equiv> \<lparr> VSpace = vs, CSpace = cs \<rparr>" definition "CreateProcessCSpace caps \<equiv> \<lparr> Caps = caps, EP = Empty \<rparr>" definition "MAC data::nat \<equiv> SOME n. 1 \<le> n \<and> n \<le> data * data * data" definition "getTime now \<equiv> SOME t . t > now" definition update_pc :: "PC \<Rightarrow> State \<Rightarrow> State" ("`pc := _" [200]) where "update_pc v \<equiv> \<lambda> s. s \<lparr>pc := v\<rparr>" definition update_local_ep :: "Message \<Rightarrow> State \<Rightarrow> State" ("`ep := _" [200]) where "update_local_ep v \<equiv> \<lambda> s. s \<lparr>ep := v\<rparr>" definition update_irq :: "bool \<Rightarrow> State \<Rightarrow> State" ("`irq := _" [200]) where "update_irq v \<equiv> \<lambda> s. s \<lparr>irq := v\<rparr>" definition update_rval :: "Message \<Rightarrow> State \<Rightarrow> State" ("`rval := _" [200]) where "update_rval v \<equiv> \<lambda> s. s \<lparr>rval := v\<rparr>" (*definition update_badge :: "bool \<Rightarrow> Proc_rec \<Rightarrow> Proc_rec" ("`badge := _" [100]) where "update_badge v \<equiv> \<lambda> s. s \<lparr>Badge := v\<rparr>"*) definition update_time :: "Time \<Rightarrow> State \<Rightarrow> State" ("`time := _" [100]) where "update_time v \<equiv> \<lambda> s. s \<lparr>l_time := v\<rparr>" definition update_mac1 :: "nat \<Rightarrow> State \<Rightarrow> State" ("`mac1 := _" [200]) where "update_mac1 v \<equiv> \<lambda> s. s \<lparr>l_mac1 := v\<rparr>" definition update_mac2 :: "nat \<Rightarrow> State \<Rightarrow> State" ("`mac2 := _" [200]) where "update_mac2 v \<equiv> \<lambda> s. s \<lparr>l_mac2 := v\<rparr>" definition update_nonce :: "nat \<Rightarrow> State \<Rightarrow> State" ("`nonce := _" [200]) where "update_nonce v \<equiv> \<lambda> s. s \<lparr>Nonce := v\<rparr>" definition Setup :: "SetupState \<Rightarrow> State \<Rightarrow> SetupState \<Rightarrow> State \<Rightarrow> bool" where "Setup ss s ss' s' \<equiv> (case (ss_pc ss) of L1 \<Rightarrow> let csp = CreateProcessCSpace {VSCap P\<^sub>A, CSCap P\<^sub>A, TCBCap P\<^sub>A, TCap, KeyCap , EPCap, GrantCap, IQCap, SendCap, BadgeCap P\<^sub>A, BadgeCap P\<^sub>N}; tcb = CreateProcessTCB 0 csp; pr = CreateProcess tcb (0,1) 0 (TInit s) 0 in s' = s\<lparr>Procs := Procs s \<union> {P\<^sub>A}, ProcRec := (ProcRec s)(P\<^sub>A := pr), policy := policy s \<union> {(P\<^sub>A, Read, KEY),(P\<^sub>A, Read, INITTIME), (P\<^sub>A, Control,P P\<^sub>A),(P\<^sub>A, Control, IRQ), (P\<^sub>A, Control, NONCE), (P\<^sub>A, Control, MEM)}\<rparr> \<and> (ss_pc ss' = L2) | L2 \<Rightarrow> let csp = CreateProcessCSpace {VSCap P\<^sub>1, CSCap P\<^sub>1, TCBCap P\<^sub>1}; tcb = CreateProcessTCB 0 csp; pr = CreateProcess tcb (1,2) 1 (TInit s) 1 in s' = s\<lparr>Procs := Procs s \<union> {P\<^sub>1}, ProcRec := (ProcRec s)(P\<^sub>1 := pr),policy := policy s \<union> {(P\<^sub>1, Control,P P\<^sub>1) , (P\<^sub>A, Control,P P\<^sub>1)}\<rparr> \<and> (ss_pc ss' = L3) | L3 \<Rightarrow> let csp = CreateProcessCSpace {VSCap P\<^sub>N, CSCap P\<^sub>N, TCBCap P\<^sub>N}; tcb = CreateProcessTCB 0 csp; pr = CreateProcess tcb (2,3) 1 (TInit s) 0 in s' = s\<lparr>Procs := Procs s \<union> {P\<^sub>N}, ProcRec := (ProcRec s)(P\<^sub>N := pr), policy := policy s \<union> {(P\<^sub>N, Control,P P\<^sub>N) , (P\<^sub>A, Control,P P\<^sub>N)}\<rparr> \<and> (ss_pc ss' = L4) | L4 \<Rightarrow> False ) " definition "getEP s p \<equiv> (EP (CSpace (TCB (ProcRec s p))))" lemmas simps [simp] = update_nonce_def update_mac2_def update_mac1_def update_time_def (*update_badge_def*) update_rval_def update_irq_def update_pc_def MAC_def update_local_ep_def Let_def definition Prover :: "State \<Rightarrow> State \<Rightarrow> bool" where "Prover s s' \<equiv> (case (pc s) of P0 \<Rightarrow> if BadgeCap P\<^sub>A \<in> (Caps (CSpace (TCB ((ProcRec s) P\<^sub>N)))) then s' = (`pc := P1) s else s' = s | P1 \<Rightarrow> s' = (`pc := P2 \<circ> `irq := False) s | P2 \<Rightarrow> let ep = (EP(CSpace (TCB ((ProcRec s) P\<^sub>N)))) in if isReq ep then s' = (`pc := P3 \<circ> `ep := ep \<circ> (\<lambda> s . s \<lparr>ProcRec := (ProcRec s)(P\<^sub>A := (ProcRec s P\<^sub>A)\<lparr> TCB := (TCB (ProcRec s P\<^sub>A))\<lparr>CSpace := ((CSpace (TCB (ProcRec s P\<^sub>A)))\<lparr>EP := ep\<rparr>)\<rparr>\<rparr>)\<rparr>)) s else s' = s | P3 \<Rightarrow> (if(TInit s > (getMTime (ep s))) then (s'= (`pc := Idle \<circ> `rval := Empty) s ) else (s' = (`pc := P4) s)) | P4 \<Rightarrow> (if ((getFMac (ep s)) \<noteq> (MAC ((getMTime (ep s)) * fst (Mem ((ProcRec s) P\<^sub>A)) * snd (Mem ((ProcRec s) P\<^sub>A)) * (P\<^sub>A)))) then (s' = (`pc := Idle \<circ> `rval := Empty) s) else (s' = (`pc := P5) s)) | P5 \<Rightarrow> s' = (`pc := P6 \<circ> `nonce := (TInit s + (getMTime (ep s)))) s | P6 \<Rightarrow> s' = (`pc := P7 \<circ> `time := (getTime ((getMTime (ep s))))) s | P7 \<Rightarrow> s' = (`pc := P8 \<circ> `mac1 := (MAC (fst (Mem ((ProcRec s) P\<^sub>A)) * snd (Mem ((ProcRec s) P\<^sub>A))))) s | P8 \<Rightarrow> s' = (`pc := P9 \<circ> `mac2 := (MAC ((l_time s) * (P\<^sub>A) * (l_mac1 s)))) s | P9 \<Rightarrow> s' = (`pc := P10 \<circ> `rval := ((Res (l_time s) (l_mac1 s) (l_mac2 s)))) s | P10 \<Rightarrow> s' = (`pc := P11 \<circ> (\<lambda> s . s \<lparr>ProcRec := (ProcRec s)(P\<^sub>A := (ProcRec s P\<^sub>A) \<lparr>TCB := (TCB (ProcRec s P\<^sub>A))\<lparr>CSpace := ((CSpace (TCB (ProcRec s P\<^sub>A)))\<lparr>EP := rval s\<rparr>)\<rparr>\<rparr>)\<rparr>)) s | P11 \<Rightarrow> s' = (`pc := Idle \<circ> `irq := True) s | Idle \<Rightarrow> False | _ \<Rightarrow> False)" definition Network :: "State \<Rightarrow> Message \<Rightarrow> State \<Rightarrow> bool" where "Network s m s' \<equiv> case (pc s) of P0 \<Rightarrow> s' = (`pc := P1 \<circ> `ep := m \<circ> (\<lambda> s . s \<lparr>ProcRec := (ProcRec s)(P\<^sub>N := (ProcRec s P\<^sub>N)\<lparr> TCB := (TCB (ProcRec s P\<^sub>N))\<lparr>CSpace := ((CSpace (TCB (ProcRec s P\<^sub>N)))\<lparr>EP := m\<rparr>)\<rparr>\<rparr>)\<rparr>)) s | P1 \<Rightarrow> if BadgeCap P\<^sub>N \<in> (Caps (CSpace (TCB ((ProcRec s) P\<^sub>A)))) then s' = (`pc := P2) s else s' = s | P2 \<Rightarrow> let ep = (EP(CSpace (TCB ((ProcRec s) P\<^sub>A)))) in s' = (`pc := P3 \<circ> (\<lambda> s . s \<lparr>ProcRec := (ProcRec s)(P\<^sub>N := (ProcRec s P\<^sub>N)\<lparr> TCB := (TCB (ProcRec s P\<^sub>N))\<lparr>CSpace := ((CSpace (TCB (ProcRec s P\<^sub>N)))\<lparr>EP := ep\<rparr>)\<rparr>\<rparr>)\<rparr>)) s | _ \<Rightarrow> False" (* -----------------------------------------------------P\<^sub>A Related Lemmas-------------------------------------------------*) lemma Setup_P\<^sub>A: "ss_pc ss = L1 \<Longrightarrow> Setup ss s ss' s' \<Longrightarrow> P_attest_prop s'" apply(simp add: Setup_def P_attest_prop_def CreateProcessCSpace_def CreateProcessTCB_def CreateProcess_def) done lemma Setup_P\<^sub>1: "P_distinct \<Longrightarrow> ss_pc ss = L2 \<Longrightarrow> P_attest_prop s \<Longrightarrow> Setup ss s ss' s' \<Longrightarrow> P_attest_prop s'" by(simp add:P_distinct_def Setup_def P_attest_prop_def CreateProcessCSpace_def CreateProcessTCB_def CreateProcess_def) lemma Setup_P\<^sub>N: "P_distinct \<Longrightarrow> ss_pc ss = L3 \<Longrightarrow> P_attest_prop s \<Longrightarrow> Setup ss s ss' s' \<Longrightarrow> P_attest_prop s'" by(simp add:P_distinct_def Setup_def P_attest_prop_def CreateProcessCSpace_def CreateProcessTCB_def CreateProcess_def) lemma Network_P\<^sub>A: "P_attest_prop s \<Longrightarrow> Network s m s' \<Longrightarrow> P_attest_prop s'" apply(simp add: Setup_def Prover_def Network_def P_distinct_def Setup_P\<^sub>A P_attest_prop_def CreateProcessCSpace_def CreateProcessTCB_def CreateProcess_def) apply(cases "pc s", simp_all) apply clarsimp apply clarsimp done lemma Prover_P\<^sub>A: "P_attest_prop s \<Longrightarrow> Prover s s' \<Longrightarrow> P_attest_prop s'" apply(simp add: Setup_def Prover_def P_distinct_def Setup_P\<^sub>A P_attest_prop_def CreateProcessCSpace_def CreateProcessTCB_def CreateProcess_def) apply(cases " pc s", simp_all) apply (case_tac "BadgeCap P\<^sub>A \<in> Caps (CSpace (TCB (ProcRec s P\<^sub>N)))", simp_all) apply(case_tac "isReq (EP (CSpace (TCB (ProcRec s P\<^sub>N))))", simp_all) apply(case_tac "getMTime (ep s) < TInit s", simp_all) apply(case_tac "getFMac (ep s) \<noteq> (SOME n. Suc 0 \<le> n \<and> n \<le> getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A) * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A))", simp_all) done (* -----------------------------------------------------P\<^sub>N Related Lemmas-------------------------------------------------*) lemma Network_P\<^sub>N: "P_distinct \<Longrightarrow> pc s = P3 \<Longrightarrow> Net_prop P\<^sub>N s \<Longrightarrow> Prover s s' \<Longrightarrow> Net_prop P\<^sub>N s'" apply(simp add:Prover_def P_distinct_def Setup_def P_attest_prop_def Net_prop_def CreateProcessCSpace_def CreateProcessTCB_def CreateProcess_def) apply(case_tac "getMTime (ep s) < TInit s", simp_all) done lemma Prover_P\<^sub>N: "P_distinct \<Longrightarrow> pc s = P4 \<Longrightarrow> Net_prop P\<^sub>N s \<Longrightarrow> Network s m s' \<Longrightarrow> Net_prop P\<^sub>N s'" by(simp add:Network_def Prover_def P_distinct_def Setup_def P_attest_prop_def Net_prop_def CreateProcessCSpace_def CreateProcessTCB_def CreateProcess_def) (* *********************************** Confidentiality Through AC ***************************************** *) definition "KeyConf s \<equiv> \<forall>p. (p, Read, KEY)\<in>policy s \<longrightarrow> p = P\<^sub>A" definition "MemConf s \<equiv> \<forall>p. (p, Read, MEM)\<in>policy s \<longrightarrow> p = P\<^sub>A" definition "IrqAC s \<equiv> \<forall>p. (p, Control, IRQ)\<in>policy s \<longrightarrow> p = P\<^sub>A" definition "TimeConf s \<equiv> \<forall>p. (p, Read, INITTIME)\<in>policy s \<longrightarrow> p = P\<^sub>A" definition "NONCE_AC s \<equiv> \<forall>p. (p, Control, NONCE)\<in>policy s \<longrightarrow> p = P\<^sub>A" definition "Super s \<equiv> \<forall>p. p\<in> Procs s \<longrightarrow> (P\<^sub>A, Control, P p)\<in>policy s" definition "no_grant s \<equiv> \<forall> p p' .p \<in> Procs s \<and> p'\<in>Procs s \<and> p \<noteq> P\<^sub>A \<and> p'\<noteq>P\<^sub>A \<and> (p, Control, P p')\<in>policy s \<longrightarrow> p = p'" definition "Evolution s ss \<equiv> (ss_pc ss = L1 \<longrightarrow> Procs s = {}) \<and>( ss_pc ss = L2 \<longrightarrow> Procs s = {P\<^sub>A}) \<and> ( ss_pc ss = L3 \<longrightarrow> Procs s = {P\<^sub>A , P\<^sub>1}) \<and> ( ss_pc ss = L4 \<longrightarrow> Procs s = {P\<^sub>A , P\<^sub>1 , P\<^sub>N})" definition "Evolution_Policy s ss \<equiv> (ss_pc ss = L1 \<longrightarrow> policy s = {}) \<and>(ss_pc ss = L2 \<longrightarrow> policy s = {(P\<^sub>A, Read, KEY),(P\<^sub>A, Read, INITTIME), (P\<^sub>A, Control,P P\<^sub>A),(P\<^sub>A, Control, IRQ), (P\<^sub>A, Control, NONCE), (P\<^sub>A, Control, MEM)}) \<and> (ss_pc ss = L3 \<longrightarrow> policy s = {(P\<^sub>1, Control,P P\<^sub>1) , (P\<^sub>A, Control,P P\<^sub>1)}) \<and> (ss_pc ss = L4 \<longrightarrow> policy s = {(P\<^sub>N, Control,P P\<^sub>N) , (P\<^sub>A, Control,P P\<^sub>N)})" definition "Reflect s \<equiv> \<forall>p. p\<in> Procs s \<longrightarrow> (p, Control,P p)\<in>policy s" lemma Setup_no_Control : "Evolution_Policy s ss \<Longrightarrow> Reflect s \<Longrightarrow> Evolution s ss \<Longrightarrow> P_distinct \<Longrightarrow> no_grant s \<Longrightarrow> Setup ss s ss' s' \<Longrightarrow> no_grant s'" apply(simp add: Setup_def del:simps) apply (cases "ss_pc ss", simp_all) apply safe apply(simp add: Reflect_def Evolution_def Evolution_Policy_def no_grant_def) apply(simp add: Reflect_def Evolution_def Evolution_Policy_def no_grant_def) apply blast by (simp add: Evolution_Policy_def Evolution_def P_distinct_def Reflect_def) lemma Prover_no_Control: assumes "Prover s s'" and "no_grant s" shows "no_grant s'" using assms apply(simp add: Setup_def Prover_def Evolution_def Evolution_Policy_def P_distinct_def Reflect_def P_attest_prop_def CreateProcess_def CSpace_def CreateProcessTCB_def no_grant_def) apply(cases "pc s", simp_all) apply(case_tac "BadgeCap P\<^sub>A \<in> Caps (CSpace (TCB (ProcRec s P\<^sub>N)))", simp_all) apply(case_tac " isReq (EP (CSpace (TCB (ProcRec s P\<^sub>N))))", simp_all) apply(case_tac "getMTime (ep s) < TInit s", simp_all) apply(case_tac "getFMac (ep s) \<noteq> (SOME n. Suc 0 \<le> n \<and> n \<le> getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A) * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A))", simp_all) done lemma Setup_Key_conf : "P_distinct \<Longrightarrow> KeyConf s \<Longrightarrow> Setup ss s ss' s' \<Longrightarrow> KeyConf s'" apply(simp add: KeyConf_def Setup_def CreateProcessCSpace_def CreateProcessTCB_def CreateProcess_def) apply(cases "ss_pc ss", simp_all) done lemma Prover_Key_conf : "KeyConf s \<Longrightarrow> Prover s s' \<Longrightarrow> KeyConf s'" apply(simp add: KeyConf_def Setup_def Prover_def CreateProcessCSpace_def CreateProcessTCB_def CreateProcess_def P_distinct_def) apply(cases "pc s", simp_all) apply(case_tac "BadgeCap P\<^sub>A \<in> Caps (CSpace (TCB (ProcRec s P\<^sub>N)))", simp_all) apply(case_tac "isReq (EP (CSpace (TCB (ProcRec s P\<^sub>N))))", simp_all) apply(case_tac "getMTime (ep s) < TInit s ", simp_all) apply(case_tac "getFMac (ep s) \<noteq> (SOME n. Suc 0 \<le> n \<and> n \<le> getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A) * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A))", simp_all) done lemma Setup_Time_conf : "TimeConf s \<Longrightarrow> Setup ss s ss' s' \<Longrightarrow> TimeConf s'" apply(simp add: TimeConf_def Setup_def CreateProcessCSpace_def CreateProcessTCB_def CreateProcess_def) apply(cases "ss_pc ss", simp_all) done lemma Prover_Time_conf : "TimeConf s \<Longrightarrow> Prover s s' \<Longrightarrow> TimeConf s'" apply(simp add: TimeConf_def Prover_def Setup_def CreateProcessCSpace_def CreateProcessTCB_def CreateProcess_def) apply(cases "pc s", simp_all) apply(case_tac "BadgeCap P\<^sub>A \<in> Caps (CSpace (TCB (ProcRec s P\<^sub>N)))", simp_all) apply(case_tac "isReq (EP (CSpace (TCB (ProcRec s P\<^sub>N))))", simp_all) apply(case_tac "getMTime (ep s) < TInit s", simp_all) apply(case_tac "getFMac (ep s) \<noteq> (SOME n. Suc 0 \<le> n \<and> n \<le> getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A) * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A))", simp_all) done lemma Superiority_Setup : "P_distinct \<Longrightarrow> Super s \<Longrightarrow> Setup ss s ss' s' \<Longrightarrow> Super s'" apply(simp add: Super_def Setup_def CreateProcessCSpace_def P_distinct_def CreateProcessTCB_def CreateProcess_def) apply(intro allI impI) apply(cases "ss_pc ss", simp_all) apply auto[1] apply blast by auto lemma Superiority_Prover : "P_distinct \<Longrightarrow> Super s \<Longrightarrow> Prover s s' \<Longrightarrow> Super s'" apply(simp add: Super_def Setup_def Prover_def CreateProcessCSpace_def P_distinct_def CreateProcessTCB_def CreateProcess_def Network_def) apply(cases "pc s", simp_all) apply(case_tac "BadgeCap P\<^sub>A \<in> Caps (CSpace (TCB (ProcRec s P\<^sub>N)))", simp_all) apply(case_tac "\<forall>p. p \<in> Procs s \<longrightarrow> (P\<^sub>A, Control, P p) \<in> policy s ", simp_all) apply(case_tac "isReq (EP (CSpace (TCB (ProcRec s P\<^sub>N))))", simp_all) apply(case_tac "getMTime (ep s) < TInit s", simp_all) apply(case_tac "getFMac (ep s) \<noteq> (SOME n. Suc 0 \<le> n \<and> n \<le> getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A) * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A))", simp_all) done lemma Setup_Mem_conf : "MemConf s \<Longrightarrow> Setup ss s ss' s' \<Longrightarrow> MemConf s'" apply(simp add: MemConf_def Setup_def CreateProcessCSpace_def CreateProcessTCB_def CreateProcess_def) apply(cases "ss_pc ss", simp_all) done lemma Prover_Mem_conf : "MemConf s \<Longrightarrow> Prover s s' \<Longrightarrow> MemConf s'" apply(simp add: MemConf_def Setup_def Prover_def CreateProcessCSpace_def CreateProcessTCB_def CreateProcess_def) apply(case_tac "\<forall>p. (p, Read, MEM) \<in> policy s \<longrightarrow> p = P\<^sub>A",simp_all) apply(cases "pc s", simp_all) apply(case_tac "BadgeCap P\<^sub>A \<in> Caps (CSpace (TCB (ProcRec s P\<^sub>N)))", simp_all) apply(case_tac "isReq (EP (CSpace (TCB (ProcRec s P\<^sub>N))))", simp_all) apply(case_tac "getMTime (ep s) < TInit s", simp_all) apply(case_tac "getFMac (ep s) \<noteq> (SOME n. Suc 0 \<le> n \<and> n \<le> getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A) * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A))", simp_all) done lemma Prover_IRQ_AC : "IrqAC s \<Longrightarrow> Prover s s' \<Longrightarrow> IrqAC s'" apply(simp add: Setup_def Prover_def CreateProcessCSpace_def P_distinct_def CreateProcessTCB_def CreateProcess_def Network_def IrqAC_def) apply(cases "pc s", simp_all) apply(case_tac "\<forall>p. (p, Control, IRQ) \<in> policy s \<longrightarrow> p = P\<^sub>A", simp_all) apply(case_tac "BadgeCap P\<^sub>A \<in> Caps (CSpace (TCB (ProcRec s P\<^sub>N)))", simp_all) apply(case_tac "isReq (EP (CSpace (TCB (ProcRec s P\<^sub>N))))", simp_all) apply(case_tac "getMTime (ep s) < TInit s", simp_all) apply(case_tac "getFMac (ep s) \<noteq> (SOME n. Suc 0 \<le> n \<and> n \<le> getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A) * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A))", simp_all) done lemma Prover_Nonce_AC : "NONCE_AC s \<Longrightarrow> Prover s s' \<Longrightarrow> NONCE_AC s'" apply(simp add: NONCE_AC_def Setup_def Prover_def CreateProcessCSpace_def CreateProcessTCB_def CreateProcess_def) apply(case_tac "\<forall>p. (p, Control, NONCE) \<in> policy s \<longrightarrow> p = P\<^sub>A ", simp_all) apply(cases "pc s", simp_all) apply(case_tac "BadgeCap P\<^sub>A \<in> Caps (CSpace (TCB (ProcRec s P\<^sub>N)))",simp_all) apply(case_tac "isReq (EP (CSpace (TCB (ProcRec s P\<^sub>N))))", simp_all) apply(case_tac "getMTime (ep s) < TInit s",simp_all) apply(case_tac "getFMac (ep s) \<noteq> (SOME n. Suc 0 \<le> n \<and> n \<le> getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A) * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A))",simp_all) done (* *********************************** Information Flow ***************************************** *) definition "inv_rval s \<equiv> pc s \<in> {P10, P11} \<longrightarrow> isRes (rval s) " definition "inv_req s \<equiv> pc s = P3 \<longrightarrow> isReq (ep s)" lemma P\<^sub>A_to_P\<^sub>N: assumes "Prover s s'" and "inv_rval s" shows "inv_rval s'" using assms apply(simp add: Prover_def inv_rval_def) apply(cases "pc s", simp_all) apply(case_tac "BadgeCap P\<^sub>A \<in> Caps (CSpace (TCB (ProcRec s P\<^sub>N)))", simp_all) apply(case_tac "isReq (EP (CSpace (TCB (ProcRec s P\<^sub>N))))", simp_all) apply(case_tac "getMTime (ep s) < TInit s", simp_all) apply(case_tac "getFMac (ep s) \<noteq> (SOME n. Suc 0 \<le> n \<and> n \<le> getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A) * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A))", simp_all) done lemma P\<^sub>N_to_P\<^sub>A: assumes "Prover s s'" and "inv_req s" shows "inv_req s'" using assms apply(simp add: P_distinct_def Setup_def Prover_def inv_req_def inv_rval_def CreateProcessCSpace_def CreateProcessTCB_def CreateProcess_def) apply(cases "pc s", simp_all) apply(case_tac "BadgeCap P\<^sub>A \<in> Caps (CSpace (TCB (ProcRec s P\<^sub>N)))", simp_all) apply(case_tac "isReq (EP (CSpace (TCB (ProcRec s P\<^sub>N))))", simp_all) apply(case_tac "getMTime (ep s) < TInit s", simp_all) apply(case_tac "getFMac (ep s) \<noteq> (SOME n. Suc 0 \<le> n \<and> n \<le> getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A) * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A))", simp_all) done lemma Info_Flow_1: "inv_rval s \<Longrightarrow> pc s = P12 \<Longrightarrow> Badge ((ProcRec s) P\<^sub>A) \<Longrightarrow> Prover s s' \<Longrightarrow> isRes (EP(CSpace (TCB ((ProcRec s') P\<^sub>A)))) " apply(simp add: Prover_def inv_rval_def) done (* *********************************** Integrity ***************************************** *) definition "Key_AC \<equiv> \<forall>p. (p, Read, KEY)\<in>Policy \<longrightarrow> p = P\<^sub>A" definition "Mem_AC \<equiv> \<forall>p. (p, Control, MEM)\<in>Policy \<longrightarrow> p = P\<^sub>A" lemma Res_Integrity: "pc s\<in> {P2, P3, P4, P5} \<Longrightarrow> Badge ((ProcRec s) P\<^sub>A) \<Longrightarrow> isReq m \<Longrightarrow> Network s m s' \<Longrightarrow> pc s' = P5 \<Longrightarrow> (EP(CSpace (TCB ((ProcRec s') P\<^sub>A)))) = (EP(CSpace (TCB ((ProcRec s') P\<^sub>N)))) " apply(simp add: Network_def) apply(case_tac "pc s = P1", simp_all) apply(case_tac "pc s = P2", simp_all) by auto lemma EP_Integrity_Prover: "pc s = P2 \<Longrightarrow> BadgeCap P\<^sub>A \<in> (Caps (CSpace (TCB ((ProcRec s) P\<^sub>N)))) \<Longrightarrow> Prover s s' \<Longrightarrow> pc s' = P4 \<Longrightarrow> (EP(CSpace (TCB ((ProcRec s') P\<^sub>A)))) = (EP(CSpace (TCB ((ProcRec s') P\<^sub>N)))) " apply(simp add: Prover_def) apply (case_tac "isReq (EP (CSpace (TCB (ProcRec s P\<^sub>N))))", simp_all) done lemma TInit_Integrity: assumes "Prover s s'" and "P_attest_prop s" shows "TInit s' = TInit s" using assms apply(simp add: Prover_def Key_AC_def P_attest_prop_def) apply(case_tac "pc s") apply simp_all apply(case_tac "BadgeCap P\<^sub>A \<in> Caps (CSpace (TCB (ProcRec s P\<^sub>N)))") apply simp_all apply(case_tac "getMTime (ep s) < TInit s") apply(case_tac "isReq (EP (CSpace (TCB (ProcRec s P\<^sub>N))))", simp_all) apply(case_tac "isReq (EP (CSpace (TCB (ProcRec s P\<^sub>N))))", simp_all) apply(case_tac "getMTime (ep s) < TInit s",simp_all) apply(case_tac "getFMac (ep s) \<noteq> (SOME n. Suc 0 \<le> n \<and> n \<le> getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A) * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A))") apply simp_all done lemma Key_Integrity: assumes "Prover s s'" and "P_attest_prop s" shows "Key s' = Key s" using assms apply(simp add: Prover_def Key_AC_def P_attest_prop_def) apply(cases "pc s", simp_all) apply(case_tac " BadgeCap P\<^sub>A \<in> Caps (CSpace (TCB (ProcRec s P\<^sub>N)))") apply simp_all apply(case_tac " getMTime (ep s) < TInit s") apply(case_tac "isReq (EP (CSpace (TCB (ProcRec s P\<^sub>N))))", simp_all) apply(case_tac "isReq (EP (CSpace (TCB (ProcRec s P\<^sub>N))))", simp_all) apply(case_tac "getMTime (ep s) < TInit s", simp_all) apply(case_tac "getFMac (ep s) \<noteq> (SOME n. Suc 0 \<le> n \<and> n \<le> getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A) * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A))") apply simp_all done lemma Mem_Integrity_Prover: assumes "Prover s s'" and "P_attest_prop s" shows "Mem ((ProcRec s') P\<^sub>A) = Mem ((ProcRec s) P\<^sub>A)" using assms apply(simp add: Prover_def Key_AC_def P_attest_prop_def) apply(cases "pc s", simp_all) apply(case_tac " BadgeCap P\<^sub>A \<in> Caps (CSpace (TCB (ProcRec s P\<^sub>N)))", simp_all) apply (case_tac "isReq (EP (CSpace (TCB (ProcRec s P\<^sub>N))))", simp_all) apply(case_tac "getMTime (ep s) < TInit s", simp_all) apply(case_tac "getFMac (ep s) \<noteq> (SOME n. Suc 0 \<le> n \<and> n \<le> getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A) * (getMTime (ep s) * fst (Mem (ProcRec s P\<^sub>A)) * snd (Mem (ProcRec s P\<^sub>A)) * P\<^sub>A))", simp_all) done lemma Mem_Integrity_Network: assumes "Network s m s'" shows "Mem ((ProcRec s') P\<^sub>A) = Mem ((ProcRec s) P\<^sub>A)" using assms apply(simp add: Setup_def P_attest_prop_def Prover_def Network_def Mem_AC_def) apply(case_tac "pc s", simp_all) apply(case_tac "BadgeCap P\<^sub>N \<in> Caps (CSpace (TCB (ProcRec s P\<^sub>A)))", simp_all) done end
State Before: α : Type u_1 β : Type ?u.36188 γ : Type ?u.36191 δ : Type ?u.36194 ι : Type ?u.36197 R : Type ?u.36200 R' : Type ?u.36203 m : MeasurableSpace α μ μ₁ μ₂ : Measure α s s₁ s₂ t t₁ t₂ : Set α hs : s₁ ⊆ s₂ hsμ : ↑↑μ s₂ ≤ ↑↑μ s₁ ht : t₁ ⊆ t₂ htμ : ↑↑μ t₂ ≤ ↑↑μ t₁ ⊢ ↑↑μ (s₁ ∪ t₁) = ↑↑μ (s₂ ∪ t₂) State After: α : Type u_1 β : Type ?u.36188 γ : Type ?u.36191 δ : Type ?u.36194 ι : Type ?u.36197 R : Type ?u.36200 R' : Type ?u.36203 m : MeasurableSpace α μ μ₁ μ₂ : Measure α s s₁ s₂ t t₁ t₂ : Set α hs : s₁ ⊆ s₂ hsμ : ↑↑μ s₂ ≤ ↑↑μ s₁ ht : t₁ ⊆ t₂ htμ : ↑↑μ t₂ ≤ ↑↑μ t₁ ⊢ ↑↑μ (⋃ (b : Bool), bif b then s₁ else t₁) = ↑↑μ (⋃ (b : Bool), bif b then s₂ else t₂) Tactic: rw [union_eq_iUnion, union_eq_iUnion] State Before: α : Type u_1 β : Type ?u.36188 γ : Type ?u.36191 δ : Type ?u.36194 ι : Type ?u.36197 R : Type ?u.36200 R' : Type ?u.36203 m : MeasurableSpace α μ μ₁ μ₂ : Measure α s s₁ s₂ t t₁ t₂ : Set α hs : s₁ ⊆ s₂ hsμ : ↑↑μ s₂ ≤ ↑↑μ s₁ ht : t₁ ⊆ t₂ htμ : ↑↑μ t₂ ≤ ↑↑μ t₁ ⊢ ↑↑μ (⋃ (b : Bool), bif b then s₁ else t₁) = ↑↑μ (⋃ (b : Bool), bif b then s₂ else t₂) State After: no goals Tactic: exact measure_iUnion_congr_of_subset (Bool.forall_bool.2 ⟨ht, hs⟩) (Bool.forall_bool.2 ⟨htμ, hsμ⟩)
callable <- function(arity, f, formatter = NULL) { if (is.null(formatter)) { force(f) formatter <- function() paste(format(f), collapse = "\n") } x <- list(arity = arity, f = f, formatter = formatter) structure(x, class = c("lox_callable", class(x))) } lox_call <- function(callee, arguments, env) UseMethod("lox_call") lox_call.lox_callable <- function(callee, arguments, env) { do.call(callee$f, arguments, envir = env) } arity <- function(callee) UseMethod("arity") arity.lox_callable <- function(callee) { callee$arity } #' @export format.lox_callable <- function(x) { x$formatter() }
[GOAL] C : Type u_1 D : Type u_2 E : Type u_3 inst✝⁶ : Category.{u_6, u_1} C inst✝⁵ : Category.{u_5, u_2} D inst✝⁴ : Category.{?u.20851, u_3} E F : C ⥤ D G : D ⥤ E A : Type u_4 inst✝³ : AddMonoid A inst✝² : HasShift C A inst✝¹ : HasShift D A inst✝ : HasShift E A a b : A e₁ : shiftFunctor C a ⋙ F ≅ F ⋙ shiftFunctor D a e₂ : shiftFunctor C b ⋙ F ≅ F ⋙ shiftFunctor D b X : C ⊢ NatTrans.app (isoAdd e₁ e₂).hom X = F.map (NatTrans.app (shiftFunctorAdd C a b).hom X) ≫ NatTrans.app e₂.hom ((shiftFunctor C a).obj X) ≫ (shiftFunctor D b).map (NatTrans.app e₁.hom X) ≫ NatTrans.app (shiftFunctorAdd D a b).inv (F.obj X) [PROOFSTEP] simp only [isoAdd, isoAdd'_hom_app, shiftFunctorAdd'_eq_shiftFunctorAdd] [GOAL] C : Type u_1 D : Type u_2 E : Type u_3 inst✝⁶ : Category.{u_6, u_1} C inst✝⁵ : Category.{u_5, u_2} D inst✝⁴ : Category.{?u.24197, u_3} E F : C ⥤ D G : D ⥤ E A : Type u_4 inst✝³ : AddMonoid A inst✝² : HasShift C A inst✝¹ : HasShift D A inst✝ : HasShift E A a b : A e₁ : shiftFunctor C a ⋙ F ≅ F ⋙ shiftFunctor D a e₂ : shiftFunctor C b ⋙ F ≅ F ⋙ shiftFunctor D b X : C ⊢ NatTrans.app (isoAdd e₁ e₂).inv X = NatTrans.app (shiftFunctorAdd D a b).hom (F.obj X) ≫ (shiftFunctor D b).map (NatTrans.app e₁.inv X) ≫ NatTrans.app e₂.inv ((shiftFunctor C a).obj X) ≫ F.map (NatTrans.app (shiftFunctorAdd C a b).inv X) [PROOFSTEP] simp only [isoAdd, isoAdd'_inv_app, shiftFunctorAdd'_eq_shiftFunctorAdd] [GOAL] C : Type u_1 D : Type u_2 E : Type u_3 inst✝⁷ : Category.{u_6, u_1} C inst✝⁶ : Category.{u_5, u_2} D inst✝⁵ : Category.{?u.38582, u_3} E F : C ⥤ D G : D ⥤ E A : Type u_4 inst✝⁴ : AddMonoid A inst✝³ : HasShift C A inst✝² : HasShift D A inst✝¹ : HasShift E A inst✝ : CommShift F A a b c : A h : a + b = c ⊢ commShiftIso F c = CommShift.isoAdd' h (commShiftIso F a) (commShiftIso F b) [PROOFSTEP] subst h [GOAL] C : Type u_1 D : Type u_2 E : Type u_3 inst✝⁷ : Category.{u_6, u_1} C inst✝⁶ : Category.{u_5, u_2} D inst✝⁵ : Category.{?u.38582, u_3} E F : C ⥤ D G : D ⥤ E A : Type u_4 inst✝⁴ : AddMonoid A inst✝³ : HasShift C A inst✝² : HasShift D A inst✝¹ : HasShift E A inst✝ : CommShift F A a b : A ⊢ commShiftIso F (a + b) = CommShift.isoAdd' (_ : a + b = a + b) (commShiftIso F a) (commShiftIso F b) [PROOFSTEP] simp only [commShiftIso_add, CommShift.isoAdd]
module Main import Data.Vect data DataStore : Type where MkData : (size : Nat) -> (items : Vect size String) -> DataStore size : DataStore -> Nat size (MkData size items) = size items : (store : DataStore) -> Vect (size store) String items (MkData size items) = items addToStore : DataStore -> String -> DataStore addToStore (MkData size items) newItem = MkData _ (addToData items) where addToData : Vect old String -> Vect (S old) String addToData [] = [newItem] addToData (item :: items2) = item :: addToData items2 data Command = Add String | Get Integer | Search String | Size | Quit parseCommand : String -> String -> Maybe Command parseCommand "add" str = Just (Add str) parseCommand "get" val = case all isDigit (unpack val) of False => Nothing True => Just (Get (cast val)) parseCommand "search" pat = Just (Search pat) parseCommand "size" "" = Just Size parseCommand "quit" "" = Just Quit parseCommand _ _ = Nothing parse : (input : String) -> Maybe Command parse input = case span (/= ' ') input of (cmd, args) => parseCommand cmd (ltrim args) getEntry : (pos : Integer) -> (store : DataStore) -> Maybe (String, DataStore) getEntry pos store = let store_items = items store in case integerToFin pos (size store) of Nothing => Just ("Out of range\n", store) Just id => Just (index id store_items ++ "\n", store) findAllMatches : String -> Integer -> Vect n String -> List (Integer, String) findAllMatches pat idx [] = [] findAllMatches pat idx (x :: xs) = if isInfixOf pat x then (idx, x) :: findAllMatches pat (idx + 1) xs else findAllMatches pat (idx + 1) xs search : String -> DataStore -> List (Integer, String) search pat (MkData size items) = findAllMatches pat 0 items processInput : DataStore -> String -> Maybe (String, DataStore) processInput store inp = case parse inp of Nothing => Just ("Invalid command\n", store) Just (Add item) => Just ("ID " ++ show (size store) ++ "\n", addToStore store item) Just (Get pos) => getEntry pos store Just (Search pat) => Just ("Found: " ++ show (search pat store) ++ "\n", store) Just Size => Just ("Size of store: " ++ show (size store) ++ "\n", store) Just Quit => Nothing main : IO () main = replWith (MkData _ []) "Command: " processInput
The Rupa Lake Cooperative in Nepal. Credit: Bioversity International / B. Saugat. Sourced through Flickr. Responding to the impacts of climate change effectively at national policy and local planning level requires robust and comprehensive information and a strong knowledge base. The potential for this information to provide crucial knowledge in the designing and implementation of climate-resilient policies, plans and programmes is enormous. In 2010, the Government of Nepal established the Nepal Climate Change Knowledge Management Center (NCCKMC) to facilitate the generation, management and dissemination of climate-related knowledge. The Alternative Energy Promotion Centre (AEPC) has established a climate carbon unit to manage knowledge of climate change adaptation and mitigation. The Ministry of Forest and Soil Conservation (MoFSC) has established Reduced Emission from Forest Degradation and Deforestation (REDD) Implementation Centre to manage knowledge related to mitigation and REDD. Similarly, the Ministry of Agriculture and Development (MoAD) has established Agriculture Information Management System (AIMS) to consolidate climate information and develop these into practical agro advisories. Issues have, however, arisen within the climate change knowledge management community about the effective functioning of the knowledge management centres (see "Barriers" below). assess the supply side of knowledge management, with specific focus on the way knowledge and information on climate change is available, processed, packaged and made accessible to those involved in local government planning at sub- national (district) and national level. An overview of the methods used, key barriers and recommendations are provided below. See the full text (download from right-hand column) for much more detail. The study used a mix of methods to generate information. It carried out a desk review to analyse the policy, programmes and projects on managing knowledge of climate change in Nepal. The desk review also analysed the institutional strategy and action plans, particularly of development partners, international and national non-government organisations (I/NGOs) and research institutions related to demand for, and generation and sharing of, knowledge of climate change. Field work was carried out in Rukum and Dang Districts in mid- western region of Nepal. The aim of field work was to assess the demand for and supply of climate change knowledge at district and community level. The study interviewed 64 persons at district and national level to obtain an overview and suggestions on climate change knowledge management at these level. A Google-based online survey tool was used to map the perceptions of stakeholders, particularly to assess the effectiveness of the NCCKMC. Finally, two district- and one national-level stakeholder workshops were organised to draw stakeholders’ feedback on ways to strengthen knowledge management work on climate change in Nepal. the existing knowledge management system has not been able to effectively guide decision-making at policy, planning and implementation level due to its inability to process and package knowledge according to the demand and requirements of the various institutions in the country. NCCKMC should capitalise on the favourable policy environment for climate change to improve climate change-related knowledge management practices. Nepal has significantly progressed in crafting national policies and a framework on climate change. Several national-level institutional mechanisms and financial flow systems provide mechanisms for partly strengthening the implementation of the climate change agenda in Nepal. Policy is, therefore, not a barrier to operationalising a climate change knowledge management system in Nepal. The country, however, lacks a clear vision, strategy and institutional commitment to knowledge generation and management. This is the reason the available knowledge has contributed little to operationalising a knowledge management policy and practices on climate change. There is genuine and strong need for an overarching national strategy and roadmap on knowledge management to streamline ongoing initiatives and responses to climate change. There are opportunities for climate change knowledge management in Nepal. This and other research support the assertion that knowledge management could be streamlined and harmonised if government has clear national and local-level strategies on knowledge, and strong leadership and commitment. Policy, institutions and human resources are not an issue in climate change knowledge management in Nepal. Knowledge management centres have already been established in Nepal. What is needed are joint proactive actions and a harmonised approach to climate change knowledge management among different agencies and stakeholders which can feed into policy making, planning and budgeting. Climate change knowledge management should be mainstreamed within the policy and institutional mandate and work. There is need for state ownership and dedicated institutions to drive climate change knowledge management forward. A multi-stakeholder mechanism should be created for information and knowledge sharing and for learning at different level to allow innovations, ideas and learning to expand and flourish. It is also necessary to mainstream knowledge management within the government and non-government institutions to create a sustainable mechanism for learning and sharing. Research and academic institutions should take the lead role in knowledge generation. Unless existing research institutions take the lead in knowledge generation, there will continue to be a mismatch in demand for and supply of climate change knowledge. Since many grey areas and knowledge gaps have been identified, the government and development agencies should invest in research and knowledge management. This study was undertaken as part of the Climate Proofing Growth and Development (CPGD) project funded by the UK aid from the Department for International Development (DFID). The programme has been branded as Action on Climate Today (ACT). The programme aims to improve resilience by directly incorporating climate change considerations into policy, planning and investment environments within each country. Practical Action is an implementing partner of the ACT programme in Nepal.
State Before: ι : Type u_1 I : Box ι inst✝ : Countable ι ⊢ MeasurableSet ↑I State After: ι : Type u_1 I : Box ι inst✝ : Countable ι ⊢ MeasurableSet (pi univ fun i => Ioc (lower I i) (upper I i)) Tactic: rw [coe_eq_pi] State Before: ι : Type u_1 I : Box ι inst✝ : Countable ι ⊢ MeasurableSet (pi univ fun i => Ioc (lower I i) (upper I i)) State After: no goals Tactic: exact MeasurableSet.univ_pi fun i => measurableSet_Ioc
#!/usr/bin/env Rscript # # This file is part of the `OmnipathR` R package # # Copyright # 2018-2021 # Saez Lab, Uniklinik RWTH Aachen, Heidelberg University # # File author(s): Alberto Valdeolivas # Dénes Türei ([email protected]) # Attila Gábor # # Distributed under the MIT (Expat) License. # See accompanying file `LICENSE` or find a copy at # https://directory.fsf.org/wiki/License:Expat # # Website: https://saezlab.github.io/omnipathr # Git repo: https://github.com/saezlab/OmnipathR # # # Bio Model Analyzer export: converts path to a BMA motif # Author: Ben Hall # #' Ends a function where something has gone wrong, printing information about the error #' @param a string with information about why the error occurred #' @NoRd wrongInput <- function(reason){ cat(reason) return(NULL) } #' Returns a formatted string describing a BMA interaction between variables #' @param a unique id, variable ids describing the source and targets, and the edge description #' @NoRd bmaRelationship <- function(id,from,to,type){ rel <- sprintf('{"Id":%d,"FromVariable":%d,"ToVariable":%d,"Type":"%s"}', id, from, to, type) return(rel) } #' Returns a formatted string describing the model parameters of a BMA variable #' @param a unique id, human readable name (e.g. JAG1), unique variable id, granularity (number of levels) and the formula #' @NoRd bmaVariableModel <- function(id,name,granularity,formula=""){ var <- sprintf('{"Name":"%s","Id":%d,"RangeFrom":0,"RangeTo":%d,"Formula":"%s"}', name, id, granularity, formula) return(var) } #' Returns a formatted string describing the layout parameters of a BMA variable #' @param a unique id, human readable name (e.g. JAG1), granularity (number of levels) and the update formula #' @NoRd bmaVariableLayout <- function(id,name,x,y,description="") { var <- sprintf('{"Id":%d,"Name":"%s","Type":"Constant","ContainerId":0,"PositionX":%f,"PositionY":%f,"CellX":0,"CellY":0,"Angle":0,"Description":"%s"}',id,name,x,y,description) return(var) } #' Returns a string containing the target function of a variable #' #' Returns either empty string (interpreted as default function), or granularity - activity of upstream inhibitor #' @param bool stating whether the interaciton is an inhibition, granularity of #' variables (number of levels), and source of interaction #' @NoRd bmaFormula <- function(inhibitor,granularity,upstream){ f <- ifelse(inhibitor,sprintf("%d-var(%s)",granularity,upstream),"") return(f) } #' Returns a string describing the evidence behind an interaction #' #' Contains all interaction types with a simple descriptor and PMIDs #' @param takes an edge from omnipath "e", and optionally the name of the upstream variable ("incoming") #' @NoRd bmaDescription <- function(e,incoming=""){ sign <- ifelse(e$is_stimulation == 1, ifelse(e$is_inhibition == 1,"Mixed","Activator"), ifelse(e$is_inhibition == 1,"Inhibitor","Unknown")) refs <- paste(unlist(e$references), sep = '', collapse = ',') incoming <- ifelse(incoming == "","",paste("",incoming,"",sep=" ")) return(sprintf("%s%s-PMID:%s.",incoming,sign,refs)) } #' Prints a BMA motif to the screen from a sequence of edges, which can be copy/pasted into the BMA canvas #' #' Intended to parallel print_path_es #' @param takes an sequence of edges, a graph, and a granularity #' @export bmaMotif_es <- function(edgeSeq,G,granularity=2){ if(length(edgeSeq) == 0) { wrongInput("\nempty path\n") } #Process- ## Create list of variables ## Create layout of variables ## Create list of links ## Print format as follows (x is a string, xN is an integer, xF is a float) ### {"Model": {"Name": "Omnipath motif", ### "Variables": [{"Name":"x","Id":xN,"RangeFrom"=0,"RangeTo"=granularity},...] ### "Relationships": [{"Id":xN,"FromVariable":xN,"ToVariable":xN,"Type":"Activator"},...] ### } ### "Layout": {"Variables": [{"Id":xN,"Name":"x","Type":"Constant","ContainerId":0,"PositionX":xF,"PositionY":xF,"CellX":0,"CellY":0,"Angle":0,"Description":""},...] ### "Containers":[] ### } ### } #Code for identifying sign #signs <- ifelse(edgeSeq$is_stimulation == 1, # ifelse(edgeSeq$is_inhibition == 1,"(+/-)","( + )"), # ifelse(edgeSeq$is_inhibition == 1,"( - )","( ? )")) #interaction <- paste0(" == ", signs," == >") #relationships <- ifelse(edgeSeq$is_stimulation == 1, # ifelse(edgeSeq$is_inhibition == 1,"Activator","Activator"), # ifelse(edgeSeq$is_inhibition == 1,"Inhibitor",return(wrongInput("\nUnsigned input graph\n"))) sources <- tail_of(G, edgeSeq)$name variableNames <- c(sources,head_of(G, edgeSeq)$name[length(edgeSeq)]) varNum <- length(variableNames) positions <- vector('list',varNum) variables <- vector('list',varNum) relationships <- vector('list',varNum-1) formula = "" description = "" x=125 y=140 for (i in seq_along(variableNames)) { v <- bmaVariableModel(i,variableNames[i],granularity,formula) p <- bmaVariableLayout(i,variableNames[i],x,y,description) if (i < varNum){ #Simplified sign- if inhibition, inhibitor, else (activator/mixed/unknown) activation r <- bmaRelationship(i+varNum,i,i+1,ifelse(edgeSeq[i]$is_inhibition == 1,"Inhibitor","Activator")) relationships[[i]] <- r formula <- bmaFormula((edgeSeq[i]$is_inhibition == 1),granularity,variableNames[i]) description <- bmaDescription(edgeSeq[i]) } positions[[i]] <- p variables[[i]] <- v x <- x + 86.6025404 ymod <- ifelse(i %% 2 == 0, 50, -50) y <- y + ymod } result <- sprintf('{"Model": {"Name": "Omnipath motif","Variables":[%s],"Relationships":[%s]},"Layout":{"Variables":[%s],"Containers":[]}}\n',paste(variables, sep = '', collapse = ','),paste(relationships, sep = '', collapse = ','),paste(positions, sep = '', collapse = ',')) cat(result) } #' Prints a BMA motif to the screen from a sequence of nodes, which can be copy/pasted into the BMA canvas #' #' Intended to parallel print_path_vs #' @param takes an sequence of nodes, and a granularity #' @export bmaMotif_vs <- function(nodeSeq,G){ if(length(nodeSeq) == 0){ print("empty path") return(invisible(NULL)) } nodeSeq_names <- unique_nodeSeq(nodeSeq) for(i in seq(nodeSeq_names)){ print(paste0("pathway ", i, ": ", paste(nodeSeq_names[[i]],collapse = " -> "))) edgeSet <- c() for(j in 2:length(nodeSeq_names[[i]])){ edgeSet <- c(edgeSet, E(G)[nodeSeq_names[[i]][[j-1]] %->% nodeSeq_names[[i]][[j]]]) } bmaMotif_es(E(G)[edgeSet],G) } }
Require Import Coq.Lists.List. Import ListNotations. Require Import Tactics. Require Import Axioms. Require Import Sigma. Require Import Equality. Require Import Sequence. Require Import Relation. Require Import Ordinal. Require Import Syntax. Require Import SimpSub. Require Import Dynamic. Require Import Ofe. Require Import Uniform. Require Import Intensional. Require Import Candidate. Require Import System. Require Import Semantics. Require Import SemanticsKnot. Require Import Judgement. Require Import Hygiene. Require Import ProperClosed. Require Import ProperFun. Require Import Shut. Require Import SemanticsProperty. Require Import SemanticsEqtype. Require Import SemanticsSubtype. Require Import Equivalence. Require Import ContextHygiene. Require Import Truncate. Require Import ProperDownward. Require Import Subsumption. Local Ltac prove_hygiene := repeat (apply hygiene_auto; cbn; repeat2 split; auto); eauto using hygiene_weaken, clo_min, hygiene_shift', hygiene_subst1, subst_closub; try (apply hygiene_var; cbn; auto; done). Lemma sound_subtype_formation : forall G a a' b b', pseq G (deqtype a a') -> pseq G (deqtype b b') -> pseq G (deqtype (subtype a b) (subtype a' b')). Proof. intros G a b c d. revert G. refine (seq_pseq 0 2 [] _ [] _ _ _); cbn. intros G Hseqab Hseqcd. rewrite -> seq_eqtype in Hseqab, Hseqcd |- *. intros i s s' Hs. so (Hseqab _#3 Hs) as (A & Hal & Har & Hbl & Hbr). so (Hseqcd _#3 Hs) as (C & Hcl & Hcr & Hdl & Hdr). exists (iusubtype stop i A C). simpsub. do2 3 split; apply interp_eval_refl; apply interp_subtype; auto. Qed. Lemma sound_subtype_formation_univ : forall G lv a a' b b', pseq G (deq a a' (univ lv)) -> pseq G (deq b b' (univ lv)) -> pseq G (deq (subtype a b) (subtype a' b') (univ lv)). Proof. intros G lv a b c d. revert G. refine (seq_pseq 0 2 [] _ [] _ _ _); cbn. intros G Hseqab Hseqcd. rewrite -> seq_univ in Hseqab, Hseqcd |- *. intros i s s' Hs. so (Hseqab _#3 Hs) as (pg & A & Hlvl & Hlvr & Hal & Har & Hbl & Hbr). so (Hseqcd _#3 Hs) as (pg' & C & Hlvl' & _ & Hcl & Hcr & Hdl & Hdr). so (pginterp_fun _#3 Hlvl Hlvl'); subst pg'. exists pg, (iusubtype stop i A C). simpsub. do2 5 split; auto; apply interp_eval_refl; apply interp_subtype; auto. Qed. Lemma sound_subtype_intro : forall G a b, pseq G (deqtype a a) -> pseq G (deqtype b b) -> pseq (hyp_tm a :: G) (deq (var 0) (var 0) (subst sh1 b)) -> pseq G (deq triv triv (subtype a b)). Proof. intros G a b. revert G. refine (seq_pseq 0 3 [] _ [] _ [_] _ _ _); cbn. intros G Hseqa Hseqb Hseqincl. rewrite -> seq_eqtype in Hseqa, Hseqb. rewrite -> seq_deq in Hseqincl |- *. intros i s s' Hs. so (Hseqa _#3 Hs) as (A & Hal & Har & _). so (Hseqb _#3 Hs) as (B & Hbl & Hbr & _). exists (iusubtype stop i A B). simpsub. do2 2 split. { apply interp_eval_refl. apply interp_subtype; auto. } { apply interp_eval_refl. apply interp_subtype; auto. } cut (rel (den (iusubtype stop i A B)) i triv triv). { intro H; auto. } cbn. do2 5 split; auto using star_refl; try prove_hygiene. intros j m p Hj Hmp. assert (pwctx j (dot m s) (dot p s') (hyp_tm a :: G)) as Hs'. { apply pwctx_cons_tm_seq; eauto using pwctx_downward. { apply (seqhyp_tm _#5 (iutruncate (S j) A)). { eapply basic_downward; eauto. } { eapply basic_downward; eauto. } { split; auto. } } { intros k u u' Hu. so (Hseqa _#3 Hu) as (R & Hl & Hr & _). eauto. } } so (Hseqincl _#3 Hs') as (R & Hbl' & _ & Hrel & _). simpsubin Hbl'. so (basic_fun _#7 (basic_downward _#7 Hj Hbl) Hbl'); subst R. simpsubin Hrel. destruct Hrel; auto. Qed. Lemma sound_subtype_elim : forall G a b m n, pseq G (deq triv triv (subtype a b)) -> pseq G (deq m n a) -> pseq G (deq m n b). Proof. intros G a b m n. revert G. refine (seq_pseq 0 2 [] _ [] _ _ _); cbn. intros G Hseqsub Hseqmn. rewrite -> seq_deq in Hseqsub, Hseqmn |- *. intros i s s' Hs. so (Hseqsub _#3 Hs) as (R & Hsubl & Hsubr & Hinh & _). simpsubin Hsubl. simpsubin Hsubr. invert (basic_value_inv _#6 value_subtype Hsubl). intros A B Hal Hbl Heq1. invert (basic_value_inv _#6 value_subtype Hsubr). intros A' B' Har Hbr Heq2. so (eqtrans Heq1 (eqsymm Heq2)) as Heq. clear Heq2. subst R. so (iusubtype_inj _#6 Heq) as (<- & <-); clear Heq. cbn in Hinh. decompose Hinh. intros Hsub _ _ _ _ _. unfold subtype_property in Hsub. assert (forall j p q, rel (den A) j p q -> rel (den B) j p q) as Hsub'. { intros j p q Hpq. so (basic_member_index _#9 Hal Hpq) as Hj. apply Hsub; auto. } so (Hseqmn _#3 Hs) as (A' & Hal' & _ & Hm & Hn & Hmn). so (basic_fun _#7 Hal Hal'); subst A'; clear Hal'. exists B. do2 4 split; auto. Qed. Lemma sound_subtype_eta : forall G a b p, pseq G (deq p p (subtype a b)) -> pseq G (deq p triv (subtype a b)). Proof. intros G a b p. revert G. refine (seq_pseq 1 [] p 1 [] _ _ _); cbn. intros G Hclp Hseq. rewrite -> seq_deq in Hseq |- *. intros i s s' Hs. so (pwctx_impl_closub _#4 Hs) as (Hcls & Hcls'). so (Hseq _#3 Hs) as (R & Hequall & Hequalr & Htrue & _). exists R. do2 4 split; auto. { simpsub. simpsubin Hequall. invert (basic_value_inv _#6 value_subtype Hequall). intros Q Q' Hl Hr <-. do2 5 split; auto using star_refl; try prove_hygiene. destruct Htrue as (H & _). exact H. } { simpsub. simpsubin Hequall. invert (basic_value_inv _#6 value_subtype Hequall). intros Q Q' Hl Hr <-. destruct Htrue as (H & _ & _ & _ & Hsteps & _). do2 5 split; auto using star_refl; try prove_hygiene. } Qed. Lemma sound_subtype_eta_hyp : forall G1 G2 a a' m n b, pseq (substctx (dot triv id) G2 ++ G1) (deq m n (subst (under (length G2) (dot triv id)) b)) -> pseq (G2 ++ hyp_tm (subtype a a') :: G1) (deq (subst (under (length G2) sh1) m) (subst (under (length G2) sh1) n) b). Proof. intros G1 G2 a a' m n b Hseq. eapply sound_property_eta_hyp; eauto. intros s pg z i R H. simpsubin H. invert (basic_value_inv _#6 value_subtype H). intros A A' _ _ <-. do 3 eexists. reflexivity. Qed. Lemma sound_subtype_convert_hyp : forall G1 G2 a b J, pseq (cons (hyp_tm (eqtype a a)) G1) (dsubtype (subst sh1 a) (subst sh1 b)) -> pseq (cons (hyp_tm (eqtype a a)) G1) (dsubtype (subst sh1 b) (subst sh1 a)) -> pseq (G2 ++ hyp_tm b :: G1) J -> pseq (G2 ++ hyp_tm a :: G1) J. Proof. intros G1 G2 a b J. revert G1. refine (seq_pseq_hyp 0 3 [] [_] _ [] [_] _ _ [_] _ _ [_] _ _); cbn. intros G1 Hsubab Hsubba Hseq HclJ. so (conj Hsubab Hsubba) as Hexteq. simpsubin Hexteq. rewrite -> seq_exteqtype in Hexteq. clear Hsubab Hsubba. replace J with (substj (under (length G2) id) J) in Hseq by (simpsub; reflexivity). replace G2 with (substctx id G2) in Hseq by (simpsub; reflexivity). refine (subsume_seq _ _ (under (length G2) id) _ _ HclJ _ Hseq). rewrite -> length_substctx. apply subsume_under. do2 2 split. { intros j. split. { intro Hj. cbn. simpsub. apply hygiene_var; auto. } { intro Hj. cbn. simpsubin Hj. invert Hj. auto. } } { intros j. split. { intro Hj. cbn. simpsub. apply hygiene_var; auto. } { intro Hj. cbn. simpsubin Hj. invert Hj. auto. } } intros i ss ss' Hss. invertc Hss. intros m n s s' Hs Hmn Hleft Hright <- <-. simpsubin Hmn. invertc Hmn. intros A Hal Har Hmn. assert (forall j u, j <= i -> seqctx j s u G1 -> pwctx j (dot triv s) (dot triv u) (cons (hyp_tm (eqtype a a)) G1)) as Hsl. { intros j u Hj Hu. apply pwctx_cons_tm; auto. { eapply (seqctx_pwctx_left _ _ s'); auto. eapply pwctx_downward; eauto. } { simpsub. exploit (Hleft j false u) as Hh; auto using smaller_le. cbn in Hh. invertc Hh. intros A' Har' Hau. so (basic_fun _#7 (basic_downward _#7 Hj Har) Har'); subst A'; clear Har'. apply (seqhyp_tm _#5 (iueqtype stop j (iutruncate (S j) A) (iutruncate (S j) A))). { apply interp_eval_refl. apply interp_eqtype; eauto using basic_downward. } { apply interp_eval_refl. apply interp_eqtype; eauto using basic_downward. } { cbn. do2 4 split; auto using star_refl; try prove_hygiene. reflexivity. } } { intros k v Hk Hsv. assert (k <= i) as Hki by omega. exploit (Hleft k false u) as H; eauto using smaller_le. { cbn. eapply (seqctx_downward j); eauto. } cbn in H. invertc H. intros A' Har' Hau. so (basic_fun _#7 (basic_downward _#7 Hki Har) Har'); subst A'; clear Har'. exploit (Hleft k false v) as H; eauto using smaller_le. { cbn. apply pwctx_impl_seqctx; eauto. } cbn in H. invertc H. intros A' Har' Hav. so (basic_fun _#7 (basic_downward _#7 Hki Har) Har'); subst A'; clear Har'. apply (relhyp_tm _#4 (iueqtype stop k (iutruncate (S k) A) (iutruncate (S k) A))). { simpsub. apply interp_eval_refl. apply interp_eqtype; auto. } { simpsub. apply interp_eval_refl. apply interp_eqtype; auto. } } { intros k v Hk Hvu. assert (k <= i) as Hki by omega. exploit (Hright k false v) as H; eauto using smaller_le. { cbn. exact (seqctx_zigzag _#6 (pwctx_impl_seqctx _#4 Hvu) (seqctx_downward _#5 Hk Hu) (seqctx_downward _#5 Hki (pwctx_impl_seqctx _#4 Hs))). } cbn in H. invertc H. intros A' Hal' Hau. so (basic_fun _#7 (basic_downward _#7 Hki Hal) Hal'); subst A'. apply (relhyp_tm _#4 (iueqtype stop k (iutruncate (S k) A) (iutruncate (S k) A))). { simpsub. apply interp_eval_refl. apply interp_eqtype; auto. } { simpsub. apply interp_eval_refl. apply interp_eqtype; auto. } } } assert (forall j u, j <= i -> seqctx j u s' G1 -> pwctx j (dot triv u) (dot triv s') (cons (hyp_tm (eqtype a a)) G1)) as Hsr. { intros j u Hj Hu. apply pwctx_cons_tm; auto. { eapply (seqctx_pwctx_right _ _ s'); auto. eapply pwctx_downward; eauto. } { simpsub. exploit (Hright j false u) as Hh; auto using smaller_le. cbn in Hh. invertc Hh. intros A' Hal' Hau. so (basic_fun _#7 (basic_downward _#7 Hj Hal) Hal'); subst A'; clear Hal'. apply (seqhyp_tm _#5 (iueqtype stop j (iutruncate (S j) A) (iutruncate (S j) A))). { apply interp_eval_refl. apply interp_eqtype; eauto using basic_downward. } { apply interp_eval_refl. apply interp_eqtype; eauto using basic_downward. } { cbn. do2 4 split; auto using star_refl; try prove_hygiene. reflexivity. } } { intros k v Hk Huv. assert (k <= i) as Hki by omega. exploit (Hleft k false v) as H; eauto using smaller_le. { cbn. exact (seqctx_zigzag _#6 (seqctx_downward _#5 Hki (pwctx_impl_seqctx _#4 Hs)) (seqctx_downward _#5 Hk Hu) (pwctx_impl_seqctx _#4 Huv)). } cbn in H. invertc H. intros A' Har' Hau. so (basic_fun _#7 (basic_downward _#7 Hki Har) Har'); subst A'. apply (relhyp_tm _#4 (iueqtype stop k (iutruncate (S k) A) (iutruncate (S k) A))). { simpsub. apply interp_eval_refl. apply interp_eqtype; auto. } { simpsub. apply interp_eval_refl. apply interp_eqtype; auto. } } { intros k v Hk Hsv. assert (k <= i) as Hki by omega. exploit (Hright k false u) as H; eauto using smaller_le. { cbn. eapply (seqctx_downward j); eauto. } cbn in H. invertc H. intros A' Hal' Hau. so (basic_fun _#7 (basic_downward _#7 Hki Hal) Hal'); subst A'; clear Hal'. exploit (Hright k false v) as H; eauto using smaller_le. { cbn. apply pwctx_impl_seqctx; eauto. } cbn in H. invertc H. intros A' Hal' Hav. so (basic_fun _#7 (basic_downward _#7 Hki Hal) Hal'); subst A'; clear Hal'. apply (relhyp_tm _#4 (iueqtype stop k (iutruncate (S k) A) (iutruncate (S k) A))). { simpsub. apply interp_eval_refl. apply interp_eqtype; auto. } { simpsub. apply interp_eval_refl. apply interp_eqtype; auto. } } } so (Hsl i s' (le_refl _) (pwctx_impl_seqctx _#4 Hs)) as Hs'. so (Hexteq _#3 Hs') as (A' & B & Hal' & _ & Hbl & Hbr & Heq). simpsubin Hal'. simpsubin Hbl. simpsubin Hbr. so (basic_fun _#7 Hal Hal'); subst A'. clear Hal'. do2 4 split. { simpsub. apply pwctx_cons_tm; eauto. { eapply seqhyp_tm; eauto. rewrite <- Heq; auto. } { intros j u Hj Hsu. exploit (Hleft j false u) as H. { apply smaller_le; auto. } { cbn. apply pwctx_impl_seqctx; auto. } { cbn in H. invertc H. intros A' Har' Hau. so (basic_fun _#7 (basic_downward _#7 Hj Har) Har'); subst A'. apply (relhyp_tm _#4 (iutruncate (S j) B)); auto. { eapply basic_downward; eauto. } { so (Hexteq _#3 (Hsl _ _ Hj (pwctx_impl_seqctx _#4 Hsu))) as (_ & B' & _ & _ & Hbl' & Hbu & _). simpsubin Hbl'. simpsubin Hbu. so (basic_fun _#7 (basic_downward _#7 Hj Hbl) Hbl'); subst B'; clear Hbl'. auto. } } } { intros j u Hj Hus. exploit (Hright j false u) as H. { apply smaller_le; auto. } { cbn. apply pwctx_impl_seqctx; auto. } { cbn in H. invertc H. intros A' Hal' Hau. so (basic_fun _#7 (basic_downward _#7 Hj Hal) Hal'); subst A'. apply (relhyp_tm _#4 (iutruncate (S j) B)); auto. { eapply basic_downward; eauto. } { so (Hexteq _#3 (Hsr _ _ Hj (pwctx_impl_seqctx _#4 Hus))) as (_ & B' & _ & _ & Hbu & Hbr' & _). simpsubin Hbr'. simpsubin Hbu. so (basic_fun _#7 (basic_downward _#7 Hj Hbr) Hbr'); subst B'; clear Hbr'. auto. } } } } { simpsub. apply equivsub_refl. } { simpsub. apply equivsub_refl. } { intros j d uu Hsmall Huu. simpsubin Huu. simpsub. rewrite -> qpromote_cons in Huu |- *. rewrite -> qpromote_hyp_tm in Huu |- *. invertc Huu. intros p u Hu Hmp <-. so (smaller_impl_le _#3 Hsmall) as Hj. apply seqctx_cons; auto. simpsub. simpsubin Hmp. invertc Hmp. intros B' Hbl' Hbu Hmp. so (basic_fun _#7 (basic_downward _#7 Hj Hbl) Hbl'); subst B'. apply (seqhyp_tm _#5 (iutruncate (S j) A)). { eapply basic_downward; eauto. } { so (seqctx_pwctx_demote_left _#7 Hsmall Hs Hu) as Hu'. so (Hexteq _#3 (Hsl j u Hj (pwctx_impl_seqctx _#4 Hu'))) as (A' & _ & Hal' & Hau & _). simpsubin Hal'. simpsubin Hau. so (basic_fun _#7 (basic_downward _#7 Hj Hal) Hal'); subst A'. exact Hau. } { rewrite -> den_iutruncate in Hmp |- *. destruct Hmp as (_ & Hmp). split; auto. rewrite -> Heq; auto. } } { intros j d uu Hsmall Huu. simpsubin Huu. simpsub. rewrite -> qpromote_cons in Huu |- *. rewrite -> qpromote_hyp_tm in Huu |- *. invertc Huu. intros p u Hu Hmp <-. so (smaller_impl_le _#3 Hsmall) as Hj. apply seqctx_cons; auto. simpsub. simpsubin Hmp. invertc Hmp. intros B' Hbu Hbr' Hmp. so (basic_fun _#7 (basic_downward _#7 Hj Hbr) Hbr'); subst B'. apply (seqhyp_tm _#5 (iutruncate (S j) A)). { so (seqctx_pwctx_demote_right _#7 Hsmall Hs Hu) as Hu'. so (Hexteq _#3 (Hsr j u Hj (pwctx_impl_seqctx _#4 Hu'))) as (A' & _ & Hau & Har' & _). simpsubin Har'. simpsubin Hau. so (basic_fun _#7 (basic_downward _#7 Hj Har) Har'); subst A'. exact Hau. } { eapply basic_downward; eauto. } { rewrite -> den_iutruncate in Hmp |- *. destruct Hmp as (_ & Hmp). split; auto. rewrite -> Heq; auto. } } Qed. Lemma sound_subtype_formation_invert1 : forall G a a' b b', pseq G (deqtype (subtype a b) (subtype a' b')) -> pseq G (deqtype a a'). Proof. intros G a a' b b'. revert G. refine (seq_pseq 0 1 [] _ _ _); cbn. intros G Hseq. rewrite -> seq_eqtype in Hseq |- *. intros i s s' Hs. so (Hseq _#3 Hs) as (R & Hl & Hr & Hl' & Hr'). simpsubin Hl. simpsubin Hl'. simpsubin Hr. simpsubin Hr'. invert (basic_value_inv _#6 value_subtype Hl). intros A B Hal Hbl Heql. invert (basic_value_inv _#6 value_subtype Hr). intros A' B' Har Hbr Heqr. so (iusubtype_inj _#6 (eqtrans Heql (eqsymm Heqr))) as (<- & <-). invert (basic_value_inv _#6 value_subtype Hl'). intros A' B' Hal' Hbl' Heql'. so (iusubtype_inj _#6 (eqtrans Heql (eqsymm Heql'))) as (<- & <-). invert (basic_value_inv _#6 value_subtype Hr'). intros A' B' Har' Hbr' Heqr'. so (iusubtype_inj _#6 (eqtrans Heql (eqsymm Heqr'))) as (<- & <-). exists A. auto. Qed. Lemma sound_subtype_formation_invert2 : forall G a a' b b', pseq G (deqtype (subtype a b) (subtype a' b')) -> pseq G (deqtype b b'). Proof. intros G a a' b b'. revert G. refine (seq_pseq 0 1 [] _ _ _); cbn. intros G Hseq. rewrite -> seq_eqtype in Hseq |- *. intros i s s' Hs. so (Hseq _#3 Hs) as (R & Hl & Hr & Hl' & Hr'). simpsubin Hl. simpsubin Hl'. simpsubin Hr. simpsubin Hr'. invert (basic_value_inv _#6 value_subtype Hl). intros A B Hal Hbl Heql. invert (basic_value_inv _#6 value_subtype Hr). intros A' B' Har Hbr Heqr. so (iusubtype_inj _#6 (eqtrans Heql (eqsymm Heqr))) as (<- & <-). invert (basic_value_inv _#6 value_subtype Hl'). intros A' B' Hal' Hbl' Heql'. so (iusubtype_inj _#6 (eqtrans Heql (eqsymm Heql'))) as (<- & <-). invert (basic_value_inv _#6 value_subtype Hr'). intros A' B' Har' Hbr' Heqr'. so (iusubtype_inj _#6 (eqtrans Heql (eqsymm Heqr'))) as (<- & <-). exists B. auto. Qed.
-- Copyright 2022-2023 VMware, Inc. -- SPDX-License-Identifier: BSD-2-Clause import tactic.omega.main import tactic.linarith import tactic.split_ifs /-! # Streams Definition of streams and some basic properties. We don't use mathlib streams because we hardly need any definitions from it. A stream over a type `a` is a `ℕ → a`. Defines agree_upto n s s', usually written with the notation s ==n== s', which says that s and s' agree on all indices in 0..n (inclusive). -/ universes u v. /-- A stream is an infinite sequence of elements from `a`. The indices usually use the metavariable `t`, meant to represent (a discrete notion of) time. -/ def stream (a: Type u) : Type u := ℕ → a. variable {a : Type u}. /-- s₁ ==n== s₂ says that streams s₁ and s₂ are equal up to (and including) time `n`. -/ def agree_upto (n: ℕ) (s₁ s₂: stream a) := ∀ t ≤ n, s₁ t = s₂ t. notation s ` ==` n `== ` s':35 := agree_upto n s s'. instance stream_po [partial_order a] : partial_order (stream a) := by { unfold stream, apply_instance }. @[ext] lemma stream_le_ext [partial_order a] (s1 s2: stream a) : s1 ≤ s2 = (∀ t, s1 t ≤ s2 t) := rfl. instance stream_zero [has_zero a] : has_zero (stream a) := ⟨λ (_: ℕ), 0⟩. @[refl] lemma agree_refl (n: ℕ) : ∀ (s: stream a), s ==n== s := begin unfold agree_upto, intros s i _, refl, end @[symm] lemma agree_symm (n: ℕ) : ∀ (s1 s2: stream a), s1 ==n== s2 → s2 ==n== s1 := begin unfold agree_upto, intros s1 s2 h12 i hle, rw [h12]; assumption, end @[trans] lemma agree_trans {n: ℕ} : ∀ (s1 s2 s3: stream a), s1 ==n== s2 → s2 ==n== s3 → s1 ==n== s3 := begin unfold agree_upto, intros s1 s2 s3 h12 h23 i hle, rw [h12, h23]; assumption, end -- TODO: these don't seem to do anything (don't help with rewriting) instance agree_upto_refl (n: ℕ) : is_refl (stream a) (agree_upto n) := ⟨agree_refl n⟩. instance agree_upto_symm (n: ℕ) : is_symm (stream a) (agree_upto n) := ⟨agree_symm n⟩. instance agree_upto_trans (n: ℕ) : is_trans (stream a) (agree_upto n) := ⟨agree_trans⟩. instance agree_upto_preorder (n: ℕ) : is_preorder (stream a) (agree_upto n) := ⟨⟩. instance agree_upto_equiv (n: ℕ) : is_equiv (stream a) (agree_upto n) := ⟨⟩. theorem agree_everywhere_eq (s s': stream a) : s = s' ↔ (∀ n, s ==n== s') := begin split, { intros h n, rw h, }, { intros h, funext n, apply (h n), omega, } end lemma agree_upto_weaken {s s': stream a} (n n': ℕ) : s ==n== s' → n' ≤ n → s ==n'== s' := begin intros heq hle, intros i hle_i, apply heq, omega, end lemma agree_upto_weaken1 {s s': stream a} (n: ℕ) : s ==n.succ== s' → s ==n== s' := begin intros heq, apply (agree_upto_weaken n.succ), assumption, omega, end lemma agree_upto_0 (s s': stream a) : s ==0== s' ↔ s 0 = s' 0 := begin unfold agree_upto, split, { intros hagree, apply (hagree 0), omega, }, { intros h0 t hle, have h: (t = 0) := by omega, cc, } end lemma agree_upto_extend (n: nat) (s s': stream a) : s ==n== s' → s n.succ = s' n.succ → s ==n.succ== s' := begin intros hagree heq, intros i hle, have h: (i ≤ n ∨ i = n.succ) := by omega, cases h, { apply hagree, assumption, }, { subst i, assumption, } end -- We don't use this theory because everything is based on [agree_upto], but -- formalize a little bit from the paper. namespace cutting. variables [has_zero a]. /-- Construct a stream that matches `s` up to time `t` and is 0 afterward. -/ def cut (s: stream a) (t: ℕ) : stream a := λ i, if (i < t) then s i else 0. lemma cut_at_0 (s: stream a) : cut s 0 = 0 := begin ext n, unfold cut, rw if_neg, simp, omega, end lemma cut_0 : cut (0 : stream a) = 0 := begin ext n, unfold cut, split_ifs; refl, end theorem cut_cut (s: stream a) (t1 t2: ℕ) : cut (cut s t1) t2 = cut s (min t1 t2) := begin funext i, simp [cut], split_ifs; try { simp }, tauto, { exfalso, linarith, }, { exfalso, linarith, }, end theorem cut_comm (s: stream a) (t1 t2: ℕ) : cut (cut s t1) t2 = cut (cut s t2) t1 := begin rw [cut_cut, cut_cut], rw min_comm, end theorem cut_idem (s: stream a) (t: ℕ) : cut (cut s t) t = cut s t := begin rw cut_cut, simp, end /-- Relate [agree_upto] to equality on [cut]. -/ theorem agree_upto_cut (s1 s2: stream a) (n: ℕ) : s1 ==n== s2 ↔ cut s1 n.succ = cut s2 n.succ := begin split, { intros heq, funext t, simp [cut], split_ifs; try { refl }, apply heq, omega, }, { intros heq, intros t hle, simp [cut] at heq, have h := congr_fun heq t, simp at h, split_ifs at *, { assumption, }, { exfalso, apply h_1, omega, }, }, end lemma cut_agree_succ (s1 s2: stream a) (t: ℕ) : cut s1 t = cut s2 t → s1 t = s2 t → cut s1 t.succ = cut s2 t.succ := begin cases t, { intros _hcut heq, ext n, unfold cut, split_ifs, swap, refl, have heq : n = 0 := by omega, subst n, assumption, }, repeat { rw<- agree_upto_cut }, apply agree_upto_extend, end theorem agree_with_cut (s: stream a) (n: ℕ) : s ==n== cut s n.succ := begin rw [agree_upto_cut, cut_idem], end end cutting. -- #lint only doc_blame simp_nf
$ifndef _REP_REFINE_ $define _REP_REFINE_ $endif
(* Copyright (C) 2020 Susi Lehtola This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/. *) (* type: mgga_exc *) (* prefix: mgga_k_rda_params *params; assert(p->params != NULL); params = (mgga_k_rda_params * ) (p->params); *) rda_s := x -> X2S*x: rda_p := u -> X2S^2*u: (* Equation (61) *) rda_k4 := (s, p, b) -> sqrt(s^4 + b*p^2): (* Equation (63) *) rda_k2 := (s, p, b) -> s^2 + b*p: (* Equation (71); first term is von Weiszäcker according to equation (13) *) rda_f0 := (s, p) -> 5/3*s^2 + params_a_A0 + params_a_A1 * (rda_k4(s,p,params_a_a) / (1 + params_a_beta1*rda_k4(s,p,params_a_a)))^2 + params_a_A2 * (rda_k4(s,p,params_a_b) / (1 + params_a_beta2*rda_k4(s,p,params_a_b)))^4 + params_a_A3 * (rda_k2(s,p,params_a_c) / (1 + params_a_beta3*rda_k2(s,p,params_a_c))): (* Complete functional *) rda_f := (xs, us) -> rda_f0(rda_s(xs), rda_p(us)): f := (rs, z, xt, xs0, xs1, u0, u1, t0, t1) -> mgga_kinetic(rda_f, rs, z, xs0, xs1, u0, u1):
[GOAL] X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b c : X s t : Set X ⊢ ordConnectedComponent s a ∈ 𝓝 a ↔ s ∈ 𝓝 a [PROOFSTEP] refine' ⟨fun h => mem_of_superset h ordConnectedComponent_subset, fun h => _⟩ [GOAL] X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b c : X s t : Set X h : s ∈ 𝓝 a ⊢ ordConnectedComponent s a ∈ 𝓝 a [PROOFSTEP] rcases exists_Icc_mem_subset_of_mem_nhds h with ⟨b, c, ha, ha', hs⟩ [GOAL] case intro.intro.intro.intro X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c✝ : X s t : Set X h : s ∈ 𝓝 a b c : X ha : a ∈ Icc b c ha' : Icc b c ∈ 𝓝 a hs : Icc b c ⊆ s ⊢ ordConnectedComponent s a ∈ 𝓝 a [PROOFSTEP] exact mem_of_superset ha' (subset_ordConnectedComponent ha hs) [GOAL] X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b c : X s t : Set X hd : Disjoint s (closure t) ha : a ∈ s ⊢ (ordConnectedSection (ordSeparatingSet s t))ᶜ ∈ 𝓝[Ici a] a [PROOFSTEP] have hmem : tᶜ ∈ 𝓝[≥] a := by refine' mem_nhdsWithin_of_mem_nhds _ rw [← mem_interior_iff_mem_nhds, interior_compl] exact disjoint_left.1 hd ha [GOAL] X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b c : X s t : Set X hd : Disjoint s (closure t) ha : a ∈ s ⊢ tᶜ ∈ 𝓝[Ici a] a [PROOFSTEP] refine' mem_nhdsWithin_of_mem_nhds _ [GOAL] X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b c : X s t : Set X hd : Disjoint s (closure t) ha : a ∈ s ⊢ tᶜ ∈ 𝓝 a [PROOFSTEP] rw [← mem_interior_iff_mem_nhds, interior_compl] [GOAL] X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b c : X s t : Set X hd : Disjoint s (closure t) ha : a ∈ s ⊢ a ∈ (closure t)ᶜ [PROOFSTEP] exact disjoint_left.1 hd ha [GOAL] X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b c : X s t : Set X hd : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a ⊢ (ordConnectedSection (ordSeparatingSet s t))ᶜ ∈ 𝓝[Ici a] a [PROOFSTEP] rcases exists_Icc_mem_subset_of_mem_nhdsWithin_Ici hmem with ⟨b, hab, hmem', hsub⟩ [GOAL] case intro.intro.intro X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c : X s t : Set X hd : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a b : X hab : a ≤ b hmem' : Icc a b ∈ 𝓝[Ici a] a hsub : Icc a b ⊆ tᶜ ⊢ (ordConnectedSection (ordSeparatingSet s t))ᶜ ∈ 𝓝[Ici a] a [PROOFSTEP] by_cases H : Disjoint (Icc a b) (ordConnectedSection <| ordSeparatingSet s t) [GOAL] case pos X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c : X s t : Set X hd : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a b : X hab : a ≤ b hmem' : Icc a b ∈ 𝓝[Ici a] a hsub : Icc a b ⊆ tᶜ H : Disjoint (Icc a b) (ordConnectedSection (ordSeparatingSet s t)) ⊢ (ordConnectedSection (ordSeparatingSet s t))ᶜ ∈ 𝓝[Ici a] a [PROOFSTEP] exact mem_of_superset hmem' (disjoint_left.1 H) [GOAL] case neg X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c : X s t : Set X hd : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a b : X hab : a ≤ b hmem' : Icc a b ∈ 𝓝[Ici a] a hsub : Icc a b ⊆ tᶜ H : ¬Disjoint (Icc a b) (ordConnectedSection (ordSeparatingSet s t)) ⊢ (ordConnectedSection (ordSeparatingSet s t))ᶜ ∈ 𝓝[Ici a] a [PROOFSTEP] simp only [Set.disjoint_left, not_forall, Classical.not_not] at H [GOAL] case neg X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c : X s t : Set X hd : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a b : X hab : a ≤ b hmem' : Icc a b ∈ 𝓝[Ici a] a hsub : Icc a b ⊆ tᶜ H : ∃ x h, x ∈ ordConnectedSection (ordSeparatingSet s t) ⊢ (ordConnectedSection (ordSeparatingSet s t))ᶜ ∈ 𝓝[Ici a] a [PROOFSTEP] rcases H with ⟨c, ⟨hac, hcb⟩, hc⟩ [GOAL] case neg.intro.intro.intro X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c✝ : X s t : Set X hd : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a b : X hab : a ≤ b hmem' : Icc a b ∈ 𝓝[Ici a] a hsub : Icc a b ⊆ tᶜ c : X hc : c ∈ ordConnectedSection (ordSeparatingSet s t) hac : a ≤ c hcb : c ≤ b ⊢ (ordConnectedSection (ordSeparatingSet s t))ᶜ ∈ 𝓝[Ici a] a [PROOFSTEP] have hsub' : Icc a b ⊆ ordConnectedComponent tᶜ a := subset_ordConnectedComponent (left_mem_Icc.2 hab) hsub [GOAL] case neg.intro.intro.intro X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c✝ : X s t : Set X hd : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a b : X hab : a ≤ b hmem' : Icc a b ∈ 𝓝[Ici a] a hsub : Icc a b ⊆ tᶜ c : X hc : c ∈ ordConnectedSection (ordSeparatingSet s t) hac : a ≤ c hcb : c ≤ b hsub' : Icc a b ⊆ ordConnectedComponent tᶜ a ⊢ (ordConnectedSection (ordSeparatingSet s t))ᶜ ∈ 𝓝[Ici a] a [PROOFSTEP] have hd : Disjoint s (ordConnectedSection (ordSeparatingSet s t)) := disjoint_left_ordSeparatingSet.mono_right ordConnectedSection_subset [GOAL] case neg.intro.intro.intro X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c✝ : X s t : Set X hd✝ : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a b : X hab : a ≤ b hmem' : Icc a b ∈ 𝓝[Ici a] a hsub : Icc a b ⊆ tᶜ c : X hc : c ∈ ordConnectedSection (ordSeparatingSet s t) hac : a ≤ c hcb : c ≤ b hsub' : Icc a b ⊆ ordConnectedComponent tᶜ a hd : Disjoint s (ordConnectedSection (ordSeparatingSet s t)) ⊢ (ordConnectedSection (ordSeparatingSet s t))ᶜ ∈ 𝓝[Ici a] a [PROOFSTEP] replace hac : a < c := hac.lt_of_ne <| Ne.symm <| ne_of_mem_of_not_mem hc <| disjoint_left.1 hd ha [GOAL] case neg.intro.intro.intro X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c✝ : X s t : Set X hd✝ : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a b : X hab : a ≤ b hmem' : Icc a b ∈ 𝓝[Ici a] a hsub : Icc a b ⊆ tᶜ c : X hc : c ∈ ordConnectedSection (ordSeparatingSet s t) hcb : c ≤ b hsub' : Icc a b ⊆ ordConnectedComponent tᶜ a hd : Disjoint s (ordConnectedSection (ordSeparatingSet s t)) hac : a < c ⊢ (ordConnectedSection (ordSeparatingSet s t))ᶜ ∈ 𝓝[Ici a] a [PROOFSTEP] refine' mem_of_superset (Ico_mem_nhdsWithin_Ici (left_mem_Ico.2 hac)) fun x hx hx' => _ [GOAL] case neg.intro.intro.intro X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c✝ : X s t : Set X hd✝ : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a b : X hab : a ≤ b hmem' : Icc a b ∈ 𝓝[Ici a] a hsub : Icc a b ⊆ tᶜ c : X hc : c ∈ ordConnectedSection (ordSeparatingSet s t) hcb : c ≤ b hsub' : Icc a b ⊆ ordConnectedComponent tᶜ a hd : Disjoint s (ordConnectedSection (ordSeparatingSet s t)) hac : a < c x : X hx : x ∈ Ico a c hx' : x ∈ ordConnectedSection (ordSeparatingSet s t) ⊢ False [PROOFSTEP] refine' hx.2.ne (eq_of_mem_ordConnectedSection_of_uIcc_subset hx' hc _) [GOAL] case neg.intro.intro.intro X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c✝ : X s t : Set X hd✝ : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a b : X hab : a ≤ b hmem' : Icc a b ∈ 𝓝[Ici a] a hsub : Icc a b ⊆ tᶜ c : X hc : c ∈ ordConnectedSection (ordSeparatingSet s t) hcb : c ≤ b hsub' : Icc a b ⊆ ordConnectedComponent tᶜ a hd : Disjoint s (ordConnectedSection (ordSeparatingSet s t)) hac : a < c x : X hx : x ∈ Ico a c hx' : x ∈ ordConnectedSection (ordSeparatingSet s t) ⊢ [[x, c]] ⊆ ordSeparatingSet s t [PROOFSTEP] refine' subset_inter (subset_iUnion₂_of_subset a ha _) _ [GOAL] case neg.intro.intro.intro.refine'_1 X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c✝ : X s t : Set X hd✝ : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a b : X hab : a ≤ b hmem' : Icc a b ∈ 𝓝[Ici a] a hsub : Icc a b ⊆ tᶜ c : X hc : c ∈ ordConnectedSection (ordSeparatingSet s t) hcb : c ≤ b hsub' : Icc a b ⊆ ordConnectedComponent tᶜ a hd : Disjoint s (ordConnectedSection (ordSeparatingSet s t)) hac : a < c x : X hx : x ∈ Ico a c hx' : x ∈ ordConnectedSection (ordSeparatingSet s t) ⊢ [[x, c]] ⊆ ordConnectedComponent tᶜ a [PROOFSTEP] exact OrdConnected.uIcc_subset inferInstance (hsub' ⟨hx.1, hx.2.le.trans hcb⟩) (hsub' ⟨hac.le, hcb⟩) [GOAL] case neg.intro.intro.intro.refine'_2 X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c✝ : X s t : Set X hd✝ : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a b : X hab : a ≤ b hmem' : Icc a b ∈ 𝓝[Ici a] a hsub : Icc a b ⊆ tᶜ c : X hc : c ∈ ordConnectedSection (ordSeparatingSet s t) hcb : c ≤ b hsub' : Icc a b ⊆ ordConnectedComponent tᶜ a hd : Disjoint s (ordConnectedSection (ordSeparatingSet s t)) hac : a < c x : X hx : x ∈ Ico a c hx' : x ∈ ordConnectedSection (ordSeparatingSet s t) ⊢ [[x, c]] ⊆ ⋃ (x : X) (_ : x ∈ t), ordConnectedComponent sᶜ x [PROOFSTEP] rcases mem_iUnion₂.1 (ordConnectedSection_subset hx').2 with ⟨y, hyt, hxy⟩ [GOAL] case neg.intro.intro.intro.refine'_2.intro.intro X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c✝ : X s t : Set X hd✝ : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a b : X hab : a ≤ b hmem' : Icc a b ∈ 𝓝[Ici a] a hsub : Icc a b ⊆ tᶜ c : X hc : c ∈ ordConnectedSection (ordSeparatingSet s t) hcb : c ≤ b hsub' : Icc a b ⊆ ordConnectedComponent tᶜ a hd : Disjoint s (ordConnectedSection (ordSeparatingSet s t)) hac : a < c x : X hx : x ∈ Ico a c hx' : x ∈ ordConnectedSection (ordSeparatingSet s t) y : X hyt : y ∈ t hxy : x ∈ ordConnectedComponent sᶜ y ⊢ [[x, c]] ⊆ ⋃ (x : X) (_ : x ∈ t), ordConnectedComponent sᶜ x [PROOFSTEP] refine' subset_iUnion₂_of_subset y hyt (OrdConnected.uIcc_subset inferInstance hxy _) [GOAL] case neg.intro.intro.intro.refine'_2.intro.intro X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c✝ : X s t : Set X hd✝ : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a b : X hab : a ≤ b hmem' : Icc a b ∈ 𝓝[Ici a] a hsub : Icc a b ⊆ tᶜ c : X hc : c ∈ ordConnectedSection (ordSeparatingSet s t) hcb : c ≤ b hsub' : Icc a b ⊆ ordConnectedComponent tᶜ a hd : Disjoint s (ordConnectedSection (ordSeparatingSet s t)) hac : a < c x : X hx : x ∈ Ico a c hx' : x ∈ ordConnectedSection (ordSeparatingSet s t) y : X hyt : y ∈ t hxy : x ∈ ordConnectedComponent sᶜ y ⊢ c ∈ ordConnectedComponent sᶜ y [PROOFSTEP] refine' subset_ordConnectedComponent left_mem_uIcc hxy _ [GOAL] case neg.intro.intro.intro.refine'_2.intro.intro X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c✝ : X s t : Set X hd✝ : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a b : X hab : a ≤ b hmem' : Icc a b ∈ 𝓝[Ici a] a hsub : Icc a b ⊆ tᶜ c : X hc : c ∈ ordConnectedSection (ordSeparatingSet s t) hcb : c ≤ b hsub' : Icc a b ⊆ ordConnectedComponent tᶜ a hd : Disjoint s (ordConnectedSection (ordSeparatingSet s t)) hac : a < c x : X hx : x ∈ Ico a c hx' : x ∈ ordConnectedSection (ordSeparatingSet s t) y : X hyt : y ∈ t hxy : x ∈ ordConnectedComponent sᶜ y ⊢ c ∈ [[y, x]] [PROOFSTEP] suffices c < y by rw [uIcc_of_ge (hx.2.trans this).le] exact ⟨hx.2.le, this.le⟩ [GOAL] X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c✝ : X s t : Set X hd✝ : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a b : X hab : a ≤ b hmem' : Icc a b ∈ 𝓝[Ici a] a hsub : Icc a b ⊆ tᶜ c : X hc : c ∈ ordConnectedSection (ordSeparatingSet s t) hcb : c ≤ b hsub' : Icc a b ⊆ ordConnectedComponent tᶜ a hd : Disjoint s (ordConnectedSection (ordSeparatingSet s t)) hac : a < c x : X hx : x ∈ Ico a c hx' : x ∈ ordConnectedSection (ordSeparatingSet s t) y : X hyt : y ∈ t hxy : x ∈ ordConnectedComponent sᶜ y this : c < y ⊢ c ∈ [[y, x]] [PROOFSTEP] rw [uIcc_of_ge (hx.2.trans this).le] [GOAL] X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c✝ : X s t : Set X hd✝ : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a b : X hab : a ≤ b hmem' : Icc a b ∈ 𝓝[Ici a] a hsub : Icc a b ⊆ tᶜ c : X hc : c ∈ ordConnectedSection (ordSeparatingSet s t) hcb : c ≤ b hsub' : Icc a b ⊆ ordConnectedComponent tᶜ a hd : Disjoint s (ordConnectedSection (ordSeparatingSet s t)) hac : a < c x : X hx : x ∈ Ico a c hx' : x ∈ ordConnectedSection (ordSeparatingSet s t) y : X hyt : y ∈ t hxy : x ∈ ordConnectedComponent sᶜ y this : c < y ⊢ c ∈ Icc x y [PROOFSTEP] exact ⟨hx.2.le, this.le⟩ [GOAL] case neg.intro.intro.intro.refine'_2.intro.intro X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c✝ : X s t : Set X hd✝ : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a b : X hab : a ≤ b hmem' : Icc a b ∈ 𝓝[Ici a] a hsub : Icc a b ⊆ tᶜ c : X hc : c ∈ ordConnectedSection (ordSeparatingSet s t) hcb : c ≤ b hsub' : Icc a b ⊆ ordConnectedComponent tᶜ a hd : Disjoint s (ordConnectedSection (ordSeparatingSet s t)) hac : a < c x : X hx : x ∈ Ico a c hx' : x ∈ ordConnectedSection (ordSeparatingSet s t) y : X hyt : y ∈ t hxy : x ∈ ordConnectedComponent sᶜ y ⊢ c < y [PROOFSTEP] refine' lt_of_not_le fun hyc => _ [GOAL] case neg.intro.intro.intro.refine'_2.intro.intro X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c✝ : X s t : Set X hd✝ : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a b : X hab : a ≤ b hmem' : Icc a b ∈ 𝓝[Ici a] a hsub : Icc a b ⊆ tᶜ c : X hc : c ∈ ordConnectedSection (ordSeparatingSet s t) hcb : c ≤ b hsub' : Icc a b ⊆ ordConnectedComponent tᶜ a hd : Disjoint s (ordConnectedSection (ordSeparatingSet s t)) hac : a < c x : X hx : x ∈ Ico a c hx' : x ∈ ordConnectedSection (ordSeparatingSet s t) y : X hyt : y ∈ t hxy : x ∈ ordConnectedComponent sᶜ y hyc : y ≤ c ⊢ False [PROOFSTEP] have hya : y < a := not_le.1 fun hay => hsub ⟨hay, hyc.trans hcb⟩ hyt [GOAL] case neg.intro.intro.intro.refine'_2.intro.intro X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b✝ c✝ : X s t : Set X hd✝ : Disjoint s (closure t) ha : a ∈ s hmem : tᶜ ∈ 𝓝[Ici a] a b : X hab : a ≤ b hmem' : Icc a b ∈ 𝓝[Ici a] a hsub : Icc a b ⊆ tᶜ c : X hc : c ∈ ordConnectedSection (ordSeparatingSet s t) hcb : c ≤ b hsub' : Icc a b ⊆ ordConnectedComponent tᶜ a hd : Disjoint s (ordConnectedSection (ordSeparatingSet s t)) hac : a < c x : X hx : x ∈ Ico a c hx' : x ∈ ordConnectedSection (ordSeparatingSet s t) y : X hyt : y ∈ t hxy : x ∈ ordConnectedComponent sᶜ y hyc : y ≤ c hya : y < a ⊢ False [PROOFSTEP] exact hxy (Icc_subset_uIcc ⟨hya.le, hx.1⟩) ha [GOAL] X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b c : X s t : Set X hd : Disjoint s (closure t) ha : a ∈ s ⊢ (ordConnectedSection (ordSeparatingSet s t))ᶜ ∈ 𝓝[Iic a] a [PROOFSTEP] have hd' : Disjoint (ofDual ⁻¹' s) (closure <| ofDual ⁻¹' t) := hd [GOAL] X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b c : X s t : Set X hd : Disjoint s (closure t) ha : a ∈ s hd' : Disjoint (↑ofDual ⁻¹' s) (closure (↑ofDual ⁻¹' t)) ⊢ (ordConnectedSection (ordSeparatingSet s t))ᶜ ∈ 𝓝[Iic a] a [PROOFSTEP] have ha' : toDual a ∈ ofDual ⁻¹' s := ha [GOAL] X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b c : X s t : Set X hd : Disjoint s (closure t) ha : a ∈ s hd' : Disjoint (↑ofDual ⁻¹' s) (closure (↑ofDual ⁻¹' t)) ha' : ↑toDual a ∈ ↑ofDual ⁻¹' s ⊢ (ordConnectedSection (ordSeparatingSet s t))ᶜ ∈ 𝓝[Iic a] a [PROOFSTEP] simpa only [dual_ordSeparatingSet, dual_ordConnectedSection] using compl_section_ordSeparatingSet_mem_nhdsWithin_Ici hd' ha' [GOAL] X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b c : X s t : Set X hd : Disjoint s (closure t) ha : a ∈ s ⊢ (ordConnectedSection (ordSeparatingSet s t))ᶜ ∈ 𝓝 a [PROOFSTEP] rw [← nhds_left_sup_nhds_right, mem_sup] [GOAL] X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b c : X s t : Set X hd : Disjoint s (closure t) ha : a ∈ s ⊢ (ordConnectedSection (ordSeparatingSet s t))ᶜ ∈ 𝓝[Iic a] a ∧ (ordConnectedSection (ordSeparatingSet s t))ᶜ ∈ 𝓝[Ici a] a [PROOFSTEP] exact ⟨compl_section_ordSeparatingSet_mem_nhdsWithin_Iic hd ha, compl_section_ordSeparatingSet_mem_nhdsWithin_Ici hd ha⟩ [GOAL] X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b c : X s t : Set X hd : Disjoint s (closure t) x : X hx : x ∈ s ⊢ tᶜ ∈ 𝓝 x [PROOFSTEP] rw [← mem_interior_iff_mem_nhds, interior_compl] [GOAL] X : Type u_1 inst✝² : LinearOrder X inst✝¹ : TopologicalSpace X inst✝ : OrderTopology X a b c : X s t : Set X hd : Disjoint s (closure t) x : X hx : x ∈ s ⊢ x ∈ (closure t)ᶜ [PROOFSTEP] exact disjoint_left.1 hd hx
A function $f$ is continuous on a set $S$ if and only if for every $x \in S$ and every $\epsilon > 0$, there exists a $\delta > 0$ such that for every $x' \in S$, if $|x' - x| < \delta$, then $|f(x') - f(x)| < \epsilon$.
#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION #include <Python.h> #include <numpy/arrayobject.h> #include <lapacke.h> /* DGESVD prototype */ extern void LAPACK_dgesvd( char* jobu, char* jobvt, int* m, int* n, double* a, int* lda, double* s, double* u, int* ldu, double* vt, int* ldvt, double* work, int* lwork, int* info ); double** An(double *pi, double *x, int labs, int dims); double** A(double **PI, double **X, int labs, int dims, int n_pool); double** Fisher(double *pi, double *x, double sigma, int labs, int dims); static char estVar_docstring[] = "Calculate the A and Fisher matrix."; static PyObject *varRedu_estVar(PyObject *self, PyObject *args); static PyMethodDef module_methods[] = { {"estVar", varRedu_estVar, METH_VARARGS, estVar_docstring}, {NULL, NULL, 0, NULL} }; static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, "_variance_reduction", /* m_name */ "This module provides calculate A and Fisher matrix using C.", /* m_doc */ -1, /* m_size */ module_methods, /* m_methods */ NULL, /* m_reload */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ }; PyMODINIT_FUNC PyInit__variance_reduction(void){ PyObject *m = PyModule_Create(&moduledef); if(m==NULL){ return NULL; } /* Load 'numpy' */ import_array(); return m; } double* matrix_mul(double* a, double* b, int m1, int n1, int m2, int n2){ double *ret = (double*) malloc(m1 * n2 * sizeof(double)); if(n1 != m2){ return NULL; } for(int i=0; i<m1; i++) for(int j=0; j<n2; j++){ double temp = 0.0; for(int p=0; p<n1; p++) temp += a[i*n1 + p] * b[p*n2 + j]; ret[i*n2 + j] = temp; } return ret; } void pinv(double** X, int labs, int dims){ int m = labs*dims, n = labs*dims, lda = labs*dims, ldu = labs*dims, ldvt = labs*dims, lwork, info; double wkopt; double *work; double *s = (double*) malloc(labs*dims * sizeof(double)); double *u = (double*) malloc(labs*dims * labs*dims * sizeof(double)); double *vt = (double*) malloc(labs*dims * labs*dims * sizeof(double)); double *a = (double*) malloc(labs*dims * labs*dims * sizeof(double)); for(int i=0; i<m; i++) for(int j=0; j<n; j++) a[i*labs*dims + j] = X[i][j]; /* Query and allocate the optimal workspace */ lwork = -1; LAPACK_dgesvd("All", "All", &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, &wkopt, &lwork, &info); lwork = (int)wkopt; work = (double*)malloc( lwork*sizeof(double) ); /* Compute SVD */ LAPACK_dgesvd("All", "All", &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, &lwork, &info); /* Check for convergence */ if(info > 0) { printf("The algorithm computing SVD failed to converge. %d\n", info); } if(info < 0) { printf("Has illegal value. %d\n", info); } int numSigular = 0; double *si = (double*) malloc(labs*dims * labs*dims * sizeof(double)); memset(si, 0, labs*dims * labs*dims * sizeof(double)); for(int i=0; i<ldu; i++){ if(s[i] > 1e-30){ si[i*ldu + i] = 1.0 / s[i]; numSigular += 1; }else{ si[i+ldu + i] = 0.0; } } /* calculating transpose */ double *ret = matrix_mul(vt, si, labs*dims, numSigular, numSigular, numSigular); double *ret_pinv = matrix_mul(ret, u, labs*dims, numSigular, numSigular, labs*dims); for(int i=0; i<m; i++) for(int j=0; j<n; j++) X[i][j] = ret_pinv[i*n + j]; free(ret); free(ret_pinv); free(work); free(a); free(s); free(vt); free(u); free(si); return; } static PyObject *varRedu_estVar(PyObject *self, PyObject *args) { int dims, n_pool, labs, sigma; PyObject *PI_obj, *X_obj, *ePI_obj, *eX_obj; if (!PyArg_ParseTuple(args, "dOOOO", &sigma, &PI_obj, &X_obj, &ePI_obj, &eX_obj)) return NULL; PyArrayObject *PI_array = (PyArrayObject*)PyArray_FROM_OTF(PI_obj, NPY_DOUBLE, NPY_ARRAY_IN_ARRAY); PyArrayObject *X_array = (PyArrayObject*)PyArray_FROM_OTF(X_obj, NPY_DOUBLE, NPY_ARRAY_IN_ARRAY); PyArrayObject *ePI_array = (PyArrayObject*)PyArray_FROM_OTF(ePI_obj, NPY_DOUBLE, NPY_ARRAY_IN_ARRAY); PyArrayObject *eX_array = (PyArrayObject*)PyArray_FROM_OTF(eX_obj, NPY_DOUBLE, NPY_ARRAY_IN_ARRAY); if (PI_array == NULL || X_array == NULL || ePI_array == NULL || eX_array == NULL) { Py_XDECREF(PI_array); Py_XDECREF(X_array); Py_XDECREF(ePI_array); Py_XDECREF(eX_array); return NULL; } labs = (int)PyArray_DIM(PI_array, 1); n_pool = (int)PyArray_DIM(X_array, 0); dims = (int)PyArray_DIM(X_array, 1); double **PI = (double**) malloc(n_pool * sizeof(double*)); double **X = (double**) malloc(n_pool * sizeof(double*)); for(int i=0; i<n_pool; i++){ PI[i] = (double*) malloc(labs * sizeof(double)); X[i] = (double*) malloc(dims * sizeof(double)); } for(int i=0; i<n_pool; i++){ for(int j=0; j<labs; j++){ PI[i][j] = *(double*)PyArray_GETPTR2(PI_array, i, j); } for(int j=0; j<dims; j++){ X[i][j] = *(double*)PyArray_GETPTR2(X_array, i, j); } } double *ePI = (double*) PyArray_DATA(ePI_array); double *eX = (double*) PyArray_DATA(eX_array); double **retF = Fisher(ePI, eX, sigma, labs, dims); double **retA = A(PI, X, labs, dims, n_pool); pinv(retF, labs, dims); /* calculates the trace of the multiply of pinv(F) and A */ double score = 0.0; for(int i=0; i<dims*labs; i++){ for(int k=0; k<dims*labs; k++){ score += retA[i][k] * retF[k][i]; } } Py_DECREF(PI_array); Py_DECREF(X_array); Py_DECREF(ePI_array); Py_DECREF(eX_array); PyObject* ret = Py_BuildValue("d", score); for(int i=0; i<n_pool; i++){ free(PI[i]); free(X[i]); } free(PI); free(X); for(int i=0; i<labs*dims; i++){ free(retF[i]); free(retA[i]); } free(retF); free(retA); return ret; } double** An(double *pi, double *x, int labs, int dims){ double **g = (double**) malloc(labs*dims * sizeof(double*)); for(int i=0; i<labs*dims; i++){ g[i] = (double*) malloc(labs * sizeof(double)); memset(g[i], 0, labs * sizeof(double)); } for(int p=0; p<labs; p++) for(int i=0; i<dims; i++){ for(int c=0; c<labs; c++) if(p == c) g[p*dims + i][c] = pi[p] * (1.0-pi[p]) * x[i]; else g[p*dims + i][c] = -1.0 * pi[p] * pi[c] * x[i]; } double **an = (double**) malloc(labs*dims * sizeof(double*)); for(int i=0; i<labs*dims; i++){ an[i] = (double*) malloc(labs*dims * sizeof(double)); memset(an[i], 0, labs*dims * sizeof(double)); } for(int p=0; p<labs; p++) for(int i=0; i<dims; i++) for(int q=0; q<labs; q++) for(int j=0; j<dims; j++){ /* inner product */ double tmp = 0.0; for(int k=0; k<labs; k++){ tmp += g[p*dims + i][k] * g[q*dims + j][k]; } an[p*dims + i][q*dims + j] = tmp; } for(int i=0; i<labs*dims; i++) free(g[i]); free(g); return an; } double** A(double **PI, double **X, int labs, int dims, int n_pool){ double **ret = (double**) malloc(labs*dims * sizeof(double*)); for(int i=0; i<labs*dims; i++){ ret[i] = (double*) malloc(labs*dims * sizeof(double)); memset(ret[i], 0, labs*dims * sizeof(double)); } for(int n=0; n<n_pool; n++){ double **an = An(PI[n], X[n], labs, dims); for(int p=0; p<labs; p++) for(int i=0; i<dims; i++) for(int q=0; q<labs; q++) for(int j=0; j<dims; j++) ret[p*dims + i][q*dims + j] += an[p*dims + i][q*dims + j]; for(int i=0; i<labs*dims; i++) free(an[i]); free(an); } return ret; } double** Fisher(double *pi, double *x, double sigma, int labs, int dims){ double **ret = (double**) malloc(labs*dims * sizeof(double*)); for(int i=0; i<labs*dims; i++){ ret[i] = (double*) malloc(labs*dims * sizeof(double*)); memset(ret[i], 0, labs*dims * sizeof(double)); } for(int p=0; p<labs; p++) for(int i=0; i<dims; i++) for(int q=0; q<labs; q++) for(int j=0; j<dims; j++){ if(p == q && i == j) ret[p*dims + i][q*dims + j] = x[i]*x[i]*pi[p]*(1.0-pi[p]) + 1.0/sigma*sigma; else if(p == q && i != j) ret[p*dims + i][q*dims + j] = x[i]*x[j]*pi[p]*(1.0-pi[p]); else ret[p*dims + i][q*dims + j] = x[i]*x[j]*pi[p]*pi[q]; } return ret; }
Formal statement is: lemma homeomorphic_simply_connected: "\<lbrakk>S homeomorphic T; simply_connected S\<rbrakk> \<Longrightarrow> simply_connected T" Informal statement is: If two spaces are homeomorphic and one of them is simply connected, then the other is also simply connected.
lemma pderiv_pcompose: "pderiv (pcompose p q) = pcompose (pderiv p) q * pderiv q"
(* File: Nearest_Neighbors.thy Author: Martin Rau, TU München *) section \<open>Nearest Neighbor Search on the \<open>k\<close>-d Tree\<close> theory Nearest_Neighbors imports KD_Tree "Eval_Base.Eval_Base" begin text \<open> Verifying nearest neighbor search on the k-d tree. Given a \<open>k\<close>-d tree and a point \<open>p\<close>, which might not be in the tree, find the points \<open>ps\<close> that are closest to \<open>p\<close> using the Euclidean metric. \<close> subsection \<open>Auxiliary Lemmas about \<open>sorted_wrt\<close>\<close> lemma assumes "sorted_wrt f xs" shows sorted_wrt_take: "sorted_wrt f (take n xs)" and sorted_wrt_drop: "sorted_wrt f (drop n xs)" proof - have "sorted_wrt f (take n xs @ drop n xs)" using assms by simp thus "sorted_wrt f (take n xs)" "sorted_wrt f (drop n xs)" using sorted_wrt_append by blast+ qed definition sorted_wrt_dist :: "('k::finite) point \<Rightarrow> 'k point list \<Rightarrow> bool" where "sorted_wrt_dist p \<equiv> sorted_wrt (\<lambda>p\<^sub>0 p\<^sub>1. dist p\<^sub>0 p \<le> dist p\<^sub>1 p)" lemma sorted_wrt_dist_insort_key: "sorted_wrt_dist p ps \<Longrightarrow> sorted_wrt_dist p (insort_key (\<lambda>q. dist q p) q ps)" apply2 (induction ps) by (auto simp: sorted_wrt_dist_def set_insort_key) lemma sorted_wrt_dist_take_drop: assumes "sorted_wrt_dist p ps" shows "\<forall>p\<^sub>0 \<in> set (take n ps). \<forall>p\<^sub>1 \<in> set (drop n ps). dist p\<^sub>0 p \<le> dist p\<^sub>1 p" using assms sorted_wrt_append[of _ "take n ps" "drop n ps"] by (simp add: sorted_wrt_dist_def) lemma sorted_wrt_dist_last_take_mono: assumes "sorted_wrt_dist p ps" "n \<le> length ps" "0 < n" shows "dist (last (take n ps)) p \<le> dist (last ps) p" using assms unfolding sorted_wrt_dist_def apply2 (induction ps arbitrary: n) by (auto simp add: take_Cons') lemma sorted_wrt_dist_last_insort_key_eq: assumes "sorted_wrt_dist p ps" "insort_key (\<lambda>q. dist q p) q ps \<noteq> ps @ [q]" shows "last (insort_key (\<lambda>q. dist q p) q ps) = last ps" using assms unfolding sorted_wrt_dist_def apply2 (induction ps) by (auto) lemma sorted_wrt_dist_last: assumes "sorted_wrt_dist p ps" shows "\<forall>q \<in> set ps. dist q p \<le> dist (last ps) p" proof (cases "ps = []") case True thus ?thesis by simp next case False then obtain ps' p' where [simp]:"ps = ps' @ [p']" using rev_exhaust by blast hence "sorted_wrt_dist p (ps' @ [p'])" using assms by blast thus ?thesis unfolding sorted_wrt_dist_def using sorted_wrt_append[of _ ps' "[p']"] by simp qed subsection \<open>Neighbors Sorted wrt. Distance\<close> definition upd_nbors :: "nat \<Rightarrow> ('k::finite) point \<Rightarrow> 'k point \<Rightarrow> 'k point list \<Rightarrow> 'k point list" where "upd_nbors n p q ps = take n (insort_key (\<lambda>q. dist q p) q ps)" lemma sorted_wrt_dist_nbors: assumes "sorted_wrt_dist p ps" shows "sorted_wrt_dist p (upd_nbors n p q ps)" proof - have "sorted_wrt_dist p (insort_key (\<lambda>q. dist q p) q ps)" using assms sorted_wrt_dist_insort_key by blast thus ?thesis by (simp add: sorted_wrt_dist_def sorted_wrt_take upd_nbors_def) qed lemma sorted_wrt_dist_nbors_diff: assumes "sorted_wrt_dist p ps" shows "\<forall>r \<in> set ps \<union> {q} - set (upd_nbors n p q ps). \<forall>s \<in> set (upd_nbors n p q ps). dist s p \<le> dist r p" proof - let ?ps' = "insort_key (\<lambda>q. dist q p) q ps" have "set ps \<union> { q } = set ?ps'" by (simp add: set_insort_key) moreover have "set ?ps' = set (take n ?ps') \<union> set (drop n ?ps')" using append_take_drop_id set_append by metis ultimately have "set ps \<union> { q } - set (take n ?ps') \<subseteq> set (drop n ?ps')" by blast moreover have "sorted_wrt_dist p ?ps'" using assms sorted_wrt_dist_insort_key by blast ultimately show ?thesis unfolding upd_nbors_def using sorted_wrt_dist_take_drop by blast qed lemma sorted_wrt_dist_last_upd_nbors_mono: assumes "sorted_wrt_dist p ps" "n \<le> length ps" "0 < n" shows "dist (last (upd_nbors n p q ps)) p \<le> dist (last ps) p" proof (cases "insort_key (\<lambda>q. dist q p) q ps = ps @ [q]") case True thus ?thesis unfolding upd_nbors_def using assms sorted_wrt_dist_last_take_mono by auto next case False hence "last (insort_key (\<lambda>q. dist q p) q ps) = last ps" using sorted_wrt_dist_last_insort_key_eq assms by blast moreover have "dist (last (upd_nbors n p q ps)) p \<le> dist (last (insort_key (\<lambda>q. dist q p) q ps)) p" unfolding upd_nbors_def using assms sorted_wrt_dist_last_take_mono[of p "insort_key (\<lambda>q. dist q p) q ps"] by (simp add: sorted_wrt_dist_insort_key) ultimately show ?thesis by simp qed subsection \<open>The Recursive Nearest Neighbor Algorithm\<close> fun nearest_nbors :: "nat \<Rightarrow> ('k::finite) point list \<Rightarrow> 'k point \<Rightarrow> 'k kdt \<Rightarrow> 'k point list" where "nearest_nbors n ps p (Leaf q) = upd_nbors n p q ps" | "nearest_nbors n ps p (Node k v l r) = ( if p$k \<le> v then let candidates = nearest_nbors n ps p l in if length candidates = n \<and> dist p (last candidates) \<le> dist v (p$k) then candidates else nearest_nbors n candidates p r else let candidates = nearest_nbors n ps p r in if length candidates = n \<and> dist p (last candidates) \<le> dist v (p$k) then candidates else nearest_nbors n candidates p l )" subsection \<open>Auxiliary Lemmas\<close> lemma cutoff_r: assumes "invar (Node k v l r)" assumes "p$k \<le> v" "dist p c \<le> dist (p$k) v" shows "\<forall>q \<in> set_kdt r. dist p c \<le> dist p q" proof standard fix q assume *: "q \<in> set_kdt r" have "dist p c \<le> dist (p$k) v" using assms(3) by blast also have "... \<le> dist (p$k) v + dist v (q$k)" by simp also have "... = dist (p$k) (q$k)" using * assms(1,2) dist_real_def by auto also have "... \<le> dist p q" using dist_vec_nth_le by blast finally show "dist p c \<le> dist p q" . qed lemma cutoff_l: assumes "invar (Node k v l r)" assumes "v \<le> p$k" "dist p c \<le> dist v (p$k)" shows "\<forall>q \<in> set_kdt l. dist p c \<le> dist p q" proof standard fix q assume *: "q \<in> set_kdt l" have "dist p c \<le> dist v (p$k)" using assms(3) by blast also have "... \<le> dist v (p$k) + dist (q$k) v" by simp also have "... = dist (p$k) (q$k)" using * assms(1,2) dist_real_def by auto also have "... \<le> dist p q" using dist_vec_nth_le by blast finally show "dist p c \<le> dist p q" . qed subsection \<open>The Main Theorems\<close> lemma set_nns: "set (nearest_nbors n ps p kdt) \<subseteq> set_kdt kdt \<union> set ps" apply2 (induction kdt arbitrary: ps) apply (auto simp: Let_def upd_nbors_def set_insort_key) using in_set_takeD set_insort_key by fastforce lemma length_nns: "length (nearest_nbors n ps p kdt) = min n (size_kdt kdt + length ps)" apply2 (induction kdt arbitrary: ps) by (auto simp: Let_def upd_nbors_def) lemma length_nns_gt_0: "0 < n \<Longrightarrow> 0 < length (nearest_nbors n ps p kdt)" apply2 (induction kdt arbitrary: ps) by (auto simp: Let_def upd_nbors_def) lemma length_nns_n: assumes "(set_kdt kdt \<union> set ps) - set (nearest_nbors n ps p kdt) \<noteq> {}" shows "length (nearest_nbors n ps p kdt) = n" using assms proof2 (induction kdt arbitrary: ps) case (Node k v l r) let ?nnsl = "nearest_nbors n ps p l" let ?nnsr = "nearest_nbors n ps p r" consider (A) "p$k \<le> v \<and> length ?nnsl = n \<and> dist p (last ?nnsl) \<le> dist v (p$k)" | (B) "p$k \<le> v \<and> \<not>(length ?nnsl = n \<and> dist p (last ?nnsl) \<le> dist v (p$k))" | (C) "v < p$k \<and> length ?nnsr = n \<and> dist p (last ?nnsr) \<le> dist v (p$k)" | (D) "v < p$k \<and> \<not>(length ?nnsr = n \<and> dist p (last ?nnsr) \<le> dist v (p$k))" by argo thus ?case proof cases case B let ?nns = "nearest_nbors n ?nnsl p r" have "length ?nnsl \<noteq> n \<longrightarrow> (set_kdt l \<union> set ps - set (nearest_nbors n ps p l) = {})" using Node.IH(1) by blast hence "length ?nnsl \<noteq> n \<longrightarrow> (set_kdt r \<union> set ?nnsl - set ?nns \<noteq> {})" using B Node.prems by auto moreover have "length ?nnsl = n \<longrightarrow> ?thesis" using B by (auto simp: length_nns) ultimately show ?thesis using B Node.IH(2) by force next case D let ?nns = "nearest_nbors n ?nnsr p l" have "length ?nnsr \<noteq> n \<longrightarrow> (set_kdt r \<union> set ps - set (nearest_nbors n ps p r) = {})" using Node.IH(2) by blast hence "length ?nnsr \<noteq> n \<longrightarrow> (set_kdt l \<union> set ?nnsr - set ?nns \<noteq> {})" using D Node.prems by auto moreover have "length ?nnsr = n \<longrightarrow> ?thesis" using D by (auto simp: length_nns) ultimately show ?thesis using D Node.IH(1) by force qed auto qed (auto simp: upd_nbors_def min_def set_insort_key) lemma sorted_nns: "sorted_wrt_dist p ps \<Longrightarrow> sorted_wrt_dist p (nearest_nbors n ps p kdt)" using sorted_wrt_dist_nbors apply2 (induction kdt arbitrary: ps) by (auto simp: Let_def) lemma distinct_nns: assumes "invar kdt" "distinct ps" "set ps \<inter> set_kdt kdt = {}" shows "distinct (nearest_nbors n ps p kdt)" using assms proof2 (induction kdt arbitrary: ps) case (Node k v l r) let ?nnsl = "nearest_nbors n ps p l" let ?nnsr = "nearest_nbors n ps p r" have "set ps \<inter> set_kdt l = {}" "set ps \<inter> set_kdt r = {}" using Node.prems(3) by auto hence DCLR: "distinct ?nnsl" "distinct ?nnsr" using Node invar_l invar_r by blast+ have "set ?nnsl \<inter> set_kdt r = {}" "set ?nnsr \<inter> set_kdt l = {}" using Node.prems(1,3) set_nns by fastforce+ hence "distinct (nearest_nbors n ?nnsl p r)" "distinct (nearest_nbors n ?nnsr p l)" using Node.IH(1,2) Node.prems(1,2) DCLR invar_l invar_r by blast+ thus ?case using DCLR by (auto simp add: Let_def) qed (auto simp: upd_nbors_def distinct_insort) theorem dist_nns: assumes "invar kdt" "sorted_wrt_dist p ps" "set ps \<inter> set_kdt kdt = {}" "distinct ps" "0 < n" shows "\<forall>q \<in> set_kdt kdt \<union> set ps - set (nearest_nbors n ps p kdt). dist (last (nearest_nbors n ps p kdt)) p \<le> dist q p" using assms proof2 (induction kdt arbitrary: ps) case (Node k v l r) let ?nnsl = "nearest_nbors n ps p l" let ?nnsr = "nearest_nbors n ps p r" have IHL: "\<forall>q \<in> set_kdt l \<union> set ps - set ?nnsl. dist (last ?nnsl) p \<le> dist q p" using Node.IH(1) Node.prems invar_l invar_set by auto have IHR: "\<forall>q \<in> set_kdt r \<union> set ps - set ?nnsr. dist (last ?nnsr) p \<le> dist q p" using Node.IH(2) Node.prems invar_r invar_set by auto have SORTED_L: "sorted_wrt_dist p ?nnsl" using sorted_nns Node.prems(2) by blast have SORTED_R: "sorted_wrt_dist p ?nnsr" using sorted_nns Node.prems(2) by blast have DISTINCT_L: "distinct ?nnsl" using Node.prems distinct_nns invar_set invar_l by fastforce have DISTINCT_R: "distinct ?nnsr" using Node.prems distinct_nns invar_set invar_r by (metis inf_bot_right inf_sup_absorb inf_sup_aci(3) sup.commute) consider (A) "p$k \<le> v \<and> length ?nnsl = n \<and> dist p (last ?nnsl) \<le> dist v (p$k)" | (B) "p$k \<le> v \<and> \<not>(length ?nnsl = n \<and> dist p (last ?nnsl) \<le> dist v (p$k))" | (C) "v < p$k \<and> length ?nnsr = n \<and> dist p (last ?nnsr) \<le> dist v (p$k)" | (D) "v < p$k \<and> \<not>(length ?nnsr = n \<and> dist p (last ?nnsr) \<le> dist v (p$k))" by argo thus ?case proof cases case A hence "\<forall>q \<in> set_kdt r. dist (last ?nnsl) p \<le> dist q p" using Node.prems(1,2) cutoff_r by (metis dist_commute) thus ?thesis using IHL A by auto next case B let ?nns = "nearest_nbors n ?nnsl p r" have "set ?nnsl \<subseteq> set_kdt l \<union> set ps" "set ps \<inter> set_kdt r = {}" using set_nns Node.prems(1,3) by (simp add: set_nns disjoint_iff_not_equal)+ hence "set ?nnsl \<inter> set_kdt r = {}" using Node.prems(1) by fastforce hence IHLR: "\<forall>q \<in> set_kdt r \<union> set ?nnsl - set ?nns. dist (last ?nns) p \<le> dist q p" using Node.IH(2)[OF _ SORTED_L _ DISTINCT_L Node.prems(5)] Node.prems(1) invar_r by blast have "\<forall>q \<in> set ps - set ?nnsl. dist (last ?nns) p \<le> dist q p" proof standard fix q assume *: "q \<in> set ps - set ?nnsl" hence "length ?nnsl = n" using length_nns_n by blast hence LAST: "dist (last ?nns) p \<le> dist (last ?nnsl) p" using last_nns_mono SORTED_L invar_r Node.prems(1,2,5) by (metis order_refl) have "dist (last ?nnsl) p \<le> dist q p" using IHL * by blast thus "dist (last ?nns) p \<le> dist q p" using LAST by argo qed hence R: "\<forall>q \<in> set_kdt r \<union> set ps - set ?nns. dist (last ?nns) p \<le> dist q p" using IHLR by auto have "\<forall>q \<in> set_kdt l - set ?nnsl. dist (last ?nns) p \<le> dist q p" proof standard fix q assume *: "q \<in> set_kdt l - set ?nnsl" hence "length ?nnsl = n" using length_nns_n by blast hence LAST: "dist (last ?nns) p \<le> dist (last ?nnsl) p" using last_nns_mono SORTED_L invar_r Node.prems(1,2,5) by (metis order_refl) have "dist (last ?nnsl) p \<le> dist q p" using IHL * by blast thus "dist (last ?nns) p \<le> dist q p" using LAST by argo qed hence L: "\<forall>q \<in> set_kdt l - set ?nns. dist (last ?nns) p \<le> dist q p" using IHLR by blast show ?thesis using B R L by auto next case C hence "\<forall>q \<in> set_kdt l. dist (last ?nnsr) p \<le> dist q p" using Node.prems(1,2) cutoff_l by (metis dist_commute less_imp_le) thus ?thesis using IHR C by auto next case D let ?nns = "nearest_nbors n ?nnsr p l" have "set ?nnsr \<subseteq> set_kdt r \<union> set ps" "set ps \<inter> set_kdt l = {}" using set_nns Node.prems(1,3) by (simp add: set_nns disjoint_iff_not_equal)+ hence "set ?nnsr \<inter> set_kdt l = {}" using Node.prems(1) by fastforce hence IHRL: "\<forall>q \<in> set_kdt l \<union> set ?nnsr - set ?nns. dist (last ?nns) p \<le> dist q p" using Node.IH(1)[OF _ SORTED_R _ DISTINCT_R Node.prems(5)] Node.prems(1) invar_l by blast have "\<forall>q \<in> set ps - set ?nnsr. dist (last ?nns) p \<le> dist q p" proof standard fix q assume *: "q \<in> set ps - set ?nnsr" hence "length ?nnsr = n" using length_nns_n by blast hence LAST: "dist (last ?nns) p \<le> dist (last ?nnsr) p" using last_nns_mono SORTED_R invar_l Node.prems(1,2,5) by (metis order_refl) have "dist (last ?nnsr) p \<le> dist q p" using IHR * by blast thus "dist (last ?nns) p \<le> dist q p" using LAST by argo qed hence R: "\<forall>q \<in> set_kdt l \<union> set ps - set ?nns. dist (last ?nns) p \<le> dist q p" using IHRL by auto have "\<forall>q \<in> set_kdt r - set ?nnsr. dist (last ?nns) p \<le> dist q p" proof standard fix q assume *: "q \<in> set_kdt r - set ?nnsr" hence "length ?nnsr = n" using length_nns_n by blast hence LAST: "dist (last ?nns) p \<le> dist (last ?nnsr) p" using last_nns_mono SORTED_R invar_l Node.prems(1,2,5) by (metis order_refl) have "dist (last ?nnsr) p \<le> dist q p" using IHR * by blast thus "dist (last ?nns) p \<le> dist q p" using LAST by argo qed hence L: "\<forall>q \<in> set_kdt r - set ?nns. dist (last ?nns) p \<le> dist q p" using IHRL by blast show ?thesis using D R L by auto qed qed (auto simp: sorted_wrt_dist_nbors_diff upd_nbors_def) subsection \<open>Nearest Neighbors Definition and Theorems\<close> definition nearest_neighbors :: "nat \<Rightarrow> ('k::finite) point \<Rightarrow> 'k kdt \<Rightarrow> 'k point list" where "nearest_neighbors n p kdt = nearest_nbors n [] p kdt" theorem length_nearest_neighbors: "length (nearest_neighbors n p kdt) = min n (size_kdt kdt)" by (simp add: length_nns nearest_neighbors_def) theorem sorted_wrt_dist_nearest_neighbors: "sorted_wrt_dist p (nearest_neighbors n p kdt)" using sorted_nns unfolding nearest_neighbors_def sorted_wrt_dist_def by force theorem distinct_nearest_neighbors: assumes "invar kdt" shows "distinct (nearest_neighbors n p kdt)" using assms by (simp add: distinct_nns nearest_neighbors_def) theorem dist_nearest_neighbors: assumes "invar kdt" "nns = nearest_neighbors n p kdt" shows "\<forall>q \<in> (set_kdt kdt - set nns). \<forall>r \<in> set nns. dist r p \<le> dist q p" proof (cases "0 < n") case True have "\<forall>q \<in> set_kdt kdt - set nns. dist (last nns) p \<le> dist q p" using nearest_neighbors_def dist_nns[OF assms(1), of p "[]", OF _ _ _ True] assms(2) by (simp add: nearest_neighbors_def sorted_wrt_dist_def) hence "\<forall>q \<in> set_kdt kdt - set nns. \<forall>n \<in> set nns. dist n p \<le> dist q p" using assms(2) sorted_wrt_dist_nearest_neighbors[of p n kdt] sorted_wrt_dist_last[of p nns] by force thus ?thesis using nearest_neighbors_def by blast next case False hence "length nns = 0" using assms(2) unfolding nearest_neighbors_def by (auto simp: length_nns) thus ?thesis by simp qed end
"upsetting, traumatic and left with an..." Antenatal care at the Peartree clinic was very good. Sonographer was nice as were the midwives. I have written directly to the Maternity Unit and have since received an apology for the care me and my new born baby received. What concerns me is the posting from a lady who had her baby towards the end of 2010 (response from the Hospital Dec 2010). My baby was born in January 2010 - I wrote to the hospital to complain about our treatment, including massive mis-communication regarding discharge i.e. midwives said I could go home and I wasn't told that I couldn't until 9pm! It seems that the lady who posted her problems suffered exactly the same issue, more than six months after the issue had been raised with the hospital. We're sorry that you had this experience when you gave birth at the QEII recently. We are pleased, however, that you complained because it is very important that such issues are addressed for the benefit of all women using our maternity service. To help with, we will make sure that our midwifery team gets to read your comments.
(* *********************************************************************) (* *) (* The Compcert verified compiler *) (* *) (* Xavier Leroy, INRIA Paris-Rocquencourt *) (* *) (* Copyright Institut National de Recherche en Informatique et en *) (* Automatique. All rights reserved. This file is distributed *) (* 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 file is also distributed *) (* under the terms of the INRIA Non-Commercial License Agreement. *) (* *) (* *********************************************************************) (** Multi-way branches (``switch'' statements) and their compilation to comparison trees. *) Require Import EqNat. Require Import FMaps. Require FMapAVL. Require Import Coqlib. Require Import Integers. Require Import Ordered. Module IntMap := FMapAVL.Make(OrderedInt). Module IntMapF := FMapFacts.Facts(IntMap). (** A multi-way branch is composed of a list of (key, action) pairs, plus a default action. *) Definition table : Type := list (int * nat). Fixpoint switch_target (n: int) (dfl: nat) (cases: table) {struct cases} : nat := match cases with | nil => dfl | (key, action) :: rem => if Int.eq n key then action else switch_target n dfl rem end. (** Multi-way branches are translated to comparison trees. Each node of the tree performs either - an equality against one of the keys; - or a "less than" test against one of the keys; - or a computed branch (jump table) against a range of key values. *) Inductive comptree : Type := | CTaction: nat -> comptree | CTifeq: int -> nat -> comptree -> comptree | CTiflt: int -> comptree -> comptree -> comptree | CTjumptable: int -> int -> list nat -> comptree -> comptree. Fixpoint comptree_match (n: int) (t: comptree) {struct t}: option nat := match t with | CTaction act => Some act | CTifeq key act t' => if Int.eq n key then Some act else comptree_match n t' | CTiflt key t1 t2 => if Int.ltu n key then comptree_match n t1 else comptree_match n t2 | CTjumptable ofs sz tbl t' => if Int.ltu (Int.sub n ofs) sz then list_nth_z tbl (Int.unsigned (Int.sub n ofs)) else comptree_match n t' end. (** The translation from a table to a comparison tree is performed by untrusted Caml code (function [compile_switch] in file [RTLgenaux.ml]). In Coq, we validate a posteriori the result of this function. In other terms, we now develop and prove correct Coq functions that take a table and a comparison tree, and check that their semantics are equivalent. *) Fixpoint split_lt (pivot: int) (cases: table) {struct cases} : table * table := match cases with | nil => (nil, nil) | (key, act) :: rem => let (l, r) := split_lt pivot rem in if Int.ltu key pivot then ((key, act) :: l, r) else (l, (key, act) :: r) end. Fixpoint split_eq (pivot: int) (cases: table) {struct cases} : option nat * table := match cases with | nil => (None, nil) | (key, act) :: rem => let (same, others) := split_eq pivot rem in if Int.eq key pivot then (Some act, others) else (same, (key, act) :: others) end. Fixpoint split_between (ofs sz: int) (cases: table) {struct cases} : IntMap.t nat * table := match cases with | nil => (IntMap.empty nat, nil) | (key, act) :: rem => let (inside, outside) := split_between ofs sz rem in if Int.ltu (Int.sub key ofs) sz then (IntMap.add key act inside, outside) else (inside, (key, act) :: outside) end. Definition refine_low_bound (v lo: Z) := if zeq v lo then lo + 1 else lo. Definition refine_high_bound (v hi: Z) := if zeq v hi then hi - 1 else hi. Fixpoint validate_jumptable (cases: IntMap.t nat) (default: nat) (tbl: list nat) (n: int) {struct tbl} : bool := match tbl with | nil => true | act :: rem => beq_nat act (match IntMap.find n cases with Some a => a | None => default end) && validate_jumptable cases default rem (Int.add n Int.one) end. Fixpoint validate (default: nat) (cases: table) (t: comptree) (lo hi: Z) {struct t} : bool := match t with | CTaction act => match cases with | nil => beq_nat act default | (key1, act1) :: _ => zeq (Int.unsigned key1) lo && zeq lo hi && beq_nat act act1 end | CTifeq pivot act t' => match split_eq pivot cases with | (None, _) => false | (Some act', others) => beq_nat act act' && validate default others t' (refine_low_bound (Int.unsigned pivot) lo) (refine_high_bound (Int.unsigned pivot) hi) end | CTiflt pivot t1 t2 => match split_lt pivot cases with | (lcases, rcases) => validate default lcases t1 lo (Int.unsigned pivot - 1) && validate default rcases t2 (Int.unsigned pivot) hi end | CTjumptable ofs sz tbl t' => let tbl_len := list_length_z tbl in match split_between ofs sz cases with | (inside, outside) => zle (Int.unsigned sz) tbl_len && zle tbl_len Int.max_signed && validate_jumptable inside default tbl ofs && validate default outside t' lo hi end end. Definition validate_switch (default: nat) (cases: table) (t: comptree) := validate default cases t 0 Int.max_unsigned. (** Correctness proof for validation. *) Lemma split_eq_prop: forall v default n cases optact cases', split_eq n cases = (optact, cases') -> switch_target v default cases = (if Int.eq v n then match optact with Some act => act | None => default end else switch_target v default cases'). Proof. induction cases; simpl; intros until cases'. intros. inversion H; subst. simpl. destruct (Int.eq v n); auto. destruct a as [key act]. case_eq (split_eq n cases). intros same other SEQ. rewrite (IHcases _ _ SEQ). predSpec Int.eq Int.eq_spec key n; intro EQ; inversion EQ; simpl. subst n. destruct (Int.eq v key). auto. auto. predSpec Int.eq Int.eq_spec v key. subst v. predSpec Int.eq Int.eq_spec key n. congruence. auto. auto. Qed. Lemma split_lt_prop: forall v default n cases lcases rcases, split_lt n cases = (lcases, rcases) -> switch_target v default cases = (if Int.ltu v n then switch_target v default lcases else switch_target v default rcases). Proof. induction cases; intros until rcases; simpl. intro. inversion H; subst. simpl. destruct (Int.ltu v n); auto. destruct a as [key act]. case_eq (split_lt n cases). intros lc rc SEQ. rewrite (IHcases _ _ SEQ). case_eq (Int.ltu key n); intros; inv H0; simpl. predSpec Int.eq Int.eq_spec v key. subst v. rewrite H. auto. auto. predSpec Int.eq Int.eq_spec v key. subst v. rewrite H. auto. auto. Qed. Lemma split_between_prop: forall v default ofs sz cases inside outside, split_between ofs sz cases = (inside, outside) -> switch_target v default cases = (if Int.ltu (Int.sub v ofs) sz then match IntMap.find v inside with Some a => a | None => default end else switch_target v default outside). Proof. induction cases; intros until outside; simpl. intros. inv H. simpl. destruct (Int.ltu (Int.sub v ofs) sz); auto. destruct a as [key act]. case_eq (split_between ofs sz cases). intros ins outs SEQ. rewrite (IHcases _ _ SEQ). case_eq (Int.ltu (Int.sub key ofs) sz); intros; inv H0; simpl. rewrite IntMapF.add_o. predSpec Int.eq Int.eq_spec v key. subst v. rewrite H. rewrite dec_eq_true. auto. rewrite dec_eq_false; auto. case_eq (Int.ltu (Int.sub v ofs) sz); intros; auto. predSpec Int.eq Int.eq_spec v key. subst v. congruence. auto. Qed. Lemma validate_jumptable_correct_rec: forall cases default tbl base v, validate_jumptable cases default tbl base = true -> 0 <= Int.unsigned v < list_length_z tbl -> list_nth_z tbl (Int.unsigned v) = Some(match IntMap.find (Int.add base v) cases with Some a => a | None => default end). Proof. induction tbl; intros until v; simpl. unfold list_length_z; simpl. intros. omegaContradiction. rewrite list_length_z_cons. intros. destruct (andb_prop _ _ H). clear H. generalize (beq_nat_eq _ _ (sym_equal H1)). clear H1. intro. subst a. destruct (zeq (Int.unsigned v) 0). unfold Int.add. rewrite e. rewrite Zplus_0_r. rewrite Int.repr_unsigned. auto. assert (Int.unsigned (Int.sub v Int.one) = Int.unsigned v - 1). unfold Int.sub. change (Int.unsigned Int.one) with 1. apply Int.unsigned_repr. split. omega. generalize (Int.unsigned_range_2 v). omega. replace (Int.add base v) with (Int.add (Int.add base Int.one) (Int.sub v Int.one)). rewrite <- IHtbl. rewrite H. auto. auto. rewrite H. omega. rewrite Int.sub_add_opp. rewrite Int.add_permut. rewrite Int.add_assoc. replace (Int.add Int.one (Int.neg Int.one)) with Int.zero. rewrite Int.add_zero. apply Int.add_commut. apply Int.mkint_eq. reflexivity. Qed. Lemma validate_jumptable_correct: forall cases default tbl ofs v sz, validate_jumptable cases default tbl ofs = true -> Int.ltu (Int.sub v ofs) sz = true -> Int.unsigned sz <= list_length_z tbl -> list_nth_z tbl (Int.unsigned (Int.sub v ofs)) = Some(match IntMap.find v cases with Some a => a | None => default end). Proof. intros. exploit Int.ltu_inv; eauto. intros. rewrite (validate_jumptable_correct_rec cases default tbl ofs). rewrite Int.sub_add_opp. rewrite Int.add_permut. rewrite <- Int.sub_add_opp. rewrite Int.sub_idem. rewrite Int.add_zero. auto. auto. omega. Qed. Lemma validate_correct_rec: forall default v t cases lo hi, validate default cases t lo hi = true -> lo <= Int.unsigned v <= hi -> comptree_match v t = Some (switch_target v default cases). Proof. Opaque Int.sub. induction t; simpl; intros until hi. (* base case *) destruct cases as [ | [key1 act1] cases1]; intros. replace n with default. reflexivity. symmetry. apply beq_nat_eq. auto. destruct (andb_prop _ _ H). destruct (andb_prop _ _ H1). clear H H1. assert (Int.unsigned key1 = lo). eapply proj_sumbool_true; eauto. assert (lo = hi). eapply proj_sumbool_true; eauto. assert (Int.unsigned v = Int.unsigned key1). omega. replace n with act1. simpl. unfold Int.eq. rewrite H5. rewrite zeq_true. auto. symmetry. apply beq_nat_eq. auto. (* eq node *) case_eq (split_eq i cases). intros optact cases' EQ. destruct optact as [ act | ]. 2: congruence. intros. destruct (andb_prop _ _ H). clear H. rewrite (split_eq_prop v default _ _ _ _ EQ). predSpec Int.eq Int.eq_spec v i. f_equal. apply beq_nat_eq; auto. eapply IHt. eauto. assert (Int.unsigned v <> Int.unsigned i). rewrite <- (Int.repr_unsigned v) in H. rewrite <- (Int.repr_unsigned i) in H. congruence. split. unfold refine_low_bound. destruct (zeq (Int.unsigned i) lo); omega. unfold refine_high_bound. destruct (zeq (Int.unsigned i) hi); omega. (* lt node *) case_eq (split_lt i cases). intros lcases rcases EQ V RANGE. destruct (andb_prop _ _ V). clear V. rewrite (split_lt_prop v default _ _ _ _ EQ). unfold Int.ltu. destruct (zlt (Int.unsigned v) (Int.unsigned i)). eapply IHt1. eauto. omega. eapply IHt2. eauto. omega. (* jumptable node *) case_eq (split_between i i0 cases). intros ins outs EQ V RANGE. destruct (andb_prop _ _ V). clear V. destruct (andb_prop _ _ H). clear H. destruct (andb_prop _ _ H1). clear H1. rewrite (split_between_prop v _ _ _ _ _ _ EQ). case_eq (Int.ltu (Int.sub v i) i0); intros. eapply validate_jumptable_correct; eauto. eapply proj_sumbool_true; eauto. eapply IHt; eauto. Qed. Definition table_tree_agree (default: nat) (cases: table) (t: comptree) : Prop := forall v, comptree_match v t = Some(switch_target v default cases). Theorem validate_switch_correct: forall default t cases, validate_switch default cases t = true -> table_tree_agree default cases t. Proof. unfold validate_switch, table_tree_agree; intros. eapply validate_correct_rec; eauto. apply Int.unsigned_range_2. Qed.
#redirect Davis Timebank
State Before: α : Type u inst✝² : Group α inst✝¹ : LE α inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1 a b c d : α ⊢ b⁻¹ * a ≤ c ↔ a ≤ b * c State After: no goals Tactic: rw [← mul_le_mul_iff_left b, mul_inv_cancel_left]
@testset "Manopt Cyclic Proximal Point" begin using Dates n = 100 N = Power(Circle(),(n,)) f = PowPoint(artificialS1Signal(n)) F = x -> costL2TV(N,f,0.5,x) proxes = [ (λ,x) -> proxDistance(N,λ,f,x), (λ,x) -> proxTV(N,0.5*λ,x) ] fR,rec = cyclicProximalPoint(N,F,proxes, f; λ = i -> π/(2*i), stoppingCriterion = stopWhenAll( stopAfter(Second(10)), stopAfterIteration(5000) ), debug = [DebugIterate()," ",DebugCost()," ",DebugProximalParameter(),"\n",10000], record = [RecordProximalParameter(), RecordIterate(f), RecordCost()] ) @test F(f) > F(fR) # o = CyclicProximalPointOptions(f, stopAfterIteration(1), i -> π/(2*i)) p = ProximalProblem(N,F,proxes,[1,2]) @test_throws ErrorException getProximalMap(p,1.,f,3) end
module PotentialDB using Reexport @reexport using PotentialCalculation export CASnumber, PotentialRegistry, addpotential!, defaultregistry, listpotentials, loadpotential, saveregistry include("potentialregistry.jl") using .potentialregistry end # module
(** Just an union-find *) Require Import Arith.Peano_dec. Require Import String. Require Import List. Require Import Cybele.Cybele. Require Import Cybele.DataStructures. Set Implicit Arguments. Set Transparent Obligation. Import Monad ListNotations. (** Normal union-find with array of integers *) Module UnionFind. Definition Sig: Sig.t := Sig.Make nil ((Array.internal_t nat: Type) :: nil). Definition Array := Array.t Sig nat. Definition M := M Sig. (** The representative of [i] *) Definition Find (array: Array) (i: nat): M nat := fix_ (fun f i => let! j := Array.read array i in match eq_nat_dec i j with | left _ => ret i | right _ => f j end) i. (** Merge the equivalent classes of [i] and [j] *) Definition Unify (array: Array) (i j: nat): M unit := let! i' := Find array i in let! j' := Find array j in Array.write array i' j'. (** Do the union-find with a list of equalities and return the list of representatives *) Definition UnionFind (n: nat) (unions: list (nat * nat)) : M (list nat) := let! array := tmp_ref Sig 0 (seq 0 n) in do! List.iter (fun (ij: nat * nat) => let (i, j) := ij in Unify array i j) unions in Array.to_list array. Definition Eval (n: nat) (l: list (nat * nat)) (nb_steps: nat) := UnionFind n l (State.of_prophecy (Prophecy.of_nat _ nb_steps)). Compute Eval 10 nil 0. Compute Eval 10 [(0, 1); (0, 0); (2, 9); (1, 4); (4, 1)] 2. End UnionFind.
Name: Alex Loyd This is Alex with several of his friends. Biography: Alex Loyd is a happygolucky fellow who is grateful for his friends and his lifestyle. He is currently the drummer for a high school Music Scene band which has yet to be named. The band consists of his friends Eddie, Jackson, Max, Jack, and himself. His favorite hobbies include playing copious amounts of video games, watching tv, listening to music, eating, and hanging out with friends. Alex can often be seen hanging out with at least 2 friends, earphones draped around his neck and bottle of coke in hand. He is a sharp boy with a good sense of humor. He is generally happy and very outgoing. Everyone loves Alex.
Load LFindLoad. From lfind Require Import LFind. From QuickChick Require Import QuickChick. From adtind Require Import goal31. Derive Show for natural. Derive Arbitrary for natural. Instance Dec_Eq_natural : Dec_Eq natural. Proof. dec_eq. Qed. Derive Show for lst. Derive Arbitrary for lst. Instance Dec_Eq_lst : Dec_Eq lst. Proof. dec_eq. Qed. Lemma lfind_hyp_test : (@eq lst (qreva (qreva (Nil) Nil) Nil) (Nil)). Admitted. QuickChick lfind_hyp_test.
module Sixel.Helpers import Data.Buffer import Sixel.Library import Sixel.Symbols import Sixel.Allocator %foreign (sixel "sixel_helper_get_additional_message") sixel_helper_get_additional_message : String %foreign (sixel "sixel_helper_set_additional_message") sixel_helper_set_additional_message : String -> () %foreign (sixel "sixel_helper_format_error") sixel_helper_format_error : Int -> String export %inline getAdditionalMessage : String getAdditionalMessage = sixel_helper_get_additional_message export %inline setAdditionalMessage : String -> IO () setAdditionalMessage = pure . sixel_helper_set_additional_message export %inline format : Status -> String format (MkStatus s) = sixel_helper_format_error s
import algebra.homology.exact import category_theory.abelian.opposite import category_theory.abelian.exact import category_theory.limits.constructions.epi_mono import category_theory.abelian.pseudoelements noncomputable theory open category_theory open category_theory.limits universes w v u namespace list variables {α : Type*} (a : α) (L : list α) (m n : ℕ) /-- Returns the sublist of `L` starting at index `m` of length `n` (or shorter, if `L` is too short). -/ def extract := (L.drop m).take n @[simp] lemma extract_nil : [].extract m n = ([] : list α) := by { cases n, refl, cases m, refl, refl } @[simp] lemma extract_zero_right : L.extract m 0 = [] := rfl @[simp] lemma extract_cons_succ_left : (a :: L).extract m.succ n = L.extract m n := rfl end list example : [0,1,2,3,4,5,6,7,8,9].extract 4 3 = [4,5,6] := rfl namespace category_theory variables (𝒞 : Type u) [category.{v} 𝒞] variables [has_zero_morphisms 𝒞] [has_images 𝒞] [has_kernels 𝒞] variables {𝒜 : Type u} [category.{v} 𝒜] [abelian 𝒜] namespace exact -- move this variables {A B C : 𝒜} (f : A ⟶ B) (g : B ⟶ C) def kernel_op_iso : (kernel f.op).unop ≅ cokernel f := { hom := (kernel.lift _ (cokernel.π f).op begin simp [← op_comp, limits.cokernel.condition], end).unop ≫ eq_to_hom (opposite.unop_op (cokernel f)), inv := cokernel.desc _ (eq_to_hom (opposite.unop_op B).symm ≫ (kernel.ι f.op).unop) begin dsimp, rw [category.id_comp, ← f.unop_op, ← unop_comp, f.unop_op, kernel.condition], refl, end, hom_inv_id' := begin dsimp, simp, rw [← unop_id, ← (cokernel.desc f (kernel.ι f.op).unop _).unop_op, ← unop_comp], congr' 1, apply limits.equalizer.hom_ext, dsimp, simp [← op_comp], end, inv_hom_id' := begin apply limits.coequalizer.hom_ext, dsimp, simp [← unop_comp], end } def cokernel_op_iso : (cokernel f.op).unop ≅ kernel f := { hom := kernel.lift _ ((cokernel.π f.op).unop ≫ eq_to_hom (opposite.unop_op _)) begin simp only [eq_to_hom_refl, category.comp_id], rw [← f.unop_op, ← unop_comp, f.op.op_unop, cokernel.condition], refl, end, inv := eq_to_hom (opposite.unop_op _).symm ≫ (cokernel.desc _ (kernel.ι f).op (by simp [← op_comp])).unop, hom_inv_id' := begin simp only [category.id_comp, eq_to_hom_refl, category.comp_id, ← unop_id, ← unop_comp], rw [← (kernel.lift f (cokernel.π f.op).unop _).unop_op, ← unop_comp], congr' 1, apply limits.coequalizer.hom_ext, dsimp, simp [← op_comp], end, inv_hom_id' := begin apply limits.equalizer.hom_ext, dsimp, simp [← unop_comp] end } . @[simp] lemma kernel.ι_op : (kernel.ι f.op).unop = eq_to_hom (opposite.unop_op _) ≫ cokernel.π f ≫ (kernel_op_iso f).inv := begin dsimp [kernel_op_iso], simp, end @[simp] lemma cokernel.π_op : (cokernel.π f.op).unop = (cokernel_op_iso f).hom ≫ kernel.ι f ≫ eq_to_hom (opposite.unop_op _).symm := begin dsimp [cokernel_op_iso], simp, end variables {f g} lemma op (h : exact f g) : exact g.op f.op := begin rw abelian.exact_iff, refine ⟨_, _⟩, { simp only [← op_comp, h.w, op_zero], }, apply_fun quiver.hom.unop, swap, { exact quiver.hom.unop_inj }, simp only [h, unop_comp, cokernel.π_op, eq_to_hom_refl, kernel.ι_op, category.id_comp, category.assoc, kernel_comp_cokernel_assoc, zero_comp, comp_zero, unop_zero], end variables (f g) def kernel_unop_iso {C B : 𝒜ᵒᵖ} (f : C ⟶ B) : opposite.op (kernel f.unop) ≅ cokernel f := { hom := (kernel.lift _ (cokernel.π f).unop (by simp [← unop_comp])).op ≫ eq_to_hom (opposite.op_unop (cokernel f)), inv := cokernel.desc _ (eq_to_hom (opposite.op_unop _).symm ≫ (kernel.ι f.unop).op) begin dsimp, rw [← f.op_unop, category.id_comp, ← op_comp, f.op_unop, kernel.condition], refl, end, hom_inv_id' := begin dsimp, simp, rw [← (cokernel.desc f (kernel.ι f.unop).op _).op_unop, ← op_comp, ← op_id], congr' 1, apply limits.equalizer.hom_ext, dsimp, simp [← unop_comp], end, inv_hom_id' := begin apply limits.coequalizer.hom_ext, dsimp, simp [← op_comp], end } def cokernel_unop_iso {C B : 𝒜ᵒᵖ} (f : C ⟶ B) : opposite.op (cokernel f.unop) ≅ kernel f := { hom := kernel.lift _ ((cokernel.π f.unop).op ≫ eq_to_hom (opposite.op_unop _)) begin dsimp, rw [← f.op_unop, category.comp_id, ← op_comp, f.op_unop, cokernel.condition], refl, end, inv := eq_to_hom (opposite.op_unop _).symm ≫ (cokernel.desc _ (kernel.ι f).unop (by simp [← unop_comp])).op, hom_inv_id' := begin dsimp, rw category.id_comp, rw [← (kernel.lift f ((cokernel.π f.unop).op ≫ 𝟙 C) _).op_unop, ← op_comp, ← op_id], congr' 1, apply limits.coequalizer.hom_ext, dsimp, simp [← unop_comp], end, inv_hom_id' := begin apply limits.equalizer.hom_ext, dsimp, simp [← op_comp] end } @[simp] lemma cokernel.π_unop {C B : 𝒜ᵒᵖ} (f : C ⟶ B) : (cokernel.π f.unop).op = (cokernel_unop_iso f).hom ≫ kernel.ι f ≫ eq_to_hom (opposite.op_unop _).symm := begin dsimp [cokernel_unop_iso], simp, end @[simp] lemma kernel.ι_unop {C B : 𝒜ᵒᵖ} (f : C ⟶ B) : (kernel.ι f.unop).op = eq_to_hom (opposite.op_unop _) ≫ cokernel.π f ≫ (kernel_unop_iso f).inv := begin dsimp [kernel_unop_iso], simp, end lemma unop {C B A : 𝒜ᵒᵖ} {g : C ⟶ B} {f : B ⟶ A} (h : exact g f) : exact f.unop g.unop := begin rw abelian.exact_iff, refine ⟨by simp only [← unop_comp, h.w, unop_zero], _⟩, apply_fun quiver.hom.op, swap, { exact quiver.hom.op_inj }, simp [h], end end exact /-- A sequence `[f, g, ...]` of morphisms is exact if the pair `(f,g)` is exact, and the sequence `[g, ...]` is exact. Recall that the pair `(f,g)` is exact if `f ≫ g = 0` and the natural map from the image of `f` to the kernel of `g` is an epimorphism (equivalently, in abelian categories: isomorphism). -/ inductive exact_seq : list (arrow 𝒞) → Prop | nil : exact_seq [] | single : ∀ f, exact_seq [f] | cons : ∀ {A B C : 𝒞} (f : A ⟶ B) (g : B ⟶ C) (hfg : exact f g) (L) (hgL : exact_seq (g :: L)), exact_seq (f :: g :: L) variable {𝒞} lemma exact_iff_exact_seq {A B C : 𝒞} (f : A ⟶ B) (g : B ⟶ C) : exact f g ↔ exact_seq 𝒞 [f, g] := begin split, { intro h, exact exact_seq.cons f g h _ (exact_seq.single _), }, { rintro (_ | _ | ⟨A, B, C, f, g, hfg, _, _ | _ | _⟩), exact hfg, } end namespace exact_seq lemma extract : ∀ {L : list (arrow 𝒞)} (h : exact_seq 𝒞 L) (m n : ℕ), exact_seq 𝒞 (L.extract m n) | L (nil) m n := by { rw list.extract_nil, exact nil } | L (single f) m 0 := nil | L (single f) 0 (n+1) := by { cases n; exact single f } | L (single f) (m+1) (n+1) := by { cases m; exact nil } | _ (cons f g hfg L hL) (m+1) n := extract hL m n | _ (cons f g hfg L hL) 0 0 := nil | _ (cons f g hfg L hL) 0 1 := single f | _ (cons f g hfg L hL) 0 (n+2) := cons f g hfg (L.take n) (extract hL 0 (n+1)) inductive arrow_congr : Π (L L' : list (arrow 𝒞)), Prop | nil : arrow_congr [] [] | cons : ∀ {A B : 𝒞} {f f' : A ⟶ B} {L L' : list (arrow 𝒞)} (h : f = f') (H : arrow_congr L L'), arrow_congr (f :: L) (f' :: L') lemma congr : ∀ {L L' : list (arrow 𝒞)}, exact_seq 𝒞 L → arrow_congr L L' → exact_seq 𝒞 L' | _ _ h arrow_congr.nil := exact_seq.nil | _ _ h (arrow_congr.cons h₁ arrow_congr.nil) := exact_seq.single _ | _ _ h (arrow_congr.cons h₁ ((arrow_congr.cons h₂ H))) := begin substs h₁ h₂, rcases h with _ | _ | ⟨A, B, C, f, g, hfg, _, hL⟩, refine exact_seq.cons _ _ hfg _ (congr hL (arrow_congr.cons rfl H)), end lemma append : ∀ {L₁ L₂ L₃ : list (arrow 𝒞)} (h₁₂ : exact_seq 𝒞 (L₁ ++ L₂)) (h₂₃ : exact_seq 𝒞 (L₂ ++ L₃)) (h₂ : L₂ ≠ []), exact_seq 𝒞 (L₁ ++ L₂ ++ L₃) | L₁ [] L₃ h₁₂ h₂₃ h := (h rfl).elim | [] L₂ L₃ h₁₂ h₂₃ h := by rwa list.nil_append | (_::[]) (_::L₂) L₃ (cons f g hfg L hL) h₂₃ h := cons f g hfg _ h₂₃ | (_::_::L₁) L₂ L₃ (cons f g hfg L hL) h₂₃ h := suffices exact_seq 𝒞 ([f] ++ ([g] ++ L₁ ++ L₂) ++ L₃), { simpa only [list.append_assoc] }, cons _ _ hfg _ $ suffices exact_seq 𝒞 ((g :: L₁) ++ L₂ ++ L₃), { simpa only [list.append_assoc] }, append (by simpa only using hL) h₂₃ h end exact_seq namespace arrow open _root_.opposite variables {C : Type*} [category C] @[simps] def op (f : arrow C) : arrow Cᵒᵖ := { left := op f.right, right := op f.left, hom := f.hom.op } @[simps] def unop (f : arrow Cᵒᵖ) : arrow C := { left := unop f.right, right := unop f.left, hom := f.hom.unop } @[simp] lemma op_unop (f : arrow C) : f.op.unop = f := by { cases f, dsimp [op, unop], refl } @[simp] lemma unop_op (f : arrow Cᵒᵖ) : f.unop.op = f := by { cases f, dsimp [op, unop], refl } @[simp] lemma op_comp_unop : (op ∘ unop : arrow Cᵒᵖ → arrow Cᵒᵖ) = id := by { ext, exact unop_op _ } @[simp] lemma unop_comp_op : (unop ∘ op : arrow C → arrow C ) = id := by { ext, exact op_unop _ } end arrow namespace exact_seq lemma op : ∀ {L : list (arrow 𝒜)}, exact_seq 𝒜 L → exact_seq 𝒜ᵒᵖ (L.reverse.map arrow.op) | _ nil := nil | _ (single f) := single f.op | _ (cons f g hfg L hL) := begin have := op hL, simp only [list.reverse_cons, list.map_append] at this ⊢, refine this.append _ (list.cons_ne_nil _ _), exact cons _ _ hfg.op _ (single _), end lemma unop : ∀ {L : list (arrow 𝒜ᵒᵖ)}, exact_seq 𝒜ᵒᵖ L → exact_seq 𝒜 (L.reverse.map arrow.unop) | _ nil := nil | _ (single f) := single f.unop | _ (cons f g hfg L hL) := begin have := unop hL, simp only [list.reverse_cons, list.map_append] at this ⊢, refine this.append _ (list.cons_ne_nil _ _), exact cons _ _ hfg.unop _ (single _), end lemma of_op {L : list (arrow 𝒜)} (h : exact_seq 𝒜ᵒᵖ (L.reverse.map arrow.op)) : exact_seq 𝒜 L := by simpa only [list.map_reverse, list.reverse_reverse, list.map_map, arrow.unop_comp_op, list.map_id] using h.unop lemma of_unop {L : list (arrow 𝒜ᵒᵖ)} (h : exact_seq 𝒜 (L.reverse.map arrow.unop)) : exact_seq 𝒜ᵒᵖ L := by simpa only [list.map_reverse, list.reverse_reverse, list.map_map, arrow.op_comp_unop, list.map_id] using h.op end exact_seq end category_theory
[GOAL] M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) L' : Language inst✝¹ : Structure L' M h : Definable A L s φ : L →ᴸ L' inst✝ : LHom.IsExpansionOn φ M ⊢ Definable A L' s [PROOFSTEP] obtain ⟨ψ, rfl⟩ := h [GOAL] case intro M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M L' : Language inst✝¹ : Structure L' M φ : L →ᴸ L' inst✝ : LHom.IsExpansionOn φ M ψ : Formula (L[[↑A]]) α ⊢ Definable A L' (setOf (Formula.Realize ψ)) [PROOFSTEP] refine' ⟨(φ.addConstants A).onFormula ψ, _⟩ [GOAL] case intro M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M L' : Language inst✝¹ : Structure L' M φ : L →ᴸ L' inst✝ : LHom.IsExpansionOn φ M ψ : Formula (L[[↑A]]) α ⊢ setOf (Formula.Realize ψ) = setOf (Formula.Realize (LHom.onFormula (LHom.addConstants (↑A) φ) ψ)) [PROOFSTEP] ext x [GOAL] case intro.h M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M L' : Language inst✝¹ : Structure L' M φ : L →ᴸ L' inst✝ : LHom.IsExpansionOn φ M ψ : Formula (L[[↑A]]) α x : α → M ⊢ x ∈ setOf (Formula.Realize ψ) ↔ x ∈ setOf (Formula.Realize (LHom.onFormula (LHom.addConstants (↑A) φ) ψ)) [PROOFSTEP] simp only [mem_setOf_eq, LHom.realize_onFormula] [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) ⊢ Definable ∅ L s ↔ ∃ φ, s = setOf (Formula.Realize φ) [PROOFSTEP] rw [Definable, Equiv.exists_congr_left (LEquiv.addEmptyConstants L (∅ : Set M)).onFormula] [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) ⊢ (∃ φ, s = setOf (Formula.Realize φ)) ↔ ∃ b, s = setOf (Formula.Realize (↑(LEquiv.onFormula (LEquiv.addEmptyConstants L ↑∅)).symm b)) [PROOFSTEP] simp [-constantsOn] [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) hAs : Definable A L s hAB : A ⊆ B ⊢ Definable B L s [PROOFSTEP] rw [definable_iff_empty_definable_with_params] at * [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) hAs : Definable ∅ (L[[↑A]]) s hAB : A ⊆ B ⊢ Definable ∅ (L[[↑B]]) s [PROOFSTEP] exact hAs.map_expansion (L.lhomWithConstantsMap (Set.inclusion hAB)) [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) ⊢ ∅ = setOf (Formula.Realize ⊥) [PROOFSTEP] ext [GOAL] case h M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) x✝ : α → M ⊢ x✝ ∈ ∅ ↔ x✝ ∈ setOf (Formula.Realize ⊥) [PROOFSTEP] simp [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) ⊢ univ = setOf (Formula.Realize ⊤) [PROOFSTEP] ext [GOAL] case h M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) x✝ : α → M ⊢ x✝ ∈ univ ↔ x✝ ∈ setOf (Formula.Realize ⊤) [PROOFSTEP] simp [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s f g : Set (α → M) hf : Definable A L f hg : Definable A L g ⊢ Definable A L (f ∩ g) [PROOFSTEP] rcases hf with ⟨φ, rfl⟩ [GOAL] case intro M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s g : Set (α → M) hg : Definable A L g φ : Formula (L[[↑A]]) α ⊢ Definable A L (setOf (Formula.Realize φ) ∩ g) [PROOFSTEP] rcases hg with ⟨θ, rfl⟩ [GOAL] case intro.intro M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) φ θ : Formula (L[[↑A]]) α ⊢ Definable A L (setOf (Formula.Realize φ) ∩ setOf (Formula.Realize θ)) [PROOFSTEP] refine' ⟨φ ⊓ θ, _⟩ [GOAL] case intro.intro M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) φ θ : Formula (L[[↑A]]) α ⊢ setOf (Formula.Realize φ) ∩ setOf (Formula.Realize θ) = setOf (Formula.Realize (φ ⊓ θ)) [PROOFSTEP] ext [GOAL] case intro.intro.h M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) φ θ : Formula (L[[↑A]]) α x✝ : α → M ⊢ x✝ ∈ setOf (Formula.Realize φ) ∩ setOf (Formula.Realize θ) ↔ x✝ ∈ setOf (Formula.Realize (φ ⊓ θ)) [PROOFSTEP] simp [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s f g : Set (α → M) hf : Definable A L f hg : Definable A L g ⊢ Definable A L (f ∪ g) [PROOFSTEP] rcases hf with ⟨φ, hφ⟩ [GOAL] case intro M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s f g : Set (α → M) hg : Definable A L g φ : Formula (L[[↑A]]) α hφ : f = setOf (Formula.Realize φ) ⊢ Definable A L (f ∪ g) [PROOFSTEP] rcases hg with ⟨θ, hθ⟩ [GOAL] case intro.intro M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s f g : Set (α → M) φ : Formula (L[[↑A]]) α hφ : f = setOf (Formula.Realize φ) θ : Formula (L[[↑A]]) α hθ : g = setOf (Formula.Realize θ) ⊢ Definable A L (f ∪ g) [PROOFSTEP] refine' ⟨φ ⊔ θ, _⟩ [GOAL] case intro.intro M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s f g : Set (α → M) φ : Formula (L[[↑A]]) α hφ : f = setOf (Formula.Realize φ) θ : Formula (L[[↑A]]) α hθ : g = setOf (Formula.Realize θ) ⊢ f ∪ g = setOf (Formula.Realize (φ ⊔ θ)) [PROOFSTEP] ext [GOAL] case intro.intro.h M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s f g : Set (α → M) φ : Formula (L[[↑A]]) α hφ : f = setOf (Formula.Realize φ) θ : Formula (L[[↑A]]) α hθ : g = setOf (Formula.Realize θ) x✝ : α → M ⊢ x✝ ∈ f ∪ g ↔ x✝ ∈ setOf (Formula.Realize (φ ⊔ θ)) [PROOFSTEP] rw [hφ, hθ, mem_setOf_eq, Formula.realize_sup, mem_union, mem_setOf_eq, mem_setOf_eq] [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) ι : Type u_2 f : ι → Set (α → M) hf : ∀ (i : ι), Definable A L (f i) s : Finset ι ⊢ Definable A L (Finset.inf s f) [PROOFSTEP] classical refine' Finset.induction definable_univ (fun i s _ h => _) s rw [Finset.inf_insert] exact (hf i).inter h [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) ι : Type u_2 f : ι → Set (α → M) hf : ∀ (i : ι), Definable A L (f i) s : Finset ι ⊢ Definable A L (Finset.inf s f) [PROOFSTEP] refine' Finset.induction definable_univ (fun i s _ h => _) s [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝¹ : Set (α → M) ι : Type u_2 f : ι → Set (α → M) hf : ∀ (i : ι), Definable A L (f i) s✝ : Finset ι i : ι s : Finset ι x✝ : ¬i ∈ s h : Definable A L (Finset.inf s f) ⊢ Definable A L (Finset.inf (insert i s) f) [PROOFSTEP] rw [Finset.inf_insert] [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝¹ : Set (α → M) ι : Type u_2 f : ι → Set (α → M) hf : ∀ (i : ι), Definable A L (f i) s✝ : Finset ι i : ι s : Finset ι x✝ : ¬i ∈ s h : Definable A L (Finset.inf s f) ⊢ Definable A L (f i ⊓ Finset.inf s f) [PROOFSTEP] exact (hf i).inter h [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) ι : Type u_2 f : ι → Set (α → M) hf : ∀ (i : ι), Definable A L (f i) s : Finset ι ⊢ Definable A L (Finset.sup s f) [PROOFSTEP] classical refine' Finset.induction definable_empty (fun i s _ h => _) s rw [Finset.sup_insert] exact (hf i).union h [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) ι : Type u_2 f : ι → Set (α → M) hf : ∀ (i : ι), Definable A L (f i) s : Finset ι ⊢ Definable A L (Finset.sup s f) [PROOFSTEP] refine' Finset.induction definable_empty (fun i s _ h => _) s [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝¹ : Set (α → M) ι : Type u_2 f : ι → Set (α → M) hf : ∀ (i : ι), Definable A L (f i) s✝ : Finset ι i : ι s : Finset ι x✝ : ¬i ∈ s h : Definable A L (Finset.sup s f) ⊢ Definable A L (Finset.sup (insert i s) f) [PROOFSTEP] rw [Finset.sup_insert] [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝¹ : Set (α → M) ι : Type u_2 f : ι → Set (α → M) hf : ∀ (i : ι), Definable A L (f i) s✝ : Finset ι i : ι s : Finset ι x✝ : ¬i ∈ s h : Definable A L (Finset.sup s f) ⊢ Definable A L (f i ⊔ Finset.sup s f) [PROOFSTEP] exact (hf i).union h [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) ι : Type u_2 f : ι → Set (α → M) hf : ∀ (i : ι), Definable A L (f i) s : Finset ι ⊢ Definable A L (⋂ (i : ι) (_ : i ∈ s), f i) [PROOFSTEP] rw [← Finset.inf_set_eq_iInter] [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) ι : Type u_2 f : ι → Set (α → M) hf : ∀ (i : ι), Definable A L (f i) s : Finset ι ⊢ Definable A L (Finset.inf s fun i => f i) [PROOFSTEP] exact definable_finset_inf hf s [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) ι : Type u_2 f : ι → Set (α → M) hf : ∀ (i : ι), Definable A L (f i) s : Finset ι ⊢ Definable A L (⋃ (i : ι) (_ : i ∈ s), f i) [PROOFSTEP] rw [← Finset.sup_set_eq_biUnion] [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) ι : Type u_2 f : ι → Set (α → M) hf : ∀ (i : ι), Definable A L (f i) s : Finset ι ⊢ Definable A L (Finset.sup s fun i => f i) [PROOFSTEP] exact definable_finset_sup hf s [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ s : Set (α → M) hf : Definable A L s ⊢ Definable A L sᶜ [PROOFSTEP] rcases hf with ⟨φ, hφ⟩ [GOAL] case intro M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ s : Set (α → M) φ : Formula (L[[↑A]]) α hφ : s = setOf (Formula.Realize φ) ⊢ Definable A L sᶜ [PROOFSTEP] refine' ⟨φ.not, _⟩ [GOAL] case intro M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ s : Set (α → M) φ : Formula (L[[↑A]]) α hφ : s = setOf (Formula.Realize φ) ⊢ sᶜ = setOf (Formula.Realize (Formula.not φ)) [PROOFSTEP] ext v [GOAL] case intro.h M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ s : Set (α → M) φ : Formula (L[[↑A]]) α hφ : s = setOf (Formula.Realize φ) v : α → M ⊢ v ∈ sᶜ ↔ v ∈ setOf (Formula.Realize (Formula.not φ)) [PROOFSTEP] rw [hφ, compl_setOf, mem_setOf, mem_setOf, Formula.realize_not] [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) f : α → β s : Set (α → M) h : Definable A L s ⊢ Definable A L ((fun g => g ∘ f) ⁻¹' s) [PROOFSTEP] obtain ⟨φ, rfl⟩ := h [GOAL] case intro M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) f : α → β φ : Formula (L[[↑A]]) α ⊢ Definable A L ((fun g => g ∘ f) ⁻¹' setOf (Formula.Realize φ)) [PROOFSTEP] refine' ⟨φ.relabel f, _⟩ [GOAL] case intro M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) f : α → β φ : Formula (L[[↑A]]) α ⊢ (fun g => g ∘ f) ⁻¹' setOf (Formula.Realize φ) = setOf (Formula.Realize (Formula.relabel f φ)) [PROOFSTEP] ext [GOAL] case intro.h M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) f : α → β φ : Formula (L[[↑A]]) α x✝ : β → M ⊢ x✝ ∈ (fun g => g ∘ f) ⁻¹' setOf (Formula.Realize φ) ↔ x✝ ∈ setOf (Formula.Realize (Formula.relabel f φ)) [PROOFSTEP] simp only [Set.preimage_setOf_eq, mem_setOf_eq, Formula.realize_relabel] [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h : Definable A L s f : α ≃ β ⊢ Definable A L ((fun g => g ∘ ↑f) '' s) [PROOFSTEP] refine' (congr rfl _).mp (h.preimage_comp f.symm) [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h : Definable A L s f : α ≃ β ⊢ (fun g => g ∘ ↑f.symm) ⁻¹' s = (fun g => g ∘ ↑f) '' s [PROOFSTEP] rw [image_eq_preimage_of_inverse] [GOAL] case h₁ M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h : Definable A L s f : α ≃ β ⊢ Function.LeftInverse (fun g => g ∘ ↑f.symm) fun g => g ∘ ↑f [PROOFSTEP] intro i [GOAL] case h₁ M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h : Definable A L s f : α ≃ β i : β → M ⊢ (fun g => g ∘ ↑f.symm) ((fun g => g ∘ ↑f) i) = i [PROOFSTEP] ext b [GOAL] case h₁.h M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h : Definable A L s f : α ≃ β i : β → M b : β ⊢ (fun g => g ∘ ↑f.symm) ((fun g => g ∘ ↑f) i) b = i b [PROOFSTEP] simp only [Function.comp_apply, Equiv.apply_symm_apply] [GOAL] case h₂ M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h : Definable A L s f : α ≃ β ⊢ Function.RightInverse (fun g => g ∘ ↑f.symm) fun g => g ∘ ↑f [PROOFSTEP] intro i [GOAL] case h₂ M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h : Definable A L s f : α ≃ β i : α → M ⊢ (fun g => g ∘ ↑f) ((fun g => g ∘ ↑f.symm) i) = i [PROOFSTEP] ext a [GOAL] case h₂.h M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h : Definable A L s f : α ≃ β i : α → M a : α ⊢ (fun g => g ∘ ↑f) ((fun g => g ∘ ↑f.symm) i) a = i a [PROOFSTEP] simp [GOAL] M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) m : ℕ s : Set (α ⊕ Fin m → M) h : Definable A L s ⊢ Definable A L ((fun g => g ∘ Sum.inl) '' s) [PROOFSTEP] obtain ⟨φ, rfl⟩ := h [GOAL] case intro M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) m : ℕ φ : Formula (L[[↑A]]) (α ⊕ Fin m) ⊢ Definable A L ((fun g => g ∘ Sum.inl) '' setOf (Formula.Realize φ)) [PROOFSTEP] refine' ⟨(BoundedFormula.relabel id φ).exs, _⟩ [GOAL] case intro M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) m : ℕ φ : Formula (L[[↑A]]) (α ⊕ Fin m) ⊢ (fun g => g ∘ Sum.inl) '' setOf (Formula.Realize φ) = setOf (Formula.Realize (BoundedFormula.exs (BoundedFormula.relabel id φ))) [PROOFSTEP] ext x [GOAL] case intro.h M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) m : ℕ φ : Formula (L[[↑A]]) (α ⊕ Fin m) x : α → M ⊢ x ∈ (fun g => g ∘ Sum.inl) '' setOf (Formula.Realize φ) ↔ x ∈ setOf (Formula.Realize (BoundedFormula.exs (BoundedFormula.relabel id φ))) [PROOFSTEP] simp only [Set.mem_image, mem_setOf_eq, BoundedFormula.realize_exs, BoundedFormula.realize_relabel, Function.comp.right_id, Fin.castAdd_zero, Fin.castIso_refl] [GOAL] case intro.h M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) m : ℕ φ : Formula (L[[↑A]]) (α ⊕ Fin m) x : α → M ⊢ (∃ x_1, Formula.Realize φ x_1 ∧ x_1 ∘ Sum.inl = x) ↔ ∃ xs, BoundedFormula.Realize φ (Sum.elim x (xs ∘ Fin.cast (_ : m = m))) (xs ∘ Fin.natAdd m) [PROOFSTEP] constructor [GOAL] case intro.h.mp M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) m : ℕ φ : Formula (L[[↑A]]) (α ⊕ Fin m) x : α → M ⊢ (∃ x_1, Formula.Realize φ x_1 ∧ x_1 ∘ Sum.inl = x) → ∃ xs, BoundedFormula.Realize φ (Sum.elim x (xs ∘ Fin.cast (_ : m = m))) (xs ∘ Fin.natAdd m) [PROOFSTEP] rintro ⟨y, hy, rfl⟩ [GOAL] case intro.h.mp.intro.intro M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) m : ℕ φ : Formula (L[[↑A]]) (α ⊕ Fin m) y : α ⊕ Fin m → M hy : Formula.Realize φ y ⊢ ∃ xs, BoundedFormula.Realize φ (Sum.elim (y ∘ Sum.inl) (xs ∘ Fin.cast (_ : m = m))) (xs ∘ Fin.natAdd m) [PROOFSTEP] exact ⟨y ∘ Sum.inr, (congr (congr rfl (Sum.elim_comp_inl_inr y).symm) (funext finZeroElim)).mp hy⟩ [GOAL] case intro.h.mpr M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) m : ℕ φ : Formula (L[[↑A]]) (α ⊕ Fin m) x : α → M ⊢ (∃ xs, BoundedFormula.Realize φ (Sum.elim x (xs ∘ Fin.cast (_ : m = m))) (xs ∘ Fin.natAdd m)) → ∃ x_1, Formula.Realize φ x_1 ∧ x_1 ∘ Sum.inl = x [PROOFSTEP] rintro ⟨y, hy⟩ [GOAL] case intro.h.mpr.intro M : Type w A : Set M L : Language inst✝ : Structure L M α : Type u₁ β : Type u_1 B : Set M s : Set (α → M) m : ℕ φ : Formula (L[[↑A]]) (α ⊕ Fin m) x : α → M y : Fin (m + 0) → M hy : BoundedFormula.Realize φ (Sum.elim x (y ∘ Fin.cast (_ : m = m))) (y ∘ Fin.natAdd m) ⊢ ∃ x_1, Formula.Realize φ x_1 ∧ x_1 ∘ Sum.inl = x [PROOFSTEP] exact ⟨Sum.elim x y, (congr rfl (funext finZeroElim)).mp hy, Sum.elim_comp_inl _ _⟩ [GOAL] M : Type w A : Set M L : Language inst✝¹ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h : Definable A L s f : α ↪ β inst✝ : Finite β ⊢ Definable A L ((fun g => g ∘ ↑f) '' s) [PROOFSTEP] classical cases nonempty_fintype β refine' (congr rfl (ext fun x => _)).mp (((h.image_comp_equiv (Equiv.Set.sumCompl (range f))).image_comp_equiv (Equiv.sumCongr (Equiv.ofInjective f f.injective) (Fintype.equivFin (↥(range f)ᶜ)).symm)).image_comp_sum_inl_fin _) simp only [mem_preimage, mem_image, exists_exists_and_eq_and] refine' exists_congr fun y => and_congr_right fun _ => Eq.congr_left (funext fun a => _) simp [GOAL] M : Type w A : Set M L : Language inst✝¹ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h : Definable A L s f : α ↪ β inst✝ : Finite β ⊢ Definable A L ((fun g => g ∘ ↑f) '' s) [PROOFSTEP] cases nonempty_fintype β [GOAL] case intro M : Type w A : Set M L : Language inst✝¹ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h : Definable A L s f : α ↪ β inst✝ : Finite β val✝ : Fintype β ⊢ Definable A L ((fun g => g ∘ ↑f) '' s) [PROOFSTEP] refine' (congr rfl (ext fun x => _)).mp (((h.image_comp_equiv (Equiv.Set.sumCompl (range f))).image_comp_equiv (Equiv.sumCongr (Equiv.ofInjective f f.injective) (Fintype.equivFin (↥(range f)ᶜ)).symm)).image_comp_sum_inl_fin _) [GOAL] case intro M : Type w A : Set M L : Language inst✝¹ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h : Definable A L s f : α ↪ β inst✝ : Finite β val✝ : Fintype β x : α → M ⊢ x ∈ (fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.ofInjective ↑f (_ : Function.Injective ↑f)) (Fintype.equivFin ↑(range ↑f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range ↑f))) '' s)) ↔ x ∈ (fun g => g ∘ ↑f) '' s [PROOFSTEP] simp only [mem_preimage, mem_image, exists_exists_and_eq_and] [GOAL] case intro M : Type w A : Set M L : Language inst✝¹ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h : Definable A L s f : α ↪ β inst✝ : Finite β val✝ : Fintype β x : α → M ⊢ (∃ a, a ∈ s ∧ ((a ∘ ↑(Equiv.Set.sumCompl (range ↑f))) ∘ ↑(Equiv.sumCongr (Equiv.ofInjective ↑f (_ : Function.Injective ↑f)) (Fintype.equivFin ↑(range ↑f)ᶜ).symm)) ∘ Sum.inl = x) ↔ ∃ x_1, x_1 ∈ s ∧ x_1 ∘ ↑f = x [PROOFSTEP] refine' exists_congr fun y => and_congr_right fun _ => Eq.congr_left (funext fun a => _) [GOAL] case intro M : Type w A : Set M L : Language inst✝¹ : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h : Definable A L s f : α ↪ β inst✝ : Finite β val✝ : Fintype β x : α → M y : β → M x✝ : y ∈ s a : α ⊢ (((y ∘ ↑(Equiv.Set.sumCompl (range ↑f))) ∘ ↑(Equiv.sumCongr (Equiv.ofInjective ↑f (_ : Function.Injective ↑f)) (Fintype.equivFin ↑(range ↑f)ᶜ).symm)) ∘ Sum.inl) a = (y ∘ ↑f) a [PROOFSTEP] simp [GOAL] M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β ⊢ Definable A L ((fun g => g ∘ f) '' s) [PROOFSTEP] classical cases nonempty_fintype α cases nonempty_fintype β have h := (((h.image_comp_equiv (Equiv.Set.sumCompl (range f))).image_comp_equiv (Equiv.sumCongr (_root_.Equiv.refl _) (Fintype.equivFin _).symm)).image_comp_sum_inl_fin _).preimage_comp (rangeSplitting f) have h' : A.Definable L {x : α → M | ∀ a, x a = x (rangeSplitting f (rangeFactorization f a))} := by have h' : ∀ a, A.Definable L {x : α → M | x a = x (rangeSplitting f (rangeFactorization f a))} := by refine' fun a => ⟨(var a).equal (var (rangeSplitting f (rangeFactorization f a))), ext _⟩ simp refine' (congr rfl (ext _)).mp (definable_finset_biInter h' Finset.univ) simp refine' (congr rfl (ext fun x => _)).mp (h.inter h') simp only [Equiv.coe_trans, mem_inter_iff, mem_preimage, mem_image, exists_exists_and_eq_and, mem_setOf_eq] constructor · rintro ⟨⟨y, ys, hy⟩, hx⟩ refine' ⟨y, ys, _⟩ ext a rw [hx a, ← Function.comp_apply (f := x), ← hy] simp · rintro ⟨y, ys, rfl⟩ refine' ⟨⟨y, ys, _⟩, fun a => _⟩ · ext simp [Set.apply_rangeSplitting f] · rw [Function.comp_apply, Function.comp_apply, apply_rangeSplitting f, rangeFactorization_coe] [GOAL] M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β ⊢ Definable A L ((fun g => g ∘ f) '' s) [PROOFSTEP] cases nonempty_fintype α [GOAL] case intro M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝ : Fintype α ⊢ Definable A L ((fun g => g ∘ f) '' s) [PROOFSTEP] cases nonempty_fintype β [GOAL] case intro.intro M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝¹ : Fintype α val✝ : Fintype β ⊢ Definable A L ((fun g => g ∘ f) '' s) [PROOFSTEP] have h := (((h.image_comp_equiv (Equiv.Set.sumCompl (range f))).image_comp_equiv (Equiv.sumCongr (_root_.Equiv.refl _) (Fintype.equivFin _).symm)).image_comp_sum_inl_fin _).preimage_comp (rangeSplitting f) [GOAL] case intro.intro M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h✝ : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝¹ : Fintype α val✝ : Fintype β h : Definable A L ((fun g => g ∘ rangeSplitting f) ⁻¹' ((fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range f))) '' s)))) ⊢ Definable A L ((fun g => g ∘ f) '' s) [PROOFSTEP] have h' : A.Definable L {x : α → M | ∀ a, x a = x (rangeSplitting f (rangeFactorization f a))} := by have h' : ∀ a, A.Definable L {x : α → M | x a = x (rangeSplitting f (rangeFactorization f a))} := by refine' fun a => ⟨(var a).equal (var (rangeSplitting f (rangeFactorization f a))), ext _⟩ simp refine' (congr rfl (ext _)).mp (definable_finset_biInter h' Finset.univ) simp [GOAL] M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h✝ : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝¹ : Fintype α val✝ : Fintype β h : Definable A L ((fun g => g ∘ rangeSplitting f) ⁻¹' ((fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range f))) '' s)))) ⊢ Definable A L {x | ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a))} [PROOFSTEP] have h' : ∀ a, A.Definable L {x : α → M | x a = x (rangeSplitting f (rangeFactorization f a))} := by refine' fun a => ⟨(var a).equal (var (rangeSplitting f (rangeFactorization f a))), ext _⟩ simp [GOAL] M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h✝ : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝¹ : Fintype α val✝ : Fintype β h : Definable A L ((fun g => g ∘ rangeSplitting f) ⁻¹' ((fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range f))) '' s)))) ⊢ ∀ (a : α), Definable A L {x | x a = x (rangeSplitting f (rangeFactorization f a))} [PROOFSTEP] refine' fun a => ⟨(var a).equal (var (rangeSplitting f (rangeFactorization f a))), ext _⟩ [GOAL] M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h✝ : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝¹ : Fintype α val✝ : Fintype β h : Definable A L ((fun g => g ∘ rangeSplitting f) ⁻¹' ((fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range f))) '' s)))) a : α ⊢ ∀ (x : α → M), x ∈ {x | x a = x (rangeSplitting f (rangeFactorization f a))} ↔ x ∈ setOf (Formula.Realize (Term.equal (var a) (var (rangeSplitting f (rangeFactorization f a))))) [PROOFSTEP] simp [GOAL] M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h✝ : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝¹ : Fintype α val✝ : Fintype β h : Definable A L ((fun g => g ∘ rangeSplitting f) ⁻¹' ((fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range f))) '' s)))) h' : ∀ (a : α), Definable A L {x | x a = x (rangeSplitting f (rangeFactorization f a))} ⊢ Definable A L {x | ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a))} [PROOFSTEP] refine' (congr rfl (ext _)).mp (definable_finset_biInter h' Finset.univ) [GOAL] M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h✝ : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝¹ : Fintype α val✝ : Fintype β h : Definable A L ((fun g => g ∘ rangeSplitting f) ⁻¹' ((fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range f))) '' s)))) h' : ∀ (a : α), Definable A L {x | x a = x (rangeSplitting f (rangeFactorization f a))} ⊢ ∀ (x : α → M), x ∈ ⋂ (i : α) (_ : i ∈ Finset.univ), {x | x i = x (rangeSplitting f (rangeFactorization f i))} ↔ x ∈ {x | ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a))} [PROOFSTEP] simp [GOAL] case intro.intro M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h✝ : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝¹ : Fintype α val✝ : Fintype β h : Definable A L ((fun g => g ∘ rangeSplitting f) ⁻¹' ((fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range f))) '' s)))) h' : Definable A L {x | ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a))} ⊢ Definable A L ((fun g => g ∘ f) '' s) [PROOFSTEP] refine' (congr rfl (ext fun x => _)).mp (h.inter h') [GOAL] case intro.intro M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h✝ : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝¹ : Fintype α val✝ : Fintype β h : Definable A L ((fun g => g ∘ rangeSplitting f) ⁻¹' ((fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range f))) '' s)))) h' : Definable A L {x | ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a))} x : α → M ⊢ x ∈ (fun g => g ∘ rangeSplitting f) ⁻¹' ((fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range f))) '' s))) ∩ {x | ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a))} ↔ x ∈ (fun g => g ∘ f) '' s [PROOFSTEP] simp only [Equiv.coe_trans, mem_inter_iff, mem_preimage, mem_image, exists_exists_and_eq_and, mem_setOf_eq] [GOAL] case intro.intro M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h✝ : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝¹ : Fintype α val✝ : Fintype β h : Definable A L ((fun g => g ∘ rangeSplitting f) ⁻¹' ((fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range f))) '' s)))) h' : Definable A L {x | ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a))} x : α → M ⊢ ((∃ a, a ∈ s ∧ ((a ∘ ↑(Equiv.Set.sumCompl (range f))) ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) ∘ Sum.inl = x ∘ rangeSplitting f) ∧ ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a))) ↔ ∃ x_1, x_1 ∈ s ∧ x_1 ∘ f = x [PROOFSTEP] constructor [GOAL] case intro.intro.mp M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h✝ : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝¹ : Fintype α val✝ : Fintype β h : Definable A L ((fun g => g ∘ rangeSplitting f) ⁻¹' ((fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range f))) '' s)))) h' : Definable A L {x | ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a))} x : α → M ⊢ ((∃ a, a ∈ s ∧ ((a ∘ ↑(Equiv.Set.sumCompl (range f))) ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) ∘ Sum.inl = x ∘ rangeSplitting f) ∧ ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a))) → ∃ x_1, x_1 ∈ s ∧ x_1 ∘ f = x [PROOFSTEP] rintro ⟨⟨y, ys, hy⟩, hx⟩ [GOAL] case intro.intro.mp.intro.intro.intro M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h✝ : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝¹ : Fintype α val✝ : Fintype β h : Definable A L ((fun g => g ∘ rangeSplitting f) ⁻¹' ((fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range f))) '' s)))) h' : Definable A L {x | ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a))} x : α → M hx : ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a)) y : β → M ys : y ∈ s hy : ((y ∘ ↑(Equiv.Set.sumCompl (range f))) ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) ∘ Sum.inl = x ∘ rangeSplitting f ⊢ ∃ x_1, x_1 ∈ s ∧ x_1 ∘ f = x [PROOFSTEP] refine' ⟨y, ys, _⟩ [GOAL] case intro.intro.mp.intro.intro.intro M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h✝ : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝¹ : Fintype α val✝ : Fintype β h : Definable A L ((fun g => g ∘ rangeSplitting f) ⁻¹' ((fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range f))) '' s)))) h' : Definable A L {x | ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a))} x : α → M hx : ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a)) y : β → M ys : y ∈ s hy : ((y ∘ ↑(Equiv.Set.sumCompl (range f))) ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) ∘ Sum.inl = x ∘ rangeSplitting f ⊢ y ∘ f = x [PROOFSTEP] ext a [GOAL] case intro.intro.mp.intro.intro.intro.h M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h✝ : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝¹ : Fintype α val✝ : Fintype β h : Definable A L ((fun g => g ∘ rangeSplitting f) ⁻¹' ((fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range f))) '' s)))) h' : Definable A L {x | ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a))} x : α → M hx : ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a)) y : β → M ys : y ∈ s hy : ((y ∘ ↑(Equiv.Set.sumCompl (range f))) ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) ∘ Sum.inl = x ∘ rangeSplitting f a : α ⊢ (y ∘ f) a = x a [PROOFSTEP] rw [hx a, ← Function.comp_apply (f := x), ← hy] [GOAL] case intro.intro.mp.intro.intro.intro.h M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h✝ : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝¹ : Fintype α val✝ : Fintype β h : Definable A L ((fun g => g ∘ rangeSplitting f) ⁻¹' ((fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range f))) '' s)))) h' : Definable A L {x | ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a))} x : α → M hx : ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a)) y : β → M ys : y ∈ s hy : ((y ∘ ↑(Equiv.Set.sumCompl (range f))) ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) ∘ Sum.inl = x ∘ rangeSplitting f a : α ⊢ (y ∘ f) a = (((y ∘ ↑(Equiv.Set.sumCompl (range f))) ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) ∘ Sum.inl) (rangeFactorization f a) [PROOFSTEP] simp [GOAL] case intro.intro.mpr M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h✝ : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝¹ : Fintype α val✝ : Fintype β h : Definable A L ((fun g => g ∘ rangeSplitting f) ⁻¹' ((fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range f))) '' s)))) h' : Definable A L {x | ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a))} x : α → M ⊢ (∃ x_1, x_1 ∈ s ∧ x_1 ∘ f = x) → (∃ a, a ∈ s ∧ ((a ∘ ↑(Equiv.Set.sumCompl (range f))) ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) ∘ Sum.inl = x ∘ rangeSplitting f) ∧ ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a)) [PROOFSTEP] rintro ⟨y, ys, rfl⟩ [GOAL] case intro.intro.mpr.intro.intro M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h✝ : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝¹ : Fintype α val✝ : Fintype β h : Definable A L ((fun g => g ∘ rangeSplitting f) ⁻¹' ((fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range f))) '' s)))) h' : Definable A L {x | ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a))} y : β → M ys : y ∈ s ⊢ (∃ a, a ∈ s ∧ ((a ∘ ↑(Equiv.Set.sumCompl (range f))) ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) ∘ Sum.inl = (y ∘ f) ∘ rangeSplitting f) ∧ ∀ (a : α), (y ∘ f) a = (y ∘ f) (rangeSplitting f (rangeFactorization f a)) [PROOFSTEP] refine' ⟨⟨y, ys, _⟩, fun a => _⟩ [GOAL] case intro.intro.mpr.intro.intro.refine'_1 M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h✝ : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝¹ : Fintype α val✝ : Fintype β h : Definable A L ((fun g => g ∘ rangeSplitting f) ⁻¹' ((fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range f))) '' s)))) h' : Definable A L {x | ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a))} y : β → M ys : y ∈ s ⊢ ((y ∘ ↑(Equiv.Set.sumCompl (range f))) ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) ∘ Sum.inl = (y ∘ f) ∘ rangeSplitting f [PROOFSTEP] ext [GOAL] case intro.intro.mpr.intro.intro.refine'_1.h M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h✝ : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝¹ : Fintype α val✝ : Fintype β h : Definable A L ((fun g => g ∘ rangeSplitting f) ⁻¹' ((fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range f))) '' s)))) h' : Definable A L {x | ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a))} y : β → M ys : y ∈ s x✝ : ↑(range f) ⊢ (((y ∘ ↑(Equiv.Set.sumCompl (range f))) ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) ∘ Sum.inl) x✝ = ((y ∘ f) ∘ rangeSplitting f) x✝ [PROOFSTEP] simp [Set.apply_rangeSplitting f] [GOAL] case intro.intro.mpr.intro.intro.refine'_2 M : Type w A : Set M L : Language inst✝² : Structure L M α : Type u₁ β : Type u_1 B : Set M s✝ : Set (α → M) s : Set (β → M) h✝ : Definable A L s f : α → β inst✝¹ : Finite α inst✝ : Finite β val✝¹ : Fintype α val✝ : Fintype β h : Definable A L ((fun g => g ∘ rangeSplitting f) ⁻¹' ((fun g => g ∘ Sum.inl) '' ((fun g => g ∘ ↑(Equiv.sumCongr (Equiv.refl ↑(range f)) (Fintype.equivFin ↑(range f)ᶜ).symm)) '' ((fun g => g ∘ ↑(Equiv.Set.sumCompl (range f))) '' s)))) h' : Definable A L {x | ∀ (a : α), x a = x (rangeSplitting f (rangeFactorization f a))} y : β → M ys : y ∈ s a : α ⊢ (y ∘ f) a = (y ∘ f) (rangeSplitting f (rangeFactorization f a)) [PROOFSTEP] rw [Function.comp_apply, Function.comp_apply, apply_rangeSplitting f, rangeFactorization_coe]
[STATEMENT] lemma inverse_diff_inverse: fixes a b :: "'a::division_ring" assumes "a \<noteq> 0" and "b \<noteq> 0" shows "inverse a - inverse b = - (inverse a * (a - b) * inverse b)" [PROOF STATE] proof (prove) goal (1 subgoal): 1. inverse a - inverse b = - (inverse a * (a - b) * inverse b) [PROOF STEP] using assms [PROOF STATE] proof (prove) using this: a \<noteq> (0::'a) b \<noteq> (0::'a) goal (1 subgoal): 1. inverse a - inverse b = - (inverse a * (a - b) * inverse b) [PROOF STEP] by (simp add: algebra_simps)
corollary\<^marker>\<open>tag unimportant\<close> contour_integral_uniform_limit_circlepath: assumes "\<forall>\<^sub>F n::'a in F. (f n) contour_integrable_on (circlepath z r)" and "uniform_limit (sphere z r) f l F" and "\<not> trivial_limit F" "0 < r" shows "l contour_integrable_on (circlepath z r)" "((\<lambda>n. contour_integral (circlepath z r) (f n)) \<longlongrightarrow> contour_integral (circlepath z r) l) F"
#!/usr/bin/env python # -*- coding: utf-8 -*- # Import modules import pytest import numpy as np # Import from package from pyswarms.single import GlobalBestPSO from pyswarms.utils.functions.single_obj import sphere_func @pytest.mark.parametrize( "options", [{"c2": 0.7, "w": 0.5}, {"c1": 0.5, "w": 0.5}, {"c1": 0.5, "c2": 0.7}], ) def test_keyword_exception(options): """Tests if exceptions are thrown when keywords are missing""" with pytest.raises(KeyError): GlobalBestPSO(5, 2, options) @pytest.mark.parametrize( "bounds", [ tuple(np.array([-5, -5])), (np.array([-5, -5, -5]), np.array([5, 5])), (np.array([-5, -5, -5]), np.array([5, 5, 5])), ], ) def test_bounds_size_exception(bounds, options): """Tests if exceptions are raised when bound sizes are wrong""" with pytest.raises(IndexError): GlobalBestPSO(5, 2, options=options, bounds=bounds) @pytest.mark.parametrize( "bounds", [ (np.array([5, 5]), np.array([-5, -5])), (np.array([5, -5]), np.array([-5, 5])), ], ) def test_bounds_maxmin_exception(bounds, options): """Tests if the max bounds is less than min bounds and vice-versa""" with pytest.raises(ValueError): GlobalBestPSO(5, 2, options=options, bounds=bounds) @pytest.mark.parametrize( "bounds", [ [np.array([-5, -5]), np.array([5, 5])], np.array([np.array([-5, -5]), np.array([5, 5])]), ], ) def test_bound_type_exception(bounds, options): """Tests if exception is raised when bound type is not a tuple""" with pytest.raises(TypeError): GlobalBestPSO(5, 2, options=options, bounds=bounds) @pytest.mark.parametrize("velocity_clamp", [(1, 1, 1), (2, 3, 1)]) def test_vclamp_shape_exception(velocity_clamp, options): """Tests if exception is raised when velocity_clamp's size is not equal to 2""" with pytest.raises(IndexError): GlobalBestPSO(5, 2, velocity_clamp=velocity_clamp, options=options) @pytest.mark.parametrize("velocity_clamp", [(3, 2), (10, 8)]) def test_vclamp_maxmin_exception(velocity_clamp, options): """Tests if the max velocity_clamp is less than min velocity_clamp and vice-versa""" with pytest.raises(ValueError): GlobalBestPSO(5, 2, velocity_clamp=velocity_clamp, options=options) @pytest.mark.parametrize("err, center", [(IndexError, [1.5, 3.2, 2.5])]) def test_center_exception(err, center, options): """Tests if exception is thrown when center is not a list or of different shape""" with pytest.raises(err): GlobalBestPSO(5, 2, center=center, options=options) def test_reset_default_values(gbest_reset): """Tests if best cost and best pos are set properly when the reset() method is called""" assert gbest_reset.swarm.best_cost == np.inf assert set(gbest_reset.swarm.best_pos) == set(np.array([])) @pytest.mark.parametrize( "history, expected_shape", [ ("cost_history", (1000,)), ("mean_pbest_history", (1000,)), ("mean_neighbor_history", (1000,)), ("pos_history", (1000, 10, 2)), ("velocity_history", (1000, 10, 2)), ], ) def test_training_history_shape(gbest_history, history, expected_shape): """Test if training histories are of expected shape""" pso = vars(gbest_history) assert np.array(pso[history]).shape == expected_shape def test_ftol_effect(options): """Test if setting the ftol breaks the optimization process accodingly""" pso = GlobalBestPSO(10, 2, options=options, ftol=1e-1) pso.optimize(sphere_func, 2000, verbose=0) assert np.array(pso.cost_history).shape != (2000,)
{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-} -- | -- Module : Statistics.Distribution.Binomial -- Copyright : (c) 2009 Bryan O'Sullivan -- License : BSD3 -- -- Maintainer : [email protected] -- Stability : experimental -- Portability : portable -- -- The binomial distribution. This is the discrete probability -- distribution of the number of successes in a sequence of /n/ -- independent yes\/no experiments, each of which yields success with -- probability /p/. module Statistics.Distribution.Binomial ( BinomialDistribution -- * Constructors , binomial -- * Accessors , bdTrials , bdProbability ) where import Data.Aeson (FromJSON, ToJSON) import Data.Binary (Binary) import Data.Data (Data, Typeable) import GHC.Generics (Generic) import qualified Statistics.Distribution as D import qualified Statistics.Distribution.Poisson.Internal as I import Numeric.SpecFunctions (choose,incompleteBeta) import Numeric.MathFunctions.Constants (m_epsilon) import Data.Binary (put, get) import Control.Applicative ((<$>), (<*>)) -- | The binomial distribution. data BinomialDistribution = BD { bdTrials :: {-# UNPACK #-} !Int -- ^ Number of trials. , bdProbability :: {-# UNPACK #-} !Double -- ^ Probability. } deriving (Eq, Read, Show, Typeable, Data, Generic) instance FromJSON BinomialDistribution instance ToJSON BinomialDistribution instance Binary BinomialDistribution where put (BD x y) = put x >> put y get = BD <$> get <*> get instance D.Distribution BinomialDistribution where cumulative = cumulative instance D.DiscreteDistr BinomialDistribution where probability = probability instance D.Mean BinomialDistribution where mean = mean instance D.Variance BinomialDistribution where variance = variance instance D.MaybeMean BinomialDistribution where maybeMean = Just . D.mean instance D.MaybeVariance BinomialDistribution where maybeStdDev = Just . D.stdDev maybeVariance = Just . D.variance instance D.Entropy BinomialDistribution where entropy (BD n p) | n == 0 = 0 | n <= 100 = directEntropy (BD n p) | otherwise = I.poissonEntropy (fromIntegral n * p) instance D.MaybeEntropy BinomialDistribution where maybeEntropy = Just . D.entropy -- This could be slow for big n probability :: BinomialDistribution -> Int -> Double probability (BD n p) k | k < 0 || k > n = 0 | n == 0 = 1 | otherwise = choose n k * p^k * (1-p)^(n-k) -- Summation from different sides required to reduce roundoff errors cumulative :: BinomialDistribution -> Double -> Double cumulative (BD n p) x | isNaN x = error "Statistics.Distribution.Binomial.cumulative: NaN input" | isInfinite x = if x > 0 then 1 else 0 | k < 0 = 0 | k >= n = 1 | otherwise = incompleteBeta (fromIntegral (n-k)) (fromIntegral (k+1)) (1 - p) where k = floor x mean :: BinomialDistribution -> Double mean (BD n p) = fromIntegral n * p variance :: BinomialDistribution -> Double variance (BD n p) = fromIntegral n * p * (1 - p) directEntropy :: BinomialDistribution -> Double directEntropy d@(BD n _) = negate . sum $ takeWhile (< negate m_epsilon) $ dropWhile (not . (< negate m_epsilon)) $ [ let x = probability d k in x * log x | k <- [0..n]] -- | Construct binomial distribution. Number of trials must be -- non-negative and probability must be in [0,1] range binomial :: Int -- ^ Number of trials. -> Double -- ^ Probability. -> BinomialDistribution binomial n p | n < 0 = error $ msg ++ "number of trials must be non-negative. Got " ++ show n | p < 0 || p > 1 = error $ msg++"probability must be in [0,1] range. Got " ++ show p | otherwise = BD n p where msg = "Statistics.Distribution.Binomial.binomial: "
# clear the environment ======================================================== rm(list=ls()) gc() setwd("P:/torabif/workspace/CCU0002-03") # load options, packages and functions ========================================= source("01_load.r") # create data ================================================================== # Run '02', '03' and '04' scripts in Eclipse # prepare data for analysis ==================================================== source("03a_save_data.r") source("04a_sample_selection_summary.r") # report ======================================================================= # for gitlab render( input = "README.Rmd", output_format = md_document(), quiet = TRUE ) # for local viewing render( input = "README.rmd", output_file = "README.html", quiet = TRUE )
-- Andreas, 2012-09-15 -- Positive effects of making Agda recognize constant functions. -- Arguments to constant functions are ignored in definitional equality. {-# OPTIONS --copatterns #-} module NonvariantPolarity where open import Common.Equality data ⊥ : Set where record ⊤ : Set where constructor trivial data Bool : Set where true false : Bool True : Bool → Set True true = ⊤ True false = ⊥ module IgnoreArg where -- A function ignoring its first argument knot : Bool → Bool → Bool knot x true = false knot x false = true test : (y : Bool) → knot true y ≡ knot false y test y = refl module UnusedModulePar where -- An unused module parameter module M (x : Bool) where not : Bool → Bool not true = false not false = true open M true open M false renaming (not to not′) test : (y : Bool) → not y ≡ not′ y test y = refl module CoinductiveUnit where record Unit : Set where coinductive constructor delay field force : Unit open Unit -- The identity on Unit does not match on its argument, so it is constant. id : Unit → Unit force (id x) = id (force x) idConst : (x y : Unit) → id x ≡ id y idConst x y = refl -- That does not imply x ≡ y (needs bisimulation).
theory Lexer imports Spec begin section {* The Lexer Functions by Sulzmann and Lu *} fun mkeps :: "rexp \<Rightarrow> val" where "mkeps(ONE) = Void" | "mkeps(SEQ r1 r2) = Seq (mkeps r1) (mkeps r2)" | "mkeps(ALT r1 r2) = (if nullable(r1) then Left (mkeps r1) else Right (mkeps r2))" | "mkeps(STAR r) = Stars []" fun injval :: "rexp \<Rightarrow> char \<Rightarrow> val \<Rightarrow> val" where "injval (CR d) c Void = Char d" | "injval (ALT r1 r2) c (Left v1) = Left(injval r1 c v1)" | "injval (ALT r1 r2) c (Right v2) = Right(injval r2 c v2)" | "injval (SEQ r1 r2) c (Seq v1 v2) = Seq (injval r1 c v1) v2" | "injval (SEQ r1 r2) c (Left (Seq v1 v2)) = Seq (injval r1 c v1) v2" | "injval (SEQ r1 r2) c (Right v2) = Seq (mkeps r1) (injval r2 c v2)" | "injval (STAR r) c (Seq v (Stars vs)) = Stars ((injval r c v) # vs)" fun lexer :: "rexp \<Rightarrow> string \<Rightarrow> val option" where "lexer r [] = (if nullable r then Some(mkeps r) else None)" | "lexer r (c#s) = (case (lexer (der c r) s) of None \<Rightarrow> None | Some(v) \<Rightarrow> Some(injval r c v))" section {* Mkeps, Injval Properties *} lemma mkeps_nullable: assumes "nullable(r)" shows "\<Turnstile> mkeps r : r" using assms by (induct rule: nullable.induct) (auto intro: Prf.intros) lemma mkeps_flat: assumes "nullable(r)" shows "flat (mkeps r) = []" using assms by (induct rule: nullable.induct) (auto) lemma Prf_injval_flat: assumes "\<Turnstile> v : der c r" shows "flat (injval r c v) = c # (flat v)" using assms apply(induct c r arbitrary: v rule: der.induct) apply(auto elim!: Prf_elims intro: mkeps_flat split: if_splits) done lemma Prf_injval: assumes "\<Turnstile> v : der c r" shows "\<Turnstile> (injval r c v) : r" using assms apply(induct r arbitrary: c v rule: rexp.induct) apply(auto intro!: Prf.intros mkeps_nullable elim!: Prf_elims split: if_splits) apply(simp add: Prf_injval_flat) done text {* Mkeps and injval produce, or preserve, Posix values. *} lemma Posix_mkeps: assumes "nullable r" shows "[] \<in> r \<rightarrow> mkeps r" using assms apply(induct r rule: nullable.induct) apply(auto intro: Posix.intros simp add: nullable_correctness Sequ_def) apply(subst append.simps(1)[symmetric]) apply(rule Posix.intros) apply(auto) done lemma Posix_injval: assumes "s \<in> (der c r) \<rightarrow> v" shows "(c # s) \<in> r \<rightarrow> (injval r c v)" using assms proof(induct r arbitrary: s v rule: rexp.induct) case ZERO have "s \<in> der c ZERO \<rightarrow> v" by fact then have "s \<in> ZERO \<rightarrow> v" by simp then have "False" by cases then show "(c # s) \<in> ZERO \<rightarrow> (injval ZERO c v)" by simp next case ONE have "s \<in> der c ONE \<rightarrow> v" by fact then have "s \<in> ZERO \<rightarrow> v" by simp then have "False" by cases then show "(c # s) \<in> ONE \<rightarrow> (injval ONE c v)" by simp next case (CR d) consider (eq) "c = d" | (ineq) "c \<noteq> d" by blast then show "(c # s) \<in> (CR d) \<rightarrow> (injval (CR d) c v)" proof (cases) case eq have "s \<in> der c (CR d) \<rightarrow> v" by fact then have "s \<in> ONE \<rightarrow> v" using eq by simp then have eqs: "s = [] \<and> v = Void" by cases simp show "(c # s) \<in> CR d \<rightarrow> injval (CR d) c v" using eq eqs by (auto intro: Posix.intros) next case ineq have "s \<in> der c (CR d) \<rightarrow> v" by fact then have "s \<in> ZERO \<rightarrow> v" using ineq by simp then have "False" by cases then show "(c # s) \<in> CR d \<rightarrow> injval (CR d) c v" by simp qed next case (ALT r1 r2) have IH1: "\<And>s v. s \<in> der c r1 \<rightarrow> v \<Longrightarrow> (c # s) \<in> r1 \<rightarrow> injval r1 c v" by fact have IH2: "\<And>s v. s \<in> der c r2 \<rightarrow> v \<Longrightarrow> (c # s) \<in> r2 \<rightarrow> injval r2 c v" by fact have "s \<in> der c (ALT r1 r2) \<rightarrow> v" by fact then have "s \<in> ALT (der c r1) (der c r2) \<rightarrow> v" by simp then consider (left) v' where "v = Left v'" "s \<in> der c r1 \<rightarrow> v'" | (right) v' where "v = Right v'" "s \<notin> L (der c r1)" "s \<in> der c r2 \<rightarrow> v'" by cases auto then show "(c # s) \<in> ALT r1 r2 \<rightarrow> injval (ALT r1 r2) c v" proof (cases) case left have "s \<in> der c r1 \<rightarrow> v'" by fact then have "(c # s) \<in> r1 \<rightarrow> injval r1 c v'" using IH1 by simp then have "(c # s) \<in> ALT r1 r2 \<rightarrow> injval (ALT r1 r2) c (Left v')" by (auto intro: Posix.intros) then show "(c # s) \<in> ALT r1 r2 \<rightarrow> injval (ALT r1 r2) c v" using left by simp next case right have "s \<notin> L (der c r1)" by fact then have "c # s \<notin> L r1" by (simp add: der_correctness Der_def) moreover have "s \<in> der c r2 \<rightarrow> v'" by fact then have "(c # s) \<in> r2 \<rightarrow> injval r2 c v'" using IH2 by simp ultimately have "(c # s) \<in> ALT r1 r2 \<rightarrow> injval (ALT r1 r2) c (Right v')" by (auto intro: Posix.intros) then show "(c # s) \<in> ALT r1 r2 \<rightarrow> injval (ALT r1 r2) c v" using right by simp qed next case (SEQ r1 r2) have IH1: "\<And>s v. s \<in> der c r1 \<rightarrow> v \<Longrightarrow> (c # s) \<in> r1 \<rightarrow> injval r1 c v" by fact have IH2: "\<And>s v. s \<in> der c r2 \<rightarrow> v \<Longrightarrow> (c # s) \<in> r2 \<rightarrow> injval r2 c v" by fact have "s \<in> der c (SEQ r1 r2) \<rightarrow> v" by fact then consider (left_nullable) v1 v2 s1 s2 where "v = Left (Seq v1 v2)" "s = s1 @ s2" "s1 \<in> der c r1 \<rightarrow> v1" "s2 \<in> r2 \<rightarrow> v2" "nullable r1" "\<not> (\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = s2 \<and> s1 @ s\<^sub>3 \<in> L (der c r1) \<and> s\<^sub>4 \<in> L r2)" | (right_nullable) v1 s1 s2 where "v = Right v1" "s = s1 @ s2" "s \<in> der c r2 \<rightarrow> v1" "nullable r1" "s1 @ s2 \<notin> L (SEQ (der c r1) r2)" | (not_nullable) v1 v2 s1 s2 where "v = Seq v1 v2" "s = s1 @ s2" "s1 \<in> der c r1 \<rightarrow> v1" "s2 \<in> r2 \<rightarrow> v2" "\<not>nullable r1" "\<not> (\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = s2 \<and> s1 @ s\<^sub>3 \<in> L (der c r1) \<and> s\<^sub>4 \<in> L r2)" by (force split: if_splits elim!: Posix_elims simp add: Sequ_def der_correctness Der_def) then show "(c # s) \<in> SEQ r1 r2 \<rightarrow> injval (SEQ r1 r2) c v" proof (cases) case left_nullable have "s1 \<in> der c r1 \<rightarrow> v1" by fact then have "(c # s1) \<in> r1 \<rightarrow> injval r1 c v1" using IH1 by simp moreover have "\<not> (\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = s2 \<and> s1 @ s\<^sub>3 \<in> L (der c r1) \<and> s\<^sub>4 \<in> L r2)" by fact then have "\<not> (\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = s2 \<and> (c # s1) @ s\<^sub>3 \<in> L r1 \<and> s\<^sub>4 \<in> L r2)" by (simp add: der_correctness Der_def) ultimately have "((c # s1) @ s2) \<in> SEQ r1 r2 \<rightarrow> Seq (injval r1 c v1) v2" using left_nullable by (rule_tac Posix.intros) then show "(c # s) \<in> SEQ r1 r2 \<rightarrow> injval (SEQ r1 r2) c v" using left_nullable by simp next case right_nullable have "nullable r1" by fact then have "[] \<in> r1 \<rightarrow> (mkeps r1)" by (rule Posix_mkeps) moreover have "s \<in> der c r2 \<rightarrow> v1" by fact then have "(c # s) \<in> r2 \<rightarrow> (injval r2 c v1)" using IH2 by simp moreover have "s1 @ s2 \<notin> L (SEQ (der c r1) r2)" by fact then have "\<not> (\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = c # s \<and> [] @ s\<^sub>3 \<in> L r1 \<and> s\<^sub>4 \<in> L r2)" using right_nullable by(auto simp add: der_correctness Der_def append_eq_Cons_conv Sequ_def) ultimately have "([] @ (c # s)) \<in> SEQ r1 r2 \<rightarrow> Seq (mkeps r1) (injval r2 c v1)" by(rule Posix.intros) then show "(c # s) \<in> SEQ r1 r2 \<rightarrow> injval (SEQ r1 r2) c v" using right_nullable by simp next case not_nullable have "s1 \<in> der c r1 \<rightarrow> v1" by fact then have "(c # s1) \<in> r1 \<rightarrow> injval r1 c v1" using IH1 by simp moreover have "\<not> (\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = s2 \<and> s1 @ s\<^sub>3 \<in> L (der c r1) \<and> s\<^sub>4 \<in> L r2)" by fact then have "\<not> (\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = s2 \<and> (c # s1) @ s\<^sub>3 \<in> L r1 \<and> s\<^sub>4 \<in> L r2)" by (simp add: der_correctness Der_def) ultimately have "((c # s1) @ s2) \<in> SEQ r1 r2 \<rightarrow> Seq (injval r1 c v1) v2" using not_nullable by (rule_tac Posix.intros) (simp_all) then show "(c # s) \<in> SEQ r1 r2 \<rightarrow> injval (SEQ r1 r2) c v" using not_nullable by simp qed next case (STAR r) have IH: "\<And>s v. s \<in> der c r \<rightarrow> v \<Longrightarrow> (c # s) \<in> r \<rightarrow> injval r c v" by fact have "s \<in> der c (STAR r) \<rightarrow> v" by fact then consider (cons) v1 vs s1 s2 where "v = Seq v1 (Stars vs)" "s = s1 @ s2" "s1 \<in> der c r \<rightarrow> v1" "s2 \<in> (STAR r) \<rightarrow> (Stars vs)" "\<not> (\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = s2 \<and> s1 @ s\<^sub>3 \<in> L (der c r) \<and> s\<^sub>4 \<in> L (STAR r))" apply(auto elim!: Posix_elims(1-5) simp add: der_correctness Der_def intro: Posix.intros) apply(rotate_tac 3) apply(erule_tac Posix_elims(6)) apply (simp add: Posix.intros(6)) using Posix.intros(7) by blast then show "(c # s) \<in> STAR r \<rightarrow> injval (STAR r) c v" proof (cases) case cons have "s1 \<in> der c r \<rightarrow> v1" by fact then have "(c # s1) \<in> r \<rightarrow> injval r c v1" using IH by simp moreover have "s2 \<in> STAR r \<rightarrow> Stars vs" by fact moreover have "(c # s1) \<in> r \<rightarrow> injval r c v1" by fact then have "flat (injval r c v1) = (c # s1)" by (rule Posix1) then have "flat (injval r c v1) \<noteq> []" by simp moreover have "\<not> (\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = s2 \<and> s1 @ s\<^sub>3 \<in> L (der c r) \<and> s\<^sub>4 \<in> L (STAR r))" by fact then have "\<not> (\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = s2 \<and> (c # s1) @ s\<^sub>3 \<in> L r \<and> s\<^sub>4 \<in> L (STAR r))" by (simp add: der_correctness Der_def) ultimately have "((c # s1) @ s2) \<in> STAR r \<rightarrow> Stars (injval r c v1 # vs)" by (rule Posix.intros) then show "(c # s) \<in> STAR r \<rightarrow> injval (STAR r) c v" using cons by(simp) qed qed section {* Lexer Correctness *} lemma lexer_correct_None: shows "s \<notin> L r \<longleftrightarrow> lexer r s = None" apply(induct s arbitrary: r) apply(simp) apply(simp add: nullable_correctness) apply(simp) apply(drule_tac x="der a r" in meta_spec) apply(auto) apply(auto simp add: der_correctness Der_def) done lemma lexer_correct_Some: shows "s \<in> L r \<longleftrightarrow> (\<exists>v. lexer r s = Some(v) \<and> s \<in> r \<rightarrow> v)" apply(induct s arbitrary : r) apply(simp only: lexer.simps) apply(simp) apply(simp add: nullable_correctness Posix_mkeps) apply(drule_tac x="der a r" in meta_spec) apply(simp (no_asm_use) add: der_correctness Der_def del: lexer.simps) apply(simp del: lexer.simps) apply(simp only: lexer.simps) apply(case_tac "lexer (der a r) s = None") apply(auto)[1] apply(simp) apply(erule exE) apply(simp) apply(rule iffI) apply(simp add: Posix_injval) apply(simp add: Posix1(1)) done lemma lexer_correctness: shows "(lexer r s = Some v) \<longleftrightarrow> s \<in> r \<rightarrow> v" and "(lexer r s = None) \<longleftrightarrow> \<not>(\<exists>v. s \<in> r \<rightarrow> v)" using Posix1(1) Posix_determ lexer_correct_None lexer_correct_Some apply fastforce using Posix1(1) lexer_correct_None lexer_correct_Some by blast fun flex :: "rexp \<Rightarrow> (val \<Rightarrow> val) => string \<Rightarrow> (val \<Rightarrow> val)" where "flex r f [] = f" | "flex r f (c#s) = flex (der c r) (\<lambda>v. f (injval r c v)) s" lemma flex_fun_apply: shows "g (flex r f s v) = flex r (g o f) s v" apply(induct s arbitrary: g f r v) apply(simp_all add: comp_def) by meson lemma flex_append: shows "flex r f (s1 @ s2) = flex (ders s1 r) (flex r f s1) s2" apply(induct s1 arbitrary: s2 r f) apply(simp_all) done lemma lexer_flex: shows "lexer r s = (if nullable (ders s r) then Some(flex r id s (mkeps (ders s r))) else None)" apply(induct s arbitrary: r) apply(simp_all add: flex_fun_apply) done unused_thms end
Formal statement is: lemma Bseq_ignore_initial_segment: "Bseq X \<Longrightarrow> Bseq (\<lambda>n. X (n + k))" Informal statement is: If $X$ is a bounded sequence, then so is the sequence $X$ shifted by $k$ positions.
State Before: F : Type ?u.75344 α : Type u_1 β : Type ?u.75350 inst✝¹ : LinearOrderedSemiring α inst✝ : FloorSemiring α a✝ : α n : ℕ a : α ⊢ Nat.cast ⁻¹' Iio a = Iio ⌈a⌉₊ State After: case h F : Type ?u.75344 α : Type u_1 β : Type ?u.75350 inst✝¹ : LinearOrderedSemiring α inst✝ : FloorSemiring α a✝ : α n : ℕ a : α x✝ : ℕ ⊢ x✝ ∈ Nat.cast ⁻¹' Iio a ↔ x✝ ∈ Iio ⌈a⌉₊ Tactic: ext State Before: case h F : Type ?u.75344 α : Type u_1 β : Type ?u.75350 inst✝¹ : LinearOrderedSemiring α inst✝ : FloorSemiring α a✝ : α n : ℕ a : α x✝ : ℕ ⊢ x✝ ∈ Nat.cast ⁻¹' Iio a ↔ x✝ ∈ Iio ⌈a⌉₊ State After: no goals Tactic: simp [lt_ceil]
set.seed(1234) R2_bootstrap <- function(model, n.sim = 10000) { # bootstrap n.sim times to calc pseudo r-squared values: lmer_bs <- bootMer(model, FUN=function(x)r.squaredGLMM(x), nsim=n.sim) # calculate median and 0.025,0.975 percentiles for R2c and R2m: lmer_bs_R2 <- as.data.frame(lmer_bs$t) %>% rownames_to_column(var = "type_R2") %>% rename(R2=V1) %>% mutate(type_R2 = substr(type_R2,1,3)) %>% group_by(type_R2) %>% mutate(median = median(R2), ll = quantile(R2,0.025), ul = quantile(R2, 0.975)) # return bootstrap data: return(lmer_bs_R2) }
function dl=lpcaa2dl(aa) %LPCAA2DL LPC: Convert area coefficients to dct of log area DL=(AA) % note: we do not correct for sinc distortion; perhaps we should multiply by % k=1:p-1;s=[sqrt(0.5)/p 2*sin(pi*k/(2*p))./(pi*k)]; % Copyright (C) Mike Brookes 1998 % Version: $Id: lpcaa2dl.m,v 1.4 2007/05/04 07:01:38 dmb Exp $ % % 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. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% [nf,p2]=size(aa); dl=rdct(log(aa(:,2:p2-1)./aa(:,p2*ones(1,p2-2))).').';
function one_phase_solve(m::JuMP.Model) nlp_raw = MathOptNLPModel(m); return one_phase_solve(nlp_raw) end function one_phase_solve(m::JuMP.Model, pars::Class_parameters) nlp_raw = MathOptNLPModel(m); return one_phase_solve(nlp_raw, pars::Class_parameters) end function one_phase_solve(nlp_raw::NLPModels.AbstractNLPModel) pars = Class_parameters() return one_phase_solve(nlp_raw, pars) end function one_phase_solve(nlp_raw::NLPModels.AbstractNLPModel, pars::Class_parameters) nlp = Class_CUTEst(nlp_raw); if ncon(nlp) == 0 throw(ErrorException("Unconstrained minimization problems are unsupported")) end timer = class_advanced_timer() start_advanced_timer(timer) start_advanced_timer(timer, "INIT") if pars.init.init_style == :gertz intial_it = gertz_init(nlp, pars, timer); # Gertz, Michael, Jorge Nocedal, and A. Sartenar. "A starting point strategy for nonlinear interior methods." Applied mathematics letters 17.8 (2004): 945-952. elseif pars.init.init_style == :mehrotra intial_it = mehrotra_init(nlp, pars, timer); elseif pars.init.init_style == :LP intial_it = LP_init(nlp, pars, timer); else error("Init strategy does not exist") end pause_advanced_timer(timer, "INIT") pause_advanced_timer(timer) if pars.output_level >= 4 print_timer_stats(timer) end start_advanced_timer(timer) @assert(is_feasible(intial_it, pars.ls.comp_feas)) iter, status, hist, t, err = one_phase_IPM(intial_it, pars, timer); pause_advanced_timer(timer) if pars.output_level >= 3 print_timer_stats(timer) end return iter, status, hist, t, err, timer end function switching_condition(iter::Class_iterate, last_step_was_superlinear::Bool, pars::Class_parameters) # should we take an aggressive step or not? is_feas = is_feasible(iter, pars.ls.comp_feas_agg) dual_avg = scaled_dual_feas(iter, pars) if pars.primal_bounds_dual_feas dual_progress = dual_avg < pars.aggressive_dual_threshold * LinearAlgebra.norm(get_primal_res(iter), Inf) else dual_progress = dual_avg < pars.aggressive_dual_threshold * get_mu(iter) end delta_small = get_delta(iter) < sqrt(get_mu(iter)) * max(0.1, LinearAlgebra.norm(get_y(iter),Inf)) lag_grad = LinearAlgebra.norm(eval_grad_lag(iter,get_mu(iter)),1) < sum(iter.point.s .* iter.point.y) + LinearAlgebra.norm(get_grad(iter) + iter.point.mu * eval_grad_r(iter),1) # + LinearAlgebra.norm(get_primal_res(iter), Inf) + 1.0 #+ sqrt(LinearAlgebra.norm(get_y(iter),Inf)) be_aggressive = is_feas && dual_progress && lag_grad be_aggressive |= last_step_was_superlinear && dual_progress && lag_grad return be_aggressive end function one_phase_IPM(iter::Class_iterate, pars::Class_parameters, timer::class_advanced_timer) ##################################################################### # THE MAIN ALGORITHM # input: # iter = starting point # pars = parameters for running the algorithm # timer = code to time the algorithm ##################################################################### # intialize code t = 0; rpt = 0.0 progress = Array{alg_history2,1}(); filter = Array{Class_filter,1}(); update!(iter, timer, pars) # is this necessary ???? kkt_solver = pick_KKT_solver(pars); initialize!(kkt_solver, iter) if pars.output_level >= 1 head_progress() end display = pars.output_level >= 1 record_progress_first_it!(progress, iter, kkt_solver, pars, display) if pars.output_level >= 4 println("") end init_step_size = 1.0 status = :success agg_next_step = false; dir_size_agg = Inf dir_size_stable = 0.0 ls_info = false start_time = time() last_step_was_superlinear = false scale_update = false # check termination critieron at starting point start_advanced_timer(timer, "misc/terminate") status = terminate(iter, pars) pause_advanced_timer(timer, "misc/terminate") if status != false if pars.output_level >= 1 println("Terminated with ", status) end return iter, status, progress, t, false end if time() - start_time > pars.term.max_time if pars.output_level >= 1 println("Terminated due to timeout") end return iter, :MAX_TIME, progress, t, false end # run the algorithm for t = 1:pars.term.max_it @assert(is_feasible(iter, pars.ls.comp_feas)) for i = 1:pars.max_it_corrections if pars.output_level >= 4 println("================================== ITERATION $t, MINOR ITERATION $i ======================================") end if pars.output_level >= 5 println("Strict comp = ", maximum(min.(iter.point.s/LinearAlgebra.norm(iter.point.s,Inf),iter.point.y/LinearAlgebra.norm(iter.point.y,Inf)))) end tot_num_fac = 0; inertia_num_fac = 0; start_advanced_timer(timer, "misc/checks") be_aggressive = switching_condition(iter, last_step_was_superlinear, pars) # should we take an aggressive step or not? last_step_was_superlinear = false pause_advanced_timer(timer, "misc/checks") if i == 1 ########################################################################################## ##### first step of iteration, we need to compute lag hessian and do a factorization ##### ########################################################################################## update_H!(iter, timer, pars) @assert(is_updated(iter.cache)) # form matrix that we are going to factorize form_system!(kkt_solver, iter, timer) start_advanced_timer(timer, "ipopt_strategy") # Figures out what delta will give fact_succeed, inertia_num_fac, new_delta = ipopt_strategy!(iter, kkt_solver, pars, timer) tot_num_fac = inertia_num_fac old_delta = get_delta(iter) set_delta(iter, new_delta) pause_advanced_timer(timer, "ipopt_strategy") if fact_succeed != :success return iter, :MAX_DELTA, progress, t, false end start_advanced_timer(timer, "STEP") start_advanced_timer(timer, "STEP/first") if pars.output_level >= 5 println(pd("**"), pd("status"), pd("delta"), pd("a_P"), pd("dx"), pd("dy"), pd("ds")) end for k = 1:100 #status, new_iter, ls_info = take_step!(iter, reduct_factors, kkt_solver, ls_mode, filter, pars, actual_min_step_size, timer) step_status, new_iter, ls_info, reduct_factors = take_step2!(be_aggressive, iter, kkt_solver, filter, pars, timer) if pars.output_level >= 6 println("") println(pd("**"), pd(step_status), rd(get_delta(iter)), rd(ls_info.step_size_P), rd(LinearAlgebra.norm(kkt_solver.dir.x,Inf)), rd(LinearAlgebra.norm(kkt_solver.dir.y,Inf)), rd(LinearAlgebra.norm(kkt_solver.dir.s,Inf))) end if step_status == :success break elseif i < 100 && get_delta(iter) < pars.delta.max if pars.test.response_to_failure == :lag_delta_inc set_delta(iter, max(LinearAlgebra.norm(eval_grad_lag(iter,iter.point.mu),Inf) / LinearAlgebra.norm(kkt_solver.dir.x,Inf),get_delta(iter) * pars.delta.inc, max(pars.delta.start, old_delta * pars.delta.dec))) elseif pars.test.response_to_failure == :default set_delta(iter, max(get_delta(iter) * pars.delta.inc, max(pars.delta.start, old_delta * pars.delta.dec))) else error("pars.test.response_to_failure parameter incorrectly set") end inertia = factor!(kkt_solver, get_delta(iter), timer) tot_num_fac += 1 elseif LinearAlgebra.norm(comp(iter),Inf) > 1e-14 warn("Error ... large delta causing issues") iter.point.y = iter.point.mu ./ iter.point.s step_status = :success break else pause_advanced_timer(timer, "STEP/first") pause_advanced_timer(timer, "STEP") println("Terminated due to max delta while attempting to take step") println("delta=$(get_delta(iter)), be_aggressive=$be_aggressive, status=$step_status") println("dx = $(LinearAlgebra.norm(kkt_solver.dir.x,2)), dy = $(LinearAlgebra.norm(kkt_solver.dir.y,2)), ds = $(LinearAlgebra.norm(kkt_solver.dir.s,2))") @show reduct_factors #, ls_mode @show ls_info return iter, :MAX_DELTA, progress, t, false end end pause_advanced_timer(timer, "STEP/first") pause_advanced_timer(timer, "STEP") else ####################################### ### corrections, reuse factorization ## ####################################### start_advanced_timer(timer, "STEP") start_advanced_timer(timer, "STEP/correction") step_status, new_iter, ls_info, reduct_factors = take_step2!(be_aggressive, iter, kkt_solver, filter, pars, timer) if pars.superlinear_theory_mode && be_aggressive if get_mu(new_iter) < get_mu(iter) * 0.1 last_step_was_superlinear = true end end pause_advanced_timer(timer, "STEP/correction") pause_advanced_timer(timer, "STEP") end if step_status == :success iter = new_iter if be_aggressive dir_size_agg = LinearAlgebra.norm(kkt_solver.dir.x, 2) end end add!(filter, iter, pars) # update filter start_advanced_timer(timer, "misc/terminate") status = terminate(iter, pars) # check termination criteron pause_advanced_timer(timer, "misc/terminate") start_advanced_timer(timer, "misc/record_progress") # output to the console output_level = pars.output_level display = output_level >= 4 || (output_level >= 3 && i == 1) || (output_level == 2 && t % 10 == 1 && i == 1) || (status != false && output_level >= 1) record_progress!(progress, t, be_aggressive ? "agg" : "stb", iter, kkt_solver, ls_info, reduct_factors, inertia_num_fac, tot_num_fac, pars, display) if pars.output_level >= 4 println("") end pause_advanced_timer(timer, "misc/record_progress") @assert(is_updated_correction(iter.cache)) check_for_nan(iter.point) # if termination criteron is satisfied stop the algorithm if status != false if pars.output_level >= 1 println("Terminated with ", status) end return iter, status, progress, t, false end if time() - start_time > pars.term.max_time if pars.output_level >= 1 println("Terminated due to timeout") end return iter, :MAX_TIME, progress, t, false end if step_status != :success break end end end if pars.output_level >= 1 println("Terminated due to max iterations reached") end return iter, :MAX_IT, progress, pars.term.max_it, false end
Require Import List. Import ListNotations. (*Require Import Coq.Lists.ListSet.*) Require Import Extraction. Require Import Unify. Require Import MiniKanrenSyntax. Require Import Stream. Require Import DenotationalSem. Require Import OperationalSem. Require Import OpSemSoundness. Require Import OpSemCompleteness. Module ObviousConstraintStore <: ConstraintStoreSig. Definition constraint_store (s : subst) : Set := list (term * term). Definition init_cs : constraint_store empty_subst := []. Inductive add_constraint_ind_def : forall (s : subst), constraint_store s -> term -> term -> option (constraint_store s) -> Set := | acC : forall s cs t1 t2, add_constraint_ind_def s cs t1 t2 (Some ((t1, t2) :: cs)). Definition add_constraint := add_constraint_ind_def. Lemma add_constraint_exists : forall (s : subst) (cs : constraint_store s) (t1 t2 : term), {r : option (constraint_store s) & add_constraint s cs t1 t2 r}. Proof. intros. eexists. econstructor. Qed. Lemma add_constraint_unique : forall (s : subst) (cs : constraint_store s) (t1 t2 : term) (r r' : option (constraint_store s)), add_constraint s cs t1 t2 r -> add_constraint s cs t1 t2 r' -> r = r'. Proof. intros. good_inversion H. good_inversion H0. simpl_existT_cs_same. reflexivity. Qed. Inductive upd_cs_ind_def : forall (s : subst), constraint_store s -> forall (d : subst), option (constraint_store (compose s d)) -> Set := | uC : forall s cs d, upd_cs_ind_def s cs d (Some cs). Definition upd_cs := upd_cs_ind_def. Lemma upd_cs_exists : forall (s : subst) (cs : constraint_store s) (d : subst), {r : option (constraint_store (compose s d)) & upd_cs s cs d r}. Proof. intros. eexists. econstructor. Qed. Lemma upd_cs_unique : forall (s : subst) (cs : constraint_store s) (d : subst) (r r' : option (constraint_store (compose s d))), upd_cs s cs d r -> upd_cs s cs d r' -> r = r'. Proof. intros. good_inversion H. good_inversion H0. simpl_existT_cs_same. reflexivity. Qed. Definition in_denotational_sem_cs (s : subst) (cs : constraint_store s) (f : repr_fun) := forall (t1 t2 : term), In (t1, t2) cs -> ~ gt_eq (apply_repr_fun f t1) (apply_repr_fun f t2). Notation "[| s , cs , f |]" := (in_denotational_sem_cs s cs f) (at level 0). Lemma init_condition : forall f, [| empty_subst , init_cs , f |]. Proof. unfold in_denotational_sem_cs. contradiction. Qed. Lemma add_constraint_fail_condition : forall (s : subst) (cs : constraint_store s) (t1 t2 : term), add_constraint s cs t1 t2 None -> forall f, ~ ([| s , cs , f |] /\ [ s , f ] /\ [| Disunify t1 t2 , f |]). Proof. intros. inversion H. Qed. Lemma add_constraint_success_condition : forall (s : subst) (cs cs' : constraint_store s) (t1 t2 : term), add_constraint s cs t1 t2 (Some cs') -> forall f, [| s , cs' , f |] /\ [ s , f ] <-> [| s , cs , f |] /\ [ s , f ] /\ [| Disunify t1 t2 , f |]. Proof. unfold in_denotational_sem_cs. intros. good_inversion H. simpl_existT_cs_same. good_inversion H4. split. { intros [DSCS DSS]. split; try split; intros; auto. { apply DSCS. right. auto. } { constructor. apply DSCS. left. auto. } } { intros [DSCS [DSS DSG]]. good_inversion DSG. split; auto. intros. destruct H; auto. good_inversion H; auto. } Qed. Lemma upd_cs_fail_condition : forall (s : subst) (cs : constraint_store s) (d : subst), upd_cs s cs d None -> forall f, ~ ([| s , cs , f |] /\ [ compose s d , f ]). Proof. intros. inversion H. Qed. Lemma upd_cs_success_condition : forall (s : subst) (cs : constraint_store s) (d : subst) (cs' : constraint_store (compose s d)), upd_cs s cs d (Some cs') -> forall f, [| compose s d , cs' , f |] /\ [ compose s d , f ] <-> [| s , cs , f |] /\ [ compose s d , f ]. Proof. unfold in_denotational_sem_cs. intros. good_inversion H. simpl_existT_cs_same. good_inversion H3. reflexivity. Qed. End ObviousConstraintStore. Module OperationalSemObviousCS := OperationalSemAbstr ObviousConstraintStore. Module OperationalSemObviousCSSoundness := OperationalSemSoundnessAbstr ObviousConstraintStore. Module OperationalSemObviousCSCompleteness := OperationalSemCompletenessAbstr ObviousConstraintStore. Import OperationalSemObviousCS. Extraction Language Haskell. Extraction "extracted/obvious_diseq_interpreter.hs" op_sem_exists.
Formal statement is: lemma homotopy_eqv_sing: fixes S :: "'a::real_normed_vector set" and a :: "'b::real_normed_vector" shows "S homotopy_eqv {a} \<longleftrightarrow> S \<noteq> {} \<and> contractible S" Informal statement is: A set $S$ is homotopy equivalent to a single point if and only if $S$ is nonempty and contractible.
State Before: R✝ : Type u S : Type v a b : R✝ m n : ℕ ι : Type y inst✝¹ : Semiring R✝ p✝ : R✝[X] R : Type u_1 inst✝ : Ring R p : R[X] hp : Monic p ⊢ IsRegular p State After: case left R✝ : Type u S : Type v a b : R✝ m n : ℕ ι : Type y inst✝¹ : Semiring R✝ p✝ : R✝[X] R : Type u_1 inst✝ : Ring R p : R[X] hp : Monic p ⊢ IsLeftRegular p case right R✝ : Type u S : Type v a b : R✝ m n : ℕ ι : Type y inst✝¹ : Semiring R✝ p✝ : R✝[X] R : Type u_1 inst✝ : Ring R p : R[X] hp : Monic p ⊢ IsRightRegular p Tactic: constructor State Before: case left R✝ : Type u S : Type v a b : R✝ m n : ℕ ι : Type y inst✝¹ : Semiring R✝ p✝ : R✝[X] R : Type u_1 inst✝ : Ring R p : R[X] hp : Monic p ⊢ IsLeftRegular p State After: case left R✝ : Type u S : Type v a b : R✝ m n : ℕ ι : Type y inst✝¹ : Semiring R✝ p✝ : R✝[X] R : Type u_1 inst✝ : Ring R p : R[X] hp : Monic p q r : R[X] h : (fun x => p * x) q = (fun x => p * x) r ⊢ q = r Tactic: intro q r h State Before: case left R✝ : Type u S : Type v a b : R✝ m n : ℕ ι : Type y inst✝¹ : Semiring R✝ p✝ : R✝[X] R : Type u_1 inst✝ : Ring R p : R[X] hp : Monic p q r : R[X] h : (fun x => p * x) q = (fun x => p * x) r ⊢ q = r State After: case left R✝ : Type u S : Type v a b : R✝ m n : ℕ ι : Type y inst✝¹ : Semiring R✝ p✝ : R✝[X] R : Type u_1 inst✝ : Ring R p : R[X] hp : Monic p q r : R[X] h : p * q = p * r ⊢ q = r Tactic: dsimp only at h State Before: case left R✝ : Type u S : Type v a b : R✝ m n : ℕ ι : Type y inst✝¹ : Semiring R✝ p✝ : R✝[X] R : Type u_1 inst✝ : Ring R p : R[X] hp : Monic p q r : R[X] h : p * q = p * r ⊢ q = r State After: no goals Tactic: rw [← sub_eq_zero, ← hp.mul_right_eq_zero_iff, mul_sub, h, sub_self] State Before: case right R✝ : Type u S : Type v a b : R✝ m n : ℕ ι : Type y inst✝¹ : Semiring R✝ p✝ : R✝[X] R : Type u_1 inst✝ : Ring R p : R[X] hp : Monic p ⊢ IsRightRegular p State After: case right R✝ : Type u S : Type v a b : R✝ m n : ℕ ι : Type y inst✝¹ : Semiring R✝ p✝ : R✝[X] R : Type u_1 inst✝ : Ring R p : R[X] hp : Monic p q r : R[X] h : (fun x => x * p) q = (fun x => x * p) r ⊢ q = r Tactic: intro q r h State Before: case right R✝ : Type u S : Type v a b : R✝ m n : ℕ ι : Type y inst✝¹ : Semiring R✝ p✝ : R✝[X] R : Type u_1 inst✝ : Ring R p : R[X] hp : Monic p q r : R[X] h : (fun x => x * p) q = (fun x => x * p) r ⊢ q = r State After: case right R✝ : Type u S : Type v a b : R✝ m n : ℕ ι : Type y inst✝¹ : Semiring R✝ p✝ : R✝[X] R : Type u_1 inst✝ : Ring R p : R[X] hp : Monic p q r : R[X] h : q * p = r * p ⊢ q = r Tactic: simp only at h State Before: case right R✝ : Type u S : Type v a b : R✝ m n : ℕ ι : Type y inst✝¹ : Semiring R✝ p✝ : R✝[X] R : Type u_1 inst✝ : Ring R p : R[X] hp : Monic p q r : R[X] h : q * p = r * p ⊢ q = r State After: no goals Tactic: rw [← sub_eq_zero, ← hp.mul_left_eq_zero_iff, sub_mul, h, sub_self]
function [xmin,... % Solution, returned as a real vector or real array. fmin,... % Objective function value at the solution, returned as a real number. stopflag,... % Reason cmaes stopped, returned as an integer. out] = ... % Information about the optimization process, returned as a structure my_cmaes(infitfun,... % Function to minimize, specified as a function handle or function name xstart,... % Initial point, specified as a real vector or real array inopts,... % Optimization options, specified as a structure varargin) % Additional arguments to FITFUN % This is a modified version of the CMA-ES optimisation algorithm of % Nikolaus Hansen, GNU General Public License (C) 2001-2008 % The original version is available from http://cma.gforge.inria.fr/ % Differences to the original: % 1. inputs and outputs are consistent with MATLAB's proprietary optimisers % (e.g. fminsearch) % - this requires that old argument INSIGMA is included in OPTS % 2. this version now accepts a function handle as FUN instead of only a % character string % 3. new options: % - inopts.RestartIf: when opts.Restarts>0 it sets a condition whether to % restart ot not % - inopts.flgEvalParallel: this option existed before, but its behaviour % changed, if true or 1 it now triggers parallel evaluation with a % parfor loop % Copyright (C) 2021 L. Trotter % This file is part of the Modular Assessment of Rainfall-Runoff Models % Toolbox (MARRMoT). % MARRMoT is a free software (GNU GPL v3) and distributed WITHOUT ANY % WARRANTY. See <https://www.gnu.org/licenses/> for details. % ORIGINAL COPIRIGHT NOTICE IS AT THE END OF THE FILE as in the original % cmaes.m file. % cmaes.m, Version 3.61.beta, last change: April, 2012 % CMAES implements an Evolution Strategy with Covariance Matrix % Adaptation (CMA-ES) for nonlinear function minimization. For % introductory comments and copyright (GPL) see end of file (type % 'type cmaes'). cmaes.m runs with MATLAB (Windows, Linux) and, % without data logging and plotting, it should run under Octave % (Linux, package octave-forge is needed). % % OPTS = CMAES returns default options. % OPTS = CMAES('defaults') returns default options quietly. % OPTS = CMAES('displayoptions') displays options. % OPTS = CMAES('defaults', OPTS) supplements options OPTS with default % options. % % XMIN = CMAES(FITFUN, XSTART[, OPTS]) locates an approximate minimum % XMIN of function FITFUN starting from column vector XSTART with the initial % coordinate wise search standard deviation OPTS.INSIGMA. % % Input arguments: % % FITFUN is a string function name like 'frosen' or a function hanfle. % FUN takes as argument a column vector of size of XSTART and returns a % scalar. An easy way to implement a hard non-linear constraint is to % return NaN. Then, this function evaluation is not counted and a newly % sampled point is tried immediately. % % XSTART is a column vector, or a matrix, or a string. If XSTART is a matrix, % mean(XSTART, 2) is taken as initial point. If XSTART is a string like % '2*rand(10,1)-1', the string is evaluated first. % % INOPTS (an optional argument) is a struct holding additional input % options. Valid field names and a short documentation can be % discovered by looking at the default options (type 'cmaes' % without arguments, see above). Empty or missing fields in OPTS % invoke the default value, i.e. OPTS needs not to have all valid % field names. Capitalization does not matter and unambiguous % abbreviations can be used for the field names. If a string is % given where a numerical value is needed, the string is evaluated % by eval, where 'N' expands to the problem dimension % (==size(XSTART,1)) and 'popsize' to the population size. % % [XMIN, FMIN, STOPFLAG, OUT] = CMAES(FITFUN, XSTART) % returns the best (minimal) point XMIN (found in the last % generation); function value FMIN of XMIN; an STOPFLAG value as cell array, % where possible entries are 'fitness', 'tolx', 'tolupx', 'tolfun', % 'maxfunevals', 'maxiter', 'stoptoresume', 'manual', % 'warnconditioncov', 'warnnoeffectcoord', 'warnnoeffectaxis', % 'warnequalfunvals', 'warnequalfunvalhist', 'bug' (use % e.g. any(strcmp(STOPFLAG, 'tolx')) or findstr(strcat(STOPFLAG, % 'tolx')) for further processing); a record struct OUTPUT with some % more output, where the struct SOLUTIONS.BESTEVER contains the overall % best evaluated point X with function value F evaluated at evaluation % count EVALS. The last output argument BESTEVER equals % OUT.SOLUTIONS.BESTEVER. Moreover a history of solutions and % parameters is written to files according to the Log-options. % % A regular manual stop can be achieved via the file signals.par. The % program is terminated if the first two non-white sequences in any % line of this file are 'stop' and the value of the LogFilenamePrefix % option (by default 'outcmaes'). Also a run can be skipped. % Given, for example, 'skip outcmaes run 2', skips the second run % if option Restarts is at least 2, and another run will be started. % % To run the code completely silently set Disp, Save, and Log options % to 0. With OPTS.LogModulo > 0 (1 by default) the most important % data are written to ASCII files permitting to investigate the % results (e.g. plot with function plotcmaesdat) even while CMAES is % still running (which can be quite useful on expensive objective % functions). When OPTS.SaveVariables==1 (default) everything is saved % in file OPTS.SaveFilename (default 'variablescmaes.mat') allowing to % resume the search afterwards by using the resume option. % % To find the best ever evaluated point load the variables typing % "es=load('variablescmaes')" and investigate the variable % es.out.solutions.bestever. % % OPTS.INSIGMA is a scalar, or a column vector of size(X0,1), or a string % that can be evaluated into one of these. INSIGMA determines the % initial coordinate wise standard deviations for the search. % Setting INSIGMA one third of the initial search region is % appropriate, e.g., the initial point in [0, 6]^10 and SIGMA=2 % means cmaes('myfun', 3*rand(10,1), 2). If SIGMA is missing and % size(X0,2) > 1, INSIGMA is set to sqrt(var(X0')'). That is, X0 is % used as a sample for estimating initial mean and variance of the % search distribution. If inopts.LBounds and inopts.UBounds are both set % legally, INSIGMA will default to 0.3(inopts.LBounds - inopts.UBounds) % % In case of a noisy objective function (uncertainties) set % OPTS.Noise.on = 1. This option interferes presumably with some % termination criteria, because the step-size sigma will presumably % not converge to zero anymore. If CMAES was provided with a % fifth argument (P1 in the below example, which is passed to the % objective function FUN), this argument is multiplied with the % factor given in option Noise.alphaevals, each time the detected % noise exceeds a threshold. This argument can be used within % FUN, for example, as averaging number to reduce the noise level. % % OPTS.DiagonalOnly > 1 defines the number of initial iterations, % where the covariance matrix remains diagonal and the algorithm has % internally linear time complexity. OPTS.DiagonalOnly = 1 means % keeping the covariance matrix always diagonal and this setting % also exhibits linear space complexity. This can be particularly % useful for dimension > 100. The default is OPTS.DiagonalOnly = 0. % % OPTS.CMA.active = 1 turns on "active CMA" with a negative update % of the covariance matrix and checks for positive definiteness. % OPTS.CMA.active = 2 does not check for pos. def. and is numerically % faster. Active CMA usually speeds up the adaptation and might % become a default in near future. % % The primary strategy parameter to play with is OPTS.PopSize, which % can be increased from its default value. Increasing the population % size (by default linked to increasing parent number OPTS.ParentNumber) % improves global search properties in exchange to speed. Speed % decreases, as a rule, at most linearely with increasing population % size. It is advisable to begin with the default small population % size. The options Restarts and IncPopSize can be used for an % automated multistart where the population size is increased by the % factor IncPopSize (two by default) before each restart. X0 (given as % string) is reevaluated for each restart. Stopping options % StopFunEvals, StopIter, MaxFunEvals, and Fitness terminate the % program, all others including MaxIter invoke another restart, where % the iteration counter is reset to zero. % % See also FMINSEARCH, FMINUNC, FMINBND. cmaVersion = '3.61.beta'; % ----------- Set Defaults for Input Parameters and Options ------------- % These defaults may be edited for convenience % Options defaults: Stopping criteria % (value of stop flag) defopts.insigma = '[] % when left empty, it defaults to the standard deviation of xstart if all(size(xstart) > 1) or to'; defopts.StopFitness = '-Inf % stop if f(xmin) < stopfitness, minimization'; defopts.MaxFunEvals = 'Inf % maximal number of fevals'; defopts.MaxIter = '1e3*(N+5)^2/sqrt(popsize) % maximal number of iterations'; defopts.StopFunEvals = 'Inf % stop after resp. evaluation, possibly resume later'; defopts.StopIter = 'Inf % stop after resp. iteration, possibly resume later'; defopts.TolX = '1e-11*max(insigma) % stop if x-change smaller TolX'; defopts.TolUpX = '1e3*max(insigma) % stop if x-changes larger TolUpX'; defopts.TolFun = '1e-12 % stop if fun-changes smaller TolFun'; defopts.TolHistFun = '1e-13 % stop if back fun-changes smaller TolHistFun'; defopts.StopOnStagnation = 'on % stop when fitness stagnates for a long time'; % TODO: stagnation has four parameters for the period: min = 120, const = 30N/lam, rel = 0.2, max = 2e5 % defopts.StopOnStagnation = '[120 30*N/popsize 0.2 2e5] % [min const rel_iter max] measuring period'; defopts.StopOnWarnings = 'yes % ''no''==''off''==0, ''on''==''yes''==1 '; defopts.StopOnEqualFunctionValues = '2 + N/3 % number of iterations'; % Options defaults: Other defopts.DiffMaxChange = 'Inf % maximal variable change(s), can be Nx1-vector'; defopts.DiffMinChange = '0 % minimal variable change(s), can be Nx1-vector'; defopts.WarnOnEqualFunctionValues = ... 'yes % ''no''==''off''==0, ''on''==''yes''==1 '; defopts.LBounds = '-Inf % lower bounds, scalar or Nx1-vector'; defopts.UBounds = 'Inf % upper bounds, scalar or Nx1-vector'; defopts.EvalParallel = 'no % Can we use parallel evaluation with a parallel pool of workers?'; defopts.EvalInitialX = 'yes % evaluation of initial solution'; defopts.Restarts = '0 % number of restarts '; defopts.IncPopSize = '2 % multiplier for population size before each restart'; defopts.RestartIf = 'true % condition for restart: true restarts as many times as in opts.Restarts'; defopts.PopSize = '(4 + floor(3*log(N))) % population size, lambda'; defopts.ParentNumber = 'floor(popsize/2) % AKA mu, popsize equals lambda'; defopts.RecombinationWeights = 'superlinear decrease % or linear, or equal'; defopts.DiagonalOnly = '0*(1+100*N/sqrt(popsize))+(N>=1000) % C is diagonal for given iterations, 1==always'; defopts.Noise.on = '0 % uncertainty handling is off by default'; defopts.Noise.reevals = '1*ceil(0.05*lambda) % nb. of re-evaluated for uncertainty measurement'; defopts.Noise.theta = '0.5 % threshold to invoke uncertainty treatment'; % smaller: more likely to diverge defopts.Noise.cum = '0.3 % cumulation constant for uncertainty'; defopts.Noise.cutoff = '2*lambda/3 % rank change cutoff for summation'; defopts.Noise.alphasigma = '1+2/(N+10) % factor for increasing sigma'; % smaller: slower adaptation defopts.Noise.epsilon = '1e-7 % additional relative perturbation before reevaluation'; defopts.Noise.minmaxevals = '[1 inf] % min and max value of 2nd arg to fitfun, start value is 5th arg to cmaes'; defopts.Noise.alphaevals = '1+2/(N+10) % factor for increasing 2nd arg to fitfun'; defopts.Noise.callback = '[] % callback function when uncertainty threshold is exceeded'; % defopts.TPA = 0; defopts.CMA.cs = '(mueff+2)/(N+mueff+3) % cumulation constant for step-size'; %qqq defopts.CMA.cs = (mueff^0.5)/(N^0.5+mueff^0.5) % the short time horizon version defopts.CMA.damps = '1 + 2*max(0,sqrt((mueff-1)/(N+1))-1) + cs % damping for step-size'; % defopts.CMA.ccum = '4/(N+4) % cumulation constant for covariance matrix'; defopts.CMA.ccum = '(4 + mueff/N) / (N+4 + 2*mueff/N) % cumulation constant for pc'; defopts.CMA.ccov1 = '2 / ((N+1.3)^2+mueff) % learning rate for rank-one update'; defopts.CMA.ccovmu = '2 * (mueff-2+1/mueff) / ((N+2)^2+mueff) % learning rate for rank-mu update'; defopts.CMA.on = 'yes'; defopts.CMA.active = '0 % active CMA 1: neg. updates with pos. def. check, 2: neg. updates'; flg_future_setting = 0; % testing for possible future variant(s) if flg_future_setting disp('in the future') % damps setting from Brockhoff et al 2010 % this damps diverges with popsize 400: % defopts.CMA.damps = '2*mueff/lambda + 0.3 + cs % damping for step-size'; % cmaeshtml('benchmarkszero', ones(20,1)*2, 5, o, 15); % how about: % defopts.CMA.damps = '2*mueff/lambda + 0.3 + 2*max(0,sqrt((mueff-1)/(N+1))-1) + cs % damping for step-size'; defopts.CMA.damps = '0.5 + 0.5*min(1, (0.27*lambda/mueff-1)^2) + 2*max(0,sqrt((mueff-1)/(N+1))-1) + cs % damping for step-size'; if 11 < 3 defopts.CMA.damps = '0.5 + 0.5*min(1,(lam_mirr/(0.159*lambda)-1)^2) + 2*max(0,sqrt((mueff-1)/(N+1))-1) + cs % damping for step-size'; defopts.mirrored_offspring = 'floor(0.5 + 0.159 * lambda)'; % TODO: this should also depend on diagonal option!? defopts.CMA.active = 'floor(int8(lam_mirr>0)) % active CMA 1: neg. updates with pos. def. check, 2: neg. updates'; end % ccum adjusted for large mueff, better on schefelmult? % TODO: this should also depend on diagonal option!? defopts.CMA.ccum = '(4 + mueff/N) / (N+4 + 2*mueff/N) % cumulation constant for pc'; defopts.CMA.active = '1 % active CMA 1: neg. updates with pos. def. check, 2: neg. updates'; end defopts.Resume = 'no % resume former run from SaveFile'; defopts.Science = 'on % off==do some additional (minor) problem capturing, NOT IN USE'; defopts.ReadSignals = 'on % from file signals.par for termination, yet a stumb'; defopts.Seed = 'sum(100*clock) % evaluated if it is a string'; defopts.DispFinal = 'on % display messages like initial and final message'; defopts.DispModulo = '100 % [0:Inf], disp messages after every i-th iteration'; defopts.SaveVariables = 'on % [on|final|off][-v6] save variables to .mat file'; defopts.SaveFilename = 'variablescmaes.mat % save all variables, see SaveVariables'; defopts.LogModulo = '1 % [0:Inf] if >1 record data less frequently after gen=100'; defopts.LogTime = '25 % [0:100] max. percentage of time for recording data'; defopts.LogFilenamePrefix = 'outcmaes % files for output data'; defopts.LogPlot = 'off % plot while running using output data files'; %qqqkkk %defopts.varopt1 = ''; % 'for temporary and hacking purposes'; %defopts.varopt2 = ''; % 'for temporary and hacking purposes'; defopts.UserData = 'for saving data/comments associated with the run'; defopts.UserDat2 = ''; 'for saving data/comments associated with the run'; % ---------------------- Handling Input Parameters ---------------------- if nargin < 1 || isequal(infitfun, 'defaults') % pass default options if nargin < 1 disp('Default options returned (type "help cmaes" for help).'); end xmin = defopts; if nargin > 1 % supplement second argument with default options xmin = getoptions(xstart, defopts); end return; end if isequal(infitfun, 'displayoptions') names = fieldnames(defopts); for name = names' disp([name{:} repmat(' ', 1, 20-length(name{:})) ': ''' defopts.(name{:}) '''']); end return; end input.fitfun = infitfun; % record used input if isempty(infitfun) % fitfun = definput.fitfun; % warning(['Objective function not determined, ''' fitfun ''' used']); error(['Objective function not determined']); end % EDITS so that fitfun is a handle rather than a string % if ~ischar(fitfun) % error('first argument FUN must be a string'); % end if ischar(infitfun) fitfun_char = infitfun; original_fitfun = @(varargin) feval(fitfun_char, varargin{:}); else original_fitfun = infitfun; end if nargin < 2 xstart = []; end input.xstart = xstart; if isempty(xstart) % xstart = definput.xstart; % objective variables initial point % warning('Initial search point, and problem dimension, not determined'); error('Initial search point, and problem dimension, not determined'); end % EDITS to add insigma to inopts % if nargin < 3 % insigma = []; % end % if isa(insigma, 'struct') % error(['Third argument SIGMA must be (or eval to) a scalar '... % 'or a column vector of size(X0,1)']); % end % Compose options opts if nargin < 3 || isempty(inopts) % no input options available inopts = []; inopts = defopts; else inopts = getoptions(inopts, defopts); end % EDITS to add insigma to inopts original_insigma = myeval(inopts.insigma); input.sigma = original_insigma; if isempty(original_insigma) if all(size(myeval(xstart)) > 1) original_insigma = std(xstart, 0, 2); if any(original_insigma == 0) error(['Initial search volume is zero, choose SIGMA or X0 appropriate']); end else % will be captured later % error(['Initial step sizes (SIGMA) not determined']); end end i = strfind(inopts.SaveFilename, '%'); % remove everything after comment if ~isempty(i) inopts.SaveFilename = inopts.SaveFilename(1:i(1)-1); end inopts.SaveFilename = deblank(inopts.SaveFilename); % remove trailing white spaces %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% counteval = 0; countevalNaN = 0; irun = 0; while irun <= myeval(inopts.Restarts) && (irun == 0 || myeval(inopts.RestartIf)) % for-loop does not work with resume irun = irun + 1; % ------------------------ Initialization ------------------------------- % Handle resuming of old run flgresume = myevalbool(inopts.Resume); xmean = myeval(xstart); if all(size(xmean) > 1) xmean = mean(xmean, 2); % in case if xstart is a population elseif size(xmean, 2) > 1 xmean = xmean'; end if ~flgresume % not resuming a former run % Assign settings from input parameters and options for myeval... N = size(xmean, 1); numberofvariables = N; lambda0 = floor(myeval(inopts.PopSize) * myeval(inopts.IncPopSize)^(irun-1)); % lambda0 = floor(myeval(opts.PopSize) * 3^floor((irun-1)/2)); popsize = lambda0; lambda = lambda0; original_insigma = myeval(original_insigma); if all(size(original_insigma) == [N 2]) original_insigma = 0.5 * (original_insigma(:,2) - original_insigma(:,1)); end insigma = original_insigma; else % flgresume is true, do resume former run tmp = whos('-file', inopts.SaveFilename); for i = 1:length(tmp) if strcmp(tmp(i).name, 'localopts'); error('Saved variables include variable "localopts", please remove'); end end local.opts = inopts; % keep stopping and display options local.varargin = varargin; load(inopts.SaveFilename); varargin = local.varargin; flgresume = 1; % Overwrite old stopping and display options inopts.StopFitness = local.opts.StopFitness; %%opts.MaxFunEvals = local.opts.MaxFunEvals; %%opts.MaxIter = local.opts.MaxIter; inopts.StopFunEvals = local.opts.StopFunEvals; inopts.StopIter = local.opts.StopIter; inopts.TolX = local.opts.TolX; inopts.TolUpX = local.opts.TolUpX; inopts.TolFun = local.opts.TolFun; inopts.TolHistFun = local.opts.TolHistFun; inopts.StopOnStagnation = local.opts.StopOnStagnation; inopts.StopOnWarnings = local.opts.StopOnWarnings; inopts.ReadSignals = local.opts.ReadSignals; inopts.DispFinal = local.opts.DispFinal; inopts.LogPlot = local.opts.LogPlot; inopts.DispModulo = local.opts.DispModulo; inopts.SaveVariables = local.opts.SaveVariables; inopts.LogModulo = local.opts.LogModulo; inopts.LogTime = local.opts.LogTime; inopts.EvalParallel = local.opts.EvalParallel; % Get any option that doesn't exist in the old option from the new one, % this is handy if you make any changes that adds new options between two % restarts inopts = getoptions(inopts, local.opts); clear local; % otherwise local would be overwritten during load end %-------------------------------------------------------------- % Evaluate options stopFitness = myeval(inopts.StopFitness); stopMaxFunEvals = myeval(inopts.MaxFunEvals); stopMaxIter = myeval(inopts.MaxIter); stopFunEvals = myeval(inopts.StopFunEvals); stopIter = myeval(inopts.StopIter); if flgresume stopIter = stopIter + countiter; end stopTolX = myeval(inopts.TolX); stopTolUpX = myeval(inopts.TolUpX); stopTolFun = myeval(inopts.TolFun); stopTolHistFun = myeval(inopts.TolHistFun); stopOnStagnation = myevalbool(inopts.StopOnStagnation); stopOnWarnings = myevalbool(inopts.StopOnWarnings); flgreadsignals = myevalbool(inopts.ReadSignals); flgWarnOnEqualFunctionValues = myevalbool(inopts.WarnOnEqualFunctionValues); flgEvalParallel = myevalbool(inopts.EvalParallel); if flgEvalParallel poolobj = gcp('nocreate'); if isempty(poolobj); poolobj = parpool; end end stopOnEqualFunctionValues = myeval(inopts.StopOnEqualFunctionValues); arrEqualFunvals = zeros(1, 10+N); flgDiagonalOnly = myeval(inopts.DiagonalOnly); flgActiveCMA = myeval(inopts.CMA.active); noiseHandling = myevalbool(inopts.Noise.on); noiseMinMaxEvals = myeval(inopts.Noise.minmaxevals); noiseAlphaEvals = myeval(inopts.Noise.alphaevals); noiseCallback = myeval(inopts.Noise.callback); flgdisplay = myevalbool(inopts.DispFinal); flgplotting = myevalbool(inopts.LogPlot); verbosemodulo = myeval(inopts.DispModulo); flgscience = myevalbool(inopts.Science); flgsaving = []; strsaving = []; if strfind(inopts.SaveVariables, '-v6') i = strfind(inopts.SaveVariables, '%'); if isempty(i) || i == 0 || strfind(inopts.SaveVariables, '-v6') < i strsaving = '-v6'; flgsaving = 1; flgsavingfinal = 1; end end if strncmp('final', inopts.SaveVariables, 5) flgsaving = 0; flgsavingfinal = 1; end if isempty(flgsaving) flgsaving = myevalbool(inopts.SaveVariables); flgsavingfinal = flgsaving; end savemodulo = myeval(inopts.LogModulo); savetime = myeval(inopts.LogTime); i = strfind(inopts.LogFilenamePrefix, ' '); % remove everything after white space if ~isempty(i) inopts.LogFilenamePrefix = inopts.LogFilenamePrefix(1:i(1)-1); end % TODO here silent option? set disp, save and log options to 0 %-------------------------------------------------------------- if (isfinite(stopFunEvals) || isfinite(stopIter)) && ~flgsaving warning('To resume later the saving option needs to be set'); end % Do more checking and initialization if flgresume % resume is on time.t0 = clock; if flgdisplay disp([' resumed from ' inopts.SaveFilename ]); end if counteval >= stopMaxFunEvals error(['MaxFunEvals exceeded, use StopFunEvals as stopping ' ... 'criterion before resume']); end if countiter >= stopMaxIter error(['MaxIter exceeded, use StopIter as stopping criterion ' ... 'before resume']); end else % flgresume xmean = mean(myeval(xstart), 2); % evaluate xstart again, because of irun maxdx = myeval(inopts.DiffMaxChange); % maximal sensible variable change mindx = myeval(inopts.DiffMinChange); % minimal sensible variable change % can both also be defined as Nx1 vectors % rescale original_lbounds = myeval(inopts.LBounds); original_ubounds = myeval(inopts.UBounds); if length(original_lbounds) == 1 original_lbounds = repmat(original_lbounds, N, 1); end if length(original_ubounds) == 1 original_ubounds = repmat(original_ubounds, N, 1); end % We'll use fixed bounds [0;10] and rescale the parameters linearly % withing this bounds, if original bounds are given - otherwise no % scaling happens if all(original_lbounds > -Inf) && all(original_ubounds < Inf) lbounds = zeros(N, 1); ubounds = repmat(10, N, 1); xmean = scale_linear(xmean, original_lbounds, original_ubounds, lbounds, ubounds); fitfun = @(x, varargin) original_fitfun(scale_linear(x, lbounds, ubounds, original_lbounds, original_ubounds), varargin{:}); if ~isempty(original_insigma) insigma = scale_linear_range(original_insigma, original_ubounds - original_lbounds, ubounds - lbounds); end else lbounds = original_lbounds; ubounds = original_ubounds; insigma = original_insigma; fitfun = original_fitfun; end if isempty(insigma) % last chance to set insigma if all(lbounds > -Inf) && all(ubounds < Inf) if any(lbounds>=ubounds) error('upper bound must be greater than lower bound'); end insigma = 0.3*(ubounds-lbounds); stopTolX = myeval(inopts.TolX); % reevaluate these stopTolUpX = myeval(inopts.TolUpX); else error(['Initial step sizes (SIGMA) not determined']); end end % Check all vector sizes if size(xmean, 2) > 1 || size(xmean,1) ~= N error(['intial search point should be a column vector of size ' ... num2str(N)]); elseif ~(all(size(insigma) == [1 1]) || all(size(insigma) == [N 1])) error(['input parameter SIGMA should be (or eval to) a scalar '... 'or a column vector of size ' num2str(N)] ); elseif size(stopTolX, 2) > 1 || ~ismember(size(stopTolX, 1), [1 N]) error(['option TolX should be (or eval to) a scalar '... 'or a column vector of size ' num2str(N)] ); elseif size(stopTolUpX, 2) > 1 || ~ismember(size(stopTolUpX, 1), [1 N]) error(['option TolUpX should be (or eval to) a scalar '... 'or a column vector of size ' num2str(N)] ); elseif size(maxdx, 2) > 1 || ~ismember(size(maxdx, 1), [1 N]) error(['option DiffMaxChange should be (or eval to) a scalar '... 'or a column vector of size ' num2str(N)] ); elseif size(mindx, 2) > 1 || ~ismember(size(mindx, 1), [1 N]) error(['option DiffMinChange should be (or eval to) a scalar '... 'or a column vector of size ' num2str(N)] ); elseif size(lbounds, 2) > 1 || ~ismember(size(lbounds, 1), [1 N]) error(['option lbounds should be (or eval to) a scalar '... 'or a column vector of size ' num2str(N)] ); elseif size(ubounds, 2) > 1 || ~ismember(size(ubounds, 1), [1 N]) error(['option ubounds should be (or eval to) a scalar '... 'or a column vector of size ' num2str(N)] ); end % Initialize dynamic internal state parameters if any(insigma <= 0) error(['Initial search volume (SIGMA) must be greater than zero']); end if max(insigma)/min(insigma) > 1e6 error(['Initial search volume (SIGMA) badly conditioned']); end sigma = max(insigma); % overall standard deviation pc = zeros(N,1); ps = zeros(N,1); % evolution paths for C and sigma if length(insigma) == 1 insigma = insigma * ones(N,1) ; end diagD = insigma/max(insigma); % diagonal matrix D defines the scaling diagC = diagD.^2; if flgDiagonalOnly ~= 1 % use at some point full covariance matrix B = eye(N,N); % B defines the coordinate system BD = B.*repmat(diagD',N,1); % B*D for speed up only C = diag(diagC); % covariance matrix == BD*(BD)' end if flgDiagonalOnly B = 1; end fitness.hist=NaN*ones(1,10+ceil(3*10*N/lambda)); % history of fitness values fitness.histsel=NaN*ones(1,10+ceil(3*10*N/lambda)); % history of fitness values fitness.histbest=[]; % history of fitness values fitness.histmedian=[]; % history of fitness values % Initialize boundary handling bnd.isactive = any(lbounds > -Inf) || any(ubounds < Inf); if bnd.isactive if any(lbounds>ubounds) error('lower bound found to be greater than upper bound'); end [xmean ti] = xintobounds(xmean, lbounds, ubounds); % just in case if any(ti) warning('Initial point was out of bounds, corrected'); end bnd.weights = zeros(N,1); % weights for bound penalty % scaling is better in axis-parallel case, worse in rotated bnd.flgscale = 0; % scaling will be omitted if zero if bnd.flgscale ~= 0 bnd.scale = diagC/mean(diagC); else bnd.scale = ones(N,1); end idx = (lbounds > -Inf) | (ubounds < Inf); if length(idx) == 1 idx = idx * ones(N,1); end bnd.isbounded = zeros(N,1); bnd.isbounded(find(idx)) = 1; maxdx = min(maxdx, (ubounds - lbounds)/2); if any(sigma*sqrt(diagC) > maxdx) fac = min(maxdx ./ sqrt(diagC))/sigma; sigma = min(maxdx ./ sqrt(diagC)); warning(['Initial SIGMA multiplied by the factor ' num2str(fac) ... ', because it was larger than half' ... ' of one of the boundary intervals']); end idx = (lbounds > -Inf) & (ubounds < Inf); dd = diagC; if any(5*sigma*sqrt(dd(idx)) < ubounds(idx) - lbounds(idx)) warning(['Initial SIGMA is, in at least one coordinate, ' ... 'much smaller than the '... 'given boundary intervals. For reasonable ' ... 'global search performance SIGMA should be ' ... 'between 0.2 and 0.5 of the bounded interval in ' ... 'each coordinate. If all coordinates have ' ... 'lower and upper bounds SIGMA can be empty']); end bnd.dfithist = 1; % delta fit for setting weights bnd.aridxpoints = []; % remember complete outside points bnd.arfitness = []; % and their fitness bnd.validfitval = 0; bnd.iniphase = 1; end % ooo initial feval, for output only if irun == 1 out.algorithm = 'Evolution Strategy with Covariance Matrix Adaptation (CMA-ES)'; out.solutions.bestever.x = scale_linear(xmean, lbounds, ubounds, original_lbounds, original_ubounds); out.solutions.bestever.f = Inf; % for simpler comparison below out.solutions.bestever.evals = counteval; bestever = out.solutions.bestever; end if myevalbool(inopts.EvalInitialX) % EDITS to make fitfun a handle rather a string % fitness.hist(1)=feval(fitfun, xmean, varargin{:}); fitness.hist(1)=fitfun(xmean, varargin{:}); fitness.histsel(1)=fitness.hist(1); counteval = counteval + 1; if fitness.hist(1) < out.solutions.bestever.f out.solutions.bestever.x = scale_linear(xmean, lbounds, ubounds, original_lbounds, original_ubounds); out.solutions.bestever.f = fitness.hist(1); out.solutions.bestever.evals = counteval; bestever = out.solutions.bestever; end else fitness.hist(1)=NaN; fitness.histsel(1)=NaN; end % initialize random number generator if ischar(inopts.Seed) randn('state', eval(inopts.Seed)); % random number generator state else randn('state', inopts.Seed); end %qqq % load(opts.SaveFilename, 'startseed'); % randn('state', startseed); % disp(['SEED RELOADED FROM ' opts.SaveFilename]); startseed = randn('state'); % for retrieving in saved variables % Initialize further constants chiN=N^0.5*(1-1/(4*N)+1/(21*N^2)); % expectation of % ||N(0,I)|| == norm(randn(N,1)) countiter = 0; % Initialize records and output if irun == 1 time.t0 = clock; % TODO: keep also median solution? out.evals = counteval; % should be first entry out.stopflag = {}; outiter = 0; % Write headers to output data files filenameprefix = inopts.LogFilenamePrefix; if savemodulo && savetime filenames = {}; filenames(end+1) = {'axlen'}; filenames(end+1) = {'fit'}; filenames(end+1) = {'stddev'}; filenames(end+1) = {'xmean'}; filenames(end+1) = {'xrecentbest'}; str = [' (startseed=' num2str(startseed(2)) ... ', ' num2str(clock, '%d/%02d/%d %d:%d:%2.2f') ')']; for namecell = filenames(:)' name = namecell{:}; [fid, err] = fopen(['./' filenameprefix name '.dat'], 'w'); if fid < 1 % err ~= 0 warning(['could not open ' filenameprefix name '.dat']); filenames(find(strcmp(filenames,name))) = []; else % fprintf(fid, '%s\n', ... % ['<CMAES-OUTPUT version="' cmaVersion '">']); % fprintf(fid, [' <NAME>' name '</NAME>\n']); % fprintf(fid, [' <DATE>' date() '</DATE>\n']); % fprintf(fid, ' <PARAMETERS>\n'); % fprintf(fid, [' dimension=' num2str(N) '\n']); % fprintf(fid, ' </PARAMETERS>\n'); % different cases for DATA columns annotations here % fprintf(fid, ' <DATA'); if strcmp(name, 'axlen') fprintf(fid, ['%% columns="iteration, evaluation, sigma, ' ... 'max axis length, min axis length, ' ... 'all principal axes lengths (sorted square roots ' ... 'of eigenvalues of C)"' str]); elseif strcmp(name, 'fit') fprintf(fid, ['%% columns="iteration, evaluation, sigma, axis ratio, bestever,' ... ' best, median, worst fitness function value,' ... ' further objective values of best"' str]); elseif strcmp(name, 'stddev') fprintf(fid, ['%% columns=["iteration, evaluation, sigma, void, void, ' ... 'stds==sigma*sqrt(diag(C))"' str]); elseif strcmp(name, 'xmean') fprintf(fid, ['%% columns="iteration, evaluation, void, ' ... 'void, void, xmean"' str]); elseif strcmp(name, 'xrecentbest') fprintf(fid, ['%% columns="iteration, evaluation, fitness, ' ... 'void, void, xrecentbest"' str]); end fprintf(fid, '\n'); % DATA if strcmp(name, 'xmean') fprintf(fid, '%ld %ld 0 0 0 ', 0, counteval); % fprintf(fid, '%ld %ld 0 0 %e ', countiter, counteval, fmean); %qqq fprintf(fid, msprintf('%e ', genophenotransform(out.genopheno, xmean)) + '\n'); fprintf(fid, '%e ', scale_linear(xmean, lbounds, ubounds, original_lbounds, original_ubounds)); fprintf(fid, '\n'); end fclose(fid); clear fid; % preventing end end % for files end % savemodulo end % irun == 1 end % else flgresume % -------------------- Generation Loop -------------------------------- stopflag = {}; while isempty(stopflag) % set internal parameters if countiter == 0 || lambda ~= lambda_last if countiter > 0 && floor(log10(lambda)) ~= floor(log10(lambda_last)) ... && flgdisplay disp([' lambda = ' num2str(lambda)]); lambda_hist(:,end+1) = [countiter+1; lambda]; else lambda_hist = [countiter+1; lambda]; end lambda_last = lambda; % Strategy internal parameter setting: Selection mu = myeval(inopts.ParentNumber); % number of parents/points for recombination if strncmp(lower(inopts.RecombinationWeights), 'equal', 3) weights = ones(mu,1); % (mu_I,lambda)-CMA-ES elseif strncmp(lower(inopts.RecombinationWeights), 'linear', 3) weights = mu+0.5-(1:mu)'; elseif strncmp(lower(inopts.RecombinationWeights), 'superlinear', 3) % use (lambda+1)/2 as reference if mu < lambda/2 weights = log(max(mu, lambda/2) + 1/2)-log(1:mu)'; % muXone array for weighted recombination else error(['Recombination weights to be "' inopts.RecombinationWeights ... '" is not implemented']); end mueff=sum(weights)^2/sum(weights.^2); % variance-effective size of mu weights = weights/sum(weights); % normalize recombination weights array if mueff == lambda error(['Combination of values for PopSize, ParentNumber and ' ... ' and RecombinationWeights is not reasonable']); end % Strategy internal parameter setting: Adaptation cc = myeval(inopts.CMA.ccum); % time constant for cumulation for covariance matrix cs = myeval(inopts.CMA.cs); % old way TODO: remove this at some point % mucov = mueff; % size of mu used for calculating learning rate ccov % ccov = (1/mucov) * 2/(N+1.41)^2 ... % learning rate for covariance matrix % + (1-1/mucov) * min(1,(2*mucov-1)/((N+2)^2+mucov)); % new way if myevalbool(inopts.CMA.on) ccov1 = myeval(inopts.CMA.ccov1); ccovmu = min(1-ccov1, myeval(inopts.CMA.ccovmu)); else ccov1 = 0; ccovmu = 0; end % flgDiagonalOnly = -lambda*4*1/ccov; % for ccov==1 it is not needed % 0 : C will never be diagonal anymore % 1 : C will always be diagonal % >1: C is diagonal for first iterations, set to 0 afterwards if flgDiagonalOnly < 1 flgDiagonalOnly = 0; end if flgDiagonalOnly ccov1_sep = min(1, ccov1 * (N+1.5) / 3); ccovmu_sep = min(1-ccov1_sep, ccovmu * (N+1.5) / 3); elseif N > 98 && flgdisplay && countiter == 0 disp('consider option DiagonalOnly for high-dimensional problems'); end % ||ps|| is close to sqrt(mueff/N) for mueff large on linear fitness %damps = ... % damping for step size control, usually close to one % (1 + 2*max(0,sqrt((mueff-1)/(N+1))-1)) ... % limit sigma increase % * max(0.3, ... % reduce damps, if max. iteration number is small % 1 - N/min(stopMaxIter,stopMaxFunEvals/lambda)) + cs; damps = myeval(inopts.CMA.damps); if noiseHandling noiseReevals = min(myeval(inopts.Noise.reevals), lambda); noiseAlpha = myeval(inopts.Noise.alphasigma); noiseEpsilon = myeval(inopts.Noise.epsilon); noiseTheta = myeval(inopts.Noise.theta); noisecum = myeval(inopts.Noise.cum); noiseCutOff = myeval(inopts.Noise.cutoff); % arguably of minor relevance else noiseReevals = 0; % more convenient in later coding end %qqq hacking of a different parameter setting, e.g. for ccov or damps, % can be done here, but is not necessary anymore, see opts.CMA. % ccov1 = 0.0*ccov1; disp(['CAVE: ccov1=' num2str(ccov1)]); % ccovmu = 0.0*ccovmu; disp(['CAVE: ccovmu=' num2str(ccovmu)]); % damps = inf*damps; disp(['CAVE: damps=' num2str(damps)]); % cc = 1; disp(['CAVE: cc=' num2str(cc)]); end % Display initial message if countiter == 0 && flgdisplay if mu == 1 strw = '100'; elseif mu < 8 strw = [sprintf('%.0f', 100*weights(1)) ... sprintf(' %.0f', 100*weights(2:end)')]; else strw = [sprintf('%.2g ', 100*weights(1:2)') ... sprintf('%.2g', 100*weights(3)') '...' ... sprintf(' %.2g', 100*weights(end-1:end)') ']%, ']; end if irun > 1 strrun = [', run ' num2str(irun)]; else strrun = ''; end disp([' n=' num2str(N) ': (' num2str(mu) ',' ... num2str(lambda) ')-CMA-ES(w=[' ... strw ']%, ' ... 'mu_eff=' num2str(mueff,'%.1f') ... ') on function ' ... (func2str(fitfun)) strrun]); % EDITS to make fitfun a handle rahter than a string %(fitfun) strrun]); if flgDiagonalOnly == 1 disp(' C is diagonal'); elseif flgDiagonalOnly disp([' C is diagonal for ' num2str(floor(flgDiagonalOnly)) ' iterations']); end end flush; countiter = countiter + 1; % Generate and evaluate lambda offspring fitness.raw = NaN(1, lambda + noiseReevals); fitness_to_calc=find(isnan(fitness.raw)); arz = NaN(N,numel(fitness.raw)); arx = arz; arxvalid = arx; tries = 0; while numel(fitness_to_calc)>0 arz(:,fitness_to_calc) = randn(N, numel(fitness_to_calc)); for k=fitness_to_calc % calculate samples if k <= lambda % regular samples (not the re-evaluation-samples) if flgDiagonalOnly arx(:,k) = xmean + sigma * diagD .* arz(:,k); % Eq. (1) else arx(:,k) = xmean + sigma * (BD * arz(:,k)); % Eq. (1) end else % re-evaluation solution with index > lambda if flgDiagonalOnly arx(:,k) = arx(:,k-lambda) + (noiseEpsilon * sigma) * diagD .* arz(:,k); else arx(:,k) = arx(:,k-lambda) + (noiseEpsilon * sigma) * (BD * arz(:,k)); end end % Handle bounds if ~bnd.isactive arxvalid(:,k) = arx(:,k); else arxvalid(:,k) = xintobounds(arx(:,k), lbounds, ubounds); end end % non-parallel evaluation if ~flgEvalParallel for k=fitness_to_calc fitness.raw(k) = fitfun(arxvalid(:,k), varargin{:}); end else % parallel implementation here all_fitness = fitness.raw; parfor k=fitness_to_calc all_fitness(k) = fitfun(arxvalid(:,k), varargin{:}); end fitness.raw = all_fitness; end counteval = counteval + numel(fitness_to_calc); % these are the ones that still need to be calculated, because they % gave NaN fitness_to_calc=find(isnan(fitness.raw)); countevalNaN = countevalNaN + numel(fitness_to_calc); tries = tries + 1; if mod(tries,100)==0 warning([num2str(tries) ... ' NaN objective function values at evaluation ' ... num2str(counteval)]); end end fitness.sel = fitness.raw; % ----- handle boundaries ----- if 1 < 3 && bnd.isactive % Get delta fitness values val = myprctile(fitness.raw, [25 75]); % more precise would be exp(mean(log(diagC))) val = (val(2) - val(1)) / N / mean(diagC) / sigma^2; %val = (myprctile(fitness.raw, 75) - myprctile(fitness.raw, 25)) ... % / N / mean(diagC) / sigma^2; % Catch non-sensible values if ~isfinite(val) warning('Non-finite fitness range'); val = max(bnd.dfithist); elseif val == 0 % happens if all points are out of bounds val = min(bnd.dfithist(bnd.dfithist>0)); % seems not to make sense, given all solutions are out of bounds elseif bnd.validfitval == 0 % flag that first sensible val was found bnd.dfithist = []; bnd.validfitval = 1; end % Store delta fitness values if length(bnd.dfithist) < 20+(3*N)/lambda bnd.dfithist = [bnd.dfithist val]; else bnd.dfithist = [bnd.dfithist(2:end) val]; end [tx ti] = xintobounds(xmean, lbounds, ubounds); % Set initial weights if bnd.iniphase if any(ti) bnd.weights(find(bnd.isbounded)) = 2.0002 * median(bnd.dfithist); if bnd.flgscale == 0 % scale only initial weights then dd = diagC; idx = find(bnd.isbounded); dd = dd(idx) / mean(dd); % remove mean scaling bnd.weights(idx) = bnd.weights(idx) ./ dd; end if bnd.validfitval && countiter > 2 bnd.iniphase = 0; end end end % Increase weights if 1 < 3 && any(ti) % any coordinate of xmean out of bounds % judge distance of xmean to boundary tx = xmean - tx; idx = (ti ~= 0 & abs(tx) > 3*max(1,sqrt(N)/mueff) ... * sigma*sqrt(diagC)) ; % only increase if xmean is moving away idx = idx & (sign(tx) == sign(xmean - xold)); if ~isempty(idx) % increase % the factor became 1.2 instead of 1.1, because % changed from max to min in version 3.52 bnd.weights(idx) = 1.2^(min(1, mueff/10/N)) * bnd.weights(idx); end end % Calculate scaling biased to unity, product is one if bnd.flgscale ~= 0 bnd.scale = exp(0.9*(log(diagC)-mean(log(diagC)))); end % Assigned penalized fitness bnd.arpenalty = (bnd.weights ./ bnd.scale)' * (arxvalid - arx).^2; fitness.sel = fitness.raw + bnd.arpenalty; end % handle boundaries % ----- end handle boundaries ----- % compute noise measurement and reduce fitness arrays to size lambda if noiseHandling [noiseS] = local_noisemeasurement(fitness.sel(1:lambda), ... fitness.sel(lambda+(1:noiseReevals)), ... noiseReevals, noiseTheta, noiseCutOff); if countiter == 1 % TODO: improve this very rude way of initialization noiseSS = 0; noiseN = 0; % counter for mean end noiseSS = noiseSS + noisecum * (noiseS - noiseSS); % noise-handling could be done here, but the original sigma is still needed % disp([noiseS noiseSS noisecum]) fitness.rawar12 = fitness.raw; % just documentary fitness.selar12 = fitness.sel; % just documentary % qqq refine fitness based on both values if 11 < 3 % TODO: in case of outliers this mean is counterproductive % median out of three would be ok fitness.raw(1:noiseReevals) = ... % not so raw anymore (fitness.raw(1:noiseReevals) + fitness.raw(lambda+(1:noiseReevals))) / 2; fitness.sel(1:noiseReevals) = ... (fitness.sel(1:noiseReevals) + fitness.sel(lambda+(1:noiseReevals))) / 2; end fitness.raw = fitness.raw(1:lambda); fitness.sel = fitness.sel(1:lambda); end % Sort by fitness [fitness.raw, fitness.idx] = sort(fitness.raw); [fitness.sel, fitness.idxsel] = sort(fitness.sel); % minimization fitness.hist(2:end) = fitness.hist(1:end-1); % record short history of fitness.hist(1) = fitness.raw(1); % best fitness values if length(fitness.histbest) < 120+ceil(30*N/lambda) || ... (mod(countiter, 5) == 0 && length(fitness.histbest) < 2e4) % 20 percent of 1e5 gen. fitness.histbest = [fitness.raw(1) fitness.histbest]; % best fitness values fitness.histmedian = [median(fitness.raw) fitness.histmedian]; % median fitness values else fitness.histbest(2:end) = fitness.histbest(1:end-1); fitness.histmedian(2:end) = fitness.histmedian(1:end-1); fitness.histbest(1) = fitness.raw(1); % best fitness values fitness.histmedian(1) = median(fitness.raw); % median fitness values end fitness.histsel(2:end) = fitness.histsel(1:end-1); % record short history of fitness.histsel(1) = fitness.sel(1); % best sel fitness values % Calculate new xmean, this is selection and recombination xold = xmean; % for speed up of Eq. (2) and (3) cmean = 1; % 1/min(max((lambda-1*N)/2, 1), N); % == 1/kappa xmean = (1-cmean) * xold + cmean * arx(:,fitness.idxsel(1:mu))*weights; zmean = arz(:,fitness.idxsel(1:mu))*weights;%==D^-1*B'*(xmean-xold)/sigma if mu == 1 fmean = fitness.sel(1); else fmean = NaN; % [] does not work in the latter assignment % fmean = feval(fitfun, xintobounds(xmean, lbounds, ubounds), varargin{:}); % counteval = counteval + 1; end % Cumulation: update evolution paths ps = (1-cs)*ps + sqrt(cs*(2-cs)*mueff) * (B*zmean); % Eq. (4) hsig = norm(ps)/sqrt(1-(1-cs)^(2*countiter))/chiN < 1.4 + 2/(N+1); if flg_future_setting hsig = sum(ps.^2) / (1-(1-cs)^(2*countiter)) / N < 2 + 4/(N+1); % just simplified end % hsig = norm(ps)/sqrt(1-(1-cs)^(2*countiter))/chiN < 1.4 + 2/(N+1); % hsig = norm(ps)/sqrt(1-(1-cs)^(2*countiter))/chiN < 1.5 + 1/(N-0.5); % hsig = norm(ps) < 1.5 * sqrt(N); % hsig = 1; pc = (1-cc)*pc ... + hsig*(sqrt(cc*(2-cc)*mueff)/sigma/cmean) * (xmean-xold); % Eq. (2) if hsig == 0 % disp([num2str(countiter) ' ' num2str(counteval) ' pc update stalled']); end % Adapt covariance matrix neg.ccov = 0; % TODO: move parameter setting upwards at some point if ccov1 + ccovmu > 0 % Eq. (3) if flgDiagonalOnly % internal linear(?) complexity diagC = (1-ccov1_sep-ccovmu_sep+(1-hsig)*ccov1_sep*cc*(2-cc)) * diagC ... % regard old matrix + ccov1_sep * pc.^2 ... % plus rank one update + ccovmu_sep ... % plus rank mu update * (diagC .* (arz(:,fitness.idxsel(1:mu)).^2 * weights)); % * (repmat(diagC,1,mu) .* arz(:,fitness.idxsel(1:mu)).^2 * weights); diagD = sqrt(diagC); % replaces eig(C) else arpos = (arx(:,fitness.idxsel(1:mu))-repmat(xold,1,mu)) / sigma; % "active" CMA update: negative update, in case controlling pos. definiteness if flgActiveCMA > 0 % set parameters neg.mu = mu; neg.mueff = mueff; if flgActiveCMA > 10 % flat weights with mu=lambda/2 neg.mu = floor(lambda/2); neg.mueff = neg.mu; end % neg.mu = ceil(min([N, lambda/4, mueff])); neg.mueff = mu; % i.e. neg.mu <= N % Parameter study: in 3-D lambda=50,100, 10-D lambda=200,400, 30-D lambda=1000,2000 a % three times larger neg.ccov does not work. % increasing all ccov rates three times does work (probably because of the factor (1-ccovmu)) % in 30-D to looks fine neg.ccov = (1 - ccovmu) * 0.25 * neg.mueff / ((N+2)^1.5 + 2*neg.mueff); neg.minresidualvariance = 0.66; % keep at least 0.66 in all directions, small popsize are most critical neg.alphaold = 0.5; % where to make up for the variance loss, 0.5 means no idea what to do % 1 is slightly more robust and gives a better "guaranty" for pos. def., % but does it make sense from the learning perspective for large ccovmu? neg.ccovfinal = neg.ccov; % prepare vectors, compute negative updating matrix Cneg and checking matrix Ccheck arzneg = arz(:,fitness.idxsel(lambda:-1:lambda - neg.mu + 1)); % i-th longest becomes i-th shortest % TODO: this is not in compliance with the paper Hansen&Ros2010, % where simply arnorms = arnorms(end:-1:1) ? [arnorms idxnorms] = sort(sqrt(sum(arzneg.^2, 1))); [ignore idxnorms] = sort(idxnorms); % inverse index arnormfacs = arnorms(end:-1:1) ./ arnorms; % arnormfacs = arnorms(randperm(neg.mu)) ./ arnorms; arnorms = arnorms(end:-1:1); % for the record if flgActiveCMA < 20 arzneg = arzneg .* repmat(arnormfacs(idxnorms), N, 1); % E x*x' is N % arzneg = sqrt(N) * arzneg ./ repmat(sqrt(sum(arzneg.^2, 1)), N, 1); % E x*x' is N end if flgActiveCMA < 10 && neg.mu == mu % weighted sum if mod(flgActiveCMA, 10) == 1 % TODO: prevent this with a less tight but more efficient check (see below) Ccheck = arzneg * diag(weights) * arzneg'; % in order to check the largest EV end artmp = BD * arzneg; Cneg = artmp * diag(weights) * artmp'; else % simple sum if mod(flgActiveCMA, 10) == 1 Ccheck = (1/neg.mu) * arzneg*arzneg'; % in order to check largest EV end artmp = BD * arzneg; Cneg = (1/neg.mu) * artmp*artmp'; end % check pos.def. and set learning rate neg.ccov accordingly, % this check makes the original choice of neg.ccov extremly failsafe % still assuming C == BD*BD', which is only approxim. correct if mod(flgActiveCMA, 10) == 1 && 1 - neg.ccov * arnorms(idxnorms).^2 * weights < neg.minresidualvariance % TODO: the simple and cheap way would be to set % fac = 1 - ccovmu - ccov1 OR 1 - mueff/lambda and % neg.ccov = fac*(1 - neg.minresidualvariance) / (arnorms(idxnorms).^2 * weights) % this is the more sophisticated way: % maxeigenval = eigs(arzneg * arzneg', 1, 'lm', eigsopts); % not faster maxeigenval = max(eig(Ccheck)); % norm is much slower, because (norm()==max(svd()) %disp([countiter log10([neg.ccov, maxeigenval, arnorms(idxnorms).^2 * weights, max(arnorms)^2]), ... % neg.ccov * arnorms(idxnorms).^2 * weights]) % pause % remove less than ??34*(1-cmu)%?? of variance in any direction % 1-ccovmu is the variance left from the old C neg.ccovfinal = min(neg.ccov, (1-ccovmu)*(1-neg.minresidualvariance)/maxeigenval); % -ccov1 removed to avoid error message?? if neg.ccovfinal < neg.ccov disp(['active CMA at iteration ' num2str(countiter) ... ': max EV ==', num2str([maxeigenval, neg.ccov, neg.ccovfinal])]); end end % xmean = xold; % the distribution does not degenerate!? % update C C = (1-ccov1-ccovmu+neg.alphaold*neg.ccovfinal+(1-hsig)*ccov1*cc*(2-cc)) * C ... % regard old matrix + ccov1 * pc*pc' ... % plus rank one update + (ccovmu + (1-neg.alphaold)*neg.ccovfinal) ... % plus rank mu update * arpos * (repmat(weights,1,N) .* arpos') ... - neg.ccovfinal * Cneg; % minus rank mu update else % no active (negative) update C = (1-ccov1-ccovmu+(1-hsig)*ccov1*cc*(2-cc)) * C ... % regard old matrix + ccov1 * pc*pc' ... % plus rank one update + ccovmu ... % plus rank mu update * arpos * (repmat(weights,1,N) .* arpos'); % is now O(mu*N^2 + mu*N), was O(mu*N^2 + mu^2*N) when using diag(weights) % for mu=30*N it is now 10 times faster, overall 3 times faster end diagC = diag(C); end end % the following is de-preciated and will be removed in future % better setting for cc makes this hack obsolete if 11 < 2 && ~flgscience % remove momentum in ps, if ps is large and fitness is getting worse. % this should rarely happen. % this might very well be counterproductive in dynamic environments if sum(ps.^2)/N > 1.5 + 10*(2/N)^.5 && ... fitness.histsel(1) > max(fitness.histsel(2:3)) ps = ps * sqrt(N*(1+max(0,log(sum(ps.^2)/N))) / sum(ps.^2)); if flgdisplay disp(['Momentum in ps removed at [niter neval]=' ... num2str([countiter counteval]) ']']); end end end % Adapt sigma if flg_future_setting % according to a suggestion from Dirk Arnold (2000) % exp(1) is still not reasonably small enough, maybe 2/3? sigma = sigma * exp(min(1, (sum(ps.^2)/N - 1)/2 * cs/damps)); % Eq. (5) else % exp(1) is still not reasonably small enough sigma = sigma * exp(min(1, (sqrt(sum(ps.^2))/chiN - 1) * cs/damps)); % Eq. (5) end % disp([countiter norm(ps)/chiN]); if 11 < 3 % testing with optimal step-size if countiter == 1 disp('*********** sigma set to const * ||x|| ******************'); end sigma = 0.04 * mueff * sqrt(sum(xmean.^2)) / N; % 20D,lam=1000:25e3 sigma = 0.3 * mueff * sqrt(sum(xmean.^2)) / N; % 20D,lam=(40,1000):17e3 % 75e3 with def (1.5) % 35e3 with damps=0.25 end if 11 < 3 if countiter == 1 disp('*********** xmean set to const ******************'); end xmean = ones(N,1); end % Update B and D from C if ~flgDiagonalOnly && (ccov1+ccovmu+neg.ccov) > 0 && mod(countiter, 1/(ccov1+ccovmu+neg.ccov)/N/10) < 1 C=triu(C)+triu(C,1)'; % enforce symmetry to prevent complex numbers [B,tmp] = eig(C); % eigen decomposition, B==normalized eigenvectors % effort: approx. 15*N matrix-vector multiplications diagD = diag(tmp); if any(~isfinite(diagD)) clear idx; % prevents error under octave save(['tmp' inopts.SaveFilename]); error(['function eig returned non-finited eigenvalues, cond(C)=' ... num2str(cond(C)) ]); end if any(any(~isfinite(B))) clear idx; % prevents error under octave save(['tmp' inopts.SaveFilename]); error(['function eig returned non-finited eigenvectors, cond(C)=' ... num2str(cond(C)) ]); end % limit condition of C to 1e14 + 1 if min(diagD) <= 0 if stopOnWarnings stopflag(end+1) = {'warnconditioncov'}; else warning(['Iteration ' num2str(countiter) ... ': Eigenvalue (smaller) zero']); diagD(diagD<0) = 0; tmp = max(diagD)/1e14; C = C + tmp*eye(N,N); diagD = diagD + tmp*ones(N,1); end end if max(diagD) > 1e14*min(diagD) if stopOnWarnings stopflag(end+1) = {'warnconditioncov'}; else warning(['Iteration ' num2str(countiter) ': condition of C ' ... 'at upper limit' ]); tmp = max(diagD)/1e14 - min(diagD); C = C + tmp*eye(N,N); diagD = diagD + tmp*ones(N,1); end end diagC = diag(C); diagD = sqrt(diagD); % D contains standard deviations now % diagD = diagD / prod(diagD)^(1/N); C = C / prod(diagD)^(2/N); BD = B.*repmat(diagD',N,1); % O(n^2) end % if mod % Align/rescale order of magnitude of scales of sigma and C for nicer output % TODO: interference with sigmafacup: replace 1e10 with 2*sigmafacup % not a very usual case if 1 < 2 && sigma > 1e10*max(diagD) && sigma > 8e14 * max(insigma) fac = sigma; % / max(diagD); sigma = sigma/fac; pc = fac * pc; diagD = fac * diagD; if ~flgDiagonalOnly C = fac^2 * C; % disp(fac); BD = B .* repmat(diagD',N,1); % O(n^2), but repmat might be inefficient todo? end diagC = fac^2 * diagC; end if flgDiagonalOnly > 1 && countiter > flgDiagonalOnly % full covariance matrix from now on flgDiagonalOnly = 0; B = eye(N,N); BD = diag(diagD); C = diag(diagC); % is better, because correlations are spurious anyway end if noiseHandling if countiter == 1 % assign firstvarargin for noise treatment e.g. as #reevaluations if ~isempty(varargin) && length(varargin{1}) == 1 && isnumeric(varargin{1}) if irun == 1 firstvarargin = varargin{1}; else varargin{1} = firstvarargin; % reset varargin{1} end else firstvarargin = 0; end end if noiseSS < 0 && noiseMinMaxEvals(2) > noiseMinMaxEvals(1) && firstvarargin varargin{1} = max(noiseMinMaxEvals(1), varargin{1} / noiseAlphaEvals^(1/4)); % still experimental elseif noiseSS > 0 if ~isempty(noiseCallback) % to be removed? res = feval(noiseCallback); % should also work without output argument!? if ~isempty(res) && res > 1 % TODO: decide for interface of callback % also a dynamic popsize could be done here sigma = sigma * noiseAlpha; end else if noiseMinMaxEvals(2) > noiseMinMaxEvals(1) && firstvarargin varargin{1} = min(noiseMinMaxEvals(2), varargin{1} * noiseAlphaEvals); end sigma = sigma * noiseAlpha; % lambda = ceil(0.1 * sqrt(lambda) + lambda); % TODO: find smallest increase of lambda with log-linear % convergence in iterations end % qqq experimental: take a mean to estimate the true optimum noiseN = noiseN + 1; if noiseN == 1 noiseX = xmean; else noiseX = noiseX + (3/noiseN) * (xmean - noiseX); end end end % ----- numerical error management ----- % Adjust maximal coordinate axis deviations if any(sigma*sqrt(diagC) > maxdx) sigma = min(maxdx ./ sqrt(diagC)); %warning(['Iteration ' num2str(countiter) ': coordinate axis std ' ... % 'deviation at upper limit of ' num2str(maxdx)]); % stopflag(end+1) = {'maxcoorddev'}; end % Adjust minimal coordinate axis deviations if any(sigma*sqrt(diagC) < mindx) sigma = max(mindx ./ sqrt(diagC)) * exp(0.05+cs/damps); %warning(['Iteration ' num2str(countiter) ': coordinate axis std ' ... % 'deviation at lower limit of ' num2str(mindx)]); % stopflag(end+1) = {'mincoorddev'};; end % Adjust too low coordinate axis deviations if any(xmean == xmean + 0.2*sigma*sqrt(diagC)) if stopOnWarnings stopflag(end+1) = {'warnnoeffectcoord'}; else warning(['Iteration ' num2str(countiter) ': coordinate axis std ' ... 'deviation too low' ]); if flgDiagonalOnly diagC = diagC + (ccov1_sep+ccovmu_sep) * (diagC .* ... (xmean == xmean + 0.2*sigma*sqrt(diagC))); else C = C + (ccov1+ccovmu) * diag(diagC .* ... (xmean == xmean + 0.2*sigma*sqrt(diagC))); end sigma = sigma * exp(0.05+cs/damps); end end % Adjust step size in case of (numerical) precision problem if flgDiagonalOnly tmp = 0.1*sigma*diagD; else tmp = 0.1*sigma*BD(:,1+floor(mod(countiter,N))); end if all(xmean == xmean + tmp) i = 1+floor(mod(countiter,N)); if stopOnWarnings stopflag(end+1) = {'warnnoeffectaxis'}; else warning(['Iteration ' num2str(countiter) ... ': main axis standard deviation ' ... num2str(sigma*diagD(i)) ' has no effect' ]); sigma = sigma * exp(0.2+cs/damps); end end % Adjust step size in case of equal function values (flat fitness) % isequalfuncvalues = 0; if fitness.sel(1) == fitness.sel(1+ceil(0.1+lambda/4)) % isequalfuncvalues = 1; if stopOnEqualFunctionValues arrEqualFunvals = [countiter arrEqualFunvals(1:end-1)]; % stop if this happens in more than 33% if arrEqualFunvals(end) > countiter - 3 * length(arrEqualFunvals) stopflag(end+1) = {'equalfunvals'}; end else if flgWarnOnEqualFunctionValues warning(['Iteration ' num2str(countiter) ... ': equal function values f=' num2str(fitness.sel(1)) ... ' at maximal main axis sigma ' ... num2str(sigma*max(diagD))]); end sigma = sigma * exp(0.2+cs/damps); end end % Adjust step size in case of equal function values if countiter > 2 && myrange([fitness.hist fitness.sel(1)]) == 0 if stopOnWarnings stopflag(end+1) = {'warnequalfunvalhist'}; else warning(['Iteration ' num2str(countiter) ... ': equal function values in history at maximal main ' ... 'axis sigma ' num2str(sigma*max(diagD))]); sigma = sigma * exp(0.2+cs/damps); end end % ----- end numerical error management ----- % Keep overall best solution out.evals = counteval; out.solutions.evals = counteval; out.solutions.mean.x = scale_linear(xmean, lbounds, ubounds, original_lbounds, original_ubounds); out.solutions.mean.f = fmean; out.solutions.mean.evals = counteval; out.solutions.recentbest.x = scale_linear(arxvalid(:, fitness.idx(1)), lbounds, ubounds, original_lbounds, original_ubounds); out.solutions.recentbest.f = fitness.raw(1); out.solutions.recentbest.evals = counteval + fitness.idx(1) - lambda; out.solutions.recentworst.x = scale_linear(arxvalid(:, fitness.idx(end)), lbounds, ubounds, original_lbounds, original_ubounds); out.solutions.recentworst.f = fitness.raw(end); out.solutions.recentworst.evals = counteval + fitness.idx(end) - lambda; if fitness.hist(1) < out.solutions.bestever.f out.solutions.bestever.x = scale_linear(arxvalid(:, fitness.idx(1)), lbounds, ubounds, original_lbounds, original_ubounds); out.solutions.bestever.f = fitness.hist(1); out.solutions.bestever.evals = counteval + fitness.idx(1) - lambda; bestever = out.solutions.bestever; end % Set stop flag if fitness.raw(1) <= stopFitness, stopflag(end+1) = {'fitness'}; end if counteval >= stopMaxFunEvals, stopflag(end+1) = {'maxfunevals'}; end if countiter >= stopMaxIter, stopflag(end+1) = {'maxiter'}; end if all(sigma*(max(abs(pc), sqrt(diagC))) < stopTolX) stopflag(end+1) = {'tolx'}; end if any(sigma*sqrt(diagC) > stopTolUpX) stopflag(end+1) = {'tolupx'}; end if sigma*max(diagD) == 0 % should never happen stopflag(end+1) = {'bug'}; end if countiter > 2 && myrange([fitness.sel fitness.hist]) <= stopTolFun stopflag(end+1) = {'tolfun'}; end if countiter >= length(fitness.hist) && myrange(fitness.hist) <= stopTolHistFun stopflag(end+1) = {'tolhistfun'}; end l = floor(length(fitness.histbest)/3); if 1 < 2 && stopOnStagnation && ... % leads sometimes early stop on ftablet, fcigtab countiter > N * (5+100/lambda) && ... length(fitness.histbest) > 100 && ... median(fitness.histmedian(1:l)) >= median(fitness.histmedian(end-l:end)) && ... median(fitness.histbest(1:l)) >= median(fitness.histbest(end-l:end)) stopflag(end+1) = {'stagnation'}; end if counteval >= stopFunEvals || countiter >= stopIter stopflag(end+1) = {'stoptoresume'}; if length(stopflag) == 1 && flgsaving == 0 error('To resume later the saving option needs to be set'); end end % read stopping message from file signals.par if flgreadsignals fid = fopen('./signals.par', 'rt'); % can be performance critical while fid > 0 strline = fgetl(fid); %fgets(fid, 300); if strline < 0 % fgets and fgetl returns -1 at end of file break; end % 'stop filename' sets stopflag to manual str = sscanf(strline, ' %s %s', 2); if strcmp(str, ['stop' inopts.LogFilenamePrefix]) stopflag(end+1) = {'manual'}; break; end % 'skip filename run 3' skips a run, but not the last str = sscanf(strline, ' %s %s %s', 3); if strcmp(str, ['skip' inopts.LogFilenamePrefix 'run']) i = strfind(strline, 'run'); if irun == sscanf(strline(i+3:end), ' %d ', 1) && irun <= myeval(inopts.Restarts) stopflag(end+1) = {'skipped'}; end end end % while, break if fid > 0 fclose(fid); clear fid; % prevents strange error under octave end end out.stopflag = stopflag; % ----- output generation ----- if verbosemodulo > 0 && isfinite(verbosemodulo) if countiter == 1 || mod(countiter, 10*verbosemodulo) < 1 disp(['Iterat, #Fevals: Function Value (median,worst) ' ... '|Axis Ratio|' ... 'idx:Min SD idx:Max SD']); end if mod(countiter, verbosemodulo) < 1 ... || (verbosemodulo > 0 && isfinite(verbosemodulo) && ... (countiter < 3 || ~isempty(stopflag))) [minstd minstdidx] = min(sigma*sqrt(diagC)); [maxstd maxstdidx] = max(sigma*sqrt(diagC)); % format display nicely disp([repmat(' ',1,4-floor(log10(countiter))) ... num2str(countiter) ' , ' ... repmat(' ',1,5-floor(log10(counteval))) ... num2str(counteval) ' : ' ... num2str(fitness.hist(1), '%.13e') ... ' +(' num2str(median(fitness.raw)-fitness.hist(1), '%.0e ') ... ',' num2str(max(fitness.raw)-fitness.hist(1), '%.0e ') ... ') | ' ... num2str(max(diagD)/min(diagD), '%4.2e') ' | ' ... repmat(' ',1,1-floor(log10(minstdidx))) num2str(minstdidx) ':' ... num2str(minstd, ' %.1e') ' ' ... repmat(' ',1,1-floor(log10(maxstdidx))) num2str(maxstdidx) ':' ... num2str(maxstd, ' %.1e')]); elseif countiter == 3 disp("Don't worry! Your calibration is still running."); disp(['The next output will be displayed at the ',... num2str(verbosemodulo), 'th iteration or at the end of the calibration.']); disp("You can change this setting using the 'DispModulo' option passed to 'my_cmaes'") end end % measure time for recording data if countiter < 3 time.c = 0.05; time.nonoutput = 0; time.recording = 0; time.saving = 0.15; % first saving after 3 seconds of 100 iterations time.plotting = 0; elseif countiter > 300 % set backward horizon, must be long enough to cover infrequent plotting etc % time.c = min(1, time.nonoutput/3 + 1e-9); time.c = max(1e-5, 0.1/sqrt(countiter)); % mean over all or 1e-5 end % get average time per iteration time.t1 = clock; time.act = max(0,etime(time.t1, time.t0)); time.nonoutput = (1-time.c) * time.nonoutput ... + time.c * time.act; time.recording = (1-time.c) * time.recording; % per iteration time.saving = (1-time.c) * time.saving; time.plotting = (1-time.c) * time.plotting; % record output data, concerning time issues if savemodulo && savetime && (countiter < 1e2 || ~isempty(stopflag) || ... countiter >= outiter + savemodulo) outiter = countiter; % Save output data to files for namecell = filenames(:)' name = namecell{:}; [fid, err] = fopen(['./' filenameprefix name '.dat'], 'a'); if fid < 1 % err ~= 0 warning(['could not open ' filenameprefix name '.dat']); else if strcmp(name, 'axlen') fprintf(fid, '%d %d %e %e %e ', countiter, counteval, sigma, ... max(diagD), min(diagD)); fprintf(fid, '%e ', sort(diagD)); fprintf(fid, '\n'); elseif strcmp(name, 'disp') % TODO elseif strcmp(name, 'fit') fprintf(fid, '%ld %ld %e %e %25.18e %25.18e %25.18e %25.18e', ... countiter, counteval, sigma, max(diagD)/min(diagD), ... out.solutions.bestever.f, ... fitness.raw(1), median(fitness.raw), fitness.raw(end)); if ~isempty(varargin) && length(varargin{1}) == 1 && isnumeric(varargin{1}) && varargin{1} ~= 0 fprintf(fid, ' %f', varargin{1}); end fprintf(fid, '\n'); elseif strcmp(name, 'stddev') fprintf(fid, '%ld %ld %e 0 0 ', countiter, counteval, sigma); fprintf(fid, '%e ', sigma*sqrt(diagC)); fprintf(fid, '\n'); elseif strcmp(name, 'xmean') if isnan(fmean) fprintf(fid, '%ld %ld 0 0 0 ', countiter, counteval); else fprintf(fid, '%ld %ld 0 0 %e ', countiter, counteval, fmean); end fprintf(fid, '%e ', scale_linear(xmean, lbounds, ubounds, original_lbounds, original_ubounds)); fprintf(fid, '\n'); elseif strcmp(name, 'xrecentbest') % TODO: fitness is inconsistent with x-value fprintf(fid, '%ld %ld %25.18e 0 0 ', countiter, counteval, fitness.raw(1)); fprintf(fid, '%e ', scale_linear(arx(:,fitness.idx(1)), lbounds, ubounds, original_lbounds, original_ubounds)); fprintf(fid, '\n'); end fclose(fid); end end % get average time for recording data time.t2 = clock; time.recording = time.recording + time.c * max(0,etime(time.t2, time.t1)); % plot if flgplotting && countiter > 1 if countiter == 2 iterplotted = 0; end if ~isempty(stopflag) || ... ((time.nonoutput+time.recording) * (countiter - iterplotted) > 1 && ... time.plotting < 0.05 * (time.nonoutput+time.recording)) local_plotcmaesdat(324, filenameprefix); iterplotted = countiter; % outplot(out); % outplot defined below if time.plotting == 0 % disregard opening of the window time.plotting = time.nonoutput+time.recording; else time.plotting = time.plotting + time.c * max(0,etime(clock, time.t2)); end end end if countiter > 100 + 20 && savemodulo && ... time.recording * countiter > 0.1 && ... % absolute time larger 0.1 second time.recording > savetime * (time.nonoutput+time.recording) / 100 savemodulo = floor(1.02 * savemodulo) + 1; % disp(['++savemodulo == ' num2str(savemodulo) ' at ' num2str(countiter)]); %qqq end end % if output % save everything time.t3 = clock; if ~isempty(stopflag) || time.saving < 0.05 * time.nonoutput || countiter == 100 xmin = scale_linear(arxvalid(:, fitness.idx(1)), lbounds, ubounds, original_lbounds, original_ubounds); fmin = fitness.raw(1); if flgsaving && countiter > 2 clear idx; % prevents error under octave % -v6 : non-compressed non-unicode for version 6 and earlier if ~isempty(strsaving) && ~isoctave save('-mat', strsaving, inopts.SaveFilename); % for inspection and possible restart else save('-mat', inopts.SaveFilename); % for inspection and possible restart end time.saving = time.saving + time.c * max(0,etime(clock, time.t3)); end end time.t0 = clock; % ----- end output generation ----- end % while, end generation loop % -------------------- Final Procedures ------------------------------- if flgEvalParallel delete(poolobj); end % Evaluate xmean and return best point as xmin fmin = fitness.raw(1); xmin = scale_linear(arxvalid(:, fitness.idx(1)), lbounds, ubounds, original_lbounds, original_ubounds); % Return best point of last generation. if length(stopflag) > sum(strcmp(stopflag, 'stoptoresume')) % final stopping out.solutions.mean.f = ... fitfun(xintobounds(xmean, lbounds, ubounds), varargin{:}); % EDITS to make fitfun a handle rather than a string %feval(fitfun, xintobounds(xmean, lbounds, ubounds), varargin{:}); counteval = counteval + 1; out.solutions.mean.evals = counteval; if out.solutions.mean.f < out.solutions.bestever.f out.solutions.bestever = out.solutions.mean; % Return xmean as bestever point out.solutions.bestever.x = scale_linear(xintobounds(xmean, lbounds, ubounds), lbounds, ubounds, original_lbounds, original_ubounds); bestever = out.solutions.bestever; end fmin = bestever.f; xmin = bestever.x; end % Save everything and display final message if flgsavingfinal clear idx; % prevents error under octave if ~isempty(strsaving) && ~isoctave save('-mat', strsaving, inopts.SaveFilename); % for inspection and possible restart else save('-mat', inopts.SaveFilename); % for inspection and possible restart end message = [' (saved to ' inopts.SaveFilename ')']; else message = []; end if flgdisplay disp(['#Fevals: f(returned x) | bestever.f | stopflag' ... message]); if isoctave strstop = stopflag(:); else strcat(stopflag(:), '.'); end strstop = stopflag(:); %strcat(stopflag(:), '.'); disp([repmat(' ',1,6-floor(log10(counteval))) ... num2str(counteval, '%6.0f') ': ' num2str(fmin, '%.11e') ' | ' ... num2str(out.solutions.bestever.f, '%.11e') ' | ' ... strstop{1:end}]); if N < 102 disp(['mean solution:' sprintf(' %+.1e', scale_linear(xmean, lbounds, ubounds, original_lbounds, original_ubounds))]); disp(['std deviation:' sprintf(' %.1e', sigma*sqrt(diagC))]); disp(sprintf('use plotcmaesdat.m for plotting the output at any time (option LogModulo must not be zero)')); end if exist('sfile', 'var') disp(['Results saved in ' sfile]); end end out.arstopflags{irun} = stopflag; if any(strcmp(stopflag, 'fitness')) ... || any(strcmp(stopflag, 'maxfunevals')) ... || any(strcmp(stopflag, 'stoptoresume')) ... || any(strcmp(stopflag, 'manual')) break; end end % while irun <= Restarts % --------------------------------------------------------------- % --------------------------------------------------------------- function xscaled = scale_linear(x, old_lbs, old_ubs, new_lbs, new_ubs) if all(old_lbs == new_lbs) && all(old_ubs == new_ubs) xscaled = x; else xscaled = new_lbs + (new_ubs - new_lbs) .* (x - old_lbs) ./ (old_ubs - old_lbs); end function xscaled = scale_linear_range(x, old_range, new_range) if all(old_range == new_range) xscaled = x; else xscaled = new_range .* x ./ (old_range); end % --------------------------------------------------------------- % --------------------------------------------------------------- function [x, idx] = xintobounds(x, lbounds, ubounds) % % x can be a column vector or a matrix consisting of column vectors % if ~isempty(lbounds) if length(lbounds) == 1 idx = x < lbounds; x(idx) = lbounds; else arbounds = repmat(lbounds, 1, size(x,2)); idx = x < arbounds; x(idx) = arbounds(idx); end else idx = 0; end if ~isempty(ubounds) if length(ubounds) == 1 idx2 = x > ubounds; x(idx2) = ubounds; else arbounds = repmat(ubounds, 1, size(x,2)); idx2 = x > arbounds; x(idx2) = arbounds(idx2); end else idx2 = 0; end idx = idx2-idx; % --------------------------------------------------------------- % --------------------------------------------------------------- function opts=getoptions(inopts, defopts) % OPTS = GETOPTIONS(INOPTS, DEFOPTS) handles an arbitrary number of % optional arguments to a function. The given arguments are collected % in the struct INOPTS. GETOPTIONS matches INOPTS with a default % options struct DEFOPTS and returns the merge OPTS. Empty or missing % fields in INOPTS invoke the default value. Fieldnames in INOPTS can % be abbreviated. % % The returned struct OPTS is first assigned to DEFOPTS. Then any % field value in OPTS is replaced by the respective field value of % INOPTS if (1) the field unambiguously (case-insensitive) matches % with the fieldname in INOPTS (cut down to the length of the INOPTS % fieldname) and (2) the field is not empty. % % Example: % In the source-code of the function that needs optional % arguments, the last argument is the struct of optional % arguments: % % function results = myfunction(mandatory_arg, inopts) % % Define four default options % defopts.PopulationSize = 200; % defopts.ParentNumber = 50; % defopts.MaxIterations = 1e6; % defopts.MaxSigma = 1; % % % merge default options with input options % opts = getoptions(inopts, defopts); % % % Thats it! From now on the values in opts can be used % for i = 1:opts.PopulationSize % % do whatever % if sigma > opts.MaxSigma % % do whatever % end % end % % For calling the function myfunction with default options: % myfunction(argument1, []); % For calling the function myfunction with modified options: % opt.pop = 100; % redefine PopulationSize option % opt.PAR = 10; % redefine ParentNumber option % opt.maxiter = 2; % opt.max=2 is ambiguous and would result in an error % myfunction(argument1, opt); % % 04/07/19: Entries can be structs itself leading to a recursive % call to getoptions. % if nargin < 2 || isempty(defopts) % no default options available opts=inopts; return; elseif isempty(inopts) % empty inopts invoke default options opts = defopts; return; elseif ~isstruct(defopts) % handle a single option value if isempty(inopts) opts = defopts; elseif ~isstruct(inopts) opts = inopts; else error('Input options are a struct, while default options are not'); end return; elseif ~isstruct(inopts) % no valid input options error('The options need to be a struct or empty'); end opts = defopts; % start from defopts % if necessary overwrite opts fields by inopts values defnames = fieldnames(defopts); idxmatched = []; % indices of defopts that already matched for name = fieldnames(inopts)' name = name{1}; % name of i-th inopts-field if isoctave for i = 1:size(defnames, 1) idx(i) = strncmpi(defnames(i), name, length(name)); end else idx = strncmpi(defnames, name, length(name)); end if sum(idx) > 1 error(['option "' name '" is not an unambigous abbreviation. ' ... 'Use opts=RMFIELD(opts, ''' name, ... ''') to remove the field from the struct.']); end if sum(idx) == 1 defname = defnames{find(idx)}; if ismember(find(idx), idxmatched) error(['input options match more than ones with "' ... defname '". ' ... 'Use opts=RMFIELD(opts, ''' name, ... ''') to remove the field from the struct.']); end idxmatched = [idxmatched find(idx)]; val = getfield(inopts, name); % next line can replace previous line from MATLAB version 6.5.0 on and in octave % val = inopts.(name); if isstruct(val) % valid syntax only from version 6.5.0 opts = setfield(opts, defname, ... getoptions(val, getfield(defopts, defname))); elseif isstruct(getfield(defopts, defname)) % next three lines can replace previous three lines from MATLAB % version 6.5.0 on % opts.(defname) = ... % getoptions(val, defopts.(defname)); % elseif isstruct(defopts.(defname)) warning(['option "' name '" disregarded (must be struct)']); elseif ~isempty(val) % empty value: do nothing, i.e. stick to default opts = setfield(opts, defnames{find(idx)}, val); % next line can replace previous line from MATLAB version 6.5.0 on % opts.(defname) = inopts.(name); end else warning(['option "' name '" disregarded (unknown field name)']); end end % --------------------------------------------------------------- % --------------------------------------------------------------- function res=myeval(s) if ischar(s) res = evalin('caller', s); else res = s; end % --------------------------------------------------------------- % --------------------------------------------------------------- function res=myevalbool(s) if ~ischar(s) % s may not and cannot be empty res = s; else % evaluation string s if strncmpi(s, 'yes', 3) || strncmpi(s, 'on', 2) ... || strncmpi(s, 'true', 4) || strncmp(s, '1 ', 2) res = 1; elseif strncmpi(s, 'no', 2) || strncmpi(s, 'off', 3) ... || strncmpi(s, 'false', 5) || strncmp(s, '0 ', 2) res = 0; else try res = evalin('caller', s); catch error(['String value "' s '" cannot be evaluated']); end try res ~= 0; catch error(['String value "' s '" cannot be evaluated reasonably']); end end end % --------------------------------------------------------------- % --------------------------------------------------------------- function res = isoctave % any hack to find out whether we are running octave s = version; res = 0; if exist('fflush', 'builtin') && eval(s(1)) < 7 res = 1; end % --------------------------------------------------------------- % --------------------------------------------------------------- function flush if isoctave feval('fflush', stdout); end % --------------------------------------------------------------- % --------------------------------------------------------------- % ----- replacements for statistic toolbox functions ------------ % --------------------------------------------------------------- % --------------------------------------------------------------- function res=myrange(x) res = max(x) - min(x); % --------------------------------------------------------------- % --------------------------------------------------------------- function res = myprctile(inar, perc, idx) % % Computes the percentiles in vector perc from vector inar % returns vector with length(res)==length(perc) % idx: optional index-array indicating sorted order % N = length(inar); flgtranspose = 0; % sizes if size(perc,1) > 1 perc = perc'; flgtranspose = 1; if size(perc,1) > 1 error('perc must not be a matrix'); end end if size(inar, 1) > 1 && size(inar,2) > 1 error('data inar must not be a matrix'); end % sort inar if nargin < 3 || isempty(idx) [sar idx] = sort(inar); else sar = inar(idx); end res = []; for p = perc if p <= 100*(0.5/N) res(end+1) = sar(1); elseif p >= 100*((N-0.5)/N) res(end+1) = sar(N); else % find largest index smaller than required percentile availablepercentiles = 100*((1:N)-0.5)/N; i = max(find(p > availablepercentiles)); % interpolate linearly res(end+1) = sar(i) ... + (sar(i+1)-sar(i))*(p - availablepercentiles(i)) ... / (availablepercentiles(i+1) - availablepercentiles(i)); end end if flgtranspose res = res'; end % --------------------------------------------------------------- % --------------------------------------------------------------- % --------------------------------------------------------------- % --------------------------------------------------------------- function [s ranks rankDelta] = local_noisemeasurement(arf1, arf2, lamreev, theta, cutlimit) % function [s ranks rankDelta] = noisemeasurement(arf1, arf2, lamreev, theta) % % Input: % arf1, arf2 : two arrays of function values. arf1 is of size 1xlambda, % arf2 may be of size 1xlamreev or 1xlambda. The first lamreev values % in arf2 are (re-)evaluations of the respective solutions, i.e. % arf1(1) and arf2(1) are two evaluations of "the first" solution. % lamreev: number of reevaluated individuals in arf2 % theta : parameter theta for the rank change limit, between 0 and 1, % typically between 0.2 and 0.7. % cutlimit (optional): output s is computed as a mean of rankchange minus % threshold, where rankchange is <=2*(lambda-1). cutlimit limits % abs(rankchange minus threshold) in this calculation to cutlimit. % cutlimit=1 evaluates basically the sign only. cutlimit=2 could be % the rank change with one solution (both evaluations of it). % % Output: % s : noise measurement, s>0 means the noise measure is above the % acceptance threshold % ranks : 2xlambda array, corresponding to [arf1; arf2], of ranks % of arf1 and arf2 in the set [arf1 arf2], values are in [1:2*lambda] % rankDelta: 1xlambda array of rank movements of arf2 compared to % arf1. rankDelta(i) agrees with the number of values from % the set [arf1 arf2] that lie between arf1(i) and arf2(i). % % Note: equal function values might lead to somewhat spurious results. % For this case a revision is advisable. %%% verify input argument sizes if size(arf1,1) ~= 1 error('arf1 must be an 1xlambda array'); elseif size(arf2,1) ~= 1 error('arf2 must be an 1xsomething array'); elseif size(arf1,2) < size(arf2,2) % not really necessary, but saver error('arf2 must not be smaller than arf1 in length'); end lam = size(arf1, 2); if size(arf1,2) ~= size(arf2,2) arf2(end+1:lam) = arf1((size(arf2,2)+1):lam); end if nargin < 5 cutlimit = inf; end %%% capture unusual values if any(diff(arf1) == 0) % this will presumably interpreted as rank change, because % sort(ones(...)) returns 1,2,3,... warning([num2str(sum(diff(arf1)==0)) ' equal function values']); end %%% compute rank changes into rankDelta % compute ranks [ignore, idx] = sort([arf1 arf2]); [ignore, ranks] = sort(idx); ranks = reshape(ranks, lam, 2)'; rankDelta = ranks(1,:) - ranks(2,:) - sign(ranks(1,:) - ranks(2,:)); %%% compute rank change limits using both ranks(1,...) and ranks(2,...) for i = 1:lamreev sumlim(i) = ... 0.5 * (... myprctile(abs((1:2*lam-1) - (ranks(1,i) - (ranks(1,i)>ranks(2,i)))), ... theta*50) ... + myprctile(abs((1:2*lam-1) - (ranks(2,i) - (ranks(2,i)>ranks(1,i)))), ... theta*50)); end %%% compute measurement %s = abs(rankDelta(1:lamreev)) - sumlim; % lives roughly in 0..2*lambda % max: 1 rankchange in 2*lambda is always fine s = abs(rankDelta(1:lamreev)) - max(1, sumlim); % lives roughly in 0..2*lambda % cut-off limit idx = abs(s) > cutlimit; s(idx) = sign(s(idx)) * cutlimit; s = mean(s); % --------------------------------------------------------------- % --------------------------------------------------------------- % --------------------------------------------------------------- % --------------------------------------------------------------- % just a "local" copy of plotcmaesdat.m, with manual_mode set to zero function local_plotcmaesdat(figNb, filenameprefix, filenameextension, objectvarname) % PLOTCMAESDAT; % PLOTCMAES(FIGURENUMBER_iBEGIN_iEND, FILENAMEPREFIX, FILENAMEEXTENSION, OBJECTVARNAME); % plots output from CMA-ES, e.g. cmaes.m, Java class CMAEvolutionStrategy... % mod(figNb,100)==1 plots versus iterations. % % PLOTCMAES([101 300]) plots versus iteration, from iteration 300. % PLOTCMAES([100 150 800]) plots versus function evaluations, between iteration 150 and 800. % % Upper left subplot: blue/red: function value of the best solution in the % recent population, cyan: same function value minus best % ever seen function value, green: sigma, red: ratio between % longest and shortest principal axis length which is equivalent % to sqrt(cond(C)). % Upper right plot: time evolution of the distribution mean (default) or % the recent best solution vector. % Lower left: principal axes lengths of the distribution ellipsoid, % equivalent with the sqrt(eig(C)) square root eigenvalues of C. % Lower right: magenta: minimal and maximal "true" standard deviation % (with sigma included) in the coordinates, other colors: sqrt(diag(C)) % of all diagonal elements of C, if C is diagonal they equal to the % lower left. % % Files [FILENAMEPREFIX name FILENAMEEXTENSION] are used, where % name = axlen, OBJECTVARNAME (xmean|xrecentbest), fit, or stddev. % manual_mode = 0; if nargin < 1 || isempty(figNb) figNb = 325; end if nargin < 2 || isempty(filenameprefix) filenameprefix = 'outcmaes'; end if nargin < 3 || isempty(filenameextension) filenameextension = '.dat'; end if nargin < 4 || isempty(objectvarname) objectvarname = 'xmean'; objectvarname = 'xrecentbest'; end % load data d.x = load([filenameprefix objectvarname filenameextension]); % d.x = load([filenameprefix 'xmean' filenameextension]); % d.x = load([filenameprefix 'xrecentbest' filenameextension]); d.f = load([filenameprefix 'fit' filenameextension]); d.std = load([filenameprefix 'stddev' filenameextension]); d.D = load([filenameprefix 'axlen' filenameextension]); % interpret entries in figNb for cutting out some data if length(figNb) > 1 iend = inf; istart = figNb(2); if length(figNb) > 2 iend = figNb(3); end figNb = figNb(1); d.x = d.x(d.x(:,1) >= istart & d.x(:,1) <= iend, :); d.f = d.f(d.f(:,1) >= istart & d.f(:,1) <= iend, :); d.std = d.std(d.std(:,1) >= istart & d.std(:,1) <= iend, :); d.D = d.D(d.D(:,1) >= istart & d.D(:,1) <= iend, :); end % decide for x-axis iabscissa = 2; % 1== versus iterations, 2==versus fevals if mod(figNb,100) == 1 iabscissa = 1; % a short hack end if iabscissa == 1 xlab ='iterations'; elseif iabscissa == 2 xlab = 'function evaluations'; end if size(d.x, 2) < 1000 minxend = 1.03*d.x(end, iabscissa); else minxend = 0; end % set up figure window if manual_mode figure(figNb); % just create and raise the figure window else if 1 < 3 && evalin('caller', 'iterplotted') == 0 && evalin('caller', 'irun') == 1 figure(figNb); % incomment this, if figure raise in the beginning is not desired elseif ismember(figNb, findobj('Type', 'figure')) set(0, 'CurrentFigure', figNb); % prevents raise of existing figure window else figure(figNb); end end % plot fitness etc foffset = 1e-99; dfit = d.f(:,6)-min(d.f(:,6)); [ignore idxbest] = min(dfit); dfit(dfit<1e-98) = NaN; subplot(2,2,1); hold off; dd = abs(d.f(:,7:8)) + foffset; dd(d.f(:,7:8)==0) = NaN; semilogy(d.f(:,iabscissa), dd, '-k'); hold on; % additional fitness data, for example constraints values if size(d.f,2) > 8 dd = abs(d.f(:,9:end)) + 10*foffset; % a hack % dd(d.f(:,9:end)==0) = NaN; semilogy(d.f(:,iabscissa), dd, '-m'); hold on; if size(d.f,2) > 12 semilogy(d.f(:,iabscissa),abs(d.f(:,[7 8 11 13]))+foffset,'-k'); hold on; end end idx = find(d.f(:,6)>1e-98); % positive values if ~isempty(idx) % otherwise non-log plot gets hold semilogy(d.f(idx,iabscissa), d.f(idx,6)+foffset, '.b'); hold on; end idx = find(d.f(:,6) < -1e-98); % negative values if ~isempty(idx) semilogy(d.f(idx, iabscissa), abs(d.f(idx,6))+foffset,'.r'); hold on; end semilogy(d.f(:,iabscissa),abs(d.f(:,6))+foffset,'-b'); hold on; semilogy(d.f(:,iabscissa),dfit,'-c'); hold on; semilogy(d.f(:,iabscissa),(d.f(:,4)),'-r'); hold on; % AR semilogy(d.std(:,iabscissa), [max(d.std(:,6:end)')' ... min(d.std(:,6:end)')'], '-m'); % max,min std maxval = max(d.std(end,6:end)); minval = min(d.std(end,6:end)); text(d.std(end,iabscissa), maxval, sprintf('%.0e', maxval)); text(d.std(end,iabscissa), minval, sprintf('%.0e', minval)); semilogy(d.std(:,iabscissa),(d.std(:,3)),'-g'); % sigma % plot best f semilogy(d.f(idxbest,iabscissa),min(dfit),'*c'); hold on; semilogy(d.f(idxbest,iabscissa),abs(d.f(idxbest,6))+foffset,'*r'); hold on; ax = axis; ax(2) = max(minxend, ax(2)); axis(ax); yannote = 10^(log10(ax(3)) + 0.05*(log10(ax(4))-log10(ax(3)))); text(ax(1), yannote, ... [ 'f=' num2str(d.f(end,6), '%.15g') ]); title('blue:abs(f), cyan:f-min(f), green:sigma, red:axis ratio'); grid on; subplot(2,2,2); hold off; plot(d.x(:,iabscissa), d.x(:,6:end),'-'); hold on; ax = axis; ax(2) = max(minxend, ax(2)); axis(ax); % add some annotation lines [ignore idx] = sort(d.x(end,6:end)); % choose no more than 25 indices idxs = round(linspace(1, size(d.x,2)-5, min(size(d.x,2)-5, 25))); yy = repmat(NaN, 2, size(d.x,2)-5); yy(1,:) = d.x(end, 6:end); yy(2,idx(idxs)) = linspace(ax(3), ax(4), length(idxs)); plot([d.x(end,iabscissa) ax(2)], yy, '-'); plot(repmat(d.x(end,iabscissa),2), [ax(3) ax(4)], 'k-'); for i = idx(idxs) text(ax(2), yy(2,i), ... ['x(' num2str(i) ')=' num2str(yy(1,i))]); end lam = 'NA'; if size(d.x, 1) > 1 && d.x(end, 1) > d.x(end-1, 1) lam = num2str((d.x(end, 2) - d.x(end-1, 2)) / (d.x(end, 1) - d.x(end-1, 1))); end title(['Object Variables (' num2str(size(d.x, 2)-5) ... '-D, popsize~' lam ')']);grid on; subplot(2,2,3); hold off; semilogy(d.D(:,iabscissa), d.D(:,6:end), '-'); ax = axis; ax(2) = max(minxend, ax(2)); axis(ax); title('Principal Axes Lengths');grid on; xlabel(xlab); subplot(2,2,4); hold off; % semilogy(d.std(:,iabscissa), d.std(:,6:end), 'k-'); hold on; % remove sigma from stds d.std(:,6:end) = d.std(:,6:end) ./ (d.std(:,3) * ones(1,size(d.std,2)-5)); semilogy(d.std(:,iabscissa), d.std(:,6:end), '-'); hold on; if 11 < 3 % max and min std semilogy(d.std(:,iabscissa), [d.std(:,3).*max(d.std(:,6:end)')' ... d.std(:,3).*min(d.std(:,6:end)')'], '-m', 'linewidth', 2); maxval = max(d.std(end,6:end)); minval = min(d.std(end,6:end)); text(d.std(end,iabscissa), d.std(end,3)*maxval, sprintf('max=%.0e', maxval)); text(d.std(end,iabscissa), d.std(end,3)*minval, sprintf('min=%.0e', minval)); end ax = axis; ax(2) = max(minxend, ax(2)); axis(ax); % add some annotation lines [ignore idx] = sort(d.std(end,6:end)); % choose no more than 25 indices idxs = round(linspace(1, size(d.x,2)-5, min(size(d.x,2)-5, 25))); yy = repmat(NaN, 2, size(d.std,2)-5); yy(1,:) = d.std(end, 6:end); yy(2,idx(idxs)) = logspace(log10(ax(3)), log10(ax(4)), length(idxs)); semilogy([d.std(end,iabscissa) ax(2)], yy, '-'); semilogy(repmat(d.std(end,iabscissa),2), [ax(3) ax(4)], 'k-'); for i = idx(idxs) text(ax(2), yy(2,i), [' ' num2str(i)]); end title('Standard Deviations in Coordinates divided by sigma');grid on; xlabel(xlab); if figNb ~= 324 % zoom on; % does not work in Octave end drawnow; % --------------------------------------------------------------- % --------------- TEST OBJECTIVE FUNCTIONS ---------------------- % --------------------------------------------------------------- %%% Unimodal functions function f=fjens1(x) % % use population size about 2*N % f = sum((x>0) .* x.^1, 1); if any(any(x<0)) idx = sum(x < 0, 1) > 0; f(idx) = 1e3; % f = f + 1e3 * sum(x<0, 1); % f = f + 10 * sum((x<0) .* x.^2, 1); f(idx) = f(idx) + 1e-3*abs(randn(1,sum(idx))); % f(idx) = NaN; end function f=fsphere(x) f = sum(x.^2,1); function f=fmax(x) f = max(abs(x), [], 1); function f=fssphere(x) f=sqrt(sum(x.^2, 1)); % lb = -0.512; ub = 512; % xfeas = x; % xfeas(x<lb) = lb; % xfeas(x>ub) = ub; % f=sum(xfeas.^2, 1); % f = f + 1e-9 * sum((xfeas-x).^2); function f=fspherenoise(x, Nevals) if nargin < 2 || isempty(Nevals) Nevals = 1; end [N,popsi] = size(x); % x = x .* (1 + 0.3e-0 * randn(N, popsi)/(2*N)); % actuator noise fsum = 10.^(0*(0:N-1)/(N-1)) * x.^2; % f = 0*rand(1,1) ... % + fsum ... % + fsum .* (2*randn(1,popsi) ./ randn(1,popsi).^0 / (2*N)) ... % + 1*fsum.^0.9 .* 2*randn(1,popsi) / (2*N); % % f = fsum .* exp(0.1*randn(1,popsi)); f = fsum .* (1 + (10/(N+10)/sqrt(Nevals))*randn(1,popsi)); % f = fsum .* (1 + (0.1/N)*randn(1,popsi)./randn(1,popsi).^1); idx = rand(1,popsi) < 0.0; if sum(idx) > 0 f(idx) = f(idx) + 1e3*exp(randn(1,sum(idx))); end function f=fmixranks(x) N = size(x,1); f=(10.^(0*(0:(N-1))/(N-1))*x.^2).^0.5; if size(x, 2) > 1 % compute ranks, if it is a population [ignore, idx] = sort(f); [ignore, ranks] = sort(idx); k = 9; % number of solutions randomly permuted, lambda/2-1 % works still quite well (two time slower) for i = k+1:k-0:size(x,2) idx(i-k+(1:k)) = idx(i-k+randperm(k)); end %disp([ranks' f']) [ignore, ranks] = sort(idx); %disp([ranks' f']) %pause f = ranks+1e-9*randn(1,1); end function f = fsphereoneax(x) f = x(1)^2; f = mean(x)^2; function f=frandsphere(x) N = size(x,1); idx = ceil(N*rand(7,1)); f=sum(x(idx).^2); function f=fspherelb0(x, M) % lbound at zero for 1:M needed if nargin < 2 M = 0; end N = size(x,1); % M active bounds, f_i = 1 for x = 0 f = -M + sum((x(1:M) + 1).^2); f = f + sum(x(M+1:N).^2); function f=fspherehull(x) % Patton, Dexter, Goodman, Punch % in -500..500 % spherical ridge through zeros(N,1) % worst case start point seems x = 2*100*sqrt(N) % and small step size N = size(x,1); f = norm(x) + (norm(x-100*sqrt(N)) - 100*N)^2; function f=fellilb0(x, idxM, scal) % lbound at zero for 1:M needed N = size(x,1); if nargin < 3 || isempty(scal) scal = 100; end scale=scal.^((0:N-1)/(N-1)); if nargin < 2 || isempty(idxM) idxM = 1:N; end %scale(N) = 1e0; % M active bounds xopt = 0.1; x(idxM) = x(idxM) + xopt; f = scale.^2*x.^2; f = f - sum((xopt*scale(idxM)).^2); % f = exp(f) - 1; % f = log10(f+1e-19) + 19; f = f + 1e-19; function f=fcornersphere(x) w = ones(size(x,1)); w(1) = 2.5; w(2)=2.5; idx = x < 0; f = sum(x(idx).^2); idx = x > 0; f = f + 2^2*sum(w(idx).*x(idx).^2); function f=fsectorsphere(x, scal) % % This is deceptive for cumulative sigma control CSA in large dimension: % The strategy (initially) diverges for N=50 and popsize = 150. (Even % for cs==1 this can be observed for larger settings of N and % popsize.) The reason is obvious from the function topology. % Divergence can be avoided by setting boundaries or adding a % penalty for large ||x||. Then, convergence can be observed again. % Conclusion: for popsize>N cumulative sigma control is not completely % reasonable, but I do not know better alternatives. In particular: % TPA takes longer to converge than CSA when the latter still works. % if nargin < 2 || isempty (scal) scal = 1e3; end f=sum(x.^2,1); idx = x<0; f = f + (scal^2 - 1) * sum((idx.*x).^2,1); if 11 < 3 idxpen = find(f>1e9); if ~isempty(idxpen) f(idxpen) = f(idxpen) + 1e8*sum(x(:,idxpen).^2,1); end end function f=fstepsphere(x, scal) if nargin < 2 || isempty (scal) scal = 1e0; end N = size(x,1); f=1e-11+sum(scal.^((0:N-1)/(N-1))*floor(x+0.5).^2); f=1e-11+sum(floor(scal.^((0:N-1)/(N-1))'.*x+0.5).^2); % f=1e-11+sum(floor(x+0.5).^2); function f=fstep(x) % in -5.12..5.12 (bounded) N = size(x,1); f=1e-11+6*N+sum(floor(x)); function f=flnorm(x, scal, e) if nargin < 2 || isempty(scal) scal = 1; end if nargin < 3 || isempty(e) e = 1; end if e==inf f = max(abs(x)); else N = size(x,1); scale = scal.^((0:N-1)/(N-1))'; f=sum(abs(scale.*x).^e); end function f=fneumaier3(x) % in -n^2..n^2 % x^*-i = i(n+1-i) N = size(x,1); % f = N*(N+4)*(N-1)/6 + sum((x-1).^2) - sum(x(1:N-1).*x(2:N)); f = sum((x-1).^2) - sum(x(1:N-1).*x(2:N)); function f = fmaxmindist(y) % y in [-1,1], y(1:2) is first point on a plane, y(3:4) second etc % points best % 5 1.4142 % 8 1.03527618 % 10 0.842535997 % 20 0.5997 pop = size(y,2); N = size(y,1)/2; f = []; for ipop = 1:pop if any(abs(y(:,ipop)) > 1) f(ipop) = NaN; else x = reshape(y(:,ipop), [2, N]); f(ipop) = inf; for i = 1:N f(ipop) = min(f(ipop), min(sqrt(sum((x(:,[1:i-1 i+1:N]) - repmat(x(:,i), 1, N-1)).^2, 1)))); end end end f = -f; function f=fchangingsphere(x) N = size(x,1); global scale_G; global count_G; if isempty(count_G) count_G=-1; end count_G = count_G+1; if mod(count_G,10) == 0 scale_G = 10.^(2*rand(1,N)); end %disp(scale(1)); f = scale_G*x.^2; function f= flogsphere(x) f = 1-exp(-sum(x.^2)); function f= fexpsphere(x) f = exp(sum(x.^2)) - 1; function f=fbaluja(x) % in [-0.16 0.16] y = x(1); for i = 2:length(x) y(i) = x(i) + y(i-1); end f = 1e5 - 1/(1e-5 + sum(abs(y))); function f=fschwefel(x) f = 0; for i = 1:size(x,1), f = f+sum(x(1:i))^2; end function f=fcigar(x, ar) if nargin < 2 || isempty(ar) ar = 1e3; end f = x(1,:).^2 + ar^2*sum(x(2:end,:).^2,1); function f=fcigtab(x) f = x(1,:).^2 + 1e8*x(end,:).^2 + 1e4*sum(x(2:(end-1),:).^2, 1); function f=ftablet(x) f = 1e6*x(1,:).^2 + sum(x(2:end,:).^2, 1); function f=felli(x, lgscal, expon, expon2) % lgscal: log10(axis ratio) % expon: x_i^expon, sphere==2 N = size(x,1); if N < 2 error('dimension must be greater one'); end % x = x - repmat(-0.5+(1:N)',1,size(x,2)); % optimum in 1:N if nargin < 2 || isempty(lgscal), lgscal = 3; end if nargin < 3 || isempty(expon), expon = 2; end if nargin < 4 || isempty(expon2), expon2 = 1; end f=((10^(lgscal*expon)).^((0:N-1)/(N-1)) * abs(x).^expon).^(1/expon2); % if rand(1,1) > 0.015 % f = NaN; % end % f = f + randn(size(f)); function f=fellitest(x) beta = 0.9; N = size(x,1); f = (1e6.^((0:(N-1))/(N-1))).^beta * (x.^2).^beta; function f=fellii(x, scal) N = size(x,1); if N < 2 error('dimension must be greater one'); end if nargin < 2 scal = 1; end f= (scal*(1:N)).^2 * (x).^2; function f=fellirot(x) N = size(x,1); global ORTHOGONALCOORSYSTEM_G if isempty(ORTHOGONALCOORSYSTEM_G) ... || length(ORTHOGONALCOORSYSTEM_G) < N ... || isempty(ORTHOGONALCOORSYSTEM_G{N}) coordinatesystem(N); end f = felli(ORTHOGONALCOORSYSTEM_G{N}*x); function f=frot(x, fun, varargin) N = size(x,1); global ORTHOGONALCOORSYSTEM_G if isempty(ORTHOGONALCOORSYSTEM_G) ... || length(ORTHOGONALCOORSYSTEM_G) < N ... || isempty(ORTHOGONALCOORSYSTEM_G{N}) coordinatesystem(N); end f = feval(fun, ORTHOGONALCOORSYSTEM_G{N}*x, varargin{:}); function coordinatesystem(N) if nargin < 1 || isempty(N) arN = 2:30; else arN = N; end global ORTHOGONALCOORSYSTEM_G ORTHOGONALCOORSYSTEM_G{1} = 1; for N = arN ar = randn(N,N); for i = 1:N for j = 1:i-1 ar(:,i) = ar(:,i) - ar(:,i)'*ar(:,j) * ar(:,j); end ar(:,i) = ar(:,i) / norm(ar(:,i)); end ORTHOGONALCOORSYSTEM_G{N} = ar; end function f=fplane(x) f=x(1); function f=ftwoaxes(x) f = sum(x(1:floor(end/2),:).^2, 1) + 1e6*sum(x(floor(1+end/2):end,:).^2, 1); function f=fparabR(x) f = -x(1,:) + 100*sum(x(2:end,:).^2,1); function f=fsharpR(x) f = abs(-x(1, :)).^2 + 100 * sqrt(sum(x(2:end,:).^2, 1)); function f=frosen(x) if size(x,1) < 2 error('dimension must be greater one'); end N = size(x,1); popsi = size(x,2); f = 1e2*sum((x(1:end-1,:).^2 - x(2:end,:)).^2,1) + sum((x(1:end-1,:)-1).^2,1); % f = f + f^0.9 .* (2*randn(1,popsi) ./ randn(1,popsi).^0 / (2*N)); function f=frosenlin(x) if size(x,1) < 2 error('dimension must be greater one'); end x_org = x; x(x>30) = 30; x(x<-30) = -30; f = 1e2*sum(-(x(1:end-1,:).^2 - x(2:end,:)),1) + ... sum((x(1:end-1,:)-1).^2,1); f = f + sum((x-x_org).^2,1); % f(any(abs(x)>30,1)) = NaN; function f=frosenrot(x) N = size(x,1); global ORTHOGONALCOORSYSTEM_G if isempty(ORTHOGONALCOORSYSTEM_G) ... || length(ORTHOGONALCOORSYSTEM_G) < N ... || isempty(ORTHOGONALCOORSYSTEM_G{N}) coordinatesystem(N); end f = frosen(ORTHOGONALCOORSYSTEM_G{N}*x); function f=frosenmodif(x) f = 74 + 100*(x(2)-x(1)^2)^2 + (1-x(1))^2 ... - 400*exp(-sum((x+1).^2)/2/0.05); function f=fschwefelrosen1(x) % in [-10 10] f=sum((x.^2-x(1)).^2 + (x-1).^2); function f=fschwefelrosen2(x) % in [-10 10] f=sum((x(2:end).^2-x(1)).^2 + (x(2:end)-1).^2); function f=fdiffpow(x) [N popsi] = size(x); if N < 2 error('dimension must be greater one'); end f = sum(abs(x).^repmat(2+10*(0:N-1)'/(N-1), 1, popsi), 1); f = sqrt(f); function f=fabsprod(x) f = sum(abs(x),1) + prod(abs(x),1); function f=ffloor(x) f = sum(floor(x+0.5).^2,1); function f=fmaxx(x) f = max(abs(x), [], 1); %%% Multimodal functions function f=fbirastrigin(x) % todo: the volume needs to be a constant N = size(x,1); idx = (sum(x, 1) < 0.5*N); % global optimum f = zeros(1,size(x,2)); f(idx) = 10*(N-sum(cos(2*pi*x(:,idx)),1)) + sum(x(:,idx).^2,1); idx = ~idx; f(idx) = 0.1 + 10*(N-sum(cos(2*pi*(x(:,idx)-2)),1)) + sum((x(:,idx)-2).^2,1); function f=fackley(x) % -32.768..32.768 % Adding a penalty outside the interval is recommended, % because for large step sizes, fackley imposes like frand % N = size(x,1); f = 20-20*exp(-0.2*sqrt(sum(x.^2)/N)); f = f + (exp(1) - exp(sum(cos(2*pi*x))/N)); % add penalty outside the search interval f = f + sum((x(x>32.768)-32.768).^2) + sum((x(x<-32.768)+32.768).^2); function f = fbohachevsky(x) % -15..15 f = sum(x(1:end-1).^2 + 2 * x(2:end).^2 - 0.3 * cos(3*pi*x(1:end-1)) ... - 0.4 * cos(4*pi*x(2:end)) + 0.7); function f=fconcentric(x) % in +-600 s = sum(x.^2); f = s^0.25 * (sin(50*s^0.1)^2 + 1); function f=fgriewank(x) % in [-600 600] [N, P] = size(x); f = 1 - prod(cos(x'./sqrt(1:N))) + sum(x.^2)/4e3; scale = repmat(sqrt(1:N)', 1, P); f = 1 - prod(cos(x./scale), 1) + sum(x.^2, 1)/4e3; % f = f + 1e4*sum(x(abs(x)>5).^2); % if sum(x(abs(x)>5).^2) > 0 % f = 1e4 * sum(x(abs(x)>5).^2) + 1e8 * sum(x(x>5)).^2; % end function f=fgriewrosen(x) % F13 or F8F2 [N, P] = size(x); scale = repmat(sqrt(1:N)', 1, P); y = [x(2:end,:); x(1,:)]; x = 100 * (x.^2 - y) + (x - 1).^2; % Rosenbrock part f = 1 - prod(cos(x./scale), 1) + sum(x.^2, 1)/4e3; f = sum(1 - cos(x) + x.^2/4e3, 1); function f=fspallpseudorastrigin(x, scal, skewfac, skewstart, amplitude) % by default multi-modal about between -30 and 30 if nargin < 5 || isempty(amplitude) amplitude = 40; end if nargin < 4 || isempty(skewstart) skewstart = 0; end if nargin < 3 || isempty(skewfac) skewfac = 1; end if nargin < 2 || isempty(scal) scal = 1; end N = size(x,1); scale = 1; if N > 1 scale=scal.^((0:N-1)'/(N-1)); end % simple version: % f = amplitude*(N - sum(cos(2*pi*(scale.*x)))) + sum((scale.*x).^2); % skew version: y = repmat(scale, 1, size(x,2)) .* x; idx = find(x > skewstart); if ~isempty(idx) y(idx) = skewfac*y(idx); end f = amplitude * (0*N-prod(cos((2*pi)^0*y),1)) + 0.05 * sum(y.^2,1) ... + randn(1,1); function f=frastrigin(x, scal, skewfac, skewstart, amplitude) % by default multi-modal about between -30 and 30 if nargin < 5 || isempty(amplitude) amplitude = 10; end if nargin < 4 || isempty(skewstart) skewstart = 0; end if nargin < 3 || isempty(skewfac) skewfac = 1; end if nargin < 2 || isempty(scal) scal = 1; end N = size(x,1); scale = 1; if N > 1 scale=scal.^((0:N-1)'/(N-1)); end % simple version: % f = amplitude*(N - sum(cos(2*pi*(scale.*x)))) + sum((scale.*x).^2); % skew version: y = repmat(scale, 1, size(x,2)) .* x; idx = find(x > skewstart); % idx = intersect(idx, 2:2:10); if ~isempty(idx) y(idx) = skewfac*y(idx); end f = amplitude * (N-sum(cos(2*pi*y),1)) + sum(y.^2,1); function f=frastriginmax(x) N = size(x,1); f = (N/20)*807.06580387678 - (10 * (N-sum(cos(2*pi*x),1)) + sum(x.^2,1)); f(any(abs(x) > 5.12)) = 1e2*N; function f = fschaffer(x) % -100..100 N = size(x,1); s = x(1:N-1,:).^2 + x(2:N,:).^2; f = sum(s.^0.25 .* (sin(50*s.^0.1).^2+1), 1); function f=fschwefelmult(x) % -500..500 % N = size(x,1); f = - sum(x.*sin(sqrt(abs(x))), 1); f = 418.9829*N - 1.27275661e-5*N - sum(x.*sin(sqrt(abs(x))), 1); % penalty term f = f + 1e4*sum((abs(x)>500) .* (abs(x)-500).^2, 1); function f=ftwomax(x) % Boundaries at +/-5 N = size(x,1); f = -abs(sum(x)) + 5*N; function f=ftwomaxtwo(x) % Boundaries at +/-10 N = size(x,1); f = abs(sum(x)); if f > 30 f = f - 30; end f = -f; function f=frand(x) f=1./(1-rand(1, size(x,2))) - 1; % CHANGES % 12/04/28: (3.61) stopIter is relative to countiter after resume (thanks to Tom Holden) % 12/04/28: (3.61) some syncing from 3.32.integer branch (cmean introduced, ...) % 12/02/19: "future" setting of ccum, correcting for large mueff, is default now % 11/11/15: bug-fix: max value for ccovmu_sep setting corrected % 10/11/11: (3.52.beta) boundary handling: replace max with min in change % rate formula. Active CMA: check of pos.def. improved. % Plotting: value of lambda appears in the title. % 10/04/03: (3.51.beta) active CMA cleaned up. Equal fitness detection % looks into history now. % 10/03/08: (3.50.beta) "active CMA" revised and bug-fix of ambiguous % option Noise.alpha -> Noise.alphasigma. % 09/10/12: (3.40.beta) a slightly modified version of "active CMA", % that is a negative covariance matrix update, use option % CMA.active. In 10;30;90-D the gain on ftablet is a factor % of 1.6;2.5;4.4 (the scaling improves by sqrt(N)). On % Rosenbrock the gain is about 25%. On sharp ridge the % behavior is improved. Cigar is unchanged. % 09/08/10: local plotcmaesdat remains in backround % 09/08/10: bug-fix in time management for data writing, logtime was not % considered properly (usually not at all). % 09/07/05: V3.24: stagnation termination added % 08/09/27: V3.23: momentum alignment is out-commented and de-preciated % 08/09/25: V3.22: re-alignment of sigma and C was buggy % 08/07/15: V3.20, CMA-parameters are options now. ccov and mucov were replaced % by ccov1 \approx ccov/mucov and ccovmu \approx (1-1/mucov)*ccov % 08/06/30: file name xrecent was change to xrecentbest (compatible with other % versions) % 08/06/29: time stamp added to output files % 08/06/28: bug fixed with resume option, commentary did not work % 08/06/28: V3.10, uncertainty (noise) handling added (re-implemented), according % to reference "A Method for Handling Uncertainty..." from below. % 08/06/28: bug fix: file xrecent was empty % 08/06/01: diagonalonly clean up. >1 means some iterations. % 08/05/05: output is written to file preventing an increasing data % array and ease long runs. % 08/03/27: DiagonalOnly<0 learns for -DiagonalOnly iterations only the % diagonal with a larger learning rate. % 08/03 (2.60): option DiagonalOnly>=1 invokes a time- and space-linear % variant with only diagonal elements of the covariance matrix % updating. This can be useful for large dimensions, say > 100. % 08/02: diag(weights) * ... replaced with repmat(weights,1,N) .* ... % in C update, implies O(mu*N^2) instead of O(mu^2*N + mu*N^2). % 07/09: tolhistfun as termination criterion added, "<" changed to % "<=" also for TolFun to allow for stopping on zero difference. % Name tolfunhist clashes with option tolfun. % 07/07: hsig threshold made slighly smaller for large dimension, % useful for lambda < lambda_default. % 07/06: boundary handling: scaling in the boundary handling % is omitted now, see bnd.flgscale. This seems not to % have a big impact. Using the scaling is worse on rotated % functions, but better on separable ones. % 07/05: boundary handling: weight i is not incremented anymore % if xmean(i) moves towards the feasible space. Increment % factor changed to 1.2 instead of 1.1. % 07/05: boundary handling code simplified not changing the algorithm % 07/04: bug removed for saving in octave % 06/11/10: more testing of outcome of eig, fixed max(D) to max(diag(D)) % 06/10/21: conclusive final bestever assignment in the end % 06/10/21: restart and incpopsize option implemented for restarts % with increasing population size, version 2.50. % 06/09/16: output argument bestever inserted again for convenience and % backward compatibility % 06/08: output argument out and struct out reorganized. % 06/01: Possible parallel evaluation included as option EvalParallel % 05/11: Compatibility to octave implemented, package octave-forge % is needed. % 05/09: Raise of figure and waiting for first plots improved % 05/01: Function coordinatesystem cleaned up. % 05/01: Function prctile, which requires the statistics toolbox, % replaced by myprctile. % 05/01: Option warnonequalfunctionvalues included. % 04/12: Decrease of sigma removed. Problems on fsectorsphere can % be addressed better by adding search space boundaries. % 04/12: Boundary handling simpyfied. % 04/12: Bug when stopping criteria tolx or tolupx are vectors. % 04/11: Three input parameters are obligatory now. % 04/11: Bug in boundary handling removed: Boundary weights can decrease now. % 04/11: Normalization for boundary weights scale changed. % 04/11: VerboseModulo option bug removed. Documentation improved. % 04/11: Condition for increasing boundary weights changed. % 04/10: Decrease of sigma when fitness is getting consistenly % worse. Addresses the problems appearing on fsectorsphere for % large population size. % 04/10: VerboseModulo option included. % 04/10: Bug for condition for increasing boundary weights removed. % 04/07: tolx depends on initial sigma to achieve scale invariance % for this stopping criterion. % 04/06: Objective function value NaN is not counted as function % evaluation and invokes resampling of the search point. % 04/06: Error handling for eigenvalue beeing zero (never happens % with default parameter setting) % 04/05: damps further tuned for large mueff % o Details for stall of pc-adaptation added (variable hsig % introduced). % 04/05: Bug in boundary handling removed: A large initial SIGMA was % corrected not until *after* the first iteration, which could % lead to a complete failure. % 04/05: Call of function range (works with stats toolbox only) % changed to myrange. % 04/04: Parameter cs depends on mueff now and damps \propto sqrt(mueff) % instead of \propto mueff. % o Initial stall to adapt C (flginiphase) is removed and % adaptation of pc is stalled for large norm(ps) instead. % o Returned default options include documentation. % o Resume part reorganized. % 04/03: Stopflag becomes cell-array. % --------------------------------------------------------------- % CMA-ES: Evolution Strategy with Covariance Matrix Adaptation for % nonlinear function minimization. To be used under the terms of the % GNU General Public License (http://www.gnu.org/copyleft/gpl.html). % Author (copyright): Nikolaus Hansen, 2001-2008. % e-mail: nikolaus.hansen AT inria.fr % URL:http://www.bionik.tu-berlin.de/user/niko % References: See below. % --------------------------------------------------------------- % % GENERAL PURPOSE: The CMA-ES (Evolution Strategy with Covariance % Matrix Adaptation) is a robust search method which should be % applied, if derivative based methods, e.g. quasi-Newton BFGS or % conjucate gradient, (supposably) fail due to a rugged search % landscape (e.g. noise, local optima, outlier, etc.). On smooth % landscapes CMA-ES is roughly ten times slower than BFGS. For up to % N=10 variables even the simplex direct search method (Nelder & Mead) % is often faster, but far less robust than CMA-ES. To see the % advantage of the CMA, it will usually take at least 30*N and up to % 300*N function evaluations, where N is the search problem dimension. % On considerably hard problems the complete search (a single run) is % expected to take at least 30*N^2 and up to 300*N^2 function % evaluations. % % SOME MORE COMMENTS: % The adaptation of the covariance matrix (e.g. by the CMA) is % equivalent to a general linear transformation of the problem % coding. Nevertheless every problem specific knowlegde about the best % linear transformation should be exploited before starting the % search. That is, an appropriate a priori transformation should be % applied to the problem. This also makes the identity matrix as % initial covariance matrix the best choice. % % The strategy parameter lambda (population size, opts.PopSize) is the % preferred strategy parameter to play with. If results with the % default strategy are not satisfactory, increase the population % size. (Remark that the crucial parameter mu (opts.ParentNumber) is % increased proportionally to lambda). This will improve the % strategies capability of handling noise and local minima. We % recomment successively increasing lambda by a factor of about three, % starting with initial values between 5 and 20. Casually, population % sizes even beyond 1000+100*N can be sensible. % % % --------------------------------------------------------------- %%% REFERENCES % % The equation numbers refer to % Hansen, N. and S. Kern (2004). Evaluating the CMA Evolution % Strategy on Multimodal Test Functions. Eighth International % Conference on Parallel Problem Solving from Nature PPSN VIII, % Proceedings, pp. 282-291, Berlin: Springer. % (http://www.bionik.tu-berlin.de/user/niko/ppsn2004hansenkern.pdf) % % Further references: % Hansen, N. and A. Ostermeier (2001). Completely Derandomized % Self-Adaptation in Evolution Strategies. Evolutionary Computation, % 9(2), pp. 159-195. % (http://www.bionik.tu-berlin.de/user/niko/cmaartic.pdf). % % Hansen, N., S.D. Mueller and P. Koumoutsakos (2003). Reducing the % Time Complexity of the Derandomized Evolution Strategy with % Covariance Matrix Adaptation (CMA-ES). Evolutionary Computation, % 11(1). (http://mitpress.mit.edu/journals/pdf/evco_11_1_1_0.pdf). % % Ros, R. and N. Hansen (2008). A Simple Modification in CMA-ES % Achieving Linear Time and Space Complexity. To appear in Tenth % International Conference on Parallel Problem Solving from Nature % PPSN X, Proceedings, Berlin: Springer. % % Hansen, N., A.S.P. Niederberger, L. Guzzella and P. Koumoutsakos % (2009?). A Method for Handling Uncertainty in Evolutionary % Optimization with an Application to Feedback Control of % Combustion. To appear in IEEE Transactions on Evolutionary % Computation.
[STATEMENT] lemma map_equal: "dom m = dom m' \<Longrightarrow> (\<And>x. x \<in> dom m \<Longrightarrow> m x = m' x) \<Longrightarrow> m = m'" [PROOF STATE] proof (prove) goal (1 subgoal): 1. \<lbrakk>dom m = dom m'; \<And>x. x \<in> dom m \<Longrightarrow> m x = m' x\<rbrakk> \<Longrightarrow> m = m' [PROOF STEP] by fastforce
Formal statement is: lemma poly_eq_iff: "p = q \<longleftrightarrow> (\<forall>n. coeff p n = coeff q n)" Informal statement is: Two polynomials are equal if and only if they have the same coefficients.
using Unitful, UnitfulAstro using PhysicalConstants.CODATA2018: h, c_0, k_B export blackbody """ blackbody(wave::Vector{<:Quantity}, T::Quantity) blackbody(wave::Vector{<:Real}, T::Real) Create a blackbody spectrum using Planck's law. The curve follows the mathematical form ``B_\\lambda(T) = \\frac{2hc^2}{\\lambda^5}\\frac{1}{e^{hc/\\lambda k_B T} - 1}`` If `wave` and `T` are not `Unitful.Quantity`, they are assumed to be in angstrom and Kelvin, and the returned flux will be in units `W m^-2 Å^-1`. The physical constants are calculated using [PhysicalConstants.jl](https://github.com/juliaphysics/physicalconstants.jl), specifically the CODATA2018 measurement set. # References [Planck's Law](https://en.wikipedia.org/wiki/Planck%27s_law) # Examples ```jldoctest julia> using Spectra, Unitful, UnitfulAstro julia> wave = range(1, 3, length=100)u"μm" (1.0:0.020202020202020204:3.0) μm julia> bb = blackbody(wave, 2000u"K") UnitfulSpectrum (100,) λ (μm) f (W μm^-1 m^-2) T: 2000 K name: Blackbody julia> blackbody(ustrip.(u"angstrom", wave), 6000) Spectrum (100,) T: 6000 name: Blackbody julia> bb.wave[argmax(bb)] 1.4444444444444444 μm julia> 2898u"μm*K" / bb.T # See if it matches up with Wien's law 1.449 μm ``` """ function blackbody(wave::AbstractVector{<:Quantity}, T::Quantity) out_unit = u"W/m^2" / unit(eltype(wave)) flux = _blackbody(wave, T) .|> out_unit return spectrum(wave, flux, name = "Blackbody", T = T) end function blackbody(wave::AbstractVector{<:Real}, T::Real) flux = ustrip.(u"W/m^2/angstrom", _blackbody(wave * u"angstrom", T * u"K")) return spectrum(wave, flux, name = "Blackbody", T = T) end _blackbody(wave::AbstractVector{<:Quantity}, T::Quantity) = blackbody(T).(wave) """ blackbody(T::Quantity) Returns a function for calculating blackbody curves. """ blackbody(T::Quantity) = w->2h * c_0^2 / w^5 / (exp(h * c_0 / (w * k_B * T)) - 1)