text
stringlengths 0
3.34M
|
|---|
# From https://github.com/vchuravy/GPUifyLoops.jl/blob/b4d43198ec4aee75e6bcfdda7165ed5e469d2df5/src/loopinfo.jl
module LoopInfo
const HAS_LOOPINFO_EXPR = VERSION >= v"1.2.0-DEV.462"
export @unroll
##
# Uses the loopinfo expr node to attach LLVM loopinfo to loops
# the full list of supported metadata nodes is available at
# https://llvm.org/docs/LangRef.html#llvm-loop
# TODO: Figure out how to deal with compile-time constants in `@unroll(N, expr)`
# so constants that come from `Val{N}` but are not parse time constant.
# Most likely will require changes to base Julia.
##
module MD
unroll_count(n) = (Symbol("llvm.loop.unroll.count"), convert(Int, n))
unroll_disable() = (Symbol("llvm.loop.unroll.disable"), 1)
unroll_enable() = (Symbol("llvm.loop.unroll.enable"), 1)
unroll_full() = (Symbol("llvm.loop.unroll.full"), 1)
end
function loopinfo(expr, nodes...)
if expr.head != :for
error("Syntax error: loopinfo needs a for loop")
end
if HAS_LOOPINFO_EXPR
push!(expr.args[2].args, Expr(:loopinfo, nodes...))
end
return expr
end
"""
@unroll expr
Takes a for loop as `expr` and informs the LLVM unroller to fully unroll it, if
it is safe to do so and the loop count is known.
"""
macro unroll(expr)
expr = loopinfo(expr, MD.unroll_full())
return esc(expr)
end
"""
@unroll N expr
Takes a for loop as `expr` and informs the LLVM unroller to unroll it `N` times,
if it is safe to do so.
"""
macro unroll(N, expr)
if !(N isa Integer)
error("Syntax error: `@unroll N expr` needs a constant integer N")
end
expr = loopinfo(expr, MD.unroll_count(N))
return esc(expr)
end
end #module
|
lemma open_path_connected_component: fixes S :: "'a :: real_normed_vector set" shows "open S \<Longrightarrow> path_component S x = connected_component S x" |
Formal statement is: lemma filterlim_at_infinity: fixes f :: "_ \<Rightarrow> 'a::real_normed_vector" assumes "0 \<le> c" shows "(LIM x F. f x :> at_infinity) \<longleftrightarrow> (\<forall>r>c. eventually (\<lambda>x. r \<le> norm (f x)) F)" Informal statement is: If $f$ is a nonnegative real-valued function, then $f$ tends to infinity if and only if for every $r > c$, there exists an $x$ such that $r \leq f(x)$. |
Require Import ExtLib.Data.HList.
Require Import ExtLib.Core.RelDec.
Require Import Charge.Logics.ILogic.
Require Import Charge.ModularFunc.ListType.
Require Import Charge.ModularFunc.BaseType.
Require Import Charge.ModularFunc.ListFunc.
Require Import Charge.ModularFunc.BaseFunc.
Require Import Charge.ModularFunc.SemiEqDecTyp.
Require Import Charge.Tactics.Base.DenotationTacs.
Require Import Charge.Tactics.Base.MirrorCoreTacs.
Require Import ExtLib.Tactics.
Require Import MirrorCore.TypesI.
Require Import MirrorCore.RTac.Core.
Require Import MirrorCore.Lambda.AppN.
Require Import MirrorCore.Lambda.Red.
Require Import MirrorCore.Lambda.RedAll.
Require Import MirrorCore.Lambda.Expr.
Section Length.
Context {typ func : Type} {RType_typ : RType typ} {RSym_func : RSym func}
{BT : BaseType typ} {BTD : BaseTypeD BT}
{LT : ListType typ} {LTD: ListTypeD LT}.
Context {BF : BaseFunc typ func} {LF : ListFunc typ func}.
Context {RelDec_eq : RelDec (@eq typ)} {RelDecOk_eq : RelDec_Correct RelDec_eq}.
Context {Heqd : SemiEqDecTyp typ} {HeqdOk : SemiEqDecTypOk Heqd}.
Context {EU : ExprUVar (expr typ func)}.
Context {RType_typOk : RTypeOk} {RsymOk_func : RSymOk RSym_func}.
Context {Typ0_tyProp : Typ0 _ Prop}.
Context {Typ2_tyArr : Typ2 _ Fun}.
Context {Typ0Ok_tyProp : Typ0Ok Typ0_tyProp}.
Context {Typ2Ok_tyArr : Typ2Ok Typ2_tyArr}.
Context {BFOk : BaseFuncOk typ func } {LFOk : ListFuncOk typ func}.
Let tyArr : typ -> typ -> typ := @typ2 _ _ _ _.
Let tyProp := @typ0 typ RType_typ Prop Typ0_tyProp.
(* This function will return None unless lst eventually reaches nil. This means that we cannot partially evaluate a length of a list
(length 1::2::3::lst = 3 + (length lst) for instance). To be able to do this, we need a language that supports arithmetic operations
(at least +) on natural numbers. This is a perfectly natural thing to have, but it is not implemented at the moment. *)
Fixpoint lengthTacAux (t : typ) (lst : expr typ func) : option nat :=
match lst with
| App (App f x) xs =>
match listS f with
| Some (pCons _) =>
match lengthTacAux t xs with
| Some x => Some (S x)
| None => None
end
| _ => None
end
| _ => None
end.
Definition lengthTac (_ : list (option (expr typ func))) (e : expr typ func) (args : list (expr typ func)) : expr typ func :=
match listS e, args with
| Some (pLength t), lst::nil =>
match baseS lst with
| Some (pConst u c) =>
match type_cast (tyList t) u with
| Some pf => mkNat (natR (length (listD (eq_rect_r typD c pf))))
| None => apps e args
end
| _ =>
match lengthTacAux t lst with
| Some l => mkNat (natR l)
| None => apps e args
end
end
| _, _ => apps e args
end.
Existing Instance Expr_expr.
Existing Instance ExprOk_expr.
End Length. |
module Addition.Absorb
import Data.Vect
import Common.Util
import Common.Interfaces
import Specifications.DiscreteOrderedGroup
import Specifications.OrderedRing
import Proofs.GroupTheory
import Addition.Carry
import Addition.Scaling
import Addition.AbsorptionLemmas
import Addition.Adhoc
%default total
%access export
||| This is a proof friendly semantics function. Consider a tail
||| recursive variation for run time use.
public export
phi : Ringops s => (radix : s) -> (lsdf : Vect n s) -> (msc : Carry) -> s
phi radix (x :: xs) c = x + radix * phi radix xs c
phi radix [] c = value c
||| The result of absorbing carry digits:
|||
||| in1 in2 in3
||| ou1 ou2 pen + unk
||| msc abs abs unk
|||
||| unk = the least significant carry is still unknown
||| pen = ouput of reduction before absorbing the unknown carry
||| msc = most significant carry
||| abs = carry already absorbed in the corresponding output
data Absorption :
(k : Nat) ->
(constraints : s -> Vect k s -> Type) ->
(semantics : Vect (S k) s -> Carry -> s) ->
(inputs : Vect (S k) s) -> Type
where MkAbsorption :
(msc : Carry) ->
(pending : s) ->
(outputs : Vect k s) ->
(constraints pending outputs) ->
(semantics inputs O = semantics (pending :: outputs) msc) ->
Absorption k constraints semantics inputs
outputs : Absorption {s} k _ _ _ -> (Carry, Vect (S k) s)
outputs (MkAbsorption c p o _ _) = (c, reverse (p :: o))
absorptionBase : Ringops s =>
DiscreteOrderedRingSpec {s} (+) Zero Ng (*) leq One ->
(radix : s) ->
(red : Reduction (+) Zero Ng leq One u radix) ->
Absorption Z (Ranges leq Ng u (u + Ng One)) (phi radix) [input red]
absorptionBase spec radix (MkReduction i c o invariant outRange) =
MkAbsorption c o [] (MkRanges outRange []) o3
where
o1 : o + radix * value c = i
o1 = rewriteInvariant (unitalRing spec) radix i o c invariant
o2 : i = i + radix * value O
o2 = adhocIdentity2 (ring (unitalRing spec)) i radix
o3 : phi radix [i] O = phi radix [o] c
o3 = sym (o1 === o2)
arithLemma : Ringops s => UnitalRingSpec {s} (+) Zero Ng (*) One ->
(msc : Carry) ->
(pending : s) ->
(outputs : Vect k s) ->
(inputs : Vect (S k) s) ->
(red : Reduction {s} (+) Zero Ng _ One u radix) ->
(ih : phi radix inputs O = phi radix (pending :: outputs) msc) ->
phi radix (input red :: inputs) O =
phi radix (output red :: (value (carry red) + pending) :: outputs) msc
arithLemma {s} {radix} spec msc pending outputs inputs
(MkReduction i c o invariant _) inductionHypothesis =
let
adhoc = adhocIdentity1 (ring spec) pending o radix (value c) o2
shift = radix * phi radix inputs O
shifted = cong {f = (+ shift)} o1
in shifted @== adhoc
where
o1 : o + radix * value c = i
o1 = rewriteInvariant spec radix i o c invariant
o2 : phi radix inputs O = pending + radix * phi radix outputs msc
o2 = inductionHypothesis
absorptionStep : Ringops s =>
DiscreteOrderedRingSpec {s} (+) Zero Ng (*) leq One ->
(radix : s) ->
(red : Reduction (+) Zero Ng leq One u radix) ->
Absorption k (Ranges leq Ng u (u + Ng One)) (phi radix) inputs ->
Absorption (S k) (Ranges leq Ng u (u + Ng One))
(phi radix) (input red :: inputs)
absorptionStep spec radix red@(MkReduction _ _ _ _ reducedRange)
(MkAbsorption {inputs} msc pending outputs ranges invariant) =
let absorb = value (carry red) + pending
in MkAbsorption msc (output red) (absorb :: outputs)
(rangeLemma (discreteOrderedGroup spec) ranges reducedRange (carry red))
(arithLemma (unitalRing spec) msc pending outputs inputs red invariant)
|
(* *********************************************************************)
(* *)
(* 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. *)
(* *)
(* *********************************************************************)
Require Import Coqlib.
Require Import Integers.
Require Import AST.
Require Import Values.
Require Import Memory.
Require Import Globalenvs.
Require Import Events.
Inductive builtin_function: Type :=
| EF_vload (chunk: memory_chunk)
(** A volatile read operation. If the adress given as first argument
points within a volatile global variable, generate an
event and return the value found in this event. Otherwise,
produce no event and behave like a regular memory load. *)
| EF_vstore (chunk: memory_chunk)
(** A volatile store operation. If the adress given as first argument
points within a volatile global variable, generate an event.
Otherwise, produce no event and behave like a regular memory store. *)
| EF_vload_global (chunk: memory_chunk) (id: ident) (ofs: int)
(** A volatile load operation from a global variable.
Specialized version of [EF_vload]. *)
| EF_vstore_global (chunk: memory_chunk) (id: ident) (ofs: int)
(** A volatile store operation in a global variable.
Specialized version of [EF_vstore]. *)
| EF_memcpy (sz: Z) (al: Z)
(** Block copy, of [sz] bytes, between addresses that are [al]-aligned. *)
| EF_annot (text: ident) (targs: list annot_arg)
(** A programmer-supplied annotation. Takes zero, one or several arguments,
produces an event carrying the text and the values of these arguments,
and returns no value. *)
| EF_annot_val (text: ident) (targ: typ)
(** Another form of annotation that takes one argument, produces
an event carrying the text and the value of this argument,
and returns the value of the argument. *)
| EF_inline_asm (text: ident).
(** Inline [asm] statements. Semantically, treated like an
annotation with no parameters ([EF_annot text nil]). To be
used with caution, as it can invalidate the semantic
preservation theorem. Generated only if [-finline-asm] is
given. *)
Definition bf_sig (bf: builtin_function): signature :=
match bf with
| EF_vload chunk => mksignature (Tint :: nil) (Some (type_of_chunk chunk))
| EF_vstore chunk => mksignature (Tint :: type_of_chunk chunk :: nil) None
| EF_vload_global chunk _ _ => mksignature nil (Some (type_of_chunk chunk))
| EF_vstore_global chunk _ _ => mksignature (type_of_chunk chunk :: nil) None
| EF_memcpy sz al => mksignature (Tint :: Tint :: nil) None
| EF_annot text targs => mksignature (annot_args_typ targs) None
| EF_annot_val text targ => mksignature (targ :: nil) (Some targ)
| EF_inline_asm text => mksignature nil None
end.
Definition bf_reloads (bf: builtin_function) : bool :=
match bf with
| EF_annot text targs => false
| _ => true
end.
Global Instance bf_ops: ExtFunOps builtin_function := {
ef_sig := bf_sig;
ef_reloads := bf_reloads
}.
Global Instance bf_proof: ExternalFunctions builtin_function := {
}.
(** ** Semantics of volatile loads *)
Section WITHMEM.
Context `{Hcc: CompilerConfiguration}.
Set Implicit Arguments.
Inductive volatile_load_sem (chunk: memory_chunk) (F V: Type) (ge: Genv.t F V):
list val -> mem -> trace -> val -> mem -> Prop :=
| volatile_load_sem_intro: forall b ofs m t v,
volatile_load ge chunk m b ofs t v ->
volatile_load_sem chunk ge (Vptr b ofs :: nil) m t v m.
Lemma volatile_load_preserved:
forall F1 V1 (ge1: Genv.t F1 V1) F2 V2 (ge2: Genv.t F2 V2) chunk m b ofs t v,
(forall id, Genv.find_symbol ge2 id = Genv.find_symbol ge1 id) ->
(forall b, block_is_volatile ge2 b = block_is_volatile ge1 b) ->
volatile_load ge1 chunk m b ofs t v ->
volatile_load ge2 chunk m b ofs t v.
Proof.
intros. inv H1; constructor; auto.
rewrite H0; auto.
rewrite H; auto.
eapply eventval_match_preserved; eauto.
rewrite H0; auto.
Qed.
Lemma volatile_load_extends:
forall F V (ge: Genv.t F V) chunk m b ofs t v m',
volatile_load ge chunk m b ofs t v ->
Mem.extends m m' ->
exists v', volatile_load ge chunk m' b ofs t v' /\ Val.lessdef v v'.
Proof.
intros. inv H.
econstructor; split; eauto. econstructor; eauto.
exploit Mem.load_extends; eauto. intros [v' [A B]]. exists v'; split; auto. constructor; auto.
Qed.
Remark meminj_preserves_block_is_volatile:
forall F V (ge: Genv.t F V) f b1 b2 delta,
meminj_preserves_globals ge f ->
f b1 = Some (b2, delta) ->
block_is_volatile ge b2 = block_is_volatile ge b1.
Proof.
intros. destruct H as [A [B C]]. unfold block_is_volatile.
case_eq (Genv.find_var_info ge b1); intros.
exploit B; eauto. intro EQ; rewrite H0 in EQ; inv EQ. rewrite H; auto.
case_eq (Genv.find_var_info ge b2); intros.
exploit C; eauto. intro EQ. congruence.
auto.
Qed.
Lemma volatile_load_inject:
forall F V (ge: Genv.t F V) f chunk m b ofs t v b' ofs' m',
meminj_preserves_globals ge f ->
volatile_load ge chunk m b ofs t v ->
val_inject f (Vptr b ofs) (Vptr b' ofs') ->
Mem.inject f m m' ->
exists v', volatile_load ge chunk m' b' ofs' t v' /\ val_inject f v v'.
Proof.
intros. inv H0.
inv H1. exploit (proj1 H); eauto. intros EQ; rewrite H8 in EQ; inv EQ.
rewrite Int.add_zero. exists (Val.load_result chunk v0); split.
constructor; auto.
apply val_load_result_inject. eapply eventval_match_inject_2; eauto.
exploit Mem.loadv_inject; eauto. simpl; eauto. simpl; intros [v' [A B]]. exists v'; split; auto.
constructor; auto. rewrite <- H3. inv H1. eapply meminj_preserves_block_is_volatile; eauto.
Qed.
Lemma volatile_load_receptive:
forall F V (ge: Genv.t F V) chunk m b ofs t1 t2 v1,
volatile_load ge chunk m b ofs t1 v1 -> match_traces ge t1 t2 ->
exists v2, volatile_load ge chunk m b ofs t2 v2.
Proof.
intros. inv H; inv H0.
exploit eventval_match_valid; eauto. intros [A B].
exploit eventval_valid_match. eexact H9. rewrite <- H10; eauto.
intros [v' EVM]. exists (Val.load_result chunk v'). constructor; auto.
exists v1; constructor; auto.
Qed.
Lemma volatile_load_ok:
forall chunk,
extcall_properties (volatile_load_sem chunk)
(mksignature (Tint :: nil) (Some (type_of_chunk chunk))).
Proof.
intros; constructor; intros.
(* well typed *)
unfold proj_sig_res; simpl. inv H. inv H0.
destruct chunk; destruct v; simpl; constructor.
eapply Mem.load_type; eauto.
(* arity *)
inv H; inv H0; auto.
(* symbols *)
inv H1. constructor. eapply volatile_load_preserved; eauto.
(* valid blocks *)
inv H; auto.
(* max perms *)
inv H; auto.
(* readonly *)
inv H; auto.
(* mem extends *)
inv H. inv H1. inv H6. inv H4.
exploit volatile_load_extends; eauto. intros [v' [A B]].
exists v'; exists m1'; intuition. constructor; auto. red; auto.
(* mem injects *)
inv H0. inv H2. inv H7. inversion H5; subst.
exploit volatile_load_inject; eauto. intros [v' [A B]].
exists f; exists v'; exists m1'; intuition. constructor; auto.
red; auto. red; auto. red; intros. congruence.
(* trace length *)
inv H; inv H0; simpl; omega.
(* receptive *)
inv H. exploit volatile_load_receptive; eauto. intros [v2 A].
exists v2; exists m1; constructor; auto.
(* determ *)
inv H; inv H0. inv H1; inv H7; try congruence.
assert (id = id0) by (eapply Genv.genv_vars_inj; eauto). subst id0.
exploit eventval_match_valid. eexact H2. intros [V1 T1].
exploit eventval_match_valid. eexact H4. intros [V2 T2].
split. constructor; auto. congruence.
intros EQ; inv EQ.
assert (v = v0) by (eapply eventval_match_determ_1; eauto). subst v0.
auto.
split. constructor. intuition congruence.
Qed.
Inductive volatile_load_global_sem (chunk: memory_chunk) (id: ident) (ofs: int)
(F V: Type) (ge: Genv.t F V):
list val -> mem -> trace -> val -> mem -> Prop :=
| volatile_load_global_sem_intro: forall b t v m,
Genv.find_symbol ge id = Some b ->
volatile_load ge chunk m b ofs t v ->
volatile_load_global_sem chunk id ofs ge nil m t v m.
Remark volatile_load_global_charact:
forall chunk id ofs (F V: Type) (ge: Genv.t F V) vargs m t vres m',
volatile_load_global_sem chunk id ofs ge vargs m t vres m' <->
exists b, Genv.find_symbol ge id = Some b /\ volatile_load_sem chunk ge (Vptr b ofs :: vargs) m t vres m'.
Proof.
intros; split.
intros. inv H. exists b; split; auto. constructor; auto.
intros [b [P Q]]. inv Q. econstructor; eauto.
Qed.
Lemma volatile_load_global_ok:
forall chunk id ofs,
extcall_properties (volatile_load_global_sem chunk id ofs)
(mksignature nil (Some (type_of_chunk chunk))).
Proof.
intros; constructor; intros.
(* well typed *)
unfold proj_sig_res; simpl. inv H. inv H1.
destruct chunk; destruct v; simpl; constructor.
eapply Mem.load_type; eauto.
(* arity *)
inv H; inv H1; auto.
(* symbols *)
inv H1. econstructor. rewrite H; eauto. eapply volatile_load_preserved; eauto.
(* valid blocks *)
inv H; auto.
(* max perm *)
inv H; auto.
(* readonly *)
inv H; auto.
(* extends *)
inv H. inv H1. exploit volatile_load_extends; eauto. intros [v' [A B]].
exists v'; exists m1'; intuition. econstructor; eauto. red; auto.
(* inject *)
inv H0. inv H2.
assert (val_inject f (Vptr b ofs) (Vptr b ofs)).
exploit (proj1 H); eauto. intros EQ. econstructor. eauto. rewrite Int.add_zero; auto.
exploit volatile_load_inject; eauto. intros [v' [A B]].
exists f; exists v'; exists m1'; intuition. econstructor; eauto.
red; auto. red; auto. red; intros; congruence.
(* trace length *)
inv H; inv H1; simpl; omega.
(* receptive *)
inv H. exploit volatile_load_receptive; eauto. intros [v2 A].
exists v2; exists m1; econstructor; eauto.
(* determ *)
rewrite volatile_load_global_charact in *.
destruct H as [b1 [A1 B1]]. destruct H0 as [b2 [A2 B2]].
rewrite A1 in A2; inv A2.
eapply ec_determ. eapply volatile_load_ok. eauto. eauto.
Qed.
(** ** Semantics of volatile stores *)
Inductive volatile_store_sem (chunk: memory_chunk) (F V: Type) (ge: Genv.t F V):
list val -> mem -> trace -> val -> mem -> Prop :=
| volatile_store_sem_intro: forall b ofs m1 v t m2,
volatile_store ge chunk m1 b ofs v t m2 ->
volatile_store_sem chunk ge (Vptr b ofs :: v :: nil) m1 t Vundef m2.
Lemma volatile_store_preserved:
forall F1 V1 (ge1: Genv.t F1 V1) F2 V2 (ge2: Genv.t F2 V2) chunk m1 b ofs v t m2,
(forall id, Genv.find_symbol ge2 id = Genv.find_symbol ge1 id) ->
(forall b, block_is_volatile ge2 b = block_is_volatile ge1 b) ->
volatile_store ge1 chunk m1 b ofs v t m2 ->
volatile_store ge2 chunk m1 b ofs v t m2.
Proof.
intros. inv H1; constructor; auto.
rewrite H0; auto.
rewrite H; auto.
eapply eventval_match_preserved; eauto.
rewrite H0; auto.
Qed.
Lemma volatile_store_readonly:
forall F V (ge: Genv.t F V) chunk1 m1 b1 ofs1 v t m2 chunk ofs b,
volatile_store ge chunk1 m1 b1 ofs1 v t m2 ->
Mem.valid_block m1 b ->
(forall ofs', ofs <= ofs' < ofs + size_chunk chunk ->
~(Mem.perm m1 b ofs' Max Writable)) ->
Mem.load chunk m2 b ofs = Mem.load chunk m1 b ofs.
Proof.
intros. inv H.
auto.
eapply Mem.load_store_other; eauto.
destruct (eq_block b b1); auto. subst b1. right.
apply (Intv.range_disjoint' (ofs, ofs + size_chunk chunk)
(Int.unsigned ofs1, Int.unsigned ofs1 + size_chunk chunk1)).
red; intros; red; intros.
elim (H1 x); auto.
exploit Mem.store_valid_access_3; eauto. intros [A B].
apply Mem.perm_cur_max. apply A. auto.
simpl. generalize (size_chunk_pos chunk); omega.
simpl. generalize (size_chunk_pos chunk1); omega.
Qed.
Lemma volatile_store_extends:
forall F V (ge: Genv.t F V) chunk m1 b ofs v t m2 m1' v',
volatile_store ge chunk m1 b ofs v t m2 ->
Mem.extends m1 m1' ->
Val.lessdef v v' ->
exists m2',
volatile_store ge chunk m1' b ofs v' t m2'
/\ Mem.extends m2 m2'
/\ mem_unchanged_on (loc_out_of_bounds m1) m1' m2'.
Proof.
intros. inv H.
econstructor; split. econstructor; eauto. eapply eventval_match_lessdef; eauto.
split. auto. red; auto.
exploit Mem.store_within_extends; eauto. intros [m2' [A B]].
exists m2'; intuition. econstructor; eauto.
red; split; intros.
eapply Mem.perm_store_1; eauto.
rewrite <- H4. eapply Mem.load_store_other; eauto.
destruct (eq_block b0 b); auto. subst b0; right.
apply (Intv.range_disjoint' (ofs0, ofs0 + size_chunk chunk0)
(Int.unsigned ofs, Int.unsigned ofs + size_chunk chunk)).
red; intros; red; intros.
exploit (H x H5). exploit Mem.store_valid_access_3. eexact H3. intros [E G].
apply Mem.perm_cur_max. apply Mem.perm_implies with Writable; auto with mem.
auto.
simpl. generalize (size_chunk_pos chunk0). omega.
simpl. generalize (size_chunk_pos chunk). omega.
Qed.
Lemma volatile_store_inject:
forall F V (ge: Genv.t F V) f chunk m1 b ofs v t m2 m1' b' ofs' v',
meminj_preserves_globals ge f ->
volatile_store ge chunk m1 b ofs v t m2 ->
val_inject f (Vptr b ofs) (Vptr b' ofs') ->
val_inject f v v' ->
Mem.inject f m1 m1' ->
exists m2',
volatile_store ge chunk m1' b' ofs' v' t m2'
/\ Mem.inject f m2 m2'
/\ mem_unchanged_on (loc_unmapped f) m1 m2
/\ mem_unchanged_on (loc_out_of_reach f m1) m1' m2'.
Proof.
intros. inv H0.
inv H1. exploit (proj1 H); eauto. intros EQ; rewrite H9 in EQ; inv EQ.
rewrite Int.add_zero. exists m1'.
split. constructor; auto. eapply eventval_match_inject; eauto.
split. auto. split. red; auto. red; auto.
assert (Mem.storev chunk m1 (Vptr b ofs) v = Some m2). simpl; auto.
exploit Mem.storev_mapped_inject; eauto. intros [m2' [A B]].
inv H1. exists m2'; intuition.
constructor; auto. rewrite <- H4. eapply meminj_preserves_block_is_volatile; eauto.
split; intros. eapply Mem.perm_store_1; eauto.
rewrite <- H6. eapply Mem.load_store_other; eauto.
left. exploit (H1 ofs0). generalize (size_chunk_pos chunk0). omega.
unfold loc_unmapped. congruence.
split; intros. eapply Mem.perm_store_1; eauto.
rewrite <- H6. eapply Mem.load_store_other; eauto.
destruct (eq_block b0 b'); auto. subst b0; right.
assert (EQ: Int.unsigned (Int.add ofs (Int.repr delta)) = Int.unsigned ofs + delta).
eapply Mem.address_inject; eauto with mem.
unfold Mem.storev in A. rewrite EQ in A. rewrite EQ.
apply (Intv.range_disjoint' (ofs0, ofs0 + size_chunk chunk0)
(Int.unsigned ofs + delta, Int.unsigned ofs + delta + size_chunk chunk)).
red; intros; red; intros. exploit (H1 x H7). eauto.
exploit Mem.store_valid_access_3. eexact H0. intros [C D].
apply Mem.perm_cur_max. apply Mem.perm_implies with Writable; auto with mem.
apply C. red in H8; simpl in H8. omega.
auto.
simpl. generalize (size_chunk_pos chunk0). omega.
simpl. generalize (size_chunk_pos chunk). omega.
Qed.
Lemma volatile_store_receptive:
forall F V (ge: Genv.t F V) chunk m b ofs v t1 m1 t2,
volatile_store ge chunk m b ofs v t1 m1 -> match_traces ge t1 t2 -> t1 = t2.
Proof.
intros. inv H; inv H0; auto.
Qed.
Lemma volatile_store_ok:
forall chunk,
extcall_properties (volatile_store_sem chunk)
(mksignature (Tint :: type_of_chunk chunk :: nil) None).
Proof.
intros; constructor; intros.
(* well typed *)
unfold proj_sig_res; simpl. inv H; constructor.
(* arity *)
inv H; simpl; auto.
(* symbols preserved *)
inv H1. constructor. eapply volatile_store_preserved; eauto.
(* valid block *)
inv H. inv H1. auto. eauto with mem.
(* perms *)
inv H. inv H2. auto. eauto with mem.
(* readonly *)
inv H. eapply volatile_store_readonly; eauto.
(* mem extends*)
inv H. inv H1. inv H6. inv H7. inv H4.
exploit volatile_store_extends; eauto. intros [m2' [A [B C]]].
exists Vundef; exists m2'; intuition. constructor; auto.
(* mem inject *)
inv H0. inv H2. inv H7. inv H8. inversion H5; subst.
exploit volatile_store_inject; eauto. intros [m2' [A [B [C D]]]].
exists f; exists Vundef; exists m2'; intuition. constructor; auto. red; intros; congruence.
(* trace length *)
inv H; inv H0; simpl; omega.
(* receptive *)
assert (t1 = t2). inv H. eapply volatile_store_receptive; eauto.
subst t2; exists vres1; exists m1; auto.
(* determ *)
inv H; inv H0. inv H1; inv H8; try congruence.
assert (id = id0) by (eapply Genv.genv_vars_inj; eauto). subst id0.
assert (ev = ev0) by (eapply eventval_match_determ_2; eauto). subst ev0.
split. constructor. auto.
split. constructor. intuition congruence.
Qed.
Inductive volatile_store_global_sem (chunk: memory_chunk) (id: ident) (ofs: int)
(F V: Type) (ge: Genv.t F V):
list val -> mem -> trace -> val -> mem -> Prop :=
| volatile_store_global_sem_intro: forall b m1 v t m2,
Genv.find_symbol ge id = Some b ->
volatile_store ge chunk m1 b ofs v t m2 ->
volatile_store_global_sem chunk id ofs ge (v :: nil) m1 t Vundef m2.
Remark volatile_store_global_charact:
forall chunk id ofs (F V: Type) (ge: Genv.t F V) vargs m t vres m',
volatile_store_global_sem chunk id ofs ge vargs m t vres m' <->
exists b, Genv.find_symbol ge id = Some b /\ volatile_store_sem chunk ge (Vptr b ofs :: vargs) m t vres m'.
Proof.
intros; split.
intros. inv H; exists b; split; auto; econstructor; eauto.
intros [b [P Q]]. inv Q. econstructor; eauto.
Qed.
Lemma volatile_store_global_ok:
forall chunk id ofs,
extcall_properties (volatile_store_global_sem chunk id ofs)
(mksignature (type_of_chunk chunk :: nil) None).
Proof.
intros; constructor; intros.
(* well typed *)
unfold proj_sig_res; simpl. inv H; constructor.
(* arity *)
inv H; simpl; auto.
(* symbols preserved *)
inv H1. econstructor. rewrite H; eauto. eapply volatile_store_preserved; eauto.
(* valid block *)
inv H. inv H2. auto. eauto with mem.
(* perms *)
inv H. inv H3. auto. eauto with mem.
(* readonly *)
inv H. eapply volatile_store_readonly; eauto.
(* mem extends*)
rewrite volatile_store_global_charact in H. destruct H as [b [P Q]].
exploit ec_mem_extends. eapply volatile_store_ok. eexact Q. eauto. eauto.
intros [vres' [m2' [A [B [C D]]]]].
exists vres'; exists m2'; intuition. rewrite volatile_store_global_charact. exists b; auto.
(* mem inject *)
rewrite volatile_store_global_charact in H0. destruct H0 as [b [P Q]].
exploit (proj1 H). eauto. intros EQ.
assert (val_inject f (Vptr b ofs) (Vptr b ofs)). econstructor; eauto. rewrite Int.add_zero; auto.
exploit ec_mem_inject. eapply volatile_store_ok. eauto. eexact Q. eauto. eauto.
intros [f' [vres' [m2' [A [B [C [D [E G]]]]]]]].
exists f'; exists vres'; exists m2'; intuition.
rewrite volatile_store_global_charact. exists b; auto.
(* trace length *)
inv H. inv H1; simpl; omega.
(* receptive *)
assert (t1 = t2). inv H. eapply volatile_store_receptive; eauto. subst t2.
exists vres1; exists m1; congruence.
(* determ *)
rewrite volatile_store_global_charact in *.
destruct H as [b1 [A1 B1]]. destruct H0 as [b2 [A2 B2]]. rewrite A1 in A2; inv A2.
eapply ec_determ. eapply volatile_store_ok. eauto. eauto.
Qed.
(** ** Semantics of annotations. *)
Fixpoint annot_eventvals (targs: list annot_arg) (vargs: list eventval) : list eventval :=
match targs, vargs with
| AA_arg ty :: targs', varg :: vargs' => varg :: annot_eventvals targs' vargs'
| AA_int n :: targs', _ => EVint n :: annot_eventvals targs' vargs
| AA_float n :: targs', _ => EVfloat n :: annot_eventvals targs' vargs
| _, _ => vargs
end.
Inductive extcall_annot_sem (text: ident) (targs: list annot_arg) (F V: Type) (ge: Genv.t F V):
list val -> mem -> trace -> val -> mem -> Prop :=
| extcall_annot_sem_intro: forall vargs m args,
eventval_list_match ge args (annot_args_typ targs) vargs ->
extcall_annot_sem text targs ge vargs m
(Event_annot text (annot_eventvals targs args) :: E0) Vundef m.
Lemma extcall_annot_ok:
forall text targs,
extcall_properties (extcall_annot_sem text targs) (mksignature (annot_args_typ targs) None).
Proof.
intros; constructor; intros.
(* well typed *)
inv H. simpl. auto.
(* arity *)
inv H. simpl. eapply eventval_list_match_length; eauto.
(* symbols *)
inv H1. econstructor; eauto.
eapply eventval_list_match_preserved; eauto.
(* valid blocks *)
inv H; auto.
(* perms *)
inv H; auto.
(* readonly *)
inv H; auto.
(* mem extends *)
inv H.
exists Vundef; exists m1'; intuition.
econstructor; eauto.
eapply eventval_list_match_lessdef; eauto.
red; auto.
(* mem injects *)
inv H0.
exists f; exists Vundef; exists m1'; intuition.
econstructor; eauto.
eapply eventval_list_match_inject; eauto.
red; auto.
red; auto.
red; intros; congruence.
(* trace length *)
inv H; simpl; omega.
(* receptive *)
assert (t1 = t2). inv H; inv H0; auto.
exists vres1; exists m1; congruence.
(* determ *)
inv H; inv H0.
assert (args = args0). eapply eventval_list_match_determ_2; eauto. subst args0.
split. constructor. auto.
Qed.
Inductive extcall_annot_val_sem (text: ident) (targ: typ) (F V: Type) (ge: Genv.t F V):
list val -> mem -> trace -> val -> mem -> Prop :=
| extcall_annot_val_sem_intro: forall varg m arg,
eventval_match ge arg targ varg ->
extcall_annot_val_sem text targ ge (varg :: nil) m (Event_annot text (arg :: nil) :: E0) varg m.
Lemma extcall_annot_val_ok:
forall text targ,
extcall_properties (extcall_annot_val_sem text targ) (mksignature (targ :: nil) (Some targ)).
Proof.
intros; constructor; intros.
inv H. unfold proj_sig_res; simpl. eapply eventval_match_type; eauto.
inv H. auto.
inv H1. econstructor; eauto.
eapply eventval_match_preserved; eauto.
inv H; auto.
inv H; auto.
inv H; auto.
inv H. inv H1. inv H6.
exists v2; exists m1'; intuition.
econstructor; eauto.
eapply eventval_match_lessdef; eauto.
red; auto.
inv H0. inv H2. inv H7.
exists f; exists v'; exists m1'; intuition.
econstructor; eauto.
eapply eventval_match_inject; eauto.
red; auto.
red; auto.
red; intros; congruence.
inv H; simpl; omega.
assert (t1 = t2). inv H; inv H0; auto. subst t2.
exists vres1; exists m1; auto.
inv H; inv H0.
assert (arg = arg0). eapply eventval_match_determ_2; eauto. subst arg0.
split. constructor. auto.
Qed.
(** ** Semantics of [memcpy] operations. *)
Inductive extcall_memcpy_sem (sz al: Z) (F V: Type) (ge: Genv.t F V): list val -> mem -> trace -> val -> mem -> Prop :=
| extcall_memcpy_sem_intro: forall bdst odst bsrc osrc m bytes m',
al = 1 \/ al = 2 \/ al = 4 \/ al = 8 -> sz > 0 ->
(al | sz) -> (al | Int.unsigned osrc) -> (al | Int.unsigned odst) ->
bsrc <> bdst \/ Int.unsigned osrc = Int.unsigned odst
\/ Int.unsigned osrc + sz <= Int.unsigned odst
\/ Int.unsigned odst + sz <= Int.unsigned osrc ->
Mem.loadbytes m bsrc (Int.unsigned osrc) sz = Some bytes ->
Mem.storebytes m bdst (Int.unsigned odst) bytes = Some m' ->
extcall_memcpy_sem sz al ge (Vptr bdst odst :: Vptr bsrc osrc :: nil) m E0 Vundef m'.
Lemma extcall_memcpy_ok:
forall sz al,
extcall_properties (extcall_memcpy_sem sz al) (mksignature (Tint :: Tint :: nil) None).
Proof.
intros. constructor.
(* return type *)
intros. inv H. constructor.
(* arity *)
intros. inv H. auto.
(* change of globalenv *)
intros. inv H1. econstructor; eauto.
(* valid blocks *)
intros. inv H. eauto with mem.
(* perms *)
intros. inv H. eapply Mem.perm_storebytes_2; eauto.
(* readonly *)
intros. inv H. eapply Mem.load_storebytes_other; eauto.
destruct (eq_block b bdst); auto. subst b. right.
apply (Intv.range_disjoint'
(ofs, ofs + size_chunk chunk)
(Int.unsigned odst, Int.unsigned odst + Z_of_nat (length bytes))).
red; intros; red; intros. elim (H1 x); auto.
apply Mem.perm_cur_max.
eapply Mem.storebytes_range_perm; eauto.
simpl. generalize (size_chunk_pos chunk); omega.
simpl. rewrite (Mem.loadbytes_length _ _ _ _ _ H8). rewrite nat_of_Z_eq.
omega. omega.
(* extensions *)
intros. inv H.
inv H1. inv H13. inv H14. inv H10. inv H11.
exploit Mem.loadbytes_length; eauto. intros LEN.
exploit Mem.loadbytes_extends; eauto. intros [bytes2 [A B]].
exploit Mem.storebytes_within_extends; eauto. intros [m2' [C D]].
exists Vundef; exists m2'.
split. econstructor; eauto.
split. constructor.
split. auto.
red; split; intros.
eauto with mem.
exploit Mem.loadbytes_length. eexact H8. intros.
rewrite <- H1. eapply Mem.load_storebytes_other; eauto.
destruct (eq_block b bdst); auto. subst b; right.
exploit list_forall2_length; eauto. intros R.
apply (Intv.range_disjoint' (ofs, ofs + size_chunk chunk)
(Int.unsigned odst, Int.unsigned odst + Z_of_nat (length bytes2))); simpl.
red; unfold Intv.In; simpl; intros; red; intros.
eapply (H x H11).
apply Mem.perm_cur_max. apply Mem.perm_implies with Writable; auto with mem.
eapply Mem.storebytes_range_perm. eexact H9.
rewrite R. auto.
generalize (size_chunk_pos chunk). omega.
rewrite <- R. rewrite H10. rewrite nat_of_Z_eq. omega. omega.
(* injections *)
intros. inv H0. inv H2. inv H14. inv H15. inv H11. inv H12.
exploit Mem.loadbytes_length; eauto. intros LEN.
assert (RPSRC: Mem.range_perm m1 bsrc (Int.unsigned osrc) (Int.unsigned osrc + sz) Cur Nonempty).
eapply Mem.range_perm_implies. eapply Mem.loadbytes_range_perm; eauto. auto with mem.
assert (RPDST: Mem.range_perm m1 bdst (Int.unsigned odst) (Int.unsigned odst + sz) Cur Nonempty).
replace sz with (Z_of_nat (length bytes)).
eapply Mem.range_perm_implies. eapply Mem.storebytes_range_perm; eauto. auto with mem.
rewrite LEN. apply nat_of_Z_eq. omega.
assert (PSRC: Mem.perm m1 bsrc (Int.unsigned osrc) Cur Nonempty).
apply RPSRC. omega.
assert (PDST: Mem.perm m1 bdst (Int.unsigned odst) Cur Nonempty).
apply RPDST. omega.
exploit Mem.address_inject. eauto. eexact PSRC. eauto. intros EQ1.
exploit Mem.address_inject. eauto. eexact PDST. eauto. intros EQ2.
exploit Mem.loadbytes_inject; eauto. intros [bytes2 [A B]].
exploit Mem.storebytes_mapped_inject; eauto. intros [m2' [C D]].
exists f; exists Vundef; exists m2'.
split. econstructor; try rewrite EQ1; try rewrite EQ2; eauto.
eapply Mem.aligned_area_inject with (m := m1); eauto.
eapply Mem.aligned_area_inject with (m := m1); eauto.
eapply Mem.disjoint_or_equal_inject with (m := m1); eauto.
apply Mem.range_perm_max with Cur; auto.
apply Mem.range_perm_max with Cur; auto.
split. constructor.
split. auto.
split. red; split; intros. eauto with mem.
rewrite <- H2. eapply Mem.load_storebytes_other; eauto.
destruct (eq_block b bdst); auto. subst b.
assert (loc_unmapped f bdst ofs). apply H0. generalize (size_chunk_pos chunk); omega.
red in H12. congruence.
split. red; split; intros. eauto with mem.
rewrite <- H2. eapply Mem.load_storebytes_other; eauto.
destruct (eq_block b b0); auto. subst b0; right.
rewrite <- (list_forall2_length B). rewrite LEN. rewrite nat_of_Z_eq; try omega.
apply (Intv.range_disjoint' (ofs, ofs + size_chunk chunk)
(Int.unsigned odst + delta0, Int.unsigned odst + delta0 + sz)); simpl.
red; unfold Intv.In; simpl; intros; red; intros.
eapply (H0 x H12). eauto. apply Mem.perm_cur_max. apply RPDST. omega.
generalize (size_chunk_pos chunk); omega.
omega.
split. apply inject_incr_refl.
red; intros; congruence.
(* trace length *)
intros; inv H. simpl; omega.
(* receptive *)
intros.
assert (t1 = t2). inv H; inv H0; auto. subst t2.
exists vres1; exists m1; auto.
(* determ *)
intros; inv H; inv H0. split. constructor. intros; split; congruence.
Qed.
Definition builtin_call (bf: builtin_function): extcall_sem :=
match bf with
| EF_vload chunk => volatile_load_sem chunk
| EF_vstore chunk => volatile_store_sem chunk
| EF_vload_global chunk id ofs => volatile_load_global_sem chunk id ofs
| EF_vstore_global chunk id ofs => volatile_store_global_sem chunk id ofs
| EF_memcpy sz al => extcall_memcpy_sem sz al
| EF_annot txt targs => extcall_annot_sem txt targs
| EF_annot_val txt targ=> extcall_annot_val_sem txt targ
| EF_inline_asm txt => extcall_annot_sem txt nil
end.
Theorem builtin_call_ok:
forall ef,
extcall_properties (builtin_call ef) (ef_sig ef).
Proof.
intros. unfold external_call, ef_sig. destruct ef.
apply volatile_load_ok.
apply volatile_store_ok.
apply volatile_load_global_ok.
apply volatile_store_global_ok.
apply extcall_memcpy_ok.
apply extcall_annot_ok.
apply extcall_annot_val_ok.
apply extcall_annot_ok.
Qed.
Global Instance bc_ops: ExtCallOps mem builtin_function := {
external_call := builtin_call
}.
Global Instance bc_proof: ExternalCalls mem builtin_function := {
external_call_spec := builtin_call_ok
}.
End WITHMEM.
|
{-# OPTIONS --cubical --safe --postfix-projections #-}
-- This module defines a data type for balanced strings of parentheses,
-- which is isomorphic to binary trees.
module Data.Dyck.Rose where
open import Prelude
open import Data.Nat using (_+_)
open import Data.Vec.Iterated using (Vec; _∷_; []; foldlN; head)
open import Data.Tree.Rose
open import Data.List
private
variable
n : ℕ
--------------------------------------------------------------------------------
-- Programs: definition and associated functions
--------------------------------------------------------------------------------
data Prog (A : Type a) : ℕ → Type a where
halt : Prog A 1
pull : Prog A (1 + n) → Prog A n
push : A → Prog A (1 + n) → Prog A (2 + n)
--------------------------------------------------------------------------------
-- Conversion from a Prog to a Tree
--------------------------------------------------------------------------------
prog→tree⊙ : Prog A n → Vec (Forest A) n → Forest A
prog→tree⊙ halt (v ∷ []) = v
prog→tree⊙ (pull is) st = prog→tree⊙ is ([] ∷ st)
prog→tree⊙ (push v is) (t₁ ∷ t₂ ∷ st) = prog→tree⊙ is (((v & t₂) ∷ t₁) ∷ st)
prog→tree : Prog A zero → Forest A
prog→tree ds = prog→tree⊙ ds []
--------------------------------------------------------------------------------
-- Conversion from a Tree to a Prog
--------------------------------------------------------------------------------
tree→prog⊙ : Forest A → Prog A (suc n) → Prog A n
tree→prog⊙ [] = pull
tree→prog⊙ ((t & ts) ∷ xs) = tree→prog⊙ ts ∘ tree→prog⊙ xs ∘ push t
tree→prog : Forest A → Prog A zero
tree→prog tr = tree→prog⊙ tr halt
--------------------------------------------------------------------------------
-- Proof of isomorphism
--------------------------------------------------------------------------------
tree→prog→tree⊙ : (e : Forest A) (is : Prog A (1 + n)) (st : Vec (Forest A) n) →
prog→tree⊙ (tree→prog⊙ e is) st ≡ prog→tree⊙ is (e ∷ st)
tree→prog→tree⊙ [] is st = refl
tree→prog→tree⊙ ((t & ts) ∷ xs) is st =
tree→prog→tree⊙ ts _ st ; tree→prog→tree⊙ xs (push t is) (ts ∷ st)
tree→prog→tree : (e : Forest A) → prog→tree (tree→prog e) ≡ e
tree→prog→tree e = tree→prog→tree⊙ e halt []
prog→tree→prog⊙ : (is : Prog A n) (st : Vec (Forest A) n) →
tree→prog (prog→tree⊙ is st) ≡ foldlN (Prog A) tree→prog⊙ is st
prog→tree→prog⊙ halt st = refl
prog→tree→prog⊙ (pull is) st = prog→tree→prog⊙ is ([] ∷ st)
prog→tree→prog⊙ (push x is) (t₁ ∷ t₂ ∷ st) =
prog→tree→prog⊙ is (((x & t₂) ∷ t₁) ∷ st)
prog→tree→prog : (is : Prog A 0) → tree→prog (prog→tree is) ≡ is
prog→tree→prog is = prog→tree→prog⊙ is []
prog-iso : Prog A zero ⇔ Forest A
prog-iso .fun = prog→tree
prog-iso .inv = tree→prog
prog-iso .rightInv = tree→prog→tree
prog-iso .leftInv = prog→tree→prog
|
[STATEMENT]
lemma extensional_push_forward: "extensional0 dest.diff_fun_space (push_forward X)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. extensional0 dest.diff_fun_space (push_forward X)
[PROOF STEP]
by (auto simp: push_forward_def) |
-- ------------------------------------------------------------ [ Sequence.idr ]
-- Module : UML.Sequence
-- Description : Sequence diagrams.
-- Copyright : (c) Jan de Muijnck-Hughes
-- License : see LICENSE
-- --------------------------------------------------------------------- [ EOH ]
module UML.Sequence
import public UML.Sequence.Model
import public UML.Sequence.Parser
-- --------------------------------------------------------------------- [ EOF ]
|
Eight FAB subtypes were proposed in 1976 .
|
-- Jesper, 2016-11-04
-- Absurd patterns should *not* be counted as a UnusedArg.
open import Common.Equality
data ⊥ : Set where
data Bool : Set where
true false : Bool
abort : (A : Set) → ⊥ → A
abort A ()
test : (x y : ⊥) → abort Bool x ≡ abort Bool y
test x y = refl
|
Formal statement is: lemma real_lim_sequentially: fixes l::complex shows "(f \<longlongrightarrow> l) sequentially \<Longrightarrow> (\<exists>N. \<forall>n\<ge>N. f n \<in> \<real>) \<Longrightarrow> l \<in> \<real>" Informal statement is: If $f$ converges to $l$ and $f$ is eventually real, then $l$ is real. |
= = = 2000s = = =
|
[STATEMENT]
lemma bound0_qf: "bound0 p \<Longrightarrow> qfree p"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. bound0 p \<Longrightarrow> qfree p
[PROOF STEP]
by (induct p) simp_all |
module Semantics where
open import Data.Nat hiding (_⊔_; _⊓_)
open import Data.Product
open import Data.Sum
open import Data.String using (String)
open import Data.Unit hiding (_≟_)
open import Data.Empty
open import Relation.Nullary
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_;_≢_; refl)
open Eq.≡-Reasoning
open import Level hiding (_⊔_) renaming (zero to lzero; suc to lsuc)
{- TODO:
* subtyping of refinement types
* union types
* intersection types
-}
Id = String
variable
x y : Id
ℓ : Level
data Expr : Set where
Nat : ℕ → Expr
Var : Id → Expr
Lam : Id → Expr → Expr
App : Expr → Expr → Expr
Pair : Expr → Expr → Expr
Fst Snd : Expr → Expr
Inl Inr : Expr → Expr
Case : Expr → Id → Expr → Id → Expr → Expr
data RawType : Set where
Nat : RawType
_⇒_ _⋆_ _⊹_ : RawType → RawType → RawType
ss⇒tt : ∀ {S S₁ T T₁ : RawType} → (S ⇒ S₁) ≡ (T ⇒ T₁) → (S ≡ T × S₁ ≡ T₁)
ss⇒tt refl = refl , refl
ss⋆tt : ∀ {S S₁ T T₁ : RawType} → (S ⋆ S₁) ≡ (T ⋆ T₁) → (S ≡ T × S₁ ≡ T₁)
ss⋆tt refl = refl , refl
ss⊹tt : ∀ {S S₁ T T₁ : RawType} → (S ⊹ S₁) ≡ (T ⊹ T₁) → (S ≡ T × S₁ ≡ T₁)
ss⊹tt refl = refl , refl
data Type : Set₁ where
Base : (P : ℕ → Set) → Type -- refinement
Nat : Type
_⇒_ : Type → Type → Type
_⋆_ : Type → Type → Type
_⊹_ : Type → Type → Type
T-Nat = Base (λ n → ⊤) -- all natural numbers
data ne : Type → Set where
ne-base : ∀ {P} → (∃P : Σ ℕ P) → ne (Base P)
ne-nat : ne Nat
ne-⇒ : ∀ {S T} → ne S → ne T → ne (S ⇒ T)
ne-⋆ : ∀ {S T} → ne S → ne T → ne (S ⋆ T)
ne-⊹L : ∀ {S T} → ne S → ne (S ⊹ T)
ne-⊹R : ∀ {S T} → ne T → ne (S ⊹ T)
data Env (A : Set ℓ) : Set ℓ where
· : Env A
_,_⦂_ : Env A → (x : Id) → (a : A) → Env A
∥_∥ : Type → RawType
∥ Base P ∥ = Nat
∥ Nat ∥ = Nat
∥ S ⇒ S₁ ∥ = ∥ S ∥ ⇒ ∥ S₁ ∥
∥ S ⋆ S₁ ∥ = ∥ S ∥ ⋆ ∥ S₁ ∥
∥ S ⊹ S₁ ∥ = ∥ S ∥ ⊹ ∥ S₁ ∥
_∨_ : (P Q : ℕ → Set) → ℕ → Set
P ∨ Q = λ n → P n ⊎ Q n
_∧_ : (P Q : ℕ → Set) → ℕ → Set
P ∧ Q = λ n → P n × Q n
implies : ∀ {P Q : ℕ → Set} → (n : ℕ) → P n → (P n ⊎ Q n)
implies n Pn = inj₁ Pn
p*q->p : ∀ {P Q : ℕ → Set} → (n : ℕ) → (P n × Q n) → P n
p*q->p n (Pn , Qn) = Pn
_⊔_ _⊓_ : (S T : Type) {r : ∥ S ∥ ≡ ∥ T ∥} → Type
(Base P ⊔ Base P₁) {refl} = Base (P ∨ P₁)
(Base P ⊔ Nat) = Nat
(Nat ⊔ Base P) = Nat
(Nat ⊔ Nat) = Nat
((S ⇒ S₁) ⊔ (T ⇒ T₁)) {r} with ss⇒tt r
... | sss , ttt = (S ⊓ T){sss} ⇒ (S₁ ⊔ T₁){ttt}
((S ⋆ S₁) ⊔ (T ⋆ T₁)) {r} with ss⋆tt r
... | sss , ttt = (S ⊔ T){sss} ⋆ (S₁ ⊔ T₁){ttt}
((S ⊹ S₁) ⊔ (T ⊹ T₁)) {r} with ss⊹tt r
... | sss , ttt = (S ⊔ T){sss} ⊹ (S₁ ⊔ T₁){ttt}
Base P ⊓ Base P₁ = Base (P ∧ P₁)
Base P ⊓ Nat = Base P
Nat ⊓ Base P = Base P
Nat ⊓ Nat = Nat
((S ⇒ S₁) ⊓ (T ⇒ T₁)){r} with ss⇒tt r
... | sss , ttt = (S ⊔ T){sss} ⇒ (S₁ ⊓ T₁){ttt}
((S ⋆ S₁) ⊓ (T ⋆ T₁)){r} with ss⋆tt r
... | sss , ttt = (S ⊓ T){sss} ⋆ (S₁ ⊓ T₁){ttt}
((S ⊹ S₁) ⊓ (T ⊹ T₁)){r} with ss⊹tt r
... | sss , ttt = (S ⊓ T){sss} ⊹ (S₁ ⊓ T₁){ttt}
variable
S T U S′ T′ U′ U″ : Type
Γ Γ₁ Γ₂ : Env Type
L M N : Expr
n : ℕ
P : ℕ → Set
data Split {A : Set ℓ} : Env A → Env A → Env A → Set ℓ where
nil : Split · · ·
lft : ∀ {a : A}{Γ Γ₁ Γ₂ : Env A} → Split Γ Γ₁ Γ₂ → Split (Γ , x ⦂ a) (Γ₁ , x ⦂ a) Γ₂
rgt : ∀ {a : A}{Γ Γ₁ Γ₂ : Env A} → Split Γ Γ₁ Γ₂ → Split (Γ , x ⦂ a) Γ₁ (Γ₂ , x ⦂ a)
data _⦂_∈_ {A : Set ℓ} : Id → A → Env A → Set ℓ where
found : ∀ {a : A}{E : Env A} →
x ⦂ a ∈ (E , x ⦂ a)
there : ∀ {a a' : A}{E : Env A} →
x ⦂ a ∈ E →
-- x ≢ y →
x ⦂ a ∈ (E , y ⦂ a')
data _<:_ : Type → Type → Set where
<:-refl :
T <: T
<:-base :
(P Q : ℕ → Set) →
(p→q : ∀ n → P n → Q n) →
Base P <: Base Q
<:-base-nat :
Base P <: Nat
<:-⇒ :
S′ <: S →
T <: T′ →
(S ⇒ T) <: (S′ ⇒ T′)
<:-⋆ :
S <: S′ →
T <: T′ →
(S ⋆ T) <: (S′ ⋆ T′)
<:-⊹ :
S <: S′ →
T <: T′ →
(S ⊹ T) <: (S′ ⊹ T′)
-- subtyping is compatible with raw types
<:-raw : S <: T → ∥ S ∥ ≡ ∥ T ∥
<:-raw <:-refl = refl
<:-raw (<:-base P Q p→q) = refl
<:-raw <:-base-nat = refl
<:-raw (<:-⇒ s<:t s<:t₁) = Eq.cong₂ _⇒_ (Eq.sym (<:-raw s<:t)) (<:-raw s<:t₁)
<:-raw (<:-⋆ s<:t s<:t₁) = Eq.cong₂ _⋆_ (<:-raw s<:t) (<:-raw s<:t₁)
<:-raw (<:-⊹ s<:t s<:t₁) = Eq.cong₂ _⊹_ (<:-raw s<:t) (<:-raw s<:t₁)
<:-⊔ : ∀ S T → {c : ∥ S ∥ ≡ ∥ T ∥} → S <: (S ⊔ T){c}
<:-⊓ : ∀ S T → {c : ∥ S ∥ ≡ ∥ T ∥} → (S ⊓ T){c} <: S
<:-⊔ (Base P) (Base P₁) {refl} = <:-base P (P ∨ P₁) implies
<:-⊔ (Base P) Nat = <:-base-nat
<:-⊔ Nat (Base P) = <:-refl
<:-⊔ Nat Nat = <:-refl
<:-⊔ (S ⇒ S₁) (T ⇒ T₁) {c} with ss⇒tt c
... | c1 , c2 = <:-⇒ (<:-⊓ S T) (<:-⊔ S₁ T₁)
<:-⊔ (S ⋆ S₁) (T ⋆ T₁) {c} with ss⋆tt c
... | c1 , c2 = <:-⋆ (<:-⊔ S T) (<:-⊔ S₁ T₁)
<:-⊔ (S ⊹ S₁) (T ⊹ T₁) {c} with ss⊹tt c
... | c1 , c2 = <:-⊹ (<:-⊔ S T) (<:-⊔ S₁ T₁)
<:-⊓ (Base P) (Base P₁) {refl} = <:-base (P ∧ P₁) P p*q->p
<:-⊓ (Base P) Nat = <:-refl
<:-⊓ Nat (Base P) = <:-base-nat
<:-⊓ Nat Nat = <:-refl
<:-⊓ (S ⇒ S₁) (T ⇒ T₁) {c} with ss⇒tt c
... | c1 , c2 = <:-⇒ (<:-⊔ S T) (<:-⊓ S₁ T₁)
<:-⊓ (S ⋆ S₁) (T ⋆ T₁) {c} with ss⋆tt c
... | c1 , c2 = <:-⋆ (<:-⊓ S T) (<:-⊓ S₁ T₁)
<:-⊓ (S ⊹ S₁) (T ⊹ T₁) {c} with ss⊹tt c
... | c1 , c2 = <:-⊹ (<:-⊓ S T) (<:-⊓ S₁ T₁)
-- should be in terms of RawType for evaluation
data _⊢_⦂_ : Env Type → Expr → Type → Set₁ where
nat' :
Γ ⊢ Nat n ⦂ Base (_≡_ n)
var :
(x∈ : x ⦂ T ∈ Γ) →
--------------------
Γ ⊢ Var x ⦂ T
lam :
(Γ , x ⦂ S) ⊢ M ⦂ T →
--------------------
Γ ⊢ Lam x M ⦂ (S ⇒ T)
app :
Γ ⊢ M ⦂ (S ⇒ T) →
Γ ⊢ N ⦂ S →
--------------------
Γ ⊢ App M N ⦂ T
pair :
Γ ⊢ M ⦂ S →
Γ ⊢ N ⦂ T →
--------------------
Γ ⊢ Pair M N ⦂ (S ⋆ T)
pair-E1 :
Γ ⊢ M ⦂ (S ⋆ T) →
--------------------
Γ ⊢ Fst M ⦂ S
pair-E2 :
Γ ⊢ M ⦂ (S ⋆ T) →
--------------------
Γ ⊢ Snd M ⦂ T
sum-I1 :
Γ ⊢ M ⦂ S →
--------------------
Γ ⊢ Inl M ⦂ (S ⊹ T)
sum-I2 :
Γ ⊢ N ⦂ T →
--------------------
Γ ⊢ Inl N ⦂ (S ⊹ T)
sum-E :
Γ ⊢ L ⦂ (S ⊹ T) →
(Γ , x ⦂ S) ⊢ M ⦂ U →
(Γ , y ⦂ T) ⊢ N ⦂ U →
--------------------
Γ ⊢ Case L x M y N ⦂ U
split-sym : Split Γ Γ₁ Γ₂ → Split Γ Γ₂ Γ₁
split-sym nil = nil
split-sym (lft sp) = rgt (split-sym sp)
split-sym (rgt sp) = lft (split-sym sp)
weaken-∈ : Split Γ Γ₁ Γ₂ → x ⦂ T ∈ Γ₁ → x ⦂ T ∈ Γ
weaken-∈ (lft sp) found = found
weaken-∈ (rgt sp) found = there (weaken-∈ sp found)
weaken-∈ (lft sp) (there x∈) = there (weaken-∈ sp x∈)
weaken-∈ (rgt sp) (there x∈) = there (weaken-∈ sp (there x∈))
weaken : Split Γ Γ₁ Γ₂ → Γ₁ ⊢ M ⦂ T → Γ ⊢ M ⦂ T
weaken sp (nat') = nat'
weaken sp (var x∈) = var (weaken-∈ sp x∈)
weaken sp (lam ⊢M) = lam (weaken (lft sp) ⊢M)
weaken sp (app ⊢M ⊢N) = app (weaken sp ⊢M) (weaken sp ⊢N)
weaken sp (pair ⊢M ⊢N) = pair (weaken sp ⊢M) (weaken sp ⊢N)
weaken sp (pair-E1 ⊢M) = pair-E1 (weaken sp ⊢M)
weaken sp (pair-E2 ⊢M) = pair-E2 (weaken sp ⊢M)
weaken sp (sum-I1 ⊢M) = sum-I1 (weaken sp ⊢M)
weaken sp (sum-I2 ⊢N) = sum-I2 (weaken sp ⊢N)
weaken sp (sum-E ⊢L ⊢M ⊢N) = sum-E (weaken sp ⊢L) (weaken (lft sp) ⊢M) (weaken (lft sp) ⊢N)
-- incorrectness typing
P=n : ℕ → ℕ → Set
P=n = λ n x → n ≡ x
data _⊢_÷_ : Env Type → Expr → Type → Set₁ where
nat' :
--------------------
· ⊢ Nat n ÷ Base (_≡_ n)
var1 :
( · , x ⦂ T) ⊢ Var x ÷ T
{-
var :
x ⦂ T ∈ Γ →
--------------------
Γ ⊢ Var x ÷ T
-}
lam :
(· , x ⦂ S) ⊢ M ÷ T →
--------------------
· ⊢ Lam x M ÷ (S ⇒ T)
pair :
Split Γ Γ₁ Γ₂ →
Γ₁ ⊢ M ÷ S →
Γ₂ ⊢ N ÷ T →
--------------------
Γ ⊢ Pair M N ÷ (S ⋆ T)
pair-E1 :
Γ ⊢ M ÷ (S ⋆ T) →
--------------------
Γ ⊢ Fst M ÷ S
pair-E2 :
Γ ⊢ M ÷ (S ⋆ T) →
--------------------
Γ ⊢ Snd M ÷ T
sum-E :
Split Γ Γ₁ Γ₂ →
Γ₁ ⊢ L ÷ (S ⊹ T) →
(Γ₂ , x ⦂ S) ⊢ M ÷ U →
(Γ₂ , y ⦂ T) ⊢ N ÷ U →
--------------------
Γ ⊢ Case L x M y N ÷ U
sum-E′ : ∀ {ru′=ru″} →
Split Γ Γ₁ Γ₂ →
Γ₁ ⊢ L ÷ (S ⊹ T) →
(Γ₂ , x ⦂ S) ⊢ M ÷ U′ →
(Γ₂ , y ⦂ T) ⊢ N ÷ U″ →
U ≡ (U′ ⊔ U″){ru′=ru″} →
--------------------
Γ ⊢ Case L x M y N ÷ U
{-
`sub` :
Γ ⊢ M ÷ S →
T <: S →
--------------------
Γ ⊢ M ÷ T
-}
record _←_ (A B : Set) : Set where
field
func : A → B
back : ∀ (b : B) → ∃ λ (a : A) → func a ≡ b
open _←_
T⟦_⟧ : Type → Set
T⟦ Base P ⟧ = Σ ℕ P
T⟦ Nat ⟧ = ℕ
T⟦ S ⇒ T ⟧ = T⟦ S ⟧ → T⟦ T ⟧
T⟦ S ⋆ T ⟧ = T⟦ S ⟧ × T⟦ T ⟧
T⟦ S ⊹ T ⟧ = T⟦ S ⟧ ⊎ T⟦ T ⟧
T'⟦_⟧ : Type → Set
T'⟦ Base P ⟧ = Σ ℕ P
T'⟦ Nat ⟧ = ℕ
T'⟦ S ⇒ T ⟧ = T'⟦ S ⟧ ← T'⟦ T ⟧
T'⟦ S ⋆ T ⟧ = T'⟦ S ⟧ × T'⟦ T ⟧
T'⟦ S ⊹ T ⟧ = T'⟦ S ⟧ ⊎ T'⟦ T ⟧
E⟦_⟧ : Env Type → Env Set
E⟦ · ⟧ = ·
E⟦ Γ , x ⦂ T ⟧ = E⟦ Γ ⟧ , x ⦂ T⟦ T ⟧
data iEnv : Env Set → Set where
· : iEnv ·
_,_⦂_ : ∀ {E}{A} → iEnv E → (x : Id) → (a : A) → iEnv (E , x ⦂ A)
lookup : (x ⦂ T ∈ Γ) → iEnv E⟦ Γ ⟧ → T⟦ T ⟧
lookup found (γ , _ ⦂ a) = a
lookup (there x∈) (γ , _ ⦂ a) = lookup x∈ γ
eval : Γ ⊢ M ⦂ T → iEnv E⟦ Γ ⟧ → T⟦ T ⟧
eval (nat'{n = n}) γ = n , refl
eval (var x∈) γ = lookup x∈ γ
eval (lam ⊢M) γ = λ s → eval ⊢M (γ , _ ⦂ s)
eval (app ⊢M ⊢N) γ = eval ⊢M γ (eval ⊢N γ)
eval (pair ⊢M ⊢N) γ = (eval ⊢M γ) , (eval ⊢N γ)
eval (pair-E1 ⊢M) γ = proj₁ (eval ⊢M γ)
eval (pair-E2 ⊢M) γ = proj₂ (eval ⊢M γ)
eval (sum-I1 ⊢M) γ = inj₁ (eval ⊢M γ)
eval (sum-I2 ⊢N) γ = inj₂ (eval ⊢N γ)
eval (sum-E{S = S}{T = T}{U = U} ⊢L ⊢M ⊢N) γ =
[ (λ s → eval ⊢M (γ , _ ⦂ s)) , (λ t → eval ⊢N (γ , _ ⦂ t)) ] (eval ⊢L γ)
corr : Γ ⊢ M ÷ T → Γ ⊢ M ⦂ T
corr (nat') = nat'
corr var1 = var found
-- corr (var x) = var x
corr (lam ⊢M) = lam (corr ⊢M)
corr (pair-E1 ÷M) = pair-E1 (corr ÷M)
corr (pair-E2 ÷M) = pair-E2 (corr ÷M)
corr (pair sp ÷M ÷N) = pair (weaken sp (corr ÷M)) (weaken (split-sym sp) (corr ÷N))
corr (sum-E sp ÷L ÷M ÷N) = sum-E (weaken sp (corr ÷L)) (weaken (lft (split-sym sp)) (corr ÷M)) (weaken (lft (split-sym sp)) (corr ÷N))
corr (sum-E′ sp ÷L ÷M ÷N U≡U′⊔U″) =
sum-E (weaken sp (corr ÷L)) (weaken (lft (split-sym sp)) (corr {!!})) (weaken (lft (split-sym sp)) (corr {!!}))
{-
corr (`sub` ÷M T<S) = {!÷M!}
-}
-- pick one element of a type to demonstrate non-emptiness
one : ∀ (T : Type) {net : ne T} → T⟦ T ⟧
one (Base P) {ne-base ∃P} = ∃P
one Nat = zero
one (T ⇒ T₁) {ne-⇒ ne-T ne-T₁} = λ x → one T₁ {ne-T₁}
one (T ⋆ T₁) {ne-⋆ ne-T ne-T₁} = (one T {ne-T}) , (one T₁ {ne-T₁})
one (T ⊹ T₁) {ne-⊹L ne-T} = inj₁ (one T {ne-T})
one (T ⊹ T₁) {ne-⊹R ne-T₁} = inj₂ (one T₁ {ne-T₁})
{- not needed
many : iEnv E⟦ Γ ⟧
many {·} = ·
many {Γ , x ⦂ T} = many , x ⦂ one T
gen : (x∈ : x ⦂ T ∈ Γ) (t : T⟦ T ⟧) → iEnv E⟦ Γ ⟧
gen found t = many , _ ⦂ t
gen (there x∈) t = (gen x∈ t) , _ ⦂ one {!!}
lookup-gen : (x∈ : x ⦂ T ∈ Γ) (t : T⟦ T ⟧) → lookup x∈ (gen x∈ t) ≡ t
lookup-gen found t = refl
lookup-gen (there x∈) t = lookup-gen x∈ t
-}
open Eq.≡-Reasoning
postulate
ext : ∀ {A B : Set}{f g : A → B} → (∀ x → f x ≡ g x) → f ≡ g
unsplit-env : Split Γ Γ₁ Γ₂ → iEnv E⟦ Γ₁ ⟧ → iEnv E⟦ Γ₂ ⟧ → iEnv E⟦ Γ ⟧
unsplit-env nil γ₁ γ₂ = ·
unsplit-env (lft sp) (γ₁ , _ ⦂ a) γ₂ = (unsplit-env sp γ₁ γ₂) , _ ⦂ a
unsplit-env (rgt sp) γ₁ (γ₂ , _ ⦂ a) = (unsplit-env sp γ₁ γ₂) , _ ⦂ a
unsplit-split : (sp : Split Γ Γ₁ Γ₂) (γ₁ : iEnv E⟦ Γ₁ ⟧) (γ₂ : iEnv E⟦ Γ₂ ⟧) →
unsplit-env sp γ₁ γ₂ ≡ unsplit-env (split-sym sp) γ₂ γ₁
unsplit-split nil γ₁ γ₂ = refl
unsplit-split (lft sp) (γ₁ , _ ⦂ a) γ₂ rewrite unsplit-split sp γ₁ γ₂ = refl
unsplit-split (rgt sp) γ₁ (γ₂ , _ ⦂ a) rewrite unsplit-split sp γ₁ γ₂ = refl
lookup-unsplit : (sp : Split Γ Γ₁ Γ₂) (γ₁ : iEnv E⟦ Γ₁ ⟧) (γ₂ : iEnv E⟦ Γ₂ ⟧) →
(x∈ : x ⦂ T ∈ Γ₁) →
lookup (weaken-∈ sp x∈) (unsplit-env sp γ₁ γ₂) ≡ lookup x∈ γ₁
lookup-unsplit (lft sp) (γ₁ , _ ⦂ a) γ₂ found = refl
lookup-unsplit (rgt sp) γ₁ (γ₂ , _ ⦂ a) found = lookup-unsplit sp γ₁ γ₂ found
lookup-unsplit (lft sp) (γ₁ , _ ⦂ a) γ₂ (there x∈) = lookup-unsplit sp γ₁ γ₂ x∈
lookup-unsplit (rgt sp) γ₁ (γ₂ , _ ⦂ a) (there x∈) = lookup-unsplit sp γ₁ γ₂ (there x∈)
eval-unsplit : (sp : Split Γ Γ₁ Γ₂) (γ₁ : iEnv E⟦ Γ₁ ⟧) (γ₂ : iEnv E⟦ Γ₂ ⟧) →
(⊢M : Γ₁ ⊢ M ⦂ T) →
eval (weaken sp ⊢M) (unsplit-env sp γ₁ γ₂) ≡ eval ⊢M γ₁
eval-unsplit sp γ₁ γ₂ (nat')= refl
eval-unsplit sp γ₁ γ₂ (var x∈) = lookup-unsplit sp γ₁ γ₂ x∈
eval-unsplit sp γ₁ γ₂ (lam ⊢M) = ext (λ s → eval-unsplit (lft sp) (γ₁ , _ ⦂ s) γ₂ ⊢M)
eval-unsplit sp γ₁ γ₂ (app ⊢M ⊢M₁)
rewrite eval-unsplit sp γ₁ γ₂ ⊢M | eval-unsplit sp γ₁ γ₂ ⊢M₁ = refl
eval-unsplit sp γ₁ γ₂ (pair ⊢M ⊢M₁)
rewrite eval-unsplit sp γ₁ γ₂ ⊢M | eval-unsplit sp γ₁ γ₂ ⊢M₁ = refl
eval-unsplit sp γ₁ γ₂ (pair-E1 ⊢M)
rewrite eval-unsplit sp γ₁ γ₂ ⊢M = refl
eval-unsplit sp γ₁ γ₂ (pair-E2 ⊢M)
rewrite eval-unsplit sp γ₁ γ₂ ⊢M = refl
eval-unsplit sp γ₁ γ₂ (sum-I1 ⊢M)
rewrite eval-unsplit sp γ₁ γ₂ ⊢M = refl
eval-unsplit sp γ₁ γ₂ (sum-I2 ⊢N)
rewrite eval-unsplit sp γ₁ γ₂ ⊢N = refl
eval-unsplit sp γ₁ γ₂ (sum-E ⊢L ⊢M ⊢N)
rewrite eval-unsplit sp γ₁ γ₂ ⊢L
| ext (λ s → eval-unsplit (lft sp) (γ₁ , _ ⦂ s) γ₂ ⊢M)
| ext (λ t → eval-unsplit (lft sp) (γ₁ , _ ⦂ t) γ₂ ⊢N)
= refl
-- soundness of the incorrectness rules
lave :
(÷M : Γ ⊢ M ÷ T) →
∀ (t : T⟦ T ⟧) →
∃ λ (γ : iEnv E⟦ Γ ⟧) →
eval (corr ÷M) γ ≡ t
lave nat' (n , refl) = · , refl
lave var1 t = (· , _ ⦂ t) , refl
-- lave (var x∈) t = (gen x∈ t) , lookup-gen x∈ t
lave (lam{x = x}{S = S} ÷M) t = · , ext aux
where
aux : (s : T⟦ S ⟧) → eval (corr ÷M) (· , x ⦂ s) ≡ t s
aux s with lave ÷M (t s)
... | (· , .x ⦂ a) , snd = {!!} -- impossible to complete!
lave (pair-E1 ÷M) t with lave ÷M (t , one {!!})
... | γ , ih = γ , Eq.cong proj₁ ih
lave (pair-E2 ÷M) t with lave ÷M (one {!!} , t)
... | γ , ih = γ , Eq.cong proj₂ ih
lave (pair sp ÷M ÷N) (s , t) with lave ÷M s | lave ÷N t
... | γ₁ , ih-M | γ₂ , ih-N =
unsplit-env sp γ₁ γ₂ ,
Eq.cong₂ _,_ (Eq.trans (eval-unsplit sp γ₁ γ₂ (corr ÷M)) ih-M)
(begin eval (weaken (split-sym sp) (corr ÷N)) (unsplit-env sp γ₁ γ₂)
≡⟨ Eq.cong (eval (weaken (split-sym sp) (corr ÷N))) (unsplit-split sp γ₁ γ₂) ⟩
eval (weaken (split-sym sp) (corr ÷N)) (unsplit-env (split-sym sp) γ₂ γ₁)
≡⟨ eval-unsplit (split-sym sp) γ₂ γ₁ (corr ÷N) ⟩
ih-N)
-- works, but unsatisfactory!
-- this proof uses only one branch of the case
-- this choice is possible because both branches ÷M and ÷N have the same type
-- in general, U could be the union of the types of ÷M and ÷N
lave (sum-E{S = S}{T = T}{U = U} sp ÷L ÷M ÷N) u
with lave ÷M u | lave ÷N u
... | (γ₁ , x ⦂ s) , ih-M | (γ₂ , y ⦂ t) , ih-N
with lave ÷L (inj₁ s)
... | γ₀ , ih-L
=
unsplit-env sp γ₀ γ₁ ,
(begin [
(λ s₁ →
eval (weaken (lft (split-sym sp)) (corr ÷M))
(unsplit-env sp γ₀ γ₁ , x ⦂ s₁))
,
(λ t₁ →
eval (weaken (lft (split-sym sp)) (corr ÷N))
(unsplit-env sp γ₀ γ₁ , y ⦂ t₁))
]
(eval (weaken sp (corr ÷L)) (unsplit-env sp γ₀ γ₁))
≡⟨ Eq.cong [
(λ s₁ →
eval (weaken (lft (split-sym sp)) (corr ÷M))
(unsplit-env sp γ₀ γ₁ , x ⦂ s₁))
,
(λ t₁ →
eval (weaken (lft (split-sym sp)) (corr ÷N))
(unsplit-env sp γ₀ γ₁ , y ⦂ t₁))
] (eval-unsplit sp γ₀ γ₁ (corr ÷L)) ⟩
[
(λ s₁ →
eval (weaken (lft (split-sym sp)) (corr ÷M))
(unsplit-env sp γ₀ γ₁ , x ⦂ s₁))
,
(λ t₁ →
eval (weaken (lft (split-sym sp)) (corr ÷N))
(unsplit-env sp γ₀ γ₁ , y ⦂ t₁))
]
(eval (corr ÷L) γ₀)
≡⟨ Eq.cong
[
(λ s₁ →
eval (weaken (lft (split-sym sp)) (corr ÷M))
(unsplit-env sp γ₀ γ₁ , x ⦂ s₁))
,
(λ t₁ →
eval (weaken (lft (split-sym sp)) (corr ÷N))
(unsplit-env sp γ₀ γ₁ , y ⦂ t₁))
]
ih-L ⟩
eval (weaken (lft (split-sym sp)) (corr ÷M)) (unsplit-env sp γ₀ γ₁ , x ⦂ s)
≡⟨ Eq.cong (λ γ → eval (weaken (lft (split-sym sp)) (corr ÷M)) (γ , x ⦂ s)) (unsplit-split sp γ₀ γ₁) ⟩
eval (weaken (lft (split-sym sp)) (corr ÷M)) (unsplit-env (split-sym sp) γ₁ γ₀ , x ⦂ s)
≡⟨⟩
eval (weaken (lft (split-sym sp)) (corr ÷M)) (unsplit-env (lft (split-sym sp)) (γ₁ , x ⦂ s) γ₀)
≡⟨ eval-unsplit (lft (split-sym sp)) (γ₁ , x ⦂ s) γ₀ (corr ÷M) ⟩
ih-M)
lave (sum-E′{S = S}{T = T}{U = U} sp ÷L ÷M ÷N uuu) u = {!!}
|
"""
Kalman filters, log-likelihood and reasonable priors for a "Celerite"
process, as defined in [Foreman-Mackey, et
al. (2017)[https://arxiv.org/abs/1703.09710].
A Celerite process is a sum of AR(1) and CARMA(2,0) processes; an
alternative description is as a sum of damped random walks and SHOs
driven by white noise. It is, in fact, a re-parameterization of a
CARMA process, but a convenient one for stably finding mode
frequencies and damping rates and correlation timescales because it is
a sum of low-order terms.
"""
module Celerite
using Ensemble
mutable struct CeleriteKalmanFilter
mu::Float64 # Mean
x::Array{ComplexF64, 1} # State mean
Vx::Array{ComplexF64, 2} # State variance
K::Array{ComplexF64, 1} # Kalman Gain
lambda::Array{ComplexF64, 1} # Evolution factors exp(roots*dt)
b::Array{ComplexF64, 2} # Rotated observation vector
roots::Array{ComplexF64, 1} # Eigenvalues of the ODEs
V::Array{ComplexF64, 2} # Stationary covariance
Vtemp::Array{ComplexF64, 2} # Storage for matrix ops
drw_rms::Array{Float64, 1}
drw_rates::Array{Float64, 1}
osc_rms::Array{Float64, 1}
osc_freqs::Array{Float64, 1}
osc_Qs::Array{Float64, 1}
end
function reset!(filt::CeleriteKalmanFilter)
p = size(filt.x, 1)
filt.x = zeros(ComplexF64, p)
filt.Vx = copy(filt.V)
filt.K = zeros(ComplexF64, p)
filt
end
function osc_roots(osc_freqs::Array{Float64, 1}, osc_Qs::Array{Float64, 1})
nosc = size(osc_freqs, 1)
oscroots = zeros(ComplexF64, nosc)
for i in 1:nosc
omega0 = 2.0*pi*osc_freqs[i]
alpha = omega0/(2.0*osc_Qs[i])
oscroots[i] = -alpha + omega0*1im
end
oscroots
end
function CeleriteKalmanFilter(mu::Float64, drw_rms::Array{Float64, 1}, drw_rates::Array{Float64, 1}, osc_rms::Array{Float64, 1}, osc_freqs::Array{Float64, 1}, osc_Qs::Array{Float64, 1})
ndrw = size(drw_rms,1)
nosc = size(osc_rms,1)
dim = ndrw + 2*nosc
oscroots = osc_roots(osc_freqs, osc_Qs)
roots = zeros(ComplexF64, dim)
ii = 1
for i in 1:ndrw
roots[ii] = -drw_rates[i]
ii+=1
end
for i in 1:nosc
roots[ii] = oscroots[i]
roots[ii+1] = conj(oscroots[i])
ii += 2
end
b = zeros(ComplexF64, dim)
iobs = 1
for i in 1:ndrw
b[iobs] = 1.0
iobs += 1
end
for i in 1:nosc
b[iobs] = 1.0
iobs += 2 # skip the derivative term
end
b = b'
U = zeros(ComplexF64, (dim,dim))
ii = 1
for i in 1:ndrw
U[ii,ii] = 1.0
ii += 1
end
for i in 1:nosc
U[ii,ii] = 1.0
U[ii, ii+1] = 1.0
U[ii+1,ii] = oscroots[i]
U[ii+1,ii+1] = conj(oscroots[i])
ii += 2
end
b = b*U # Rotated observation vector
e = zeros(ComplexF64, dim)
ii = 1
for i in 1:ndrw
e[ii] = 1.0
ii += 1
end
for i in 1:nosc
e[ii+1] = 1.0
ii += 2
end
J = U \ e
V = zeros(ComplexF64, (dim,dim))
ii = 1
for i in 1:ndrw
V[ii,ii] = -J[ii]*conj(J[ii])/(roots[ii] + conj(roots[ii]))
ii += 1
end
for i in 1:nosc
for j in 0:1
for k in 0:1
V[ii+j, ii+k] = -J[ii+j]*conj(J[ii+k])/(roots[ii+j] + conj(roots[ii+k]))
end
end
ii += 2
end
ii = 1
for i in 1:ndrw
s2 = b[1,ii]*V[ii,ii]*conj(b[1,ii])
s2 = s2[1]
V[ii,ii] *= drw_rms[i]*drw_rms[i]/s2
ii += 1
end
for i in 1:nosc
s2 = b[:,ii:ii+1]*V[ii:ii+1,ii:ii+1]*b[:,ii:ii+1]'
s2 = s2[1]
V[ii:ii+1, ii:ii+1] *= osc_rms[i]*osc_rms[i]/s2
ii += 2
end
CeleriteKalmanFilter(mu, zeros(ComplexF64, dim), V, zeros(ComplexF64, dim), zeros(ComplexF64, dim), b, roots, copy(V), zeros(ComplexF64, (dim,dim)), drw_rms, drw_rates, osc_rms, osc_freqs, osc_Qs)
end
@inbounds function advance!(filt::CeleriteKalmanFilter, dt::Float64)
p = size(filt.x, 1)
for i in 1:p
x = filt.roots[i]*dt
filt.lambda[i] = exp(x)
end
lam = filt.lambda
for i in 1:p
filt.x[i] = lam[i]*filt.x[i]
end
for j in 1:p
for i in 1:p
a::ComplexF64 = lam[i]*conj(lam[j])
b::ComplexF64 = a*(filt.Vx[i,j] - filt.V[i,j])
filt.Vx[i,j] = b + filt.V[i,j]
end
end
filt
end
@inbounds function observe!(filt::CeleriteKalmanFilter, y::Float64, dy::Float64)
p = size(filt.x, 1)
ey, vy = predict(filt)
vy += dy*dy
for i in 1:p
filt.K[i] = zero(filt.K[i])
for j in 1:p
filt.K[i] += filt.Vx[i,j]*conj(filt.b[1,j])/vy
end
end
for i in 1:p
filt.x[i] = filt.x[i] + (y - ey)*filt.K[i]
end
for j in 1:p
for i in 1:p
a::ComplexF64 = vy*filt.K[i]
b::ComplexF64 = a*conj(filt.K[j])
filt.Vx[i,j] = filt.Vx[i,j] - b
end
end
filt
end
@inbounds function predict(filt::CeleriteKalmanFilter)
p = size(filt.x,1)
yp = filt.mu
for i in 1:p
yp += real(filt.b[1,i]*filt.x[i])
end
vyp = 0.0
for i in 1:p
for j in 1:p
a::ComplexF64 = filt.b[1,i]*filt.Vx[i,j]
b::ComplexF64 = a*conj(filt.b[1,j])
vyp = vyp + real(b)
end
end
yp, vyp
end
function whiten(filt::CeleriteKalmanFilter, ts, ys, dys)
n = size(ts, 1)
reset!(filt)
zs = zeros(n)
for i in 1:n
yp, vyp = predict(filt)
zs[i] = (ys[i] - yp)/sqrt(vyp + dys[i]*dys[i])
observe!(filt, ys[i], dys[i])
if i < n
advance!(filt, ts[i+1]-ts[i])
end
end
zs
end
function draw_and_collapse!(filt::CeleriteKalmanFilter)
nd = size(filt.x, 1)
try
for i in 1:nd
filt.Vx[i,i] = real(filt.Vx[i,i]) # Fix a roundoff error problem?
end
L = ctranspose(chol(Hermitian(filt.Vx)))
filt.x = filt.x + L*randn(nd)
filt.Vx = zeros(ComplexF64, (nd, nd))
catch e
if isa(e, Base.LinearAlgebra.PosDefException)
warn("Current variance matrix not pos. def.---may be roundoff problem in generation.")
F = eigfact(filt.Vx)
for i in eachindex(F[:values])
l = real(F[:values][i])
v = F[:vectors][:,i]
if l < 0.0
l = 0.0
end
filt.x = filt.x + sqrt(l)*randn()*v
end
filt.Vx = zeros(ComplexF64, (nd, nd))
else
rethrow()
end
end
end
function generate(filt::CeleriteKalmanFilter, ts, dys)
n = size(ts, 1)
nd = size(filt.x, 1)
ys = zeros(n)
reset!(filt)
for i in 1:n
# Draw a new state
draw_and_collapse!(filt)
y, _ = predict(filt)
ys[i] = y + dys[i]*randn()
if i < n
advance!(filt, ts[i+1]-ts[i])
end
end
ys
end
function log_likelihood(filt, ts, ys, dys)
n = size(ts, 1)
ll = -0.5*n*log(2.0*pi)
reset!(filt)
for i in 1:n
yp, vyp = predict(filt)
if vyp < 0.0
warn("Kalman filter has gone unstable!")
return -Inf
end
dy = ys[i] - yp
vy = vyp + dys[i]*dys[i]
ll -= 0.5*log(vy)
ll -= 0.5*dy*dy/vy
observe!(filt, ys[i], dys[i])
if i < n
advance!(filt, ts[i+1]-ts[i])
end
end
ll
end
function residuals(filt, ts, ys, dys)
n = size(ts, 1)
resid = zeros(n)
dresid = zeros(n)
reset!(filt)
for i in 1:n
yp, vyp = predict(filt)
if vyp < 0.0
warn("Kalman filter has gone unstable!")
return resid, dresid
end
resid[i] = ys[i] - yp
dresid[i] = sqrt(vyp + dys[i]*dys[i])
observe!(filt, ys[i], dys[i])
if i < n
advance!(filt, ts[i+1]-ts[i])
end
end
resid, dresid
end
function raw_covariance(ts::Array{Float64, 1}, dys::Array{Float64, 1}, drw_rms::Array{Float64, 1}, drw_rates::Array{Float64, 1}, osc_rms::Array{Float64, 1}, osc_freqs::Array{Float64, 1}, osc_Qs::Array{Float64,1})
N = size(ts, 1)
ndrw = size(drw_rms,1)
nosc = size(osc_rms,1)
cov = zeros((N,N))
dts = zeros((N,N))
oscroots = osc_roots(osc_freqs, osc_Qs)
for j in 1:N
for i in 1:N
dts[i,j] = abs(ts[i] - ts[j])
end
end
for i in 1:ndrw
cov += drw_rms[i]*drw_rms[i]*exp.(-drw_rates[i].*dts)
end
for i in 1:nosc
A = 1.0 / (-4.0*real(oscroots[i])*(conj(oscroots[i]) - oscroots[i])*oscroots[i])
B = 1.0 / (-4.0*real(oscroots[i])*(oscroots[i] - conj(oscroots[i]))*conj(oscroots[i]))
s2 = osc_rms[i]*osc_rms[i] / (A+B)
cov = cov .+ real.(s2.*(A.*exp.(oscroots[i].*dts) .+ B.*exp.(conj(oscroots[i]).*dts)))
end
for i in 1:N
cov[i,i] += dys[i]*dys[i]
end
cov
end
function psd_drw(rms_amp, damp_rate, fs)
4.0*damp_rate*rms_amp*rms_amp./abs2.(2.0*pi*1im.*fs .+ damp_rate)
end
function psd_osc(rms_amp, freq, Q, fs)
r1 = osc_roots([freq], [Q])[1]
r2 = conj(r1)
norm = 1.0/real(2.0*r1*(r1-r2)*(r1+r2))
rms_amp*rms_amp/norm./abs2.((2.0*pi*1im.*fs .- r1).*(2.0*pi*1im.*fs .- r2))
end
function psd(filt::CeleriteKalmanFilter, fs::Array{Float64, 1})
Pfs = zeros(size(fs,1))
for i in 1:size(filt.drw_rms,1)
Pfs .= Pfs .+ psd_drw(filt.drw_rms[i], filt.drw_rates[i], fs)
end
for i in 1:size(filt.osc_rms,1)
Pfs .= Pfs .+ psd_osc(filt.osc_rms[i], filt.osc_freqs[i], filt.osc_Qs[i], fs)
end
Pfs
end
function predict(filt::CeleriteKalmanFilter, ts, ys, dys, tsp)
# The algorithm here is to run the filter twice over the union of
# the data and prediction times. The first run is "forward" in
# time, and predicts at each time *before* observing the output at
# data times, and the second run is "backward" in time, and
# predicts at each time *after* observing the output at data
# times. Weighted-averaging of the two runs together gives the
# full internal state prediction incorporating all the data at the
# given times.
allts = vcat(ts, tsp)
obsflag = convert(Array{Bool, 1}, vcat(trues(size(ts, 1)), falses(size(tsp, 1))))
inds = sortperm(allts)
rinds = reverse(inds)
yspforward = zeros(size(allts, 1))
vyspforward = zeros(size(allts, 1))
reset!(filt)
for i in eachindex(allts)
yspforward[inds[i]], vyspforward[inds[i]] = predict(filt)
if obsflag[inds[i]]
observe!(filt, ys[inds[i]], dys[inds[i]])
end
if i < size(allts, 1)
advance!(filt, allts[inds[i+1]]-allts[inds[i]])
end
end
yspbackward = zeros(size(allts, 1))
vyspbackward = zeros(size(allts, 1))
reset!(filt)
for i in eachindex(allts)
if obsflag[rinds[i]]
observe!(filt, ys[rinds[i]], dys[rinds[i]])
end
yspbackward[rinds[i]], vyspbackward[rinds[i]] = predict(filt)
if i < size(allts, 1)
advance!(filt, allts[rinds[i]] - allts[rinds[i+1]])
end
end
ysp = (yspforward.*vyspbackward .+ yspbackward.*vyspforward) ./ (vyspbackward .+ vyspforward)
vysp = 1.0./(1.0./vyspforward .+ 1.0./vyspbackward)
ysp[size(ts,1)+1:end], vysp[size(ts, 1)+1:end]
end
struct CeleriteKalmanPosterior
ts::Array{Float64, 1}
ys::Array{Float64, 1}
dys::Array{Float64, 1}
ndrw::Int
nosc::Int
mumin::Float64
mumax::Float64
fmin::Float64
fmax::Float64
ratemin::Float64
ratemax::Float64
Qmin::Float64
Qmax::Float64
drw_rms_min::Float64
drw_rms_max::Float64
osc_rms_min::Float64
osc_rms_max::Float64
end
struct CeleriteKalmanParams
mu::Float64
nu::Float64
drw_rms::Array{Float64, 1}
drw_rates::Array{Float64, 1}
osc_rms::Array{Float64, 1}
osc_freqs::Array{Float64, 1}
osc_Qs::Array{Float64, 1}
end
function ndim(post::CeleriteKalmanPosterior)
2 + 2*post.ndrw + 3*post.nosc
end
function to_params(post::CeleriteKalmanPosterior, x::Array{Float64, 1})
nd = post.ndrw
no = post.nosc
mu = Parameterizations.bounded_value(x[1], post.mumin, post.mumax)
nu = Parameterizations.bounded_value(x[2], 0.1, 10.0)
drw_rms = Parameterizations.bounded_value.(x[3:3+nd-1], post.drw_rms_min, post.drw_rms_max)
drw_rates = Parameterizations.bounded_value.(x[3+nd:3+2*nd-1], post.ratemin, post.ratemax)
osc_rms = Parameterizations.bounded_value.(x[3+2*nd:3+2*nd+no-1], post.osc_rms_min, post.osc_rms_max)
osc_freqs = Parameterizations.bounded_value.(x[3+2*nd+no:3+2*nd+2*no-1], post.fmin, post.fmax)
osc_Qs = Parameterizations.bounded_value.(x[3+2*nd+2*no:3+2*nd+3*no-1], post.Qmin, post.Qmax)
CeleriteKalmanParams(mu, nu, drw_rms, drw_rates, osc_rms, osc_freqs, osc_Qs)
end
function to_array(post::CeleriteKalmanPosterior, p::CeleriteKalmanParams)
x = zeros(ndim(post))
nd = post.ndrw
no = post.nosc
x[1] = Parameterizations.bounded_param(p.mu, post.mumin, post.mumax)
x[2] = Parameterizations.bounded_param(p.nu, 0.1, 10)
x[3:3+nd-1] = Parameterizations.bounded_param.(p.drw_rms, post.drw_rms_min, post.drw_rms_max)
x[3+nd:3+2*nd-1] = Parameterizations.bounded_param.(p.drw_rates, post.ratemin, post.ratemax)
x[3+2*nd:3+2*nd+no-1] = Parameterizations.bounded_param.(p.osc_rms, post.osc_rms_min, post.osc_rms_max)
x[3+2*nd+no:3+2*nd+2*no-1] = Parameterizations.bounded_param.(p.osc_freqs, post.fmin, post.fmax)
x[3+2*nd+2*no:3+2*nd+3*no-1] = Parameterizations.bounded_param.(p.osc_Qs, post.Qmin, post.Qmax)
x
end
function log_prior(post::CeleriteKalmanPosterior, x::Array{Float64, 1})
log_prior(post, to_params(post, x), x)
end
function log_prior(post::CeleriteKalmanPosterior, p::CeleriteKalmanParams)
log_prior(post, p, to_array(post, p))
end
function log_prior(post::CeleriteKalmanPosterior, p::CeleriteKalmanParams, x::Array{Float64, 1})
nd = post.ndrw
no = post.nosc
lp = 0.0
# Flat prior on mu
lp += Parameterizations.bounded_logjac(p.mu, x[1], post.mumin, post.mumax)
# Flat-in-log prior on nu
lp += -log(p.nu) + Parameterizations.bounded_logjac(p.nu, x[2], 0.1, 10.0)
# Flat in log prior on rms
lp += -sum(log.(p.drw_rms)) + sum(Parameterizations.bounded_logjac(p.drw_rms, x[3:3+nd-1], post.drw_rms_min, post.drw_rms_max))
# Flat in log prior on rates
lp += -sum(log.(p.drw_rates)) + sum(Parameterizations.bounded_logjac(p.drw_rates, x[3+nd:3+2*nd-1], post.ratemin, post.ratemax))
# Flat in log prior on osc rms
lp += -sum(log.(p.osc_rms)) + sum(Parameterizations.bounded_logjac(p.osc_rms, x[3+2*nd:3+2*nd+no-1], post.osc_rms_min, post.osc_rms_max))
# Flat in log prior on osc freqs
lp += -sum(log.(p.osc_freqs)) + sum(Parameterizations.bounded_logjac(p.osc_freqs, x[3+2*nd+no:3+2*nd+2*no-1], post.fmin, post.fmax))
# Flat in log prior on Q
lp += -sum(log.(p.osc_Qs)) + sum(Parameterizations.bounded_logjac(p.osc_Qs, x[3+2*nd+2*no:3+2*nd+3*no-1], post.Qmin, post.Qmax))
lp
end
function log_likelihood(post::CeleriteKalmanPosterior, x::Array{Float64, 1})
log_likelihood(post, to_params(post, x))
end
function log_likelihood(post::CeleriteKalmanPosterior, p::CeleriteKalmanParams)
filt = CeleriteKalmanFilter(p.mu, p.drw_rms, p.drw_rates, p.osc_rms, p.osc_freqs, p.osc_Qs)
log_likelihood(filt, post.ts, post.ys, p.nu*post.dys)
end
function init(post::CeleriteKalmanPosterior, n::Int)
nd = post.ndrw
no = post.nosc
xs = zeros(ndim(post), n)
for i in 1:n
mu = post.mumin + (post.mumax-post.mumin)*rand()
nu = exp(log(0.1) + (log(10.0) - log(0.1))*rand())
drw_rms = exp.(log(post.drw_rms_min) + log(post.drw_rms_max/post.drw_rms_min)*rand(nd))
drw_rates = exp.(log(post.ratemin) + log(post.ratemax/post.ratemin)*rand(nd))
osc_rms = exp.(log(post.osc_rms_min) + log(post.rms_osc_max/post.osc_rms_min)*rand(no))
osc_freqs = exp.(log(post.fmin) + log(post.fmax/post.fmin)*rand(no))
osc_Qs = exp.(log(post.Qmin) + log(post.Qmax/post.Qmin)*rand(no))
p = CeleriteKalmanParams(mu, nu, drw_rms, drw_rates, osc_rms, osc_freqs, osc_Qs)
xs[:,i] = to_array(post, p)
end
xs
end
end
|
Originally conceived as a domestic hi @-@ fi speaker , the NS @-@ 10 was designed by Akira Nakamura and launched in 1978 . It was sold at the $ 400 price point . The speaker was poorly received and its commercial life was short . However , it took five years for its popularity to be established with professional users . As recording engineers came to rely on the NS @-@ 10 as a benchmark , it dominated the mixing of pop and rock music throughout the world for at least 20 years .
|
module Monoid
%access public export
||| The proof that some element is identity in the type
total
IsIdentity : (mon : Type) -> ((*) : mon -> mon -> mon) -> (e : mon) -> Type
IsIdentity mon (*) e = (a : mon) -> ((a*e) = a, (e*a) = a)
||| Given a type and a binary operation the type of proofs that the operation is associative
total
Associative : (typ : Type) -> ((*): typ -> typ -> typ) -> Type
Associative typ (*) = (a : typ) -> (b : typ) -> (c : typ) -> ((a * b) * c) = (a * (b * c))
||| Given a type and a binary operation the type of proofs that the operation is commutative
total
Commutative : (typ : Type) -> ((*) : typ -> typ -> typ) -> Type
Commutative typ (*) = (a : typ) -> (b : typ) -> (a * b) = (b * a)
||| Given a type and a binary operation the type of proofs that identity exists
total
IdentityExists : (typ : Type) -> ((*) : typ -> typ -> typ) -> Type
IdentityExists typ (*) = (e : typ ** (IsIdentity typ (*) e))
--((a : typ) -> ((a*e) = a, (e*a) = a)))
total
IsMonoid : (mon : Type) -> ((*) : mon -> mon -> mon) -> Type
IsMonoid mon (*) = (Associative mon (*), IdentityExists mon (*))
||| Gives the identity of the monoid
total
Monoid_id : (mon : Type) -> ((*) : mon -> mon -> mon) -> (IsMonoid mon (*))
-> (IdentityExists mon (*))
Monoid_id mon (*) (pfAss, pfId) = pfId
|
\documentclass[executivepaper]{article}
\usepackage{mathtools}
\everymath{\displaystyle}
\usepackage{amssymb}
\usepackage{amsfonts}
\usepackage{commath}
\usepackage{kantlipsum,graphicx}
\usepackage{amsmath}
\usepackage[utf8]{inputenc}
\usepackage{sectsty}
\usepackage{tcolorbox}
\usepackage{geometry}
\usepackage{tikz}
\usetikzlibrary{shapes,snakes}
\usepackage{float}
\setlength\parindent{3pt} % Removes all indentation from paragraphs - comment this line for an assignment with lots of text
\newcommand{\horrule}[1]{\rule{\linewidth}{#1}} % Create horizontal rule command with 1 argument of height
\newtheorem{definition}{Definition}
\newtheorem{theorem}{Theorem}
\newtheorem{corollary}{Corollary}[theorem]
\newtheorem{sidenote}{Side Note}
\newcommand{\KP}[1]{%
\begin{tikzpicture}[baseline=-\dimexpr\fontdimen22\textfont2\relax]
#1
\end{tikzpicture}%
}
\newcommand{\KPA}{%
\KP{\filldraw[color=gray, fill=none, thick] circle (0.3);}%
}
\newcommand{\KPB}{%
\KP{
\draw[color=gray,thick] (-0.3,0.3) -- (0.3,-0.3);
\draw[color=gray,thick] (-0.3,-0.3) -- (-0.05,-0.05);
\draw[color=gray,thick] (0.05,0.05) -- (0.3,0.3);
}%
}
\newcommand{\KPC}{%
\KP{%
\draw[color=gray,thick] (-0.3,0.3) .. controls (0,-0.05) .. (0.3,0.3);
\draw[color=gray,thick] (-0.3,-0.3) .. controls (0,0.05) .. (0.3,-0.3);
}%
}
\newcommand{\KPD}{%
\KP{%
\draw[color=gray,thick] (-0.3,-0.3) .. controls (0.05,0) .. (-0.3,0.3);
\draw[color=gray,thick] (0.3,-0.3) .. controls (-0.05,0) .. (0.3,0.3);
}%
}
\begin{document}
\title
{
\vspace*{-40mm}
\normalfont \normalsize
\horrule{0.5pt} \\[0.4cm] % Thin top horizontal rule
\huge Topology Final Exam Study Guide\\ % The assignment title
\horrule{0.5pt} \\[0.5cm] % Thick bottom horizontal rule
}
\author{Brendan Busey} % Your name
\date{\normalsize\today} % Today's date or a custom date
\maketitle
\begin{center}
\section*{Chapter 1}
\end{center}
\subsection*{1.1 Equivalence Relations}
\begin{tcolorbox}
\begin{definition}
\textit{A binary relation $\thicksim$ on a set X is an \textbf{equivalence relation} if and only if $\forall ~ x, y, z \in$ X satisfies}
\begin{enumerate}
\item x $\thicksim$ x (reflexivity)
\item if x $\thicksim$ y, then y $\thicksim$ x (symmetry)
\item if x $\thicksim$ y and y $\thicksim$ z, then x $\thicksim$ z (transitivity)
\end{enumerate}
\end{definition}
\end{tcolorbox}
\section*{1.2 Bijections}
\begin{tcolorbox}
\begin{definition}
\textit{A function $f: X \rightarrow Y$ is an injection (or a \textbf{one-to-one} function) if and only if for an $x_{1}, x_{2} \in X$ we have}
\begin{center}
$f(x{_1})=f(x_{2}) \implies x_{1}=x_{2}$
\end{center}
\textit{The function is a \textbf{surjection} (or an \textbf{onto} function) if and only if for every $y \in Y$, there is $x \in X$ with $f(x)=y$. The function is a \textbf{bijection} if and only if it is an injection and a surjection.}
\end{definition}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{theorem}
\textit{Consider a function $f: X \rightarrow Y$. Then, f is a bijection if and only if f has an inverse function.}
\end{theorem}
\end{tcolorbox}
\pagebreak
\vspace*{-35mm}
\section*{1.3 Continuous Functions}
\begin{tcolorbox}
\begin{definition}
\textit{A function $f: X \rightarrow Y$ is continuous at $x_{0} \in X$ if and only if for every $\varepsilon > 0$ there is $\delta > 0$ such that $\forall ~ x \in X$, we have the implication that $d(x, x_{0}) < \delta \implies d(f(x), f(x_{0})) < \varepsilon$. A function is continuous if and only if it is continuous at each point of it s domain.}
\end{definition}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{theorem}
\textit{Suppose A and B are regions of $\mathbb{R}^{2}$ that are bounded by polygons. Suppose $f: A \rightarrow Y$ and $g: B \rightarrow Y$ are continuous functions such that $f(x)=g(x) ~ \forall x \in A \cap B$. Then, the function $h: A \cup B \rightarrow Y$ is defined by}
\begin{center}
\[h(x)= \begin{cases}
f(x) & if ~ x \in A \\
g(x) & if ~ x \in B
\end{cases}
\]
\end{center}
is continuous.
\end{theorem}
\end{tcolorbox}
\subsection*{1.4 Topological Equivalance}
\begin{tcolorbox}
\begin{definition}
\textit{A \textbf{homeomorphism} (or \textbf{topological equivalence}) is a bijection $h: X \rightarrow Y$ such that both $h$ and $h^{-1}$ are continuous. The spaces X and Y are \textbf{homeomorphic} (or \textbf{topologically equivalent}) if and only if there is a homeomorphism from X to Y.}
\end{definition}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{definition}
\textit{The \textit{standard disk} is the set \{$(x,y) \in \mathbb{R}^{2} ~ | ~ x^2+y^2 \leq 1$\}. A \textbf{disk} is any topological space homeomorphic to the standard disk. \\[2ex]
The \textbf{standard n-dimensional ball} (or more simply, the \textbf{the standard n-ball}) is the set $\{(x_{1}, x_{2}, \ldots, x_{n}) \in \mathbb{R}^{n} ~ | ~ x_{1}^{2} + x_{2}^{2} + \cdots + x_{n}^{2} \leq 1\}$. An \textbf{n-ball} (or \textbf{n-cell}) is any topological space homeomorphic to the standard n-ball.\\[2ex]
The \textbf{standard} n-\textbf{dimensional sphere} (or more simply, the \textbf{standard} n-\textbf{sphere}) is the set $\{(x_{1}, x_{2}, \cdots, x_{n}) \in \mathbb{R}^{n} ~ | ~ x_{1}^{2} + x_{2}^{2} + \ldots + x_{n+1}^{2} = 1\}$. An n-\textbf{sphere} is any topological space homeomorphic to the standard n-sphere.}
\end{definition}
\end{tcolorbox}
\pagebreak
\vspace*{-35mm}
\subsection*{1.5 Topological Invariants}
\begin{tcolorbox}
\begin{definition}
\textit{A \textbf{path} in a space X is a continuous function $\alpha: [0,1] \rightarrow X$. Consider the equivalence relation between pairs of points in a set of X defined by $x \thicksim y$ if and only if there is a path $\alpha : [0,1] \rightarrow X$ with $\alpha(0)=x$ and $\alpha(1)=y$. The equivalence classes under this relation are called \textbf{path components} of X. A set such that every two points are joined by a path is said to be \textbf{path-connected}}
\end{definition}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{theorem}
\textit{Suppose $\alpha : [0,1] \rightarrow A \cup B ~ is ~ a ~ path ~ \alpha(0) \in A$ and $\alpha(1) \in B$. Then, there is a sequence of points of A that converges to a point of B or else there is a sequence of points of B that converges to a point in A.}
\end{theorem}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{corollary}
\textit{A homeomorphism $h: X \rightarrow Y$ induces a bijection $h_{*}: P(x) \rightarrow P(Y)$. In particular, the number of path components of a space is topologically invariant.}
\end{corollary}
\end{tcolorbox}
\subsection*{1.6 Isotopy}
\begin{tcolorbox}
\begin{definition}
\textit{Suppose A and B are two subsets of a space X. An \textbf{Ambient isotopy} from A to B in X is a continuous function $h : X \times [0,1] \rightarrow X$ that satisfies the following three conditions. We denote $h(x,t)$ by $h_{t}(x)$.}
\begin{center}
\begin{enumerate}
\item $h_{t}: X \rightarrow X$ is a homeomorphism for every t $\in$ [0,1]
\item $h_{0} ~ is ~ the ~ identity ~ function ~ on ~ X$
\item $h_{1}(A)=B$
\end{enumerate}
\end{center}
\end{definition}
\end{tcolorbox}
\begin{center}
\section*{Chapter 2}
\end{center}
\subsection*{2.1 Knots, Links, and Equivalences}
\begin{tcolorbox}
\begin{definition}
\textit{A \textbf{knot K} is a simple closed curve in $\mathbb{R}^{3}$ that can be broken into a finite number of straight line segments $e_{1}, e_{2}, \cdots, e_{n}$ such that the intersection of any segment with $e_{k}$ with the other segments is exactly one endpoint of $e_{k}$ intersecting an endpoint of $e_{k-1}$ (or $e_{n}$ if $k=1$) and the other endpoint of $e_{k}$ intersecting an endpoint of $e_{k+1}$ (or $e_{1}$ if $k=n$).}
\end{definition}
\end{tcolorbox}
\pagebreak
\vspace*{-30mm}
\begin{tcolorbox}
\begin{definition}
\textit{Consider a triangle ABC with side AC matching one of the line segments of a knot K. In the plane determined by the triangle, we require that the region bounded by ABC intersects K only in the edge AC. A \textbf{triangular detour} involves replacing the edge AC of knot K with the two edges AB and BC to produce a new knot L. With the same notation, a \textbf{triangular shortcut} involves replacing the two edges AB and BC and L with the single edge of AC to produce knot K. A \textbf{triangular move} is either a triangular detour or a triangular shortcut. Two knots are \textbf{equivalent} if and only if there is a finite sequence of triangular moves that changes the first knot into the second.}
\end{definition}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{definition}
\textit{A \textbf{Link} is the nonempty union of a finite number of disjoint knots.}
\end{definition}
\end{tcolorbox}
\subsection*{2.2 Knot Diagrams}
\begin{tcolorbox}
\begin{definition}[General Position Rule of Thumb]
\textit{Suppose two piecewise-linear objects are embedded in general position in $\mathbb{R}^{n}$. Suppose A is a vertex, edge, face, or analogous higher-dimensional part of one object and B is a vertex, edge, face, or analogous higher-dimensional part of the other object. If the intersection $A \cup B$ is nonempty, then.}
\begin{center}
dim($A \cap B$)=dim(A)+dim(B)-n
\end{center}
\end{definition}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{definition}
\textit{The orthogonal projection of a knot onto a plane is a \textbf{regular projection} if and only if no vertex projects to the image of another point of the knot and there are no triple points.}
\end{definition}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{definition}
\textit{The \textbf{crossing number} of a knot K is the minimum number of crossing points that occur in the knot diagrams for all knots equivalent K.}
\end{definition}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{definition}
\textit{The \textbf{unknotting number} is the minimum number of times the knot must be passed through itself (\textbf{crossing switch}) to untie it}
\end{definition}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{definition}
\textit{A \textbf{trivial knot} is a knot that is equivalent to a triangle. A \textbf{trivial link} is a link that is equivalent to the union of disjoint triangles lying in a plane}
\end{definition}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{definition}
\textit{A knot is \textbf{alternating} if and only if it is equivalent to a knot with a diagram in which underpasses alternate with overpasses as you travel around the knot}
\end{definition}
\end{tcolorbox}
\pagebreak
\vspace*{-30mm}
\subsection*{2.3 Reidmeister Moves}
\begin{figure}[H]
\centering
\includegraphics[scale=0.5]{Reidemeister_move_1.png}
\caption{Type 1}
\end{figure}
\vspace{2mm}
\begin{figure}[H]
\centering
\includegraphics[scale=0.5]{Reidemeister_move_2.png}
\caption{Type 2}
\end{figure}
\pagebreak
\vspace*{-40mm}
\begin{figure}[H]
\centering
\includegraphics[scale=0.5]{Reidemeister_move_3.png}
\caption{Type 3}
\end{figure}
\vspace{2mm}
\begin{tcolorbox}
\begin{theorem}
\textit{If two links are equivalent, then their diagrams, subject to ambient isotopies of the plane, are related by a sequence of Reidemeister moves.}
\end{theorem}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{definition}
\textit{An \textbf{orientation} of a link is a choice of direction to travel around each component of the link. Consider a crossing a regular projection of an oriented link. Stand on the overpass and face in the direction of the orientation. The crossing is \textbf{right-handed} if and only if traffic on the underpass goes from right to left; the crossing is \textbf{left-handed} if and only if traffic on the underpass goes from left to right. In regular projection of an oriented link of two components, assign +1 to right-handed crossings and -1 to left-handed crossings. Add up the numbers assigned to crossings involving both components. One half this sum is the \textbf{linking number} of the two oriented components of the link.}
\end{definition}
\end{tcolorbox}
\subsection*{2.4 Colorings}
\begin{tcolorbox}
\begin{definition}
\textit{The diagram of a knot is \textbf{colorable} if and only if each arc can be assigned one of three colors subject to the two conditions:}
\begin{center}
\begin{enumerate}
\item At least two colors appear
\item At any crossing where two colors appear, all three colors appear
\end{enumerate}
\end{center}
\end{definition}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{theorem}
\textit{The colorability of a knot diagram is an invariant property of the knot type.}
\end{theorem}
\end{tcolorbox}
\pagebreak
\vspace*{-20mm}
\begin{tcolorbox}
\begin{definition}
\textit{Let p be an odd number greater than two. A knot is p-colorable if at every crossing:}
\begin{center}
\begin{enumerate}
\item At least two colors appear
\item you can solve $color1 + color2 \equiv 2x ~ mod ~ (the ~ number ~ of ~ colors ~ used)$, where color1 and color2 are numbers assigned to the arcs of the knot
\end{enumerate}
\end{center}
\end{definition}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{theorem}
\textit{The colorability of a knot diagram is an invariant property of the knot type.}
\end{theorem}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{theorem}
\textit{The representation of a knot diagram on a wheel with p colors is an invariant property of the knot type.}
\end{theorem}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{definition}
\textit{The determinant of a knot is the absolute value of its Alexander Polynominal evaluated at -1 (simply, plug-in -1 for t)}
\end{definition}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{theorem}
\textit{A knot is p-\textbf{colorable} for prime p greater than two if and only if p divides its determinant}
\end{theorem}
\end{tcolorbox}
\subsection*{2.5 The Alexander Polynominal}
\begin{tcolorbox}
\textit{Steps in computing the Alexander Polynominal:}
\begin{center}
\begin{enumerate}
\item Label the crossings $x_{1}, x_{2}, \cdots, x_{n}$
\item Label the arcs $a_{1}, a_{2}, \cdots, a_{n}$
\item Choose an orientation for the knot
\item As you travel around the knot in the chosen orientation, stand on the overpass of each crossing. Label the overstrand with $1-t$, the left-end of the understrand $t$, and the right-end of the understrand -1
\item Create the arc/crossing matrix
\item Compute the determinant of the matrix, which is the Alexander Polynominal
\end{enumerate}
\end{center}
\end{tcolorbox}
\pagebreak
\vspace*{-30mm}
\begin{tcolorbox}
\begin{definition}
\textit{The projection of an oriented knot divides the plane into a number of regions. The \textbf{index} of one of these regions is the net number of times the projection winds counterclockwise around any point in the region.}
\end{definition}
\end{tcolorbox}
\begin{tcolorbox}
\begin{definition}
\textit{The \textbf{index} of a crossing of a knot diagram is the common value of the index of two of the regions near the crossing.}
\end{definition}
\end{tcolorbox}
\begin{tcolorbox}
\begin{theorem}
\textit{The Alexander Polynominal of an oriented knot is an invariant under Reidemeister moves.}
\end{theorem}
\end{tcolorbox}
\subsection*{2.6 Skein Relations}
\begin{tcolorbox}
\textit{Calculating the $\Delta$ polynominal is the same as calculating the Alexander Polynominal}
\end{tcolorbox}
\subsection*{2.7 The Jones Polynominal}
\begin{tcolorbox}
\textbf{Rules for the Bracket Polynominal} \textit{The Kauffman \textbf{Bracket Polynominal} of a regular projection of a link is a polynominal in integer powers of the variable A defined by the following three rules:}
\begin{center}
\begin{enumerate}
%the first rule
\item
$\left\langle\KPA\right\rangle=1$
%the second rule
\item
$\left\langle L \cup \KPA\right\rangle=(-A^{2}-A^{-2})\langle L\rangle$
%the third rule
\item
$\left\langle\KPB\right\rangle=
A\left\langle\KPC\right\rangle + A^{-1} \left\langle \KPD \right\rangle$
\end{enumerate}
\end{center}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{definition}
\textit{The \textbf{writhe} w(L) of the regular projection L of a link is the number of right-handed crossings minus the number of left-handed crossings.}
\end{definition}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{definition}
\textit{The X(L) polynominal is defined as:}
\begin{center}
$X(L)=(-A)^{-3w(L)} \big \langle L \big \rangle$, where $\big \langle L \big \rangle$ is the bracket polynominal for L and $w(L)$ is the writhe of L
\end{center}
\end{definition}
\end{tcolorbox}
\pagebreak
\vspace*{-30mm}
\begin{tcolorbox}
\textit{Steps in calculating the Jones Polynominal:}
\begin{center}
\begin{enumerate}
\item Calculate the Bracket Polynominal
\item Calculate the $X-polynominal$
\item Substitute $t^{-\frac{1}{4}}$ in for every ``A" in the $X-polynominal$ and simplify
\end{enumerate}
\end{center}
\end{tcolorbox}
\begin{center}
\section*{Chapter 3 Surfaces}
\end{center}
\subsection*{3.1 Definition and Examples}
\begin{tcolorbox}
\begin{definition}
\textit{In a space with a way of measuring distances between points, a \textbf{neighborhood} of a point is a subset that contains all points within some positive distance of the point}
\end{definition}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{definition}
\textit{A \textbf{surface} (or 2 \textbf{-manifold}) is a space that is homeomorphic to a nonempty subset of finite-dimensional Euclidean space and in which every point has a neighborhood homeomorphic to $\mathbb{R}^{2}$. We sometimes also wish to admit \textbf{boundary} points, which have neighborhoods homeomorphic to the half-plane $\{(x,y) \in \mathbb{R}^{2} ~ | ~ y \geq 0\}$}.
\end{definition}
\end{tcolorbox}
\subsection*{3.2 Cut-and-Paste Techniques}
\begin{tcolorbox}
\begin{definition}
\textit{Let S and T be path-connected surfaces Remove the interior of a disk from each surface by cutting along the boundaries of the disks. Glue the remaining surfaces together along the newly formed boundary components. The result surface is the \textbf{connected sum} of S and T. It is denoted S\texttt{\#}T.}
\end{definition}
\end{tcolorbox}
\subsection*{3.3 The Euler Characteristic and Orientability}
\begin{tcolorbox}
\begin{definition}
\textit{A \textbf{triangulation} of a space is a decomposition of the space into a union of disks, arcs, and points. The disks are called \textbf{faces}, the arcs are called \textbf{edges}, and the points are \textbf{vertices} of the triangulation. A face intersects other components of a triangulation only along its boundary; and the boundary of a face consists of three edges and three vertices. An edge intersects other edges and the vertices only at its endpoints; and both endpoints of an edge are vertices.}
\end{definition}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{definition}
\textit{A triangulated space is \textbf{compact} if and only if it consists of a finite number of faces, edges, and vertices.}
\end{definition}
\end{tcolorbox}
\pagebreak
\vspace*{-30mm}
\begin{tcolorbox}
\begin{definition}
\textit{The \textbf{Euler characteristic} of a compact triangulation space S is the number of vertices minus the number of edges plus the number of faces. The Euler characteristic of S is denoted by $\chi(S)$.}
\end{definition}
\end{tcolorbox}
\begin{tcolorbox}
\begin{theorem}
\textit{Every closed, path-connected surface is homeomorphic to exactly one of:}
\begin{center}
\begin{enumerate}
\item A 2-sphere
\item A connected sum of Tori
\item A connected sum of projective planes
\end{enumerate}
\end{center}
\end{theorem}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{sidenote}
\textit{Something is orientable if it is 2-colorable or doesn't have a mobius band}
\end{sidenote}
\end{tcolorbox}
\begin{tcolorbox}
\begin{theorem}
\textit{Suppose $A$ and $B$ are triangulated so that $A \cap B$ is also triangulated. Then, $\chi(A \cup B)=\chi(A)+\chi(B)-\chi(A \cap B)$}.
\end{theorem}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{theorem}
\textit{The surface formed by taking the connected sum of g tori and cutting out disks to leave b boundary components has Euler characteristic 2-2g-b. The surface formed by taking the connected sum of n projective plane and cutting out disks to leave b boundary components has Euler characteristic 2-n-b}.
\end{theorem}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{definition}
\textit{An \textbf{orientation} of a polygonal face of a triangulated surface is the choice of one of the two possible orientations of the boundary curve of the face. A surface is \textbf{orientable} if and only if it is possible to choose orientations of all the faces of a triangulation of the surface so that whenever two faces share a common edge, the orientation of the faces induce opposite orientations on the edge.}
\end{definition}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{definition}
\textit{$\chi(f_{1}\texttt{\#}f_{2})=\chi(f_{1}) + \chi(f_{2}) - 2$}
\end{definition}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{definition}
\textit{With the word you come up with for the surface, if every letter does not have an inverse, the surface is not orientable. If every letter does have an inverse, it is orientable}
\end{definition}
\end{tcolorbox}
\vspace{2mm}
\begin{tcolorbox}
\begin{definition}
\textit{Just concatenate the two individual words of each surface to get a word for the connected sum of the two surfaces}
\end{definition}
\end{tcolorbox}
\pagebreak
\vspace*{-30mm}
\begin{tcolorbox}
\begin{sidenote}
\textit{The table below helps you figure out what surface is being asked for based on \textbf{Orientability} and the \textbf{Euler characterisitic}}
\vspace{2mm}
\begin{tabular}{||c c c||}
\hline
\textit{$\chi$} & \textit{$Oreintable$} & \textit{$Non-orientable$} \\ [0.5ex]
\hline\hline
2 & Sphere & \\
\hline
1 & & P \\
\hline
0 & T & P \texttt{\#} P \\
\hline
-1 & & P \texttt{\#} P \texttt{\#} P \\
\hline
-2 & T \texttt{\#} T & P \texttt{\#} P \texttt{\#} P \texttt{\#} P \\
\hline
-3 & & P \texttt{\#} P \texttt{\#} P \texttt{\#} P \texttt{\#} P \\
\hline
-4 & T \texttt{\#} T \texttt{\#} T & P \texttt{\#} P \texttt{\#} P \texttt{\#} P \texttt{\#} P \texttt{\# P} \\ [1ex]
\hline
\end{tabular}
\end{sidenote}
\end{tcolorbox}
\end{document} |
The monomial $x^0$ is equal to $1$. |
State Before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.228490
β : Type ?u.228493
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t✝ : Set E
h : Convex 𝕜 s
x y : E
hx : x ∈ s
hy : y ∈ s
t : 𝕜
ht : t ∈ Icc 0 1
⊢ x + t • (y - x) ∈ s State After: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.228490
β : Type ?u.228493
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t✝ : Set E
h : Convex 𝕜 s
x y : E
hx : x ∈ s
hy : y ∈ s
t : 𝕜
ht : t ∈ Icc 0 1
⊢ t • (y - x) + x ∈ s Tactic: rw [add_comm] State Before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.228490
β : Type ?u.228493
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t✝ : Set E
h : Convex 𝕜 s
x y : E
hx : x ∈ s
hy : y ∈ s
t : 𝕜
ht : t ∈ Icc 0 1
⊢ t • (y - x) + x ∈ s State After: no goals Tactic: exact h.lineMap_mem hx hy ht |
(* Author: Tobias Nipkow *)
section "Splay Tree Implementation of Maps"
theory Splay_Map
imports
Splay_Tree
"HOL-Data_Structures.Map_Specs"
begin
function splay :: "'a::linorder \<Rightarrow> ('a*'b) tree \<Rightarrow> ('a*'b) tree" where
"splay x Leaf = Leaf" |
"x = fst a \<Longrightarrow> splay x (Node t1 a t2) = Node t1 a t2" |
"x = fst a \<Longrightarrow> x < fst b \<Longrightarrow> splay x (Node (Node t1 a t2) b t3) = Node t1 a (Node t2 b t3)" |
"x < fst a \<Longrightarrow> splay x (Node Leaf a t) = Node Leaf a t" |
"x < fst a \<Longrightarrow> x < fst b \<Longrightarrow> splay x (Node (Node Leaf a t1) b t2) = Node Leaf a (Node t1 b t2)" |
"x < fst a \<Longrightarrow> x < fst b \<Longrightarrow> t1 \<noteq> Leaf \<Longrightarrow>
splay x (Node (Node t1 a t2) b t3) =
(case splay x t1 of Node t11 y t12 \<Rightarrow> Node t11 y (Node t12 a (Node t2 b t3)))" |
"fst a < x \<Longrightarrow> x < fst b \<Longrightarrow> splay x (Node (Node t1 a Leaf) b t2) = Node t1 a (Node Leaf b t2)" |
"fst a < x \<Longrightarrow> x < fst b \<Longrightarrow> t2 \<noteq> Leaf \<Longrightarrow>
splay x (Node (Node t1 a t2) b t3) =
(case splay x t2 of Node t21 y t22 \<Rightarrow> Node (Node t1 a t21) y (Node t22 b t3))" |
"fst a < x \<Longrightarrow> x = fst b \<Longrightarrow> splay x (Node t1 a (Node t2 b t3)) = Node (Node t1 a t2) b t3" |
"fst a < x \<Longrightarrow> splay x (Node t a Leaf) = Node t a Leaf" |
"fst a < x \<Longrightarrow> x < fst b \<Longrightarrow> t2 \<noteq> Leaf \<Longrightarrow>
splay x (Node t1 a (Node t2 b t3)) =
(case splay x t2 of Node t21 y t22 \<Rightarrow> Node (Node t1 a t21) y (Node t22 b t3))" |
"fst a < x \<Longrightarrow> x < fst b \<Longrightarrow> splay x (Node t1 a (Node Leaf b t2)) = Node (Node t1 a Leaf) b t2" |
"fst a < x \<Longrightarrow> fst b < x \<Longrightarrow> splay x (Node t1 a (Node t2 b Leaf)) = Node (Node t1 a t2) b Leaf" |
"fst a < x \<Longrightarrow> fst b < x \<Longrightarrow> t3 \<noteq> Leaf \<Longrightarrow>
splay x (Node t1 a (Node t2 b t3)) =
(case splay x t3 of Node t31 y t32 \<Rightarrow> Node (Node (Node t1 a t2) b t31) y t32)"
apply(atomize_elim)
apply(auto)
(* 1 subgoal *)
apply (subst (asm) neq_Leaf_iff)
apply(auto)
apply (metis tree.exhaust surj_pair less_linear)+
done
termination splay
by lexicographic_order
lemma splay_code: "splay (x::_::linorder) t = (case t of Leaf \<Rightarrow> Leaf |
Node al a ar \<Rightarrow> (case cmp x (fst a) of
EQ \<Rightarrow> t |
LT \<Rightarrow> (case al of
Leaf \<Rightarrow> t |
Node bl b br \<Rightarrow> (case cmp x (fst b) of
EQ \<Rightarrow> Node bl b (Node br a ar) |
LT \<Rightarrow> if bl = Leaf then Node bl b (Node br a ar)
else case splay x bl of
Node bll y blr \<Rightarrow> Node bll y (Node blr b (Node br a ar)) |
GT \<Rightarrow> if br = Leaf then Node bl b (Node br a ar)
else case splay x br of
Node brl y brr \<Rightarrow> Node (Node bl b brl) y (Node brr a ar))) |
GT \<Rightarrow> (case ar of
Leaf \<Rightarrow> t |
Node bl b br \<Rightarrow> (case cmp x (fst b) of
EQ \<Rightarrow> Node (Node al a bl) b br |
LT \<Rightarrow> if bl = Leaf then Node (Node al a bl) b br
else case splay x bl of
Node bll y blr \<Rightarrow> Node (Node al a bll) y (Node blr b br) |
GT \<Rightarrow> if br=Leaf then Node (Node al a bl) b br
else case splay x br of
Node bll y blr \<Rightarrow> Node (Node (Node al a bl) b bll) y blr))))"
by(auto split!: tree.split)
definition lookup :: "('a*'b)tree \<Rightarrow> 'a::linorder \<Rightarrow> 'b option" where "lookup t x =
(case splay x t of Leaf \<Rightarrow> None | Node _ (a,b) _ \<Rightarrow> if x=a then Some b else None)"
hide_const (open) insert
fun update :: "'a::linorder \<Rightarrow> 'b \<Rightarrow> ('a*'b) tree \<Rightarrow> ('a*'b) tree" where
"update x y t = (if t = Leaf then Node Leaf (x,y) Leaf
else case splay x t of
Node l a r \<Rightarrow> if x = fst a then Node l (x,y) r
else if x < fst a then Node l (x,y) (Node Leaf a r) else Node (Node l a Leaf) (x,y) r)"
definition delete :: "'a::linorder \<Rightarrow> ('a*'b) tree \<Rightarrow> ('a*'b) tree" where
"delete x t = (if t = Leaf then Leaf
else case splay x t of Node l a r \<Rightarrow>
if x = fst a
then if l = Leaf then r else case splay_max l of Node l' m r' \<Rightarrow> Node l' m r
else Node l a r)"
subsection "Functional Correctness Proofs"
lemma splay_Leaf_iff: "(splay x t = Leaf) = (t = Leaf)"
by(induction x t rule: splay.induct) (auto split: tree.splits)
subsubsection "Proofs for lookup"
lemma lookup_eq:
"sorted1(inorder t) \<Longrightarrow> lookup t x = map_of (inorder t) x"
by(auto simp: lookup_def splay_Leaf_iff splay_map_of_inorder split: tree.split)
subsubsection "Proofs for update"
lemma inorder_splay: "inorder(splay x t) = inorder t"
by(induction x t rule: splay.induct)
(auto simp: neq_Leaf_iff split: tree.split)
lemma sorted_splay:
"sorted1(inorder t) \<Longrightarrow> splay x t = Node l a r \<Longrightarrow>
sorted(map fst (inorder l) @ x # map fst (inorder r))"
unfolding inorder_splay[of x t, symmetric]
by(induction x t arbitrary: l a r rule: splay.induct)
(auto simp: sorted_lems sorted_Cons_le sorted_snoc_le splay_Leaf_iff split: tree.splits)
lemma inorder_update_splay:
"sorted1(inorder t) \<Longrightarrow> inorder(update x y t) = upd_list x y (inorder t)"
using inorder_splay[of x t, symmetric] sorted_splay[of t x]
by(auto simp: upd_list_simps upd_list_Cons upd_list_snoc neq_Leaf_iff split: tree.split)
subsubsection "Proofs for delete"
lemma inorder_splay_maxD:
"splay_max t = Node l a r \<Longrightarrow> sorted1(inorder t) \<Longrightarrow>
inorder l @ [a] = inorder t \<and> r = Leaf"
by(induction t arbitrary: l a r rule: splay_max.induct)
(auto simp: sorted_lems split: tree.splits if_splits)
lemma inorder_delete_splay:
"sorted1(inorder t) \<Longrightarrow> inorder(delete x t) = del_list x (inorder t)"
using inorder_splay[of x t, symmetric] sorted_splay[of t x]
by (auto simp: del_list_simps del_list_sorted_app delete_def del_list_notin_Cons inorder_splay_maxD
split: tree.splits)
subsubsection "Overall Correctness"
interpretation Map_by_Ordered
where empty = empty and lookup = lookup and update = update
and delete = delete and inorder = inorder and inv = "\<lambda>_. True"
proof (standard, goal_cases)
case 2 thus ?case by(simp add: lookup_eq)
next
case 3 thus ?case by(simp add: inorder_update_splay del: update.simps)
next
case 4 thus ?case by(simp add: inorder_delete_splay)
qed (auto simp: empty_def)
end
|
State Before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
a : E
f' : E →L[ℝ] ℝ
s : Set E
h : IsLocalMaxOn f s a
y : E
hy : y ∈ posTangentConeAt s a
hy' : -y ∈ posTangentConeAt s a
hf : ¬DifferentiableWithinAt ℝ f s a
⊢ ↑(fderivWithin ℝ f s a) y = 0 State After: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
a : E
f' : E →L[ℝ] ℝ
s : Set E
h : IsLocalMaxOn f s a
y : E
hy : y ∈ posTangentConeAt s a
hy' : -y ∈ posTangentConeAt s a
hf : ¬DifferentiableWithinAt ℝ f s a
⊢ ↑0 y = 0 Tactic: rw [fderivWithin_zero_of_not_differentiableWithinAt hf] State Before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
a : E
f' : E →L[ℝ] ℝ
s : Set E
h : IsLocalMaxOn f s a
y : E
hy : y ∈ posTangentConeAt s a
hy' : -y ∈ posTangentConeAt s a
hf : ¬DifferentiableWithinAt ℝ f s a
⊢ ↑0 y = 0 State After: no goals Tactic: rfl |
{-
- Automatically generate UARel and DUARel instances
-}
{-# OPTIONS --no-exact-split --safe #-}
module Cubical.Displayed.Auto where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Function
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Univalence
open import Cubical.Displayed.Base
open import Cubical.Displayed.Subst
open import Cubical.Displayed.Morphism
open import Cubical.Displayed.Constant
open import Cubical.Displayed.Function
open import Cubical.Displayed.Generic
open import Cubical.Displayed.Sigma
open import Cubical.Displayed.Unit
open import Cubical.Displayed.Universe
open import Cubical.Data.List.Base
open import Cubical.Data.Nat.Base
open import Cubical.Data.Sigma.Base
open import Cubical.Data.Unit.Base
import Agda.Builtin.Reflection as R
open import Cubical.Reflection.Base
-- Descriptor language
mutual
data UARelDesc : ∀ {ℓA ℓ≅A} {A : Type ℓA} (𝒮-A : UARel A ℓ≅A) → Typeω where
generic : ∀ {ℓA} {A : Type ℓA} → UARelDesc (𝒮-generic A)
univ : ∀ ℓU → UARelDesc (𝒮-Univ ℓU)
-- Having a special descriptor for non-dependent × helps to avoid
-- combinatorial explosion. Automation will try to apply this first.
prod : ∀ {ℓA ℓ≅A ℓB ℓ≅B}
{A : Type ℓA} {𝒮-A : UARel A ℓ≅A} (dA : UARelDesc 𝒮-A)
{B : Type ℓB} {𝒮-B : UARel B ℓ≅B} (dB : UARelDesc 𝒮-B)
→ UARelDesc (𝒮-A ×𝒮 𝒮-B)
sigma : ∀ {ℓA ℓ≅A ℓB ℓ≅B}
{A : Type ℓA} {𝒮-A : UARel A ℓ≅A} (dA : UARelDesc 𝒮-A)
{B : A → Type ℓB} {𝒮ᴰ-B : DUARel 𝒮-A B ℓ≅B} (dB : DUARelDesc 𝒮-A 𝒮ᴰ-B)
→ UARelDesc (∫ 𝒮ᴰ-B)
param : ∀ {ℓA ℓB ℓ≅B} (A : Type ℓA)
{B : Type ℓB} {𝒮-B : UARel B ℓ≅B} (dB : UARelDesc 𝒮-B)
→ UARelDesc (A →𝒮 𝒮-B)
pi : ∀ {ℓA ℓ≅A ℓB ℓ≅B}
{A : Type ℓA} {𝒮-A : UARel A ℓ≅A} (dA : UARelDesc 𝒮-A)
{B : A → Type ℓB} {𝒮ᴰ-B : DUARel 𝒮-A B ℓ≅B} (dB : DUARelDesc 𝒮-A 𝒮ᴰ-B)
→ UARelDesc (𝒮-Π 𝒮-A 𝒮ᴰ-B)
unit : UARelDesc 𝒮-Unit
-- Projections from one UARel to another
data UARelReindex : ∀ {ℓA ℓ≅A ℓC ℓ≅C}
{A : Type ℓA} {𝒮-A : UARel A ℓ≅A}
{C : Type ℓC} {𝒮-C : UARel C ℓ≅C}
(f : UARelHom 𝒮-A 𝒮-C)
→ Typeω
where
id : ∀ {ℓA ℓ≅A} {A : Type ℓA} {𝒮-A : UARel A ℓ≅A}
→ UARelReindex (𝒮-id 𝒮-A)
∘fst : ∀ {ℓA ℓ≅A ℓB ℓ≅B ℓC ℓ≅C}
{A : Type ℓA} {𝒮-A : UARel A ℓ≅A}
{B : A → Type ℓB} {𝒮ᴰ-B : DUARel 𝒮-A B ℓ≅B}
{C : Type ℓC} {𝒮-C : UARel C ℓ≅C}
{f : UARelHom 𝒮-A 𝒮-C}
→ UARelReindex f
→ UARelReindex (𝒮-∘ f (𝒮-fst {𝒮ᴰ-B = 𝒮ᴰ-B}))
∘snd : ∀ {ℓA ℓ≅A ℓB ℓ≅B ℓC ℓ≅C}
{A : Type ℓA} {𝒮-A : UARel A ℓ≅A}
{B : Type ℓB} {𝒮-B : UARel B ℓ≅B}
{C : Type ℓC} {𝒮-C : UARel C ℓ≅C}
{f : UARelHom 𝒮-B 𝒮-C}
→ UARelReindex f
→ UARelReindex (𝒮-∘ f (𝒮-snd {𝒮-A = 𝒮-A}))
∘app : ∀ {ℓA ℓB ℓ≅B ℓC ℓ≅C}
{A : Type ℓA}
{B : Type ℓB} {𝒮-B : UARel B ℓ≅B}
{C : Type ℓC} {𝒮-C : UARel C ℓ≅C}
{f : UARelHom 𝒮-B 𝒮-C}
→ UARelReindex f
→ (a : A) → UARelReindex (𝒮-∘ f (𝒮-app a))
data SubstRelDesc : ∀ {ℓA ℓ≅A ℓB}
{A : Type ℓA} (𝒮-A : UARel A ℓ≅A)
{B : A → Type ℓB} (𝒮ˢ-B : SubstRel 𝒮-A B) → Typeω
where
generic : ∀ {ℓA ℓ≅A ℓB} {A : Type ℓA} {𝒮-A : UARel A ℓ≅A} {B : A → Type ℓB}
→ SubstRelDesc 𝒮-A (𝒮ˢ-generic 𝒮-A B)
constant : ∀ {ℓA ℓ≅A ℓB}
{A : Type ℓA} {𝒮-A : UARel A ℓ≅A} {B : Type ℓB}
→ SubstRelDesc 𝒮-A (𝒮ˢ-const 𝒮-A B)
-- We have an element DUARel over any 𝒮-A with a proejction to a universe
-- that can be described with UARelReindex
el : ∀ {ℓA ℓ≅A ℓU} {A : Type ℓA} {𝒮-A : UARel A ℓ≅A}
{f : UARelHom 𝒮-A (𝒮-Univ ℓU)}
→ UARelReindex f
→ SubstRelDesc 𝒮-A (𝒮ˢ-reindex f (𝒮ˢ-El ℓU))
prod : ∀ {ℓA ℓ≅A ℓB ℓC}
{A : Type ℓA} {𝒮-A : UARel A ℓ≅A}
{B : A → Type ℓB} {𝒮ˢ-B : SubstRel 𝒮-A B} (dB : SubstRelDesc 𝒮-A 𝒮ˢ-B)
{C : A → Type ℓC} {𝒮ˢ-C : SubstRel 𝒮-A C} (dC : SubstRelDesc 𝒮-A 𝒮ˢ-C)
→ SubstRelDesc 𝒮-A (𝒮ˢ-B ×𝒮ˢ 𝒮ˢ-C)
sigma : ∀ {ℓA ℓ≅A ℓB ℓC}
{A : Type ℓA} {𝒮-A : UARel A ℓ≅A}
{B : A → Type ℓB} {𝒮ˢ-B : SubstRel 𝒮-A B} (dB : SubstRelDesc 𝒮-A 𝒮ˢ-B)
{C : Σ A B → Type ℓC} {𝒮ˢ-C : SubstRel (∫ˢ 𝒮ˢ-B) C} (dC : SubstRelDesc (∫ˢ 𝒮ˢ-B) 𝒮ˢ-C)
→ SubstRelDesc 𝒮-A (𝒮ˢ-Σ 𝒮ˢ-B 𝒮ˢ-C)
pi : ∀ {ℓA ℓ≅A ℓB ℓC}
{A : Type ℓA} {𝒮-A : UARel A ℓ≅A}
{B : A → Type ℓB} {𝒮ˢ-B : SubstRel 𝒮-A B} (dB : SubstRelDesc 𝒮-A 𝒮ˢ-B)
{C : Σ A B → Type ℓC} {𝒮ˢ-C : SubstRel (∫ˢ 𝒮ˢ-B) C} (dC : SubstRelDesc (∫ˢ 𝒮ˢ-B) 𝒮ˢ-C)
→ SubstRelDesc 𝒮-A (𝒮ˢ-Π 𝒮ˢ-B 𝒮ˢ-C)
data DUARelDesc : ∀ {ℓA ℓ≅A ℓB ℓ≅B}
{A : Type ℓA} (𝒮-A : UARel A ℓ≅A)
{B : A → Type ℓB} (𝒮ᴰ-B : DUARel 𝒮-A B ℓ≅B) → Typeω
where
generic : ∀ {ℓA ℓ≅A ℓB} {A : Type ℓA} {𝒮-A : UARel A ℓ≅A} {B : A → Type ℓB}
→ DUARelDesc 𝒮-A (𝒮ᴰ-generic 𝒮-A B)
constant : ∀ {ℓA ℓ≅A ℓB ℓ≅B}
{A : Type ℓA} {𝒮-A : UARel A ℓ≅A}
{B : Type ℓB} {𝒮-B : UARel B ℓ≅B}
→ UARelDesc 𝒮-B
→ DUARelDesc 𝒮-A (𝒮ᴰ-const 𝒮-A 𝒮-B)
el : ∀ {ℓA ℓ≅A ℓU} {A : Type ℓA} {𝒮-A : UARel A ℓ≅A}
{f : UARelHom 𝒮-A (𝒮-Univ ℓU)}
→ UARelReindex f
→ DUARelDesc 𝒮-A (𝒮ᴰ-reindex f (𝒮ᴰ-El ℓU))
prod : ∀ {ℓA ℓ≅A ℓB ℓ≅B ℓC ℓ≅C}
{A : Type ℓA} {𝒮-A : UARel A ℓ≅A}
{B : A → Type ℓB} {𝒮ᴰ-B : DUARel 𝒮-A B ℓ≅B} (dB : DUARelDesc 𝒮-A 𝒮ᴰ-B)
{C : A → Type ℓC} {𝒮ᴰ-C : DUARel 𝒮-A C ℓ≅C} (dC : DUARelDesc 𝒮-A 𝒮ᴰ-C)
→ DUARelDesc 𝒮-A (𝒮ᴰ-B ×𝒮ᴰ 𝒮ᴰ-C)
sigma : ∀ {ℓA ℓ≅A ℓB ℓ≅B ℓC ℓ≅C}
{A : Type ℓA} {𝒮-A : UARel A ℓ≅A}
{B : A → Type ℓB} {𝒮ᴰ-B : DUARel 𝒮-A B ℓ≅B} (dB : DUARelDesc 𝒮-A 𝒮ᴰ-B)
{C : Σ A B → Type ℓC} {𝒮ᴰ-C : DUARel (∫ 𝒮ᴰ-B) C ℓ≅C} (dC : DUARelDesc (∫ 𝒮ᴰ-B) 𝒮ᴰ-C)
→ DUARelDesc 𝒮-A (𝒮ᴰ-Σ 𝒮ᴰ-B 𝒮ᴰ-C)
pi : ∀ {ℓA ℓ≅A ℓB ℓ≅B ℓC ℓ≅C}
{A : Type ℓA} {𝒮-A : UARel A ℓ≅A}
{B : A → Type ℓB} {𝒮ᴰ-B : DUARel 𝒮-A B ℓ≅B} (dB : DUARelDesc 𝒮-A 𝒮ᴰ-B)
{C : Σ A B → Type ℓC} {𝒮ᴰ-C : DUARel (∫ 𝒮ᴰ-B) C ℓ≅C} (dC : DUARelDesc (∫ 𝒮ᴰ-B) 𝒮ᴰ-C)
→ DUARelDesc 𝒮-A (𝒮ᴰ-Π 𝒮ᴰ-B 𝒮ᴰ-C)
piˢ : ∀ {ℓA ℓ≅A ℓB ℓC ℓ≅C}
{A : Type ℓA} {𝒮-A : UARel A ℓ≅A}
{B : A → Type ℓB} {𝒮ˢ-B : SubstRel 𝒮-A B} (dB : SubstRelDesc 𝒮-A 𝒮ˢ-B)
{C : Σ A B → Type ℓC} {𝒮ᴰ-C : DUARel (∫ˢ 𝒮ˢ-B) C ℓ≅C} (dC : DUARelDesc (∫ˢ 𝒮ˢ-B) 𝒮ᴰ-C)
→ DUARelDesc 𝒮-A (𝒮ᴰ-Πˢ 𝒮ˢ-B 𝒮ᴰ-C)
private
getUARel : ∀ {ℓA ℓ≅A} {A : Type ℓA} {𝒮-A : UARel A ℓ≅A}
→ UARelDesc 𝒮-A → UARel A ℓ≅A
getUARel {𝒮-A = 𝒮-A} _ = 𝒮-A
getDUARel : ∀ {ℓA ℓ≅A ℓB ℓ≅B}
{A : Type ℓA} {𝒮-A : UARel A ℓ≅A}
{B : A → Type ℓB} {𝒮ᴰ-B : DUARel 𝒮-A B ℓ≅B}
→ DUARelDesc 𝒮-A 𝒮ᴰ-B → DUARel 𝒮-A B ℓ≅B
getDUARel {𝒮ᴰ-B = 𝒮ᴰ-B} _ = 𝒮ᴰ-B
-- Magic number
private
FUEL = 10000
mutual
autoUARelDesc : ℕ → R.Term → R.TC Unit
autoUARelDesc zero hole = R.typeError [ R.strErr "Out of fuel" ]
autoUARelDesc (suc n) hole =
tryUniv <|> tryProd <|> trySigma <|> tryParam <|> tryPi <|> tryUnit <|> useGeneric
where
tryUniv : R.TC Unit
tryUniv = R.unify (R.con (quote UARelDesc.univ) [ varg R.unknown ]) hole
tryBinary : R.Name → R.TC Unit
tryBinary name =
newMeta R.unknown >>= λ hole₁ →
newMeta R.unknown >>= λ hole₂ →
R.unify (R.con name (hole₁ v∷ hole₂ v∷ [])) hole >>
autoUARelDesc n hole₁ >>
autoDUARelDesc n hole₂
tryParam : R.TC Unit
tryParam =
newMeta R.unknown >>= λ paramTy →
newMeta R.unknown >>= λ hole₁ →
R.unify (R.con (quote UARelDesc.param) (paramTy v∷ hole₁ v∷ [])) hole >>
autoUARelDesc n hole₁
tryProd = tryBinary (quote UARelDesc.prod)
trySigma = tryBinary (quote UARelDesc.sigma)
tryPi = tryBinary (quote UARelDesc.pi)
tryUnit : R.TC Unit
tryUnit = R.unify (R.con (quote UARelDesc.unit) []) hole
useGeneric : R.TC Unit
useGeneric = R.unify (R.con (quote UARelDesc.generic) []) hole
autoUARelReindex : ℕ → R.Term → R.TC Unit
autoUARelReindex zero hole = R.typeError [ R.strErr "Out of fuel" ]
autoUARelReindex (suc n) hole =
tryId <|> tryFst <|> trySnd <|> tryApp
where
tryId : R.TC Unit
tryId = R.unify (R.con (quote UARelReindex.id) []) hole
tryUnary : R.Name → R.TC Unit
tryUnary name =
newMeta R.unknown >>= λ hole₁ →
R.unify (R.con name [ varg hole₁ ]) hole >>
autoUARelReindex n hole₁
tryFst = tryUnary (quote UARelReindex.∘fst)
trySnd = tryUnary (quote UARelReindex.∘snd)
tryApp : R.TC Unit
tryApp =
newMeta R.unknown >>= λ hole₁ →
newMeta R.unknown >>= λ param →
R.unify (R.con (quote UARelReindex.∘app) (hole₁ v∷ param v∷ [])) hole >>
autoUARelReindex n hole₁
autoSubstRelDesc : ℕ → R.Term → R.TC Unit
autoSubstRelDesc zero hole = R.typeError [ R.strErr "Out of fuel" ]
autoSubstRelDesc (suc n) hole =
tryConstant <|> tryEl <|> tryProd <|> trySigma <|> tryPi <|> useGeneric
where
tryConstant : R.TC Unit
tryConstant =
R.unify (R.con (quote SubstRelDesc.constant) []) hole
tryEl : R.TC Unit
tryEl =
newMeta R.unknown >>= λ hole₁ →
R.unify (R.con (quote SubstRelDesc.el) [ varg hole₁ ]) hole >>
autoUARelReindex n hole₁
tryBinary : R.Name → R.TC Unit
tryBinary name =
newMeta R.unknown >>= λ hole₁ →
newMeta R.unknown >>= λ hole₂ →
R.unify (R.con name (hole₁ v∷ hole₂ v∷ [])) hole >>
autoSubstRelDesc n hole₁ >>
autoSubstRelDesc n hole₂
tryProd = tryBinary (quote SubstRelDesc.prod)
trySigma = tryBinary (quote SubstRelDesc.sigma)
tryPi = tryBinary (quote SubstRelDesc.pi)
useGeneric : R.TC Unit
useGeneric = R.unify (R.con (quote SubstRelDesc.generic) []) hole
autoDUARelDesc : ℕ → R.Term → R.TC Unit
autoDUARelDesc zero hole = R.typeError [ R.strErr "Out of fuel" ]
autoDUARelDesc (suc n) hole =
tryConstant <|> tryEl <|> tryProd <|> trySigma <|> tryPiˢ <|> tryPi <|> useGeneric
where
tryConstant : R.TC Unit
tryConstant =
newMeta R.unknown >>= λ hole₁ →
R.unify (R.con (quote DUARelDesc.constant) [ varg hole₁ ]) hole >>
autoUARelDesc n hole₁
tryEl : R.TC Unit
tryEl =
newMeta R.unknown >>= λ hole₁ →
R.unify (R.con (quote DUARelDesc.el) [ varg hole₁ ]) hole >>
autoUARelReindex n hole₁
tryBinary : R.Name → R.TC Unit
tryBinary name =
newMeta R.unknown >>= λ hole₁ →
newMeta R.unknown >>= λ hole₂ →
R.unify (R.con name (hole₁ v∷ hole₂ v∷ [])) hole >>
autoDUARelDesc n hole₁ >>
autoDUARelDesc n hole₂
tryProd = tryBinary (quote DUARelDesc.prod)
trySigma = tryBinary (quote DUARelDesc.sigma)
tryPi = tryBinary (quote DUARelDesc.pi)
tryPiˢ : R.TC Unit
tryPiˢ =
newMeta R.unknown >>= λ hole₁ →
newMeta R.unknown >>= λ hole₂ →
R.unify (R.con (quote DUARelDesc.piˢ) (hole₁ v∷ hole₂ v∷ [])) hole >>
autoSubstRelDesc n hole₁ >>
autoDUARelDesc n hole₂
useGeneric : R.TC Unit
useGeneric = R.unify (R.con (quote DUARelDesc.generic) []) hole
module DisplayedAutoMacro where
autoUARel : ∀ {ℓA} (A : Type ℓA) → ℕ → R.Term → R.TC Unit
autoUARel A n hole =
R.quoteTC A >>= λ `A` →
newMeta R.unknown >>= λ desc →
makeAuxiliaryDef "autoUA"
(R.def (quote UARel) (`A` v∷ R.unknown v∷ []))
(R.def (quote getUARel) [ varg desc ])
>>= λ uaTerm →
R.unify hole uaTerm >>
autoUARelDesc n desc
autoDUARel : ∀ {ℓA ℓ≅A ℓB} {A : Type ℓA} (𝒮-A : UARel A ℓ≅A) (B : A → Type ℓB)
→ ℕ → R.Term → R.TC Unit
autoDUARel 𝒮-A B n hole =
R.quoteTC 𝒮-A >>= λ `𝒮-A` →
R.quoteTC B >>= λ `B` →
newMeta R.unknown >>= λ desc →
makeAuxiliaryDef "autoDUA"
(R.def (quote DUARel) (`𝒮-A` v∷ `B` v∷ R.unknown v∷ []))
(R.def (quote getDUARel) [ varg desc ])
>>= λ duaTerm →
R.unify hole duaTerm >>
autoDUARelDesc n desc
macro
autoUARel : ∀ {ℓA} (A : Type ℓA) → R.Term → R.TC Unit
autoUARel A = DisplayedAutoMacro.autoUARel A FUEL
autoDUARel : ∀ {ℓA ℓ≅A ℓB} {A : Type ℓA} (𝒮-A : UARel A ℓ≅A) (B : A → Type ℓB)
→ R.Term → R.TC Unit
autoDUARel 𝒮-A B = DisplayedAutoMacro.autoDUARel 𝒮-A B FUEL
private
module Example (A : Type) (a₀ : A) where
example0 : DUARel (autoUARel Type) (λ X → X → A × X) ℓ-zero
example0 = autoDUARel _ _
example0' : {X Y : Type} (e : X ≃ Y)
(f : X → A × X) (g : Y → A × Y)
→ (∀ x → (f x .fst ≡ g (e .fst x) .fst) × (e .fst (f x .snd) ≡ g (e .fst x) .snd))
→ PathP (λ i → ua e i → A × ua e i) f g
example0' e f g = example0 .DUARel.uaᴰ f e g .fst
-- An example where a DUARel is parameterized over a pair of types
example1 : DUARel (autoUARel (Type × Type)) (λ (X , Z) → X → Z) ℓ-zero
example1 = autoDUARel _ _
example1' : {X Y : Type} (e : X ≃ Y) {Z W : Type} (h : Z ≃ W)
(f : X → Z) (g : Y → W)
→ (∀ x → h .fst (f x) ≡ g (e .fst x))
→ PathP (λ i → ua e i → ua h i) f g
example1' e h f g = example1 .DUARel.uaᴰ f (e , h) g .fst
-- An example where a DUARel is parameterized over a family of types
example2 : DUARel (autoUARel (A → Type)) (λ B → B a₀) ℓ-zero
example2 = autoDUARel _ _
example2' : {B C : A → Type} (e : (a : A) → B a ≃ C a)
(b : B a₀) (c : C a₀)
→ e a₀ .fst b ≡ c
→ PathP (λ i → ua (e a₀) i) b c
example2' e b c = example2 .DUARel.uaᴰ b e c .fst
|
The convex hull of a set $p$ is the set of all points that can be written as a convex combination of at most $d+1$ points of $p$, where $d$ is the affine dimension of $p$. |
SUBROUTINE decsf(x,y,zz,fi0,tet0,FI,TET,h)
! this program calculates fi and tet of a point in global coordinates from
! given x, y, z coordinates relatively the point fi0, tet0
REAL PI/3.1415926/, rz/6371./
PER=PI/180.
sqr=(rz-zz)*(rz-zz)-x*x-y*y
!write(*,*)' dz=',rz-sqrt(sqr)
if(sqr.lt.0.) then
write(*,*)' problem in DECSF:'
write(*,*)' x=',x,' y=',y,' zz=',zz
pause
end if
z=sqrt(sqr)
!write(*,*)' z=',z,'sqr=',sqr
X1=x
Y1=-Y*SIN(tet0*PER)+Z*COS(tet0*PER)
Z1=Y*COS(tet0*PER)+Z*SIN(tet0*PER)
!write(*,*)' x1=',x1,' y1=',y1,' z1=',z1
if(x1.eq.0.) then
fi=fi0
else
IF(X1.GT.0..AND.Y1.GT.0.)PA=0.
IF(X1.LT.0.)PA=-PI
IF(X1.GT.0..AND.Y1.LT.0.)PA=2.*PI
ff=atan(y1/x1)/per
FI=fi0-(ff+PA/PER)+90.
end if
!write(*,*)' fi=',fi
if(fi.gt.360.)fi=fi-360.
if(abs(fi-fi0).gt.abs(fi-fi0-360)) fi=fi-360
if(abs(fi-fi0).gt.abs(fi-fi0+360)) fi=fi+360
r=sqrt(x1*x1+y1*y1+z1*z1)
TET=ASIN(Z1/r)/PER
h=rz-r
RETURN
END
|
Load LFindLoad.
From lfind Require Import LFind.
From QuickChick Require Import QuickChick.
From adtind Require Import goal33.
Derive Show for natural.
Derive Arbitrary for natural.
Instance Dec_Eq_natural : Dec_Eq natural.
Proof. dec_eq. Qed.
Lemma conj28synthconj6 : forall (lv0 : natural) (lv1 : natural) (lv2 : natural), (@eq natural (Succ (plus (mult lv0 lv1) (plus lv1 lv0))) (plus lv2 (Succ lv0))).
Admitted.
QuickChick conj28synthconj6.
|
#include <iostream>
#include <stdio.h>
#include <cstring>
#include <cmath>
#include <fstream>
#include <string>
#include <regex>
#include <iterator>
#include <python3.7m/Python.h>
#include <boost/python.hpp>
#include <boost/python/numpy.hpp>
#include <boost/python/suite/indexing/vector_indexing_suite.hpp>
#include <boost/python/module.hpp>
#include <boost/python/def.hpp>
#include <boost/python/implicit.hpp>
#include <boost/python/extract.hpp>
#include <arpa/inet.h>
#include <netinet/in.h>
namespace p = boost::python;
namespace np = boost::python::numpy;
inline void destroyManagerCObject(PyObject *obj)
{
double *b = reinterpret_cast<double *>(PyCapsule_GetPointer(obj, NULL));
if (b)
{
delete[] b;
}
}
struct AdvParser
{
bool checkBase = true;
bool checkNodes = true;
bool shapeCreated = true;
int xnodes, ynodes, znodes;
double xbase, ybase, zbase;
AdvParser()
{
xnodes = 0;
ynodes = 0;
znodes = 0;
xbase = 0.0;
ybase = 0.0;
zbase = 0.0;
};
void setXnodes(int val) { this->xnodes = val; }
void setYnodes(int val) { this->ynodes = val; }
void setZnodes(int val) { this->znodes = val; }
void setXbase(int val) { this->xbase = val; }
void setYbase(int val) { this->ybase = val; }
void setZbase(int val) { this->zbase = val; }
int getXnodes() { return xnodes; }
int getYnodes() { return ynodes; }
int getZnodes() { return znodes; }
double getXbase() { return xbase; }
double getYbase() { return ybase; }
double getZbase() { return zbase; }
np::ndarray getOmfToList(std::string path)
{
// is a text file
std::ifstream miffile;
miffile.open(path, std::ios::out);
int buffer_size = getMifHeader(miffile);
int num_vectors = xnodes * ynodes * znodes;
double *fut_ndarray = (double *)(malloc(sizeof(double) * num_vectors * 3));
int i = 0;
if (miffile.is_open())
{
std::string line;
while (std::getline(miffile, line))
{
std::istringstream iss(line);
if (line[0] == '#')
continue;
else
{
double x, y, z;
if (!(iss >> x >> y >> z))
break;
fut_ndarray[i + 0] = x;
fut_ndarray[i + 1] = y;
fut_ndarray[i + 2] = z;
i += 3;
}
}
}
miffile.close();
boost::python::numpy::dtype dt1 = boost::python::numpy::dtype::get_builtin<double>();
boost::python::tuple shape = boost::python::make_tuple(num_vectors, 3);
boost::python::tuple stride = boost::python::make_tuple(3 * sizeof(double), sizeof(double));
boost::python::numpy::ndarray vectorData = boost::python::numpy::from_data(fut_ndarray,
dt1,
shape,
stride,
boost::python::object());
// last entry is object owner
return vectorData;
}
int getMifHeader(std::ifstream &miffile)
{
std::string line;
int buffer_size = 0;
std::string node_reg("# xnodes:");
std::string base_reg("# xbase:");
// we have to change strategy here
std::string data_text("# Begin: Data Text");
if (miffile.is_open())
{
while (std::getline(miffile, line))
{
if (line.at(0) == '#')
{
if (line == "# Begin: Data Binary 8")
{
buffer_size = 8;
break;
}
else if (line == "# Begin: Data Binary 4")
{
buffer_size = 4;
break;
}
else if (data_text.compare(line.substr(0, data_text.length())) == 0)
{
buffer_size = 1;
break;
}
if (checkNodes && line.substr(0, node_reg.length()) == node_reg)
{
if (node_reg.at(2) == 'x')
{
xnodes = std::stoi(line.substr(node_reg.length(), line.length()));
node_reg.at(2) = 'y';
}
else if (node_reg.at(2) == 'y')
{
ynodes = std::stoi(line.substr(node_reg.length(), line.length()));
node_reg.at(2) = 'z';
}
else
{
znodes = std::stoi(line.substr(node_reg.length(), line.length()));
checkNodes = false;
}
}
if (checkBase && line.substr(0, base_reg.length()) == base_reg)
{
if (base_reg.at(2) == 'x')
{
xbase = std::stod(line.substr(base_reg.length(), line.length()));
base_reg.at(2) = 'y';
}
else if (base_reg.at(2) == 'y')
{
ybase = std::stod(line.substr(base_reg.length(), line.length()));
base_reg.at(2) = 'z';
}
else
{
zbase = std::stod(line.substr(base_reg.length(), line.length()));
checkBase = false;
}
}
}
else
break;
}
if (buffer_size <= 0)
{
throw std::runtime_error("Invalid buffer size");
}
char IEEE_BUF[buffer_size + 1];
miffile.read(IEEE_BUF, buffer_size);
if (buffer_size == 4)
{
float IEEE_val;
float IEEE_VALIDATION = 1234567.0;
std::memcpy(&IEEE_val, IEEE_BUF, sizeof(float));
if (IEEE_val != IEEE_VALIDATION)
{
printf("%f\n", IEEE_val);
throw std::runtime_error("IEEE value not consistent");
}
}
else if (buffer_size == 8)
{
double IEEE_val;
double IEEE_VALIDATION = 123456789012345.0;
std::memcpy(&IEEE_val, IEEE_BUF, sizeof(double));
if (IEEE_val != IEEE_VALIDATION)
{
printf("%f\n", IEEE_val);
throw std::runtime_error("IEEE value not consistent");
}
}
else if (buffer_size == 1)
{
// this is a text file
// actaully I don't know what I should do here
}
else
{
throw std::runtime_error("Unspecified or invalid buffer size for binary input data");
}
return buffer_size;
}
else
{
throw std::runtime_error("Invalid mif file");
}
return 0;
}
void matrix_vector_mul(double mat[3][3], double vec[3])
{
// only 3 x 1, inplace
double c[3] = {vec[0], vec[1], vec[2]};
vec[0] = mat[0][0] * c[0] + mat[0][1] * c[1] + mat[0][2] * c[2];
vec[1] = mat[1][0] * c[0] + mat[1][1] * c[1] + mat[1][2] * c[2];
vec[2] = mat[2][0] * c[0] + mat[2][1] * c[1] + mat[2][2] * c[2];
}
void matrix_vector_cpy(double mat[3][3], double c[3], double vec[3])
{
// only 3 x 1, not inplace
vec[0] = mat[0][0] * c[0] + mat[0][1] * c[1] + mat[0][2] * c[2];
vec[1] = mat[1][0] * c[0] + mat[1][1] * c[1] + mat[1][2] * c[2];
vec[2] = mat[2][0] * c[0] + mat[2][1] * c[1] + mat[2][2] * c[2];
}
void a_cross_b(double a[3], double b[3], double c[3])
{
c[0] = a[1] * b[2] - a[2] * b[1];
c[1] = a[2] * b[0] - a[0] * b[2];
c[2] = a[0] * b[1] - a[1] * b[0];
}
void generateVBO(double *vbo,
int *offset,
int *normal_offset,
double position[3],
double vector[3], // from omf
double color[3], // from omf
double t_rotation[3][3],
double height,
double radius,
int resolution)
{
double height_operator[3] = {0, 0, height * 1.5};
double mag = sqrt(pow(vector[0], 2) +
pow(vector[1], 2) +
pow(vector[2], 2));
double phi = acos(vector[2] / mag); // z rot
double theta = atan2(vector[1], vector[0]); // y rot
double ct = cos(theta);
double st = sin(theta);
double cp = cos(phi);
double sp = sin(phi);
double rotation_matrix[3][3] = {
{ct, -st * cp, st * sp},
{st, cp * ct, -sp * ct},
{0, sp, cp}};
double origin_base[3], cpy[3];
double cyllinder_co_rot[3] = {radius, radius, 0};
double cone_co_rot[3] = {2 * radius, 2 * radius, 0};
std::memcpy(origin_base, position, sizeof(double) * 3);
double n[3], u[3], v[3];
int prev_off = 36;
for (int i = 0; i < (resolution - 1); i++)
{
// colors first
std::memcpy(vbo + *offset, color, sizeof(double) * 3);
std::memcpy(vbo + *offset + 9, color, sizeof(double) * 3);
std::memcpy(vbo + *offset + 18, color, sizeof(double) * 3);
std::memcpy(vbo + *offset + 27, color, sizeof(double) * 3);
// bottom triangle - cyllinder
matrix_vector_cpy(rotation_matrix, cyllinder_co_rot, cpy);
vbo[*offset + 3] = origin_base[0] + cpy[0];
vbo[*offset + 4] = origin_base[1] + cpy[1];
vbo[*offset + 5] = origin_base[2] + cpy[2];
// bottom triangle - cone
cone_co_rot[2] += height;
matrix_vector_cpy(rotation_matrix, cone_co_rot, cpy);
vbo[*offset + 6] = origin_base[0] + cpy[0];
vbo[*offset + 7] = origin_base[1] + cpy[1];
vbo[*offset + 8] = origin_base[2] + cpy[2];
// top triangle - cyllinder
cyllinder_co_rot[2] += height;
matrix_vector_cpy(rotation_matrix, cyllinder_co_rot, cpy);
vbo[*offset + 21] = origin_base[0] + cpy[0];
vbo[*offset + 22] = origin_base[1] + cpy[1];
vbo[*offset + 23] = origin_base[2] + cpy[2];
// top triangle - cone
matrix_vector_mul(rotation_matrix, height_operator);
vbo[*offset + 24] = origin_base[0] + height_operator[0];
vbo[*offset + 25] = origin_base[1] + height_operator[1];
vbo[*offset + 26] = origin_base[2] + height_operator[2];
height_operator[0] = 0;
height_operator[1] = 0;
height_operator[2] = 1.5 * height;
cyllinder_co_rot[2] -= height;
cone_co_rot[2] -= height;
matrix_vector_mul(t_rotation, cyllinder_co_rot);
matrix_vector_mul(t_rotation, cone_co_rot);
if (i > 0)
{
// firstly compute the later indices for vertex
// because we will use them to compute the normals
u[0] = vbo[*offset + 3] - vbo[*offset - prev_off + 3];
u[1] = vbo[*offset + 4] - vbo[*offset - prev_off + 4];
u[2] = vbo[*offset + 5] - vbo[*offset - prev_off + 5];
v[0] = vbo[*offset - prev_off + 21] - vbo[*offset - prev_off + 3];
v[1] = vbo[*offset - prev_off + 22] - vbo[*offset - prev_off + 4];
v[2] = vbo[*offset - prev_off + 23] - vbo[*offset - prev_off + 5];
// cross product
a_cross_b(u, v, n);
vbo[*normal_offset + 0] = n[0];
vbo[*normal_offset + 1] = n[1];
vbo[*normal_offset + 2] = n[2];
vbo[*normal_offset + 18] = n[0];
vbo[*normal_offset + 19] = n[1];
vbo[*normal_offset + 20] = n[2];
// normals to the cone triangle
u[0] = vbo[*offset + 6] - vbo[*offset - prev_off + 6];
u[1] = vbo[*offset + 7] - vbo[*offset - prev_off + 7];
u[2] = vbo[*offset + 8] - vbo[*offset - prev_off + 8];
v[0] = vbo[*offset - prev_off + 24] - vbo[*offset - prev_off + 6];
v[1] = vbo[*offset - prev_off + 25] - vbo[*offset - prev_off + 7];
v[2] = vbo[*offset - prev_off + 26] - vbo[*offset - prev_off + 8];
// cross product
a_cross_b(u, v, n);
vbo[*normal_offset + 3] = n[0];
vbo[*normal_offset + 4] = n[1];
vbo[*normal_offset + 5] = n[2];
vbo[*normal_offset + 21] = n[0];
vbo[*normal_offset + 22] = n[1];
vbo[*normal_offset + 23] = n[2];
*normal_offset += 18;
*normal_offset += 18;
}
*offset += prev_off;
}
// colors first
std::memcpy(vbo + *offset, color, sizeof(double) * 3);
std::memcpy(vbo + *offset + 9, color, sizeof(double) * 3);
std::memcpy(vbo + *offset + 18, color, sizeof(double) * 3);
std::memcpy(vbo + *offset + 27, color, sizeof(double) * 3);
// reset rotational vectors to their defaults
cyllinder_co_rot[0] = radius;
cyllinder_co_rot[1] = radius;
cyllinder_co_rot[2] = 0;
matrix_vector_mul(rotation_matrix, cyllinder_co_rot);
vbo[*offset + 3] = origin_base[0] + cyllinder_co_rot[0];
vbo[*offset + 4] = origin_base[1] + cyllinder_co_rot[1];
vbo[*offset + 5] = origin_base[2] + cyllinder_co_rot[2];
cone_co_rot[0] = 2 * radius;
cone_co_rot[1] = 2 * radius;
cone_co_rot[2] = height;
matrix_vector_mul(rotation_matrix, cone_co_rot);
vbo[*offset + 6] = origin_base[0] + cone_co_rot[0];
vbo[*offset + 7] = origin_base[1] + cone_co_rot[1];
vbo[*offset + 8] = origin_base[2] + cone_co_rot[2];
cyllinder_co_rot[0] = radius;
cyllinder_co_rot[1] = radius;
cyllinder_co_rot[2] += height;
matrix_vector_mul(rotation_matrix, cyllinder_co_rot);
vbo[*offset + 21] = origin_base[0] + cyllinder_co_rot[0];
vbo[*offset + 22] = origin_base[1] + cyllinder_co_rot[1];
vbo[*offset + 23] = origin_base[2] + cyllinder_co_rot[2];
height_operator[0] = 0;
height_operator[1] = 0;
height_operator[2] = 1.5 * height;
matrix_vector_mul(rotation_matrix, height_operator);
vbo[*offset + 24] = origin_base[0] + height_operator[0];
vbo[*offset + 25] = origin_base[1] + height_operator[1];
vbo[*offset + 26] = origin_base[2] + height_operator[2];
// normals to the cyllinder triangle
u[0] = vbo[*offset + 3] - vbo[*offset - prev_off + 3];
u[1] = vbo[*offset + 4] - vbo[*offset - prev_off + 4];
u[2] = vbo[*offset + 5] - vbo[*offset - prev_off + 5];
v[0] = vbo[*offset - prev_off + 21] - vbo[*offset - prev_off + 3];
v[1] = vbo[*offset - prev_off + 22] - vbo[*offset - prev_off + 4];
v[2] = vbo[*offset - prev_off + 23] - vbo[*offset - prev_off + 5];
// cross product
a_cross_b(u, v, n);
vbo[*normal_offset + 0] = n[0];
vbo[*normal_offset + 1] = n[1];
vbo[*normal_offset + 2] = n[2];
vbo[*normal_offset + 18] = n[0];
vbo[*normal_offset + 19] = n[1];
vbo[*normal_offset + 20] = n[2];
// normals to the cone triangle
u[0] = vbo[*offset + 6] - vbo[*offset - prev_off + 6];
u[1] = vbo[*offset + 7] - vbo[*offset - prev_off + 7];
u[2] = vbo[*offset + 8] - vbo[*offset - prev_off + 8];
v[0] = vbo[*offset - prev_off + 24] - vbo[*offset - prev_off + 6];
v[1] = vbo[*offset - prev_off + 25] - vbo[*offset - prev_off + 7];
v[2] = vbo[*offset - prev_off + 26] - vbo[*offset - prev_off + 8];
// cross product
a_cross_b(u, v, n);
vbo[*normal_offset + 3] = n[0];
vbo[*normal_offset + 4] = n[1];
vbo[*normal_offset + 5] = n[2];
vbo[*normal_offset + 21] = n[0];
vbo[*normal_offset + 22] = n[1];
vbo[*normal_offset + 23] = n[2];
*normal_offset += 18;
*normal_offset += 18;
// LAST NORMALS MUST CATCH UP and are the same as previous
vbo[*normal_offset + 0] = n[0];
vbo[*normal_offset + 1] = n[1];
vbo[*normal_offset + 2] = n[2];
vbo[*normal_offset + 3] = n[0];
vbo[*normal_offset + 4] = n[1];
vbo[*normal_offset + 5] = n[2];
*normal_offset += 18;
vbo[*normal_offset + 0] = n[0];
vbo[*normal_offset + 1] = n[1];
vbo[*normal_offset + 2] = n[2];
vbo[*normal_offset + 3] = n[0];
vbo[*normal_offset + 4] = n[1];
vbo[*normal_offset + 5] = n[2];
*normal_offset += 18;
*offset += prev_off;
}
void generateCubes2(double *sh, double position[3], double dimensions[3], int current_pos)
{
double arr[144] = {
//TOP FACE
position[0] + dimensions[0], position[1], position[2] + dimensions[2],
0, 0, 0,
position[0], position[1], position[2] + dimensions[2],
0, 0, 0,
position[0], position[1] + dimensions[1], position[2] + dimensions[2],
0, 0, 0,
position[0] + dimensions[0], position[1] + dimensions[1], position[2] + dimensions[2],
0, 0, 0,
//BOTTOM FACE
position[0] + dimensions[0], position[1], position[2],
0, 0, 0,
position[0], position[1], position[2],
0, 0, 0,
position[0], position[1] + dimensions[1], position[2],
0, 0, 0,
position[0] + dimensions[0], position[1] + dimensions[1], position[2],
0, 0, 0,
//FRONT FACE
position[0] + dimensions[0], position[1] + dimensions[1], position[2] + dimensions[2],
0, 0, 0,
position[0], position[1] + dimensions[1], position[2] + dimensions[2],
0, 0, 0,
position[0], position[1] + dimensions[1], position[2],
0, 0, 0,
position[0] + dimensions[0], position[1] + dimensions[1], position[2],
0, 0, 0,
//BACK FACE
position[0] + dimensions[0], position[1], position[2] + dimensions[2],
0, 0, 0,
position[0], position[1], position[2] + dimensions[2],
0, 0, 0,
position[0], position[1], position[2],
0, 0, 0,
position[0] + dimensions[0], position[1], position[2],
0, 0, 0,
//RIGHT FACE
position[0] + dimensions[0], position[1], position[2] + dimensions[2],
0, 0, 0,
position[0] + dimensions[0], position[1] + dimensions[1], position[2] + dimensions[2],
0, 0, 0,
position[0] + dimensions[0], position[1] + dimensions[1], position[2],
0, 0, 0,
position[0] + dimensions[0], position[1], position[2],
0, 0, 0,
//LEFT FACE
position[0], position[1] + dimensions[1], position[2] + dimensions[2],
0, 0, 0,
position[0], position[1], position[2] + dimensions[2],
0, 0, 0,
position[0], position[1], position[2],
0, 0, 0,
position[0], position[1] + dimensions[1], position[2],
0, 0, 0};
// normals here
double ux, uy, uz;
double vx, vy, vz;
int offset = 0;
for (int i = 0; i < 6; i++)
{
ux = arr[offset + 0] - arr[offset + 6]; // first vertex
uy = arr[offset + 1] - arr[offset + 7];
uz = arr[offset + 2] - arr[offset + 8];
vx = arr[offset + 0] - arr[offset + 12]; // second vertex
vy = arr[offset + 1] - arr[offset + 13];
vz = arr[offset + 2] - arr[offset + 14];
// cross product
for (int j = 0; j < 4; j++)
{
arr[offset + 3 + j * 6 + 0] = uy * vz - vy * uz;
arr[offset + 3 + j * 6 + 1] = ux * uz - vx - vz;
arr[offset + 3 + j * 6 + 2] = ux * vy - uy * vx;
}
offset += 24;
}
std::memcpy(sh + current_pos, arr, sizeof(double) * 144);
}
np::ndarray generateIndices(int N, int index_required)
{
int start_index = 0;
int *indices = (int *)malloc(sizeof(int) * (3 * (index_required - 2) * N));
for (int n = 0; n < N; n++)
{
start_index = n * index_required + 3;
for (int i = 0; i < (index_required - 2); i++)
{
indices[n * (index_required - 2) * 3 + i * 3 + 0] = start_index + i - 3;
indices[n * (index_required - 2) * 3 + i * 3 + 1] = start_index + i - 2;
indices[n * (index_required - 2) * 3 + i * 3 + 2] = start_index + i - 1;
}
}
np::dtype dt = np::dtype::get_builtin<int>();
p::tuple shape = p::make_tuple(3 * (index_required - 2) * N);
p::tuple stride = p::make_tuple(sizeof(int));
p::handle<> h(::PyCapsule_New((void *)indices,
NULL,
(PyCapsule_Destructor)&destroyManagerCObject));
return np::from_data(indices,
dt,
shape,
stride,
p::object(h));
}
np::ndarray getCubeOutline(int xn, int yn, int zn,
double xb, double yb, double zb,
int sampling,
int start_layer, int stop_layer)
{
/*
Cube MIF OUTLINE
2 VBOs because the geometry is constant
1) Geometry + Normal VBO
2) Color VBO
*/
int per_vertex = 144;
// per_vertex = 72;
double *sh = (double *)(malloc(sizeof(double) * xn * yn * zn * per_vertex));
double dimensions[3] = {xb * sampling, yb * sampling, zb};
int current_pos = 0;
for (int z = start_layer; z < stop_layer; z += 1)
{
for (int y = 0; y < ynodes; y += sampling)
{
for (int x = 0; x < xnodes; x += sampling)
{
double position[3] = {xb * (x % xn) - xn * xb / 2,
yb * (y % yn) - yn * yb / 2,
zb * (z % zn) - zn * zb / 2};
generateCubes2(sh, position, dimensions, current_pos);
current_pos += per_vertex;
}
}
}
np::dtype dt = np::dtype::get_builtin<double>();
p::tuple shape = p::make_tuple(xn * yn * zn * per_vertex);
p::tuple stride = p::make_tuple(sizeof(double));
p::handle<> h(::PyCapsule_New((void *)sh,
NULL,
(PyCapsule_Destructor)&destroyManagerCObject));
return np::from_data(sh,
dt,
shape,
stride,
p::object(h));
}
void getHeader(std::string filepath)
{
std::ifstream miffile;
miffile.open(filepath, std::ios::out | std::ios_base::binary);
getMifHeader(miffile);
miffile.close();
}
np::ndarray getShapeAsNdarray(double xb, double yb, double zb)
{
double *sh = (double *)(malloc(sizeof(double) * xnodes * ynodes * znodes * 3));
int current_pos = 0;
for (int z = 0; z < znodes; z++)
{
for (int y = 0; y < ynodes; y++)
{
for (int x = 0; x < xnodes; x++)
{
sh[current_pos + 0] = xb * (x % xnodes) - xnodes * xb / 2;
sh[current_pos + 1] = yb * (y % ynodes) - ynodes * yb / 2;
sh[current_pos + 2] = zb * (z % znodes) - znodes * zb / 2;
current_pos += 3;
}
}
}
np::dtype dt = np::dtype::get_builtin<double>();
p::tuple shape = p::make_tuple(current_pos);
p::tuple stride = p::make_tuple(sizeof(double));
p::handle<> h(::PyCapsule_New((void *)sh,
NULL,
(PyCapsule_Destructor)&destroyManagerCObject));
return np::from_data(sh,
dt,
shape,
stride,
p::object(h));
}
np::ndarray getMifAsNdarrayWithColor(std::string path,
p::list color_vector_l,
p::list positive_color_l,
p::list negative_color_l,
int sampling,
int start_layer,
int stop_layer,
int binary)
{
double color_vector[3] = {
p ::extract<double>(color_vector_l[0]),
p ::extract<double>(color_vector_l[1]),
p ::extract<double>(color_vector_l[2])};
double positive_color[3] = {
p ::extract<double>(positive_color_l[0]),
p ::extract<double>(positive_color_l[1]),
p ::extract<double>(positive_color_l[2])};
double negative_color[3] = {
p ::extract<double>(negative_color_l[0]),
p ::extract<double>(negative_color_l[1]),
p ::extract<double>(negative_color_l[2])};
std::ifstream miffile;
std::ios::openmode openmod;
if (binary)
{
openmod = std::ios::out | std::ios_base::binary;
}
else
{
openmod = std::ios::out;
}
miffile.open(path, openmod);
int buffer_size = getMifHeader(miffile);
if (buffer_size == 0)
{
miffile.close();
throw std::runtime_error("Invalid mif/ovf file");
}
int lines = znodes * xnodes * ynodes;
double *vals;
vals = (double *)malloc(sizeof(double) * lines * 3);
if (buffer_size == 4)
{
char buffer[buffer_size * lines * 3];
miffile.read(buffer, buffer_size * lines * 3);
float fvals[lines * 3];
std::memcpy(fvals, buffer, lines * 3 * sizeof(float));
for (int i = 0; i < lines * 3; i++)
{
vals[i] = fvals[i];
}
}
else if (buffer_size == 8)
{
char buffer[buffer_size * lines * 3];
miffile.read(buffer, buffer_size * lines * 3);
vals = (double *)(buffer);
}
else if (buffer_size == 1)
{
int i = 0;
if (miffile.is_open())
{
std::string line;
while (std::getline(miffile, line))
{
std::istringstream iss(line);
if (line[0] == '#')
continue;
else
{
double x, y, z;
if (!(iss >> x >> y >> z))
break;
vals[i + 0] = x;
vals[i + 1] = y;
vals[i + 2] = z;
i += 3;
}
}
}
}
miffile.close();
int inflate = 24; // 24 vetrtivesd in a cube
double *fut_ndarray = (double *)(malloc(sizeof(double) * znodes * xnodes * ynodes * 3 * inflate));
double mag, dot;
double *array_to_cpy = (double *)(malloc(sizeof(double) * 3));
int offset = 0;
int index = 0;
for (int z = start_layer; z < stop_layer; z += 1)
{
for (int y = 0; y < ynodes; y += sampling)
{
for (int x = 0; x < xnodes; x += sampling)
{
index = 3 * (x + xnodes * y + xnodes * ynodes * z);
mag = sqrt(pow(vals[index + 0], 2) +
pow(vals[index + 1], 2) +
pow(vals[index + 2], 2));
if (mag != 0.0)
{
dot = (vals[index + 0] / mag) * color_vector[0] +
(vals[index + 1] / mag) * color_vector[1] +
(vals[index + 2] / mag) * color_vector[2];
if (dot > 0)
{
array_to_cpy[0] = positive_color[0] * dot + (1.0 - dot);
array_to_cpy[1] = positive_color[1] * dot + (1.0 - dot);
array_to_cpy[2] = positive_color[2] * dot + (1.0 - dot);
}
else
{
dot *= -1;
array_to_cpy[0] = negative_color[0] * dot + (1.0 - dot);
array_to_cpy[1] = negative_color[1] * dot + (1.0 - dot);
array_to_cpy[2] = negative_color[2] * dot + (1.0 - dot);
}
}
else
{
array_to_cpy[0] = 0.0;
array_to_cpy[1] = 0.0;
array_to_cpy[2] = 0.0;
}
for (int inf = 0; inf < inflate; inf++)
{
std::memcpy(fut_ndarray + offset, array_to_cpy, sizeof(double) * 3);
offset += 3;
}
}
}
}
np::dtype dt = np::dtype::get_builtin<double>();
p::tuple shape = p::make_tuple(offset);
p::tuple stride = p::make_tuple(sizeof(double));
p::handle<> h(::PyCapsule_New((void *)fut_ndarray,
NULL,
(PyCapsule_Destructor)&destroyManagerCObject));
return np::from_data(fut_ndarray,
dt,
shape,
stride,
p::object(h));
}
np::ndarray getMifVBO(std::string path,
int resolution,
p::list color_vector_l,
p::list positive_color_l,
p::list negative_color_l,
int sampling,
double height,
double radius,
int start_layer,
int stop_layer,
int xscaler,
int yscaler,
int zscaler,
int binary)
{
if (start_layer < 0 || start_layer > stop_layer)
{
throw std::invalid_argument("Start layer cannot be smaller than stop layer");
}
if (stop_layer > znodes)
{
throw std::invalid_argument("Stop layer too large");
}
double color_vector[3] = {
p ::extract<double>(color_vector_l[0]),
p ::extract<double>(color_vector_l[1]),
p ::extract<double>(color_vector_l[2])};
double positive_color[3] = {
p ::extract<double>(positive_color_l[0]),
p ::extract<double>(positive_color_l[1]),
p ::extract<double>(positive_color_l[2])};
double negative_color[3] = {
p ::extract<double>(negative_color_l[0]),
p ::extract<double>(negative_color_l[1]),
p ::extract<double>(negative_color_l[2])};
std::ifstream miffile;
std::ios::openmode openmod;
if (binary)
{
openmod = std::ios::out | std::ios_base::binary;
}
else
{
openmod = std::ios::out;
}
miffile.open(path, openmod);
int buffer_size = getMifHeader(miffile);
if (buffer_size == 0)
{
miffile.close();
throw std::runtime_error("Invalid mif/ovf file");
}
int lines = znodes * xnodes * ynodes;
double *vals;
vals = (double *)malloc(sizeof(double) * lines * 3);
if (buffer_size == 4)
{
char buffer[buffer_size * lines * 3];
miffile.read(buffer, buffer_size * lines * 3);
float fvals[lines * 3];
std::memcpy(fvals, buffer, lines * 3 * sizeof(float));
for (int i = 0; i < lines * 3; i++)
{
vals[i] = fvals[i];
}
}
else if (buffer_size == 8)
{
char buffer[buffer_size * lines * 3];
miffile.read(buffer, buffer_size * lines * 3);
// research why this casting with memcpy causes SIGSEV
// std::memcpy(vals, buffer, lines * 3 * sizeof(double));
vals = (double *)(buffer);
}
else if (buffer_size == 1)
{
int i = 0;
if (miffile.is_open())
{
std::string line;
while (std::getline(miffile, line))
{
std::istringstream iss(line);
if (line[0] == '#')
continue;
else
{
double x, y, z;
if (!(iss >> x >> y >> z))
break;
vals[i + 0] = x;
vals[i + 1] = y;
vals[i + 2] = z;
i += 3;
}
}
}
}
miffile.close();
int size = xnodes * ynodes * znodes * resolution * 10 * 3;
double *fut_ndarray = (double *)(malloc(sizeof(double) * size));
// double fut_ndarray[size];
if (fut_ndarray == NULL)
{
throw std::runtime_error("Failed to allocate memory for a large array");
}
double pos[3], vec[3], col[3];
double mag, dot;
int offset = 0;
int index = 0;
int normal_offset = 12;
double theta = 2 * M_PI / resolution;
double c = cos(theta);
double s = sin(theta);
double t_rotation[3][3] = {
{c, -s, 0},
{s, c, 0},
{0, 0, 1}};
double xb = xscaler * 1e9 * xbase / sampling;
double yb = yscaler * 1e9 * ybase / sampling;
double zb = zscaler * 1e9 * zbase / sampling;
double xoffset = xnodes * xb / 2;
double yoffset = ynodes * yb / 2;
double zoffset = znodes * zb / 2;
for (int z = start_layer; z < stop_layer; z += 1)
{
for (int y = 0; y < ynodes; y += sampling)
{
for (int x = 0; x < xnodes; x += sampling)
{
index = 3 * (x + xnodes * y + xnodes * ynodes * z);
mag = sqrt(pow(vals[index + 0], 2) +
pow(vals[index + 1], 2) +
pow(vals[index + 2], 2));
if (mag == 0.0)
continue;
pos[0] = xb * (x % xnodes) - xoffset;
pos[1] = yb * (y % ynodes) - yoffset;
pos[2] = zb * (z % znodes) - zoffset;
vec[0] = vals[index + 0] / mag;
vec[1] = vals[index + 1] / mag;
vec[2] = vals[index + 2] / mag;
dot = vec[0] * color_vector[0] +
vec[1] * color_vector[1] +
vec[2] * color_vector[2];
if (dot > 0)
{
col[0] = positive_color[0] * dot + (1.0 - dot);
col[1] = positive_color[1] * dot + (1.0 - dot);
col[2] = positive_color[2] * dot + (1.0 - dot);
}
else
{
dot *= -1;
col[0] = negative_color[0] * dot + (1.0 - dot);
col[1] = negative_color[1] * dot + (1.0 - dot);
col[2] = negative_color[2] * dot + (1.0 - dot);
}
generateVBO(
fut_ndarray,
&offset,
&normal_offset,
pos,
vec,
col,
t_rotation,
height,
radius,
resolution);
}
}
}
np::dtype dt = np::dtype::get_builtin<double>();
p::tuple shape = p::make_tuple(offset);
p::tuple stride = p::make_tuple(sizeof(double));
p::handle<> h(::PyCapsule_New((void *)fut_ndarray,
NULL,
(PyCapsule_Destructor)&destroyManagerCObject));
return np::from_data(fut_ndarray,
dt,
shape,
stride,
p::object(h));
}
np::ndarray getMifAsNdarray(std::string path)
{
std::ifstream miffile;
miffile.open(path, std::ios::out | std::ios_base::binary);
int buffer_size = getMifHeader(miffile);
if (buffer_size == 0)
{
miffile.close();
throw std::runtime_error("Invalid mif file");
}
int lines = znodes * xnodes * ynodes;
char buffer[buffer_size * lines * 3];
miffile.read(buffer, buffer_size * lines * 3);
double *vals = (double *)buffer;
double *fut_ndarray = (double *)(malloc(sizeof(double) * lines * 3));
double mag;
for (int i = 0; i < lines * 3; i += 3)
{
mag = sqrt(pow(vals[i + 0], 2) + pow(vals[i + 1], 2) + pow(vals[i + 2], 2));
if (mag == 0.0)
mag = 1.0;
fut_ndarray[i + 0] = vals[i + 0] / mag;
fut_ndarray[i + 1] = vals[i + 1] / mag;
fut_ndarray[i + 2] = vals[i + 2] / mag;
}
miffile.close();
// use explicit namespace here to make sure it does not mix the functions
np::dtype dt1 = np::dtype::get_builtin<double>();
p::tuple shape = p::make_tuple(lines, 3);
p::tuple stride = p::make_tuple(3 * sizeof(double), sizeof(double));
p::handle<> h(::PyCapsule_New((void *)fut_ndarray,
NULL,
(PyCapsule_Destructor)&destroyManagerCObject));
np::ndarray vectorData = np::from_data(fut_ndarray,
dt1,
shape,
stride,
p::object(h));
// last entry is object owner
return vectorData;
}
};
BOOST_PYTHON_MODULE(AdvParser)
{
// avoids the SIGSEV on dtype in numpy initialization
boost::python::numpy::initialize();
using namespace boost::python;
class_<AdvParser>("AdvParser")
.def(init<>())
.def(init<AdvParser>())
.def("getMifAsNdarrayWithColor", &AdvParser::getMifAsNdarrayWithColor)
.def("getMifVBO", &AdvParser::getMifVBO)
.def("getCubeOutline", &AdvParser::getCubeOutline)
.def("getOmfToList", &AdvParser::getOmfToList)
.def("getMifAsNdarray", &AdvParser::getMifAsNdarray)
.def("getHeader", &AdvParser::getHeader)
.def("getShapeAsNdarray", &AdvParser::getShapeAsNdarray)
.def("generateIndices", &AdvParser::generateIndices)
.add_property("xnodes", &AdvParser::getXnodes, &AdvParser::setXnodes)
.add_property("ynodes", &AdvParser::getYnodes, &AdvParser::setYnodes)
.add_property("znodes", &AdvParser::getZnodes, &AdvParser::setZnodes)
.add_property("xbase", &AdvParser::getXbase, &AdvParser::setXbase)
.add_property("ybase", &AdvParser::getYbase, &AdvParser::setYbase)
.add_property("zbase", &AdvParser::getZbase, &AdvParser::setZbase);
}
|
#ifndef TAG_TYPES_4NNM8B5T
#define TAG_TYPES_4NNM8B5T
// Copyright 2010 Dean Michael Berris.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <boost/mpl/vector.hpp>
#include <boost/network/protocol/http/tags.hpp>
namespace http = boost::network::http;
typedef boost::mpl::vector<http::tags::http_default_8bit_tcp_resolve,
http::tags::http_default_8bit_udp_resolve,
http::tags::http_keepalive_8bit_tcp_resolve,
http::tags::http_keepalive_8bit_udp_resolve,
http::tags::http_async_8bit_udp_resolve,
http::tags::http_async_8bit_tcp_resolve> tag_types;
#endif /* TAG_TYPES_4NNM8B5T */
|
/-
Copyright (c) 2022 Antoine Labelle. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Antoine Labelle
! This file was ported from Lean 3 source module category_theory.monoidal.subcategory
! leanprover-community/mathlib commit 70fd9563a21e7b963887c9360bd29b2393e6225a
! Please do not edit these lines, except to modify the commit id
! if you have ported upstream changes.
-/
import Mathbin.CategoryTheory.Monoidal.Braided
import Mathbin.CategoryTheory.Monoidal.Linear
import Mathbin.CategoryTheory.Preadditive.AdditiveFunctor
import Mathbin.CategoryTheory.Linear.LinearFunctor
import Mathbin.CategoryTheory.Closed.Monoidal
/-!
# Full monoidal subcategories
Given a monidal category `C` and a monoidal predicate on `C`, that is a function `P : C → Prop`
closed under `𝟙_` and `⊗`, we can put a monoidal structure on `{X : C // P X}` (the category
structure is defined in `category_theory.full_subcategory`).
When `C` is also braided/symmetric, the full monoidal subcategory also inherits the
braided/symmetric structure.
## TODO
* Add monoidal/braided versions of `category_theory.full_subcategory.lift`
-/
universe u v
namespace CategoryTheory
namespace MonoidalCategory
open Iso
variable {C : Type u} [Category.{v} C] [MonoidalCategory C] (P : C → Prop)
/- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
/-- A property `C → Prop` is a monoidal predicate if it is closed under `𝟙_` and `⊗`.
-/
class MonoidalPredicate : Prop where
prop_id' : P (𝟙_ C) := by obviously
prop_tensor' : ∀ {X Y}, P X → P Y → P (X ⊗ Y) := by obviously
#align category_theory.monoidal_category.monoidal_predicate CategoryTheory.MonoidalCategory.MonoidalPredicate
restate_axiom monoidal_predicate.prop_id'
restate_axiom monoidal_predicate.prop_tensor'
open MonoidalPredicate
variable [MonoidalPredicate P]
/- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
/- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
/- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
/- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
/--
When `P` is a monoidal predicate, the full subcategory for `P` inherits the monoidal structure of
`C`.
-/
instance fullMonoidalSubcategory : MonoidalCategory (FullSubcategory P)
where
tensorObj X Y := ⟨X.1 ⊗ Y.1, prop_tensor X.2 Y.2⟩
tensorHom X₁ Y₁ X₂ Y₂ f g := by
change X₁.1 ⊗ X₂.1 ⟶ Y₁.1 ⊗ Y₂.1
change X₁.1 ⟶ Y₁.1 at f
change X₂.1 ⟶ Y₂.1 at g
exact f ⊗ g
tensorUnit := ⟨𝟙_ C, prop_id⟩
associator X Y Z :=
⟨(α_ X.1 Y.1 Z.1).Hom, (α_ X.1 Y.1 Z.1).inv, hom_inv_id (α_ X.1 Y.1 Z.1),
inv_hom_id (α_ X.1 Y.1 Z.1)⟩
leftUnitor X := ⟨(λ_ X.1).Hom, (λ_ X.1).inv, hom_inv_id (λ_ X.1), inv_hom_id (λ_ X.1)⟩
rightUnitor X := ⟨(ρ_ X.1).Hom, (ρ_ X.1).inv, hom_inv_id (ρ_ X.1), inv_hom_id (ρ_ X.1)⟩
tensor_id' X Y := tensor_id X.1 Y.1
tensor_comp' X₁ Y₁ Z₁ X₂ Y₂ Z₂ f₁ f₂ g₁ g₂ := tensor_comp f₁ f₂ g₁ g₂
associator_naturality' X₁ X₂ X₃ Y₁ Y₂ Y₃ f₁ f₂ f₃ := associator_naturality f₁ f₂ f₃
leftUnitor_naturality' X Y f := leftUnitor_naturality f
rightUnitor_naturality' X Y f := rightUnitor_naturality f
pentagon' W X Y Z := pentagon W.1 X.1 Y.1 Z.1
triangle' X Y := triangle X.1 Y.1
#align category_theory.monoidal_category.full_monoidal_subcategory CategoryTheory.MonoidalCategory.fullMonoidalSubcategory
/-- The forgetful monoidal functor from a full monoidal subcategory into the original category
("forgetting" the condition).
-/
@[simps]
def fullMonoidalSubcategoryInclusion : MonoidalFunctor (FullSubcategory P) C
where
toFunctor := fullSubcategoryInclusion P
ε := 𝟙 _
μ X Y := 𝟙 _
#align category_theory.monoidal_category.full_monoidal_subcategory_inclusion CategoryTheory.MonoidalCategory.fullMonoidalSubcategoryInclusion
instance fullMonoidalSubcategory.full : Full (fullMonoidalSubcategoryInclusion P).toFunctor :=
FullSubcategory.full P
#align category_theory.monoidal_category.full_monoidal_subcategory.full CategoryTheory.MonoidalCategory.fullMonoidalSubcategory.full
instance fullMonoidalSubcategory.faithful :
Faithful (fullMonoidalSubcategoryInclusion P).toFunctor :=
FullSubcategory.faithful P
#align category_theory.monoidal_category.full_monoidal_subcategory.faithful CategoryTheory.MonoidalCategory.fullMonoidalSubcategory.faithful
section
variable [Preadditive C]
instance fullMonoidalSubcategoryInclusion_additive :
(fullMonoidalSubcategoryInclusion P).toFunctor.Additive :=
Functor.fullSubcategoryInclusion_additive _
#align category_theory.monoidal_category.full_monoidal_subcategory_inclusion_additive CategoryTheory.MonoidalCategory.fullMonoidalSubcategoryInclusion_additive
instance [MonoidalPreadditive C] : MonoidalPreadditive (FullSubcategory P) :=
monoidalPreadditive_of_faithful (fullMonoidalSubcategoryInclusion P)
variable (R : Type _) [Ring R] [Linear R C]
instance fullMonoidalSubcategoryInclusion_linear :
(fullMonoidalSubcategoryInclusion P).toFunctor.Linear R :=
Functor.fullSubcategoryInclusionLinear R _
#align category_theory.monoidal_category.full_monoidal_subcategory_inclusion_linear CategoryTheory.MonoidalCategory.fullMonoidalSubcategoryInclusion_linear
instance [MonoidalPreadditive C] [MonoidalLinear R C] : MonoidalLinear R (FullSubcategory P) :=
monoidalLinearOfFaithful R (fullMonoidalSubcategoryInclusion P)
end
variable {P} {P' : C → Prop} [MonoidalPredicate P']
/-- An implication of predicates `P → P'` induces a monoidal functor between full monoidal
subcategories. -/
@[simps]
def fullMonoidalSubcategory.map (h : ∀ ⦃X⦄, P X → P' X) :
MonoidalFunctor (FullSubcategory P) (FullSubcategory P')
where
toFunctor := FullSubcategory.map h
ε := 𝟙 _
μ X Y := 𝟙 _
#align category_theory.monoidal_category.full_monoidal_subcategory.map CategoryTheory.MonoidalCategory.fullMonoidalSubcategory.map
instance fullMonoidalSubcategory.mapFull (h : ∀ ⦃X⦄, P X → P' X) :
Full (fullMonoidalSubcategory.map h).toFunctor where preimage X Y f := f
#align category_theory.monoidal_category.full_monoidal_subcategory.map_full CategoryTheory.MonoidalCategory.fullMonoidalSubcategory.mapFull
instance fullMonoidalSubcategory.map_faithful (h : ∀ ⦃X⦄, P X → P' X) :
Faithful (fullMonoidalSubcategory.map h).toFunctor where
#align category_theory.monoidal_category.full_monoidal_subcategory.map_faithful CategoryTheory.MonoidalCategory.fullMonoidalSubcategory.map_faithful
section Braided
variable (P) [BraidedCategory C]
/-- The braided structure on a full subcategory inherited by the braided structure on `C`.
-/
instance fullBraidedSubcategory : BraidedCategory (FullSubcategory P) :=
braidedCategoryOfFaithful (fullMonoidalSubcategoryInclusion P)
(fun X Y =>
⟨(β_ X.1 Y.1).Hom, (β_ X.1 Y.1).inv, (β_ X.1 Y.1).hom_inv_id, (β_ X.1 Y.1).inv_hom_id⟩)
fun X Y => by tidy
#align category_theory.monoidal_category.full_braided_subcategory CategoryTheory.MonoidalCategory.fullBraidedSubcategory
/-- The forgetful braided functor from a full braided subcategory into the original category
("forgetting" the condition).
-/
@[simps]
def fullBraidedSubcategoryInclusion : BraidedFunctor (FullSubcategory P) C
where
toMonoidalFunctor := fullMonoidalSubcategoryInclusion P
braided' X Y := by
rw [is_iso.eq_inv_comp]
tidy
#align category_theory.monoidal_category.full_braided_subcategory_inclusion CategoryTheory.MonoidalCategory.fullBraidedSubcategoryInclusion
instance fullBraidedSubcategory.full : Full (fullBraidedSubcategoryInclusion P).toFunctor :=
fullMonoidalSubcategory.full P
#align category_theory.monoidal_category.full_braided_subcategory.full CategoryTheory.MonoidalCategory.fullBraidedSubcategory.full
instance fullBraidedSubcategory.faithful : Faithful (fullBraidedSubcategoryInclusion P).toFunctor :=
fullMonoidalSubcategory.faithful P
#align category_theory.monoidal_category.full_braided_subcategory.faithful CategoryTheory.MonoidalCategory.fullBraidedSubcategory.faithful
variable {P}
/-- An implication of predicates `P → P'` induces a braided functor between full braided
subcategories. -/
@[simps]
def fullBraidedSubcategory.map (h : ∀ ⦃X⦄, P X → P' X) :
BraidedFunctor (FullSubcategory P) (FullSubcategory P')
where
toMonoidalFunctor := fullMonoidalSubcategory.map h
braided' X Y := by
rw [is_iso.eq_inv_comp]
tidy
#align category_theory.monoidal_category.full_braided_subcategory.map CategoryTheory.MonoidalCategory.fullBraidedSubcategory.map
instance fullBraidedSubcategory.mapFull (h : ∀ ⦃X⦄, P X → P' X) :
Full (fullBraidedSubcategory.map h).toFunctor :=
fullMonoidalSubcategory.mapFull h
#align category_theory.monoidal_category.full_braided_subcategory.map_full CategoryTheory.MonoidalCategory.fullBraidedSubcategory.mapFull
instance fullBraidedSubcategory.map_faithful (h : ∀ ⦃X⦄, P X → P' X) :
Faithful (fullBraidedSubcategory.map h).toFunctor :=
fullMonoidalSubcategory.map_faithful h
#align category_theory.monoidal_category.full_braided_subcategory.map_faithful CategoryTheory.MonoidalCategory.fullBraidedSubcategory.map_faithful
end Braided
section Symmetric
variable (P) [SymmetricCategory C]
instance fullSymmetricSubcategory : SymmetricCategory (FullSubcategory P) :=
symmetricCategoryOfFaithful (fullBraidedSubcategoryInclusion P)
#align category_theory.monoidal_category.full_symmetric_subcategory CategoryTheory.MonoidalCategory.fullSymmetricSubcategory
end Symmetric
section Closed
variable (P) [MonoidalClosed C]
/-- A property `C → Prop` is a closed predicate if it is closed under taking internal homs
-/
class ClosedPredicate : Prop where
prop_ihom' : ∀ {X Y}, P X → P Y → P ((ihom X).obj Y) := by obviously
#align category_theory.monoidal_category.closed_predicate CategoryTheory.MonoidalCategory.ClosedPredicate
restate_axiom closed_predicate.prop_ihom'
open ClosedPredicate
variable [ClosedPredicate P]
instance fullMonoidalClosedSubcategory : MonoidalClosed (FullSubcategory P)
where closed' X :=
{
isAdj :=
{ right :=
FullSubcategory.lift P (fullSubcategoryInclusion P ⋙ ihom X.1) fun Y =>
prop_ihom X.2 Y.2
adj :=
Adjunction.mkOfUnitCounit
{ Unit :=
{ app := fun Y => (ihom.coev X.1).app Y.1
naturality' := fun Y Z f => ihom.coev_naturality X.1 f }
counit :=
{ app := fun Y => (ihom.ev X.1).app Y.1
naturality' := fun Y Z f => ihom.ev_naturality X.1 f }
left_triangle := by
ext Y
simp
exact ihom.ev_coev X.1 Y.1
right_triangle := by
ext Y
simp
exact ihom.coev_ev X.1 Y.1 } } }
#align category_theory.monoidal_category.full_monoidal_closed_subcategory CategoryTheory.MonoidalCategory.fullMonoidalClosedSubcategory
@[simp]
theorem fullMonoidalClosedSubcategory_ihom_obj (X Y : FullSubcategory P) :
((ihom X).obj Y).obj = (ihom X.obj).obj Y.obj :=
rfl
#align category_theory.monoidal_category.full_monoidal_closed_subcategory_ihom_obj CategoryTheory.MonoidalCategory.fullMonoidalClosedSubcategory_ihom_obj
@[simp]
theorem fullMonoidalClosedSubcategory_ihom_map (X : FullSubcategory P) {Y Z : FullSubcategory P}
(f : Y ⟶ Z) : (ihom X).map f = (ihom X.obj).map f :=
rfl
#align category_theory.monoidal_category.full_monoidal_closed_subcategory_ihom_map CategoryTheory.MonoidalCategory.fullMonoidalClosedSubcategory_ihom_map
end Closed
end MonoidalCategory
end CategoryTheory
|
# Covid-19: From model prediction to model predictive control
## A demo of the deterministic modeling framework
*Original code by Ryan S. McGee. Modified by T.W. Alleman in consultation with the BIOMATH research unit headed by prof. Ingmar Nopens.*
Copyright (c) 2020 by T.W. Alleman, BIOMATH, Ghent University. All Rights Reserved.
Our code implements a SEIRS infectious disease dynamics model with extensions to model the effect of quarantining detected cases. Notably, this package includes stochastic implementations of these models on dynamic networks. We modified the original implementation by Ryan McGee at its source to account for additional Covid-19 disease characteristics. The code was then integrated with our previous work and allows to quickly perform Monte Carlo simulations, calibration of model parameters and the calculation of *optimal* government policies using a model predictive controller. A white paper and souce code of our previous work can be found on the Biomath website.
https://biomath.ugent.be/covid-19-outbreak-modelling-and-control
```python
import numpy as np
import matplotlib.pyplot as plt
from IPython.display import Image
from ipywidgets import interact,fixed,FloatSlider,IntSlider,ToggleButtons
import pandas as pd
import datetime
import scipy
import coronaHelper2 as cH
from scipy.integrate import odeint
import matplotlib.dates as mdates
import matplotlib
import scipy.stats as st
import networkx
import models
```
## Introduction
### Model dynamics
In this work, we extended the SEIR model to model the disease spread with a higher resolution. To this end, the *infected pool* is split into four types of infectiousness: 1) supermild (SM): people who show little to no symptoms at all, 2) mild (M): people with noticable, mild symptoms, 3) heavy (H): people hospitalised but not in need of intensive care and 4) critical (C): people hospitalised and in need of intensive care. It takes several days before a heavy or critical infection becomes so severe that these patients need to be hospitalised. To this end, the pool of heavily and critically infected patients is split in two: not yet hospitalised (H, C) and hospitalised (HH,CH). The *removed pool* from the classical SEIR model is explicitly split into an immune (I) and dead (F) pool. People from the susceptible, exposed, supermild infected, mild infected and immune pool can be quarantined after having tested positive for covid-19. In the flowchart below, quarantine is denoted by the *Q*-suffix. Note that for individuals in the susceptible and immune pools, this corresponds to receiving a false positive test.
### Deterministic vs. Stochastic framework
The extended SEIR model is implemented using two frameworks: a deterministic and a stochastic (network based) framework. A deterministic implementation of the extended SEIRS model captures important features of infectious disease dynamics, but it assumes uniform mixing of the population (i.e. every individual in the population is equally likely to interact with every other individual). The deterministic approach results in a set of N ordinary differential equations, one for every of the N ’population pools’ considered. The main advantage of the deterministic model is that a low amount of computational resources are required while still maintaining an acceptable accuracy. The deterministic framework allows to rapidly explore scenarios and perform optimisations which require thousands of function evaluations.
However, it is often important to consider the structure of contact networks when studying disease transmission and the effect of interventions such as social distancing and contact tracing. The main drawback of the deterministic approach is the inability to simulate contact tracing, which is one of the most promising measures against the spread of sars-cov-2. For this reason, the SEIRS dynamics depicted in on the above flowchart are simulated on a stochastic dynamical network. This advantages include a more detailed analysis of the relationship between social network structure and effective transmission rates, including the effect of network-based interventions such as social distancing, quarantining, and contact tracing. The first drawback is the increased amount of computational resources required, leading to the inability to perform optimisations on a personal computer. Instead, high performance computing infrastructure is needed. The second drawback is the need for more data and/or assumptions on social interactions and how government measures affect these social interactions.
#### Deterministic equations
The dynamics of the deterministic system are mathematically formulated as the rate of change of each population pool shown in the above flowchart. This results in the following system of ordinary differential equations (subject to change),
\begin{eqnarray}
\dot{S} &=& - \beta \cdot N_c \Big( \frac{E+SM}{N} \Big) \cdot S - \theta_{\text{S}} \psi_{\text{FP}} \cdot S + SQ/d_{\text{q,FP}} + \zeta \cdot R,\\
\dot{E} &=& \beta \cdot N_c \Big( \frac{E+SM}{N} \Big) \cdot S - B / \sigma - \theta_{\text{E}} \psi_{\text{PP}} \cdot E,\\
\dot{SM} &=& \text{sm}/\sigma \cdot E - SM/d_{\text{sm}} - \theta_{\text{SM}} \psi_{\text{PP}} \cdot SM,\\
\dot{M} &=& \text{m} / \sigma \cdot E - M/d_{\text{m}} - \theta_{\text{M}} \psi_{\text{PP}} \cdot M,\\
\dot{H} &=& \text{h} / \sigma \cdot E + h / \sigma \cdot EQ - H/d_{\text{hospital}},\\
\dot{C} &=& \text{c} / \sigma \cdot E + c / \sigma \cdot EQ - C/d_{\text{hospital}},\\
\dot{HH} &=& H/d_{\text{hospital}} - HH/d_{h}\\
\dot{CH} &=& C/d_{\text{hospital}} - m_c \cdot CH/d_{\text{cf}} - (1-m_c) \cdot CH/d_{\text{cr}}\\
\dot{F} &=& m_c \cdot CH/d_{\text{cf}}\\
\dot{R} &=& SM/d_{\text{sm}} + M/d_{\text{m}} + HH/d_{\text{h}} + (1-m_h) \cdot CH/d_{\text{cr}} + SMQ/d_{\text{sm}} \\ && + MQ/d_{\text{m}} + RQ/d_{\text{q,FP}} - \zeta \cdot R \\
\dot{SQ} &=& \theta_{\text{S}} \psi_{\text{FP}} \cdot S - SQ/d_{\text{q,FP}} \\
\dot{EQ} &=& \theta_{\text{E}} \psi_{\text{PP}} \cdot E - EQ/\sigma\\
\dot{SMQ} &=& \theta_{\text{SM}} \psi_{\text{PP}} \cdot SM + sm/\sigma \cdot EQ - SMQ/d_{\text{sm}} \\
\dot{MQ} &=& \theta_{\text{M}} \psi_{\text{PP}} \cdot M + m/\sigma \cdot EQ - MQ/d_{\text{m}}\\
\dot{RQ} &=& \theta_{\text{R}} \psi_{\text{FP}} \cdot R - RQ/d_{\text{q,FP}}
\end{eqnarray}
#### Stochastic equations
Consider a network graph G like the one depicted below, representing individuals (nodes) and their interactions (edges). Each individual (node) has a state (S, E, SM, M, H, C, HH, CH, R, F, SQ, SMQ, MQ or RQ). The set of nodes adjacent (connected by an edge) to an individual defines their set of "close contacts" (highlighted in black). At a given time, each individual makes contact with a random individual from their set of close contacts with probability (1-p) or with a random individual from anywhere in the network (highlighted in blue) with probability p. The latter global contacts represent individuals interacting with the population at large. These are individuals outside of ones inner social circle, such as on public transit, at an event or chatting to an old acquaintance etc. When a susceptible individual interacts with an exposed or infectious individual they become exposed themselves. The parameter p defines the locality of the network: for p=0 an individual only interacts with their close contacts, while p=1 represents a uniformly mixed population. **For a sufficiently large network G, and $p = 1$, the stochastic and deterministic framework will yield the same result**. Social distancing interventions ifluences both the locality and connectivity of the network. It is expected that social distancing lowers the average number of interactions an individual has each day (lower connectivity of the network). But as a result, the fraction of interactions in the inner circle increases, lowering p.
Each node $i$ has a state $X_i$ that updates according to a probability transition rate. The dynamics of the stochastic system are mathematically formulated as probabilities of transitioning between the pools shown in the model flowchart. In addition, back tracking of confirmed cases can be included in the model,
\begin{eqnarray}
\text{Pr}(X_i = S \rightarrow E) &=& \Big[ \underbrace{p \cdot \frac{\beta (E + SM)}{N}}_{\text{infection through random encounter}} \\
&& + \underbrace{(1-p) \cdot \frac{\beta \sum_{j \in C_G(i)} (\delta_{X_j = E}+\delta_{X_j = SM})}{C_G (i)}}_{\text{infection through inner circle}} \Big] \delta_{X_i=S},\\
\text{Pr}(X_i = E \rightarrow SM) &=& (sm/\sigma) \cdot \delta_{X_i = E},\\
\text{Pr}(X_i = E \rightarrow M) &=& (m/\sigma) \cdot \delta_{X_i = E},\\
\text{Pr}(X_i = E \rightarrow H) &=& (h/\sigma) \cdot \delta_{X_i = E},\\
\text{Pr}(X_i = E \rightarrow C) &=& (c/\sigma) \cdot \delta_{X_i = E},\\
\text{Pr}(X_i = H \rightarrow HH) &=& (1/d_{\text{hospital}}) \delta_{X_i = H},\\
\text{Pr}(X_i = C \rightarrow CH) &=& (1/d_{\text{hospital}}) \delta_{X_i = C},\\
\text{Pr}(X_i = SM \rightarrow R) &=& (1/d_{\text{sm}}) \cdot \delta_{X_i = SM},\\
\text{Pr}(X_i = M \rightarrow R) &=& (1/d_{\text{m}}) \cdot \delta_{X_i = M},\\
\text{Pr}(X_i = HH \rightarrow R) &=& (1/d_{\text{h}}) \cdot \delta_{X_i = HH},\\
\text{Pr}(X_i = CH \rightarrow R) &=& (1-m_c)/d_{\text{cr}} \cdot \delta_{X_i = HH},\\
\text{Pr}(X_i = CH \rightarrow F) &=& (m_c/d_{\text{cf}}) \cdot \delta_{X_i = HH},\\
\text{Pr}(X_i = S \rightarrow SQ) &=& \Big[\theta_S + \phi_S \big[ \sum_{j \in C_G(i)} (\delta_{X_j = SQ}+\delta_{X_j = EQ}+\delta_{X_j = SMQ} \\
&&+\delta_{X_j = MQ}+\delta_{X_j = RQ}+\delta_{X_j = HH}+\delta_{X_j = CH}) \big] \Big] \cdot \psi_{\text{FP}} \cdot \delta_{X_i = S}, \\
\text{Pr}(X_i = E \rightarrow EQ) &=& \Big[\theta_E + \phi_E \big[ \sum_{j \in C_G(i)} (\delta_{X_j = SQ}+\delta_{X_j = EQ}+\delta_{X_j = SMQ} \\
&&+\delta_{X_j = MQ}+\delta_{X_j = RQ}+\delta_{X_j = HH}+\delta_{X_j = CH}) \big] \Big] \cdot \psi_{\text{PP}} \cdot \delta_{X_i = E}, \\
\text{Pr}(X_i = SM \rightarrow SMQ) &=& \Big[\theta_{SM} + \phi_{SM} \big[ \sum_{j \in C_G(i)} (\delta_{X_j = SQ}+\delta_{X_j = EQ}+\delta_{X_j = SMQ} \\
&&+\delta_{X_j = MQ}+\delta_{X_j = RQ}+\delta_{X_j = HH}+\delta_{X_j = CH}) \big] \Big] \cdot \psi_{\text{PP}} \cdot \delta_{X_i = SM}, \\
\text{Pr}(X_i = M \rightarrow MQ) &=& \Big[\theta_{M} + \phi_{M} \big[ \sum_{j \in C_G(i)} (\delta_{X_j = SQ}+\delta_{X_j = EQ}+\delta_{X_j = SMQ} \\
&&+\delta_{X_j = MQ}+\delta_{X_j = RQ}+\delta_{X_j = HH}+\delta_{X_j = CH}) \big] \Big] \cdot \psi_{\text{PP}} \cdot \delta_{X_i = M} \\
\text{Pr}(X_i = R \rightarrow RQ) &=& \Big[\theta_{R} + \phi_{R} \big[ \sum_{j \in C_G(i)} (\delta_{X_j = SQ}+\delta_{X_j = EQ}+\delta_{X_j = SMQ} \\
&&+\delta_{X_j = MQ}+\delta_{X_j = RQ}+\delta_{X_j = HH}+\delta_{X_j = CH}) \big] \Big] \cdot \psi_{\text{FP}} \cdot \delta_{X_i = R}\\
\text{Pr}(X_i = SQ \rightarrow S) &=& (1/d_{q,FP}) \cdot \delta_{X_i = SQ},\\
\text{Pr}(X_i = EQ \rightarrow SMQ) &=& sm \cdot \sigma \cdot \delta_{X_i = EQ},\\
\text{Pr}(X_i = EQ \rightarrow MQ) &=& m \cdot \sigma \cdot \delta_{X_i = EQ},\\
\text{Pr}(X_i = EQ \rightarrow H) &=& h \cdot \sigma \cdot \delta_{X_i = EQ},\\
\text{Pr}(X_i = EQ \rightarrow C) &=& h \cdot \sigma \cdot \delta_{X_i = EQ},\\
\text{Pr}(X_i = SMQ \rightarrow R) &=& h (1/d_{sm}) \cdot \delta_{X_i = SMQ},\\
\text{Pr}(X_i = MQ \rightarrow R) &=& h (1/d_{m}) \cdot \delta_{X_i = MQ},\\
\text{Pr}(X_i = RQ \rightarrow R) &=& h (1/d_{\text{hospital}}) \cdot \delta_{X_i = RQ},\\
\text{Pr}(X_i = R \rightarrow S) &=& \zeta \cdot \delta_{X_i = R},\\
\end{eqnarray}
where $\delta_{X_i = A} = 1$ if the state of $X_i$ is A, or 0 if not, and where $C_G(i)$ denotes the set of close contacts of node i (adjacent nodes). For large populations and $p = 1$, this stochastic model approaches the same dynamics as the deterministic SEIRS model.
### Model parameters
In the above equations, S stands for susceptible, E for exposed, SM for supermild, M for mild, H for heavy, C for critical, HH for heavy and hospitalised, CH for critical and hospitalised, F for dead, R for immune. The quarantined states are SQ, which stands for susceptible and quarantined, EQ for exposed and quarantined, SMQ for supermild infected and quarantined, MQ for mildly infected and quarantined and RQ for recovered and quarantined. N stands for the total population. The clinical parameters are: sm, m, z, h: the chance of having a supermild, mild, heavy or critical infection. Based on reported cases in China and travel data, Li et al. (2020b) estimated that 86 % of coronavirus infections in the country were "undocumented" in the weeks before officials instituted stringent quarantines. In this work it is assumed that 86 % of all infected cases are supermild (asymptotic) and hence,
$$sm = 0.86$$
Based on previously reported estimates of the distribution between mild, severe and critical cases (Wu and McGoogan, 2020), it is then calculated that the chance of contrapting a mild, severe and critical infection is,
$$m = (1 − 0.86) · 0.81 = 0.1133,$$
$$h = (1 − 0.86) · 0.14 = 0.0193,$$
$$c = (1 − 0.86) · 0.05 = 0.0066.$$
$d_{sm}$ , $d_m$ , $d_h$ : the number of symptomic days in case of a supermild, mild or heavy infection. $d_{hf}$ is the time from hospitalisation until death in case of a critical infection while $d_{hr}$ is the recovery time for critical cases. Zhou et al. (2020) performed a retrospective study on 191 Chinese hospital patients and determined that the time from illness onset to discharge or death was 22.0 days (18.0-25.0, IQR) and 18.5 days (15.0-22.0, IQR) for survivors and victims respectively. Using available preliminary data, the World Health Organisation estimated the median time from onset to clinical recovery for mild cases to be approximately 2 weeks and to be 3-6 weeks for patients with severe or critical disease (WHO, 2020). Based on this report, we assume a recovery time of three weeks for heavy infections. d hospital : the time before heavily or critically infected patients reach the hospital. On average this is 9.1 days (Li et al., 2020a). m c : the mortality in case of a critical infection, which is roughly 50% (Wu and McGoogan, 2020). It is assumed that if the number of critical cases surpasses the total number of ICU beds, the mortality is changed to the average between 0.49 and 1, with the fraction of patients in critical condition receiving care as a weight. This is formulated mathematically in the following way,
\begin{equation}
m_h = \underbrace{\Big( \frac{ICU_{\text{max}}}{H} \Big) \cdot 0.49}_{\text{critical patient receives care}} + \underbrace{\Big( \frac{H - ICU_{\text{max}}}{H} \Big) \cdot 1.00}_{\text{critical patient receives no care}}\ .
\end{equation}
$\sigma$: the incubation period in days. The incubation period is assumed to be Erlang distributed as reported by Li et al. (2020a). The average incubation time is 5.2 days. $\zeta$: can be used to model the effect of re-susceptibility and seasonality of a disease. Throughout this demo, we assume $\zeta = 0$ because no data on re-susceptibility is available at the moment. We thus assume permanent immunity after recovering from the infection.
The transmission rate of the disease in the deterministic model depends on the product of three contributions. The first contribution, $(E+SM)/N$, is the probability of encountering a contagious individual. The second contribution, $N_c$, is the average number of human-to-human interactions per day. As previously explained, **in the deterministic framework, this means all $N_c$ contacts within the population are random**. In this work, we explictly split $\beta$ and $N_c$ because this has the following advantages:1) $\beta$ is now a disease characteric, independent of social interactions. 2) The goal of this work is to demonstrate the concept of social control to contain the outbreak using model predictive control. By splitting $\beta$ and $N_c$, the controlled variable is the number of random contacts $N_c$ which is more comprehendible to the reader of this text. The number of human-human interactions per day is estimated using the Social Contact Rates (SOCRATES) Data Tool (Willem et al., 2020). The dataset on human-human interactions for Belgium is based on a 2008 study by Mossong, which kept track of 750 participants and their interactions (8878 interactions) in Belgium. The dataset includes both physical and non-physical interactions of any duration. The third contribution, $\beta$, is the probability of contracting sars-cov-2 when encoutering a contagious individual. The testing and quarantine parameters are: $\theta_{S}$, $\theta_{E}$, $\theta_{SM}$, $\theta_{M}$, expressed as the number of susceptibles, exposed, supermild and mild individuals tested each day. $\psi_{PP}$: probability of correctly identifiying and quarantining an exposed or infected person. $\psi_{FP}$: probability of falsly identifying and quarantining a susceptible or recovered individual. Both parameters can be calculated using the reliability of the test and Bayes theorem. The latest reported reliability was only 71 \% (need ref). $d_{\text{q,FP}}$: the duration of the quarantine in the case of a false positive, assumed to be 14 days.
### Gathering social interaction data:
#### Social Contact Rates (SOCRATES) Data Tool
https://lwillem.shinyapps.io/socrates_rshiny/
1. What is the average number of daily human-to-human contacts of the Belgian population? Include all ages, all genders and both physical and non-physical interactions of any duration. To include all ages, type: *0,60+* in the *Age Breaks* dialog box.
2. What is the average number of physical human-to-human contacts of the Belgian population? Include all ages, all genders and all durations of physical contact.
3. What is the average number of physical human-to-human contacts of at least 1 hour of the Belgian population?
4. Based on the above results, how would you estimate $N_c$ in the deterministic model?
5. Based on the above results, how would you estimate $p$ in the stochastic model? Recall that $p$ is the fraction of *random contacts* a person has on a daily basis, while $(1-p)$ is the fraction of *inner circle contacts* a person has on a daily basis.
#### Google COVID-19 Community Mobility Reports
https://www.google.com/covid19/mobility/
#### London School of Hygiene
https://www.thelancet.com/journals/lanpub/article/PIIS2468-2667(20)30073-6/fulltext
```python
# -----------------------
# Define model parameters
# -----------------------
# Clinical parameters
beta = 0.032 # already calibrated for the deterministic model, change to 0.29 for stochastic
Nc = np.array([[11.2]]) # average number of human-to-human contacts (USE SOCRATES TO DETERMINE VALUE)
zeta = 0 # re-susceptibility parameter (0 = permanent immunity)
dsm = 14 # length of disease for asymptotic (SM) infections
dm = 14 # length of disease for mildly symptomic infections
dhospital = 9.1 # average time from symptom onset to hospitalisation for H and C infections
dh = 21 # average recovery time for heavy infection
mc0 = 0.49 # mortality for critical cases when they receive care
ICU = 2600 # number of available ICU beds in Belgium
# Testing parameters
totalTests = 0
theta_S = 0 # no. of daily tests of susceptibles
theta_E = 0 # no. of daily tests of exposed
theta_SM = 0 # no. of daily tests of SM infected
theta_M = 0 # no. of daily tests of M infected
theta_R = 0 # no. of daily tests of recovered patients
phi_S = 0 # backtracking of susceptibles
phi_E = 0 # backtracking of exposed
phi_SM = 0 # backtracking of supermild cases
phi_R = 0 # backtracking of recovered cases
psi_FP = 0 # odds of a false positive test
psi_PP = 1 # odds of a correct test
dq = 14 # length of quarantine for false positives
# Interessant artikel over serologische testen:
#https://www.tijd.be/dossiers/coronavirus/kunnen-bloedtests-onze-maatschappij-snel-weer-in-gang-trappen/10218259.html
```
## Performing simulations
#### Additional arguments to run a stochastic simulation
Before a stochastic simulation can be performed, two more parameters must be defined. The first is the interaction network G, which determines the connectivity of the network, the second is the parameter p, which determines the locality of the network. After defining both parameters, all stochastic-specific parameters are grouped in a dictionary *stoArgs*, which must be passed as an optional keyworded argument to the *simModel* function.
```python
# Construct the network G
numNodes = 8000
baseGraph = networkx.barabasi_albert_graph(n=numNodes, m=7)
# Baseline normal interactions:
G_norm = models.custom_exponential_graph(baseGraph, scale=200)
models.plot_degree_distn(G_norm, max_degree=40)
# Construct the network G under social distancing
numNodes = 8000
baseGraph = networkx.barabasi_albert_graph(n=numNodes, m=2)
# Baseline normal interactions:
G_dist = models.custom_exponential_graph(baseGraph, scale=20000)
models.plot_degree_distn(G_dist, max_degree=40)
```
#### The use of checkpoints to change parameters on the fly
A cool feature of the original SEIRSplus package by Ryan McGee was the use of so-called *checkpoints* dictionary to change simulation parameters on the fly. In our modification, this feature is preserved. Below you can find an example of a *checkpoints* dictionary. The simulation will be started with the provided parameters. After 25 days, social interaction will be limited by changing beta to 0.10. After 85 days, social restrictions are lifted and beta once more assumes its *business-as-usual* value. When simulating a dynamic network, it is possible to change the connectivity of the network. In the example below, the connectivity is changed from an average of 12 interactions per day to only 4 interactions. If no checkpoints are needed, *checkpoints* should be set to *None*.
```python
checkpoints = {'t': [25,40,140],
'p': [0.1,1-4.1/11.2,1-4.1/11.2],
'G': [G_dist,G_norm,G_norm],
'totalTests': [0,1000000,1000000]
}
```
#### Monte-Carlo sampling
One of the layers added to the existing SEIRSplus package is the ability to perform Monte-Carlo sampling of selected parameters. In our simulation, we assume four parameters are distributed: $s_m$, $d_{hf}$, $d_{hr}$ and $\sigma$.
```python
monteCarlo = False # perform monte Carlo Sampling (recommend disabling for stochastic simulation)
n_samples = 400 # From 200 upwards no observable change
```
```python
# ------------------------
# Define initial condition
# ------------------------
initN = np.array([6e6])
initE= np.array([1])
initSM=np.zeros(1)
initM=np.zeros(1)
initH=np.zeros(1)
initC=np.zeros(1)
initHH=np.zeros(1)
initCH=np.zeros(1)
initR=np.zeros(1)
initF=np.zeros(1)
initSQ=np.zeros(1)
initEQ=np.zeros(1)
initSMQ=np.zeros(1)
initMQ=np.zeros(1)
initRQ=np.zeros(1)
# ----------------------------
# Define simulation parameters
# ----------------------------
simtime = 300 # length of simulation (days)
modelType = 'deterministic' # alternative: stochastic
method = 'none' # default
```
```python
# --------------
# Run simulation
# --------------
simout=cH.simModel(initN,beta,Nc,zeta,dsm,dm,dhospital,dh,mc0,ICU,theta_S,theta_E,theta_SM,theta_M,theta_R,totalTests,
psi_FP,psi_PP,dq,phi_S,phi_E,phi_SM,phi_R,initE, initSM, initM, initH, initC,initHH,initCH,
initR,initF,initSQ,initEQ,initSMQ,initMQ,initRQ,simtime,monteCarlo,n_samples,method,
modelType,checkpoints,**stoArgs)
```
```python
# -----------
# Plot result
# -----------
t = simout['t']
I = simout['SM']+ simout['M'] + simout['H'] + simout['C'] + simout['HH'] + simout['CH']
plt.figure(1)
plt.plot(t,np.mean(simout['S'],axis=1),color="black")
plt.fill_between(t, np.percentile(simout['S'],90,axis=1), np.percentile(simout['S'],10,axis=1),color="black",alpha=0.2)
plt.plot(t,np.mean(simout['E'],axis=1),color="blue")
plt.fill_between(t, np.percentile(simout['E'],90,axis=1), np.percentile(simout['E'],10,axis=1),color="blue",alpha=0.2)
plt.plot(t,np.mean(I,axis=1),color="red")
plt.fill_between(t, np.percentile(I,90,axis=1), np.percentile(I,10,axis=1),color="red",alpha=0.2)
plt.plot(t,np.mean(simout['R'],axis=1),color="green")
plt.fill_between(t, np.percentile(simout['R'],90,axis=1), np.percentile(simout['R'],10,axis=1),color="green",alpha=0.2)
plt.legend(('susceptible','exposed','total infected','immune'))
plt.xlabel('days')
plt.ylabel('number of patients')
plt.figure(2)
plt.plot(t,np.mean(simout['HH'],axis=1),color="orange")
plt.fill_between(t, np.percentile(simout['HH'],90,axis=1), np.percentile(simout['HH'],10,axis=1),color="orange",alpha=0.2)
plt.plot(t,np.mean(simout['CH'],axis=1),color="red")
plt.fill_between(t, np.percentile(simout['CH'],90,axis=1), np.percentile(simout['CH'],10,axis=1),color="red",alpha=0.2)
plt.plot(t,np.mean(simout['F'],axis=1),color="black")
plt.fill_between(t, np.percentile(simout['F'],90,axis=1), np.percentile(simout['F'],10,axis=1),color="black",alpha=0.2)
plt.xlabel('days')
plt.ylabel('number of patients')
# vlines=checkpoints['t']
# vline_colors=['red','green','black','black']
# vline_labels=[]
# vline_styles=[]
# #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# # Draw the vertical line annotations:
# #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# if(len(vlines)>0 and len(vline_colors)==0):
# vline_colors = ['black']*len(vlines)
# if(len(vlines)>0 and len(vline_labels)==0):
# vline_labels = [None]*len(vlines)
# if(len(vlines)>0 and len(vline_styles)==0):
# vline_styles = [':']*len(vlines)
# for vline_x, vline_color, vline_style, vline_label in zip(vlines, vline_colors, vline_styles, vline_labels):
# if(vline_x is not None):
# plt.axvline(x=vline_x, color=vline_color, linestyle=vline_style, alpha=1, label=vline_label)
plt.legend(('heavy','critical','dead','start lockdown','end lockdown'))
plt.figure(3)
plt.plot(t,np.mean(simout['SQ'],axis=1),color="green")
plt.fill_between(t, np.percentile(simout['SQ'],90,axis=1), np.percentile(simout['SQ'],10,axis=1),color="green",alpha=0.2)
plt.plot(t,np.mean(simout['EQ'],axis=1),color="orange")
plt.fill_between(t, np.percentile(simout['EQ'],90,axis=1), np.percentile(simout['EQ'],10,axis=1),color="orange",alpha=0.2)
plt.plot(t,np.mean(simout['SMQ'],axis=1),color="red")
plt.fill_between(t, np.percentile(simout['SMQ'],90,axis=1), np.percentile(simout['SMQ'],10,axis=1),color="red",alpha=0.2)
plt.legend(('SQ','EQ','SMQ'))
plt.xlabel('days')
plt.ylabel('number of patients')
plt.figure(4)
plt.plot(t,np.mean(simout['M'],axis=1),color="red")
plt.fill_between(t, np.percentile(simout['M'],90,axis=1), np.percentile(simout['M'],10,axis=1),color="red",alpha=0.2)
plt.plot(t,np.mean(simout['MQ'],axis=1),color="green")
plt.fill_between(t, np.percentile(simout['MQ'],90,axis=1), np.percentile(simout['MQ'],10,axis=1),color="green",alpha=0.2)
plt.legend(('M','MQ','number of tests on S'))
plt.xlabel('days')
plt.ylabel('number of patients')
```
## Calibrating $\beta$ in a *business-as-usual* scenario ($N_c = 11.2$)
```python
modelType = 'deterministic'
```
```python
columns = ['hospital','ICU','dead']
hospital = np.array([[58,97,163,264,368,496,648,841,1096,1380,1643,1881,2137,2715,3068,3640,4077,4468,4884,4975,5206,5358,5492,5509,5600,5738,5692,5590,5610,5635,5409,5393,5536]])
ICUvect= np.array([[5,24,33,53,79,100,130,164,238,290,322,381,474,605,690,789,867,927,1021,1088,1144,1205,1245,1261,1257,1260,1276,1285,1278,1262,1232,1234,1223]])
dead = np.array([[3,4,4,10,10,14,21,37,67,75,88,122,178,220,289,353,431,513,705,828,1011,1143,1283,1447,1632,2035,2240,2523,3019,3346,3600,3903,4157]])
index=pd.date_range('2020-03-13', freq='D', periods=ICUvect.size)
data = np.concatenate((hospital,ICUvect,dead),axis=0)
data = np.transpose(data)
data_belgie=pd.DataFrame(data,index=index, columns=columns)
```
```python
betaZonderIngrijpen=[]
```
```python
# -------------------------------
# Parameters of fitting algorithm
# -------------------------------
monteCarlo = False
n_samples = 100
maxiter=30
popsize=5
polish=True
disp = True
bounds=[(0.01,0.05),(1,60)]
idx=-22
print(index[idx])
idx = idx+1
data=np.transpose(ICUvect[:,0:idx])
method = 'findTime'
modelType = 'deterministic'
checkpoints=None
fitTo = np.array([8]) #positions in output of runSimulation that must be added together, here: CH
# -----------
# Perform fit
# -----------
estimate = cH.modelFit(bounds,data,fitTo,initN,Nc,zeta,dsm,dm,dhospital,dh,mc0,ICU,theta_S,theta_E,theta_SM,theta_M,theta_R,totalTests,psi_FP,psi_PP,dq,phi_S,phi_E,phi_SM,phi_R,monteCarlo,n_samples,method,modelType,checkpoints,disp,polish,maxiter,popsize)
betaZonderIngrijpen.append(estimate[0])
print(estimate)
```
2020-03-24 00:00:00
/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/optimize/_differentialevolution.py:494: UserWarning: differential_evolution: the 'workers' keyword has overridden updating='immediate' to updating='deferred'
" updating='deferred'", UserWarning)
differential_evolution step 1: f(x)= 115802
differential_evolution step 2: f(x)= 75693.2
differential_evolution step 3: f(x)= 75693.2
differential_evolution step 4: f(x)= 70107.6
differential_evolution step 5: f(x)= 44227
differential_evolution step 6: f(x)= 23912.3
differential_evolution step 7: f(x)= 12047.1
differential_evolution step 8: f(x)= 8827.33
differential_evolution step 9: f(x)= 5751.76
differential_evolution step 10: f(x)= 5751.76
differential_evolution step 11: f(x)= 4390.76
differential_evolution step 12: f(x)= 4390.76
differential_evolution step 13: f(x)= 4390.76
differential_evolution step 14: f(x)= 4390.76
differential_evolution step 15: f(x)= 4390.76
differential_evolution step 16: f(x)= 4390.76
differential_evolution step 17: f(x)= 4390.76
differential_evolution step 18: f(x)= 4390.76
differential_evolution step 19: f(x)= 4390.76
differential_evolution step 20: f(x)= 4390.76
differential_evolution step 21: f(x)= 4389.06
differential_evolution step 22: f(x)= 4388.69
differential_evolution step 23: f(x)= 4388.69
differential_evolution step 24: f(x)= 4388.69
differential_evolution step 25: f(x)= 4388.25
differential_evolution step 26: f(x)= 4388
differential_evolution step 27: f(x)= 4388
differential_evolution step 28: f(x)= 4388
differential_evolution step 29: f(x)= 4388
differential_evolution step 30: f(x)= 4387.93
[2.39776575e-02 4.77193463e+01]
```python
estimate=[0.0311, 35.99]
beta = estimate[0]
extraTime = estimate[1]
```
```python
obj = index[0]
timestampStr = obj.strftime("%Y-%m-%d")
print(timestampStr)
```
2020-03-13
```python
# -----------------------
# Fitted model parameters
# -----------------------
beta = estimate[0]
extraTime = estimate[1]
simtime=data.size+int(extraTime)-1
method = 'none'
# inital condition
initN = initN
initE = np.ones(Nc.shape[0])
initSM = np.zeros(Nc.shape[0])
initM = np.zeros(Nc.shape[0])
initH = np.zeros(Nc.shape[0])
initC = np.zeros(Nc.shape[0])
initHH = np.zeros(Nc.shape[0])
initCH = np.zeros(Nc.shape[0])
initR = np.zeros(Nc.shape[0])
initF = np.zeros(Nc.shape[0])
initSQ = np.zeros(Nc.shape[0])
initEQ = np.zeros(Nc.shape[0])
initSMQ = np.zeros(Nc.shape[0])
initMQ = np.zeros(Nc.shape[0])
initRQ = np.zeros(Nc.shape[0])
# --------------
# Run simulation
# --------------
simout = cH.simModel(initN,beta,Nc,zeta,dsm,dm,dhospital,dh,mc0,ICU,theta_S,theta_E,theta_SM,theta_M,
theta_R,totalTests,psi_FP,psi_PP,dq,phi_S,phi_E,phi_SM,phi_R,initE, initSM, initM, initH, initC,
initHH,initCH,initR,initF,initSQ,initEQ,initSMQ,initMQ,initRQ,simtime,monteCarlo,
n_samples,method,modelType,checkpoints)
# -----------
# Plot result
# -----------
t=pd.date_range('2020-03-13', freq='D', periods=data.size)
tacc=pd.date_range('2020-03-13', freq='D', periods=data.size+int(extraTime))-datetime.timedelta(days=int(extraTime)-1)
fig=plt.figure(1)
plt.figure(figsize=(7,5),dpi=100)
plt.scatter(t,data_belgie.iloc[:idx,1],color="black",marker="v")
plt.scatter(t,data_belgie.iloc[:idx,2],color="black",marker="o")
plt.scatter(t,data_belgie.iloc[:idx,0],color="black",marker="s")
plt.plot(tacc,np.mean(simout['HH']+simout['CH'],axis=1),'--',color="green")
plt.fill_between(tacc,np.percentile(simout['HH']+simout['CH'],95,axis=1),
np.percentile(simout['HH']+simout['CH'],5,axis=1),color="green",alpha=0.2)
plt.plot(tacc,np.mean(simout['CH'],axis=1),'--',color="orange")
plt.fill_between(tacc,np.percentile(simout['CH'],95,axis=1),
np.percentile(simout['CH'],5,axis=1),color="orange",alpha=0.2)
plt.plot(tacc,np.mean(simout['F'],axis=1),'--',color="red")
plt.fill_between(tacc,np.percentile(simout['F'],95,axis=1),
np.percentile(simout['F'],5,axis=1),color="red",alpha=0.20)
plt.legend(('Hospital (model)','ICU (model)','Deaths (model)'),loc='upper left')
plt.xlim(pd.to_datetime(tacc[24]),pd.to_datetime(tacc[-1]))
plt.title('Belgium',{'fontsize':18})
plt.gca().xaxis.set_major_locator(mdates.DayLocator())
plt.gca().xaxis.set_major_formatter(matplotlib.dates.DateFormatter('%d-%m-%Y'))
plt.setp(plt.gca().xaxis.get_majorticklabels(),
'rotation', 90)
plt.ylabel('number of patients')
plt.savefig('belgiumFit.svg',dpi=100,bbox_inches='tight')
```
## Model predictive control (use deterministic model)
### Bring model to current outbreak state
```python
# -----------------------
# Define model parameters
# -----------------------
# Clinical parameters
#beta = 0.032 # already calibrated for the deterministic model, change to 0.29 for stochastic
Nc = np.array([[11.2]]) # average number of human-to-human contacts (USE SOCRATES TO DETERMINE VALUE)
zeta = 0 # re-susceptibility parameter (0 = permanent immunity)
dsm = 14 # length of disease for asymptotic (SM) infections
dm = 14 # length of disease for mildly symptomic infections
dhospital = 9.1 # average time from symptom onset to hospitalisation for H and C infections
dh = 21 # average recovery time for heavy infection
mc0 = 0.49 # mortality for critical cases when they receive care
ICU = 2600 # number of available ICU beds in Belgium
# Testing parameters
totalTests = 0
theta_S = 0 # no. of daily tests of susceptibles
theta_E = 0 # no. of daily tests of exposed
theta_SM = 0 # no. of daily tests of SM infected
theta_M = 0 # no. of daily tests of M infected
theta_R = 0 # no. of daily tests of recovered patients
phi_S = 0 # backtracking of susceptibles
phi_E = 0 # backtracking of exposed
phi_SM = 0 # backtracking of supermild cases
phi_R = 0 # backtracking of recovered cases
psi_FP = 0 # odds of a false positive test
psi_PP = 1 # odds of a correct test
dq = 14 # length of quarantine for false positives
# Interessant artikel over serologische testen:
#https://www.tijd.be/dossiers/coronavirus/kunnen-bloedtests-onze-maatschappij-snel-weer-in-gang-trappen/10218259.html
monteCarlo = False # perform monte Carlo Sampling (recommend disabling for stochastic simulation)
n_samples = 400 # From 200 upwards no observable change
# ------------------------
# Define initial condition
# ------------------------
initN = np.array([11.43e6])
initE= np.array([1])
initSM=np.zeros(1)
initM=np.zeros(1)
initH=np.zeros(1)
initC=np.zeros(1)
initHH=np.zeros(1)
initCH=np.zeros(1)
initR=np.zeros(1)
initF=np.zeros(1)
initSQ=np.zeros(1)
initEQ=np.zeros(1)
initSMQ=np.zeros(1)
initMQ=np.zeros(1)
initRQ=np.zeros(1)
# ----------------------------
# Define simulation parameters
# ----------------------------
simtime=ICUvect.size+int(extraTime)-1 # simuleer tot vandaag
modelType = 'deterministic' # alternative: stochastic
method = 'none' # default
checkpoints={
't': [39+3],
'Nc': [np.array([0.3])] #1.78
}
# --------------
# Run simulation
# --------------
simout=cH.simModel(initN,beta,Nc,zeta,dsm,dm,dhospital,dh,mc0,ICU,theta_S,theta_E,theta_SM,theta_M,theta_R,totalTests,
psi_FP,psi_PP,dq,phi_S,phi_E,phi_SM,phi_R,initE, initSM, initM, initH, initC,initHH,initCH,
initR,initF,initSQ,initEQ,initSMQ,initMQ,initRQ,simtime,monteCarlo,n_samples,method,
modelType,checkpoints,**stoArgs)
# -----------
# Plot result
# -----------
t=pd.date_range('2020-03-13', freq='D', periods=ICUvect.size)
tacc=pd.date_range('2020-03-13', freq='D', periods=ICUvect.size+int(extraTime))-datetime.timedelta(days=int(extraTime))
fig=plt.figure(1)
plt.figure(figsize=(7,5),dpi=100)
plt.scatter(t,data_belgie.iloc[:,1],color="black",marker="v")
plt.plot(tacc,np.mean(simout['CH'],axis=1),'--',color="orange")
plt.fill_between(tacc,np.percentile(simout['CH'],95,axis=1),
np.percentile(simout['CH'],5,axis=1),color="orange",alpha=0.2)
plt.legend(('ICU (model)','ICU (data)'),loc='upper left')
plt.xlim(pd.to_datetime(tacc[24]),pd.to_datetime(tacc[-1]))
plt.title('Belgium',{'fontsize':18})
plt.gca().xaxis.set_major_locator(mdates.DayLocator())
plt.gca().xaxis.set_major_formatter(matplotlib.dates.DateFormatter('%d-%m-%Y'))
plt.setp(plt.gca().xaxis.get_majorticklabels(),
'rotation', 90)
plt.ylabel('number of patients')
```
```python
# Extract initial condition
initN = np.array([11.43e6])
initE= np.ones(1)*np.mean(simout['E'],axis=1)[-1]
initSM=np.ones(1)*np.mean(simout['SM'],axis=1)[-1]
initM=np.ones(1)*np.mean(simout['M'],axis=1)[-1]
initH=np.ones(1)*np.mean(simout['H'],axis=1)[-1]
initC=np.ones(1)*np.mean(simout['C'],axis=1)[-1]
initHH=np.ones(1)*np.mean(simout['HH'],axis=1)[-1]
initCH=np.ones(1)*np.mean(simout['CH'],axis=1)[-1]
initR=np.ones(1)*np.mean(simout['R'],axis=1)[-1]
initF=np.ones(1)*np.mean(simout['F'],axis=1)[-1]
initSQ=np.ones(1)*np.mean(simout['SQ'],axis=1)[-1]
initEQ=np.ones(1)*np.mean(simout['EQ'],axis=1)[-1]
initSMQ=np.ones(1)*np.mean(simout['SMQ'],axis=1)[-1]
initMQ=np.ones(1)*np.mean(simout['MQ'],axis=1)[-1]
initRQ=np.ones(1)*np.mean(simout['RQ'],axis=1)[-1]
print(initCH)
print(initR)
```
[1650.47821057]
[409768.92313793]
### Optimise the controller
```python
modelType = 'deterministic'
method = 'none'
```
```python
monteCarlo = False
n_samples=100
period = 7
P = 20
N = 16
discrete=False
roundOff = (0,1,2)
ICU = initCH
```
```python
polish=True
disp = True
maxiter = 100
popsize = 10
phi_S = 0
phi_E = 0
phi_SM = 0
phi_R = 0
totalTests = 0
policy = cH.MPCoptimize(initN,beta,zeta,dsm,dm,dhospital,dh,mc0,ICU,theta_S,theta_E,theta_SM,theta_M,theta_R,totalTests,
psi_FP,psi_PP,dq,phi_S,phi_E,phi_SM,phi_R,initE, initSM, initM, initH, initC,initHH,initCH,
initR,initF,initSQ,initEQ,initSMQ,initMQ,initRQ,simtime,monteCarlo,n_samples,method,
modelType,discrete,roundOff,period,P,N,disp,polish,maxiter,popsize)
```
/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/optimize/_differentialevolution.py:494: UserWarning: differential_evolution: the 'workers' keyword has overridden updating='immediate' to updating='deferred'
" updating='deferred'", UserWarning)
differential_evolution step 1: f(x)= 3.99606e+08
differential_evolution step 2: f(x)= 6.66733e+06
differential_evolution step 3: f(x)= 6.66733e+06
differential_evolution step 4: f(x)= 6.66733e+06
differential_evolution step 5: f(x)= 6.66733e+06
differential_evolution step 6: f(x)= 6.66733e+06
differential_evolution step 7: f(x)= 6.66733e+06
differential_evolution step 8: f(x)= 5.80729e+06
differential_evolution step 9: f(x)= 5.80729e+06
differential_evolution step 10: f(x)= 5.80729e+06
differential_evolution step 11: f(x)= 5.80729e+06
differential_evolution step 12: f(x)= 5.80729e+06
differential_evolution step 13: f(x)= 5.80729e+06
differential_evolution step 14: f(x)= 5.80729e+06
differential_evolution step 15: f(x)= 5.80729e+06
differential_evolution step 16: f(x)= 5.80729e+06
differential_evolution step 17: f(x)= 5.80729e+06
differential_evolution step 18: f(x)= 5.80729e+06
differential_evolution step 19: f(x)= 5.80729e+06
differential_evolution step 20: f(x)= 5.80729e+06
differential_evolution step 21: f(x)= 5.80729e+06
differential_evolution step 22: f(x)= 5.80729e+06
differential_evolution step 23: f(x)= 5.80729e+06
differential_evolution step 24: f(x)= 5.80729e+06
differential_evolution step 25: f(x)= 5.80729e+06
differential_evolution step 26: f(x)= 5.80729e+06
differential_evolution step 27: f(x)= 5.80729e+06
differential_evolution step 28: f(x)= 5.80729e+06
differential_evolution step 29: f(x)= 5.80729e+06
differential_evolution step 30: f(x)= 5.80729e+06
differential_evolution step 31: f(x)= 5.80729e+06
differential_evolution step 32: f(x)= 5.80729e+06
differential_evolution step 33: f(x)= 5.80729e+06
differential_evolution step 34: f(x)= 5.80729e+06
differential_evolution step 35: f(x)= 5.80729e+06
differential_evolution step 36: f(x)= 5.80729e+06
differential_evolution step 37: f(x)= 5.80729e+06
differential_evolution step 38: f(x)= 5.80729e+06
differential_evolution step 39: f(x)= 5.80729e+06
differential_evolution step 40: f(x)= 5.80729e+06
differential_evolution step 41: f(x)= 5.80729e+06
differential_evolution step 42: f(x)= 5.80729e+06
differential_evolution step 43: f(x)= 5.80729e+06
differential_evolution step 44: f(x)= 5.80729e+06
differential_evolution step 45: f(x)= 5.80729e+06
differential_evolution step 46: f(x)= 5.80729e+06
differential_evolution step 47: f(x)= 5.80729e+06
differential_evolution step 48: f(x)= 5.80729e+06
differential_evolution step 49: f(x)= 5.80729e+06
differential_evolution step 50: f(x)= 5.80729e+06
differential_evolution step 51: f(x)= 5.80729e+06
differential_evolution step 52: f(x)= 5.80729e+06
differential_evolution step 53: f(x)= 5.80729e+06
differential_evolution step 54: f(x)= 5.80729e+06
differential_evolution step 55: f(x)= 5.80729e+06
differential_evolution step 56: f(x)= 5.80729e+06
differential_evolution step 57: f(x)= 5.80729e+06
differential_evolution step 58: f(x)= 5.80729e+06
differential_evolution step 59: f(x)= 5.80729e+06
differential_evolution step 60: f(x)= 5.80729e+06
differential_evolution step 61: f(x)= 5.80729e+06
differential_evolution step 62: f(x)= 5.80729e+06
differential_evolution step 63: f(x)= 5.80729e+06
differential_evolution step 64: f(x)= 5.80729e+06
differential_evolution step 65: f(x)= 5.80729e+06
differential_evolution step 66: f(x)= 5.80729e+06
differential_evolution step 67: f(x)= 5.80729e+06
differential_evolution step 68: f(x)= 5.80729e+06
differential_evolution step 69: f(x)= 5.80729e+06
differential_evolution step 70: f(x)= 5.80729e+06
differential_evolution step 71: f(x)= 5.80729e+06
differential_evolution step 72: f(x)= 5.80729e+06
differential_evolution step 73: f(x)= 5.80729e+06
differential_evolution step 74: f(x)= 5.80729e+06
differential_evolution step 75: f(x)= 5.80729e+06
differential_evolution step 76: f(x)= 5.80729e+06
differential_evolution step 77: f(x)= 5.80729e+06
differential_evolution step 78: f(x)= 5.80729e+06
differential_evolution step 79: f(x)= 5.80729e+06
differential_evolution step 80: f(x)= 5.80729e+06
differential_evolution step 81: f(x)= 5.80729e+06
differential_evolution step 82: f(x)= 5.80729e+06
differential_evolution step 83: f(x)= 5.80729e+06
differential_evolution step 84: f(x)= 5.80729e+06
differential_evolution step 85: f(x)= 5.80729e+06
differential_evolution step 86: f(x)= 5.80729e+06
differential_evolution step 87: f(x)= 5.80729e+06
differential_evolution step 88: f(x)= 5.80729e+06
[2.62598999 5.34071978 3.42186642 2.82354412 2.61860091 3.91813672
4.15741651 6.73629882 5.59529611 4.64341206 2.36575502 3.42227157
2.17402135 3.81241576 2.80546971 0.49376903]
```python
controlDoF = 1
if controlDoF == 1:
thetas1 = policy
#Discretise thetas
thetas1[thetas1<5.6] = 1.8
thetas1[(thetas1>=5.6)&(thetas1<8)] = 6
thetas1[thetas1>=8] = 11.2
Ncs=[]
for i in range(policy.size):
Ncs.append(np.array([policy[i]]))
checkpoints = cH.constructHorizon(Ncs,period)
policyVect = cH.constructHorizonPlot(policy,period)
simtime = policy.size*period
elif controlDoF == 2:
# split policy vector in two
length = policy.size
middle_index = length//2
thetas1 = policy[:middle_index]
#Discretise thetas
thetas1[thetas1<5.6] = 1.8
thetas1[(thetas1>=5.6)&(thetas1<8)] = 6
thetas1[thetas1>=8] = 11.2
thetas2 = policy[middle_index:]
# add to separate lists
Ncs1=[]
for i in range(thetas1.size):
Ncs1.append(np.array([thetas1[i]]))
Ncs2=[]
for i in range(thetas2.size):
Ncs2.append(np.array([thetas2[i]]))
checkpoints = cH.constructHorizonTesting(Ncs1,Ncs2,period)
Ncvect,totalTestsvect = cH.constructHorizonTestingPlot(thetas1,thetas2,period)
simtime = thetas1.size*period
print(checkpoints)
```
{'t': array([ 7., 14., 21., 28., 35., 42., 49., 56., 63., 70., 77.,
84., 91., 98., 105.]), 'Nc': [array([1.8]), array([1.8]), array([1.8]), array([1.8]), array([1.8]), array([1.8]), array([6.]), array([1.8]), array([1.8]), array([1.8]), array([1.8]), array([1.8]), array([1.8]), array([1.8]), array([1.8])]}
```python
# # --------------
# # Run simulation
# # --------------
# Nc = np.array([thetas1[0]])
# totalTests = thetas2[0]
# simout=cH.simModel(initN,beta,Nc,zeta,dsm,dm,dhospital,dh,mc0,ICU,theta_S,theta_E,theta_SM,theta_M,theta_R,totalTests,psi_FP,psi_PP,
# dq,phi_S,phi_E,phi_SM,phi_R,initE, initSM, initM, initH, initC,initHH,initCH,initR,initF,initSQ,initEQ,initSMQ,initMQ,
# initRQ,simtime,monteCarlo,n_samples,method,modelType,checkpoints)
```
```python
# -------------------------------------------------------
# Plot Belgian results first from march 13th untill today
# -------------------------------------------------------
plt.figure(1)
t=pd.date_range('2020-03-13', freq='D', periods=ICUvect.size+int(extraTime)+simtime+1)-datetime.timedelta(days=int(extraTime))
t = np.linspace(0,t.size,t.size+1)
plt.figure(figsize=(7,5),dpi=100)
plt.scatter(t[int(extraTime):int(extraTime)+27],data_belgie.iloc[:,1],color="black",marker="v")
plt.plot(t[0:int(extraTime)+27],np.mean(simout['CH'],axis=1),color="black")
# --------------
# Run simulation
# --------------
Nc = np.array([thetas1[0]])
if controlDoF == 1:
totalTests = 0
elif controlDoF == 2:
totalTests = thetas2[0]
simout=cH.simModel(initN,beta,Nc,zeta,dsm,dm,dhospital,dh,mc0,ICU,theta_S,theta_E,theta_SM,theta_M,theta_R,totalTests,psi_FP,psi_PP,
dq,phi_S,phi_E,phi_SM,phi_R,initE, initSM, initM, initH, initC,initHH,initCH,initR,initF,initSQ,initEQ,initSMQ,initMQ,
initRQ,simtime,monteCarlo,n_samples,method,modelType,checkpoints)
# --------------------------
# Plot controller prediction
# --------------------------
plt.plot(t[int(extraTime)+27:-1],np.mean(simout['CH'],axis=1),color="red")
plt.fill_between(t[int(extraTime)+27:-1], np.percentile(simout['CH'],90,axis=1), np.percentile(simout['CH'],10,axis=1),color="red",alpha=0.2)
plt.legend(('ICU (actual)','ICU (prediction)'),loc='center left')
plt.xlabel('days')
plt.ylabel('number of patients')
thetas1[thetas1<5.6] = 0
thetas1[(thetas1>=5.6)&(thetas1<8)] = 1
thetas1[thetas1>=8] = 2
a = [0.3,0.10,0]
if period == 3:
plt.axvspan(int(extraTime)+4, int(extraTime)+27, alpha=0.3, color='black')
plt.axvspan(int(extraTime)+27, int(extraTime)+27+3, alpha=a[int(thetas1[0])], color='black')
plt.axvspan(int(extraTime)+27+3, int(extraTime)+27+6, alpha=a[int(thetas1[1])], color='black')
plt.axvspan(int(extraTime)+27+6, int(extraTime)+27+9, alpha=a[int(thetas1[2])], color='black')
plt.axvspan(int(extraTime)+27+9, int(extraTime)+27+12, alpha=a[int(thetas1[3])], color='black')
plt.axvspan(int(extraTime)+27+12, int(extraTime)+27+15, alpha=a[int(thetas1[4])], color='black')
plt.axvspan(int(extraTime)+27+15, int(extraTime)+27+18, alpha=a[int(thetas1[5])], color='black')
# als het negen intervallen is
plt.axvspan(int(extraTime)+27+18, int(extraTime)+27+21, alpha=a[int(thetas1[6])], color='black')
plt.axvspan(int(extraTime)+27+21, int(extraTime)+27+24, alpha=a[int(thetas1[7])], color='black')
plt.axvspan(int(extraTime)+27+24, int(extraTime)+27+27, alpha=a[int(thetas1[8])], color='black')
elif period == 7:
plt.axvspan(int(extraTime)+4, int(extraTime)+27, alpha=0.3, color='black')
plt.axvspan(int(extraTime)+27, int(extraTime)+27+7, alpha=a[int(thetas1[0])], color='black')
plt.axvspan(int(extraTime)+27+7, int(extraTime)+27+14, alpha=a[int(thetas1[1])], color='black')
plt.axvspan(int(extraTime)+27+14, int(extraTime)+27+21, alpha=a[int(thetas1[2])], color='black')
plt.axvspan(int(extraTime)+27+21, int(extraTime)+27+28, alpha=a[int(thetas1[3])], color='black')
plt.axvspan(int(extraTime)+27+28, int(extraTime)+27+35, alpha=a[int(thetas1[4])], color='black')
plt.axvspan(int(extraTime)+27+35, int(extraTime)+27+42, alpha=a[int(thetas1[5])], color='black')
# als het negen intervallen is
plt.axvspan(int(extraTime)+27+42, int(extraTime)+27+49, alpha=a[int(thetas1[6])], color='black')
plt.axvspan(int(extraTime)+27+49, int(extraTime)+27+56, alpha=a[int(thetas1[7])], color='black')
plt.axvspan(int(extraTime)+27+56, int(extraTime)+27+63, alpha=a[int(thetas1[8])], color='black')
# als het er zestien zijn
plt.axvspan(int(extraTime)+27+63, int(extraTime)+27+70, alpha=a[int(thetas1[9])], color='black')
plt.axvspan(int(extraTime)+27+70, int(extraTime)+27+77, alpha=a[int(thetas1[10])], color='black')
plt.axvspan(int(extraTime)+27+77, int(extraTime)+27+84, alpha=a[int(thetas1[11])], color='black')
plt.axvspan(int(extraTime)+27+84, int(extraTime)+27+91, alpha=a[int(thetas1[12])], color='black')
plt.axvspan(int(extraTime)+27+91, int(extraTime)+27+98, alpha=a[int(thetas1[13])], color='black')
plt.axvspan(int(extraTime)+27+98, int(extraTime)+27+105, alpha=a[int(thetas1[14])], color='black')
plt.axvspan(int(extraTime)+27+105, int(extraTime)+27+112, alpha=a[int(thetas1[15])], color='black')
elif period == 14:
plt.axvspan(int(extraTime)+4, int(extraTime)+27, alpha=0.3, color='black')
plt.axvspan(int(extraTime)+27, int(extraTime)+27+14, alpha=a[int(thetas1[0])], color='black')
plt.axvspan(int(extraTime)+27+14, int(extraTime)+27+28, alpha=a[int(thetas1[1])], color='black')
plt.axvspan(int(extraTime)+27+28, int(extraTime)+27+42, alpha=a[int(thetas1[2])], color='black')
plt.axvspan(int(extraTime)+27+42, int(extraTime)+27+56, alpha=a[int(thetas1[3])], color='black')
plt.axvspan(int(extraTime)+27+56, int(extraTime)+27+70, alpha=a[int(thetas1[4])], color='black')
plt.axvspan(int(extraTime)+27+70, int(extraTime)+27+84, alpha=a[int(thetas1[5])], color='black')
# als het negen intervallen is
plt.axvspan(int(extraTime)+27+84, int(extraTime)+27+98, alpha=a[int(thetas1[6])], color='black')
plt.axvspan(int(extraTime)+27+98, int(extraTime)+27+112, alpha=a[int(thetas1[7])], color='black')
plt.axvspan(int(extraTime)+27+112, int(extraTime)+27+126, alpha=a[int(thetas1[8])], color='black')
ax2 = plt.twinx()
totalTeststar = np.zeros(t.size)
totalTeststar[0:int(extraTime)+27] = 0
totalTeststar[int(extraTime)+27:-1] = totalTestsvect
plt.plot(t[0:-2],totalTeststar[0:-2],'--',color='black')
ax2.set_ylabel("Number of daily tracked infections")
plt.savefig('belgiumController.svg',dpi=100,bbox_inches='tight')
```
```python
#A biotech company in Iceland that has tested more than 9,000 people found that around 50 percent
#of those who tested positive said they were asymptomatic, the researchers told CNN.
model = models.SEIRSAgeModel(initN = np.array([11.43e6]),
beta = 0.032,
sigma = 5.2,
Nc = np.array([11.2]),
sm = 0.50,
m = (1-0.50)*0.81,
h = (1-0.50)*0.15,
c = (1-0.50)*0.04,
dsm = 14,
dm = 14,
dhospital = 1,
dh = 21,
dcf = 18.5,
dcr = 22.0,
mc0 = 0.49,
ICU = 2000,
totalTests = 0,
psi_FP = 0,
psi_PP = 1,
dq = 14,
initE = np.array([1]),
initSM = np.zeros(1),
initM = np.zeros(1),
initH = np.zeros(1),
initC = np.zeros(1),
initHH = np.zeros(1),
initCH = np.zeros(1),
initR = np.zeros(1),
initF = np.zeros(1),
initSQ = np.zeros(1),
initEQ = np.zeros(1),
initSMQ = np.zeros(1),
initMQ = np.zeros(1),
initRQ = np.zeros(1),
monteCarlo = False,
n_samples = 50
)
y = model.sim(70)
```
```python
model.plotPopulationStatus()
model.plotInfected()
```
```python
# make data vector
ICUvect= np.array([[5,24,33,53,79,100,130,164,238,290,322,381,474,605,690,789,867,927,1021,1088,1144,1205,1245,1261,1257,1260,1276,1285,1278,1262,1232,1234,1223]])
hospital = np.array([[58,97,163,264,368,496,648,841,1096,1380,1643,1881,2137,2715,3068,3640,4077,4468,4884,4975,5206,5358,5492,5509,5600,5738,5692,5590,5610,5635,5409,5393,5536]])
index=pd.date_range('2020-03-13', freq='D', periods=ICUvect.size)
idx=-26
index = index[0:idx]
print(index)
data=[np.transpose(ICUvect[:,0:idx]),np.transpose(hospital[:,0:idx])]
# set optimisation settings
bounds=[(10,60),(0.01,0.035)]
positions = [np.array([7]),np.array([6,7])]
# run optimisation
theta = model.fit(data,['beta'],positions,bounds,np.array([1,1]),setvar=True,maxiter=100)
model.plotFit(index,data,positions,modelClr=['red','orange'],legendText=('ICU (model)','ICU (data)','Hospital (model)','Hospital (data)'),titleText='Belgium')
```
```python
```
|
= = = Conspirators = = =
|
#include <gsl/gsl_spline.h>
typedef struct FastPMFDInterp{
size_t size;
gsl_interp * F;
gsl_interp * DF;
gsl_interp * DDF;
gsl_interp_accel * acc;
} FastPMFDInterp;
void fastpm_fd_interp_init(FastPMFDInterp * FDinterp);
double fastpm_do_fd_interp(FastPMFDInterp * FDinterp, int F_id, double y);
void fastpm_fd_interp_destroy(FastPMFDInterp * FDinterp);
|
Require Import Coq.Unicode.Utf8_core.
Require Import Coq.Program.Tactics.
Require Export Homotopy.Core.
Set Automatic Introduction.
Set Implicit Arguments.
Set Shrink Obligations.
Set Universe Polymorphism.
(** H-Levels *)
(* h-levels 0..2 *)
Definition is_contractible (A : Type) := {x : A & ∀ y : A, y ~ x}.
Definition is_prop (A : Type) := ∀ (x y : A), is_contractible (x ~ y).
Definition is_set (A : Type) := ∀ (x y : A), is_prop (x ~ y).
Program Fixpoint is_level (n: nat) (A: Type) : Type :=
match n with
| O => is_contractible A
| S n => ∀ (x y: A), is_level n (paths x y)
end.
Program Fixpoint n_path (n : nat) (A: Type) : Type :=
match n with
| O => ∀ (x y : A), x ~ y
| S n => ∀ (x y : A), n_path n (paths x y)
end.
Definition contractible := sigT is_contractible.
Definition prop := sigT is_prop.
Definition set := sigT is_set.
Definition level (n: nat) := sigT (is_level n).
Definition contractible_Type (p : contractible) := p.1.
Coercion contractible_Type : contractible >-> Sortclass.
Definition prop_Type (p : prop) := p.1.
Coercion prop_Type : prop >-> Sortclass.
Definition set_Type (p : set) := p.1.
Coercion set_Type : set >-> Sortclass.
Definition level_Type {n} (p : level n) := p.1.
Coercion level_Type : level >-> Sortclass.
Class is_category1 (C : category) :=
is_category1_prop : ∀ {x y : C}, is_set (x ~> y).
Class is_thin (C : category) :=
is_thin_prop : ∀ {x y : C}, is_prop (x ~> y).
Class is_strict (C : category) :=
is_strict_prop : is_set C.
|
prelude
import init.core init.system.io init.data.ordering
universe u v w
inductive Rbcolor
| red | black
inductive Rbnode (α : Type u) (β : α → Type v)
| leaf {} : Rbnode
| Node (c : Rbcolor) (lchild : Rbnode) (key : α) (val : β key) (rchild : Rbnode) : Rbnode
instance Rbcolor.DecidableEq : DecidableEq Rbcolor :=
{decEq := fun a b => Rbcolor.casesOn a
(Rbcolor.casesOn b (isTrue rfl) (isFalse (fun h => Rbcolor.noConfusion h)))
(Rbcolor.casesOn b (isFalse (fun h => Rbcolor.noConfusion h)) (isTrue rfl))}
namespace Rbnode
variable {α : Type u} {β : α → Type v} {σ : Type w}
open Rbcolor
def depth (f : Nat → Nat → Nat) : Rbnode α β → Nat
| leaf => 0
| Node _ l _ _ r => (f (depth l) (depth r)) + 1
protected def min : Rbnode α β → Option (Sigma (fun k => β k))
| leaf => none
| Node _ leaf k v _ => some ⟨k, v⟩
| Node _ l k v _ => min l
protected def max : Rbnode α β → Option (Sigma (fun k => β k))
| leaf => none
| Node _ _ k v leaf => some ⟨k, v⟩
| Node _ _ k v r => max r
@[specialize] def fold (f : ∀ (k : α), β k → σ → σ) : Rbnode α β → σ → σ
| leaf, b => b
| Node _ l k v r, b => fold r (f k v (fold l b))
@[specialize] def revFold (f : ∀ (k : α), β k → σ → σ) : Rbnode α β → σ → σ
| leaf, b => b
| Node _ l k v r, b => revFold l (f k v (revFold r b))
@[specialize] def all (p : ∀ (k : α), β k → Bool) : Rbnode α β → Bool
| leaf => true
| Node _ l k v r => p k v && all l && all r
@[specialize] def any (p : ∀ (k : α), β k → Bool) : Rbnode α β → Bool
| leaf => false
| Node _ l k v r => p k v || any l || any r
def isRed : Rbnode α β → Bool
| Node red _ _ _ _ => true
| _ => false
def rotateLeft : ∀ (n : Rbnode α β), n ≠ leaf → Rbnode α β
| n@(Node hc hl hk hv (Node red xl xk xv xr)), _ =>
if !isRed hl
then (Node hc (Node red hl hk hv xl) xk xv xr)
else n
| leaf, h => absurd rfl h
| e, _ => e
theorem ifNodeNodeNeLeaf {c : Prop} [Decidable c] {l1 l2 : Rbnode α β} {c1 k1 v1 r1 c2 k2 v2 r2} : (if c then Node c1 l1 k1 v1 r1 else Node c2 l2 k2 v2 r2) ≠ leaf :=
fun h => if hc : c
then have h1 : (if c then Node c1 l1 k1 v1 r1 else Node c2 l2 k2 v2 r2) = Node c1 l1 k1 v1 r1 from ifPos hc;
Rbnode.noConfusion (Eq.trans h1.symm h)
else have h1 : (if c then Node c1 l1 k1 v1 r1 else Node c2 l2 k2 v2 r2) = Node c2 l2 k2 v2 r2 from ifNeg hc;
Rbnode.noConfusion (Eq.trans h1.symm h)
theorem rotateLeftNeLeaf : ∀ (n : Rbnode α β) (h : n ≠ leaf), rotateLeft n h ≠ leaf
| Node _ hl _ _ (Node red _ _ _ _), _, h => ifNodeNodeNeLeaf h
| leaf, h, _ => absurd rfl h
| Node _ _ _ _ (Node black _ _ _ _), _, h => Rbnode.noConfusion h
def rotateRight : ∀ (n : Rbnode α β), n ≠ leaf → Rbnode α β
| n@(Node hc (Node red xl xk xv xr) hk hv hr), _ =>
if isRed xl
then (Node hc xl xk xv (Node red xr hk hv hr))
else n
| leaf, h => absurd rfl h
| e, _ => e
theorem rotateRightNeLeaf : ∀ (n : Rbnode α β) (h : n ≠ leaf), rotateRight n h ≠ leaf
| Node _ (Node red _ _ _ _) _ _ _, _, h => ifNodeNodeNeLeaf h
| leaf, h, _ => absurd rfl h
| Node _ (Node black _ _ _ _) _ _ _, _, h => Rbnode.noConfusion h
def flip : Rbcolor → Rbcolor
| red => black
| black => red
def flipColor : Rbnode α β → Rbnode α β
| Node c l k v r => Node (flip c) l k v r
| leaf => leaf
def flipColors : ∀ (n : Rbnode α β), n ≠ leaf → Rbnode α β
| n@(Node c l k v r), _ =>
if isRed l ∧ isRed r
then Node (flip c) (flipColor l) k v (flipColor r)
else n
| leaf, h => absurd rfl h
def fixup (n : Rbnode α β) (h : n ≠ leaf) : Rbnode α β :=
let n₁ := rotateLeft n h;
let h₁ := (rotateLeftNeLeaf n h);
let n₂ := rotateRight n₁ h₁;
let h₂ := (rotateRightNeLeaf n₁ h₁);
flipColors n₂ h₂
def setBlack : Rbnode α β → Rbnode α β
| Node red l k v r => Node black l k v r
| n => n
section insert
variable (lt : α → α → Prop) [DecidableRel lt]
def ins (x : α) (vx : β x) : Rbnode α β → Rbnode α β
| leaf => Node red leaf x vx leaf
| Node c l k v r =>
if lt x k then fixup (Node c (ins l) k v r) (fun h => Rbnode.noConfusion h)
else if lt k x then fixup (Node c l k v (ins r)) (fun h => Rbnode.noConfusion h)
else Node c l x vx r
def insert (t : Rbnode α β) (k : α) (v : β k) : Rbnode α β :=
setBlack (ins lt k v t)
end insert
section membership
variable (lt : α → α → Prop)
variable [DecidableRel lt]
def findCore : Rbnode α β → ∀ (k : α), Option (Sigma (fun k => β k))
| leaf, x => none
| Node _ a ky vy b, x =>
(match cmpUsing lt x ky with
| Ordering.lt => findCore a x
| Ordering.Eq => some ⟨ky, vy⟩
| Ordering.gt => findCore b x)
def find {β : Type v} : Rbnode α (fun _ => β) → α → Option β
| leaf, x => none
| Node _ a ky vy b, x =>
(match cmpUsing lt x ky with
| Ordering.lt => find a x
| Ordering.Eq => some vy
| Ordering.gt => find b x)
def lowerBound : Rbnode α β → α → Option (Sigma β) → Option (Sigma β)
| leaf, x, lb => lb
| Node _ a ky vy b, x, lb =>
(match cmpUsing lt x ky with
| Ordering.lt => lowerBound a x lb
| Ordering.Eq => some ⟨ky, vy⟩
| Ordering.gt => lowerBound b x (some ⟨ky, vy⟩))
end membership
inductive WellFormed (lt : α → α → Prop) : Rbnode α β → Prop
| leafWff : WellFormed leaf
| insertWff {n n' : Rbnode α β} {k : α} {v : β k} [DecidableRel lt] : WellFormed n → n' = insert lt n k v → WellFormed n'
end Rbnode
open Rbnode
/- TODO(Leo): define dRbmap -/
def Rbmap (α : Type u) (β : Type v) (lt : α → α → Prop) : Type (max u v) :=
{t : Rbnode α (fun _ => β) // t.WellFormed lt }
@[inline] def mkRbmap (α : Type u) (β : Type v) (lt : α → α → Prop) : Rbmap α β lt :=
⟨leaf, WellFormed.leafWff lt⟩
namespace Rbmap
variable {α : Type u} {β : Type v} {σ : Type w} {lt : α → α → Prop}
def depth (f : Nat → Nat → Nat) (t : Rbmap α β lt) : Nat :=
t.val.depth f
@[inline] def fold (f : α → β → σ → σ) : Rbmap α β lt → σ → σ
| ⟨t, _⟩, b => t.fold f b
@[inline] def revFold (f : α → β → σ → σ) : Rbmap α β lt → σ → σ
| ⟨t, _⟩, b => t.revFold f b
@[inline] def empty : Rbmap α β lt → Bool
| ⟨leaf, _⟩ => true
| _ => false
@[specialize] def toList : Rbmap α β lt → List (α × β)
| ⟨t, _⟩ => t.revFold (fun k v ps => (k, v)::ps) []
@[inline] protected def min : Rbmap α β lt → Option (α × β)
| ⟨t, _⟩ =>
match t.min with
| some ⟨k, v⟩ => some (k, v)
| none => none
@[inline] protected def max : Rbmap α β lt → Option (α × β)
| ⟨t, _⟩ =>
match t.max with
| some ⟨k, v⟩ => some (k, v)
| none => none
instance [Repr α] [Repr β] : Repr (Rbmap α β lt) :=
⟨fun t => "rbmapOf " ++ repr t.toList⟩
variable [DecidableRel lt]
def insert : Rbmap α β lt → α → β → Rbmap α β lt
| ⟨t, w⟩, k, v => ⟨t.insert lt k v, WellFormed.insertWff w rfl⟩
@[specialize] def ofList : List (α × β) → Rbmap α β lt
| [] => mkRbmap _ _ _
| ⟨k,v⟩::xs => (ofList xs).insert k v
def findCore : Rbmap α β lt → α → Option (Sigma (fun (k : α) => β))
| ⟨t, _⟩, x => t.findCore lt x
def find : Rbmap α β lt → α → Option β
| ⟨t, _⟩, x => t.find lt x
/-- (lowerBound k) retrieves the kv pair of the largest key smaller than or equal to `k`,
if it exists. -/
def lowerBound : Rbmap α β lt → α → Option (Sigma (fun (k : α) => β))
| ⟨t, _⟩, x => t.lowerBound lt x none
@[inline] def contains (t : Rbmap α β lt) (a : α) : Bool :=
(t.find a).isSome
def fromList (l : List (α × β)) (lt : α → α → Prop) [DecidableRel lt] : Rbmap α β lt :=
l.foldl (fun r p => r.insert p.1 p.2) (mkRbmap α β lt)
@[inline] def all : Rbmap α β lt → (α → β → Bool) → Bool
| ⟨t, _⟩, p => t.all p
@[inline] def any : Rbmap α β lt → (α → β → Bool) → Bool
| ⟨t, _⟩, p => t.any p
end Rbmap
def rbmapOf {α : Type u} {β : Type v} (l : List (α × β)) (lt : α → α → Prop) [DecidableRel lt] : Rbmap α β lt :=
Rbmap.fromList l lt
/- Test -/
@[reducible] def map : Type := Rbmap Nat Bool Less.Less
def mkMapAux : Nat → map → map
| 0, m => m
| n+1, m => mkMapAux n (m.insert n (n % 10 = 0))
def mkMap (n : Nat) :=
mkMapAux n (mkRbmap Nat Bool Less.Less)
def main (xs : List String) : IO UInt32 :=
let m := mkMap xs.head.toNat;
let v := Rbmap.fold (fun (k : Nat) (v : Bool) (r : Nat) => if v then r + 1 else r) m 0;
IO.println (toString v) *>
pure 0
|
This editor can edit this entry and tell us a bit about themselves by clicking the Edit icon.
Hey Johnathon, and welcome to the wiki! My names Evan, pleased to meet you. Thanks for contributing all the reviews, but keep in mind that youre welcome to add your opinions directly to the text of the entry. The wiki incorporates all kinds of viewpoints from the folk of Davis, and you can edit anything on the wiki (as can everybody else). Just click the Edit icon next to the page title. Once again, welcome to the wiki! Users/JabberWokky Evan JabberWokky Edwards
|
/-
Copyright (c) 2022 Adam Topaz. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Adam Topaz, Junyan Xu
-/
import ring_theory.localization.localization_localization
/-!
# Localizations of domains as subalgebras of the fraction field.
Given a domain `A` with fraction field `K`, and a submonoid `S` of `A` which
does not contain zero, this file constructs the localization of `A` at `S`
as a subalgebra of the field `K` over `A`.
-/
namespace localization
open_locale non_zero_divisors
variables {A : Type*} (K : Type*) [comm_ring A] (S : submonoid A) (hS : S ≤ A⁰)
section comm_ring
variables [comm_ring K] [algebra A K] [is_fraction_ring A K]
lemma map_is_unit_of_le (hS : S ≤ A⁰) (s : S) : is_unit (algebra_map A K s) :=
by apply is_localization.map_units K (⟨s.1, hS s.2⟩ : A⁰)
/-- The canonical map from a localization of `A` at `S` to the fraction ring
of `A`, given that `S ≤ A⁰`. -/
noncomputable
def map_to_fraction_ring (B : Type*) [comm_ring B] [algebra A B]
[is_localization S B] (hS : S ≤ A⁰) :
B →ₐ[A] K :=
{ commutes' := λ a, by simp,
..is_localization.lift (map_is_unit_of_le K S hS) }
@[simp]
lemma map_to_fraction_ring_apply {B : Type*} [comm_ring B] [algebra A B]
[is_localization S B] (hS : S ≤ A⁰) (b : B) :
map_to_fraction_ring K S B hS b = is_localization.lift (map_is_unit_of_le K S hS) b := rfl
lemma mem_range_map_to_fraction_ring_iff (B : Type*) [comm_ring B] [algebra A B]
[is_localization S B] (hS : S ≤ A⁰) (x : K) :
x ∈ (map_to_fraction_ring K S B hS).range ↔
∃ (a s : A) (hs : s ∈ S), x = is_localization.mk' K a ⟨s, hS hs⟩ :=
⟨ by { rintro ⟨x,rfl⟩, obtain ⟨a,s,rfl⟩ := is_localization.mk'_surjective S x,
use [a, s, s.2], apply is_localization.lift_mk' },
by { rintro ⟨a,s,hs,rfl⟩, use is_localization.mk' _ a ⟨s,hs⟩,
apply is_localization.lift_mk' } ⟩
instance is_localization_range_map_to_fraction_ring (B : Type*) [comm_ring B] [algebra A B]
[is_localization S B] (hS : S ≤ A⁰) :
is_localization S (map_to_fraction_ring K S B hS).range :=
is_localization.is_localization_of_alg_equiv S $ show B ≃ₐ[A] _, from alg_equiv.of_bijective
(map_to_fraction_ring K S B hS).range_restrict
begin
refine ⟨λ a b h, _, set.surjective_onto_range⟩,
refine (is_localization.lift_injective_iff _).2 (λ a b, _) (subtype.ext_iff.1 h),
exact ⟨λ h, congr_arg _ (is_localization.injective _ hS h),
λ h, congr_arg _ (is_fraction_ring.injective A K h)⟩,
end
instance is_fraction_ring_range_map_to_fraction_ring
(B : Type*) [comm_ring B] [algebra A B]
[is_localization S B] (hS : S ≤ A⁰) :
is_fraction_ring (map_to_fraction_ring K S B hS).range K :=
is_fraction_ring.is_fraction_ring_of_is_localization S _ _ hS
/--
Given a commutative ring `A` with fraction ring `K`, and a submonoid `S` of `A` which
contains no zero divisor, this is the localization of `A` at `S`, considered as
a subalgebra of `K` over `A`.
The carrier of this subalgebra is defined as the set of all `x : K` of the form
`is_localization.mk' K a ⟨s, _⟩`, where `s ∈ S`.
-/
noncomputable
def subalgebra (hS : S ≤ A⁰) : subalgebra A K :=
(map_to_fraction_ring K S (localization S) hS).range.copy
{ x | ∃ (a s : A) (hs : s ∈ S), x = is_localization.mk' K a ⟨s, hS hs⟩ } $
by { ext, symmetry, apply mem_range_map_to_fraction_ring_iff }
namespace subalgebra
instance is_localization_subalgebra :
is_localization S (subalgebra K S hS) :=
by { dunfold localization.subalgebra, rw subalgebra.copy_eq, apply_instance }
instance is_fraction_ring : is_fraction_ring (subalgebra K S hS) K :=
is_fraction_ring.is_fraction_ring_of_is_localization S _ _ hS
end subalgebra
end comm_ring
section field
variables [field K] [algebra A K] [is_fraction_ring A K]
namespace subalgebra
lemma mem_range_map_to_fraction_ring_iff_of_field
(B : Type*) [comm_ring B] [algebra A B] [is_localization S B] (x : K) :
x ∈ (map_to_fraction_ring K S B hS).range ↔
∃ (a s : A) (hs : s ∈ S), x = algebra_map A K a * (algebra_map A K s)⁻¹ :=
begin
rw mem_range_map_to_fraction_ring_iff,
iterate 3 { congr' with }, convert iff.rfl, rw units.coe_inv, refl,
end
/--
Given a domain `A` with fraction field `K`, and a submonoid `S` of `A` which
contains no zero divisor, this is the localization of `A` at `S`, considered as
a subalgebra of `K` over `A`.
The carrier of this subalgebra is defined as the set of all `x : K` of the form
`algebra_map A K a * (algebra_map A K s)⁻¹` where `a s : A` and `s ∈ S`.
-/
noncomputable
def of_field : _root_.subalgebra A K :=
(map_to_fraction_ring K S (localization S) hS).range.copy
{ x | ∃ (a s : A) (hs : s ∈ S), x = algebra_map A K a * (algebra_map A K s)⁻¹ } $
by { ext, symmetry, apply mem_range_map_to_fraction_ring_iff_of_field }
instance is_localization_of_field :
is_localization S (subalgebra.of_field K S hS) :=
by { dunfold localization.subalgebra.of_field, rw subalgebra.copy_eq, apply_instance }
instance is_fraction_ring_of_field : is_fraction_ring (subalgebra.of_field K S hS) K :=
is_fraction_ring.is_fraction_ring_of_is_localization S _ _ hS
end subalgebra
end field
end localization
|
Estudio comparativo entre aislados clínicos y no clínicos de S. cerevisiae y su papel como patógeno emergente.
Saccharomyces cerevisiae has traditionally been used in industrial fermentative processes, beer and wine production, baking, and as a nutritional supplement or even as a probiotic. This is the case of the probiotic strain of this species, S. cerevisiae var. boulardii which has been widely used in Europe to treat several types of diarrhoea. Although S. cerevisiae and S. boulardii have commonly been considered as safe microorganism, this concept has changed due to an increased number of human infections. Consequently, S. cerevisiae is now considered an emerging opportunistic pathogen that can cause clinically relevant infections, mainly associated with immunocompromised patients. With the aim of know the possible role of this yeast as an opportunistic pathogen, the present work tackles a comparative study between clinical and no clinical isolates of S. cerevisiae from different point of view. This study could be of great interest for all food industry that include S. cerevisiae inside their preparation, just as in the hospital environment, warning of the risk that entail the administration of products which contain the above mentioned yeast to immunosuppressed person. |
[STATEMENT]
lemma [simp]: "fvs(map Val vs) = {}"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. fvs (map Val vs) = {}
[PROOF STEP]
by (induct vs) auto |
/-
Copyright (c) 2021 Yury Kudryashov. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Yury Kudryashov
-/
import logic.equiv.basic
/-!
# Extra lemmas about `ulift` and `plift`
> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
> Any changes to this file require a corresponding PR to mathlib4.
In this file we provide `subsingleton`, `unique`, `decidable_eq`, and `is_empty` instances for
`ulift α` and `plift α`. We also prove `ulift.forall`, `ulift.exists`, `plift.forall`, and
`plift.exists`.
-/
universes u v
open function
namespace plift
variables {α : Sort u} {β : Sort v}
instance [subsingleton α] : subsingleton (plift α) := equiv.plift.subsingleton
instance [nonempty α] : nonempty (plift α) := equiv.plift.nonempty
instance [unique α] : unique (plift α) := equiv.plift.unique
instance [decidable_eq α] : decidable_eq (plift α) := equiv.plift.decidable_eq
instance [is_empty α] : is_empty (plift α) := equiv.plift.is_empty
lemma up_injective : injective (@up α) := equiv.plift.symm.injective
lemma up_surjective : surjective (@up α) := equiv.plift.symm.surjective
lemma up_bijective : bijective (@up α) := equiv.plift.symm.bijective
@[simp] lemma up_inj {x y : α} : up x = up y ↔ x = y := up_injective.eq_iff
lemma down_surjective : surjective (@down α) := equiv.plift.surjective
lemma down_bijective : bijective (@down α) := equiv.plift.bijective
@[simp] lemma «forall» {p : plift α → Prop} : (∀ x, p x) ↔ ∀ x : α, p (plift.up x) :=
up_surjective.forall
@[simp] lemma «exists» {p : plift α → Prop} : (∃ x, p x) ↔ ∃ x : α, p (plift.up x) :=
up_surjective.exists
end plift
namespace ulift
variables {α : Type u} {β : Type v}
instance [subsingleton α] : subsingleton (ulift α) := equiv.ulift.subsingleton
instance [nonempty α] : nonempty (ulift α) := equiv.ulift.nonempty
instance [unique α] : unique (ulift α) := equiv.ulift.unique
instance [decidable_eq α] : decidable_eq (ulift α) := equiv.ulift.decidable_eq
instance [is_empty α] : is_empty (ulift α) := equiv.ulift.is_empty
lemma up_injective : injective (@up α) := equiv.ulift.symm.injective
lemma up_surjective : surjective (@up α) := equiv.ulift.symm.surjective
lemma up_bijective : bijective (@up α) := equiv.ulift.symm.bijective
@[simp] lemma up_inj {x y : α} : up x = up y ↔ x = y := up_injective.eq_iff
lemma down_surjective : surjective (@down α) := equiv.ulift.surjective
lemma down_bijective : bijective (@down α) := equiv.ulift.bijective
@[simp] lemma «forall» {p : ulift α → Prop} : (∀ x, p x) ↔ ∀ x : α, p (ulift.up x) :=
up_surjective.forall
@[simp] lemma «exists» {p : ulift α → Prop} : (∃ x, p x) ↔ ∃ x : α, p (ulift.up x) :=
up_surjective.exists
end ulift
|
-- Idris2
import System
import System.Concurrency
||| Test releasing without acquiring errors correctly
main : IO ()
main =
do m <- makeMutex
mutexRelease m
putStrLn "Released w/o acquiring (SHOULDN'T HAPPEN)"
|
\section{Global definitions}
\label{sec:formalisations:global_definitions}
This section defines a multiplicity, which is a two tuple consisting of a lower and upper bound. In Ecore, the notion of a multiplicity is used within a field signature (\cref{defin:formalisations:ecore_formalisation:type_models:type_model}) in order to specify a limit on the allowed amount of values for a field. In GROOVE, multiplicities are used to bound the number of incoming and outgoing edges for each node type via multiplicity pairs (\cref{defin:formalisations:groove_formalisation:type_graphs:multiplicity_pair}).
\begin{defin}[Multiplicity]
\label{defin:formalisations:global_definitions:multiplicity}
A multiplicity is a two tuple consisting of a lower bound (which is any natural number) and an upper bound (which is possibly unbounded).
\begin{equation*}
\mathbb{M} \subseteq (\mathbb{N} \times \mathbb{N^+} \cup {\mstar})\ \cap \leq
\end{equation*}
The first value represents the lower bound, the second value of the tuple represents the upper bound. The set of multiplicities $\mathbb{M}$ is formally defined as
\begin{equation*}
\mathbb{M} = \{ (l, u) \mid l \in \mathbb{N} \land u \in (\mathbb{N^+} \cup {\mstar}) \land l \leq u \}
\end{equation*}
It holds that $\mstar$ is larger than each natural number, so $\forall n \in \mathbb{N}: n < \mstar$. Furthermore, the notation $l..u$ is used to denote $(l, u) \in \mathbb{M}$.
Finally, any natural number $n$ is said to be part of a multiplicity if it is within bounds, meaning:
\begin{equation*}
\forall m = l..u \in \mathbb{M}, n \in \mathbb{N} : n \in m \Leftrightarrow l \leq n \leq u
\end{equation*}
\isabellelref{multiplicity}{Ecore.Multiplicity}
\end{defin} |
/*
Copyright (C) 2003-2013 by David White <[email protected]>
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 should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "graphics.hpp"
#include <boost/shared_ptr.hpp>
#include <map>
#include <vector>
#include <sstream>
#include "asserts.hpp"
#include "custom_object_type.hpp"
#include "filesystem.hpp"
#include "foreach.hpp"
#include "formatter.hpp"
#include "frame.hpp"
#include "geometry.hpp"
#include "json_parser.hpp"
#include "module.hpp"
#include "string_utils.hpp"
#include "surface.hpp"
#include "surface_cache.hpp"
#include "unit_test.hpp"
#include "variant_utils.hpp"
#include "IMG_savepng.h"
void UTILITY_query(const std::vector<std::string>& args);
namespace {
const int TextureImageSize = 1024;
struct animation_area {
explicit animation_area(variant node) : anim(new frame(node)), is_particle(false)
{
width = 0;
height = 0;
foreach(const frame::frame_info& f, anim->frame_layout()) {
width += f.area.w();
if(f.area.h() > height) {
height = f.area.h();
}
}
src_image = node["image"].as_string();
dst_image = -1;
}
boost::intrusive_ptr<frame> anim;
int width, height;
std::string src_image;
int dst_image;
rect dst_area;
bool is_particle;
};
typedef boost::shared_ptr<animation_area> animation_area_ptr;
bool operator==(const animation_area& a, const animation_area& b)
{
return a.src_image == b.src_image && a.anim->area() == b.anim->area() && a.anim->pad() == b.anim->pad() && a.anim->num_frames() == b.anim->num_frames() && a.anim->num_frames_per_row() == b.anim->num_frames_per_row();
}
std::set<animation_area_ptr> animation_areas_with_alpha;
bool animation_area_height_compare(animation_area_ptr a, animation_area_ptr b)
{
if(a->is_particle != b->is_particle) {
return a->is_particle;
}
if(animation_areas_with_alpha.count(a) != animation_areas_with_alpha.count(b)) {
return animation_areas_with_alpha.count(a) != 0;
}
return a->height > b->height;
}
struct output_area {
explicit output_area(int n) : image_id(n)
{
area = rect(0, 0, TextureImageSize, TextureImageSize);
}
int image_id;
rect area;
};
rect use_output_area(const output_area& input, int width, int height, std::vector<output_area>& areas)
{
ASSERT_LE(width, input.area.w());
ASSERT_LE(height, input.area.h());
rect result(input.area.x(), input.area.y(), width, height);
if(input.area.h() > height) {
areas.push_back(output_area(input.image_id));
areas.back().area = rect(input.area.x(), input.area.y() + height, input.area.w(), input.area.h() - height);
}
if(input.area.w() > width) {
areas.push_back(output_area(input.image_id));
areas.back().area = rect(input.area.x() + width, input.area.y(), input.area.w() - width, height);
}
return result;
}
}
namespace graphics {
void set_alpha_for_transparent_colors_in_rgba_surface(SDL_Surface* s, int options=0);
}
namespace {
bool animation_area_has_alpha_channel(animation_area_ptr anim)
{
using namespace graphics;
surface surf = graphics::surface_cache::get(anim->src_image);
if(!surf || surf->format->BytesPerPixel != 4) {
return false;
}
const uint32_t* pixels = reinterpret_cast<const uint32_t*>(surf->pixels);
for(int f = 0; f != anim->anim->num_frames(); ++f) {
const frame::frame_info& info = anim->anim->frame_layout()[f];
const int x = f%anim->anim->num_frames_per_row();
const int y = f/anim->anim->num_frames_per_row();
const rect& base_area = anim->anim->area();
const int xpos = base_area.x() + (base_area.w()+anim->anim->pad())*x;
const int ypos = base_area.y() + (base_area.h()+anim->anim->pad())*y;
SDL_Rect blit_src = {xpos + info.x_adjust, ypos + info.y_adjust, info.area.w(), info.area.h()};
for(int x = 0; x != blit_src.w; ++x) {
for(int y = 0; y != blit_src.h; ++y) {
const int index = (blit_src.y + y)*surf->w + (blit_src.x + x);
const uint32_t pixel = pixels[index];
const uint32_t mask = (pixels[index]&surf->format->Amask);
if(mask != 0 && mask != surf->format->Amask) {
return true;
}
}
}
}
return false;
}
}
UTILITY(compile_objects)
{
#ifndef IMPLEMENT_SAVE_PNG
std::cerr
<< "This build wasn't done with IMPLEMENT_SAVE_PNG defined. "
<< "Consquently image files will not be written, aborting requested operation."
<< std::endl;
return;
#endif
using graphics::surface;
int num_output_images = 0;
std::vector<output_area> output_areas;
output_areas.push_back(output_area(num_output_images++));
std::map<variant, std::string> nodes_to_files;
std::vector<variant> objects;
std::vector<animation_area_ptr> animation_areas;
std::map<variant, animation_area_ptr> nodes_to_animation_areas;
std::vector<variant> animation_containing_nodes;
std::vector<std::string> no_compile_images;
variant gui_node = json::parse_from_file("data/gui.cfg");
animation_containing_nodes.push_back(gui_node);
std::map<std::string, variant> gui_nodes;
std::vector<std::string> gui_files;
module::get_files_in_dir("data/gui", &gui_files);
foreach(const std::string& gui, gui_files) {
if(gui[0] == '.') {
continue;
}
gui_nodes[gui] = json::parse_from_file("data/gui/" + gui);
animation_containing_nodes.push_back(gui_nodes[gui]);
if(gui_nodes[gui].has_key("no_compile_image")) {
std::vector<std::string> images = util::split(gui_nodes[gui][variant("no_compile_image")].as_string());
no_compile_images.insert(no_compile_images.end(), images.begin(), images.end());
}
}
std::vector<const_custom_object_type_ptr> types = custom_object_type::get_all();
foreach(const_custom_object_type_ptr type, types) {
const std::string* path = custom_object_type::get_object_path(type->id() + ".cfg");
//skip any experimental stuff so it isn't compiled
const std::string Experimental = "experimental";
if(std::search(path->begin(), path->end(), Experimental.begin(), Experimental.end()) != path->end()) {
continue;
}
std::cerr << "OBJECT: " << type->id() << " -> " << *path << "\n";
variant obj_node = json::parse_from_file(*path);
obj_node = custom_object_type::merge_prototype(obj_node);
obj_node.remove_attr(variant("prototype"));
if(obj_node["editor_info"].is_map() && obj_node["editor_info"]["var"].is_list()) {
std::vector<std::string> names;
foreach(variant entry, obj_node["editor_info"]["var"].as_list()) {
names.push_back(entry["name"].as_string());
}
if(names.empty() == false) {
std::map<variant, variant> m;
if(obj_node["vars"].is_map()) {
m = obj_node["vars"].as_map();
}
foreach(const std::string& name, names) {
variant v(name);
if(m.count(v) == 0) {
m[v] = variant();
}
}
obj_node.add_attr(variant("vars"), variant(&m));
}
}
objects.push_back(obj_node);
nodes_to_files[obj_node] = "data/compiled/objects/" + type->id() + ".cfg";
if(obj_node.has_key("no_compile_image")) {
std::vector<std::string> images = util::split(obj_node["no_compile_image"].as_string());
no_compile_images.insert(no_compile_images.end(), images.begin(), images.end());
}
animation_containing_nodes.push_back(obj_node);
foreach(variant v, obj_node["particle_system"].as_list()) {
animation_containing_nodes.push_back(v);
}
//add nested objects -- disabled for now until we find bugs in it.
/*
for(wml::node::child_iterator i = obj_node->begin_child("object_type"); i != obj_node->end_child("object_type"); ++i) {
animation_containing_nodes.push_back(i->second);
}
*/
}
foreach(variant node, animation_containing_nodes) {
foreach(const variant_pair& p, node.as_map()) {
std::string attr_name = p.first.as_string();
if(attr_name != "animation" && attr_name != "framed_gui_element" && attr_name != "section") {
continue;
}
foreach(const variant& v, p.second.as_list()) {
animation_area_ptr anim(new animation_area(v));
if(anim->src_image.empty() || v.has_key(variant("palettes")) || std::find(no_compile_images.begin(), no_compile_images.end(), anim->src_image) != no_compile_images.end()) {
continue;
}
animation_areas.push_back(anim);
foreach(animation_area_ptr area, animation_areas) {
if(*area == *anim) {
anim = area;
break;
}
}
if(attr_name == "particle_system") {
anim->is_particle = true;
}
if(anim != animation_areas.back()) {
animation_areas.pop_back();
}
nodes_to_animation_areas[v] = anim;
if(animation_area_has_alpha_channel(anim)) {
animation_areas_with_alpha.insert(anim);
}
}
}
}
std::sort(animation_areas.begin(), animation_areas.end(), animation_area_height_compare);
{
std::vector<animation_area_ptr> animation_areas_alpha;
}
foreach(animation_area_ptr anim, animation_areas) {
ASSERT_LOG(anim->width <= 1024 && anim->height <= 1024,
"Bad animation area " << anim->width << "x" << anim->height << " for " << anim->src_image << ". Must be 1024x1024 or less.");
int match = -1;
int match_diff = -1;
for(int n = 0; n != output_areas.size(); ++n) {
if(anim->width <= output_areas[n].area.w() && anim->height <= output_areas[n].area.h()) {
const int diff = output_areas[n].area.w()*output_areas[n].area.h() - anim->width*anim->height;
if(match == -1 || diff < match_diff) {
match = n;
match_diff = diff;
}
}
}
if(match == -1) {
match = output_areas.size();
output_areas.push_back(output_area(num_output_images++));
}
output_area match_area = output_areas[match];
output_areas.erase(output_areas.begin() + match);
rect area = use_output_area(match_area, anim->width, anim->height, output_areas);
anim->dst_image = match_area.image_id;
anim->dst_area = area;
}
std::vector<surface> surfaces;
for(int n = 0; n != num_output_images; ++n) {
surfaces.push_back(surface(SDL_CreateRGBSurface(0,TextureImageSize,TextureImageSize,32,SURFACE_MASK)));
}
foreach(animation_area_ptr anim, animation_areas) {
foreach(animation_area_ptr other, animation_areas) {
if(anim == other || anim->dst_image != other->dst_image) {
continue;
}
ASSERT_LOG(rects_intersect(anim->dst_area, other->dst_area) == false, "RECTANGLES CLASH: " << anim->dst_image << " " << anim->dst_area << " vs " << other->dst_area);
}
ASSERT_INDEX_INTO_VECTOR(anim->dst_image, surfaces);
surface dst = surfaces[anim->dst_image];
surface src = graphics::surface_cache::get(anim->src_image);
ASSERT_LOG(src.get() != NULL, "COULD NOT LOAD IMAGE: '" << anim->src_image << "'");
int xdst = 0;
for(int f = 0; f != anim->anim->num_frames(); ++f) {
const frame::frame_info& info = anim->anim->frame_layout()[f];
const int x = f%anim->anim->num_frames_per_row();
const int y = f/anim->anim->num_frames_per_row();
const rect& base_area = anim->anim->area();
const int xpos = base_area.x() + (base_area.w()+anim->anim->pad())*x;
const int ypos = base_area.y() + (base_area.h()+anim->anim->pad())*y;
SDL_Rect blit_src = {xpos + info.x_adjust, ypos + info.y_adjust, info.area.w(), info.area.h()};
SDL_Rect blit_dst = {anim->dst_area.x() + xdst,
anim->dst_area.y(),
info.area.w(), info.area.h()};
xdst += info.area.w();
ASSERT_GE(blit_dst.x, anim->dst_area.x());
ASSERT_GE(blit_dst.y, anim->dst_area.y());
ASSERT_LE(blit_dst.x + blit_dst.w, anim->dst_area.x() + anim->dst_area.w());
ASSERT_LE(blit_dst.y + blit_dst.h, anim->dst_area.y() + anim->dst_area.h());
SDL_SetSurfaceBlendMode(src.get(), SDL_BLENDMODE_NONE);
SDL_BlitSurface(src.get(), &blit_src, dst.get(), &blit_dst);
}
}
for(int n = 0; n != num_output_images; ++n) {
std::ostringstream fname;
fname << "images/compiled-" << n << ".png";
graphics::set_alpha_for_transparent_colors_in_rgba_surface(surfaces[n].get());
IMG_SavePNG((module::get_module_path() + fname.str()).c_str(), surfaces[n].get(), -1);
}
typedef std::pair<variant, animation_area_ptr> anim_pair;
foreach(const anim_pair& a, nodes_to_animation_areas) {
variant node = a.first;
animation_area_ptr anim = a.second;
std::ostringstream fname;
fname << "compiled-" << anim->dst_image << ".png";
node.add_attr_mutation(variant("image"), variant(fname.str()));
node.remove_attr_mutation(variant("x"));
node.remove_attr_mutation(variant("y"));
node.remove_attr_mutation(variant("w"));
node.remove_attr_mutation(variant("h"));
node.remove_attr_mutation(variant("pad"));
const frame::frame_info& first_frame = anim->anim->frame_layout().front();
rect r(anim->dst_area.x() - first_frame.x_adjust, anim->dst_area.y() - first_frame.y_adjust, anim->anim->area().w(), anim->anim->area().h());
node.add_attr_mutation(variant("rect"), r.write());
int xpos = anim->dst_area.x();
std::vector<int> v;
foreach(const frame::frame_info& f, anim->anim->frame_layout()) {
ASSERT_EQ(f.area.w() + f.x_adjust + f.x2_adjust, anim->anim->area().w());
ASSERT_EQ(f.area.h() + f.y_adjust + f.y2_adjust, anim->anim->area().h());
v.push_back(f.x_adjust);
v.push_back(f.y_adjust);
v.push_back(f.x2_adjust);
v.push_back(f.y2_adjust);
v.push_back(xpos);
v.push_back(anim->dst_area.y());
v.push_back(f.area.w());
v.push_back(f.area.h());
xpos += f.area.w();
}
std::vector<variant> vs;
foreach(int n, v) {
vs.push_back(variant(n));
}
node.add_attr_mutation(variant("frame_info"), variant(&vs));
}
for(std::map<variant, std::string>::iterator i = nodes_to_files.begin(); i != nodes_to_files.end(); ++i) {
variant node = i->first;
module::write_file(i->second, node.write_json());
}
module::write_file("data/compiled/gui.cfg", gui_node.write_json());
for(std::map<std::string, variant>::iterator i = gui_nodes.begin();
i != gui_nodes.end(); ++i) {
module::write_file("data/compiled/gui/" + i->first, i->second.write_json());
}
if(sys::file_exists("./compile-objects.cfg")) {
variant script = json::parse(sys::read_file("./compile-objects.cfg"));
if(script["query"].is_list()) {
foreach(variant query, script["query"].as_list()) {
std::vector<std::string> args;
foreach(variant arg, query.as_list()) {
args.push_back(arg.as_string());
}
UTILITY_query(args);
}
}
}
}
namespace {
struct SpritesheetCell {
int begin_col, end_col;
};
struct SpritesheetRow {
int begin_row, end_row;
std::vector<SpritesheetCell> cells;
};
struct SpritesheetAnimation {
std::vector<rect> frames;
variant node;
rect target_area;
int cell_width() const {
int result = 0;
for(const rect& r : frames) {
result = std::max<int>(r.w(), result);
}
return result;
}
int cell_height() const {
int result = 0;
for(const rect& r : frames) {
result = std::max<int>(r.h(), result);
}
return result;
}
int height() const {
return cell_height() + 4;
}
int width() const {
return (cell_width()+3)*frames.size() + 4;
}
};
bool is_row_blank(graphics::surface surf, const unsigned char* pixels)
{
for(int x = 0; x < surf->w; ++x) {
if(pixels[3] > 64) {
return false;
}
pixels += 4;
}
return true;
}
bool is_col_blank(graphics::surface surf, const SpritesheetRow& row, int col)
{
if(col >= surf->w) {
return true;
}
const unsigned char* pixels = (const unsigned char*)surf->pixels;
pixels += row.begin_row*surf->w*4 + col*4;
for(int y = row.begin_row; y < row.end_row; ++y) {
if(pixels[3] > 64) {
return false;
}
pixels += surf->w*4;
}
return true;
}
std::vector<SpritesheetRow> get_cells(graphics::surface surf)
{
std::vector<SpritesheetRow> rows;
const unsigned char* pixels = (const unsigned char*)surf->pixels;
int start_row = -1;
for(int row = 0; row <= surf->h; ++row) {
const bool blank = row == surf->h || is_row_blank(surf, pixels);
if(blank) {
if(start_row != -1) {
SpritesheetRow new_row;
new_row.begin_row = start_row;
new_row.end_row = row;
rows.push_back(new_row);
start_row = -1;
}
} else {
if(start_row == -1) {
start_row = row;
}
}
pixels += surf->w*4;
}
for(SpritesheetRow& sprite_row : rows) {
int start_col = -1;
for(int col = 0; col <= surf->w; ++col) {
const bool blank = is_col_blank(surf, sprite_row, col);
if(blank) {
if(start_col != -1) {
SpritesheetCell new_cell = { start_col, col };
sprite_row.cells.push_back(new_cell);
start_col = -1;
}
} else {
if(start_col == -1) {
start_col = col;
}
}
}
std::cerr << "ROW: " << sprite_row.begin_row << ", " << sprite_row.end_row << " -> " << sprite_row.cells.size() << "\n";
}
return rows;
}
void write_pixel_surface(graphics::surface surf, int x, int y, int r, int g, int b, int a)
{
if(x < 0 || y < 0 || x >= surf->w || y >= surf->h) {
return;
}
unsigned char* pixels = (unsigned char*)surf->pixels;
pixels += y * surf->w * 4 + x * 4;
*pixels++ = r;
*pixels++ = g;
*pixels++ = b;
*pixels++ = a;
}
void write_spritesheet_frame(graphics::surface src, const rect& src_area, graphics::surface dst, int target_x, int target_y)
{
const unsigned char* alpha_colors = graphics::get_alpha_pixel_colors();
std::vector<unsigned char*> border_pixels;
for(int xpos = target_x; xpos < target_x + src_area.w() + 2; ++xpos) {
unsigned char* p = (unsigned char*)dst->pixels + (target_y*dst->w + xpos)*4;
border_pixels.push_back(p);
p += (src_area.h()+1)*dst->w*4;
border_pixels.push_back(p);
}
for(int ypos = target_y; ypos < target_y + src_area.h() + 2; ++ypos) {
unsigned char* p = (unsigned char*)dst->pixels + (ypos*dst->w + target_x)*4;
border_pixels.push_back(p);
p += (src_area.w()+1)*4;
border_pixels.push_back(p);
}
for(unsigned char* p : border_pixels) {
memcpy(p, alpha_colors+3, 3);
p[3] = 255;
}
}
bool rect_in_surf_empty(graphics::surface surf, rect area)
{
const unsigned char* p = (const unsigned char*)surf->pixels;
p += (area.y()*surf->w + area.x())*4;
for(int y = 0; y < area.h(); ++y) {
for(int x = 0; x < area.w(); ++x) {
if(p[x*4 + 3]) {
return false;
}
}
p += surf->w*4;
}
return true;
}
int goodness_of_fit(graphics::surface surf, rect areaa, rect areab)
{
if(areaa.h() > areab.h()) {
std::swap(areaa, areab);
}
bool can_slice = true;
while(areaa.h() < areab.h() && can_slice) {
can_slice = false;
if(rect_in_surf_empty(surf, rect(areab.x(), areab.y(), areab.w(), 1))) {
std::cerr << "SLICE: " << areab << " -> ";
areab = rect(areab.x(), areab.y()+1, areab.w(), areab.h()-1);
std::cerr << areab << "\n";
can_slice = true;
}
if(areaa.h() < areab.h() && rect_in_surf_empty(surf, rect(areab.x(), areab.y()+areab.h()-1, areab.w(), 1))) {
std::cerr << "SLICE: " << areab << " -> ";
areab = rect(areab.x(), areab.y(), areab.w(), areab.h()-1);
std::cerr << areab << "\n";
can_slice = true;
}
if(areaa.h() == areab.h()) {
std::cerr << "SLICED DOWN: " << areab << "\n";
}
}
if(areaa.h() < areab.h() && areab.h() - areaa.h() <= 4) {
const int diff = areab.h() - areaa.h();
areab = rect(areab.x(), areab.y() + diff/2, areab.w(), areab.h() - diff);
}
if(areaa.w() != areab.w() && areaa.h() == areab.h()) {
rect a = areaa;
rect b = areab;
if(a.w() > b.w()) {
std::swap(a,b);
}
int best_score = INT_MAX;
for(int xoffset = 0; xoffset < b.w() - a.w(); ++xoffset) {
rect r(b.x() + xoffset, b.y(), a.w(), b.h());
const int score = goodness_of_fit(surf, r, a);
if(score < best_score) {
best_score = score;
}
}
return best_score;
}
if(areaa.w() != areab.w() || areaa.h() != areab.h()) {
return INT_MAX;
}
int errors = 0;
for(int y = 0; y < areaa.h(); ++y) {
const int ya = areaa.y() + y;
const int yb = areab.y() + y;
for(int x = 0; x < areaa.w(); ++x) {
const int xa = areaa.x() + x;
const int xb = areab.x() + x;
const unsigned char* pa = (const unsigned char*)surf->pixels + (ya*surf->w + xa)*4;
const unsigned char* pb = (const unsigned char*)surf->pixels + (yb*surf->w + xb)*4;
if((pa[3] > 32) != (pb[3] > 32)) {
++errors;
}
}
}
return errors;
}
int score_offset_fit(graphics::surface surf, const rect& big_area, const rect& lit_area, int offsetx, int offsety)
{
int score = 0;
for(int y = 0; y < big_area.h(); ++y) {
for(int x = 0; x < big_area.w(); ++x) {
const unsigned char* big_p = (const unsigned char*)surf->pixels + ((big_area.y() + y)*surf->w + (big_area.x() + x))*4;
const int xadj = x - offsetx;
const int yadj = y - offsety;
if(xadj < 0 || yadj < 0 || xadj >= lit_area.w() || yadj >= lit_area.h()) {
if(big_p[3] >= 32) {
++score;
}
continue;
}
const unsigned char* lit_p = (const unsigned char*)surf->pixels + ((lit_area.y() + yadj)*surf->w + (lit_area.x() + xadj))*4;
if((big_p[3] >= 32) != (lit_p[3] >= 32)) {
++score;
}
}
}
return score;
}
void get_best_offset(graphics::surface surf, const rect& big_area, const rect& lit_area, int* xoff, int* yoff)
{
std::cerr << "CALC BEST OFFSET...\n";
*xoff = *yoff = 0;
int best_score = -1;
for(int y = 0; y <= (big_area.h() - lit_area.h()); ++y) {
for(int x = 0; x <= (big_area.w() - lit_area.w()); ++x) {
const int score = score_offset_fit(surf, big_area, lit_area, x, y);
std::cerr << "OFFSET " << x << ", " << y << " SCORES " << score << "\n";
if(best_score == -1 || score < best_score) {
*xoff = x;
*yoff = y;
best_score = score;
}
}
}
std::cerr << "BEST OFFSET: " << *xoff << ", " << *yoff << "\n";
}
int find_distance_to_pixel(graphics::surface surf, const rect& area, int xoffset, int yoffset)
{
const int SearchDistance = 4;
int best_distance = SearchDistance+1;
for(int y = -SearchDistance; y <= SearchDistance; ++y) {
for(int x = -SearchDistance; x <= SearchDistance; ++x) {
const int distance = abs(x) + abs(y);
if(distance >= best_distance) {
continue;
}
int xpos = xoffset + x;
int ypos = yoffset + y;
if(xpos >= 0 && ypos >= 0 && xpos < area.w() && ypos < area.h()) {
const unsigned char* p = (const unsigned char*)surf->pixels + ((area.y() + ypos)*surf->w + (area.x() + xpos))*4;
if(p[3] >= 32) {
best_distance = distance;
}
}
}
}
return best_distance;
}
int score_spritesheet_area(graphics::surface surf, const rect& area_a, int xoff_a, int yoff_a, const rect& area_b, int xoff_b, int yoff_b, const rect& big_area)
{
unsigned char default_color[4] = {0,0,0,0};
int score = 0;
for(int y = 0; y < big_area.h(); ++y) {
for(int x = 0; x < big_area.w(); ++x) {
const int xadj_a = x - xoff_a;
const int yadj_a = y - yoff_a;
const int xadj_b = x - xoff_b;
const int yadj_b = y - yoff_b;
const unsigned char* pa = default_color;
const unsigned char* pb = default_color;
if(xadj_a >= 0 && xadj_a < area_a.w() && yadj_a >= 0 && yadj_a < area_a.h()) {
pa = (const unsigned char*)surf->pixels + ((area_a.y() + yadj_a)*surf->w + (area_a.x() + xadj_a))*4;
}
if(xadj_a >= 0 && xadj_a < area_a.w() && yadj_a >= 0 && yadj_a < area_a.h()) {
pb = (const unsigned char*)surf->pixels + ((area_b.y() + yadj_b)*surf->w + (area_b.x() + xadj_b))*4;
}
if((pa[3] >= 32) != (pb[3] >= 32)) {
if(pa[3] >= 32) {
score += find_distance_to_pixel(surf, area_b, xadj_b, yadj_b);
} else {
score += find_distance_to_pixel(surf, area_a, xadj_a, yadj_a);
}
}
}
}
return score;
}
void flip_surface_area(graphics::surface surf, const rect& area)
{
for(int y = area.y(); y < area.y() + area.h(); ++y) {
unsigned int* pixels = (unsigned int*)surf->pixels + y*surf->w + area.x();
std::reverse(pixels, pixels + area.w());
}
}
void write_spritesheet_animation(graphics::surface src, const SpritesheetAnimation& anim, graphics::surface dst, bool reorder)
{
int target_x = anim.target_area.x()+1;
int target_y = anim.target_area.y()+1;
const int cell_width = anim.cell_width();
const int cell_height = anim.cell_height();
rect biggest_rect = anim.frames.front();
for(const rect& f : anim.frames) {
std::cerr << "RECT SIZE: " << f.w() << "," << f.h() << "\n";
if(f.w()*f.h() > biggest_rect.w()*biggest_rect.h()) {
biggest_rect = f;
}
}
std::vector<int> xoffsets, yoffsets, new_xoffsets, new_yoffsets;
for(const rect& f : anim.frames) {
xoffsets.push_back(0);
yoffsets.push_back(0);
get_best_offset(src, biggest_rect, f, &xoffsets.back(), &yoffsets.back());
}
std::vector<rect> frames = anim.frames;
if(reorder) {
frames.clear();
frames.push_back(anim.frames.front());
new_xoffsets.push_back(xoffsets[0]);
new_yoffsets.push_back(yoffsets[0]);
while(frames.size() < anim.frames.size()) {
int best_frame = -1;
int best_score = INT_MAX;
for(int n = 0; n < anim.frames.size(); ++n) {
if(std::count(frames.begin(), frames.end(), anim.frames[n])) {
continue;
}
const int score = score_spritesheet_area(src, frames.back(), new_xoffsets.back(), new_yoffsets.back(), anim.frames[n], xoffsets[n], yoffsets[n], biggest_rect);
std::cerr << "SCORE: " << anim.frames[n] << " vs " << frames.back() << ": " << n << " -> " << score << "\n";
if(score < best_score || best_frame == -1) {
best_score = score;
best_frame = n;
}
}
std::cerr << "BEST : " << best_frame << ": " << best_score << "\n";
frames.push_back(anim.frames[best_frame]);
new_xoffsets.push_back(xoffsets[best_frame]);
new_yoffsets.push_back(yoffsets[best_frame]);
}
}
for(const rect& f : frames) {
int xoff = 0, yoff = 0;
get_best_offset(src, biggest_rect, f, &xoff, &yoff);
write_spritesheet_frame(src, f, dst, target_x, target_y);
SDL_Rect src_rect = { f.x(), f.y(), f.w(), f.h() };
SDL_Rect dst_rect = { target_x+1 + xoff, target_y+1 + yoff, f.w(), f.h() };
SDL_SetSurfaceBlendMode(src.get(), SDL_BLENDMODE_NONE);
SDL_BlitSurface(src.get(), &src_rect, dst.get(), &dst_rect);
flip_surface_area(dst, rect(target_x, target_y, cell_width, cell_height));
target_x += cell_width + 3;
}
}
}
COMMAND_LINE_UTILITY(bake_spritesheet)
{
std::deque<std::string> argv(args.begin(), args.end());
while(argv.empty() == false) {
std::string arg = argv.front();
argv.pop_front();
std::string cfg_fname = module::map_file(arg);
variant node;
try {
node = json::parse(sys::read_file(cfg_fname));
} catch(json::parse_error& e) {
ASSERT_LOG(false, "Parse error parsing " << arg << " -> " << cfg_fname << ": " << e.error_message());
}
variant baking_info = node["animation_baking"];
ASSERT_LOG(baking_info.is_map(), "baking info not found");
graphics::surface surf = graphics::surface_cache::get(baking_info["source_image"].as_string());
ASSERT_LOG(surf.get(), "No surface found");
std::cerr << "SURFACE SIZE: " << surf->w << "x" << surf->h << "\n";
std::cerr << "DEST SURFACE: " << module::map_file("images/" + baking_info["dest_image"].as_string()) << "\n";
ASSERT_LOG(surf->format->BytesPerPixel == 4, "Incorrect bpp: " << surf->format->BytesPerPixel);
std::vector<SpritesheetRow> rows = get_cells(surf);
unsigned char* pixels = (unsigned char*)surf->pixels;
for(const SpritesheetRow& row : rows) {
for(const SpritesheetCell& cell : row.cells) {
const int x1 = cell.begin_col - 1;
const int x2 = cell.end_col;
const int y1 = row.begin_row - 1;
const int y2 = row.end_row;
for(int x = x1; x <= x2; ++x) {
write_pixel_surface(surf, x, y1, 255, 255, 255, 255);
write_pixel_surface(surf, x, y2, 255, 255, 255, 255);
}
for(int y = y1; y <= y2; ++y) {
write_pixel_surface(surf, x1, y, 255, 255, 255, 255);
write_pixel_surface(surf, x2, y, 255, 255, 255, 255);
}
}
}
/*
typedef std::map<int, std::vector<std::pair<int,int> > > ScoresMap;
std::map<std::pair<int,int>, ScoresMap> all_scores;
for(int y = 0; y < rows.size(); ++y) {
const SpritesheetRow& row = rows[y];
for(int x = 0; x < row.cells.size(); ++x) {
const SpritesheetCell& cell = row.cells[x];
ScoresMap scores;
for(int yy = 0; yy < rows.size(); ++yy) {
const SpritesheetRow& r = rows[yy];
for(int xx = 0; xx < row.cells.size(); ++xx) {
const SpritesheetCell& c = row.cells[xx];
if(xx == x && yy == y) {
continue;
}
const rect areaa(cell.begin_col, row.begin_row, cell.end_col - cell.begin_col, row.end_row - row.begin_row);
const rect areab(c.begin_col, r.begin_row, c.end_col - c.begin_col, r.end_row - r.begin_row);
const int score = goodness_of_fit(surf, areaa, areab);
std::cerr << "SCORE: [" << y << "," << x << "] -> [" << yy << "," << xx << "]: " << score << "\n";
scores[score].resize(scores[score].size()+1);
scores[score].back().first = yy;
scores[score].back().second = xx;
}
}
auto itor = scores.begin();
std::vector<std::pair<int, int> > v = itor->second;
if(v.size() <= 1) {
++itor;
v.push_back(itor->second.front());
}
std::cerr << "BEST SCORES FOR [" << y << "," << x << "] " << (cell.end_col - cell.begin_col) << "x" << (row.end_row - row.begin_row) << ": [" << v[0].first << "," << v[0].second << "], [" << v[1].first << "," << v[1].second << "]\n";
all_scores[std::pair<int,int>(y, x)] = scores;
}
}
for(int y = 0; y < rows.size(); ++y) {
const SpritesheetRow& row = rows[y];
for(int x = 0; x < row.cells.size(); ++x) {
const SpritesheetCell& cell = row.cells[x];
std::set<std::pair<int,int> > seen;
seen.insert(std::pair<int,int>(y,x));
std::vector<std::pair<int,int> > sequence;
sequence.push_back(std::pair<int,int>(y,x));
for(;;) {
std::pair<int,int> value(-1,-1);
bool found = false;
const ScoresMap& scores = all_scores[sequence.back()];
for(auto i = scores.begin(); i != scores.end() && !found; ++i) {
for(auto j = i->second.begin(); j != i->second.end(); ++j) {
if(!seen.count(*j)) {
if(i->first < 1000) {
value = *j;
}
found = true;
break;
}
}
if(found) {
break;
}
}
if(value.first == -1) {
break;
}
seen.insert(value);
sequence.push_back(value);
}
std::cerr << "RECOMMENDED SEQUENCE: ";
for(auto p : sequence) {
std::cerr << "[" << p.first << "," << p.second << "], ";
}
std::cerr << "\n";
}
}
*/
const int TargetTextureSize = 4096;
std::vector<rect> available_space;
available_space.push_back(rect(0, 0, TargetTextureSize, TargetTextureSize));
std::vector<SpritesheetAnimation> animations;
for(const variant& anim : baking_info["animations"].as_list()) {
SpritesheetAnimation new_anim;
new_anim.node = anim;
std::vector<variant> frames = anim["frames"].as_list();
for(const variant& fr : frames) {
std::vector<int> loc = fr.as_list_int();
assert(loc.size() == 2);
ASSERT_LOG(loc[0] < rows.size(), "Invalid animation cell: " << loc[0] << "/" << rows.size());
ASSERT_LOG(loc[1] < rows[loc[0]].cells.size(), "Invalid animation cell: " << loc[1] << "/" << rows[loc[0]].cells.size());
const SpritesheetRow& r = rows[loc[0]];
const SpritesheetCell& c = r.cells[loc[1]];
const rect area(c.begin_col, r.begin_row, c.end_col - c.begin_col, r.end_row - r.begin_row);
new_anim.frames.push_back(area);
}
int best = -1;
int best_score = -1;
for(int n = 0; n != available_space.size(); ++n) {
const rect& area = available_space[n];
if(new_anim.width() <= area.w() && new_anim.height() <= area.h()) {
int score = area.w()*area.h();
fprintf(stderr, "MATCH: %dx%d %d\n", area.w(), area.h(), score);
if(best == -1 || score < best_score) {
best = n;
best_score = score;
}
break;
}
}
ASSERT_LOG(best != -1, "Could not find fit for animation " << new_anim.width() << "x" << new_anim.height() << ": " << animations.size());
new_anim.target_area = rect(available_space[best].x(), available_space[best].y(), new_anim.width(), new_anim.height());
const rect right_area(new_anim.target_area.x2(), new_anim.target_area.y(), available_space[best].w() - new_anim.target_area.w(), new_anim.target_area.h());
const rect bottom_area(new_anim.target_area.x(), new_anim.target_area.y2(), available_space[best].w(), available_space[best].h() - new_anim.target_area.h());
available_space.push_back(right_area);
available_space.push_back(bottom_area);
fprintf(stderr, "DIVIDE: %dx%d %dx%d\n", right_area.w(), right_area.h(), bottom_area.w(), bottom_area.h());
available_space.erase(available_space.begin() + best);
animations.push_back(new_anim);
fprintf(stderr, "FIT ANIM: %d, %d, %d, %d\n", new_anim.target_area.x(), new_anim.target_area.y(), new_anim.target_area.w(), new_anim.target_area.h());
}
graphics::surface target_surf(SDL_CreateRGBSurface(0,TargetTextureSize,TargetTextureSize,32,SURFACE_MASK));
const unsigned char* alpha_colors = graphics::get_alpha_pixel_colors();
unsigned char* target_pixels = (unsigned char*)target_surf->pixels;
for(int n = 0; n < target_surf->w*target_surf->h; ++n) {
memcpy(target_pixels, alpha_colors, 3);
target_pixels[3] = 255;
target_pixels += 4;
}
std::vector<variant> anim_nodes;
for(const SpritesheetAnimation& anim : animations) {
write_spritesheet_animation(surf, anim, target_surf, anim.node[variant("auto_adjust")].as_bool(false));
std::map<variant, variant> node = anim.node.as_map();
node.erase(variant("frames"));
rect area(anim.target_area.x()+2, anim.target_area.y()+2, anim.cell_width(), anim.cell_height());
node[variant("rect")] = area.write();
node[variant("image")] = baking_info["dest_image"];
node[variant("frames")] = variant(static_cast<int>(anim.frames.size()));
node[variant("pad")] = variant(3);
anim_nodes.push_back(variant(&node));
}
node.add_attr(variant("animation"), variant(&anim_nodes));
IMG_SavePNG((module::get_module_path() + "/images/" + baking_info["dest_image"].as_string()).c_str(), target_surf.get(), -1);
sys::write_file(cfg_fname, node.write_json());
}
}
COMMAND_LINE_UTILITY(build_spritesheet_from_images)
{
using namespace graphics;
std::vector<std::vector<surface> > surfaces;
surfaces.resize(surfaces.size()+1);
int row_width = 3;
int sheet_height = 3;
std::vector<int> cell_widths;
std::vector<int> row_heights;
cell_widths.push_back(0);
row_heights.push_back(0);
using namespace graphics;
for(auto img : args) {
if(img == "--newrow") {
surfaces.resize(surfaces.size()+1);
cell_widths.push_back(0);
row_heights.push_back(0);
row_width = 3;
sheet_height += 3;
continue;
}
surface s = surface_cache::get(img);
ASSERT_LOG(s.get(), "No image: " << img);
surfaces.back().push_back(s);
row_width += s->w + 3;
if(s->w > cell_widths.back()) {
cell_widths.back() = s->w;
}
if(s->h > row_heights.back()) {
sheet_height += s->h - row_heights.back();
row_heights.back() = s->h;
}
}
int sheet_width = 0;
for(int nrow = 0; nrow != surfaces.size(); ++nrow) {
const int row_width = 3 + (3+cell_widths[nrow])*surfaces[nrow].size();
if(row_width > sheet_width) {
sheet_width = row_width;
}
}
surface sheet = surface(SDL_CreateRGBSurface(0,sheet_width,sheet_height,32,SURFACE_MASK));
int ypos = 2;
int row_index = 0;
for(auto row : surfaces) {
int xpos = 2;
int max_height = 0;
for(auto src : row) {
SDL_Rect blit_src = {0, 0, src->w, src->h};
SDL_Rect blit_dst = {xpos, ypos, src->w, src->h};
SDL_Rect rect_top = {xpos-1, ypos-1, src->w+2, 1};
SDL_Rect rect_bot = {xpos-1, ypos + src->h, src->w+2, 1};
SDL_Rect rect_left = {xpos-1, ypos, 1, src->h};
SDL_Rect rect_right = {xpos + src->w, ypos, 1, src->h};
SDL_SetSurfaceBlendMode(src.get(), SDL_BLENDMODE_NONE);
SDL_BlitSurface(src.get(), &blit_src, sheet.get(), &blit_dst);
if(blit_src.h > max_height) {
max_height = blit_src.h;
}
Uint32 transparent = SDL_MapRGB(sheet->format, 0xf9, 0x30, 0x3d);
SDL_FillRect(sheet.get(), &rect_top, transparent);
SDL_FillRect(sheet.get(), &rect_bot, transparent);
SDL_FillRect(sheet.get(), &rect_left, transparent);
SDL_FillRect(sheet.get(), &rect_right, transparent);
xpos += cell_widths[row_index] + 3;
}
ypos += max_height + 3;
++row_index;
}
IMG_SavePNG("sheet.png", sheet.get(), -1);
}
//this is a template utility that can be modified to provide a nice utility
//for manipulating images.
COMMAND_LINE_UTILITY(manipulate_image_template)
{
using namespace graphics;
for(auto img : args) {
surface s = surface_cache::get(img);
uint8_t* p = (uint8_t*)s->pixels;
for(int i = 0; i != s->w*s->h; ++i) {
p[3] = p[0];
p[0] = p[1] = p[2] = 255;
p += 4;
}
IMG_SavePNG((module::get_module_path() + "/images/" + img).c_str(), s.get(), -1);
}
}
|
function term = sdlfmjMeanCompute(sdlfmKern, t , option)
% SDLFMJMEANCOMPUTE Jolt mean for the switching dynamical LFM model.
% Computes the terms $r_d$ and $q_d$ that appear in the mean function
% associated with the switching dynamical LFM model. If the mean function
% is mu(t), then
%
% mu(t) = r_d(t)y_d(t_0) + q_d(t)\dot{y}_d(t_0),
%
% where $y_d(t_0)$ is the initial condition associated to the position and
% $\dot{y}_d(t_0)$ is the initial condition associated to the velocity.
%
% FORMAT
% DESC
% ARG sdlfmKern : switching dynamical LFM kernel structure with the
% parameters.
% ARG t : input times for which the mean is to be computed.
% RETURN term : the value of $r_d$.
%
% FORMAT
% DESC
% Computes the terms that appear in the mean function associated with the
% switching dynamical LFM model.
% ARG sdlfmKern : switching dynamical LFM kernel structure with the
% parameters.
% ARG t : input times for which the mean is to be computed.
% ARG option : indicates which term of the mean should be computed. Option
% 'Pos' computes the term $r_d$ and option 'Vel' computes $q_d$ that
% accompanies the initial condition of the velocity.
% RETURN term : the value of $r_d$ or $q_d$ depending of option.
%
% COPYRIGHT : Mauricio A. Alvarez, 2010
% KERN
if nargin < 3
option = 'Pos';
end
alpha = sdlfmKern.damper/(2*sdlfmKern.mass);
omega = sqrt(sdlfmKern.spring/sdlfmKern.mass-alpha^2);
freq = omega*t;
switch option
case 'Pos'
term = (alpha^2/omega + omega)*exp(-alpha*t).*...
((omega^2 - alpha^2)*sin(freq) + 2*alpha*omega*cos(freq));
case 'Vel'
term = exp(-alpha*t).*((3*alpha*omega - alpha^3/omega)*sin(freq)...
+(3*alpha^2- omega^2)*cos(freq));
otherwise
error('No recognized option')
end
|
module PolyPairPots
import JuLIP: energy, forces, virial, alloc_temp, alloc_temp_d, cutoff
import JuLIP.Potentials: evaluate, evaluate_d, evaluate!, evaluate_d!
import Base: Dict, convert, ==
function alloc_B end
function alloc_dB end
include("jacobi.jl")
include("transforms.jl")
include("basis.jl")
include("calculator.jl")
include("repulsion.jl")
end # module
|
[STATEMENT]
lemma card_dcharacters [simp]: "card (dcharacters n) = totient n"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. card (dcharacters n) = totient n
[PROOF STEP]
using bij_betw_same_card [OF bij_betw_dcharacters_characters] card_characters
[PROOF STATE]
proof (prove)
using this:
card (dcharacters n) = card (characters G)
card (characters G) = order G
goal (1 subgoal):
1. card (dcharacters n) = totient n
[PROOF STEP]
by simp |
Jordan kept busy over the next few years by staying in shape , playing golf in celebrity charity tournaments , spending time with his family in Chicago , promoting his Jordan Brand clothing line , and riding motorcycles . Since 2004 , Jordan has owned Michael Jordan Motorsports , a professional closed @-@ course motorcycle road racing team that competed with two <unk> in the premier Superbike championship sanctioned by the American Motorcyclist Association ( AMA ) until the end of the 2013 season . Jordan and his then @-@ wife Juanita pledged $ 5 million to Chicago 's Hales Franciscan High School in 2006 , and the Jordan Brand has made donations to Habitat for Humanity and a Louisiana branch of the Boys & Girls Clubs of America .
|
# Programming Assignment
## RealNVP for the LSUN bedroom dataset
### Instructions
In this notebook, you will develop the RealNVP normalising flow architecture from scratch, including the affine coupling layers, checkerboard and channel-wise masking, and combining into a multiscale architecture. You will train the normalising flow on a subset of the LSUN bedroom dataset.
Some code cells are provided for you in the notebook. You should avoid editing provided code, and make sure to execute the cells in order to avoid unexpected errors. Some cells begin with the line:
`#### GRADED CELL ####`
Don't move or edit this first line - this is what the automatic grader looks for to recognise graded cells. These cells require you to write your own code to complete them, and are automatically graded when you submit the notebook. Don't edit the function name or signature provided in these cells, otherwise the automatic grader might not function properly.
### How to submit
Complete all the tasks you are asked for in the worksheet. When you have finished and are happy with your code, press the **Submit Assignment** button at the top of this notebook.
### Let's get started!
We'll start running some imports, and loading the dataset. Do not edit the existing imports in the following cell. If you would like to make further Tensorflow imports, you should add them here.
```python
#### PACKAGE IMPORTS ####
# Run this cell first to import all required packages. Do not make any imports elsewhere in the notebook
import tensorflow as tf
import tensorflow_probability as tfp
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras import Model, Input
from tensorflow.keras.layers import Conv2D, BatchNormalization
from tensorflow.keras.optimizers import Adam
tfd = tfp.distributions
tfb = tfp.bijectors
# If you would like to make further imports from tensorflow, add them here
from tensorflow.keras import layers
from tensorflow.keras import regularizers
from tensorflow.keras.layers import Add
```
<table><tr>
<td> </td>
<td> </td>
<td> </td>
</tr></table>
#### The LSUN Bedroom Dataset
In this assignment, you will use a subset of the [LSUN dataset](https://www.yf.io/p/lsun). This is a large-scale image dataset with 10 scene and 20 object categories. A subset of the LSUN bedroom dataset has been provided, and has already been downsampled and preprocessed into smaller, fixed-size images.
* F. Yu, A. Seff, Y. Zhang, S. Song, T. Funkhouser and J. Xia. "LSUN: Construction of a Large-scale Image Dataset using Deep Learning with Humans in the Loop". [arXiv:1506.03365](https://arxiv.org/abs/1506.03365), 10 Jun 2015
Your goal is to develop the RealNVP normalising flow architecture using bijector subclassing, and use it to train a generative model of the LSUN bedroom data subset. For full details on the RealNVP model, refer to the original paper:
* L. Dinh, J. Sohl-Dickstein and S. Bengio. "Density estimation using Real NVP". [arXiv:1605.08803](https://arxiv.org/abs/1605.08803), 27 Feb 2017.
#### Load the dataset
The following functions will be useful for loading and preprocessing the dataset. The subset you will use for this assignment consists of 10,000 training images, 1000 validation images and 1000 test images.
The images have been downsampled to 32 x 32 x 3 in order to simplify the training process.
```python
# Functions for loading and preprocessing the images
def load_image(img):
img = tf.image.random_flip_left_right(img)
return img, img
def load_dataset(split):
train_list_ds = tf.data.Dataset.from_tensor_slices(np.load('./data/{}.npy'.format(split)))
train_ds = train_list_ds.map(load_image)
return train_ds
```
```python
# Load the training, validation and testing datasets splits
train_ds = load_dataset('train')
val_ds = load_dataset('val')
test_ds = load_dataset('test')
```
```python
# Shuffle the datasets
shuffle_buffer_size = 1000
train_ds = train_ds.shuffle(shuffle_buffer_size)
val_ds = val_ds.shuffle(shuffle_buffer_size)
test_ds = test_ds.shuffle(shuffle_buffer_size)
```
```python
# Display a few examples
n_img = 4
f, axs = plt.subplots(n_img, n_img, figsize=(14, 14))
for k, image in enumerate(train_ds.take(n_img**2)):
i = k // n_img
j = k % n_img
axs[i, j].imshow(image[0])
axs[i, j].axis('off')
f.subplots_adjust(wspace=0.01, hspace=0.03)
```
```python
# Batch the Dataset objects
batch_size = 64
train_ds = train_ds.batch(batch_size)
val_ds = val_ds.batch(batch_size)
test_ds = test_ds.batch(batch_size)
```
### Affine coupling layer
We will begin the development of the RealNVP architecture with the core bijector that is called the _affine coupling layer_. This bijector can be described as follows: suppose that $x$ is a $D$-dimensional input, and let $d<D$. Then the output $y$ of the affine coupling layer is given by the following equations:
$$
\begin{align}
y_{1:d} &= x_{1:d} \tag{1}\\
y_{d+1:D} &= x_{d+1:D}\odot \exp(s(x_{1:d})) + t(x_{1:d}), \tag{2}
\end{align}
$$
where $s$ and $t$ are functions from $\mathbb{R}^d\rightarrow\mathbb{R}^{D-d}$, and define the log-scale and shift operations on the vector $x_{d+1:D}$ respectively.
The log of the Jacobian determinant for this layer is given by $\sum_{j}s(x_{1:d})_j$.
The inverse operation can be easily computed as
$$
\begin{align}
x_{1:d} &= y_{1:d}\tag{3}\\
x_{d+1:D} &= \left(y_{d+1:D} - t(y_{1:d})\right)\odot \exp(-s(y_{1:d})),\tag{4}
\end{align}
$$
In practice, we will implement equations $(1)$ and $(2)$ using a binary mask $b$:
$$
\begin{align}
\text{Forward pass:}\qquad y &= b\odot x + (1-b)\odot\left(x\odot\exp(s(b\odot x)) + t(b\odot x)\right),\tag{5}\\
\text{Inverse pass:}\qquad x &= b\odot y + (1-b)\odot\left(y - t(b\odot x)) \odot\exp( -s(b\odot x)\right).\tag{6}
\end{align}
$$
Our inputs $x$ will be a batch of 3-dimensional Tensors with `height`, `width` and `channels` dimensions. As in the original architecture, we will use both spatial 'checkerboard' masks and channel-wise masks:
<center>Figure 1. Spatial checkerboard mask (left) and channel-wise mask (right). From the original paper.</center>
#### Custom model for log-scale and shift
You should now create a custom model for the shift and log-scale parameters that are used in the affine coupling layer bijector. We will use a convolutional residual network, with two residual blocks and a final convolutional layer. Using the functional API, build the model according to the following specifications:
* The function takes the `input_shape` and `filters` as arguments
* The model should use the `input_shape` in the function argument to set the shape in the Input layer (call this layer `h0`).
* The first hidden layer should be a Conv2D layer with number of filters set by the `filters` argument, and a ReLU activation
* The second hidden layer should be a BatchNormalization layer
* The third hidden layer should be a Conv2D layer with the same number of filters as the input `h0` to the model, and a ReLU activation
* The fourth hidden layer should be a BatchNormalization layer
* The fifth hidden layer should be the sum of the fourth hidden layer output and the inputs `h0`. Call this layer `h1`
* The sixth hidden layer should be a Conv2D layer with filters set by the `filters` argument, and a ReLU activation
* The seventh hidden layer should be a BatchNormalization layer
* The eighth hidden layer should be a Conv2D layer with the same number of filters as `h1` (and `h0`), and a ReLU activation
* The ninth hidden layer should be a BatchNormalization layer
* The tenth hidden layer should be the sum of the ninth hidden layer output and `h1`
* The eleventh hidden layer should be a Conv2D layer with the number of filters equal to twice the number of channels of the model input, and a linear activation. Call this layer `h2`
* The twelfth hidden layer should split `h2` into two equal-sized Tensors along the final channel axis. These two Tensors are the shift and log-scale Tensors, and should each have the same shape as the model input
* The final layer should then apply the `tanh` nonlinearity to the log_scale Tensor. The outputs to the model should then be the list of Tensors `[shift, log_scale]`
All Conv2D layers should use a 3x3 kernel size, `"SAME"` padding and an $l2$ kernel regularizer with regularisation coefficient of `5e-5`.
_Hint: use_ `tf.split` _with arguments_ `num_or_size_splits=2, axis=-1` _to create the output Tensors_.
In total, the network should have 14 layers (including the `Input` layer).
```python
#### GRADED CELL ####
# Complete the following function.
# Make sure to not change the function name or arguments.
def get_conv_resnet(input_shape, filters):
"""
This function should build a CNN ResNet model according to the above specification,
using the functional API. The function takes input_shape as an argument, which should be
used to specify the shape in the Input layer, as well as a filters argument, which
should be used to specify the number of filters in (some of) the convolutional layers.
Your function should return the model.
The function takes the input_shape and filters as arguments
The model should use the input_shape in the function argument to set the shape in the Input layer (call this layer h0).
The first hidden layer should be a Conv2D layer with number of filters set by the filters argument, and a ReLU activation
The second hidden layer should be a BatchNormalization layer
The third hidden layer should be a Conv2D layer with the same number of filters as the input h0 to the model,
and a ReLU activation
The fourth hidden layer should be a BatchNormalization layer
The fifth hidden layer should be the sum of the fourth hidden layer output and the inputs h0. Call this layer h1
The sixth hidden layer should be a Conv2D layer with filters set by the filters argument, and a ReLU activation
The seventh hidden layer should be a BatchNormalization layer
The eighth hidden layer should be a Conv2D layer with the same number of filters as h1 (and h0), and a ReLU activation
The ninth hidden layer should be a BatchNormalization layer
The tenth hidden layer should be the sum of the ninth hidden layer output and h1
The eleventh hidden layer should be a Conv2D layer with the number of filters equal to
twice the number of channels of the model input, and a linear activation. Call this layer h2
The twelfth hidden layer should split h2 into two equal-sized Tensors along the final channel axis.
These two Tensors are the shift and log-scale Tensors, and should each have the same shape as the model input
The final layer should then apply the tanh nonlinearity to the log_scale Tensor.
The outputs to the model should then be the list of Tensors [shift, log_scale]
"""
h0 = Input(shape = input_shape)
h = Conv2D(filters = filters,activation = 'relu',kernel_size = (3,3),padding='SAME',kernel_regularizer=regularizers.l2(5e-5))(h0)
h = BatchNormalization()(h)
h = Conv2D(filters = input_shape[-1],activation = 'relu',kernel_size = (3,3),padding='SAME',kernel_regularizer=regularizers.l2(5e-5))(h)
h = BatchNormalization()(h)
# h1 = Add()([h, h0])
h1 = tf.add(h, h0)
h = Conv2D(filters = filters,activation = 'relu',kernel_size = (3,3),padding='SAME',kernel_regularizer=regularizers.l2(5e-5))(h1)
h = BatchNormalization()(h)
h = Conv2D(filters = input_shape[-1],activation = 'relu',kernel_size = (3,3),padding='SAME',kernel_regularizer=regularizers.l2(5e-5))(h)
h = BatchNormalization()(h)
# h = Add()([h1, h])
h = tf.add(h1, h)
h2 = Conv2D(filters = 2*input_shape[-1],activation = 'linear',kernel_size = (3,3),padding='SAME',kernel_regularizer=regularizers.l2(5e-5))(h)
shift, log_scale = tf.split(h2, num_or_size_splits=2, axis = -1)
log_scale = tf.math.tanh(log_scale)
outputs = [shift, log_scale]
model = tf.keras.Model(inputs=h0, outputs=outputs)
return model
```
```python
# Test your function and print the model summary
conv_resnet = get_conv_resnet((32, 32, 3), 32)
conv_resnet.summary()
```
Model: "model_1"
__________________________________________________________________________________________________
Layer (type) Output Shape Param # Connected to
==================================================================================================
input_2 (InputLayer) [(None, 32, 32, 3)] 0
__________________________________________________________________________________________________
conv2d_5 (Conv2D) (None, 32, 32, 32) 896 input_2[0][0]
__________________________________________________________________________________________________
batch_normalization_4 (BatchNor (None, 32, 32, 32) 128 conv2d_5[0][0]
__________________________________________________________________________________________________
conv2d_6 (Conv2D) (None, 32, 32, 3) 867 batch_normalization_4[0][0]
__________________________________________________________________________________________________
batch_normalization_5 (BatchNor (None, 32, 32, 3) 12 conv2d_6[0][0]
__________________________________________________________________________________________________
tf_op_layer_Add_2 (TensorFlowOp [(None, 32, 32, 3)] 0 batch_normalization_5[0][0]
input_2[0][0]
__________________________________________________________________________________________________
conv2d_7 (Conv2D) (None, 32, 32, 32) 896 tf_op_layer_Add_2[0][0]
__________________________________________________________________________________________________
batch_normalization_6 (BatchNor (None, 32, 32, 32) 128 conv2d_7[0][0]
__________________________________________________________________________________________________
conv2d_8 (Conv2D) (None, 32, 32, 3) 867 batch_normalization_6[0][0]
__________________________________________________________________________________________________
batch_normalization_7 (BatchNor (None, 32, 32, 3) 12 conv2d_8[0][0]
__________________________________________________________________________________________________
tf_op_layer_Add_3 (TensorFlowOp [(None, 32, 32, 3)] 0 tf_op_layer_Add_2[0][0]
batch_normalization_7[0][0]
__________________________________________________________________________________________________
conv2d_9 (Conv2D) (None, 32, 32, 6) 168 tf_op_layer_Add_3[0][0]
__________________________________________________________________________________________________
tf_op_layer_split_1 (TensorFlow [(None, 32, 32, 3), 0 conv2d_9[0][0]
__________________________________________________________________________________________________
tf_op_layer_Tanh_1 (TensorFlowO [(None, 32, 32, 3)] 0 tf_op_layer_split_1[0][1]
==================================================================================================
Total params: 3,974
Trainable params: 3,834
Non-trainable params: 140
__________________________________________________________________________________________________
You can also inspect your model architecture graphically by running the following cell. It should look something like the following:
```python
# Plot the model graph
tf.keras.utils.plot_model(conv_resnet, show_layer_names=False, rankdir='LR')
```
```python
# Check the output shapes are as expected
print(conv_resnet(tf.random.normal((1, 32, 32, 3)))[0].shape)
print(conv_resnet(tf.random.normal((1, 32, 32, 3)))[1].shape)
```
(1, 32, 32, 3)
(1, 32, 32, 3)
#### Binary masks
Now that you have a shift and log-scale model built, we will now implement the affine coupling layer. We will first need functions to create the binary masks $b$ as described above. The following function creates the spatial 'checkerboard' mask.
It takes a rank-2 `shape` as input, which correspond to the `height` and `width` dimensions, as well as an `orientation` argument (an integer equal to `0` or `1`) that determines which way round the zeros and ones are entered into the Tensor.
```python
# Function to create the checkerboard mask
def checkerboard_binary_mask(shape, orientation=0):
height, width = shape[0], shape[1]
height_range = tf.range(height)
width_range = tf.range(width)
height_odd_inx = tf.cast(tf.math.mod(height_range, 2), dtype=tf.bool)
width_odd_inx = tf.cast(tf.math.mod(width_range, 2), dtype=tf.bool)
odd_rows = tf.tile(tf.expand_dims(height_odd_inx, -1), [1, width])
odd_cols = tf.tile(tf.expand_dims(width_odd_inx, 0), [height, 1])
checkerboard_mask = tf.math.logical_xor(odd_rows, odd_cols)
if orientation == 1:
checkerboard_mask = tf.math.logical_not(checkerboard_mask)
return tf.cast(tf.expand_dims(checkerboard_mask, -1), tf.float32)
```
This function creates a rank-3 Tensor to mask the `height`, `width` and `channels` dimensions of the input. We can take a look at this checkerboard mask for some example inputs below. In order to make the Tensors easier to inspect, we will squeeze out the single channel dimension (which is always 1 for this mask).
```python
# Run the checkerboard_binary_mask function to see an example
# NB: we squeeze the shape for easier viewing. The full shape is (4, 4, 1)
tf.squeeze(checkerboard_binary_mask((4, 4), orientation=0))
```
<tf.Tensor: shape=(4, 4), dtype=float32, numpy=
array([[0., 1., 0., 1.],
[1., 0., 1., 0.],
[0., 1., 0., 1.],
[1., 0., 1., 0.]], dtype=float32)>
```python
# The `orientation` should be 0 or 1, and determines which way round the binary entries are
tf.squeeze(checkerboard_binary_mask((4, 4), orientation=1))
```
<tf.Tensor: shape=(4, 4), dtype=float32, numpy=
array([[1., 0., 1., 0.],
[0., 1., 0., 1.],
[1., 0., 1., 0.],
[0., 1., 0., 1.]], dtype=float32)>
```python
checkerboard_binary_mask((4, 4), orientation=1)
```
<tf.Tensor: shape=(4, 4, 1), dtype=float32, numpy=
array([[[1.],
[0.],
[1.],
[0.]],
[[0.],
[1.],
[0.],
[1.]],
[[1.],
[0.],
[1.],
[0.]],
[[0.],
[1.],
[0.],
[1.]]], dtype=float32)>
You should now complete the following function to create a channel-wise mask. This function takes a single integer `num_channels` as an input, as well as an `orientation` argument, similar to above. You can assume that the `num_channels` integer is even.
The function should return a rank-3 Tensor with singleton entries for `height` and `width`. In the channel axis, the first `num_channels // 2` entries should be zero (for `orientation=0`) and the final `num_channels // 2` entries should be one (for `orientation=0`). The zeros and ones should be reversed for `orientation=1`. The `dtype` of the returned Tensor should be `tf.float32`.
```python
#### GRADED CELL ####
# Complete the following function.
# Make sure to not change the function name or arguments.
def channel_binary_mask(num_channels, orientation=0):
"""
This function takes an integer num_channels and orientation (0 or 1) as
arguments. It should create a channel-wise binary mask with
dtype=tf.float32, according to the above specification.
The function should then return the binary mask.
"""
# Should do tf.ones(num_channels-z.shape[0]) where z = tf.zeros(num_channels // 2) because
# num_channels may not always be EVEN!
z = tf.zeros(num_channels // 2)
o = tf.ones(num_channels - z.shape[0])
return tf.concat([z,o], axis = -1)[None, None, ...] if not orientation else tf.concat([o,z], axis = -1)[None, None,...]
```
```python
# Run your function to see an example channel-wise binary mask
channel_binary_mask(6, orientation=0)
channel_binary_mask(6, orientation=1)
channel_binary_mask(5, orientation=1)
```
<tf.Tensor: shape=(1, 1, 5), dtype=float32, numpy=array([[[1., 1., 1., 0., 0.]]], dtype=float32)>
$$
\begin{align}
\text{Forward pass:}\qquad y &= b\odot x + (1-b)\odot\left(x\odot\exp(s(b\odot x)) + t(b\odot x)\right),\tag{5}\\
\text{Inverse pass:}\qquad x &= b\odot y + (1-b)\odot\left(y - t(b\odot x)) \odot\exp( -s(b\odot x)\right).\tag{6}
\end{align}
$$
```python
#### GRADED CELL ####
# Complete the following functions.
# Make sure to not change the function names or arguments.
def forward(x, b, shift_and_log_scale_fn):
"""
This function takes the input Tensor x, binary mask b and callable
shift_and_log_scale_fn as arguments.
This function should implement the forward transformation in equation (5)
and return the output Tensor y, which will have the same shape as x
"""
shift, log_scale = shift_and_log_scale_fn(x * b)
return x * b + (1 - b) * (x * tf.exp(log_scale) + shift)
def inverse(y, b, shift_and_log_scale_fn):
"""
This function takes the input Tensor x, binary mask b and callable
shift_and_log_scale_fn as arguments.
This function should implement the forward transformation in equation (5)
and return the output Tensor y, which will have the same shape as x
"""
shift, log_scale = shift_and_log_scale_fn(y * b)
return y * b + (1 - b) * (y - shift) * tf.exp(-log_scale)
```
```python
x = tf.random.normal((16, 32, 32, 3))
print(x.shape[-1])
b = channel_binary_mask(x.shape[-1], 1)
print(b)
forward(x, b, conv_resnet).shape
```
3
tf.Tensor([[[1. 1. 0.]]], shape=(1, 1, 3), dtype=float32)
TensorShape([16, 32, 32, 3])
The new bijector class also requires the `log_det_jacobian` methods to be implemented. Recall that the log of the Jacobian determinant of the forward transformation is given by $\sum_{j}s(x_{1:d})_j$, where $s$ is the log-scale function of the affine coupling layer.
You should now complete the following functions to define the `forward_log_det_jacobian` and `inverse_log_det_jacobian` methods of the affine coupling layer bijector.
* Both functions `forward_log_det_jacobian` and `inverse_log_det_jacobian` takes an input Tensor `x` (or `y`), a rank-3 binary mask `b`, and the `shift_and_log_scale_fn` callable
* These arguments are the same as the description for the `forward` and `inverse` functions
* The `forward_log_det_jacobian` function should implement the log of the Jacobian determinant for the transformation $(5)$
* The `inverse_log_det_jacobian` function should implement the log of the Jacobian determinant for the transformation $(6)$
* Both functions should reduce sum over the last three axes of the input Tensor (`height`, `width` and `channels`)
```python
#### GRADED CELL ####
# Complete the following functions.
# Make sure to not change the function names or arguments.
def forward_log_det_jacobian(x, b, shift_and_log_scale_fn):
"""
This function takes the input Tensor x, binary mask b and callable
shift_and_log_scale_fn as arguments.
This function should compute and return the log of the Jacobian determinant
of the forward transformation in equation (5)
"""
shift, log_scale = shift_and_log_scale_fn(x * b)
return tf.reduce_sum(log_scale * (1-b), axis=[-1,-2,-3])
def inverse_log_det_jacobian(y, b, shift_and_log_scale_fn):
"""
This function takes the input Tensor y, binary mask b and callable
shift_and_log_scale_fn as arguments.
This function should compute and return the log of the Jacobian determinant
of the forward transformation in equation (6)
"""
shift, log_scale = shift_and_log_scale_fn(y * b)
return -tf.reduce_sum(log_scale * (1-b), axis=[-1,-2,-3])
```
You are now ready to create the coupling layer bijector, using bijector subclassing. You should complete the class below to define the `AffineCouplingLayer`.
* You should complete the initialiser `__init__`, and the internal class method `_get_mask`
* The `_forward`, `_inverse`, `_forward_log_det_jacobian` and `_inverse_log_det_jacobian` methods are completed for you using the functions you have written above. Do not modify these methods
* The initialiser takes the `shift_and_log_scale_fn` callable, `mask_type` string (either `"checkerboard"` or `"channel"`, `orientation` (integer, either `0` or `1`) as required arguments, and allows for extra keyword arguments
* The required arguments should be set as class attributes in the initialiser (note that the `shift_and_log_scale_fn` attribute is being used in the `_forward`, `_inverse`, `_forward_log_det_jacobian` and `_inverse_log_det_jacobian` methods)
* The initialiser should call the base class initialiser, and pass in any extra keyword arguments
* The class should have a required number of event dimensions equal to 3
* The internal method `_get_mask` takes a `shape` as an argument, which is the shape of an input Tensor
* This method should use the `checkerboard_binary_mask` and `channel_binary_mask` functions above, as well as the `mask_type` and `orientation` arguments passed to the initialiser to compute and return the required binary mask
* This method is used in each of the `_forward`, `_inverse`, `_forward_log_det_jacobian` and `_inverse_log_det_jacobian` methods
```python
#### GRADED CELL ####
# Complete the following class.
# Make sure to not change the class or method names or arguments.
class AffineCouplingLayer(tfb.Bijector):
"""
Class to implement the affine coupling layer.
Complete the __init__ and _get_mask methods according to the instructions above.
"""
def __init__(self, shift_and_log_scale_fn, mask_type, orientation, **kwargs):
"""
The class initialiser takes the shift_and_log_scale_fn callable, mask_type,
orientation and possibly extra keywords arguments. It should call the
base class initialiser, passing any extra keyword arguments along.
It should also set the required arguments as class attributes.
"""
super().__init__(**kwargs, forward_min_event_ndims = 3)
self.shift_and_log_scale_fn = shift_and_log_scale_fn
self.mask_type = mask_type
self.orientation = orientation
def _get_mask(self, shape):
"""
This internal method should use the binary mask functions above to compute
and return the binary mask, according to the arguments passed in to the
initialiser.
"""
if self.mask_type == 'checkerboard':
return checkerboard_binary_mask(shape[1:], self.orientation)
else:
return channel_binary_mask(shape[-1], self.orientation)
def _forward(self, x):
b = self._get_mask(x.shape)
return forward(x, b, self.shift_and_log_scale_fn)
def _inverse(self, y):
b = self._get_mask(y.shape)
return inverse(y, b, self.shift_and_log_scale_fn)
def _forward_log_det_jacobian(self, x):
b = self._get_mask(x.shape)
return forward_log_det_jacobian(x, b, self.shift_and_log_scale_fn)
def _inverse_log_det_jacobian(self, y):
b = self._get_mask(y.shape)
return inverse_log_det_jacobian(y, b, self.shift_and_log_scale_fn)
```
```python
# Test your function by creating an instance of the AffineCouplingLayer class
affine_coupling_layer = AffineCouplingLayer(conv_resnet, 'channel', orientation=1,
name='affine_coupling_layer')
```
```python
# The following should return a Tensor of the same shape as the input
affine_coupling_layer.forward(tf.random.normal((16, 32, 32, 3))).shape
```
TensorShape([16, 32, 32, 3])
```python
# The following should compute a log_det_jacobian for each event in the batch
affine_coupling_layer.forward_log_det_jacobian(tf.random.normal((16, 32, 32, 3)), event_ndims=3).shape
```
TensorShape([16])
#### Combining the affine coupling layers
In the affine coupling layer, part of the input remains unchanged in the transformation $(5)$. In order to allow transformation of all of the input, several coupling layers are composed, with the orientation of the mask being reversed in subsequent layers.
<center>Figure 2. RealNVP alternates the orientation of masks from one affine coupling layer to the next. From the original paper.</center>
Our model design will be similar to the original architecture; we will compose three affine coupling layers with checkerboard masking, followed by a batch normalization bijector (`tfb.BatchNormalization` is a built-in bijector), followed by a squeezing operation, followed by three more affine coupling layers with channel-wise masking and a final batch normalization bijector.
The squeezing operation divides the spatial dimensions into 2x2 squares, and reshapes a Tensor of shape `(H, W, C)` into a Tensor of shape `(H // 2, W // 2, 4 * C)` as shown in Figure 1.
The squeezing operation is also a bijective operation, and has been provided for you in the class below.
```python
# Bijector class for the squeezing operation
class Squeeze(tfb.Bijector):
def __init__(self, name='Squeeze', **kwargs):
super(Squeeze, self).__init__(forward_min_event_ndims=3, is_constant_jacobian=True,
name=name, **kwargs)
def _forward(self, x):
input_shape = x.shape
height, width, channels = input_shape[-3:]
y = tfb.Reshape((height // 2, 2, width // 2, 2, channels), event_shape_in=(height, width, channels))(x)
y = tfb.Transpose(perm=[0, 2, 1, 3, 4])(y)
y = tfb.Reshape((height // 2, width // 2, 4 * channels),
event_shape_in=(height // 2, width // 2, 2, 2, channels))(y)
return y
def _inverse(self, y):
input_shape = y.shape
height, width, channels = input_shape[-3:]
x = tfb.Reshape((height, width, 2, 2, channels // 4), event_shape_in=(height, width, channels))(y)
x = tfb.Transpose(perm=[0, 2, 1, 3, 4])(x)
x = tfb.Reshape((2 * height, 2 * width, channels // 4),
event_shape_in=(height, 2, width, 2, channels // 4))(x)
return x
def _forward_log_det_jacobian(self, x):
return tf.constant(0., x.dtype)
def _inverse_log_det_jacobian(self, y):
return tf.constant(0., y.dtype)
def _forward_event_shape_tensor(self, input_shape):
height, width, channels = input_shape[-3], input_shape[-2], input_shape[-1]
return height // 2, width // 2, 4 * channels
def _inverse_event_shape_tensor(self, output_shape):
height, width, channels = output_shape[-3], output_shape[-2], output_shape[-1]
return height * 2, width * 2, channels // 4
```
You can see the effect of the squeezing operation on some example inputs in the cells below. In the forward transformation, each spatial dimension is halved, whilst the channel dimension is multiplied by 4. The opposite happens in the inverse transformation.
```python
# Test the Squeeze bijector
squeeze = Squeeze()
squeeze(tf.ones((10, 32, 32, 3))).shape
```
TensorShape([10, 16, 16, 12])
```python
# Test the inverse operation
squeeze.inverse(tf.ones((10, 4, 4, 96))).shape
```
TensorShape([10, 8, 8, 24])
We can now construct a block of coupling layers according to the architecture described above. You should complete the following function to chain together the bijectors that we have constructed, to form a bijector that performs the following operations in the forward transformation:
* Three `AffineCouplingLayer` bijectors with `"checkerboard"` masking with orientations `0, 1, 0` respectively
* A `BatchNormalization` bijector
* A `Squeeze` bijector
* Three more `AffineCouplingLayer` bijectors with `"channel"` masking with orientations `0, 1, 0` respectively
* Another `BatchNormalization` bijector
The function takes the following arguments:
* `shift_and_log_scale_fns`: a list or tuple of six conv_resnet models
* The first three models in this list are used in the three coupling layers with checkerboard masking
* The last three models in this list are used in the three coupling layers with channel masking
* `squeeze`: an instance of the `Squeeze` bijector
_NB: at this point, we would like to point out that we are following the exposition in the original paper, and think of the forward transformation as acting on the input image. Note that this is in contrast to the convention of using the forward transformation for sampling, and the inverse transformation for computing log probs._
```python
#### GRADED CELL ####
# Complete the following function.
# Make sure to not change the function name or arguments.
def realnvp_block(shift_and_log_scale_fns, squeeze):
"""
This function takes a list or tuple of six conv_resnet models, and an
instance of the Squeeze bijector.
The function should construct the chain of bijectors described above,
using the conv_resnet models in the coupling layers.
The function should then return the chained bijector.
"""
# The question actually wants to stack the AffineCouplingLayer and Squeeze bijectors together
# The inputs are the convet and squeeze functions which have NOT been converted to bijectors
len_of_list = len(shift_and_log_scale_fns)
middle = len_of_list // 2
zero_one_zero = [0,1,0]
lst1, lst2 = [], []
for i,orientation in zip(range(middle),zero_one_zero):
lst1.append(AffineCouplingLayer(shift_and_log_scale_fns[i],'checkerboard',
orientation = orientation))
lst1.append(squeeze)
lst1.append(tfb.BatchNormalization())
for i,orientation in zip(range(middle,len_of_list),zero_one_zero):
lst2.append(AffineCouplingLayer(shift_and_log_scale_fns[i],'checkerboard',
orientation = orientation))
lst = lst1+lst2
lst.append(tfb.BatchNormalization())
return tfb.Chain(lst[::-1])
```
```python
# Run your function to create an instance of the bijector
checkerboard_fns = []
for _ in range(3):
checkerboard_fns.append(get_conv_resnet((32, 32, 3), 512))
channel_fns = []
for _ in range(3):
channel_fns.append(get_conv_resnet((16, 16, 12), 512))
block = realnvp_block(checkerboard_fns + channel_fns, squeeze)
```
```python
# Test the bijector on a dummy input
block.forward(tf.random.normal((10, 32, 32, 3))).shape
```
TensorShape([10, 16, 16, 12])
#### Multiscale architecture
The final component of the RealNVP is the multiscale architecture. The squeeze operation reduces the spatial dimensions but increases the channel dimensions. After one of the blocks of coupling-squeeze-coupling that you have implemented above, half of the dimensions are factored out as latent variables, while the other half is further processed through subsequent layers. This results in latent variables that represent different scales of features in the model.
<center>Figure 3. RealNVP creates latent variables at different scales by factoring out half of the dimensions at each scale. From the original paper.</center>
The final scale does not use the squeezing operation, and instead applies four affine coupling layers with alternating checkerboard masks.
The multiscale architecture for two latent variable scales is implemented for you in the following bijector.
```python
# Bijector to implement the multiscale architecture
class RealNVPMultiScale(tfb.Bijector):
def __init__(self, **kwargs):
super(RealNVPMultiScale, self).__init__(forward_min_event_ndims=3, **kwargs)
# First level
shape1 = (32, 32, 3) # Input shape
shape2 = (16, 16, 12) # Shape after the squeeze operation
shape3 = (16, 16, 6) # Shape after factoring out the latent variable
self.conv_resnet1 = get_conv_resnet(shape1, 64)
self.conv_resnet2 = get_conv_resnet(shape1, 64)
self.conv_resnet3 = get_conv_resnet(shape1, 64)
self.conv_resnet4 = get_conv_resnet(shape2, 128)
self.conv_resnet5 = get_conv_resnet(shape2, 128)
self.conv_resnet6 = get_conv_resnet(shape2, 128)
self.squeeze = Squeeze()
self.block1 = realnvp_block([self.conv_resnet1, self.conv_resnet2,
self.conv_resnet3, self.conv_resnet4,
self.conv_resnet5, self.conv_resnet6], self.squeeze)
# Second level
self.conv_resnet7 = get_conv_resnet(shape3, 128)
self.conv_resnet8 = get_conv_resnet(shape3, 128)
self.conv_resnet9 = get_conv_resnet(shape3, 128)
self.conv_resnet10 = get_conv_resnet(shape3, 128)
self.coupling_layer1 = AffineCouplingLayer(self.conv_resnet7, 'checkerboard', 0)
self.coupling_layer2 = AffineCouplingLayer(self.conv_resnet8, 'checkerboard', 1)
self.coupling_layer3 = AffineCouplingLayer(self.conv_resnet9, 'checkerboard', 0)
self.coupling_layer4 = AffineCouplingLayer(self.conv_resnet10, 'checkerboard', 1)
self.block2 = tfb.Chain([self.coupling_layer4, self.coupling_layer3,
self.coupling_layer2, self.coupling_layer1])
def _forward(self, x):
h1 = self.block1.forward(x)
z1, h2 = tf.split(h1, 2, axis=-1)
z2 = self.block2.forward(h2)
return tf.concat([z1, z2], axis=-1)
def _inverse(self, y):
z1, z2 = tf.split(y, 2, axis=-1)
h2 = self.block2.inverse(z2)
h1 = tf.concat([z1, h2], axis=-1)
return self.block1.inverse(h1)
def _forward_log_det_jacobian(self, x):
log_det1 = self.block1.forward_log_det_jacobian(x, event_ndims=3)
h1 = self.block1.forward(x)
_, h2 = tf.split(h1, 2, axis=-1)
log_det2 = self.block2.forward_log_det_jacobian(h2, event_ndims=3)
return log_det1 + log_det2
def _inverse_log_det_jacobian(self, y):
z1, z2 = tf.split(y, 2, axis=-1)
h2 = self.block2.inverse(z2)
log_det2 = self.block2.inverse_log_det_jacobian(z2, event_ndims=3)
h1 = tf.concat([z1, h2], axis=-1)
log_det1 = self.block1.inverse_log_det_jacobian(h1, event_ndims=3)
return log_det1 + log_det2
def _forward_event_shape_tensor(self, input_shape):
height, width, channels = input_shape[-3], input_shape[-2], input_shape[-1]
return height // 4, width // 4, 16 * channels
def _inverse_event_shape_tensor(self, output_shape):
height, width, channels = output_shape[-3], output_shape[-2], output_shape[-1]
return 4 * height, 4 * width, channels // 16
```
```python
# Create an instance of the multiscale architecture
multiscale_bijector = RealNVPMultiScale()
```
#### Data preprocessing bijector
We will also preprocess the image data before sending it through the RealNVP model. To do this, for a Tensor $x$ of pixel values in $[0, 1]^D$, we transform $x$ according to the following:
$$
T(x) = \text{logit}\left(\alpha + (1 - 2\alpha)x\right),\tag{7}
$$
where $\alpha$ is a parameter, and the logit function is the inverse of the sigmoid function, and is given by
$$
\text{logit}(p) = \log (p) - \log (1 - p).
$$
You should now complete the following function to construct this bijector from in-built bijectors from the bijectors module.
* The function takes the parameter `alpha` as an input, which you can assume to take a small positive value ($\ll0.5$)
* The function should construct and return a bijector that computes $(7)$ in the forward pass
```python
#### GRADED CELL ####
# Complete the following function.
# Make sure to not change the function name or arguments.
def get_preprocess_bijector(alpha):
"""
This function should create a chained bijector that computes the
transformation T in equation (7) above.
This can be computed using in-built bijectors from the bijectors module.
Your function should then return the chained bijector.
"""
return tfb.Chain([tfb.Invert(tfb.Sigmoid()),
tfb.Shift(shift=alpha),
tfb.Scale(scale=(1-2*alpha))
])
```
```python
# Create an instance of the preprocess bijector
preprocess = get_preprocess_bijector(0.05)
```
#### Train the RealNVP model
Finally, we will use our RealNVP model to train
We will use the following model class to help with the training process.
```python
# Helper class for training
class RealNVPModel(Model):
def __init__(self, **kwargs):
super(RealNVPModel, self).__init__(**kwargs)
self.preprocess = get_preprocess_bijector(0.05)
self.realnvp_multiscale = RealNVPMultiScale()
self.bijector = tfb.Chain([self.realnvp_multiscale, self.preprocess])
def build(self, input_shape):
output_shape = self.bijector(tf.expand_dims(tf.zeros(input_shape[1:]), axis=0)).shape
self.base = tfd.Independent(tfd.Normal(loc=tf.zeros(output_shape[1:]), scale=1.),
reinterpreted_batch_ndims=3)
self._bijector_variables = (
list(self.bijector.variables))
self.flow = tfd.TransformedDistribution(
distribution=self.base,
bijector=tfb.Invert(self.bijector),
)
super(RealNVPModel, self).build(input_shape)
def call(self, inputs, training=None, **kwargs):
return self.flow
def sample(self, batch_size):
sample = self.base.sample(batch_size)
return self.bijector.inverse(sample)
```
```python
# Create an instance of the RealNVPModel class
realnvp_model = RealNVPModel()
realnvp_model.build((1, 32, 32, 3))
```
```python
# Compute the number of variables in the model
print("Total trainable variables:")
print(sum([np.prod(v.shape) for v in realnvp_model.trainable_variables]))
```
Total trainable variables:
315198
Note that the model's `call` method returns the `TransformedDistribution` object. Also, we have set up our datasets to return the input image twice as a 2-tuple. This is so we can train our model with negative log-likelihood as normal.
```python
# Define the negative log-likelihood loss function
def nll(y_true, y_pred):
return -y_pred.log_prob(y_true)
```
It is recommended to use the GPU accelerator hardware on Colab to train this model, as it can take some time to train. Note that it is not required to train the model in order to pass this assignment. For optimal results, a larger model should be trained for longer.
```python
# Compile and train the model
realnvp_model.compile(loss=nll, optimizer=Adam())
realnvp_model.fit(train_ds, validation_data=val_ds, epochs=20)
```
```python
# Evaluate the model
realnvp_model.evaluate(test_ds)
```
#### Generate some samples
```python
# Sample from the model
samples = realnvp_model.sample(8).numpy()
```
```python
# Display the samples
n_img = 8
f, axs = plt.subplots(2, n_img // 2, figsize=(14, 7))
for k, image in enumerate(samples):
i = k % 2
j = k // 2
axs[i, j].imshow(np.clip(image, 0., 1.))
axs[i, j].axis('off')
f.subplots_adjust(wspace=0.01, hspace=0.03)
```
Congratulations on completing this programming assignment! In the next week of the course we will look at the variational autoencoder.
|
lemma order_root: "poly p a = 0 \<longleftrightarrow> p = 0 \<or> order a p \<noteq> 0" (is "?lhs = ?rhs") |
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 conj17synthconj1 : forall (lv0 : natural) (lv1 : natural) (lv2 : natural), (@eq natural (mult (plus (mult lv0 lv1) lv1) lv2) (mult (mult lv1 lv2) (Succ lv0))).
Admitted.
QuickChick conj17synthconj1.
|
Require Import List.
Require Import FSets.
Require FSetAVL.
Require Peano_dec.
Require Import Setoid.
Require Import OptionMonad.
Require Import OptionExt.
Require Import BoolExt.
Require Import ILLInterfaces.
Require Import ResourceAlgebra.
Require Import Arith.
Require Import Omega.
Require Import BasicMachineTypes.
Module MkILLSyntax
(B : BASICS)
(BASESYN : ILL_BASE_SYNTAX B)
: ILL_SYNTAX B BASESYN.
Import BASESYN.
Definition context := list formula.
Inductive prf_term : Set :=
| t_lvar : nat -> prf_term
| t_ivar : nat -> prf_term
| t_i_intro : prf_term
| t_tensor_intro : prf_term -> prf_term -> prf_term
| t_tensor_elim : prf_term -> prf_term -> prf_term
| t_and_intro : prf_term -> prf_term -> prf_term
| t_and_elim1 : prf_term -> prf_term
| t_and_elim2 : prf_term -> prf_term
| t_lolli_intro : formula -> prf_term -> prf_term
| t_lolli_elim : prf_term -> prf_term -> prf_term
| t_bang_intro : prf_term -> prf_term
| t_bang_elim : prf_term -> prf_term -> prf_term
| t_axiom : axiom_name -> prf_term -> prf_term
| t_let : prf_term -> prf_term -> prf_term.
Fixpoint l_shift (d c:nat) (t:prf_term) {struct t} : prf_term :=
match t with
| t_lvar k => if le_lt_dec c k then t_lvar (d + k) else t_lvar k
| t_ivar k => t_ivar k
| t_i_intro => t_i_intro
| t_tensor_intro t1 t2 => t_tensor_intro (l_shift d c t1) (l_shift d c t2)
| t_tensor_elim t1 t2 => t_tensor_elim (l_shift d c t1) (l_shift d (S (S c)) t2)
| t_and_intro t1 t2 => t_and_intro (l_shift d c t1) (l_shift d c t2)
| t_and_elim1 t => t_and_elim1 (l_shift d c t)
| t_and_elim2 t => t_and_elim2 (l_shift d c t)
| t_lolli_intro A t => t_lolli_intro A (l_shift d (S c) t)
| t_lolli_elim t1 t2 => t_lolli_elim (l_shift d c t1) (l_shift d c t2)
| t_bang_intro t => t_bang_intro (l_shift d c t)
| t_bang_elim t1 t2 => t_bang_elim (l_shift d c t1) (l_shift d c t2)
| t_axiom nm t => t_axiom nm (l_shift d c t)
| t_let t1 t2 => t_let (l_shift d c t1) (l_shift d (S c) t2)
end.
Definition var_subst : nat -> nat -> prf_term -> prf_term.
intros k j t'.
destruct (lt_eq_lt_dec k j) as [[k_lt_j | k_eq_j] | j_lt_k].
exact (t_lvar k).
exact t'.
destruct (O_or_S k) as [[m k_eq_Sm] | k_eq_0].
exact (t_lvar m).
subst k. elimtype False. apply (lt_n_O j j_lt_k).
Defined.
Fixpoint l_subst (t:prf_term) (s:prf_term) (j:nat) {struct t} : prf_term :=
match t with
| t_lvar k => var_subst k j s
| t_ivar k => t_ivar k
| t_i_intro => t_i_intro
| t_tensor_intro t1 t2 => t_tensor_intro (l_subst t1 s j) (l_subst t2 s j)
| t_tensor_elim t1 t2 => t_tensor_elim (l_subst t1 s j) (l_subst t2 (l_shift 2 0 s) (S (S j)))
| t_and_intro t1 t2 => t_and_intro (l_subst t1 s j) (l_subst t2 s j)
| t_and_elim1 t => t_and_elim1 (l_subst t s j)
| t_and_elim2 t => t_and_elim2 (l_subst t s j)
| t_lolli_intro A t => t_lolli_intro A (l_subst t (l_shift 1 0 s) (S j))
| t_lolli_elim t1 t2 => t_lolli_elim (l_subst t1 s j) (l_subst t2 s j)
| t_bang_intro t => t_bang_intro (l_subst t s j)
| t_bang_elim t1 t2 => t_bang_elim (l_subst t1 s j) (l_subst t2 s j)
| t_axiom nm t => t_axiom nm (l_subst t s j)
| t_let t1 t2 => t_let (l_subst t1 s j) (l_subst t2 (l_shift 1 0 s) (S j))
end.
Module VarSet <: FSetInterface.Sfun Nat_as_OT := FSetAVL.Make Nat_as_OT.
(*Module VarSet : FSetInterface.S with Module E := Nat_as_OT := FSetAVL.Make Nat_as_OT.*)
Definition shift_step n s := match n with O => s | S n => VarSet.add n s end.
Definition shift_down s := VarSet.fold shift_step s VarSet.empty.
Definition shift2_step d c n s := if le_lt_dec c n then VarSet.add (d+n) s else VarSet.add n s.
Definition shift_varset d c s := VarSet.fold (shift2_step d c) s VarSet.empty.
Inductive prf : context -> context -> prf_term -> formula -> VarSet.t -> Prop :=
| prf_ivar : forall Gi G n A U,
nth_error Gi n = Some A ->
VarSet.Equal U VarSet.empty ->
prf Gi G (t_ivar n) A U
| prf_lvar : forall Gi G n A U,
nth_error G n = Some A ->
VarSet.Equal U (VarSet.singleton n) ->
prf Gi G (t_lvar n) A U
| prf_i_intro : forall Gi G U,
VarSet.Equal U VarSet.empty ->
prf Gi G t_i_intro f_i U
| prf_tensor_intro : forall Gi G t1 t2 A B U1 U2 U,
prf Gi G t1 A U1 ->
prf Gi G t2 B U2 ->
VarSet.Empty (VarSet.inter U1 U2) ->
VarSet.Equal U (VarSet.union U1 U2) ->
prf Gi G (t_tensor_intro t1 t2) (f_tensor A B) U
| prf_tensor_elim : forall Gi G t1 t2 A B C U1 U2 U,
prf Gi G t1 (f_tensor A B) U1 ->
prf Gi (A::B::G) t2 C U2 ->
VarSet.Empty (VarSet.inter U1 (shift_down (shift_down U2))) ->
VarSet.Equal U (VarSet.union U1 (shift_down (shift_down U2))) ->
prf Gi G (t_tensor_elim t1 t2) C U
| prf_and_intro : forall Gi G t1 t2 A B U1 U2 U,
prf Gi G t1 A U1->
prf Gi G t2 B U2 ->
VarSet.Equal U (VarSet.union U1 U2) ->
prf Gi G (t_and_intro t1 t2) (f_and A B) U
| prf_and_elim1 : forall Gi G t A B U,
prf Gi G t (f_and A B) U ->
prf Gi G (t_and_elim1 t) A U
| prf_and_elim2 : forall Gi G t A B U,
prf Gi G t (f_and A B) U ->
prf Gi G (t_and_elim2 t) B U
| prf_lolli_intro : forall Gi G t A B Ut U,
prf Gi (A::G) t B Ut ->
VarSet.Equal U (shift_down Ut) ->
prf Gi G (t_lolli_intro A t) (f_lolli A B) U
| prf_lolli_elim : forall Gi G t1 t2 A B U1 U2 U,
prf Gi G t1 (f_lolli A B) U1 ->
prf Gi G t2 A U2 ->
VarSet.Empty (VarSet.inter U1 U2) ->
VarSet.Equal U (VarSet.union U1 U2) ->
prf Gi G (t_lolli_elim t1 t2) B U
| prf_bang_intro : forall Gi G t A U,
prf Gi G t A U ->
VarSet.Empty U ->
prf Gi G (t_bang_intro t) (f_bang A) U
| prf_bang_elim : forall Gi G t1 t2 A B U1 U2 U,
prf Gi G t1 (f_bang A) U1 ->
prf (A::Gi) G t2 B U2 ->
VarSet.Empty (VarSet.inter U1 U2) ->
VarSet.Equal U (VarSet.union U1 U2) ->
prf Gi G (t_bang_elim t1 t2) B U
| prf_axiom : forall Gi G t ax U,
prf Gi G t (axiom_domain ax) U ->
prf Gi G (t_axiom ax t) (axiom_codomain ax) U
| prf_let : forall Gi G t1 t2 A B U1 Ut2 U2 U,
prf Gi G t1 A U1 ->
prf Gi (A::G) t2 B Ut2 ->
VarSet.Equal U2 (shift_down Ut2) ->
VarSet.Empty (VarSet.inter U1 U2) ->
VarSet.Equal U (VarSet.union U1 U2) ->
prf Gi G (t_let t1 t2) B U.
Module VarSetProps := Properties VarSet.
Lemma varset_setoid : Setoid_Theory VarSet.t VarSet.Equal.
Proof.
constructor. unfold Reflexive. reflexivity. unfold Symmetric. symmetry. assumption. intros. unfold Transitive. apply VarSet.eq_trans.
Qed.
Lemma prf_mor_aux : forall Gi G t A U1 U2, VarSet.Equal U1 U2 -> prf Gi G t A U1 -> prf Gi G t A U2.
intros.
generalize U2 H. clear U2 H.
induction H0; intros U2' U2'_eq_U; econstructor; eauto; rewrite <- U2'_eq_U; assumption.
Save.
Add Morphism prf with signature (@eq context) ==> (@eq context) ==> (@eq prf_term) ==> (@eq formula) ==> VarSet.Equal ==> iff as prf_mor.
intuition eauto using prf_mor_aux, VarSetProps.equal_sym.
Save.
Add Morphism shift_step with signature (@eq nat) ==> VarSet.Equal ==> VarSet.Equal as shift_step_mor.
intros. unfold shift_step. destruct y.
assumption.
rewrite H. reflexivity.
Save.
Add Morphism shift2_step with signature (@eq nat) ==> (@eq nat) ==> (@eq nat) ==> VarSet.Equal ==> VarSet.Equal as shift2_step_mor.
unfold shift2_step. intros. destruct (le_lt_dec y0 y1); rewrite H; reflexivity.
Save.
Add Morphism shift_varset with signature (@eq nat) ==> (@eq nat) ==> VarSet.Equal ==> VarSet.Equal as shift_varset_mor.
unfold shift_varset. intros. refine (VarSetProps.fold_equal varset_setoid _ _ _ H).
unfold compat_op. apply shift2_step_mor_Proper; auto.
unfold transpose. intros. unfold shift2_step.
destruct (le_lt_dec y0 x0); destruct (le_lt_dec y0 y2); rewrite VarSetProps.add_add; reflexivity.
Save.
Add Morphism shift_down with signature VarSet.Equal ==> VarSet.Equal as shift_down_mor.
unfold shift_down. intros. refine (VarSetProps.fold_equal varset_setoid _ _ _ H).
unfold compat_op. apply shift_step_mor_Proper.
unfold transpose. intros. unfold shift_step.
destruct x0; destruct y0; try reflexivity; eauto using VarSetProps.add_add.
Save.
Lemma list_empty : forall l,
(forall x, ~InA (@eq nat) x l) -> l = nil.
destruct l; intros.
reflexivity.
elimtype False. apply (H n). constructor. reflexivity.
Save.
Lemma elements_empty : VarSet.elements VarSet.empty = nil.
apply list_empty. intros. unfold not. intro. apply (VarSet.empty_1 (VarSet.elements_2 H)).
Save.
Lemma shift_varset_empty : forall d c,
VarSet.Equal (shift_varset d c VarSet.empty) VarSet.empty.
intros. unfold shift_varset. rewrite VarSet.fold_1. rewrite elements_empty. reflexivity.
Save.
Lemma list_single : forall l y,
(forall x, InA (@eq nat) x l <-> x=y) ->
sort Nat_as_OT.lt l ->
l = y::nil.
destruct l; intros.
assert (InA (@eq nat) y nil). rewrite H. reflexivity. inversion H1.
assert (n = y). rewrite <- H. constructor. reflexivity.
subst. destruct l.
reflexivity.
assert (n = y). rewrite <- H. right. constructor. reflexivity.
subst. inversion H0. inversion H4. elimtype False. refine (Nat_as_OT.lt_not_eq H6 _). unfold Nat_as_OT.eq. reflexivity.
Save.
Lemma elements_singleton : forall n, VarSet.elements (VarSet.singleton n) = n::nil.
intros. apply list_single.
intros. split; intro.
symmetry. eapply VarSet.singleton_1. apply VarSet.elements_2. assumption.
apply VarSet.elements_1. apply VarSet.singleton_2. unfold VarSet.E.eq. symmetry. assumption.
apply VarSet.elements_3.
Save.
Lemma shift_varset_singleton : forall d c n,
c <= n ->
VarSet.Equal (shift_varset d c (VarSet.singleton n)) (VarSet.singleton (d + n)).
intros. unfold shift_varset. rewrite VarSet.fold_1. rewrite elements_singleton. simpl. unfold shift2_step.
destruct (le_lt_dec c n).
auto with set.
elimtype False. omega.
Save.
Lemma shift_varset_singleton2 : forall d c n,
n < c ->
VarSet.Equal (shift_varset d c (VarSet.singleton n)) (VarSet.singleton n).
intros. unfold shift_varset. rewrite VarSet.fold_1. rewrite elements_singleton. simpl. unfold shift2_step.
destruct (le_lt_dec c n).
elimtype False. omega.
auto with set.
Save.
Lemma lookup_length : forall (A:Set) (G G'':list A) a, nth_error (G'' ++ a :: G) (length G'') = Some a.
induction G''; intros; simpl; intuition eauto.
Save.
Lemma lookup_length2 : forall (A:Set) (G G'':list A) a n, nth_error (G'' ++ a :: G) (length G'' + S n) = nth_error G n.
induction G''; intros; simpl; auto.
Save.
Lemma lookup_length3 : forall (A:Set) (G:list A) n a, nth_error G n = Some a -> n < length G.
induction G; intros. destruct n; simpl; discriminate.
destruct n; simpl in *; auto with arith.
apply lt_n_S. eapply IHG; eauto.
Qed.
Lemma lookup_suffix : forall (A:Set) (G G' G'':list A) n a,
length G' <= n ->
nth_error (G' ++ G) n = Some a ->
nth_error (G' ++ G'' ++ G) (length G'' + n) = Some a.
intros A G G' G'' n a. generalize G'. clear G'. induction n; intros; destruct G'.
destruct G.
discriminate.
inversion H0. simpl. replace (length G''+0) with (length G'') by omega. apply lookup_length.
simpl in H. inversion H.
destruct G.
discriminate.
simpl in *. rewrite lookup_length2. assumption.
replace (length G'' + S n) with (S (length G'' + n)) by omega. simpl in *. apply IHn.
omega. assumption.
Save.
Lemma lookup_prefix : forall (A:Set) (G G'' G':list A) n a,
n < length G' ->
nth_error (G' ++ G) n = Some a ->
nth_error (G' ++ G'' ++ G) n = Some a.
intros A G G'' G' n a. generalize G'. clear G'. induction n; intros; (destruct G'; [inversion H|]).
trivial.
simpl in *. apply IHn. omega. assumption.
Save.
Lemma add_not_empty : forall x s, ~VarSet.Empty (VarSet.add x s).
unfold VarSet.Empty. unfold not. intros.
eapply H. apply VarSet.add_1. reflexivity.
Save.
(* Hmm... the hintsdb for set seems to be screwed up with 8.3. *)
Hint Resolve VarSet.add_1 VarSet.add_2 VarSet.add_3 : set.
Lemma add_equal : forall x s s', VarSetProps.Add x s s' -> VarSet.Equal s' (VarSet.add x s).
intros. unfold VarSetProps.Add in H. unfold VarSet.Equal. intro. split; intro.
rewrite H in H0. intuition eauto with set.
rewrite H. destruct (eq_nat_dec x a); [left|right]; eauto with set.
Save.
Lemma shift2_step_twice : forall d c x U, VarSet.Equal (shift2_step d c x (shift2_step d c x U)) (shift2_step d c x U).
unfold shift2_step. intros.
destruct (le_lt_dec c x); apply VarSetProps.add_equal; apply VarSet.add_1; reflexivity.
Save.
Lemma shift2_step_transpose : forall d c x y U, VarSet.Equal (shift2_step d c x (shift2_step d c y U)) (shift2_step d c y (shift2_step d c x U)).
unfold shift2_step. intros.
destruct (le_lt_dec c x); destruct (le_lt_dec c y); rewrite VarSetProps.add_add; reflexivity.
Save.
(* FIXME: need to redo SetoidList.fold_right_add for when f is idemopotent, like shift2_step is *)
(*
Lemma fold_right_add_2 : forall d c i s' s x,
NoDup s ->
NoDup s' ->
(forall y, InA (@eq nat) y s' <-> x = y \/ InA (@eq nat) y s) ->
VarSet.Equal (fold_right (shift2_step d c) i s') (shift2_step d c x (fold_right (shift2_step d c) i s)).
induction s'.
(* base case *)
intros. assert (InA (@eq nat) x nil). rewrite H1. auto. inversion H2.
(* step case *)
simpl. intros.
destruct (eq_nat_dec x a).
subst. rewrite (IHs' s a).
apply H.
inversion H0. apply H5.
intro. split; intro.
rewrite <- H1. right. apply H2.
destruct H2. subst.
apply H1.
simpl.
apply IH. reflexivity.
Lemma shift_varset_add : forall d c s x,
VarSet.Equal (shift_varset d c (VarSet.add x s)) (shift2_step d c x (shift_varset d c s)).
intros.
elim s using VarSetProps.set_induction; intros.
(* base *)
rewrite (VarSetProps.empty_is_empty_1 H). rewrite shift_varset_empty.
rewrite <- VarSetProps.singleton_equal_add. unfold shift2_step. destruct (le_lt_dec c x).
rewrite shift_varset_singleton; auto using VarSetProps.singleton_equal_add.
rewrite shift_varset_singleton2; auto using VarSetProps.singleton_equal_add.
(* step *)
assert (VarSet.Equal s' (VarSet.add x0 s0)). auto using add_equal.
rewrite H2. destruct (eq_nat_dec x x0).
subst. setoid_replace (VarSet.add x0 (VarSet.add x0 s0)) with (VarSet.add x0 s0).
rewrite H. rewrite shift2_step_twice. reflexivity.
apply VarSetProps.add_equal. apply VarSet.add_1. reflexivity.
rewrite <- H2.
destruct (VarSetProps.fold_0 (VarSet.add x s) VarSet.empty (shift2_step d c)) as [l [l_nodup [l_eq_xs l_fold_eq]]].
destruct (VarSetProps.fold_0 s VarSet.empty (shift2_step d c)) as [l2 [l2_nodup [l2_eq_xs l2_fold_eq]]].
rewrite l_fold_eq. rewrite l2_fold_eq. clear l_fold_eq l2_fold_eq.
setoid_replace (shift2_step d c x (fold_right (shift2_step d c) VarSet.empty l2))
with (fold_right (shift2_step d c) VarSet.empty (x::l2)).
generalize
simpl. reflexivity.
*)
Lemma In_shift_varset : forall n n' s c d,
VarSet.In n s -> n'=(if le_lt_dec c n then d+n else n) -> VarSet.In n' (shift_varset d c s).
Proof.
intros. subst n'. unfold shift_varset. apply VarSet.elements_1 in H. rewrite VarSet.fold_1. set (l:=VarSet.elements s) in *. generalize VarSet.empty. clearbody l. induction l.
inversion H.
inversion H; subst.
intros. simpl. set (r:=shift2_step d c a t) in *. assert (VarSet.In (if le_lt_dec c a then d + a else a) r).
unfold r. unfold shift2_step. destruct (le_lt_dec c a); apply VarSet.add_1; reflexivity.
clearbody r. generalize r H0. clear. induction l; intros.
simpl. assumption.
simpl. apply IHl. unfold shift2_step. destruct (le_lt_dec c a0); apply VarSet.add_2; assumption.
intros. simpl. apply IHl. assumption.
Qed.
Lemma shift_varset_In : forall n s c d,
VarSet.In n (shift_varset d c s) -> VarSet.In (if le_lt_dec c n then n-d else n) s.
Proof.
intros. unfold shift_varset in H. apply VarSet.elements_2. rewrite VarSet.fold_1 in H. set (l:=VarSet.elements s) in *. clearbody l. set (r:=VarSet.empty) in *. assert (~VarSet.In n r). apply VarSet.empty_1. clearbody r. generalize r H H0. clear. induction l; intros.
simpl in H. contradiction.
compare (if le_lt_dec c n then n - d else n) a; intros.
subst a. left. reflexivity.
right. eapply IHl. simpl in H. eassumption.
unfold shift2_step. destruct (le_lt_dec c n); destruct (le_lt_dec c a);
intro bad; destruct H0; (eapply VarSet.add_3; [|eassumption]); unfold VarSet.E.eq; omega.
Qed.
Lemma shift_varset_image : forall n s c d,
VarSet.In n (shift_varset d c s) -> n < c \/ n >= c+d.
Proof.
intros. unfold shift_varset in H. rewrite VarSet.fold_1 in H. set (l:=VarSet.elements s) in *. clearbody l. set (r:=VarSet.empty) in *. assert (forall n', VarSet.In n' r -> n'<c \/ n'>=c+d).
intros. destruct (VarSet.empty_1 H0).
clearbody r. generalize r H H0. clear. induction l; intros.
simpl in H. auto.
eapply IHl.
simpl in H. apply H.
unfold shift2_step. destruct (le_lt_dec c a); intros.
compare n' (d+a); intros. omega.
apply VarSet.add_3 in H1. auto. unfold VarSet.E.eq. auto.
compare n' a; intros. omega.
apply VarSet.add_3 in H1. auto. unfold VarSet.E.eq. auto.
Qed.
Lemma shift_varset_add : forall d c x s,
~VarSet.In x s ->
VarSet.Equal (shift_varset d c (VarSet.add x s)) (shift2_step d c x (shift_varset d c s)).
intros. unfold shift_varset. apply VarSetProps.fold_add.
apply varset_setoid.
unfold compat_op. apply shift2_step_mor_Proper; auto.
unfold transpose. intros. unfold shift2_step.
destruct (le_lt_dec c x0); destruct (le_lt_dec c y); rewrite VarSetProps.add_add; reflexivity.
assumption.
Save.
Lemma shift_down_add : forall x s,
~VarSet.In x s ->
VarSet.Equal (shift_down (VarSet.add x s)) (shift_step x (shift_down s)).
intros. unfold shift_down. apply VarSetProps.fold_add.
apply varset_setoid.
unfold compat_op. apply shift_step_mor_Proper.
unfold transpose. intros. unfold shift_step.
destruct x0; destruct y; try reflexivity; eauto using VarSetProps.add_add.
assumption.
Save.
Lemma not_in_shift_varset_1 : forall U2 d c x, ~VarSet.In x U2 -> c<=x -> ~VarSet.In (d+x) (shift_varset d c U2).
intros U2. elim U2 using VarSetProps.set_induction; intros.
rewrite (VarSetProps.empty_is_empty_1 H). rewrite shift_varset_empty. apply (VarSet.empty_1).
assert (VarSet.Equal s' (VarSet.add x s)). auto using add_equal.
rewrite H4 in H2.
rewrite H4. rewrite shift_varset_add. 2:assumption.
destruct (eq_nat_dec x x0).
elimtype False. auto using VarSet.add_1.
assert (~VarSet.In x0 s). auto using VarSet.add_2.
unfold shift2_step. destruct (le_lt_dec c x); unfold not; intros.
refine (H d _ _ H5 H3 (VarSet.add_3 (x:=d+x) _ H6)). unfold VarSet.E.eq. omega.
refine (H d _ _ H5 H3 (VarSet.add_3 (x:=x) _ H6)). unfold VarSet.E.eq. omega.
Save.
Lemma not_in_shift_varset_2 : forall d c U2 x, ~VarSet.In x U2 -> x<c -> ~VarSet.In x (shift_varset d c U2).
intros d c U2. elim U2 using VarSetProps.set_induction; intros.
rewrite (VarSetProps.empty_is_empty_1 H). rewrite shift_varset_empty. apply (VarSet.empty_1).
assert (VarSet.Equal s' (VarSet.add x s)). auto using add_equal.
rewrite H4 in H2.
rewrite H4. rewrite shift_varset_add. 2:assumption.
destruct (eq_nat_dec x x0).
elimtype False. auto using VarSet.add_1.
assert (~VarSet.In x0 s). auto using VarSet.add_2.
unfold shift2_step. destruct (le_lt_dec c x); unfold not; intros.
refine (H _ H5 H3 (VarSet.add_3 (x:=d+x) _ H6)). unfold VarSet.E.eq. omega.
refine (H _ H5 H3 (VarSet.add_3 (x:=x) _ H6)). unfold VarSet.E.eq. omega.
Save.
Lemma shift_varset_empty_inter : forall d c U1 U2,
VarSet.Empty (VarSet.inter U1 U2) ->
VarSet.Empty (VarSet.inter (shift_varset d c U1) (shift_varset d c U2)).
intros d c U1. elim U1 using VarSetProps.set_induction; intros.
rewrite (VarSetProps.empty_is_empty_1 H). rewrite shift_varset_empty. auto with set.
assert (VarSet.Equal s' (VarSet.add x s)). auto using add_equal.
rewrite H3. rewrite shift_varset_add. 2:assumption.
rewrite H3 in H2.
assert (~VarSet.In x U2). destruct (VarSetProps.In_dec x U2).
rewrite (VarSetProps.inter_add_1 s i) in H2. elimtype False. apply (add_not_empty _ _ H2).
assumption.
rewrite (VarSetProps.inter_add_2 s H4) in H2.
unfold shift2_step. destruct (le_lt_dec c x).
rewrite (VarSetProps.inter_add_2); auto using not_in_shift_varset_1.
rewrite (VarSetProps.inter_add_2); auto using not_in_shift_varset_2.
Save.
Lemma shift2_step_union : forall d c U1 U2 x,
VarSet.Equal (shift2_step d c x (VarSet.union U1 U2)) (VarSet.union (shift2_step d c x U1) U2).
intros. unfold shift2_step.
destruct (le_lt_dec c x); auto with set.
Save.
Lemma shift_varset_union : forall d c U1 U2,
VarSet.Equal (shift_varset d c (VarSet.union U1 U2)) (VarSet.union (shift_varset d c U1) (shift_varset d c U2)).
Proof.
intros. intro y. split; intro H.
set (H1 := shift_varset_image _ _ _ _ H). clearbody H1. apply shift_varset_In in H.
destruct (VarSet.union_1 H); [apply VarSet.union_2|apply VarSet.union_3]; (eapply In_shift_varset; [apply H0| destruct H1; destruct (le_lt_dec c y); destruct (le_lt_dec c (y-d)); destruct (le_lt_dec c y); omega]).
destruct (VarSet.union_1 H); set (H1 := shift_varset_image _ _ _ _ H0); clearbody H1;
apply shift_varset_In in H0 ; (apply In_shift_varset with (n:=(if le_lt_dec c y then y - d else y)); [| destruct H1; destruct (le_lt_dec c y); destruct (le_lt_dec c (y-d)); destruct (le_lt_dec c y); omega]).
apply VarSet.union_2. assumption.
apply VarSet.union_3. assumption.
Qed.
(*Lemma shift_varset_union : forall d c U1 U2,
VarSet.Equal (shift_varset d c (VarSet.union U1 U2)) (VarSet.union (shift_varset d c U1) (shift_varset d c U2)).
Admitted.
*)
Lemma shift_down_empty : VarSet.Equal (shift_down VarSet.empty) VarSet.empty.
unfold shift_down. rewrite VarSet.fold_1. rewrite elements_empty. reflexivity.
Save.
Lemma In_shift_down : forall n U,
VarSet.In (S n) U -> VarSet.In n (shift_down U).
Proof.
intros n U H. apply VarSet.elements_1 in H. unfold shift_down. rewrite VarSet.fold_1. set (l:=VarSet.elements U) in *. clearbody l. clear U. generalize VarSet.empty. induction l.
inversion H.
intro s0. simpl. inversion H; subst.
simpl. set (s1:=VarSet.add n s0). assert (VarSet.In n s1) by (unfold s1; apply VarSet.add_1; reflexivity). generalize s1 H0. clear . induction l; intros.
simpl. assumption.
simpl. assert (VarSet.In n (shift_step a s1)) by (unfold shift_step; destruct a; auto using VarSet.add_2). apply IHl. assumption.
apply IHl. assumption.
Qed.
Lemma shift_down_In : forall n U,
VarSet.In n (shift_down U) -> VarSet.In (S n) U.
Proof.
intros n U H. apply VarSet.elements_2. unfold shift_down in H. rewrite VarSet.fold_1 in H. set (l:=VarSet.elements U) in *. clearbody l. assert (~VarSet.In n VarSet.empty). apply VarSet.empty_1. generalize H H0. generalize VarSet.empty. clear. induction l; intros.
simpl in H. contradiction.
simpl in H. compare a (S n); intro an.
subst a. left. reflexivity.
right. eapply IHl. apply H. unfold shift_step. destruct a. assumption.
assert (~VarSet.E.eq a n). change VarSet.E.eq with (eq (A:=nat)). intro an'. subst a. destruct an. reflexivity.
intro inadded. destruct H0. eapply VarSet.add_3; eauto.
Qed.
Lemma down_shift : forall d c U x, VarSet.Equal (shift_down (shift2_step d (S c) (S x) U)) (shift2_step d c x (shift_down U)).
intros. unfold shift2_step. destruct (le_lt_dec (S c) (S x)); destruct (le_lt_dec c x); try (elimtype False; clear - l l0; omega).
rewrite <- plus_Snm_nSm.
destruct (VarSetProps.In_dec (S d + x) U).
rewrite VarSetProps.add_equal; auto. rewrite VarSetProps.add_equal; [reflexivity|apply In_shift_down;assumption].
rewrite shift_down_add; auto. simpl. reflexivity.
destruct (VarSetProps.In_dec (S x) U).
rewrite VarSetProps.add_equal; auto. rewrite VarSetProps.add_equal; [reflexivity|apply In_shift_down;assumption].
rewrite shift_down_add; auto. simpl. reflexivity.
Qed.
Lemma shift_down_varset : forall d c U, VarSet.Equal (shift_down (shift_varset d (S c) U)) (shift_varset d c (shift_down U)).
intros d c U. elim U using VarSetProps.set_induction; intros.
(* base *)
rewrite (VarSetProps.empty_is_empty_1 H).
rewrite shift_down_empty. rewrite shift_varset_empty.
rewrite shift_down_empty. rewrite shift_varset_empty. reflexivity.
(* step *)
assert (VarSet.Equal s' (VarSet.add x s)). auto using add_equal.
rewrite H2.
rewrite shift_varset_add. 2:assumption.
rewrite shift_down_add. 2:assumption.
case_eq x; intros.
subst x. unfold shift2_step. simpl. rewrite shift_down_add. 2:(apply not_in_shift_varset_2; auto with arith). simpl. assumption.
simpl. rewrite shift_varset_add.
rewrite down_shift. rewrite H. reflexivity.
intro H'. destruct H0. rewrite H3. apply shift_down_In. assumption.
Qed.
(*
Lemma shift_down_varset_2 : forall s,
VarSet.Equal s (shift_down (shift_varset 1 1 s)).
Proof.
intros. elim s using VarSetProps.set_induction; intros.
rewrite (VarSetProps.empty_is_empty_1 H). rewrite shift_varset_empty. rewrite shift_down_empty. reflexivity.
assert (VarSet.Equal s' (VarSet.add x s0)). auto using add_equal.
rewrite H2.
rewrite shift_varset_add. assumption.
unfold shift2_step.
rewrite shift_down_add. assumption.
*)
Lemma shift_preserves_typing : forall Gi G G' G'' t A U,
prf Gi (G'++G) t A U ->
prf Gi (G'++G''++G) (l_shift (length G'') (length G') t) A (shift_varset (length G'') (length G') U).
intros Gi G G' G'' t A U prf_t.
set (Gx:=G'++G) in *. set (Gx_eq:=refl_equal Gx:Gx=G'++G).
generalize G' Gx_eq. clear Gx_eq.
induction prf_t; intros; simpl; subst G0.
(* ivar *)
rewrite H0. econstructor. assumption. apply shift_varset_empty.
(* lvar *)
rewrite H0.
destruct (le_lt_dec (length G'0) n) as [lenG_le_n | n_lt_lenG].
econstructor; eauto using lookup_suffix, shift_varset_singleton.
constructor; eauto using lookup_prefix, shift_varset_singleton2.
(* i_intro *)
rewrite H. constructor; eauto using shift_varset_empty.
(* tensor_intro *)
rewrite H0. econstructor; eauto using shift_varset_empty_inter, shift_varset_union.
(* tensor_elim *)
rewrite H0. econstructor.
apply IHprf_t1. reflexivity.
replace (A::B::G'0++G''++G) with ((A::B::G'0)++G''++G).
change (S (S (length G'0))) with (length (A::B::G'0)). apply IHprf_t2.
rewrite app_comm_cons. rewrite app_comm_cons. reflexivity.
rewrite app_comm_cons. rewrite app_comm_cons. reflexivity.
simpl. rewrite shift_down_varset. rewrite shift_down_varset. apply shift_varset_empty_inter. assumption.
simpl. rewrite shift_down_varset. rewrite shift_down_varset. apply shift_varset_union; assumption.
(* t_and_intro *)
rewrite H. econstructor.
apply IHprf_t1. reflexivity.
apply IHprf_t2. reflexivity.
apply shift_varset_union.
(* t_and_elim1 *)
econstructor; auto.
(* t_and_elim2 *)
econstructor; auto.
(* t_lolli_intro *)
rewrite H. econstructor.
replace (A::G'0++G''++G) with ((A::G'0)++G''++G).
change (S (length G'0)) with (length (A::G'0)). apply IHprf_t.
rewrite app_comm_cons. reflexivity.
rewrite app_comm_cons. reflexivity.
simpl. rewrite shift_down_varset. reflexivity.
(* t_lolli_elim *)
rewrite H0. econstructor; eauto using shift_varset_empty_inter, shift_varset_union.
(* t_bang_intro *)
econstructor; auto.
rewrite (VarSetProps.empty_is_empty_1 H). rewrite shift_varset_empty. apply VarSet.empty_1.
(* t_bang_elim *)
rewrite H0. econstructor; auto using shift_varset_empty_inter, shift_varset_union.
(* t_axiom *)
econstructor. auto.
(* t_let *)
rewrite H1. rewrite H in *. econstructor.
apply IHprf_t1. reflexivity.
replace (A::G'0++G''++G) with ((A::G'0)++G''++G).
change (S (length G'0)) with (length (A::G'0)). apply IHprf_t2. reflexivity.
reflexivity.
reflexivity.
change (length (A::G'0)) with (S (length G'0)). rewrite shift_down_varset. apply shift_varset_empty_inter. assumption.
change (length (A::G'0)) with (S (length G'0)). rewrite shift_varset_union. rewrite shift_down_varset. reflexivity.
Save.
(*
Lemma subst_preserve_typing :
prf Gi G t A U1 ->
prf Gi (G'++A::G) t' B U2 ->
prf Gi (
*)
Lemma prf_uses_ctx : forall Gi G t A U,
prf Gi G t A U -> forall n, VarSet.In n U -> n < length G.
Proof.
induction 1; intros; auto.
rewrite H0 in H1. destruct (VarSet.empty_1 H1).
rewrite H0 in H1. apply VarSet.singleton_1 in H1. unfold VarSet.E.eq in H1. subst n0. generalize G H. clear G H H0. induction n; intros.
simpl in H. destruct G. discriminate. simpl. auto with arith.
destruct G. discriminate. simpl in *. apply lt_n_S. auto.
rewrite H in H0. destruct (VarSet.empty_1 H0).
rewrite H2 in H3. destruct (VarSet.union_1 H3); auto.
rewrite H2 in H3. destruct (VarSet.union_1 H3); auto. repeat apply shift_down_In in H4. apply IHprf2 in H4. simpl in H4. auto using lt_S_n.
rewrite H1 in H2. destruct (VarSet.union_1 H2); auto.
rewrite H0 in H1. apply shift_down_In in H1. apply IHprf in H1. simpl in H1. auto using lt_S_n.
rewrite H2 in H3. destruct (VarSet.union_1 H3); auto.
rewrite H2 in H3. destruct (VarSet.union_1 H3); auto.
rewrite H3 in H4. rewrite H1 in H4. destruct (VarSet.union_1 H4). auto. apply shift_down_In in H5. apply IHprf2 in H5. auto using lt_S_n.
Qed.
Lemma proof_weakening : forall Gi G G' t A U,
prf Gi G t A U -> prf Gi (G++G') t A U.
Proof.
intros.
replace (G++G') with (G++G'++nil).
replace t with (l_shift (length G') (length G) t).
setoid_replace U with (shift_varset (length G') (length G) U).
apply shift_preserves_typing.
rewrite <- List.app_nil_end. assumption.
intros x.
split.
intros xinu.
apply prf_uses_ctx with (n:=x) in H. 2:assumption.
eapply In_shift_varset.
apply xinu.
destruct (le_lt_dec (length G)); omega.
intro xinsu.
destruct (shift_varset_image _ _ _ _ xinsu).
apply shift_varset_In in xinsu.
destruct (le_lt_dec (length G)). elimtype False. omega.
assumption.
apply shift_varset_In in xinsu.
apply prf_uses_ctx with (n:=(if le_lt_dec (length G) x then x - length G' else x)) in H. 2:assumption.
destruct (le_lt_dec (length G)). elimtype False. omega.
assumption.
induction H; simpl in *; auto; try (rewrite IHprf1; rewrite IHprf2; auto); try (rewrite IHprf; auto).
apply lookup_length3 in H. destruct (le_lt_dec (length G) n). elimtype False. omega. reflexivity.
rewrite <- app_nil_end. reflexivity.
Qed.
Definition sumbool_to_bool : forall (A B:Prop), {A}+{B} -> bool :=
fun A B x => if x then true else false.
Implicit Arguments sumbool_to_bool [A B].
Fixpoint proof_checker (Gi:context)
(G:context)
(t:prf_term)
{struct t}
: option (formula * VarSet.t)
:=
match t with
| t_lvar n =>
A <- nth_error G n;:
ret (A, VarSet.singleton n)
| t_ivar n =>
A <- nth_error Gi n;:
ret (A, VarSet.empty)
| t_i_intro =>
ret (f_i, VarSet.empty)
| t_tensor_intro t1 t2 =>
x1 <- proof_checker Gi G t1;:
x2 <- proof_checker Gi G t2;:
let (A, U1) := x1 in
let (B, U2) := x2 in
lift_bool (VarSet.is_empty (VarSet.inter U1 U2));;
ret (f_tensor A B, VarSet.union U1 U2)
| t_tensor_elim t1 t2 =>
x1 <- proof_checker Gi G t1;:
match x1 with
| (f_tensor A B, U1) =>
x2 <- proof_checker Gi (A::B::G) t2;:
let (C, U2) := x2 in
let U2' := shift_down (shift_down U2) in
lift_bool (VarSet.is_empty (VarSet.inter U1 U2'));;
ret (C, VarSet.union U1 U2')
| _ =>
fail
end
| t_and_intro t1 t2 =>
x1 <- proof_checker Gi G t1;:
x2 <- proof_checker Gi G t2;:
let (A, U1) := x1 in
let (B, U2) := x2 in
ret (f_and A B, VarSet.union U1 U2)
| t_and_elim1 t =>
x <- proof_checker Gi G t;:
match x with
| (f_and A B, U) =>
ret (A, U)
| _ => fail
end
| t_and_elim2 t =>
x <- proof_checker Gi G t;:
match x with
| (f_and A B, U) =>
ret (B, U)
| _ => fail
end
| t_lolli_intro A t =>
x <- proof_checker Gi (A::G) t;:
let (B,U) := x in
ret (f_lolli A B, shift_down U)
| t_lolli_elim t1 t2 =>
x1 <- proof_checker Gi G t1;:
match x1 with
| (f_lolli A B, U1) =>
x2 <- proof_checker Gi G t2;:
let (A', U2) := x2 in
lift_bool (sumbool_to_bool (formula_eq_dec A A'));;
lift_bool (VarSet.is_empty (VarSet.inter U1 U2));;
ret (B, VarSet.union U1 U2)
| _ =>
fail
end
| t_bang_intro t =>
x <- proof_checker Gi G t;:
let (A,U) := x in
lift_bool (VarSet.is_empty U);;
ret (f_bang A, U)
| t_bang_elim t1 t2 =>
x1 <- proof_checker Gi G t1;:
match x1 with
| (f_bang A, U1) =>
x2 <- proof_checker (A::Gi) G t2;:
let (C, U2) := x2 in
lift_bool (VarSet.is_empty (VarSet.inter U1 U2));;
ret (C, VarSet.union U1 U2)
| _ =>
fail
end
| t_axiom ax t =>
x <- proof_checker Gi G t;:
let (A,U) := x in
lift_bool (sumbool_to_bool (formula_eq_dec A (axiom_domain ax)));;
ret (axiom_codomain ax, U)
| t_let t1 t2 =>
x1 <- proof_checker Gi G t1;:
let (A, U1) := x1 in
x2 <- proof_checker Gi (A::G) t2;:
let (B, Ut2) := x2 in
let U2 := shift_down Ut2 in
lift_bool (VarSet.is_empty (VarSet.inter U1 U2));;
ret (B, VarSet.union U1 U2)
end.
Hint Resolve VarSet.is_empty_2.
Lemma proof_checker_sound : forall Gi G t A U,
proof_checker Gi G t = Some (A, U) ->
prf Gi G t A U.
intros Gi G t A U. generalize Gi G A U. clear Gi G A U.
induction t; intros.
(* t_lvar *)
simpl in H.
destruct (option_dec (nth_error G n)) as [[A' A'_res] | A'_res]; rewrite A'_res in H; try discriminate.
inversion H. subst. apply prf_lvar. assumption. reflexivity.
(* t_ivar *)
simpl in H.
destruct (option_dec (nth_error Gi n)) as [[A' A'_res] | A'_res]; rewrite A'_res in H; try discriminate.
inversion H. subst. apply prf_ivar. assumption. reflexivity.
(* t_i_intro *)
inversion H. subst. apply prf_i_intro. reflexivity.
(* t_tensor_intro *)
simpl in H.
destruct (option_dec (proof_checker Gi G t1)) as [[[A' U1] t1_check] | t1_check]; rewrite t1_check in H; try discriminate.
destruct (option_dec (proof_checker Gi G t2)) as [[[B U2] t2_check] | t2_check]; rewrite t2_check in H; try discriminate.
simpl in H.
destruct (bool_dec (VarSet.is_empty (VarSet.inter U1 U2))) as [inter_check | inter_check]; rewrite inter_check in H; try discriminate.
inversion H. subst. econstructor; intuition eauto. reflexivity.
(* t_tensor_elim *)
simpl in H.
destruct (option_dec (proof_checker Gi G t1)) as [[[A' U1] t1_check] | t1_check]; rewrite t1_check in H; try discriminate.
simpl in H.
destruct A'; try discriminate.
destruct (option_dec (proof_checker Gi (A'1::A'2::G) t2)) as [[[B U2] t2_check] | t2_check]; rewrite t2_check in H; try discriminate.
simpl in H.
destruct (bool_dec (VarSet.is_empty (VarSet.inter U1 (shift_down (shift_down U2))))) as [inter_check | inter_check]; rewrite inter_check in H; try discriminate.
inversion H. subst. econstructor; intuition eauto. reflexivity.
(* t_and_intro *)
simpl in H.
destruct (option_dec (proof_checker Gi G t1)) as [[[A' U1] t1_check] | t1_check]; rewrite t1_check in H; try discriminate.
destruct (option_dec (proof_checker Gi G t2)) as [[[B U2] t2_check] | t2_check]; rewrite t2_check in H; try discriminate.
inversion H. subst. econstructor; intuition eauto. reflexivity.
(* t_and_elim1 *)
simpl in H.
destruct (option_dec (proof_checker Gi G t)) as [[[A' U1] t_check] | t_check]; rewrite t_check in H; try discriminate.
simpl in H. destruct A'; try discriminate.
inversion H. subst. econstructor; eauto.
(* t_and_elim2 *)
simpl in H.
destruct (option_dec (proof_checker Gi G t)) as [[[A' U1] t_check] | t_check]; rewrite t_check in H; try discriminate.
simpl in H. destruct A'; try discriminate.
inversion H. subst. econstructor; eauto.
(* t_lolli_intro *)
simpl in H.
destruct (option_dec (proof_checker Gi (f::G) t)) as [[[B U1] t_check] | t_check]; rewrite t_check in H; try discriminate.
inversion H. subst. econstructor; eauto. reflexivity.
(* t_lolli_elim *)
simpl in H.
destruct (option_dec (proof_checker Gi G t1)) as [[[A' U1] t1_check] | t1_check]; rewrite t1_check in H; try discriminate.
simpl in H. destruct A'; try discriminate.
destruct (option_dec (proof_checker Gi G t2)) as [[[A' U2] t2_check] | t2_check]; rewrite t2_check in H; try discriminate.
simpl in H.
destruct (formula_eq_dec A'1 A') as [fs_eq | fs_neq]; try discriminate. simpl in H.
destruct (bool_dec (VarSet.is_empty (VarSet.inter U1 U2))) as [inter_check | inter_check]; rewrite inter_check in H; try discriminate.
inversion H. subst. econstructor; eauto. reflexivity.
(* t_bang_intro *)
simpl in H.
destruct (option_dec (proof_checker Gi G t)) as [[[A' U1] t_check] | t_check]; rewrite t_check in H; try discriminate.
simpl in H.
destruct (bool_dec (VarSet.is_empty U1)) as [empty_check | empty_check]; rewrite empty_check in H; try discriminate.
inversion H. subst. econstructor; eauto.
(* t_bang_elim *)
simpl in H.
destruct (option_dec (proof_checker Gi G t1)) as [[[A' U1] t1_check] | t1_check]; rewrite t1_check in H; try discriminate.
simpl in H; destruct A'; try discriminate.
destruct (option_dec (proof_checker (A'::Gi) G t2)) as [[[B U2] t2_check] | t2_check]; rewrite t2_check in H; try discriminate.
simpl in H.
destruct (bool_dec (VarSet.is_empty (VarSet.inter U1 U2))) as [inter_check | inter_check]; rewrite inter_check in H; try discriminate.
inversion H. subst. econstructor; eauto. reflexivity.
(* t_axiom *)
simpl in H.
destruct (option_dec (proof_checker Gi G t)) as [[[A' U1] t_check] | t_check]; rewrite t_check in H; try discriminate.
simpl in H.
destruct (formula_eq_dec A' (axiom_domain a)) as [is_equal | not_equal]; try discriminate.
inversion H. clear H. subst. econstructor; eauto.
(* t_let *)
simpl in H.
destruct (option_dec (proof_checker Gi G t1)) as [[[A' U1] t1_check] | t1_check]; rewrite t1_check in H; try discriminate.
simpl in H.
destruct (option_dec (proof_checker Gi (A'::G) t2)) as [[[B Ut2] t2_check] | t2_check]; rewrite t2_check in H; try discriminate.
simpl in H.
destruct (bool_dec (VarSet.is_empty (VarSet.inter U1 (shift_down Ut2)))) as [inter_check | inter_check]; rewrite inter_check in H; try discriminate.
inversion H. subst. econstructor; eauto. reflexivity. reflexivity.
Save.
Definition proof_check (Gi G:context) (t:prf_term)
: { B : formula | exists U, prf Gi G t B U }+{True}
:= match proof_checker Gi G t as l return proof_checker Gi G t = l -> { B : formula | exists U, prf Gi G t B U }+{True} with
| None => fun e : _ =>
inright _ I
| Some (B, U) => fun e : proof_checker Gi G t = Some (B, U) =>
(* coq suddenly seems to require more details, not sure why...
inleft _ (exist _ B (ex_intro _ U (proof_checker_sound Gi G t B U e)))
*)
inleft True (exist (fun B => exists U, prf Gi G t B U) B (ex_intro (fun U => prf Gi G t B U) U (proof_checker_sound Gi G t B U e)))
end (refl_equal (proof_checker Gi G t)).
Definition implies : formula -> formula -> Prop :=
fun A B => exists t, exists U, prf nil (A::nil) t B U.
Lemma implies_refl : forall A, implies A A.
intro A.
exists (t_lvar 0).
exists (VarSet.singleton 0%nat).
apply proof_checker_sound. reflexivity.
Save.
Lemma implies_trans : forall A B C, implies A B -> implies B C -> implies A C.
intros A B C [tAB [UAB pAB]] [tBC [UBC pBC]].
exists (t_lolli_elim (t_lolli_intro B (l_shift (length (A::nil)) (length (B::nil)) tBC)) tAB).
eexists.
(*assert (prf nil (B::A::nil) (t_lolli_intro B (l_shift (length (A::nil)) (length (B::nil)) tBC)) (f_lolli B C) *)
eapply prf_lolli_elim.
eapply prf_lolli_intro.
change (B::A::nil) with ((B::nil)++(A::nil)++nil).
apply shift_preserves_typing.
eassumption.
reflexivity.
eassumption.
intros x inboth.
pose (inbc := VarSet.inter_1 inboth).
pose (inab := VarSet.inter_2 inboth).
apply prf_uses_ctx with (n:=x) in pAB; auto.
apply shift_down_In in inbc. pose (shift := shift_varset_image _ _ _ _ inbc). clearbody shift. apply shift_varset_In in inbc. simpl in inbc. rewrite <- minus_n_O in inbc.
apply prf_uses_ctx with (n:=x) in pBC; auto.
simpl in *. omega.
reflexivity.
Qed.
Lemma lookup_neq : forall (A:Set) (G G'':list A) a b n, n<>(length G'') -> nth_error (G'' ++ a :: G) n = nth_error (G'' ++ b :: G) n.
induction G''; intros; simpl in *.
destruct n. destruct H; reflexivity. simpl. reflexivity.
destruct n; simpl. reflexivity. auto.
Save.
Set Implicit Arguments.
Lemma subst_and_1 : forall Gi G G' A C t B U,
prf Gi (G++A::G') t B U ->
exists t', prf Gi (G++(f_and A C)::G') t' B U.
Proof.
intros. set (G0:=(G++A::G')) in *. assert (G0 = (G++A::G')) by reflexivity. generalize G H0. clear H0. induction H; intros.
eexists; eauto using prf_ivar.
compare n (length G1); intro; eexists.
eapply prf_and_elim1. rewrite e in H. rewrite H1 in H. rewrite lookup_length in H. injection H as H'. subst A0. apply prf_lvar.
apply lookup_length.
rewrite <- e. assumption.
apply prf_lvar. rewrite <- H. rewrite H1. apply lookup_neq. assumption. assumption.
eexists. eauto using prf_i_intro.
destruct (IHprf1 G1 H3); destruct (IHprf2 G1 H3); eexists; eapply prf_tensor_intro; eauto.
destruct (IHprf1 G1 H3); destruct (IHprf2 (A0::B::G1)). rewrite H3. simpl. reflexivity. eauto using prf_tensor_elim.
destruct (IHprf1 G1 H2); destruct (IHprf2 G1 H2); eexists; eapply prf_and_intro; eauto.
destruct (IHprf G1 H0); eauto using prf_and_elim1.
destruct (IHprf G1 H0); eauto using prf_and_elim2.
destruct (IHprf (A0::G1)). rewrite H1. simpl. reflexivity. eauto using prf_lolli_intro.
destruct (IHprf1 G1 H3); destruct (IHprf2 G1 H3); eexists; eauto using prf_lolli_elim.
destruct (IHprf G1 H1); eauto using prf_bang_intro.
destruct (IHprf1 G1 H3); destruct (IHprf2 G1 H3); eexists; eauto using prf_bang_elim.
destruct (IHprf G1 H0); eauto using prf_axiom.
destruct (IHprf1 G1 H4); destruct (IHprf2 (A0::G1)). rewrite H4. simpl. reflexivity. eauto using prf_let.
Qed.
Lemma subst_and_2 : forall Gi G G' A C t B U,
prf Gi (G++A::G') t B U ->
exists t', prf Gi (G++(f_and C A)::G') t' B U.
Proof.
intros. set (G0:=(G++A::G')) in *. assert (G0 = (G++A::G')) by reflexivity. generalize G H0. clear H0. induction H; intros.
eexists; eauto using prf_ivar.
compare n (length G1); intro; eexists.
eapply prf_and_elim2. rewrite e in H. rewrite H1 in H. rewrite lookup_length in H. injection H as H'. subst A0. apply prf_lvar.
apply lookup_length.
rewrite <- e. assumption.
apply prf_lvar. rewrite <- H. rewrite H1. apply lookup_neq. assumption. assumption.
eexists. eauto using prf_i_intro.
destruct (IHprf1 G1 H3); destruct (IHprf2 G1 H3); eexists; eapply prf_tensor_intro; eauto.
destruct (IHprf1 G1 H3); destruct (IHprf2 (A0::B::G1)). rewrite H3. simpl. reflexivity. eauto using prf_tensor_elim.
destruct (IHprf1 G1 H2); destruct (IHprf2 G1 H2); eexists; eapply prf_and_intro; eauto.
destruct (IHprf G1 H0); eauto using prf_and_elim1.
destruct (IHprf G1 H0); eauto using prf_and_elim2.
destruct (IHprf (A0::G1)). rewrite H1. simpl. reflexivity. eauto using prf_lolli_intro.
destruct (IHprf1 G1 H3); destruct (IHprf2 G1 H3); eexists; eauto using prf_lolli_elim.
destruct (IHprf G1 H1); eauto using prf_bang_intro.
destruct (IHprf1 G1 H3); destruct (IHprf2 G1 H3); eexists; eauto using prf_bang_elim.
destruct (IHprf G1 H0); eauto using prf_axiom.
destruct (IHprf1 G1 H4); destruct (IHprf2 (A0::G1)). rewrite H4. simpl. reflexivity. eauto using prf_let.
Qed.
Unset Implicit Arguments.
Lemma implies_subformulae : forall f1 f2 f1' f2' fo,
implies f1 f1' -> implies f2 f2' -> fo = f_tensor \/ fo = f_and ->
implies (fo f1 f2) (fo f1' f2').
Proof.
intros until fo. intros [t1 [U1 p1]] [t2 [U2 p2]] [fo_eq|fo_eq]; subst fo.
unfold implies. do 2 eexists.
eapply prf_tensor_elim.
apply prf_lvar with (n:=0).
simpl. reflexivity.
reflexivity.
eapply prf_tensor_intro.
change (f1 :: f2 :: f_tensor f1 f2 :: nil) with ((f1::nil)++(f2::f_tensor f1 f2::nil)++nil). apply shift_preserves_typing. apply p1.
change (f1 :: f2 :: f_tensor f1 f2 :: nil) with (nil++(f1::nil)++(f2::f_tensor f1 f2::nil)). apply shift_preserves_typing. change (nil ++ f2 :: f_tensor f1 f2 :: nil) with ((f2::nil)++(f_tensor f1 f2::nil)++nil). apply shift_preserves_typing. apply p2.
simpl. intros x in_inter.
pose (inu1 := VarSet.inter_1 in_inter). pose (inu2 := VarSet.inter_2 in_inter).
pose (x1 := shift_varset_image _ _ _ _ inu1). clearbody x1. pose (x2 := shift_varset_image _ _ _ _ inu2). clearbody x2. apply shift_varset_In in inu2. pose (x2' := shift_varset_image _ _ _ _ inu2). clearbody x2'. apply shift_varset_In in inu2.
match type of inu2 with VarSet.In ?x2 U2 => set (n2:=x2) end. apply prf_uses_ctx with (n:=n2) in p2; auto.
destruct (le_lt_dec 0 x); destruct (le_lt_dec 1 (x-1)); unfold n2 in *; simpl in *; omega.
reflexivity.
simpl. intros x in_inter.
pose (inu1 := VarSet.inter_1 in_inter). pose (inu2 := VarSet.inter_2 in_inter).
rewrite <- (VarSet.singleton_1 inu1) in *. do 2 apply shift_down_In in inu2.
destruct (VarSet.union_1 inu2). apply shift_varset_image in H. omega.
apply shift_varset_In in H. simpl in H. apply shift_varset_image in H. omega.
reflexivity.
unfold implies.
change (f1::nil) with (nil++(f1::nil)++nil) in p1. destruct (subst_and_1 _ _ _ f2 p1). simpl in H.
change (f2::nil) with (nil++(f2::nil)++nil) in p2. destruct (subst_and_2 _ _ _ f1 p2). simpl in H0.
do 2 eexists. eapply prf_and_intro.
apply H.
apply H0.
reflexivity.
Qed.
(*
Lemma implies_lolli : forall f1 f2 f1' f2',
implies f1 f1' -> implies f2 f2' ->
implies (f_lolli f1' f2) (f_lolli f1 f2').
Proof.
intros f1 f2 f1' f2' [t1 [U1 p1]] [t2 [U2 p2]].
unfold implies. do 2 eexists. eapply prf_lolli_intro.
eapply prf_lolli_elim.
*)
Definition proof_check_single (A B:formula) (t:prf_term)
: { implies A B }+{True}
:= match proof_check nil (A::nil) t with
| inleft (exist _ B' H) =>
match formula_eq_dec B' B with
| left B'_eq_B =>
left _ (ex_intro _ t (eq_ind _ _ H _ B'_eq_B))
| right _ =>
right _ I
end
| inright _ => right _ I
end.
Definition r_may := fun c f =>
match R_new c with
| None => f_i
| Some r => f r
end.
Definition resexpr_to_formula : res_expr B.Classname.t -> formula :=
let r_to_f_step (f:formula) (r:res_expr B.Classname.t) :=
List.fold_left (fun f expr =>
f_tensor f (match expr with (true,c) => r_may c (fun r => f_bang (f_atom r)) | (false,c) => r_may c (fun r => f_atom r) end))
r f
in r_to_f_step f_i.
End MkILLSyntax.
Module MkILLSemantics
(B : BASICS)
(BASESEM : ILL_BASE_SEMANTICS B)
(SYN : ILL_SYNTAX B BASESEM.SYN)
: ILL_SEMANTICS B BASESEM SYN.
Import SYN.
Import BASESEM.SYN.
(*Lemma VarSet_Equal_refl : forall s, VarSet.Equal s s.
unfold VarSet.Equal. tauto.
Save.
Lemma VarSet_Equal_symm : forall s1 s2, VarSet.Equal s1 s2 -> VarSet.Equal s2 s1.
unfold VarSet.Equal. firstorder.
Save.
Lemma VarSet_Equal_trans : forall s1 s2 s3, VarSet.Equal s1 s2 -> VarSet.Equal s2 s3 -> VarSet.Equal s1 s3.
unfold VarSet.Equal. firstorder.
Save.
Add Relation VarSet.t VarSet.Equal
reflexivity proved by VarSet_Equal_refl
symmetry proved by VarSet_Equal_symm
transitivity proved by VarSet_Equal_trans
as VarSet_Equal.
Add Morphism VarSet.Empty with signature VarSet.Equal ==> iff as VarSet_Empty_mor.
unfold VarSet.Equal. unfold VarSet.Empty. firstorder.
Save.
Add Morphism VarSet.In with signature eq ==> VarSet.Equal ==> iff as VarSet_In_mor.
unfold VarSet.Equal. firstorder.
Save.*)
Fixpoint context_to_formula (G:context) (n:nat) (U:VarSet.t)
{struct G}
: formula :=
match G with
| nil => f_i
| cons f rest => if VarSet.mem n U then f_tensor f (context_to_formula rest (S n) U)
else context_to_formula rest (S n) U
end.
Add Morphism context_to_formula with signature (@eq context) ==> (@eq nat) ==> VarSet.Equal ==> (@eq formula) as ctf_mor.
induction y; intros x0 x1 x2 H.
reflexivity.
simpl. unfold VarSet.Equal in H. destruct (bool_dec (VarSet.mem x0 x1)).
rewrite H0. rewrite (@VarSet.mem_1 x2 x0).
rewrite (IHy (S x0) x1 x2 H); reflexivity.
rewrite <- H. apply VarSet.mem_2. assumption.
rewrite H0. replace (VarSet.mem x0 x2) with false. eauto.
destruct (bool_dec (VarSet.mem x0 x2)).
rewrite (@VarSet.mem_1 x1 x0) in H0. discriminate. rewrite H. apply VarSet.mem_2. assumption.
congruence.
Save.
Import BASESEM.
Import RA.
Fixpoint icontext_to_formula (G:context) : formula :=
match G with
| nil => f_i
| cons f rest => f_tensor f (icontext_to_formula rest)
end.
Lemma right_weaken : forall r1 r2 r,
r1 :*: r2 <: r ->
r1 <: r.
intros.
rewrite <- (r_combine_e r1).
eapply leq_trans.
apply combine_order. apply leq_refl. apply eq_refl. apply (e_bottom r2).
assumption.
Save.
Lemma left_weaken : forall r1 r2 r,
r1 :*: r2 <: r ->
r2 <: r.
intros.
rewrite <- (e_combine_r r2).
eapply leq_trans.
apply combine_order. apply e_bottom. apply leq_refl. reflexivity.
apply H.
Save.
(*
FIXME: this doesn't work because setoid doesn't know that ILL.RA.res is a setoid
but it turns out we didn't need it anyway
Add Morphism sat : sat_morphism.
intros r1 r2 r1_eq_r2 A.
generalize r1 r2 r1_eq_r2. clear r1 r2 r1_eq_r2.
induction A; intros.
(* f_i *)
intuition.
(* f_atom *)
simpl. rewrite r1_eq_r2. intuition.
(* f_tensor *)
simpl. split; intros.
destruct H as [r3 [r4 [r3r4_r1 [sat_r3 sat_r4]]]].
exists r3. exists r4. rewrite <- r1_eq_r2. intuition.
destruct H as [r3 [r4 [r3r4_r1 [sat_r3 sat_r4]]]].
exists r3. exists r4. rewrite r1_eq_r2. intuition.
(* f_and *)
simpl. rewrite (IHA1 r1 r2 r1_eq_r2). rewrite (IHA2 r1 r2 r1_eq_r2). intuition.
(* f_lolli *)
simpl. split; intros.
rewrite (IHA2 (r2 :*: r') (r1 :*: r')).
rewrite <- r1_eq_r2. reflexivity.
auto.
rewrite (IHA2 (r1 :*: r') (r2 :*: r')).
rewrite <- r1_eq_r2. reflexivity.
auto.
(* f_bang *)
simpl. split; intros.
destruct H as [r3 [r3_r2 sat_r2]].
exists r3. rewrite <- r1_eq_r2. intuition.
destruct H as [r3 [r3_r2 sat_r2]].
exists r3. rewrite r1_eq_r2. intuition.
Save.
*)
Lemma sat_leq : forall r1 r2 A,
sat r1 A -> r1 <: r2 -> sat r2 A.
intros r1 r2 A. generalize r1 r2. clear r1 r2.
induction A; intros; simpl in *.
(* f_i *)
trivial.
(* f_atom *)
eapply leq_trans; eauto.
(* f_tensor *)
destruct H as [r3 [r4 [r3r4_r1 [r2_A1 r3_A2]]]].
exists r3. exists r4. intuition. eapply leq_trans; eauto.
(* f_and *)
intuition eauto.
(* f_lolli *)
intros. apply (IHA2 (r1 :*: r') (r2 :*: r')).
apply H. apply H1.
apply combine_order. apply H0. apply leq_refl. reflexivity.
(* f_bang *)
destruct H as [r' [r'_r1 sat_r']].
exists r'. intuition. eapply leq_trans; eauto.
Save.
Lemma nat_dec : forall (n:nat), n=0%nat\/(exists m, n = S m).
intros. destruct n.
left. reflexivity.
right. exists n. reflexivity.
Save.
Lemma not_in_mem_false : forall n s,
~ (VarSet.In n s) -> VarSet.mem n s = false.
intros.
compare (VarSet.mem n s) true; intros.
elimtype False. apply H. apply VarSet.mem_2. assumption.
rewrite (not_true_is_false _ n0). reflexivity.
Save.
Implicit Arguments not_in_mem_false [n s].
Lemma not_mem : forall n m,
n <> m ->
VarSet.mem m (VarSet.singleton n) = false.
intros.
apply not_in_mem_false.
unfold not. intros. apply H. apply VarSet.singleton_1. assumption.
Save.
Lemma sat_singleton : forall r G m n A,
sat r (context_to_formula G m (VarSet.singleton (n+m))) ->
nth_error G n = Some A ->
sat r A.
intros. generalize m n H H0. clear m n H H0.
induction G; intros.
destruct n; discriminate.
destruct (nat_dec n) as [n_is_0 | [n' n_is_Sn']].
(* this is the correct one *)
subst. inversion H0. subst.
simpl in H. rewrite VarSet.mem_1 in H.
simpl in H. destruct H as [r1 [r2 [r1r2_r [sat_r1 _]]]]. eapply sat_leq. apply sat_r1. eapply right_weaken. apply r1r2_r.
apply VarSet.singleton_2. change (VarSet.E.eq m m) with (m = m). apply refl_equal. (* BUG *)
(* step on *)
subst. simpl in H0. simpl in H. rewrite not_mem in H.
eapply IHG.
replace (S (n' + m)) with (n' + (S m)) in H.
apply H.
omega.
assumption.
omega.
Save.
Lemma sep_mem : forall m U1 U2,
VarSet.In m U1 ->
VarSet.Empty (VarSet.inter U1 U2) ->
VarSet.mem m U2 = false.
intros. destruct (SYN.VarSetProps.In_dec m U2) as [in_2 | not_in_2].
(* contradiction *)
assert (VarSet.In m (VarSet.inter U1 U2)). apply VarSet.inter_3; assumption.
elimtype False. apply (H0 _ H1).
(* not_there *)
apply not_in_mem_false. assumption.
Save.
Implicit Arguments sep_mem [m U1 U2].
Lemma sep_mem_s : forall m U1 U2,
VarSet.In m U2 ->
VarSet.Empty (VarSet.inter U1 U2) ->
VarSet.mem m U1 = false.
intros.
apply (sep_mem (U1:=U2) (U2:=U1) H).
rewrite SYN.VarSetProps.inter_sym.
assumption.
Save.
Implicit Arguments sep_mem_s [m U1 U2].
Lemma not_in_union : forall x U1 U2,
~(VarSet.In x (VarSet.union U1 U2)) ->
~(VarSet.In x U1) /\ ~(VarSet.In x U2).
intros.
destruct (SYN.VarSetProps.In_dec x U1) as [in_1 | not_in_1].
elimtype False. apply H. apply VarSet.union_2. assumption.
destruct (SYN.VarSetProps.In_dec x U2) as [in_2 | not_in_2].
elimtype False. apply H. apply VarSet.union_3. assumption.
auto.
Save.
Implicit Arguments not_in_union [x U1 U2].
Lemma sat_split : forall r G m U1 U2,
VarSet.Empty (VarSet.inter U1 U2) ->
sat r (context_to_formula G m (VarSet.union U1 U2)) ->
exists r1, exists r2,
r1 :*: r2 <: r /\ sat r1 (context_to_formula G m U1) /\ sat r2 (context_to_formula G m U2).
intros r G m U1 U2 sep. generalize r m. clear r m. induction G; intros.
(* base case *)
simpl. exists e. exists e. intuition. rewrite e_combine_r. apply e_bottom.
(* step case *)
simpl in *.
destruct (SYN.VarSetProps.In_dec m (VarSet.union U1 U2)) as [is_in | isnt_in].
(* we included this position originally *)
rewrite (VarSet.mem_1 is_in) in H. simpl in H. destruct H as [r1 [r2 [r1r2_r [sat_r1_a sat_r2_rest]]]].
destruct (VarSet.union_1 is_in) as [in_1 | in_2].
(* it was in U1 *)
rewrite (VarSet.mem_1 in_1).
rewrite (sep_mem in_1 sep).
destruct (IHG _ _ sat_r2_rest) as [r1' [r2' [r1'r2'_r2 [r1'_U1 r2'_U2]]]].
exists (r1 :*: r1'). exists r2'. intuition.
rewrite <- combine_assoc. eapply leq_trans.
apply combine_order.
apply leq_refl. reflexivity.
apply r1'r2'_r2.
apply r1r2_r.
exists r1. exists r1'. intuition.
(* it was in U2 *)
rewrite (VarSet.mem_1 in_2).
rewrite (sep_mem_s in_2 sep).
destruct (IHG _ _ sat_r2_rest) as [r1' [r2' [r1'r2'_r2 [r1'_U1 r2'_U2]]]].
exists r1'. exists (r1 :*: r2'). intuition.
rewrite combine_assoc. rewrite (combine_symm r1' r1). rewrite <- combine_assoc.
eapply leq_trans.
apply combine_order.
apply leq_refl. reflexivity.
apply r1'r2'_r2.
apply r1r2_r.
exists r1. exists r2'. intuition.
(* we didn't originally include this position *)
destruct (not_in_union isnt_in) as [not_in_1 not_in_2].
rewrite (not_in_mem_false not_in_1).
rewrite (not_in_mem_false not_in_2).
rewrite (not_in_mem_false isnt_in) in H.
auto.
Save.
Implicit Arguments sat_split [r G m U1 U2].
Lemma shift_step_union : forall S S2 a,
VarSet.Equal (shift_step a (VarSet.union S2 S)) (VarSet.union (shift_step a S2) S).
intros. destruct a; simpl; auto with set.
Save.
Lemma shift_step_morphism : forall a S1 S2,
VarSet.Equal S1 S2 ->
VarSet.Equal (shift_step a S1) (shift_step a S2).
intros. destruct a.
assumption.
simpl. setoid_replace S1 with S2.
reflexivity.
assumption.
Save.
Definition fold_left_shift := fold_left (fun a b => shift_step b a).
Add Morphism fold_left_shift with signature Logic.eq ==> VarSet.Equal ==> VarSet.Equal as fold_left_morphism.
intro l. induction l; intros; simpl.
assumption.
apply IHl. apply shift_step_morphism. assumption.
Save.
Lemma fold_shift_step_union : forall l S S2,
VarSet.Equal (fold_left (fun a b => shift_step b a) l (VarSet.union S2 S))
(VarSet.union (fold_left (fun a b => shift_step b a) l S2) S).
intros l. induction l; intros; simpl.
unfold VarSet.Equal. split; intro; assumption.
setoid_rewrite <- IHl. apply fold_left_morphism. auto. apply shift_step_union.
Save.
Lemma fold_shift_step_only_add : forall m l S,
VarSet.In m (fold_left (fun a b => shift_step b a) l S) ->
~(VarSet.In m S) ->
VarSet.In m (fold_left (fun a b => shift_step b a) l VarSet.empty).
intros m l S is_in m_nin_S.
fold fold_left_shift in is_in.
setoid_replace S with (VarSet.union VarSet.empty S) in is_in; [|auto with set].
rewrite fold_shift_step_union in is_in.
destruct (VarSet.union_1 is_in).
assumption.
contradiction.
Save.
Lemma shift_prop : forall m U,
VarSet.In m (shift_down U) ->
VarSet.In (S m) U.
intros. unfold shift_down in H.
rewrite VarSet.fold_1 in H.
apply VarSet.elements_2.
induction (VarSet.elements U).
simpl in H. elimtype False. apply (VarSet.empty_1 H).
simpl in H. destruct (nat_dec a) as [is_0 | [x a_is_Sx]].
subst. auto.
subst. destruct (Peano_dec.eq_nat_dec x m).
subst. apply InA_cons_hd. reflexivity.
apply InA_cons_tl. apply IHl. eapply fold_shift_step_only_add.
apply H.
simpl. rewrite <- SYN.VarSetProps.singleton_equal_add. unfold not. intros. apply n. apply VarSet.singleton_1. assumption.
Save.
Lemma shift_prop_2 : forall m U,
VarSet.In (S m) U ->
VarSet.In m (shift_down U).
intros. unfold shift_down.
rewrite VarSet.fold_1.
set (H':=VarSet.elements_1 H). generalize H'. clear H H'. intro H.
induction (VarSet.elements U).
inversion H.
inversion H; subst.
simpl. destruct (nat_dec a) as [is_0 | [x a_is_Sx]]; subst.
discriminate.
simpl. setoid_replace (fold_left (fun a b => shift_step b a) l (VarSet.add x VarSet.empty))
with (fold_left (fun a b => shift_step b a) l (VarSet.union VarSet.empty (VarSet.singleton x))).
fold fold_left_shift.
rewrite fold_shift_step_union.
apply VarSet.union_3. apply VarSet.singleton_2. apply eq_add_S. symmetry. apply H1.
apply fold_left_morphism. reflexivity. rewrite <- SYN.VarSetProps.singleton_equal_add. rewrite SYN.VarSetProps.empty_union_1; auto with set.
simpl. destruct (nat_dec a) as [is_0 | [x a_is_Sx]]; subst.
simpl. apply IHl. assumption.
simpl. setoid_replace (fold_left (fun a b => shift_step b a) l (VarSet.add x VarSet.empty))
with (fold_left (fun a b => shift_step b a) l (VarSet.union VarSet.empty (VarSet.singleton x))).
fold fold_left_shift.
rewrite fold_shift_step_union.
apply VarSet.union_2. apply IHl. apply H1.
apply fold_left_morphism. reflexivity. rewrite <- SYN.VarSetProps.singleton_equal_add. rewrite SYN.VarSetProps.empty_union_1; auto with set.
Save.
Lemma sat_shift_aux : forall r m G U,
sat r (context_to_formula G m (shift_down U)) ->
sat r (context_to_formula G (S m) U).
intros. generalize r m H. clear r m H. induction G; intros.
simpl in *. trivial.
simpl in *. destruct (SYN.VarSetProps.In_dec m (shift_down U)).
(* it was in the shifted down one *)
rewrite (VarSet.mem_1 i) in H. rewrite (VarSet.mem_1 (shift_prop _ _ i)).
simpl in H. destruct H as [r1 [r2 [r1r2_r [sat_r1 sat_r2]]]].
exists r1. exists r2. intuition.
(* it wasn't in the shifted down one *)
rewrite (not_in_mem_false n) in H.
destruct (SYN.VarSetProps.In_dec (S m) U) as [is_in | isnt_in].
elimtype False. apply n. apply shift_prop_2. apply is_in.
rewrite (not_in_mem_false isnt_in). auto.
Save.
Lemma sat_shift : forall r1 r2 G U A,
sat r2 (context_to_formula G 0 (shift_down U)) ->
sat r1 A ->
sat (r1 :*: r2) (context_to_formula (A::G) 0 U).
intros. simpl. destruct (SYN.VarSetProps.In_dec 0%nat U) as [has_0 | no_0].
(* 0 was in U *)
rewrite (VarSet.mem_1 has_0). exists r1. exists r2. intuition.
apply sat_shift_aux. assumption.
(* 0 wasn't in U *)
rewrite (not_in_mem_false no_0). eapply sat_leq.
apply sat_shift_aux. apply H.
rewrite <- (e_combine_r r2). apply combine_order.
apply e_bottom.
rewrite e_combine_r. apply leq_refl. reflexivity.
Save.
Lemma notin_subset : forall m S1 S2,
~(VarSet.In m S2) ->
VarSet.Subset S1 S2 ->
~(VarSet.In m S1).
intros. destruct (SYN.VarSetProps.In_dec m S1).
elimtype False. auto.
apply n.
Save.
Implicit Arguments notin_subset [m S1 S2].
Lemma sat_subset : forall r m G U1 U2,
VarSet.Subset U2 U1 ->
sat r (context_to_formula G m U1) ->
sat r (context_to_formula G m U2).
intros r m G U1 U2 U2_ss_U1.
generalize r m. clear r m. induction G; intros.
(* base case *)
trivial.
(* step case *)
simpl in *. destruct (SYN.VarSetProps.In_dec m U1) as [in_U1 | notin_U1].
(* is in U1 *)
rewrite (VarSet.mem_1 in_U1) in H. simpl in H.
destruct H as [r1 [r2 [r1r2_r [sat_r1 sat_r2]]]].
destruct (SYN.VarSetProps.In_dec m U2) as [in_U2 | notin_U2].
(* is in U2 *)
rewrite (VarSet.mem_1 in_U2). exists r1. exists r2. intuition.
(* not in U2 *)
rewrite (not_in_mem_false notin_U2). eapply sat_leq.
apply IHG. apply sat_r2.
rewrite <- (e_combine_r r2).
eapply leq_trans.
apply combine_order. apply e_bottom. apply leq_refl. reflexivity.
apply r1r2_r.
(* not in U1 *)
rewrite (not_in_mem_false notin_U1) in H.
rewrite (not_in_mem_false (notin_subset notin_U1 U2_ss_U1)).
auto.
Save.
Lemma get_from_icontext : forall r G n A,
nth_error G n = Some A ->
sat r (f_bang (icontext_to_formula G)) ->
sat r A.
intros r G n A. generalize r n. clear r n.
induction G; intros.
(* empty list *)
destruct n; discriminate.
(* cons *)
simpl in *.
destruct H0 as [r' [r'_r1 [r1 [r2 [r1r2_r [sat_r1 sat_r2]]]]]].
destruct (nat_dec n) as [n_is_0 | [x n_is_Sx]]; subst; simpl in *.
(* found here *)
inversion H. subst.
eapply sat_leq.
apply sat_r1.
eapply leq_trans.
eapply right_weaken. apply r1r2_r.
eapply leq_trans. apply bang_unit. assumption.
(* not found here *)
eapply sat_leq.
eapply IHG.
apply H.
exists r2. intuition.
apply bang_order_Proper. eapply left_weaken. apply r1r2_r.
apply r'_r1.
Save.
Lemma context_empty : forall U G m,
VarSet.Empty U ->
context_to_formula G m U = f_i.
intros U G m U_empty. generalize m. clear m. induction G; intros.
reflexivity.
simpl. rewrite (not_in_mem_false (U_empty m)). auto.
Save.
Lemma combine_resources : forall r1 r2 rI rL r' r,
rI :*: rL <: r ->
!r' <: rI ->
r1 :*: r2 <: rL ->
!r' :*: r1 :*: (!r' :*: r2) <: r.
intros r1 r2 rI rL r' r rIrL_r r'_rI r1r2_r.
rewrite (combine_symm (!r') r1).
rewrite <- combine_assoc.
rewrite (combine_assoc (!r') (!r')).
rewrite combine_symm. rewrite <- combine_assoc.
eapply leq_trans.
apply combine_order.
apply bang_codup.
rewrite combine_symm at 1. apply r1r2_r.
eapply leq_trans.
apply combine_order. apply r'_rI. apply leq_refl. reflexivity.
apply rIrL_r.
Save.
Lemma soundness : forall r Gi G t A U,
prf Gi G t A U ->
sat r (f_tensor (f_bang (icontext_to_formula Gi)) (context_to_formula G 0 U)) ->
sat r A.
intros r Gi G t A U prf_deriv. generalize r. clear r.
induction prf_deriv; intros.
(* prf_ivar *)
destruct H1 as [rI [rL [rIrL_r [sat_I sat_L]]]].
eapply sat_leq.
eapply get_from_icontext.
apply H.
simpl. apply sat_I.
eapply right_weaken. apply rIrL_r.
(* prf_lvar *)
destruct H1 as [rI [rL [rIrL_r [sat_I sat_L]]]].
eapply sat_leq.
eapply sat_singleton.
replace n with (n+0) in H0. rewrite H0 in sat_L. apply sat_L. omega.
apply H.
eapply left_weaken. apply rIrL_r.
(* prf_i_intro *)
simpl. trivial.
(* prf_tensor_intro *)
destruct H1 as [rI [rL [rIrL_r [sat_I sat_L]]]]. fold sat in *.
destruct sat_I as [r' [r'_rI sat_r']].
rewrite H0 in sat_L.
destruct (sat_split H sat_L) as [r1 [r2 [r1r2_r [sat_r1 sat_r2]]]].
exists (!r' :*: r1). exists (!r' :*: r2). intuition.
eapply combine_resources; eauto.
apply IHprf_deriv1. exists (!r'). exists r1. intuition.
exists r'. intuition.
apply IHprf_deriv2. exists (!r'). exists r2. intuition.
exists r'. intuition.
(* prf_tensor_elim *)
apply IHprf_deriv2.
destruct H1 as [rI [rL [rIrL_r [sat_rI sat_rL]]]]. fold sat in *.
rewrite H0 in sat_rL.
destruct sat_rI as [r' [r'_rI sat_r']].
destruct (sat_split H sat_rL) as [r1 [r2 [r1r2_r [sat_r1 sat_r2]]]].
simpl in IHprf_deriv1. destruct (IHprf_deriv1 (!r' :*: r1)) as [rA [rB [rArB_r1 [sat_rA sat_rB]]]].
exists (!r'). exists r1. intuition.
exists r'. intuition.
exists (!r'). exists (rA :*: (rB :*: r2)). intuition.
rewrite (combine_assoc rA rB r2). rewrite combine_assoc. eapply leq_trans.
apply combine_order. eapply leq_trans.
apply combine_order.
apply leq_refl. reflexivity.
apply rArB_r1.
rewrite combine_assoc at 1. apply combine_order.
apply bang_codup.
apply leq_refl. reflexivity.
apply leq_refl. reflexivity.
rewrite <- combine_assoc. eapply leq_trans.
apply combine_order. apply r'_rI. apply r1r2_r.
apply rIrL_r.
exists r'. intuition.
apply sat_shift.
apply sat_shift; assumption.
assumption.
(* prf_and_intro *)
destruct H0 as [rI [rL [rIrL_r [sat_rI sat_rL]]]].
rewrite H in sat_rL.
simpl. split.
apply IHprf_deriv1. exists rI. exists rL. intuition. eapply sat_subset. eapply SYN.VarSetProps.union_subset_1. apply sat_rL.
apply IHprf_deriv2. exists rI. exists rL. intuition. eapply sat_subset. eapply SYN.VarSetProps.union_subset_2. apply sat_rL.
(* prf_and_elim_1 *)
simpl in *. destruct (IHprf_deriv r H). assumption.
(* prf_and_elim_2 *)
simpl in *. destruct (IHprf_deriv r H). assumption.
(* prf_lolli_intro *)
destruct H0 as [rI [rL [rIrL_r [sat_rI sat_rL]]]].
rewrite H in sat_rL.
simpl. intros.
apply IHprf_deriv. exists rI. exists (r' :*: rL). intuition.
rewrite (combine_symm r' rL). rewrite combine_assoc. apply combine_order.
assumption.
apply leq_refl. reflexivity.
apply sat_shift; assumption.
(* prf_lolli_elim *)
rewrite H0 in H1.
destruct H1 as [rI [rL [rIrL_r [sat_rI sat_rL]]]].
destruct sat_rI as [r' [r'_rI sat_r']].
destruct (sat_split H sat_rL) as [r1 [r2 [r1r2_r [sat_r1 sat_r2]]]].
eapply sat_leq.
simpl in IHprf_deriv1. eapply IHprf_deriv1.
exists (!r'). exists r1. intuition.
apply leq_refl. reflexivity.
exists r'. intuition.
apply IHprf_deriv2. exists (!r'). exists r2. intuition.
apply leq_refl. reflexivity.
exists r'. intuition.
eapply combine_resources; eauto.
(* prf_bang_intro *)
rewrite context_empty in IHprf_deriv; [|assumption].
destruct H0 as [rI [rL [rIrL_r [sat_rI sat_rL]]]].
destruct sat_rI as [r' [r'_rI sat_r']].
exists (!r'). split.
eapply leq_trans.
apply bang_mult.
rewrite <- (r_combine_e (!r')). eapply leq_trans.
apply combine_order. apply r'_rI. apply e_bottom.
apply rIrL_r.
apply IHprf_deriv. exists (!r'). exists e. intuition.
rewrite r_combine_e. apply leq_refl. reflexivity.
exists r'. intuition.
simpl. trivial.
(* prf_bang_elim *)
apply IHprf_deriv2.
rewrite H0 in H1.
destruct H1 as [rI [rL [rIrL_r [sat_rI sat_rL]]]].
destruct sat_rI as [r' [r'_rI sat_r']].
destruct (sat_split H sat_rL) as [r1 [r2 [r1r2_r [sat_r1 sat_r2]]]].
simpl in IHprf_deriv1. destruct (IHprf_deriv1 (!r' :*: r1)) as [rA [rA_r sat_rA]].
exists (!r'). exists r1. intuition.
exists r'. intuition.
exists (!(rA :*: r')). exists r2. intuition.
rewrite bang_combine. rewrite <- combine_assoc. eapply leq_trans.
apply combine_order.
apply rA_r. apply leq_refl. reflexivity.
eapply combine_resources; eauto.
exists (rA :*: r'). intuition.
exists rA. exists r'. intuition.
(* prf_axiom *)
apply axioms_sound. apply IHprf_deriv. apply H.
(* prf_let *)
rewrite H in *. rewrite H1 in H2.
destruct H2 as [rI [rL [rIrL_r [sat_rI sat_rL]]]].
destruct sat_rI as [r' [r'_rI sat_r']].
destruct (sat_split H0 sat_rL) as [r1 [r2 [r1r2_r [sat_r1 sat_r2]]]].
eapply sat_leq.
apply IHprf_deriv2.
exists (!r'). exists (!r':*:rL). intuition.
apply leq_refl. reflexivity.
exists r'. intuition.
apply sat_leq with (r1:=(!r' :*: r1) :*: r2).
apply sat_shift. assumption.
apply IHprf_deriv1.
exists (!r'). exists r1. intuition.
exists r'. intuition.
rewrite <- combine_assoc. apply combine_order.
apply leq_refl. reflexivity.
assumption.
rewrite combine_assoc.
eapply leq_trans. apply combine_order. eapply leq_trans. apply bang_codup. apply r'_rI.
apply leq_refl. reflexivity.
assumption.
Save.
Lemma single_soundness : forall r A B t U,
sat r A ->
prf nil (A::nil) t B U ->
sat r B.
intros r A B t U sat_r_A prf_A_B. eapply soundness.
apply prf_A_B.
simpl.
exists e. exists r. intuition.
rewrite e_combine_r. apply leq_refl. reflexivity.
exists e. intuition. apply leq_refl. apply bang_e.
destruct (SYN.VarSetProps.In_dec 0%nat U) as [in_U | notin_U].
(* the evidence was used by the proof *)
rewrite (VarSet.mem_1 in_U).
exists r. exists e. simpl. intuition.
rewrite r_combine_e. apply leq_refl. reflexivity.
(* the evidence was not used by the proof *)
rewrite (not_in_mem_false notin_U). simpl. trivial.
Save.
Lemma implies_soundness : forall r A B,
sat r A ->
implies A B ->
sat r B.
intros r A B r_A A_implies_B.
destruct A_implies_B as [t [U prf_ok]].
eapply single_soundness; eassumption.
Save.
Lemma res_formula : forall re,
sat (res_parse re) (resexpr_to_formula re).
Proof.
unfold resexpr_to_formula.
intro.
assert (sat e f_i) by (simpl;trivial).
apply sat_leq with (r1:=e:*:res_parse re).
generalize e f_i H. clear H.
induction re.
intros. unfold res_parse. simpl. eapply sat_leq. apply H. rewrite r_combine_e. apply leq_refl. reflexivity.
intros. unfold r_may. destruct a as [[|] c].
simpl. destruct (r_new c) as [rc|] _eqn: req. apply sat_leq with (r1:=(r :*: !rc) :*: res_parse re).
apply IHre. simpl. exists r. exists (!rc). repeat split.
apply leq_refl. reflexivity.
assumption.
destruct (r_new_match _ _ req) as [a [req' aeq]]. rewrite req'. simpl. exists rc. split.
apply leq_refl. reflexivity.
apply RA.leq_refl. apply RA.eq_symm. rewrite aeq. reflexivity.
apply leq_refl. apply eq_symm. apply combine_assoc.
rewrite (r_new_empty _ req). apply IHre. simpl. exists r. exists e. intuition.
rewrite r_combine_e. apply leq_refl. reflexivity.
simpl. destruct (r_new c) as [rc|] _eqn: req.
apply sat_leq with (r1:=(r :*: rc) :*: res_parse re).
apply IHre. simpl. exists r. exists rc. intuition.
destruct (r_new_match _ _ req) as [a [req' aeq]]. rewrite req'. simpl. rewrite aeq. apply leq_refl. reflexivity.
apply leq_refl. apply eq_symm. apply combine_assoc.
apply IHre. simpl. exists r. exists e. intuition.
apply leq_refl. rewrite r_combine_e. reflexivity.
rewrite (r_new_empty _ req). simpl. trivial.
apply leq_refl. rewrite e_combine_r. reflexivity.
Qed.
End MkILLSemantics.
(*
Local Variables:
coq-prog-args: ("-emacs-U" "-I" ".." "-R" "." "ILL")
End:
*)
|
Load LFindLoad.
From lfind Require Import LFind.
From QuickChick Require Import QuickChick.
From adtind Require Import goal33.
Derive Show for natural.
Derive Arbitrary for natural.
Instance Dec_Eq_natural : Dec_Eq natural.
Proof. dec_eq. Qed.
Lemma conj16eqsynthconj4 : forall (lv0 : natural), (@eq natural (Succ lv0) (plus (Succ Zero) lv0)).
Admitted.
QuickChick conj16eqsynthconj4.
|
State Before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hp : p ≠ 0
⊢ trailingDegree p = ↑n ↔ natTrailingDegree p = n State After: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hp : p ≠ 0
⊢ ↑(natTrailingDegree p) = ↑n ↔ natTrailingDegree p = n Tactic: rw [trailingDegree_eq_natTrailingDegree hp] State Before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hp : p ≠ 0
⊢ ↑(natTrailingDegree p) = ↑n ↔ natTrailingDegree p = n State After: no goals Tactic: exact WithTop.coe_eq_coe |
/-
Copyright (c) 2015 Microsoft Corporation. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Mario Carneiro
! This file was ported from Lean 3 source module algebra.big_operators.multiset.basic
! leanprover-community/mathlib commit 6c5f73fd6f6cc83122788a80a27cdd54663609f4
! Please do not edit these lines, except to modify the commit id
! if you have ported upstream changes.
-/
import Mathbin.Data.List.BigOperators.Basic
import Mathbin.Data.Multiset.Basic
/-!
# Sums and products over multisets
> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
> Any changes to this file require a corresponding PR to mathlib4.
In this file we define products and sums indexed by multisets. This is later used to define products
and sums indexed by finite sets.
## Main declarations
* `multiset.prod`: `s.prod f` is the product of `f i` over all `i ∈ s`. Not to be mistaken with
the cartesian product `multiset.product`.
* `multiset.sum`: `s.sum f` is the sum of `f i` over all `i ∈ s`.
## Implementation notes
Nov 2022: To speed the Lean 4 port, lemmas requiring extra algebra imports
(`data.list.big_operators.lemmas` rather than `.basic`) have been moved to a separate file,
`algebra.big_operators.multiset.lemmas`. This split does not need to be permanent.
-/
variable {ι α β γ : Type _}
namespace Multiset
section CommMonoid
variable [CommMonoid α] {s t : Multiset α} {a : α} {m : Multiset ι} {f g : ι → α}
#print Multiset.prod /-
/-- Product of a multiset given a commutative monoid structure on `α`.
`prod {a, b, c} = a * b * c` -/
@[to_additive
"Sum of a multiset given a commutative additive monoid structure on `α`.\n `sum {a, b, c} = a + b + c`"]
def prod : Multiset α → α :=
foldr (· * ·) (fun x y z => by simp [mul_left_comm]) 1
#align multiset.prod Multiset.prod
#align multiset.sum Multiset.sum
-/
/- warning: multiset.prod_eq_foldr -> Multiset.prod_eq_foldr is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (s : Multiset.{u1} α), Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 s) (Multiset.foldr.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))) (fun (x : α) (y : α) (z : α) => Eq.mpr.{0} (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y z)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x z))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y z)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x z))) True) (Eq.trans.{1} Prop (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y z)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x z))) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y z)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y z))) True ((fun (a : α) (a_1 : α) (e_1 : Eq.{succ u1} α a a_1) (ᾰ : α) (ᾰ_1 : α) (e_2 : Eq.{succ u1} α ᾰ ᾰ_1) => congr.{succ u1, 1} α Prop (Eq.{succ u1} α a) (Eq.{succ u1} α a_1) ᾰ ᾰ_1 (congr_arg.{succ u1, succ u1} α (α -> Prop) a a_1 (Eq.{succ u1} α) e_1) e_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y z)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y z)) (rfl.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y z))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x z)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y z)) (mul_left_comm.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1) y x z)) (propext (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y z)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y z))) True (eq_self_iff_true.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y z)))))) trivial) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))))) s)
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (s : Multiset.{u1} α), Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 s) (Multiset.foldr.{u1, u1} α α (fun ([email protected]._hyg.129 : α) ([email protected]._hyg.131 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) [email protected]._hyg.129 [email protected]._hyg.131) (fun (x : α) (y : α) (z : α) => of_eq_true (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y z)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1)))) y (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1)))) x z))) (Eq.trans.{1} Prop (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y z)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1)))) y (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1)))) x z))) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y z)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1)))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1)))) y z))) True (congrArg.{succ u1, 1} α Prop (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1)))) y (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1)))) x z)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1)))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1)))) y z)) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y z))) (mul_left_comm.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1) y x z)) (eq_self.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) y z))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) s)
Case conversion may be inaccurate. Consider using '#align multiset.prod_eq_foldr Multiset.prod_eq_foldrₓ'. -/
@[to_additive]
theorem prod_eq_foldr (s : Multiset α) :
prod s = foldr (· * ·) (fun x y z => by simp [mul_left_comm]) 1 s :=
rfl
#align multiset.prod_eq_foldr Multiset.prod_eq_foldr
#align multiset.sum_eq_foldr Multiset.sum_eq_foldr
/- warning: multiset.prod_eq_foldl -> Multiset.prod_eq_foldl is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (s : Multiset.{u1} α), Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 s) (Multiset.foldl.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))) (fun (x : α) (y : α) (z : α) => Eq.mpr.{0} (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) z) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x z) y)) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) z) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x z) y)) True) (Eq.trans.{1} Prop (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) z) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x z) y)) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) z) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) z)) True ((fun (a : α) (a_1 : α) (e_1 : Eq.{succ u1} α a a_1) (ᾰ : α) (ᾰ_1 : α) (e_2 : Eq.{succ u1} α ᾰ ᾰ_1) => congr.{succ u1, 1} α Prop (Eq.{succ u1} α a) (Eq.{succ u1} α a_1) ᾰ ᾰ_1 (congr_arg.{succ u1, succ u1} α (α -> Prop) a a_1 (Eq.{succ u1} α) e_1) e_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) z) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) z) (rfl.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) z)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x z) y) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) z) (mul_right_comm.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1) x z y)) (propext (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) z) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) z)) True (eq_self_iff_true.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) z))))) trivial) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))))) s)
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (s : Multiset.{u1} α), Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 s) (Multiset.foldl.{u1, u1} α α (fun ([email protected]._hyg.189 : α) ([email protected]._hyg.191 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) [email protected]._hyg.189 [email protected]._hyg.191) (fun (x : α) (y : α) (z : α) => of_eq_true (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) z) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1)))) x z) y)) (Eq.trans.{1} Prop (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) z) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1)))) x z) y)) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) z) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1)))) x y) z)) True (congrArg.{succ u1, 1} α Prop (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1)))) x z) y) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1)))) x y) z) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) z)) (mul_right_comm.{u1} α (CommMonoid.toCommSemigroup.{u1} α _inst_1) x z y)) (eq_self.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) x y) z)))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) s)
Case conversion may be inaccurate. Consider using '#align multiset.prod_eq_foldl Multiset.prod_eq_foldlₓ'. -/
@[to_additive]
theorem prod_eq_foldl (s : Multiset α) :
prod s = foldl (· * ·) (fun x y z => by simp [mul_right_comm]) 1 s :=
(foldr_swap _ _ _ _).trans (by simp [mul_comm])
#align multiset.prod_eq_foldl Multiset.prod_eq_foldl
#align multiset.sum_eq_foldl Multiset.sum_eq_foldl
/- warning: multiset.coe_prod -> Multiset.coe_prod is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (l : List.{u1} α), Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (List.{u1} α) (Multiset.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (List.{u1} α) (Multiset.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (List.{u1} α) (Multiset.{u1} α) (coeBase.{succ u1, succ u1} (List.{u1} α) (Multiset.{u1} α) (Multiset.hasCoe.{u1} α)))) l)) (List.prod.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) l)
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (l : List.{u1} α), Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 (Multiset.ofList.{u1} α l)) (List.prod.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) l)
Case conversion may be inaccurate. Consider using '#align multiset.coe_prod Multiset.coe_prodₓ'. -/
@[simp, norm_cast, to_additive]
theorem coe_prod (l : List α) : prod ↑l = l.Prod :=
prod_eq_foldl _
#align multiset.coe_prod Multiset.coe_prod
#align multiset.coe_sum Multiset.coe_sum
/- warning: multiset.prod_to_list -> Multiset.prod_toList is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (s : Multiset.{u1} α), Eq.{succ u1} α (List.prod.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) (Multiset.toList.{u1} α s)) (Multiset.prod.{u1} α _inst_1 s)
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (s : Multiset.{u1} α), Eq.{succ u1} α (List.prod.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Multiset.toList.{u1} α s)) (Multiset.prod.{u1} α _inst_1 s)
Case conversion may be inaccurate. Consider using '#align multiset.prod_to_list Multiset.prod_toListₓ'. -/
@[simp, to_additive]
theorem prod_toList (s : Multiset α) : s.toList.Prod = s.Prod :=
by
conv_rhs => rw [← coe_to_list s]
rw [coe_prod]
#align multiset.prod_to_list Multiset.prod_toList
#align multiset.sum_to_list Multiset.sum_toList
/- warning: multiset.prod_zero -> Multiset.prod_zero is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α], Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 (OfNat.ofNat.{u1} (Multiset.{u1} α) 0 (OfNat.mk.{u1} (Multiset.{u1} α) 0 (Zero.zero.{u1} (Multiset.{u1} α) (Multiset.hasZero.{u1} α))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α], Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 (OfNat.ofNat.{u1} (Multiset.{u1} α) 0 (Zero.toOfNat0.{u1} (Multiset.{u1} α) (Multiset.instZeroMultiset.{u1} α)))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))
Case conversion may be inaccurate. Consider using '#align multiset.prod_zero Multiset.prod_zeroₓ'. -/
@[simp, to_additive]
theorem prod_zero : @prod α _ 0 = 1 :=
rfl
#align multiset.prod_zero Multiset.prod_zero
#align multiset.sum_zero Multiset.sum_zero
/- warning: multiset.prod_cons -> Multiset.prod_cons is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (a : α) (s : Multiset.{u1} α), Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 (Multiset.cons.{u1} α a s)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a (Multiset.prod.{u1} α _inst_1 s))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (a : α) (s : Multiset.{u1} α), Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 (Multiset.cons.{u1} α a s)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a (Multiset.prod.{u1} α _inst_1 s))
Case conversion may be inaccurate. Consider using '#align multiset.prod_cons Multiset.prod_consₓ'. -/
@[simp, to_additive]
theorem prod_cons (a : α) (s) : prod (a ::ₘ s) = a * prod s :=
foldr_cons _ _ _ _ _
#align multiset.prod_cons Multiset.prod_cons
#align multiset.sum_cons Multiset.sum_cons
/- warning: multiset.prod_erase -> Multiset.prod_erase is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] {s : Multiset.{u1} α} {a : α} [_inst_2 : DecidableEq.{succ u1} α], (Membership.Mem.{u1, u1} α (Multiset.{u1} α) (Multiset.hasMem.{u1} α) a s) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a (Multiset.prod.{u1} α _inst_1 (Multiset.erase.{u1} α (fun (a : α) (b : α) => _inst_2 a b) s a))) (Multiset.prod.{u1} α _inst_1 s))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] {s : Multiset.{u1} α} {a : α} [_inst_2 : DecidableEq.{succ u1} α], (Membership.mem.{u1, u1} α (Multiset.{u1} α) (Multiset.instMembershipMultiset.{u1} α) a s) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a (Multiset.prod.{u1} α _inst_1 (Multiset.erase.{u1} α (fun (a : α) (b : α) => _inst_2 a b) s a))) (Multiset.prod.{u1} α _inst_1 s))
Case conversion may be inaccurate. Consider using '#align multiset.prod_erase Multiset.prod_eraseₓ'. -/
@[simp, to_additive]
theorem prod_erase [DecidableEq α] (h : a ∈ s) : a * (s.eraseₓ a).Prod = s.Prod := by
rw [← s.coe_to_list, coe_erase, coe_prod, coe_prod, List.prod_erase (mem_to_list.2 h)]
#align multiset.prod_erase Multiset.prod_erase
#align multiset.sum_erase Multiset.sum_erase
/- warning: multiset.prod_map_erase -> Multiset.prod_map_erase is a dubious translation:
lean 3 declaration is
forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : CommMonoid.{u2} α] {m : Multiset.{u1} ι} {f : ι -> α} [_inst_2 : DecidableEq.{succ u1} ι] {a : ι}, (Membership.Mem.{u1, u1} ι (Multiset.{u1} ι) (Multiset.hasMem.{u1} ι) a m) -> (Eq.{succ u2} α (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)))) (f a) (Multiset.prod.{u2} α _inst_1 (Multiset.map.{u1, u2} ι α f (Multiset.erase.{u1} ι (fun (a : ι) (b : ι) => _inst_2 a b) m a)))) (Multiset.prod.{u2} α _inst_1 (Multiset.map.{u1, u2} ι α f m)))
but is expected to have type
forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] {m : Multiset.{u2} ι} {f : ι -> α} [_inst_2 : DecidableEq.{succ u2} ι] {a : ι}, (Membership.mem.{u2, u2} ι (Multiset.{u2} ι) (Multiset.instMembershipMultiset.{u2} ι) a m) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (f a) (Multiset.prod.{u1} α _inst_1 (Multiset.map.{u2, u1} ι α f (Multiset.erase.{u2} ι (fun (a : ι) (b : ι) => _inst_2 a b) m a)))) (Multiset.prod.{u1} α _inst_1 (Multiset.map.{u2, u1} ι α f m)))
Case conversion may be inaccurate. Consider using '#align multiset.prod_map_erase Multiset.prod_map_eraseₓ'. -/
@[simp, to_additive]
theorem prod_map_erase [DecidableEq ι] {a : ι} (h : a ∈ m) :
f a * ((m.eraseₓ a).map f).Prod = (m.map f).Prod := by
rw [← m.coe_to_list, coe_erase, coe_map, coe_map, coe_prod, coe_prod,
List.prod_map_erase f (mem_to_list.2 h)]
#align multiset.prod_map_erase Multiset.prod_map_erase
#align multiset.sum_map_erase Multiset.sum_map_erase
#print Multiset.prod_singleton /-
@[simp, to_additive]
theorem prod_singleton (a : α) : prod {a} = a := by
simp only [mul_one, prod_cons, ← cons_zero, eq_self_iff_true, prod_zero]
#align multiset.prod_singleton Multiset.prod_singleton
#align multiset.sum_singleton Multiset.sum_singleton
-/
/- warning: multiset.prod_pair -> Multiset.prod_pair is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (a : α) (b : α), Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 (Insert.insert.{u1, u1} α (Multiset.{u1} α) (Multiset.hasInsert.{u1} α) a (Singleton.singleton.{u1, u1} α (Multiset.{u1} α) (Multiset.hasSingleton.{u1} α) b))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b)
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (a : α) (b : α), Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 (Insert.insert.{u1, u1} α (Multiset.{u1} α) (Multiset.instInsertMultiset.{u1} α) a (Singleton.singleton.{u1, u1} α (Multiset.{u1} α) (Multiset.instSingletonMultiset.{u1} α) b))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b)
Case conversion may be inaccurate. Consider using '#align multiset.prod_pair Multiset.prod_pairₓ'. -/
@[to_additive]
theorem prod_pair (a b : α) : ({a, b} : Multiset α).Prod = a * b := by
rw [insert_eq_cons, prod_cons, prod_singleton]
#align multiset.prod_pair Multiset.prod_pair
#align multiset.sum_pair Multiset.sum_pair
/- warning: multiset.prod_add -> Multiset.prod_add is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (s : Multiset.{u1} α) (t : Multiset.{u1} α), Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 (HAdd.hAdd.{u1, u1, u1} (Multiset.{u1} α) (Multiset.{u1} α) (Multiset.{u1} α) (instHAdd.{u1} (Multiset.{u1} α) (Multiset.hasAdd.{u1} α)) s t)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (Multiset.prod.{u1} α _inst_1 s) (Multiset.prod.{u1} α _inst_1 t))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (s : Multiset.{u1} α) (t : Multiset.{u1} α), Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 (HAdd.hAdd.{u1, u1, u1} (Multiset.{u1} α) (Multiset.{u1} α) (Multiset.{u1} α) (instHAdd.{u1} (Multiset.{u1} α) (Multiset.instAddMultiset.{u1} α)) s t)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (Multiset.prod.{u1} α _inst_1 s) (Multiset.prod.{u1} α _inst_1 t))
Case conversion may be inaccurate. Consider using '#align multiset.prod_add Multiset.prod_addₓ'. -/
@[simp, to_additive]
theorem prod_add (s t : Multiset α) : prod (s + t) = prod s * prod t :=
Quotient.induction_on₂ s t fun l₁ l₂ => by simp
#align multiset.prod_add Multiset.prod_add
#align multiset.sum_add Multiset.sum_add
/- warning: multiset.prod_nsmul -> Multiset.prod_nsmul is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (m : Multiset.{u1} α) (n : Nat), Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 (SMul.smul.{0, u1} Nat (Multiset.{u1} α) (AddMonoid.SMul.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.orderedCancelAddCommMonoid.{u1} α)))))) n m)) (HPow.hPow.{u1, 0, u1} α Nat α (instHPow.{u1, 0} α Nat (Monoid.Pow.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) (Multiset.prod.{u1} α _inst_1 m) n)
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (m : Multiset.{u1} α) (n : Nat), Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 (HSMul.hSMul.{0, u1, u1} Nat (Multiset.{u1} α) (Multiset.{u1} α) (instHSMul.{0, u1} Nat (Multiset.{u1} α) (AddMonoid.SMul.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α))))))) n m)) (HPow.hPow.{u1, 0, u1} α Nat α (instHPow.{u1, 0} α Nat (Monoid.Pow.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) (Multiset.prod.{u1} α _inst_1 m) n)
Case conversion may be inaccurate. Consider using '#align multiset.prod_nsmul Multiset.prod_nsmulₓ'. -/
theorem prod_nsmul (m : Multiset α) : ∀ n : ℕ, (n • m).Prod = m.Prod ^ n
| 0 => by
rw [zero_nsmul, pow_zero]
rfl
| n + 1 => by rw [add_nsmul, one_nsmul, pow_add, pow_one, prod_add, prod_nsmul n]
#align multiset.prod_nsmul Multiset.prod_nsmul
#print Multiset.prod_replicate /-
@[simp, to_additive]
theorem prod_replicate (n : ℕ) (a : α) : (replicate n a).Prod = a ^ n := by
simp [replicate, List.prod_replicate]
#align multiset.prod_replicate Multiset.prod_replicate
#align multiset.sum_replicate Multiset.sum_replicate
-/
/- warning: multiset.prod_map_eq_pow_single -> Multiset.prod_map_eq_pow_single is a dubious translation:
lean 3 declaration is
forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : CommMonoid.{u2} α] {m : Multiset.{u1} ι} {f : ι -> α} [_inst_2 : DecidableEq.{succ u1} ι] (i : ι), (forall (i' : ι), (Ne.{succ u1} ι i' i) -> (Membership.Mem.{u1, u1} ι (Multiset.{u1} ι) (Multiset.hasMem.{u1} ι) i' m) -> (Eq.{succ u2} α (f i') (OfNat.ofNat.{u2} α 1 (OfNat.mk.{u2} α 1 (One.one.{u2} α (MulOneClass.toHasOne.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)))))))) -> (Eq.{succ u2} α (Multiset.prod.{u2} α _inst_1 (Multiset.map.{u1, u2} ι α f m)) (HPow.hPow.{u2, 0, u2} α Nat α (instHPow.{u2, 0} α Nat (Monoid.Pow.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1))) (f i) (Multiset.count.{u1} ι (fun (a : ι) (b : ι) => _inst_2 a b) i m)))
but is expected to have type
forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] {m : Multiset.{u2} ι} {f : ι -> α} [_inst_2 : DecidableEq.{succ u2} ι] (i : ι), (forall (i' : ι), (Ne.{succ u2} ι i' i) -> (Membership.mem.{u2, u2} ι (Multiset.{u2} ι) (Multiset.instMembershipMultiset.{u2} ι) i' m) -> (Eq.{succ u1} α (f i') (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))))) -> (Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 (Multiset.map.{u2, u1} ι α f m)) (HPow.hPow.{u1, 0, u1} α Nat α (instHPow.{u1, 0} α Nat (Monoid.Pow.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) (f i) (Multiset.count.{u2} ι (fun (a : ι) (b : ι) => _inst_2 a b) i m)))
Case conversion may be inaccurate. Consider using '#align multiset.prod_map_eq_pow_single Multiset.prod_map_eq_pow_singleₓ'. -/
/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (i' «expr ≠ » i) -/
@[to_additive]
theorem prod_map_eq_pow_single [DecidableEq ι] (i : ι)
(hf : ∀ (i') (_ : i' ≠ i), i' ∈ m → f i' = 1) : (m.map f).Prod = f i ^ m.count i :=
by
induction' m using Quotient.inductionOn with l
simp [List.prod_map_eq_pow_single i f hf]
#align multiset.prod_map_eq_pow_single Multiset.prod_map_eq_pow_single
#align multiset.sum_map_eq_nsmul_single Multiset.sum_map_eq_nsmul_single
/- warning: multiset.prod_eq_pow_single -> Multiset.prod_eq_pow_single is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] {s : Multiset.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (a : α), (forall (a' : α), (Ne.{succ u1} α a' a) -> (Membership.Mem.{u1, u1} α (Multiset.{u1} α) (Multiset.hasMem.{u1} α) a' s) -> (Eq.{succ u1} α a' (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))))))) -> (Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 s) (HPow.hPow.{u1, 0, u1} α Nat α (instHPow.{u1, 0} α Nat (Monoid.Pow.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) a (Multiset.count.{u1} α (fun (a : α) (b : α) => _inst_2 a b) a s)))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] {s : Multiset.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (a : α), (forall (a' : α), (Ne.{succ u1} α a' a) -> (Membership.mem.{u1, u1} α (Multiset.{u1} α) (Multiset.instMembershipMultiset.{u1} α) a' s) -> (Eq.{succ u1} α a' (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))))) -> (Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 s) (HPow.hPow.{u1, 0, u1} α Nat α (instHPow.{u1, 0} α Nat (Monoid.Pow.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) a (Multiset.count.{u1} α (fun (a : α) (b : α) => _inst_2 a b) a s)))
Case conversion may be inaccurate. Consider using '#align multiset.prod_eq_pow_single Multiset.prod_eq_pow_singleₓ'. -/
/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (a' «expr ≠ » a) -/
@[to_additive]
theorem prod_eq_pow_single [DecidableEq α] (a : α) (h : ∀ (a') (_ : a' ≠ a), a' ∈ s → a' = 1) :
s.Prod = a ^ s.count a :=
by
induction' s using Quotient.inductionOn with l
simp [List.prod_eq_pow_single a h]
#align multiset.prod_eq_pow_single Multiset.prod_eq_pow_single
#align multiset.sum_eq_nsmul_single Multiset.sum_eq_nsmul_single
#print Multiset.pow_count /-
@[to_additive]
theorem pow_count [DecidableEq α] (a : α) : a ^ s.count a = (s.filterₓ (Eq a)).Prod := by
rw [filter_eq, prod_replicate]
#align multiset.pow_count Multiset.pow_count
#align multiset.nsmul_count Multiset.nsmul_count
-/
/- warning: multiset.prod_hom -> Multiset.prod_hom is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : CommMonoid.{u2} β] (s : Multiset.{u1} α) {F : Type.{u3}} [_inst_3 : MonoidHomClass.{u3, u1, u2} F α β (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2))] (f : F), Eq.{succ u2} β (Multiset.prod.{u2} β _inst_2 (Multiset.map.{u1, u2} α β (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u3, u1, u2} F α β (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) (MulOneClass.toHasMul.{u2} β (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F α β (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2)) _inst_3))) f) s)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u3, u1, u2} F α β (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) (MulOneClass.toHasMul.{u2} β (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F α β (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2)) _inst_3))) f (Multiset.prod.{u1} α _inst_1 s))
but is expected to have type
forall {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : CommMonoid.{u2} α] [_inst_2 : CommMonoid.{u3} β] (s : Multiset.{u2} α) {F : Type.{u1}} [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)) (Monoid.toMulOneClass.{u3} β (CommMonoid.toMonoid.{u3} β _inst_2))] (f : F), Eq.{succ u3} β (Multiset.prod.{u3} β _inst_2 (Multiset.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun ([email protected]._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (CommMonoid.toMonoid.{u3} β _inst_2))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)) (Monoid.toMulOneClass.{u3} β (CommMonoid.toMonoid.{u3} β _inst_2)) _inst_3)) f) s)) (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun ([email protected]._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (CommMonoid.toMonoid.{u3} β _inst_2))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)) (Monoid.toMulOneClass.{u3} β (CommMonoid.toMonoid.{u3} β _inst_2)) _inst_3)) f (Multiset.prod.{u2} α _inst_1 s))
Case conversion may be inaccurate. Consider using '#align multiset.prod_hom Multiset.prod_homₓ'. -/
@[to_additive]
theorem prod_hom [CommMonoid β] (s : Multiset α) {F : Type _} [MonoidHomClass F α β] (f : F) :
(s.map f).Prod = f s.Prod :=
Quotient.inductionOn s fun l => by simp only [l.prod_hom f, quot_mk_to_coe, coe_map, coe_prod]
#align multiset.prod_hom Multiset.prod_hom
#align multiset.sum_hom Multiset.sum_hom
/- warning: multiset.prod_hom' -> Multiset.prod_hom' is a dubious translation:
lean 3 declaration is
forall {ι : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : CommMonoid.{u2} α] [_inst_2 : CommMonoid.{u3} β] (s : Multiset.{u1} ι) {F : Type.{u4}} [_inst_3 : MonoidHomClass.{u4, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)) (Monoid.toMulOneClass.{u3} β (CommMonoid.toMonoid.{u3} β _inst_2))] (f : F) (g : ι -> α), Eq.{succ u3} β (Multiset.prod.{u3} β _inst_2 (Multiset.map.{u1, u3} ι β (fun (i : ι) => coeFn.{succ u4, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u4, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u4, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (CommMonoid.toMonoid.{u3} β _inst_2))) (MonoidHomClass.toMulHomClass.{u4, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)) (Monoid.toMulOneClass.{u3} β (CommMonoid.toMonoid.{u3} β _inst_2)) _inst_3))) f (g i)) s)) (coeFn.{succ u4, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u4, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u4, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (CommMonoid.toMonoid.{u3} β _inst_2))) (MonoidHomClass.toMulHomClass.{u4, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)) (Monoid.toMulOneClass.{u3} β (CommMonoid.toMonoid.{u3} β _inst_2)) _inst_3))) f (Multiset.prod.{u2} α _inst_1 (Multiset.map.{u1, u2} ι α g s)))
but is expected to have type
forall {ι : Type.{u3}} {α : Type.{u1}} {β : Type.{u4}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : CommMonoid.{u4} β] (s : Multiset.{u3} ι) {F : Type.{u2}} [_inst_3 : MonoidHomClass.{u2, u1, u4} F α β (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Monoid.toMulOneClass.{u4} β (CommMonoid.toMonoid.{u4} β _inst_2))] (f : F) (g : ι -> α), Eq.{succ u4} β (Multiset.prod.{u4} β _inst_2 (Multiset.map.{u3, u4} ι β (fun (i : ι) => FunLike.coe.{succ u2, succ u1, succ u4} F α (fun (_x : α) => (fun ([email protected]._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u2, u1, u4} F α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) (MulOneClass.toMul.{u4} β (Monoid.toMulOneClass.{u4} β (CommMonoid.toMonoid.{u4} β _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u1, u4} F α β (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Monoid.toMulOneClass.{u4} β (CommMonoid.toMonoid.{u4} β _inst_2)) _inst_3)) f (g i)) s)) (FunLike.coe.{succ u2, succ u1, succ u4} F α (fun (_x : α) => (fun ([email protected]._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u2, u1, u4} F α β (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) (MulOneClass.toMul.{u4} β (Monoid.toMulOneClass.{u4} β (CommMonoid.toMonoid.{u4} β _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u1, u4} F α β (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Monoid.toMulOneClass.{u4} β (CommMonoid.toMonoid.{u4} β _inst_2)) _inst_3)) f (Multiset.prod.{u1} α _inst_1 (Multiset.map.{u3, u1} ι α g s)))
Case conversion may be inaccurate. Consider using '#align multiset.prod_hom' Multiset.prod_hom'ₓ'. -/
@[to_additive]
theorem prod_hom' [CommMonoid β] (s : Multiset ι) {F : Type _} [MonoidHomClass F α β] (f : F)
(g : ι → α) : (s.map fun i => f <| g i).Prod = f (s.map g).Prod :=
by
convert(s.map g).prod_hom f
exact (map_map _ _ _).symm
#align multiset.prod_hom' Multiset.prod_hom'
#align multiset.sum_hom' Multiset.sum_hom'
/- warning: multiset.prod_hom₂ -> Multiset.prod_hom₂ is a dubious translation:
lean 3 declaration is
forall {ι : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} {γ : Type.{u4}} [_inst_1 : CommMonoid.{u2} α] [_inst_2 : CommMonoid.{u3} β] [_inst_3 : CommMonoid.{u4} γ] (s : Multiset.{u1} ι) (f : α -> β -> γ), (forall (a : α) (b : α) (c : β) (d : β), Eq.{succ u4} γ (f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)))) a b) (HMul.hMul.{u3, u3, u3} β β β (instHMul.{u3} β (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (CommMonoid.toMonoid.{u3} β _inst_2)))) c d)) (HMul.hMul.{u4, u4, u4} γ γ γ (instHMul.{u4} γ (MulOneClass.toHasMul.{u4} γ (Monoid.toMulOneClass.{u4} γ (CommMonoid.toMonoid.{u4} γ _inst_3)))) (f a c) (f b d))) -> (Eq.{succ u4} γ (f (OfNat.ofNat.{u2} α 1 (OfNat.mk.{u2} α 1 (One.one.{u2} α (MulOneClass.toHasOne.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)))))) (OfNat.ofNat.{u3} β 1 (OfNat.mk.{u3} β 1 (One.one.{u3} β (MulOneClass.toHasOne.{u3} β (Monoid.toMulOneClass.{u3} β (CommMonoid.toMonoid.{u3} β _inst_2))))))) (OfNat.ofNat.{u4} γ 1 (OfNat.mk.{u4} γ 1 (One.one.{u4} γ (MulOneClass.toHasOne.{u4} γ (Monoid.toMulOneClass.{u4} γ (CommMonoid.toMonoid.{u4} γ _inst_3))))))) -> (forall (f₁ : ι -> α) (f₂ : ι -> β), Eq.{succ u4} γ (Multiset.prod.{u4} γ _inst_3 (Multiset.map.{u1, u4} ι γ (fun (i : ι) => f (f₁ i) (f₂ i)) s)) (f (Multiset.prod.{u2} α _inst_1 (Multiset.map.{u1, u2} ι α f₁ s)) (Multiset.prod.{u3} β _inst_2 (Multiset.map.{u1, u3} ι β f₂ s))))
but is expected to have type
forall {ι : Type.{u2}} {α : Type.{u1}} {β : Type.{u4}} {γ : Type.{u3}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : CommMonoid.{u4} β] [_inst_3 : CommMonoid.{u3} γ] (s : Multiset.{u2} ι) (f : α -> β -> γ), (forall (a : α) (b : α) (c : β) (d : β), Eq.{succ u3} γ (f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b) (HMul.hMul.{u4, u4, u4} β β β (instHMul.{u4} β (MulOneClass.toMul.{u4} β (Monoid.toMulOneClass.{u4} β (CommMonoid.toMonoid.{u4} β _inst_2)))) c d)) (HMul.hMul.{u3, u3, u3} γ γ γ (instHMul.{u3} γ (MulOneClass.toMul.{u3} γ (Monoid.toMulOneClass.{u3} γ (CommMonoid.toMonoid.{u3} γ _inst_3)))) (f a c) (f b d))) -> (Eq.{succ u3} γ (f (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u4} β 1 (One.toOfNat1.{u4} β (Monoid.toOne.{u4} β (CommMonoid.toMonoid.{u4} β _inst_2))))) (OfNat.ofNat.{u3} γ 1 (One.toOfNat1.{u3} γ (Monoid.toOne.{u3} γ (CommMonoid.toMonoid.{u3} γ _inst_3))))) -> (forall (f₁ : ι -> α) (f₂ : ι -> β), Eq.{succ u3} γ (Multiset.prod.{u3} γ _inst_3 (Multiset.map.{u2, u3} ι γ (fun (i : ι) => f (f₁ i) (f₂ i)) s)) (f (Multiset.prod.{u1} α _inst_1 (Multiset.map.{u2, u1} ι α f₁ s)) (Multiset.prod.{u4} β _inst_2 (Multiset.map.{u2, u4} ι β f₂ s))))
Case conversion may be inaccurate. Consider using '#align multiset.prod_hom₂ Multiset.prod_hom₂ₓ'. -/
@[to_additive]
theorem prod_hom₂ [CommMonoid β] [CommMonoid γ] (s : Multiset ι) (f : α → β → γ)
(hf : ∀ a b c d, f (a * b) (c * d) = f a c * f b d) (hf' : f 1 1 = 1) (f₁ : ι → α)
(f₂ : ι → β) : (s.map fun i => f (f₁ i) (f₂ i)).Prod = f (s.map f₁).Prod (s.map f₂).Prod :=
Quotient.inductionOn s fun l => by
simp only [l.prod_hom₂ f hf hf', quot_mk_to_coe, coe_map, coe_prod]
#align multiset.prod_hom₂ Multiset.prod_hom₂
#align multiset.sum_hom₂ Multiset.sum_hom₂
/- warning: multiset.prod_hom_rel -> Multiset.prod_hom_rel is a dubious translation:
lean 3 declaration is
forall {ι : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : CommMonoid.{u2} α] [_inst_2 : CommMonoid.{u3} β] (s : Multiset.{u1} ι) {r : α -> β -> Prop} {f : ι -> α} {g : ι -> β}, (r (OfNat.ofNat.{u2} α 1 (OfNat.mk.{u2} α 1 (One.one.{u2} α (MulOneClass.toHasOne.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)))))) (OfNat.ofNat.{u3} β 1 (OfNat.mk.{u3} β 1 (One.one.{u3} β (MulOneClass.toHasOne.{u3} β (Monoid.toMulOneClass.{u3} β (CommMonoid.toMonoid.{u3} β _inst_2))))))) -> (forall {{a : ι}} {{b : α}} {{c : β}}, (r b c) -> (r (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)))) (f a) b) (HMul.hMul.{u3, u3, u3} β β β (instHMul.{u3} β (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (CommMonoid.toMonoid.{u3} β _inst_2)))) (g a) c))) -> (r (Multiset.prod.{u2} α _inst_1 (Multiset.map.{u1, u2} ι α f s)) (Multiset.prod.{u3} β _inst_2 (Multiset.map.{u1, u3} ι β g s)))
but is expected to have type
forall {ι : Type.{u2}} {α : Type.{u1}} {β : Type.{u3}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : CommMonoid.{u3} β] (s : Multiset.{u2} ι) {r : α -> β -> Prop} {f : ι -> α} {g : ι -> β}, (r (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u3} β 1 (One.toOfNat1.{u3} β (Monoid.toOne.{u3} β (CommMonoid.toMonoid.{u3} β _inst_2))))) -> (forall {{a : ι}} {{b : α}} {{c : β}}, (r b c) -> (r (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (f a) b) (HMul.hMul.{u3, u3, u3} β β β (instHMul.{u3} β (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (CommMonoid.toMonoid.{u3} β _inst_2)))) (g a) c))) -> (r (Multiset.prod.{u1} α _inst_1 (Multiset.map.{u2, u1} ι α f s)) (Multiset.prod.{u3} β _inst_2 (Multiset.map.{u2, u3} ι β g s)))
Case conversion may be inaccurate. Consider using '#align multiset.prod_hom_rel Multiset.prod_hom_relₓ'. -/
@[to_additive]
theorem prod_hom_rel [CommMonoid β] (s : Multiset ι) {r : α → β → Prop} {f : ι → α} {g : ι → β}
(h₁ : r 1 1) (h₂ : ∀ ⦃a b c⦄, r b c → r (f a * b) (g a * c)) :
r (s.map f).Prod (s.map g).Prod :=
Quotient.inductionOn s fun l => by
simp only [l.prod_hom_rel h₁ h₂, quot_mk_to_coe, coe_map, coe_prod]
#align multiset.prod_hom_rel Multiset.prod_hom_rel
#align multiset.sum_hom_rel Multiset.sum_hom_rel
/- warning: multiset.prod_map_one -> Multiset.prod_map_one is a dubious translation:
lean 3 declaration is
forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : CommMonoid.{u2} α] {m : Multiset.{u1} ι}, Eq.{succ u2} α (Multiset.prod.{u2} α _inst_1 (Multiset.map.{u1, u2} ι α (fun (i : ι) => OfNat.ofNat.{u2} α 1 (OfNat.mk.{u2} α 1 (One.one.{u2} α (MulOneClass.toHasOne.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)))))) m)) (OfNat.ofNat.{u2} α 1 (OfNat.mk.{u2} α 1 (One.one.{u2} α (MulOneClass.toHasOne.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1))))))
but is expected to have type
forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : CommMonoid.{u2} α] {m : Multiset.{u1} ι}, Eq.{succ u2} α (Multiset.prod.{u2} α _inst_1 (Multiset.map.{u1, u2} ι α (fun (i : ι) => OfNat.ofNat.{u2} α 1 (One.toOfNat1.{u2} α (Monoid.toOne.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)))) m)) (OfNat.ofNat.{u2} α 1 (One.toOfNat1.{u2} α (Monoid.toOne.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1))))
Case conversion may be inaccurate. Consider using '#align multiset.prod_map_one Multiset.prod_map_oneₓ'. -/
@[to_additive]
theorem prod_map_one : prod (m.map fun i => (1 : α)) = 1 := by
rw [map_const, prod_replicate, one_pow]
#align multiset.prod_map_one Multiset.prod_map_one
#align multiset.sum_map_zero Multiset.sum_map_zero
/- warning: multiset.prod_map_mul -> Multiset.prod_map_mul is a dubious translation:
lean 3 declaration is
forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : CommMonoid.{u2} α] {m : Multiset.{u1} ι} {f : ι -> α} {g : ι -> α}, Eq.{succ u2} α (Multiset.prod.{u2} α _inst_1 (Multiset.map.{u1, u2} ι α (fun (i : ι) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)))) (f i) (g i)) m)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)))) (Multiset.prod.{u2} α _inst_1 (Multiset.map.{u1, u2} ι α f m)) (Multiset.prod.{u2} α _inst_1 (Multiset.map.{u1, u2} ι α g m)))
but is expected to have type
forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : CommMonoid.{u2} α] {m : Multiset.{u1} ι} {f : ι -> α} {g : ι -> α}, Eq.{succ u2} α (Multiset.prod.{u2} α _inst_1 (Multiset.map.{u1, u2} ι α (fun (i : ι) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)))) (f i) (g i)) m)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)))) (Multiset.prod.{u2} α _inst_1 (Multiset.map.{u1, u2} ι α f m)) (Multiset.prod.{u2} α _inst_1 (Multiset.map.{u1, u2} ι α g m)))
Case conversion may be inaccurate. Consider using '#align multiset.prod_map_mul Multiset.prod_map_mulₓ'. -/
@[simp, to_additive]
theorem prod_map_mul : (m.map fun i => f i * g i).Prod = (m.map f).Prod * (m.map g).Prod :=
m.prod_hom₂ (· * ·) mul_mul_mul_comm (mul_one _) _ _
#align multiset.prod_map_mul Multiset.prod_map_mul
#align multiset.sum_map_add Multiset.sum_map_add
/- warning: multiset.prod_map_neg -> Multiset.prod_map_neg is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : HasDistribNeg.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))] (s : Multiset.{u1} α), Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 (Multiset.map.{u1, u1} α α (Neg.neg.{u1} α (InvolutiveNeg.toHasNeg.{u1} α (HasDistribNeg.toHasInvolutiveNeg.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) _inst_2))) s)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HPow.hPow.{u1, 0, u1} α Nat α (instHPow.{u1, 0} α Nat (Monoid.Pow.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) (Neg.neg.{u1} α (InvolutiveNeg.toHasNeg.{u1} α (HasDistribNeg.toHasInvolutiveNeg.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) _inst_2)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))))) (coeFn.{succ u1, succ u1} (AddMonoidHom.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.orderedCancelAddCommMonoid.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (fun (_x : AddMonoidHom.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.orderedCancelAddCommMonoid.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) => (Multiset.{u1} α) -> Nat) (AddMonoidHom.hasCoeToFun.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.orderedCancelAddCommMonoid.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (Multiset.card.{u1} α) s)) (Multiset.prod.{u1} α _inst_1 s))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : HasDistribNeg.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))] (s : Multiset.{u1} α), Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 (Multiset.map.{u1, u1} α α (Neg.neg.{u1} α (InvolutiveNeg.toNeg.{u1} α (HasDistribNeg.toInvolutiveNeg.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) _inst_2))) s)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) (HPow.hPow.{u1, 0, u1} α ((fun ([email protected]._hyg.403 : Multiset.{u1} α) => Nat) s) α (instHPow.{u1, 0} α ((fun ([email protected]._hyg.403 : Multiset.{u1} α) => Nat) s) (Monoid.Pow.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) (Neg.neg.{u1} α (InvolutiveNeg.toNeg.{u1} α (HasDistribNeg.toInvolutiveNeg.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) _inst_2)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))) (FunLike.coe.{succ u1, succ u1, 1} (AddMonoidHom.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (Multiset.{u1} α) (fun (_x : Multiset.{u1} α) => (fun ([email protected]._hyg.403 : Multiset.{u1} α) => Nat) _x) (AddHomClass.toFunLike.{u1, u1, 0} (AddMonoidHom.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (Multiset.{u1} α) Nat (AddZeroClass.toAdd.{u1} (Multiset.{u1} α) (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α))))))) (AddZeroClass.toAdd.{0} Nat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (AddMonoidHomClass.toAddHomClass.{u1, u1, 0} (AddMonoidHom.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoidHom.addMonoidHomClass.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)))) (Multiset.card.{u1} α) s)) (Multiset.prod.{u1} α _inst_1 s))
Case conversion may be inaccurate. Consider using '#align multiset.prod_map_neg Multiset.prod_map_negₓ'. -/
@[simp]
theorem prod_map_neg [HasDistribNeg α] (s : Multiset α) :
(s.map Neg.neg).Prod = (-1) ^ s.card * s.Prod :=
by
refine' Quotient.ind _ s
simp
#align multiset.prod_map_neg Multiset.prod_map_neg
#print Multiset.prod_map_pow /-
@[to_additive]
theorem prod_map_pow {n : ℕ} : (m.map fun i => f i ^ n).Prod = (m.map f).Prod ^ n :=
m.prod_hom' (powMonoidHom n : α →* α) f
#align multiset.prod_map_pow Multiset.prod_map_pow
#align multiset.sum_map_nsmul Multiset.sum_map_nsmul
-/
/- warning: multiset.prod_map_prod_map -> Multiset.prod_map_prod_map is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : CommMonoid.{u1} α] (m : Multiset.{u2} β) (n : Multiset.{u3} γ) {f : β -> γ -> α}, Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 (Multiset.map.{u2, u1} β α (fun (a : β) => Multiset.prod.{u1} α _inst_1 (Multiset.map.{u3, u1} γ α (fun (b : γ) => f a b) n)) m)) (Multiset.prod.{u1} α _inst_1 (Multiset.map.{u3, u1} γ α (fun (b : γ) => Multiset.prod.{u1} α _inst_1 (Multiset.map.{u2, u1} β α (fun (a : β) => f a b) m)) n))
but is expected to have type
forall {α : Type.{u1}} {β : Type.{u3}} {γ : Type.{u2}} [_inst_1 : CommMonoid.{u1} α] (m : Multiset.{u3} β) (n : Multiset.{u2} γ) {f : β -> γ -> α}, Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 (Multiset.map.{u3, u1} β α (fun (a : β) => Multiset.prod.{u1} α _inst_1 (Multiset.map.{u2, u1} γ α (fun (b : γ) => f a b) n)) m)) (Multiset.prod.{u1} α _inst_1 (Multiset.map.{u2, u1} γ α (fun (b : γ) => Multiset.prod.{u1} α _inst_1 (Multiset.map.{u3, u1} β α (fun (a : β) => f a b) m)) n))
Case conversion may be inaccurate. Consider using '#align multiset.prod_map_prod_map Multiset.prod_map_prod_mapₓ'. -/
@[to_additive]
theorem prod_map_prod_map (m : Multiset β) (n : Multiset γ) {f : β → γ → α} :
prod (m.map fun a => prod <| n.map fun b => f a b) =
prod (n.map fun b => prod <| m.map fun a => f a b) :=
Multiset.induction_on m (by simp) fun a m ih => by simp [ih]
#align multiset.prod_map_prod_map Multiset.prod_map_prod_map
#align multiset.sum_map_sum_map Multiset.sum_map_sum_map
/- warning: multiset.prod_induction -> Multiset.prod_induction is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (p : α -> Prop) (s : Multiset.{u1} α), (forall (a : α) (b : α), (p a) -> (p b) -> (p (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b))) -> (p (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))))) -> (forall (a : α), (Membership.Mem.{u1, u1} α (Multiset.{u1} α) (Multiset.hasMem.{u1} α) a s) -> (p a)) -> (p (Multiset.prod.{u1} α _inst_1 s))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] (p : α -> Prop) (s : Multiset.{u1} α), (forall (a : α) (b : α), (p a) -> (p b) -> (p (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b))) -> (p (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))) -> (forall (a : α), (Membership.mem.{u1, u1} α (Multiset.{u1} α) (Multiset.instMembershipMultiset.{u1} α) a s) -> (p a)) -> (p (Multiset.prod.{u1} α _inst_1 s))
Case conversion may be inaccurate. Consider using '#align multiset.prod_induction Multiset.prod_inductionₓ'. -/
@[to_additive]
theorem prod_induction (p : α → Prop) (s : Multiset α) (p_mul : ∀ a b, p a → p b → p (a * b))
(p_one : p 1) (p_s : ∀ a ∈ s, p a) : p s.Prod :=
by
rw [prod_eq_foldr]
exact foldr_induction (· * ·) (fun x y z => by simp [mul_left_comm]) 1 p s p_mul p_one p_s
#align multiset.prod_induction Multiset.prod_induction
#align multiset.sum_induction Multiset.sum_induction
/- warning: multiset.prod_induction_nonempty -> Multiset.prod_induction_nonempty is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] {s : Multiset.{u1} α} (p : α -> Prop), (forall (a : α) (b : α), (p a) -> (p b) -> (p (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b))) -> (Ne.{succ u1} (Multiset.{u1} α) s (EmptyCollection.emptyCollection.{u1} (Multiset.{u1} α) (Multiset.hasEmptyc.{u1} α))) -> (forall (a : α), (Membership.Mem.{u1, u1} α (Multiset.{u1} α) (Multiset.hasMem.{u1} α) a s) -> (p a)) -> (p (Multiset.prod.{u1} α _inst_1 s))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] {s : Multiset.{u1} α} (p : α -> Prop), (forall (a : α) (b : α), (p a) -> (p b) -> (p (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b))) -> (Ne.{succ u1} (Multiset.{u1} α) s (EmptyCollection.emptyCollection.{u1} (Multiset.{u1} α) (Multiset.instEmptyCollectionMultiset.{u1} α))) -> (forall (a : α), (Membership.mem.{u1, u1} α (Multiset.{u1} α) (Multiset.instMembershipMultiset.{u1} α) a s) -> (p a)) -> (p (Multiset.prod.{u1} α _inst_1 s))
Case conversion may be inaccurate. Consider using '#align multiset.prod_induction_nonempty Multiset.prod_induction_nonemptyₓ'. -/
@[to_additive]
theorem prod_induction_nonempty (p : α → Prop) (p_mul : ∀ a b, p a → p b → p (a * b)) (hs : s ≠ ∅)
(p_s : ∀ a ∈ s, p a) : p s.Prod := by
revert s
refine' Multiset.induction _ _
· intro h
exfalso
simpa using h
intro a s hs hsa hpsa
rw [prod_cons]
by_cases hs_empty : s = ∅
· simp [hs_empty, hpsa a]
have hps : ∀ x, x ∈ s → p x := fun x hxs => hpsa x (mem_cons_of_mem hxs)
exact p_mul a s.prod (hpsa a (mem_cons_self a s)) (hs hs_empty hps)
#align multiset.prod_induction_nonempty Multiset.prod_induction_nonempty
#align multiset.sum_induction_nonempty Multiset.sum_induction_nonempty
/- warning: multiset.prod_dvd_prod_of_le -> Multiset.prod_dvd_prod_of_le is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] {s : Multiset.{u1} α} {t : Multiset.{u1} α}, (LE.le.{u1} (Multiset.{u1} α) (Preorder.toLE.{u1} (Multiset.{u1} α) (PartialOrder.toPreorder.{u1} (Multiset.{u1} α) (Multiset.partialOrder.{u1} α))) s t) -> (Dvd.Dvd.{u1} α (semigroupDvd.{u1} α (Monoid.toSemigroup.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) (Multiset.prod.{u1} α _inst_1 s) (Multiset.prod.{u1} α _inst_1 t))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] {s : Multiset.{u1} α} {t : Multiset.{u1} α}, (LE.le.{u1} (Multiset.{u1} α) (Preorder.toLE.{u1} (Multiset.{u1} α) (PartialOrder.toPreorder.{u1} (Multiset.{u1} α) (Multiset.instPartialOrderMultiset.{u1} α))) s t) -> (Dvd.dvd.{u1} α (semigroupDvd.{u1} α (Monoid.toSemigroup.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) (Multiset.prod.{u1} α _inst_1 s) (Multiset.prod.{u1} α _inst_1 t))
Case conversion may be inaccurate. Consider using '#align multiset.prod_dvd_prod_of_le Multiset.prod_dvd_prod_of_leₓ'. -/
theorem prod_dvd_prod_of_le (h : s ≤ t) : s.Prod ∣ t.Prod :=
by
obtain ⟨z, rfl⟩ := exists_add_of_le h
simp only [prod_add, dvd_mul_right]
#align multiset.prod_dvd_prod_of_le Multiset.prod_dvd_prod_of_le
end CommMonoid
#print Multiset.prod_dvd_prod_of_dvd /-
theorem prod_dvd_prod_of_dvd [CommMonoid β] {S : Multiset α} (g1 g2 : α → β)
(h : ∀ a ∈ S, g1 a ∣ g2 a) : (Multiset.map g1 S).Prod ∣ (Multiset.map g2 S).Prod :=
by
apply Multiset.induction_on' S; · simp
intro a T haS _ IH
simp [mul_dvd_mul (h a haS) IH]
#align multiset.prod_dvd_prod_of_dvd Multiset.prod_dvd_prod_of_dvd
-/
section AddCommMonoid
variable [AddCommMonoid α]
/- warning: multiset.sum_add_monoid_hom -> Multiset.sumAddMonoidHom is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : AddCommMonoid.{u1} α], AddMonoidHom.{u1, u1} (Multiset.{u1} α) α (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.orderedCancelAddCommMonoid.{u1} α)))))) (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : AddCommMonoid.{u1} α], AddMonoidHom.{u1, u1} (Multiset.{u1} α) α (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))
Case conversion may be inaccurate. Consider using '#align multiset.sum_add_monoid_hom Multiset.sumAddMonoidHomₓ'. -/
/-- `multiset.sum`, the sum of the elements of a multiset, promoted to a morphism of
`add_comm_monoid`s. -/
def sumAddMonoidHom : Multiset α →+ α where
toFun := sum
map_zero' := sum_zero
map_add' := sum_add
#align multiset.sum_add_monoid_hom Multiset.sumAddMonoidHom
/- warning: multiset.coe_sum_add_monoid_hom -> Multiset.coe_sumAddMonoidHom is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : AddCommMonoid.{u1} α], Eq.{succ u1} ((fun (_x : AddMonoidHom.{u1, u1} (Multiset.{u1} α) α (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.orderedCancelAddCommMonoid.{u1} α)))))) (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) => (Multiset.{u1} α) -> α) (Multiset.sumAddMonoidHom.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (AddMonoidHom.{u1, u1} (Multiset.{u1} α) α (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.orderedCancelAddCommMonoid.{u1} α)))))) (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (fun (_x : AddMonoidHom.{u1, u1} (Multiset.{u1} α) α (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.orderedCancelAddCommMonoid.{u1} α)))))) (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) => (Multiset.{u1} α) -> α) (AddMonoidHom.hasCoeToFun.{u1, u1} (Multiset.{u1} α) α (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.orderedCancelAddCommMonoid.{u1} α)))))) (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Multiset.sumAddMonoidHom.{u1} α _inst_1)) (Multiset.sum.{u1} α _inst_1)
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : AddCommMonoid.{u1} α], Eq.{succ u1} (forall (a : Multiset.{u1} α), (fun ([email protected]._hyg.403 : Multiset.{u1} α) => α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (AddMonoidHom.{u1, u1} (Multiset.{u1} α) α (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Multiset.{u1} α) (fun (_x : Multiset.{u1} α) => (fun ([email protected]._hyg.403 : Multiset.{u1} α) => α) _x) (AddHomClass.toFunLike.{u1, u1, u1} (AddMonoidHom.{u1, u1} (Multiset.{u1} α) α (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Multiset.{u1} α) α (AddZeroClass.toAdd.{u1} (Multiset.{u1} α) (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α))))))) (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} (AddMonoidHom.{u1, u1} (Multiset.{u1} α) α (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Multiset.{u1} α) α (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1)) (AddMonoidHom.addMonoidHomClass.{u1, u1} (Multiset.{u1} α) α (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))))) (Multiset.sumAddMonoidHom.{u1} α _inst_1)) (Multiset.sum.{u1} α _inst_1)
Case conversion may be inaccurate. Consider using '#align multiset.coe_sum_add_monoid_hom Multiset.coe_sumAddMonoidHomₓ'. -/
@[simp]
theorem coe_sumAddMonoidHom : (sumAddMonoidHom : Multiset α → α) = sum :=
rfl
#align multiset.coe_sum_add_monoid_hom Multiset.coe_sumAddMonoidHom
end AddCommMonoid
section CommMonoidWithZero
variable [CommMonoidWithZero α]
/- warning: multiset.prod_eq_zero -> Multiset.prod_eq_zero is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : CommMonoidWithZero.{u1} α] {s : Multiset.{u1} α}, (Membership.Mem.{u1, u1} α (Multiset.{u1} α) (Multiset.hasMem.{u1} α) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CommMonoidWithZero.toMonoidWithZero.{u1} α _inst_1))))))) s) -> (Eq.{succ u1} α (Multiset.prod.{u1} α (CommMonoidWithZero.toCommMonoid.{u1} α _inst_1) s) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CommMonoidWithZero.toMonoidWithZero.{u1} α _inst_1))))))))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : CommMonoidWithZero.{u1} α] {s : Multiset.{u1} α}, (Membership.mem.{u1, u1} α (Multiset.{u1} α) (Multiset.instMembershipMultiset.{u1} α) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (CommMonoidWithZero.toZero.{u1} α _inst_1))) s) -> (Eq.{succ u1} α (Multiset.prod.{u1} α (CommMonoidWithZero.toCommMonoid.{u1} α _inst_1) s) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (CommMonoidWithZero.toZero.{u1} α _inst_1))))
Case conversion may be inaccurate. Consider using '#align multiset.prod_eq_zero Multiset.prod_eq_zeroₓ'. -/
theorem prod_eq_zero {s : Multiset α} (h : (0 : α) ∈ s) : s.Prod = 0 :=
by
rcases Multiset.exists_cons_of_mem h with ⟨s', hs'⟩
simp [hs', Multiset.prod_cons]
#align multiset.prod_eq_zero Multiset.prod_eq_zero
variable [NoZeroDivisors α] [Nontrivial α] {s : Multiset α}
/- warning: multiset.prod_eq_zero_iff -> Multiset.prod_eq_zero_iff is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : CommMonoidWithZero.{u1} α] [_inst_2 : NoZeroDivisors.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CommMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CommMonoidWithZero.toMonoidWithZero.{u1} α _inst_1))))] [_inst_3 : Nontrivial.{u1} α] {s : Multiset.{u1} α}, Iff (Eq.{succ u1} α (Multiset.prod.{u1} α (CommMonoidWithZero.toCommMonoid.{u1} α _inst_1) s) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CommMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))))))) (Membership.Mem.{u1, u1} α (Multiset.{u1} α) (Multiset.hasMem.{u1} α) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CommMonoidWithZero.toMonoidWithZero.{u1} α _inst_1))))))) s)
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : CommMonoidWithZero.{u1} α] [_inst_2 : NoZeroDivisors.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CommMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (CommMonoidWithZero.toZero.{u1} α _inst_1)] [_inst_3 : Nontrivial.{u1} α] {s : Multiset.{u1} α}, Iff (Eq.{succ u1} α (Multiset.prod.{u1} α (CommMonoidWithZero.toCommMonoid.{u1} α _inst_1) s) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (CommMonoidWithZero.toZero.{u1} α _inst_1)))) (Membership.mem.{u1, u1} α (Multiset.{u1} α) (Multiset.instMembershipMultiset.{u1} α) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (CommMonoidWithZero.toZero.{u1} α _inst_1))) s)
Case conversion may be inaccurate. Consider using '#align multiset.prod_eq_zero_iff Multiset.prod_eq_zero_iffₓ'. -/
theorem prod_eq_zero_iff : s.Prod = 0 ↔ (0 : α) ∈ s :=
Quotient.inductionOn s fun l => by
rw [quot_mk_to_coe, coe_prod]
exact List.prod_eq_zero_iff
#align multiset.prod_eq_zero_iff Multiset.prod_eq_zero_iff
/- warning: multiset.prod_ne_zero -> Multiset.prod_ne_zero is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : CommMonoidWithZero.{u1} α] [_inst_2 : NoZeroDivisors.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CommMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CommMonoidWithZero.toMonoidWithZero.{u1} α _inst_1))))] [_inst_3 : Nontrivial.{u1} α] {s : Multiset.{u1} α}, (Not (Membership.Mem.{u1, u1} α (Multiset.{u1} α) (Multiset.hasMem.{u1} α) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CommMonoidWithZero.toMonoidWithZero.{u1} α _inst_1))))))) s)) -> (Ne.{succ u1} α (Multiset.prod.{u1} α (CommMonoidWithZero.toCommMonoid.{u1} α _inst_1) s) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CommMonoidWithZero.toMonoidWithZero.{u1} α _inst_1))))))))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : CommMonoidWithZero.{u1} α] [_inst_2 : NoZeroDivisors.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CommMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (CommMonoidWithZero.toZero.{u1} α _inst_1)] [_inst_3 : Nontrivial.{u1} α] {s : Multiset.{u1} α}, (Not (Membership.mem.{u1, u1} α (Multiset.{u1} α) (Multiset.instMembershipMultiset.{u1} α) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (CommMonoidWithZero.toZero.{u1} α _inst_1))) s)) -> (Ne.{succ u1} α (Multiset.prod.{u1} α (CommMonoidWithZero.toCommMonoid.{u1} α _inst_1) s) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (CommMonoidWithZero.toZero.{u1} α _inst_1))))
Case conversion may be inaccurate. Consider using '#align multiset.prod_ne_zero Multiset.prod_ne_zeroₓ'. -/
theorem prod_ne_zero (h : (0 : α) ∉ s) : s.Prod ≠ 0 :=
mt prod_eq_zero_iff.1 h
#align multiset.prod_ne_zero Multiset.prod_ne_zero
end CommMonoidWithZero
section DivisionCommMonoid
variable [DivisionCommMonoid α] {m : Multiset ι} {f g : ι → α}
/- warning: multiset.prod_map_inv' -> Multiset.prod_map_inv' is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : DivisionCommMonoid.{u1} α] (m : Multiset.{u1} α), Eq.{succ u1} α (Multiset.prod.{u1} α (DivisionCommMonoid.toCommMonoid.{u1} α _inst_1) (Multiset.map.{u1, u1} α α (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) m)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) (Multiset.prod.{u1} α (DivisionCommMonoid.toCommMonoid.{u1} α _inst_1) m))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : DivisionCommMonoid.{u1} α] (m : Multiset.{u1} α), Eq.{succ u1} α (Multiset.prod.{u1} α (DivisionCommMonoid.toCommMonoid.{u1} α _inst_1) (Multiset.map.{u1, u1} α α (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))))) m)) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) (Multiset.prod.{u1} α (DivisionCommMonoid.toCommMonoid.{u1} α _inst_1) m))
Case conversion may be inaccurate. Consider using '#align multiset.prod_map_inv' Multiset.prod_map_inv'ₓ'. -/
@[to_additive]
theorem prod_map_inv' (m : Multiset α) : (m.map Inv.inv).Prod = m.Prod⁻¹ :=
m.prod_hom (invMonoidHom : α →* α)
#align multiset.prod_map_inv' Multiset.prod_map_inv'
#align multiset.sum_map_neg' Multiset.sum_map_neg'
/- warning: multiset.prod_map_inv -> Multiset.prod_map_inv is a dubious translation:
lean 3 declaration is
forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : DivisionCommMonoid.{u2} α] {m : Multiset.{u1} ι} {f : ι -> α}, Eq.{succ u2} α (Multiset.prod.{u2} α (DivisionCommMonoid.toCommMonoid.{u2} α _inst_1) (Multiset.map.{u1, u2} ι α (fun (i : ι) => Inv.inv.{u2} α (DivInvMonoid.toHasInv.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α (DivisionCommMonoid.toDivisionMonoid.{u2} α _inst_1))) (f i)) m)) (Inv.inv.{u2} α (DivInvMonoid.toHasInv.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α (DivisionCommMonoid.toDivisionMonoid.{u2} α _inst_1))) (Multiset.prod.{u2} α (DivisionCommMonoid.toCommMonoid.{u2} α _inst_1) (Multiset.map.{u1, u2} ι α f m)))
but is expected to have type
forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : DivisionCommMonoid.{u2} α] {m : Multiset.{u1} ι} {f : ι -> α}, Eq.{succ u2} α (Multiset.prod.{u2} α (DivisionCommMonoid.toCommMonoid.{u2} α _inst_1) (Multiset.map.{u1, u2} ι α (fun (i : ι) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (DivisionCommMonoid.toDivisionMonoid.{u2} α _inst_1)))) (f i)) m)) (Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (DivisionCommMonoid.toDivisionMonoid.{u2} α _inst_1)))) (Multiset.prod.{u2} α (DivisionCommMonoid.toCommMonoid.{u2} α _inst_1) (Multiset.map.{u1, u2} ι α f m)))
Case conversion may be inaccurate. Consider using '#align multiset.prod_map_inv Multiset.prod_map_invₓ'. -/
@[simp, to_additive]
theorem prod_map_inv : (m.map fun i => (f i)⁻¹).Prod = (m.map f).Prod⁻¹ :=
by
convert(m.map f).prod_map_inv'
rw [map_map]
#align multiset.prod_map_inv Multiset.prod_map_inv
#align multiset.sum_map_neg Multiset.sum_map_neg
/- warning: multiset.prod_map_div -> Multiset.prod_map_div is a dubious translation:
lean 3 declaration is
forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : DivisionCommMonoid.{u2} α] {m : Multiset.{u1} ι} {f : ι -> α} {g : ι -> α}, Eq.{succ u2} α (Multiset.prod.{u2} α (DivisionCommMonoid.toCommMonoid.{u2} α _inst_1) (Multiset.map.{u1, u2} ι α (fun (i : ι) => HDiv.hDiv.{u2, u2, u2} α α α (instHDiv.{u2} α (DivInvMonoid.toHasDiv.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α (DivisionCommMonoid.toDivisionMonoid.{u2} α _inst_1)))) (f i) (g i)) m)) (HDiv.hDiv.{u2, u2, u2} α α α (instHDiv.{u2} α (DivInvMonoid.toHasDiv.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α (DivisionCommMonoid.toDivisionMonoid.{u2} α _inst_1)))) (Multiset.prod.{u2} α (DivisionCommMonoid.toCommMonoid.{u2} α _inst_1) (Multiset.map.{u1, u2} ι α f m)) (Multiset.prod.{u2} α (DivisionCommMonoid.toCommMonoid.{u2} α _inst_1) (Multiset.map.{u1, u2} ι α g m)))
but is expected to have type
forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : DivisionCommMonoid.{u2} α] {m : Multiset.{u1} ι} {f : ι -> α} {g : ι -> α}, Eq.{succ u2} α (Multiset.prod.{u2} α (DivisionCommMonoid.toCommMonoid.{u2} α _inst_1) (Multiset.map.{u1, u2} ι α (fun (i : ι) => HDiv.hDiv.{u2, u2, u2} α α α (instHDiv.{u2} α (DivInvMonoid.toDiv.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α (DivisionCommMonoid.toDivisionMonoid.{u2} α _inst_1)))) (f i) (g i)) m)) (HDiv.hDiv.{u2, u2, u2} α α α (instHDiv.{u2} α (DivInvMonoid.toDiv.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α (DivisionCommMonoid.toDivisionMonoid.{u2} α _inst_1)))) (Multiset.prod.{u2} α (DivisionCommMonoid.toCommMonoid.{u2} α _inst_1) (Multiset.map.{u1, u2} ι α f m)) (Multiset.prod.{u2} α (DivisionCommMonoid.toCommMonoid.{u2} α _inst_1) (Multiset.map.{u1, u2} ι α g m)))
Case conversion may be inaccurate. Consider using '#align multiset.prod_map_div Multiset.prod_map_divₓ'. -/
@[simp, to_additive]
theorem prod_map_div : (m.map fun i => f i / g i).Prod = (m.map f).Prod / (m.map g).Prod :=
m.prod_hom₂ (· / ·) mul_div_mul_comm (div_one _) _ _
#align multiset.prod_map_div Multiset.prod_map_div
#align multiset.sum_map_sub Multiset.sum_map_sub
#print Multiset.prod_map_zpow /-
@[to_additive]
theorem prod_map_zpow {n : ℤ} : (m.map fun i => f i ^ n).Prod = (m.map f).Prod ^ n :=
by
convert(m.map f).prod_hom (zpowGroupHom _ : α →* α)
rw [map_map]
rfl
#align multiset.prod_map_zpow Multiset.prod_map_zpow
#align multiset.sum_map_zsmul Multiset.sum_map_zsmul
-/
end DivisionCommMonoid
section NonUnitalNonAssocSemiring
variable [NonUnitalNonAssocSemiring α] {a : α} {s : Multiset ι} {f : ι → α}
/- warning: multiset.sum_map_mul_left -> Multiset.sum_map_mul_left is a dubious translation:
lean 3 declaration is
forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : NonUnitalNonAssocSemiring.{u2} α] {a : α} {s : Multiset.{u1} ι} {f : ι -> α}, Eq.{succ u2} α (Multiset.sum.{u2} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α _inst_1) (Multiset.map.{u1, u2} ι α (fun (i : ι) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α _inst_1))) a (f i)) s)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α _inst_1))) a (Multiset.sum.{u2} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α _inst_1) (Multiset.map.{u1, u2} ι α f s)))
but is expected to have type
forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : NonUnitalNonAssocSemiring.{u2} α] {a : α} {s : Multiset.{u1} ι} {f : ι -> α}, Eq.{succ u2} α (Multiset.sum.{u2} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α _inst_1) (Multiset.map.{u1, u2} ι α (fun (i : ι) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α _inst_1)) a (f i)) s)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α _inst_1)) a (Multiset.sum.{u2} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α _inst_1) (Multiset.map.{u1, u2} ι α f s)))
Case conversion may be inaccurate. Consider using '#align multiset.sum_map_mul_left Multiset.sum_map_mul_leftₓ'. -/
theorem sum_map_mul_left : sum (s.map fun i => a * f i) = a * sum (s.map f) :=
Multiset.induction_on s (by simp) fun i s ih => by simp [ih, mul_add]
#align multiset.sum_map_mul_left Multiset.sum_map_mul_left
/- warning: multiset.sum_map_mul_right -> Multiset.sum_map_mul_right is a dubious translation:
lean 3 declaration is
forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : NonUnitalNonAssocSemiring.{u2} α] {a : α} {s : Multiset.{u1} ι} {f : ι -> α}, Eq.{succ u2} α (Multiset.sum.{u2} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α _inst_1) (Multiset.map.{u1, u2} ι α (fun (i : ι) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α _inst_1))) (f i) a) s)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α _inst_1))) (Multiset.sum.{u2} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α _inst_1) (Multiset.map.{u1, u2} ι α f s)) a)
but is expected to have type
forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : NonUnitalNonAssocSemiring.{u2} α] {a : α} {s : Multiset.{u1} ι} {f : ι -> α}, Eq.{succ u2} α (Multiset.sum.{u2} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α _inst_1) (Multiset.map.{u1, u2} ι α (fun (i : ι) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α _inst_1)) (f i) a) s)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α _inst_1)) (Multiset.sum.{u2} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α _inst_1) (Multiset.map.{u1, u2} ι α f s)) a)
Case conversion may be inaccurate. Consider using '#align multiset.sum_map_mul_right Multiset.sum_map_mul_rightₓ'. -/
theorem sum_map_mul_right : sum (s.map fun i => f i * a) = sum (s.map f) * a :=
Multiset.induction_on s (by simp) fun a s ih => by simp [ih, add_mul]
#align multiset.sum_map_mul_right Multiset.sum_map_mul_right
end NonUnitalNonAssocSemiring
section Semiring
variable [Semiring α]
#print Multiset.dvd_sum /-
theorem dvd_sum {a : α} {s : Multiset α} : (∀ x ∈ s, a ∣ x) → a ∣ s.Sum :=
Multiset.induction_on s (fun _ => dvd_zero _) fun x s ih h =>
by
rw [sum_cons]
exact dvd_add (h _ (mem_cons_self _ _)) (ih fun y hy => h _ <| mem_cons.2 <| Or.inr hy)
#align multiset.dvd_sum Multiset.dvd_sum
-/
end Semiring
/-! ### Order -/
section OrderedCommMonoid
variable [OrderedCommMonoid α] {s t : Multiset α} {a : α}
/- warning: multiset.one_le_prod_of_one_le -> Multiset.one_le_prod_of_one_le is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} α] {s : Multiset.{u1} α}, (forall (x : α), (Membership.Mem.{u1, u1} α (Multiset.{u1} α) (Multiset.hasMem.{u1} α) x s) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommMonoid.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1))))))) x)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommMonoid.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1))))))) (Multiset.prod.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1) s))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} α] {s : Multiset.{u1} α}, (forall (x : α), (Membership.mem.{u1, u1} α (Multiset.{u1} α) (Multiset.instMembershipMultiset.{u1} α) x s) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommMonoid.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1))))) x)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommMonoid.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1))))) (Multiset.prod.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1) s))
Case conversion may be inaccurate. Consider using '#align multiset.one_le_prod_of_one_le Multiset.one_le_prod_of_one_leₓ'. -/
@[to_additive sum_nonneg]
theorem one_le_prod_of_one_le : (∀ x ∈ s, (1 : α) ≤ x) → 1 ≤ s.Prod :=
Quotient.inductionOn s fun l hl => by simpa using List.one_le_prod_of_one_le hl
#align multiset.one_le_prod_of_one_le Multiset.one_le_prod_of_one_le
#align multiset.sum_nonneg Multiset.sum_nonneg
/- warning: multiset.single_le_prod -> Multiset.single_le_prod is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} α] {s : Multiset.{u1} α}, (forall (x : α), (Membership.Mem.{u1, u1} α (Multiset.{u1} α) (Multiset.hasMem.{u1} α) x s) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommMonoid.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1))))))) x)) -> (forall (x : α), (Membership.Mem.{u1, u1} α (Multiset.{u1} α) (Multiset.hasMem.{u1} α) x s) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommMonoid.toPartialOrder.{u1} α _inst_1))) x (Multiset.prod.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1) s)))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} α] {s : Multiset.{u1} α}, (forall (x : α), (Membership.mem.{u1, u1} α (Multiset.{u1} α) (Multiset.instMembershipMultiset.{u1} α) x s) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommMonoid.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1))))) x)) -> (forall (x : α), (Membership.mem.{u1, u1} α (Multiset.{u1} α) (Multiset.instMembershipMultiset.{u1} α) x s) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommMonoid.toPartialOrder.{u1} α _inst_1))) x (Multiset.prod.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1) s)))
Case conversion may be inaccurate. Consider using '#align multiset.single_le_prod Multiset.single_le_prodₓ'. -/
@[to_additive]
theorem single_le_prod : (∀ x ∈ s, (1 : α) ≤ x) → ∀ x ∈ s, x ≤ s.Prod :=
Quotient.inductionOn s fun l hl x hx => by simpa using List.single_le_prod hl x hx
#align multiset.single_le_prod Multiset.single_le_prod
#align multiset.single_le_sum Multiset.single_le_sum
/- warning: multiset.prod_le_pow_card -> Multiset.prod_le_pow_card is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} α] (s : Multiset.{u1} α) (n : α), (forall (x : α), (Membership.Mem.{u1, u1} α (Multiset.{u1} α) (Multiset.hasMem.{u1} α) x s) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommMonoid.toPartialOrder.{u1} α _inst_1))) x n)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommMonoid.toPartialOrder.{u1} α _inst_1))) (Multiset.prod.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1) s) (HPow.hPow.{u1, 0, u1} α Nat α (instHPow.{u1, 0} α Nat (Monoid.Pow.{u1} α (CommMonoid.toMonoid.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1)))) n (coeFn.{succ u1, succ u1} (AddMonoidHom.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.orderedCancelAddCommMonoid.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (fun (_x : AddMonoidHom.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.orderedCancelAddCommMonoid.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) => (Multiset.{u1} α) -> Nat) (AddMonoidHom.hasCoeToFun.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.orderedCancelAddCommMonoid.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (Multiset.card.{u1} α) s)))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} α] (s : Multiset.{u1} α) (n : α), (forall (x : α), (Membership.mem.{u1, u1} α (Multiset.{u1} α) (Multiset.instMembershipMultiset.{u1} α) x s) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommMonoid.toPartialOrder.{u1} α _inst_1))) x n)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommMonoid.toPartialOrder.{u1} α _inst_1))) (Multiset.prod.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1) s) (HPow.hPow.{u1, 0, u1} α ((fun ([email protected]._hyg.403 : Multiset.{u1} α) => Nat) s) α (instHPow.{u1, 0} α ((fun ([email protected]._hyg.403 : Multiset.{u1} α) => Nat) s) (Monoid.Pow.{u1} α (CommMonoid.toMonoid.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1)))) n (FunLike.coe.{succ u1, succ u1, 1} (AddMonoidHom.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (Multiset.{u1} α) (fun (_x : Multiset.{u1} α) => (fun ([email protected]._hyg.403 : Multiset.{u1} α) => Nat) _x) (AddHomClass.toFunLike.{u1, u1, 0} (AddMonoidHom.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (Multiset.{u1} α) Nat (AddZeroClass.toAdd.{u1} (Multiset.{u1} α) (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α))))))) (AddZeroClass.toAdd.{0} Nat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (AddMonoidHomClass.toAddHomClass.{u1, u1, 0} (AddMonoidHom.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoidHom.addMonoidHomClass.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)))) (Multiset.card.{u1} α) s)))
Case conversion may be inaccurate. Consider using '#align multiset.prod_le_pow_card Multiset.prod_le_pow_cardₓ'. -/
@[to_additive sum_le_card_nsmul]
theorem prod_le_pow_card (s : Multiset α) (n : α) (h : ∀ x ∈ s, x ≤ n) : s.Prod ≤ n ^ s.card :=
by
induction s using Quotient.inductionOn
simpa using List.prod_le_pow_card _ _ h
#align multiset.prod_le_pow_card Multiset.prod_le_pow_card
#align multiset.sum_le_card_nsmul Multiset.sum_le_card_nsmul
/- warning: multiset.all_one_of_le_one_le_of_prod_eq_one -> Multiset.all_one_of_le_one_le_of_prod_eq_one is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} α] {s : Multiset.{u1} α}, (forall (x : α), (Membership.Mem.{u1, u1} α (Multiset.{u1} α) (Multiset.hasMem.{u1} α) x s) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommMonoid.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1))))))) x)) -> (Eq.{succ u1} α (Multiset.prod.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1) s) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1)))))))) -> (forall (x : α), (Membership.Mem.{u1, u1} α (Multiset.{u1} α) (Multiset.hasMem.{u1} α) x s) -> (Eq.{succ u1} α x (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1)))))))))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} α] {s : Multiset.{u1} α}, (forall (x : α), (Membership.mem.{u1, u1} α (Multiset.{u1} α) (Multiset.instMembershipMultiset.{u1} α) x s) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommMonoid.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1))))) x)) -> (Eq.{succ u1} α (Multiset.prod.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1) s) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1)))))) -> (forall (x : α), (Membership.mem.{u1, u1} α (Multiset.{u1} α) (Multiset.instMembershipMultiset.{u1} α) x s) -> (Eq.{succ u1} α x (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1)))))))
Case conversion may be inaccurate. Consider using '#align multiset.all_one_of_le_one_le_of_prod_eq_one Multiset.all_one_of_le_one_le_of_prod_eq_oneₓ'. -/
@[to_additive all_zero_of_le_zero_le_of_sum_eq_zero]
theorem all_one_of_le_one_le_of_prod_eq_one :
(∀ x ∈ s, (1 : α) ≤ x) → s.Prod = 1 → ∀ x ∈ s, x = (1 : α) :=
by
apply Quotient.inductionOn s
simp only [quot_mk_to_coe, coe_prod, mem_coe]
exact fun l => List.all_one_of_le_one_le_of_prod_eq_one
#align multiset.all_one_of_le_one_le_of_prod_eq_one Multiset.all_one_of_le_one_le_of_prod_eq_one
#align multiset.all_zero_of_le_zero_le_of_sum_eq_zero Multiset.all_zero_of_le_zero_le_of_sum_eq_zero
#print Multiset.prod_le_prod_of_rel_le /-
@[to_additive]
theorem prod_le_prod_of_rel_le (h : s.Rel (· ≤ ·) t) : s.Prod ≤ t.Prod :=
by
induction' h with _ _ _ _ rh _ rt
· rfl
· rw [prod_cons, prod_cons]
exact mul_le_mul' rh rt
#align multiset.prod_le_prod_of_rel_le Multiset.prod_le_prod_of_rel_le
#align multiset.sum_le_sum_of_rel_le Multiset.sum_le_sum_of_rel_le
-/
/- warning: multiset.prod_map_le_prod_map -> Multiset.prod_map_le_prod_map is a dubious translation:
lean 3 declaration is
forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : OrderedCommMonoid.{u2} α] {s : Multiset.{u1} ι} (f : ι -> α) (g : ι -> α), (forall (i : ι), (Membership.Mem.{u1, u1} ι (Multiset.{u1} ι) (Multiset.hasMem.{u1} ι) i s) -> (LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (OrderedCommMonoid.toPartialOrder.{u2} α _inst_1))) (f i) (g i))) -> (LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (OrderedCommMonoid.toPartialOrder.{u2} α _inst_1))) (Multiset.prod.{u2} α (OrderedCommMonoid.toCommMonoid.{u2} α _inst_1) (Multiset.map.{u1, u2} ι α f s)) (Multiset.prod.{u2} α (OrderedCommMonoid.toCommMonoid.{u2} α _inst_1) (Multiset.map.{u1, u2} ι α g s)))
but is expected to have type
forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} α] {s : Multiset.{u2} ι} (f : ι -> α) (g : ι -> α), (forall (i : ι), (Membership.mem.{u2, u2} ι (Multiset.{u2} ι) (Multiset.instMembershipMultiset.{u2} ι) i s) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommMonoid.toPartialOrder.{u1} α _inst_1))) (f i) (g i))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommMonoid.toPartialOrder.{u1} α _inst_1))) (Multiset.prod.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1) (Multiset.map.{u2, u1} ι α f s)) (Multiset.prod.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1) (Multiset.map.{u2, u1} ι α g s)))
Case conversion may be inaccurate. Consider using '#align multiset.prod_map_le_prod_map Multiset.prod_map_le_prod_mapₓ'. -/
@[to_additive]
theorem prod_map_le_prod_map {s : Multiset ι} (f : ι → α) (g : ι → α) (h : ∀ i, i ∈ s → f i ≤ g i) :
(s.map f).Prod ≤ (s.map g).Prod :=
prod_le_prod_of_rel_le <| rel_map.2 <| rel_refl_of_refl_on h
#align multiset.prod_map_le_prod_map Multiset.prod_map_le_prod_map
#align multiset.sum_map_le_sum_map Multiset.sum_map_le_sum_map
#print Multiset.prod_map_le_prod /-
@[to_additive]
theorem prod_map_le_prod (f : α → α) (h : ∀ x, x ∈ s → f x ≤ x) : (s.map f).Prod ≤ s.Prod :=
prod_le_prod_of_rel_le <| rel_map_left.2 <| rel_refl_of_refl_on h
#align multiset.prod_map_le_prod Multiset.prod_map_le_prod
#align multiset.sum_map_le_sum Multiset.sum_map_le_sum
-/
#print Multiset.prod_le_prod_map /-
@[to_additive]
theorem prod_le_prod_map (f : α → α) (h : ∀ x, x ∈ s → x ≤ f x) : s.Prod ≤ (s.map f).Prod :=
@prod_map_le_prod αᵒᵈ _ _ f h
#align multiset.prod_le_prod_map Multiset.prod_le_prod_map
#align multiset.sum_le_sum_map Multiset.sum_le_sum_map
-/
/- warning: multiset.pow_card_le_prod -> Multiset.pow_card_le_prod is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} α] {s : Multiset.{u1} α} {a : α}, (forall (x : α), (Membership.Mem.{u1, u1} α (Multiset.{u1} α) (Multiset.hasMem.{u1} α) x s) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommMonoid.toPartialOrder.{u1} α _inst_1))) a x)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommMonoid.toPartialOrder.{u1} α _inst_1))) (HPow.hPow.{u1, 0, u1} α Nat α (instHPow.{u1, 0} α Nat (Monoid.Pow.{u1} α (CommMonoid.toMonoid.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1)))) a (coeFn.{succ u1, succ u1} (AddMonoidHom.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.orderedCancelAddCommMonoid.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (fun (_x : AddMonoidHom.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.orderedCancelAddCommMonoid.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) => (Multiset.{u1} α) -> Nat) (AddMonoidHom.hasCoeToFun.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.orderedCancelAddCommMonoid.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (Multiset.card.{u1} α) s)) (Multiset.prod.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1) s))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} α] {s : Multiset.{u1} α} {a : α}, (forall (x : α), (Membership.mem.{u1, u1} α (Multiset.{u1} α) (Multiset.instMembershipMultiset.{u1} α) x s) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommMonoid.toPartialOrder.{u1} α _inst_1))) a x)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommMonoid.toPartialOrder.{u1} α _inst_1))) (HPow.hPow.{u1, 0, u1} α ((fun ([email protected]._hyg.403 : Multiset.{u1} α) => Nat) s) α (instHPow.{u1, 0} α ((fun ([email protected]._hyg.403 : Multiset.{u1} α) => Nat) s) (Monoid.Pow.{u1} α (CommMonoid.toMonoid.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1)))) a (FunLike.coe.{succ u1, succ u1, 1} (AddMonoidHom.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (Multiset.{u1} α) (fun (_x : Multiset.{u1} α) => (fun ([email protected]._hyg.403 : Multiset.{u1} α) => Nat) _x) (AddHomClass.toFunLike.{u1, u1, 0} (AddMonoidHom.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (Multiset.{u1} α) Nat (AddZeroClass.toAdd.{u1} (Multiset.{u1} α) (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α))))))) (AddZeroClass.toAdd.{0} Nat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (AddMonoidHomClass.toAddHomClass.{u1, u1, 0} (AddMonoidHom.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoidHom.addMonoidHomClass.{u1, 0} (Multiset.{u1} α) Nat (AddMonoid.toAddZeroClass.{u1} (Multiset.{u1} α) (AddRightCancelMonoid.toAddMonoid.{u1} (Multiset.{u1} α) (AddCancelMonoid.toAddRightCancelMonoid.{u1} (Multiset.{u1} α) (AddCancelCommMonoid.toAddCancelMonoid.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toCancelAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)))))) (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)))) (Multiset.card.{u1} α) s)) (Multiset.prod.{u1} α (OrderedCommMonoid.toCommMonoid.{u1} α _inst_1) s))
Case conversion may be inaccurate. Consider using '#align multiset.pow_card_le_prod Multiset.pow_card_le_prodₓ'. -/
@[to_additive card_nsmul_le_sum]
theorem pow_card_le_prod (h : ∀ x ∈ s, a ≤ x) : a ^ s.card ≤ s.Prod :=
by
rw [← Multiset.prod_replicate, ← Multiset.map_const]
exact prod_map_le_prod _ h
#align multiset.pow_card_le_prod Multiset.pow_card_le_prod
#align multiset.card_nsmul_le_sum Multiset.card_nsmul_le_sum
end OrderedCommMonoid
/- warning: multiset.prod_nonneg -> Multiset.prod_nonneg is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : OrderedCommSemiring.{u1} α] {m : Multiset.{u1} α}, (forall (a : α), (Membership.Mem.{u1, u1} α (Multiset.{u1} α) (Multiset.hasMem.{u1} α) a m) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α (OrderedSemiring.toOrderedAddCommMonoid.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (OrderedSemiring.toSemiring.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α _inst_1))))))))) a)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α (OrderedSemiring.toOrderedAddCommMonoid.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (OrderedSemiring.toSemiring.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α _inst_1))))))))) (Multiset.prod.{u1} α (CommSemiring.toCommMonoid.{u1} α (OrderedCommSemiring.toCommSemiring.{u1} α _inst_1)) m))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : OrderedCommSemiring.{u1} α] {m : Multiset.{u1} α}, (forall (a : α), (Membership.mem.{u1, u1} α (Multiset.{u1} α) (Multiset.instMembershipMultiset.{u1} α) a m) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedSemiring.toPartialOrder.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (CommMonoidWithZero.toZero.{u1} α (CommSemiring.toCommMonoidWithZero.{u1} α (OrderedCommSemiring.toCommSemiring.{u1} α _inst_1))))) a)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedSemiring.toPartialOrder.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (CommMonoidWithZero.toZero.{u1} α (CommSemiring.toCommMonoidWithZero.{u1} α (OrderedCommSemiring.toCommSemiring.{u1} α _inst_1))))) (Multiset.prod.{u1} α (CommSemiring.toCommMonoid.{u1} α (OrderedCommSemiring.toCommSemiring.{u1} α _inst_1)) m))
Case conversion may be inaccurate. Consider using '#align multiset.prod_nonneg Multiset.prod_nonnegₓ'. -/
theorem prod_nonneg [OrderedCommSemiring α] {m : Multiset α} (h : ∀ a ∈ m, (0 : α) ≤ a) :
0 ≤ m.Prod := by
revert h
refine' m.induction_on _ _
· rintro -
rw [prod_zero]
exact zero_le_one
intro a s hs ih
rw [prod_cons]
exact mul_nonneg (ih _ <| mem_cons_self _ _) (hs fun a ha => ih _ <| mem_cons_of_mem ha)
#align multiset.prod_nonneg Multiset.prod_nonneg
/- warning: multiset.prod_eq_one -> Multiset.prod_eq_one is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] {m : Multiset.{u1} α}, (forall (x : α), (Membership.Mem.{u1, u1} α (Multiset.{u1} α) (Multiset.hasMem.{u1} α) x m) -> (Eq.{succ u1} α x (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))))))) -> (Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 m) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))))))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : CommMonoid.{u1} α] {m : Multiset.{u1} α}, (forall (x : α), (Membership.mem.{u1, u1} α (Multiset.{u1} α) (Multiset.instMembershipMultiset.{u1} α) x m) -> (Eq.{succ u1} α x (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))))) -> (Eq.{succ u1} α (Multiset.prod.{u1} α _inst_1 m) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))))
Case conversion may be inaccurate. Consider using '#align multiset.prod_eq_one Multiset.prod_eq_oneₓ'. -/
/-- Slightly more general version of `multiset.prod_eq_one_iff` for a non-ordered `monoid` -/
@[to_additive
"Slightly more general version of `multiset.sum_eq_zero_iff`\n for a non-ordered `add_monoid`"]
theorem prod_eq_one [CommMonoid α] {m : Multiset α} (h : ∀ x ∈ m, x = (1 : α)) : m.Prod = 1 :=
by
induction' m using Quotient.inductionOn with l
simp [List.prod_eq_one h]
#align multiset.prod_eq_one Multiset.prod_eq_one
#align multiset.sum_eq_zero Multiset.sum_eq_zero
#print Multiset.le_prod_of_mem /-
@[to_additive]
theorem le_prod_of_mem [CanonicallyOrderedMonoid α] {m : Multiset α} {a : α} (h : a ∈ m) :
a ≤ m.Prod := by
obtain ⟨m', rfl⟩ := exists_cons_of_mem h
rw [prod_cons]
exact _root_.le_mul_right (le_refl a)
#align multiset.le_prod_of_mem Multiset.le_prod_of_mem
#align multiset.le_sum_of_mem Multiset.le_sum_of_mem
-/
/- warning: multiset.le_prod_of_submultiplicative_on_pred -> Multiset.le_prod_of_submultiplicative_on_pred is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : OrderedCommMonoid.{u2} β] (f : α -> β) (p : α -> Prop), (Eq.{succ u2} β (f (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (MulOneClass.toHasOne.{u2} β (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β (OrderedCommMonoid.toCommMonoid.{u2} β _inst_2)))))))) -> (p (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))))) -> (forall (a : α) (b : α), (p a) -> (p b) -> (LE.le.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedCommMonoid.toPartialOrder.{u2} β _inst_2))) (f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b)) (HMul.hMul.{u2, u2, u2} β β β (instHMul.{u2} β (MulOneClass.toHasMul.{u2} β (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β (OrderedCommMonoid.toCommMonoid.{u2} β _inst_2))))) (f a) (f b)))) -> (forall (a : α) (b : α), (p a) -> (p b) -> (p (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b))) -> (forall (s : Multiset.{u1} α), (forall (a : α), (Membership.Mem.{u1, u1} α (Multiset.{u1} α) (Multiset.hasMem.{u1} α) a s) -> (p a)) -> (LE.le.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedCommMonoid.toPartialOrder.{u2} β _inst_2))) (f (Multiset.prod.{u1} α _inst_1 s)) (Multiset.prod.{u2} β (OrderedCommMonoid.toCommMonoid.{u2} β _inst_2) (Multiset.map.{u1, u2} α β f s))))
but is expected to have type
forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : CommMonoid.{u2} α] [_inst_2 : OrderedCommMonoid.{u1} β] (f : α -> β) (p : α -> Prop), (Eq.{succ u1} β (f (OfNat.ofNat.{u2} α 1 (One.toOfNat1.{u2} α (Monoid.toOne.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (Monoid.toOne.{u1} β (CommMonoid.toMonoid.{u1} β (OrderedCommMonoid.toCommMonoid.{u1} β _inst_2)))))) -> (p (OfNat.ofNat.{u2} α 1 (One.toOfNat1.{u2} α (Monoid.toOne.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1))))) -> (forall (a : α) (b : α), (p a) -> (p b) -> (LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OrderedCommMonoid.toPartialOrder.{u1} β _inst_2))) (f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)))) a b)) (HMul.hMul.{u1, u1, u1} β β β (instHMul.{u1} β (MulOneClass.toMul.{u1} β (Monoid.toMulOneClass.{u1} β (CommMonoid.toMonoid.{u1} β (OrderedCommMonoid.toCommMonoid.{u1} β _inst_2))))) (f a) (f b)))) -> (forall (a : α) (b : α), (p a) -> (p b) -> (p (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)))) a b))) -> (forall (s : Multiset.{u2} α), (forall (a : α), (Membership.mem.{u2, u2} α (Multiset.{u2} α) (Multiset.instMembershipMultiset.{u2} α) a s) -> (p a)) -> (LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OrderedCommMonoid.toPartialOrder.{u1} β _inst_2))) (f (Multiset.prod.{u2} α _inst_1 s)) (Multiset.prod.{u1} β (OrderedCommMonoid.toCommMonoid.{u1} β _inst_2) (Multiset.map.{u2, u1} α β f s))))
Case conversion may be inaccurate. Consider using '#align multiset.le_prod_of_submultiplicative_on_pred Multiset.le_prod_of_submultiplicative_on_predₓ'. -/
@[to_additive le_sum_of_subadditive_on_pred]
theorem le_prod_of_submultiplicative_on_pred [CommMonoid α] [OrderedCommMonoid β] (f : α → β)
(p : α → Prop) (h_one : f 1 = 1) (hp_one : p 1)
(h_mul : ∀ a b, p a → p b → f (a * b) ≤ f a * f b) (hp_mul : ∀ a b, p a → p b → p (a * b))
(s : Multiset α) (hps : ∀ a, a ∈ s → p a) : f s.Prod ≤ (s.map f).Prod :=
by
revert s
refine' Multiset.induction _ _
· simp [le_of_eq h_one]
intro a s hs hpsa
have hps : ∀ x, x ∈ s → p x := fun x hx => hpsa x (mem_cons_of_mem hx)
have hp_prod : p s.prod := prod_induction p s hp_mul hp_one hps
rw [prod_cons, map_cons, prod_cons]
exact (h_mul a s.prod (hpsa a (mem_cons_self a s)) hp_prod).trans (mul_le_mul_left' (hs hps) _)
#align multiset.le_prod_of_submultiplicative_on_pred Multiset.le_prod_of_submultiplicative_on_pred
#align multiset.le_sum_of_subadditive_on_pred Multiset.le_sum_of_subadditive_on_pred
/- warning: multiset.le_prod_of_submultiplicative -> Multiset.le_prod_of_submultiplicative is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : OrderedCommMonoid.{u2} β] (f : α -> β), (Eq.{succ u2} β (f (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (MulOneClass.toHasOne.{u2} β (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β (OrderedCommMonoid.toCommMonoid.{u2} β _inst_2)))))))) -> (forall (a : α) (b : α), LE.le.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedCommMonoid.toPartialOrder.{u2} β _inst_2))) (f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b)) (HMul.hMul.{u2, u2, u2} β β β (instHMul.{u2} β (MulOneClass.toHasMul.{u2} β (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β (OrderedCommMonoid.toCommMonoid.{u2} β _inst_2))))) (f a) (f b))) -> (forall (s : Multiset.{u1} α), LE.le.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedCommMonoid.toPartialOrder.{u2} β _inst_2))) (f (Multiset.prod.{u1} α _inst_1 s)) (Multiset.prod.{u2} β (OrderedCommMonoid.toCommMonoid.{u2} β _inst_2) (Multiset.map.{u1, u2} α β f s)))
but is expected to have type
forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : CommMonoid.{u2} α] [_inst_2 : OrderedCommMonoid.{u1} β] (f : α -> β), (Eq.{succ u1} β (f (OfNat.ofNat.{u2} α 1 (One.toOfNat1.{u2} α (Monoid.toOne.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (Monoid.toOne.{u1} β (CommMonoid.toMonoid.{u1} β (OrderedCommMonoid.toCommMonoid.{u1} β _inst_2)))))) -> (forall (a : α) (b : α), LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OrderedCommMonoid.toPartialOrder.{u1} β _inst_2))) (f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)))) a b)) (HMul.hMul.{u1, u1, u1} β β β (instHMul.{u1} β (MulOneClass.toMul.{u1} β (Monoid.toMulOneClass.{u1} β (CommMonoid.toMonoid.{u1} β (OrderedCommMonoid.toCommMonoid.{u1} β _inst_2))))) (f a) (f b))) -> (forall (s : Multiset.{u2} α), LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OrderedCommMonoid.toPartialOrder.{u1} β _inst_2))) (f (Multiset.prod.{u2} α _inst_1 s)) (Multiset.prod.{u1} β (OrderedCommMonoid.toCommMonoid.{u1} β _inst_2) (Multiset.map.{u2, u1} α β f s)))
Case conversion may be inaccurate. Consider using '#align multiset.le_prod_of_submultiplicative Multiset.le_prod_of_submultiplicativeₓ'. -/
@[to_additive le_sum_of_subadditive]
theorem le_prod_of_submultiplicative [CommMonoid α] [OrderedCommMonoid β] (f : α → β)
(h_one : f 1 = 1) (h_mul : ∀ a b, f (a * b) ≤ f a * f b) (s : Multiset α) :
f s.Prod ≤ (s.map f).Prod :=
le_prod_of_submultiplicative_on_pred f (fun i => True) h_one trivial (fun x y _ _ => h_mul x y)
(by simp) s (by simp)
#align multiset.le_prod_of_submultiplicative Multiset.le_prod_of_submultiplicative
#align multiset.le_sum_of_subadditive Multiset.le_sum_of_subadditive
/- warning: multiset.le_prod_nonempty_of_submultiplicative_on_pred -> Multiset.le_prod_nonempty_of_submultiplicative_on_pred is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : OrderedCommMonoid.{u2} β] (f : α -> β) (p : α -> Prop), (forall (a : α) (b : α), (p a) -> (p b) -> (LE.le.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedCommMonoid.toPartialOrder.{u2} β _inst_2))) (f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b)) (HMul.hMul.{u2, u2, u2} β β β (instHMul.{u2} β (MulOneClass.toHasMul.{u2} β (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β (OrderedCommMonoid.toCommMonoid.{u2} β _inst_2))))) (f a) (f b)))) -> (forall (a : α) (b : α), (p a) -> (p b) -> (p (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b))) -> (forall (s : Multiset.{u1} α), (Ne.{succ u1} (Multiset.{u1} α) s (EmptyCollection.emptyCollection.{u1} (Multiset.{u1} α) (Multiset.hasEmptyc.{u1} α))) -> (forall (a : α), (Membership.Mem.{u1, u1} α (Multiset.{u1} α) (Multiset.hasMem.{u1} α) a s) -> (p a)) -> (LE.le.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedCommMonoid.toPartialOrder.{u2} β _inst_2))) (f (Multiset.prod.{u1} α _inst_1 s)) (Multiset.prod.{u2} β (OrderedCommMonoid.toCommMonoid.{u2} β _inst_2) (Multiset.map.{u1, u2} α β f s))))
but is expected to have type
forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : CommMonoid.{u2} α] [_inst_2 : OrderedCommMonoid.{u1} β] (f : α -> β) (p : α -> Prop), (forall (a : α) (b : α), (p a) -> (p b) -> (LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OrderedCommMonoid.toPartialOrder.{u1} β _inst_2))) (f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)))) a b)) (HMul.hMul.{u1, u1, u1} β β β (instHMul.{u1} β (MulOneClass.toMul.{u1} β (Monoid.toMulOneClass.{u1} β (CommMonoid.toMonoid.{u1} β (OrderedCommMonoid.toCommMonoid.{u1} β _inst_2))))) (f a) (f b)))) -> (forall (a : α) (b : α), (p a) -> (p b) -> (p (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)))) a b))) -> (forall (s : Multiset.{u2} α), (Ne.{succ u2} (Multiset.{u2} α) s (EmptyCollection.emptyCollection.{u2} (Multiset.{u2} α) (Multiset.instEmptyCollectionMultiset.{u2} α))) -> (forall (a : α), (Membership.mem.{u2, u2} α (Multiset.{u2} α) (Multiset.instMembershipMultiset.{u2} α) a s) -> (p a)) -> (LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OrderedCommMonoid.toPartialOrder.{u1} β _inst_2))) (f (Multiset.prod.{u2} α _inst_1 s)) (Multiset.prod.{u1} β (OrderedCommMonoid.toCommMonoid.{u1} β _inst_2) (Multiset.map.{u2, u1} α β f s))))
Case conversion may be inaccurate. Consider using '#align multiset.le_prod_nonempty_of_submultiplicative_on_pred Multiset.le_prod_nonempty_of_submultiplicative_on_predₓ'. -/
@[to_additive le_sum_nonempty_of_subadditive_on_pred]
theorem le_prod_nonempty_of_submultiplicative_on_pred [CommMonoid α] [OrderedCommMonoid β]
(f : α → β) (p : α → Prop) (h_mul : ∀ a b, p a → p b → f (a * b) ≤ f a * f b)
(hp_mul : ∀ a b, p a → p b → p (a * b)) (s : Multiset α) (hs_nonempty : s ≠ ∅)
(hs : ∀ a, a ∈ s → p a) : f s.Prod ≤ (s.map f).Prod :=
by
revert s
refine' Multiset.induction _ _
· intro h
exfalso
exact h rfl
rintro a s hs hsa_nonempty hsa_prop
rw [prod_cons, map_cons, prod_cons]
by_cases hs_empty : s = ∅
· simp [hs_empty]
have hsa_restrict : ∀ x, x ∈ s → p x := fun x hx => hsa_prop x (mem_cons_of_mem hx)
have hp_sup : p s.prod := prod_induction_nonempty p hp_mul hs_empty hsa_restrict
have hp_a : p a := hsa_prop a (mem_cons_self a s)
exact (h_mul a _ hp_a hp_sup).trans (mul_le_mul_left' (hs hs_empty hsa_restrict) _)
#align multiset.le_prod_nonempty_of_submultiplicative_on_pred Multiset.le_prod_nonempty_of_submultiplicative_on_pred
#align multiset.le_sum_nonempty_of_subadditive_on_pred Multiset.le_sum_nonempty_of_subadditive_on_pred
/- warning: multiset.le_prod_nonempty_of_submultiplicative -> Multiset.le_prod_nonempty_of_submultiplicative is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : OrderedCommMonoid.{u2} β] (f : α -> β), (forall (a : α) (b : α), LE.le.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedCommMonoid.toPartialOrder.{u2} β _inst_2))) (f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)))) a b)) (HMul.hMul.{u2, u2, u2} β β β (instHMul.{u2} β (MulOneClass.toHasMul.{u2} β (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β (OrderedCommMonoid.toCommMonoid.{u2} β _inst_2))))) (f a) (f b))) -> (forall (s : Multiset.{u1} α), (Ne.{succ u1} (Multiset.{u1} α) s (EmptyCollection.emptyCollection.{u1} (Multiset.{u1} α) (Multiset.hasEmptyc.{u1} α))) -> (LE.le.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedCommMonoid.toPartialOrder.{u2} β _inst_2))) (f (Multiset.prod.{u1} α _inst_1 s)) (Multiset.prod.{u2} β (OrderedCommMonoid.toCommMonoid.{u2} β _inst_2) (Multiset.map.{u1, u2} α β f s))))
but is expected to have type
forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : CommMonoid.{u2} α] [_inst_2 : OrderedCommMonoid.{u1} β] (f : α -> β), (forall (a : α) (b : α), LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OrderedCommMonoid.toPartialOrder.{u1} β _inst_2))) (f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)))) a b)) (HMul.hMul.{u1, u1, u1} β β β (instHMul.{u1} β (MulOneClass.toMul.{u1} β (Monoid.toMulOneClass.{u1} β (CommMonoid.toMonoid.{u1} β (OrderedCommMonoid.toCommMonoid.{u1} β _inst_2))))) (f a) (f b))) -> (forall (s : Multiset.{u2} α), (Ne.{succ u2} (Multiset.{u2} α) s (EmptyCollection.emptyCollection.{u2} (Multiset.{u2} α) (Multiset.instEmptyCollectionMultiset.{u2} α))) -> (LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OrderedCommMonoid.toPartialOrder.{u1} β _inst_2))) (f (Multiset.prod.{u2} α _inst_1 s)) (Multiset.prod.{u1} β (OrderedCommMonoid.toCommMonoid.{u1} β _inst_2) (Multiset.map.{u2, u1} α β f s))))
Case conversion may be inaccurate. Consider using '#align multiset.le_prod_nonempty_of_submultiplicative Multiset.le_prod_nonempty_of_submultiplicativeₓ'. -/
@[to_additive le_sum_nonempty_of_subadditive]
theorem le_prod_nonempty_of_submultiplicative [CommMonoid α] [OrderedCommMonoid β] (f : α → β)
(h_mul : ∀ a b, f (a * b) ≤ f a * f b) (s : Multiset α) (hs_nonempty : s ≠ ∅) :
f s.Prod ≤ (s.map f).Prod :=
le_prod_nonempty_of_submultiplicative_on_pred f (fun i => True) (by simp [h_mul]) (by simp) s
hs_nonempty (by simp)
#align multiset.le_prod_nonempty_of_submultiplicative Multiset.le_prod_nonempty_of_submultiplicative
#align multiset.le_sum_nonempty_of_subadditive Multiset.le_sum_nonempty_of_subadditive
/- warning: multiset.sum_map_singleton -> Multiset.sum_map_singleton is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} (s : Multiset.{u1} α), Eq.{succ u1} (Multiset.{u1} α) (Multiset.sum.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.orderedCancelAddCommMonoid.{u1} α)) (Multiset.map.{u1, u1} α (Multiset.{u1} α) (fun (a : α) => Singleton.singleton.{u1, u1} α (Multiset.{u1} α) (Multiset.hasSingleton.{u1} α) a) s)) s
but is expected to have type
forall {α : Type.{u1}} (s : Multiset.{u1} α), Eq.{succ u1} (Multiset.{u1} α) (Multiset.sum.{u1} (Multiset.{u1} α) (OrderedCancelAddCommMonoid.toAddCommMonoid.{u1} (Multiset.{u1} α) (Multiset.instOrderedCancelAddCommMonoidMultiset.{u1} α)) (Multiset.map.{u1, u1} α (Multiset.{u1} α) (fun (a : α) => Singleton.singleton.{u1, u1} α (Multiset.{u1} α) (Multiset.instSingletonMultiset.{u1} α) a) s)) s
Case conversion may be inaccurate. Consider using '#align multiset.sum_map_singleton Multiset.sum_map_singletonₓ'. -/
@[simp]
theorem sum_map_singleton (s : Multiset α) : (s.map fun a => ({a} : Multiset α)).Sum = s :=
Multiset.induction_on s (by simp) (by simp)
#align multiset.sum_map_singleton Multiset.sum_map_singleton
/- warning: multiset.abs_sum_le_sum_abs -> Multiset.abs_sum_le_sum_abs is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} [_inst_1 : LinearOrderedAddCommGroup.{u1} α] {s : Multiset.{u1} α}, LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (LinearOrder.toLattice.{u1} α (LinearOrderedAddCommGroup.toLinearOrder.{u1} α _inst_1))))) (Multiset.sum.{u1} α (AddCommGroup.toAddCommMonoid.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) s)) (Multiset.sum.{u1} α (AddCommGroup.toAddCommMonoid.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) (Multiset.map.{u1, u1} α α (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (LinearOrder.toLattice.{u1} α (LinearOrderedAddCommGroup.toLinearOrder.{u1} α _inst_1)))))) s))
but is expected to have type
forall {α : Type.{u1}} [_inst_1 : LinearOrderedAddCommGroup.{u1} α] {s : Multiset.{u1} α}, LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α (LinearOrderedAddCommGroup.toLinearOrder.{u1} α _inst_1)))))) (Multiset.sum.{u1} α (OrderedCancelAddCommMonoid.toAddCommMonoid.{u1} α (LinearOrderedCancelAddCommMonoid.toOrderedCancelAddCommMonoid.{u1} α (LinearOrderedAddCommGroup.toLinearOrderedAddCancelCommMonoid.{u1} α _inst_1))) s)) (Multiset.sum.{u1} α (OrderedCancelAddCommMonoid.toAddCommMonoid.{u1} α (LinearOrderedCancelAddCommMonoid.toOrderedCancelAddCommMonoid.{u1} α (LinearOrderedAddCommGroup.toLinearOrderedAddCancelCommMonoid.{u1} α _inst_1))) (Multiset.map.{u1, u1} α α (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α (LinearOrderedAddCommGroup.toLinearOrder.{u1} α _inst_1))))))) s))
Case conversion may be inaccurate. Consider using '#align multiset.abs_sum_le_sum_abs Multiset.abs_sum_le_sum_absₓ'. -/
theorem abs_sum_le_sum_abs [LinearOrderedAddCommGroup α] {s : Multiset α} :
abs s.Sum ≤ (s.map abs).Sum :=
le_sum_of_subadditive _ abs_zero abs_add s
#align multiset.abs_sum_le_sum_abs Multiset.abs_sum_le_sum_abs
#print Multiset.sum_nat_mod /-
theorem sum_nat_mod (s : Multiset ℕ) (n : ℕ) : s.Sum % n = (s.map (· % n)).Sum % n := by
induction s using Multiset.induction <;> simp [Nat.add_mod, *]
#align multiset.sum_nat_mod Multiset.sum_nat_mod
-/
#print Multiset.prod_nat_mod /-
theorem prod_nat_mod (s : Multiset ℕ) (n : ℕ) : s.Prod % n = (s.map (· % n)).Prod % n := by
induction s using Multiset.induction <;> simp [Nat.mul_mod, *]
#align multiset.prod_nat_mod Multiset.prod_nat_mod
-/
/- warning: multiset.sum_int_mod -> Multiset.sum_int_mod is a dubious translation:
lean 3 declaration is
forall (s : Multiset.{0} Int) (n : Int), Eq.{1} Int (HMod.hMod.{0, 0, 0} Int Int Int (instHMod.{0} Int Int.hasMod) (Multiset.sum.{0} Int Int.addCommMonoid s) n) (HMod.hMod.{0, 0, 0} Int Int Int (instHMod.{0} Int Int.hasMod) (Multiset.sum.{0} Int Int.addCommMonoid (Multiset.map.{0, 0} Int Int (fun (_x : Int) => HMod.hMod.{0, 0, 0} Int Int Int (instHMod.{0} Int Int.hasMod) _x n) s)) n)
but is expected to have type
forall (s : Multiset.{0} Int) (n : Int), Eq.{1} Int (HMod.hMod.{0, 0, 0} Int Int Int (instHMod.{0} Int Int.instModInt_1) (Multiset.sum.{0} Int Int.instAddCommMonoidInt s) n) (HMod.hMod.{0, 0, 0} Int Int Int (instHMod.{0} Int Int.instModInt_1) (Multiset.sum.{0} Int Int.instAddCommMonoidInt (Multiset.map.{0, 0} Int Int (fun (_x : Int) => HMod.hMod.{0, 0, 0} Int Int Int (instHMod.{0} Int Int.instModInt_1) _x n) s)) n)
Case conversion may be inaccurate. Consider using '#align multiset.sum_int_mod Multiset.sum_int_modₓ'. -/
theorem sum_int_mod (s : Multiset ℤ) (n : ℤ) : s.Sum % n = (s.map (· % n)).Sum % n := by
induction s using Multiset.induction <;> simp [Int.add_emod, *]
#align multiset.sum_int_mod Multiset.sum_int_mod
/- warning: multiset.prod_int_mod -> Multiset.prod_int_mod is a dubious translation:
lean 3 declaration is
forall (s : Multiset.{0} Int) (n : Int), Eq.{1} Int (HMod.hMod.{0, 0, 0} Int Int Int (instHMod.{0} Int Int.hasMod) (Multiset.prod.{0} Int Int.commMonoid s) n) (HMod.hMod.{0, 0, 0} Int Int Int (instHMod.{0} Int Int.hasMod) (Multiset.prod.{0} Int Int.commMonoid (Multiset.map.{0, 0} Int Int (fun (_x : Int) => HMod.hMod.{0, 0, 0} Int Int Int (instHMod.{0} Int Int.hasMod) _x n) s)) n)
but is expected to have type
forall (s : Multiset.{0} Int) (n : Int), Eq.{1} Int (HMod.hMod.{0, 0, 0} Int Int Int (instHMod.{0} Int Int.instModInt_1) (Multiset.prod.{0} Int Int.instCommMonoidInt s) n) (HMod.hMod.{0, 0, 0} Int Int Int (instHMod.{0} Int Int.instModInt_1) (Multiset.prod.{0} Int Int.instCommMonoidInt (Multiset.map.{0, 0} Int Int (fun (_x : Int) => HMod.hMod.{0, 0, 0} Int Int Int (instHMod.{0} Int Int.instModInt_1) _x n) s)) n)
Case conversion may be inaccurate. Consider using '#align multiset.prod_int_mod Multiset.prod_int_modₓ'. -/
theorem prod_int_mod (s : Multiset ℤ) (n : ℤ) : s.Prod % n = (s.map (· % n)).Prod % n := by
induction s using Multiset.induction <;> simp [Int.mul_emod, *]
#align multiset.prod_int_mod Multiset.prod_int_mod
end Multiset
/- warning: map_multiset_prod -> map_multiset_prod is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : CommMonoid.{u2} β] {F : Type.{u3}} [_inst_3 : MonoidHomClass.{u3, u1, u2} F α β (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2))] (f : F) (s : Multiset.{u1} α), Eq.{succ u2} β (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u3, u1, u2} F α β (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) (MulOneClass.toHasMul.{u2} β (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F α β (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2)) _inst_3))) f (Multiset.prod.{u1} α _inst_1 s)) (Multiset.prod.{u2} β _inst_2 (Multiset.map.{u1, u2} α β (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u3, u1, u2} F α β (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1))) (MulOneClass.toHasMul.{u2} β (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F α β (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2)) _inst_3))) f) s))
but is expected to have type
forall {α : Type.{u3}} {β : Type.{u2}} [_inst_1 : CommMonoid.{u3} α] [_inst_2 : CommMonoid.{u2} β] {F : Type.{u1}} [_inst_3 : MonoidHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (CommMonoid.toMonoid.{u3} α _inst_1)) (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2))] (f : F) (s : Multiset.{u3} α), Eq.{succ u2} ((fun ([email protected]._hyg.2391 : α) => β) (Multiset.prod.{u3} α _inst_1 s)) (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun ([email protected]._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (CommMonoid.toMonoid.{u3} α _inst_1))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (CommMonoid.toMonoid.{u3} α _inst_1)) (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2)) _inst_3)) f (Multiset.prod.{u3} α _inst_1 s)) (Multiset.prod.{u2} β _inst_2 (Multiset.map.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun ([email protected]._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (CommMonoid.toMonoid.{u3} α _inst_1))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (CommMonoid.toMonoid.{u3} α _inst_1)) (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2)) _inst_3)) f) s))
Case conversion may be inaccurate. Consider using '#align map_multiset_prod map_multiset_prodₓ'. -/
@[to_additive]
theorem map_multiset_prod [CommMonoid α] [CommMonoid β] {F : Type _} [MonoidHomClass F α β] (f : F)
(s : Multiset α) : f s.Prod = (s.map f).Prod :=
(s.prod_hom f).symm
#align map_multiset_prod map_multiset_prod
#align map_multiset_sum map_multiset_sum
/- warning: monoid_hom.map_multiset_prod -> MonoidHom.map_multiset_prod is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : CommMonoid.{u2} β] (f : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2))) (s : Multiset.{u1} α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2))) (fun (_x : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2))) => α -> β) (MonoidHom.hasCoeToFun.{u1, u2} α β (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2))) f (Multiset.prod.{u1} α _inst_1 s)) (Multiset.prod.{u2} β _inst_2 (Multiset.map.{u1, u2} α β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2))) (fun (_x : MonoidHom.{u1, u2} α β (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2))) => α -> β) (MonoidHom.hasCoeToFun.{u1, u2} α β (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_1)) (Monoid.toMulOneClass.{u2} β (CommMonoid.toMonoid.{u2} β _inst_2))) f) s))
but is expected to have type
forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : CommMonoid.{u2} α] [_inst_2 : CommMonoid.{u1} β] (f : MonoidHom.{u2, u1} α β (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)) (Monoid.toMulOneClass.{u1} β (CommMonoid.toMonoid.{u1} β _inst_2))) (s : Multiset.{u2} α), Eq.{succ u1} ((fun ([email protected]._hyg.2391 : α) => β) (Multiset.prod.{u2} α _inst_1 s)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α β (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)) (Monoid.toMulOneClass.{u1} β (CommMonoid.toMonoid.{u1} β _inst_2))) α (fun (_x : α) => (fun ([email protected]._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α β (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)) (Monoid.toMulOneClass.{u1} β (CommMonoid.toMonoid.{u1} β _inst_2))) α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1))) (MulOneClass.toMul.{u1} β (Monoid.toMulOneClass.{u1} β (CommMonoid.toMonoid.{u1} β _inst_2))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α β (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)) (Monoid.toMulOneClass.{u1} β (CommMonoid.toMonoid.{u1} β _inst_2))) α β (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)) (Monoid.toMulOneClass.{u1} β (CommMonoid.toMonoid.{u1} β _inst_2)) (MonoidHom.monoidHomClass.{u2, u1} α β (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)) (Monoid.toMulOneClass.{u1} β (CommMonoid.toMonoid.{u1} β _inst_2))))) f (Multiset.prod.{u2} α _inst_1 s)) (Multiset.prod.{u1} β _inst_2 (Multiset.map.{u2, u1} α β (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α β (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)) (Monoid.toMulOneClass.{u1} β (CommMonoid.toMonoid.{u1} β _inst_2))) α (fun (_x : α) => (fun ([email protected]._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α β (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)) (Monoid.toMulOneClass.{u1} β (CommMonoid.toMonoid.{u1} β _inst_2))) α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1))) (MulOneClass.toMul.{u1} β (Monoid.toMulOneClass.{u1} β (CommMonoid.toMonoid.{u1} β _inst_2))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α β (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)) (Monoid.toMulOneClass.{u1} β (CommMonoid.toMonoid.{u1} β _inst_2))) α β (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)) (Monoid.toMulOneClass.{u1} β (CommMonoid.toMonoid.{u1} β _inst_2)) (MonoidHom.monoidHomClass.{u2, u1} α β (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_1)) (Monoid.toMulOneClass.{u1} β (CommMonoid.toMonoid.{u1} β _inst_2))))) f) s))
Case conversion may be inaccurate. Consider using '#align monoid_hom.map_multiset_prod MonoidHom.map_multiset_prodₓ'. -/
@[to_additive]
protected theorem MonoidHom.map_multiset_prod [CommMonoid α] [CommMonoid β] (f : α →* β)
(s : Multiset α) : f s.Prod = (s.map f).Prod :=
(s.prod_hom f).symm
#align monoid_hom.map_multiset_prod MonoidHom.map_multiset_prod
#align add_monoid_hom.map_multiset_sum AddMonoidHom.map_multiset_sum
|
Although he was a merciful warrior, David still had to fight Israel’s enemies. This account is strange in that it seems the battles described here could have been avoided if only Hanun, the leader of Ammon, had taken David’s sincere condolences at face value. But Hanun listened to his advisers, who gave him extremely poor advice! It could be that they truly, though erroneously, believed David’s messengers were spies. Or these nobles of Ammon may have turned against David in hopes of provoking him and gaining a victory over Israel.
Whatever the reason, David’s men were humiliated by their Ammonite hosts with no provocation. Then the Ammonites raised an army of 33,000 mercenaries from neighboring Aramean states — another act of unprovoked aggression against Israel. David’s army scored a resounding victory under the leadership of Joab and his brother Abishai. But the Arameans apparently did not learn their lesson, because they regrouped, sent for reinforcements, and came at Israel again! This time David himself led the armies of God to victory — the last recorded triumph of Israel’s warrior-king before his affair with Bathsheba.
What does the humiliation of David’s messengers suggest about the Ammonites’ motives?
What do Amos 1:13 and Zephaniah 2:8–11 tell us about the history of the Ammonites’ relationship with Israel?
Why do you think God gave Joab such a great victory, despite the fact that Joab had committed treachery and murder?
Why did David himself lead the final battle against the Arameans?
Anyone whose well-intentioned motives have been misconstrued — whether accidentally or purposely — can identify with the envoys of David in this story. Since all of us have felt the pain of this rejection, let us resolve to be extremely careful in judging the motives of others! |
theory Analyze_Containern
imports
Iptables_Semantics.Parser
begin
parse_iptables_save docker_fw="iptables-save.topos4.1.established"
thm docker_fw_def
thm docker_fw_FORWARD_default_policy_def
definition "unfolded_FORWARD = unfold_ruleset_FORWARD docker_fw_FORWARD_default_policy (map_of_string_ipv4 (docker_fw))"
value[code] "map (quote_rewrite \<circ> common_primitive_rule_toString) (unfolded_FORWARD)"
value[code] "map (quote_rewrite \<circ> common_primitive_rule_toString) (upper_closure unfolded_FORWARD)"
value[code] "upper_closure (packet_assume_new unfolded_FORWARD)"
lemma "check_simple_fw_preconditions (upper_closure (optimize_matches abstract_for_simple_firewall
(upper_closure (packet_assume_new unfolded_FORWARD))))" by eval
lemma "simple_fw_valid (to_simple_firewall (upper_closure
(optimize_matches abstract_for_simple_firewall (upper_closure (packet_assume_new unfolded_FORWARD)))))"
by eval
lemma "simple_fw_valid (to_simple_firewall (lower_closure
(optimize_matches abstract_for_simple_firewall (lower_closure (packet_assume_new unfolded_FORWARD)))))"
by eval
value[code] "map simple_rule_ipv4_toString (to_simple_firewall (upper_closure
(optimize_matches abstract_for_simple_firewall (upper_closure (packet_assume_new unfolded_FORWARD)))))"
value[code] "map simple_rule_ipv4_toString (to_simple_firewall (lower_closure
(optimize_matches abstract_for_simple_firewall (lower_closure (packet_assume_new unfolded_FORWARD)))))"
(*Interfaces be gone! necessary for ip partition!*)
definition preprocess where
"preprocess unfold closure ipassmt def fw \<equiv> to_simple_firewall (closure
(optimize_matches (abstract_primitive (\<lambda>r. case r of Pos a \<Rightarrow> is_Iiface a \<or> is_Oiface a \<or> is_L4_Flags a
| Neg a \<Rightarrow> is_Iiface a \<or> is_Oiface a \<or> is_Prot a \<or> is_L4_Flags a))
(closure
(iface_try_rewrite ipassmt None
(closure
(packet_assume_new
(unfold def (map_of fw))))))))"
definition preprocess_ESTABLISHED where
"preprocess_ESTABLISHED unfold closure ipassmt def fw \<equiv> to_simple_firewall (closure
(optimize_matches (abstract_primitive (\<lambda>r. case r of Pos a \<Rightarrow> is_Iiface a \<or> is_Oiface a \<or> is_L4_Flags a
| Neg a \<Rightarrow> is_Iiface a \<or> is_Oiface a \<or> is_Prot a \<or> is_L4_Flags a))
(closure
(iface_try_rewrite ipassmt None
(closure
(optimize_matches (ctstate_assume_state CT_Established)
(unfold def (map_of fw))))))))"
(*incomplete, but we won't need it anyway*)
definition ipassmt :: "(iface \<times> (32 word \<times> nat) list) list" where
"ipassmt = [(Iface ''lo'', [(ipv4addr_of_dotdecimal (127,0,0,0),8)]),
(Iface ''br-b74b417b331f'', [(ipv4addr_of_dotdecimal (10,0,0,0),8)])
]"
lemma "distinct (map fst ipassmt)" by eval
lemma "ipassmt_sanity_nowildcards (map_of ipassmt)" by eval
value[code] "map_of_ipassmt ipassmt"
value[code] "access_matrix_pretty_ipv4 parts_connection_ssh
(preprocess unfold_ruleset_FORWARD upper_closure ipassmt docker_fw_FORWARD_default_policy docker_fw)"
value[code] "access_matrix_pretty_ipv4 parts_connection_ssh
(preprocess_ESTABLISHED unfold_ruleset_FORWARD upper_closure ipassmt docker_fw_FORWARD_default_policy docker_fw)"
value[code] "access_matrix_pretty_ipv4 parts_connection_http
(preprocess unfold_ruleset_FORWARD upper_closure ipassmt docker_fw_FORWARD_default_policy docker_fw)"
value[code] "access_matrix_pretty_ipv4 parts_connection_http
(preprocess_ESTABLISHED unfold_ruleset_FORWARD upper_closure ipassmt docker_fw_FORWARD_default_policy docker_fw)"
parse_iptables_save docker_fw2="iptables-save.topos4.1"
thm docker_fw2_def
thm docker_fw2_FORWARD_default_policy_def
value[code] "access_matrix_pretty_ipv4 parts_connection_ssh
(preprocess unfold_ruleset_FORWARD upper_closure ipassmt docker_fw2_FORWARD_default_policy docker_fw2)"
value[code] "access_matrix_pretty_ipv4 parts_connection_ssh
(preprocess_ESTABLISHED unfold_ruleset_FORWARD upper_closure ipassmt docker_fw2_FORWARD_default_policy docker_fw2)"
value[code] "access_matrix_pretty_ipv4 parts_connection_http
(preprocess unfold_ruleset_FORWARD upper_closure ipassmt docker_fw2_FORWARD_default_policy docker_fw2)"
value[code] "access_matrix_pretty_ipv4 parts_connection_http
(preprocess_ESTABLISHED unfold_ruleset_FORWARD upper_closure ipassmt docker_fw2_FORWARD_default_policy docker_fw2)"
text\<open>Only one of the flows additionally allows answers for ESTABLISHED connections\<close>
lemma "let new = access_matrix_pretty_ipv4 parts_connection_http
(preprocess unfold_ruleset_FORWARD upper_closure ipassmt docker_fw2_FORWARD_default_policy docker_fw2);
est = access_matrix_pretty_ipv4 parts_connection_http
(preprocess_ESTABLISHED unfold_ruleset_FORWARD upper_closure ipassmt docker_fw2_FORWARD_default_policy docker_fw2)
in fst est = fst new \<and>
set (snd est) - set (snd new) = {(''0.0.0.0'', ''10.0.0.4'')}" by eval
parse_iptables_save docker_fw_initial="iptables-save.topos1"
thm docker_fw_initial_def
thm docker_fw_initial_FORWARD_default_policy_def
(*The original docker0 bridge is still in this dump. We need some information about it.*)
definition ipassmt_initial :: "(iface \<times> (32 word \<times> nat) list) list" where
"ipassmt_initial = (Iface ''docker0'', [(ipv4addr_of_dotdecimal (172,17,0,1),16)])#ipassmt"
lemma "distinct (map fst ipassmt_initial)" by eval
lemma "ipassmt_sanity_nowildcards (map_of ipassmt_initial)" by eval
value[code] "access_matrix_pretty_ipv4 parts_connection_ssh
(preprocess unfold_ruleset_FORWARD upper_closure ipassmt_initial docker_fw_initial_FORWARD_default_policy docker_fw_initial)"
value[code] "access_matrix_pretty_ipv4 parts_connection_ssh
(preprocess_ESTABLISHED unfold_ruleset_FORWARD upper_closure ipassmt_initial docker_fw_initial_FORWARD_default_policy docker_fw_initial)"
value[code] "access_matrix_pretty_ipv4 parts_connection_http
(preprocess unfold_ruleset_FORWARD upper_closure ipassmt_initial docker_fw_initial_FORWARD_default_policy docker_fw_initial)"
value[code] "access_matrix_pretty_ipv4 parts_connection_http
(preprocess_ESTABLISHED unfold_ruleset_FORWARD upper_closure ipassmt_initial docker_fw_initial_FORWARD_default_policy docker_fw_initial)"
end
|
data MyN = MkN Nat Nat
foo : Nat -> Nat -> Nat
foo x y = case MkN x of
MkN z => y
main : IO ()
main = printLn (foo 2 2)
|
Not American..how old is one in grade 8?
I think like, 13 and 14. So definitely a very awkward time.
I feel like bullying can be more of a middle school thing, with high school it's more you get ignored. IDK I remember kids fighting in high school I don't remember much bullying. |
import data.list.perm
import data.sigma.on_fst
local attribute [simp] not_or_distrib and.assoc
local attribute [-simp] sigma.forall
namespace list
section αβ
variables {α : Type*} {β : α → Type*}
/-- Keys: the list of keys from a list of dependent key-value pairs -/
def keys : list (sigma β) → list α :=
map sigma.fst
section keys
variables {a : α} {s hd : sigma β} {l l₁ l₂ tl : list (sigma β)}
@[simp] theorem keys_nil : @keys α β [] = [] :=
rfl
@[simp] theorem keys_cons : (hd :: tl).keys = hd.1 :: tl.keys :=
rfl
@[simp] theorem keys_singleton : [s].keys = [s.1] :=
rfl
@[simp] theorem keys_append : (l₁ ++ l₂).keys = l₁.keys ++ l₂.keys :=
by simp [keys]
@[simp] theorem keys_iff_ne_key_of_mem :
(∀ (s : sigma β), s ∈ l → a ≠ s.1) ↔ a ∉ l.keys :=
by induction l; simp *
theorem mem_of_ne_key_of_mem_cons (h : hd.1 ≠ s.1) : s ∈ hd :: tl → s ∈ tl :=
by cases s; cases hd; simp [ne.symm h]
theorem mem_keys_of_mem : s ∈ l → s.1 ∈ l.keys :=
mem_map_of_mem sigma.fst
theorem exists_mem_of_mem_keys (h : a ∈ l.keys) : ∃ (b : β a), sigma.mk a b ∈ l :=
let ⟨⟨a', b'⟩, m, e⟩ := exists_of_mem_map h in
eq.rec_on e (exists.intro b' m)
theorem mem_keys : a ∈ l.keys ↔ ∃ (b : β a), sigma.mk a b ∈ l :=
⟨exists_mem_of_mem_keys, λ ⟨b, h⟩, mem_keys_of_mem h⟩
end keys
/-- No duplicate keys in a list of dependent key-value pairs. -/
def nodupkeys : list (sigma β) → Prop :=
pairwise (sigma.fst_rel (≠))
section nodupkeys
variables {s t hd : sigma β} {l l₁ l₂ tl : list (sigma β)}
@[simp] theorem nodupkeys_nil : @nodupkeys α β [] :=
pairwise.nil _
@[simp] theorem nodupkeys_cons :
(hd :: tl).nodupkeys ↔ hd.1 ∉ tl.keys ∧ tl.nodupkeys :=
by simp [nodupkeys, sigma.fst_rel]
theorem nodupkeys_cons_of_nodupkeys (h : hd.1 ∉ tl.keys)
(t : nodupkeys tl) : nodupkeys (hd :: tl) :=
nodupkeys_cons.mpr ⟨h, t⟩
theorem nodupkeys_singleton (s : sigma β) : nodupkeys [s] :=
nodupkeys_cons_of_nodupkeys (not_mem_nil s.1) nodupkeys_nil
theorem nodup_of_nodupkeys : l.nodupkeys → l.nodup :=
pairwise.imp $ λ ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ (h : a₁ ≠ a₂), by simp [h]
@[simp] theorem nodupkeys_iff : l.keys.nodup ↔ l.nodupkeys :=
pairwise_map sigma.fst
theorem perm_nodupkeys (p : l₁ ~ l₂) : l₁.nodupkeys ↔ l₂.nodupkeys :=
perm_pairwise (@sigma.fst_rel.symm α β (≠) (@ne.symm α)) p
@[simp] theorem nodupkeys_cons_of_not_mem_keys (h : hd.1 ∉ tl.keys) :
(hd :: tl).nodupkeys ↔ tl.nodupkeys :=
begin
induction tl,
case list.nil { simp },
case list.cons : hd₁ tl ih {
simp at h,
simp [perm_nodupkeys (perm.swap hd₁ hd tl), ne.symm h.1, ih h.2] }
end
variables {ls : list (list (sigma β))}
theorem nodupkeys_join : (join ls).nodupkeys ↔
(∀ {l : list (sigma β)}, l ∈ ls → l.nodupkeys) ∧ pairwise disjoint (ls.map keys) :=
have ∀ (l₁ l₂ : list (sigma β)), (∀ (s ∈ l₁) (t ∈ l₂), sigma.fst_rel ne s t) ↔ disjoint l₁.keys l₂.keys :=
λ l₁ l₂,
have h₁ : (∀ (s : sigma β), s ∈ l₁ → s.1 ∉ l₂.keys) → disjoint l₁.keys l₂.keys :=
λ f a mkas mkat, let ⟨b, mabs⟩ := exists_mem_of_mem_keys mkas in
absurd mkat $ f ⟨a, b⟩ mabs,
have h₂ : disjoint l₁.keys l₂.keys → ∀ (s : sigma β), s ∈ l₁ → s.1 ∉ l₂.keys :=
λ dj s mss mkat, absurd mkat $ dj $ mem_keys_of_mem mss,
⟨by simpa using h₁, by simpa using h₂⟩,
pairwise_join.trans $ and_congr iff.rfl $ (pairwise.iff this).trans (pairwise_map _).symm
theorem nodup_enum_map_fst (l : list α) : (l.enum.map prod.fst).nodup :=
by simp [list.nodup_range]
theorem perm_keys_of_perm (nd₁ : l₁.nodupkeys) (nd₂ : l₂.nodupkeys) (p : l₁ ~ l₂) :
l₁.keys ~ l₂.keys :=
begin
induction p,
case list.perm.nil { refl },
case list.perm.skip : hd tl₁ tl₂ p ih {
simp at nd₁ nd₂,
simp [perm.skip hd.1 (ih nd₁.2 nd₂.2)] },
case list.perm.swap : s₁ s₂ l {
simp [perm.swap s₁.1 s₂.1 (keys l)] },
case list.perm.trans : l₁ l₂ l₃ p₁₂ p₂₃ ih₁₂ ih₂₃ nd₁ nd₃ {
have nd₂ : l₂.nodupkeys := (perm_nodupkeys p₁₂).mp nd₁,
exact perm.trans (ih₁₂ nd₁ nd₂) (ih₂₃ nd₂ nd₃) }
end
-- Is this useful?
theorem nodupkeys_functional (d : l.nodupkeys) (ms : s ∈ l) (mt : t ∈ l)
(h : s.1 = t.1) : (eq.rec_on h s.2 : β t.1) = t.2 :=
begin
induction d,
case pairwise.nil { cases ms },
case pairwise.cons : _ _ r _ ih {
simp at ms mt,
cases ms; cases mt,
{ subst ms, subst mt },
{ induction ms, exact absurd h (r _ mt) },
{ induction mt, exact absurd h (ne.symm (r _ ms)) },
{ exact ih ms mt } },
end
-- Is this useful?
theorem eq_of_nodupkeys_of_eq_fst (d : l.nodupkeys) (ms : s ∈ l) (mt : t ∈ l)
(h : s.1 = t.1) : s = t :=
sigma.eq h $ nodupkeys_functional d ms mt h
end nodupkeys
section decidable_eq_α
variables [decidable_eq α]
/-- Key-based single-value lookup in a list of dependent key-value pairs. The
result is the first key-matching value found, if one exists. -/
def klookup (a : α) : list (sigma β) → option (β a)
| [] := none
| (hd :: tl) := if h : hd.1 = a then some (h.rec_on hd.2) else klookup tl
section klookup
variables {a : α} {s hd : sigma β} {l l₁ l₂ tl : list (sigma β)}
@[simp] theorem klookup_nil : @klookup _ β _ a [] = none :=
rfl
@[simp] theorem klookup_cons_eq (h : hd.1 = a) :
klookup a (hd :: tl) = some (h.rec_on hd.2) :=
by simp [klookup, h]
@[simp] theorem klookup_cons_ne (h : hd.1 ≠ a) :
klookup a (hd :: tl) = klookup a tl :=
by simp [klookup, h]
@[simp] theorem klookup_eq (a : α) : ∀ (l : list (sigma β)),
klookup a l = none ∨ ∃ (b : β a), b ∈ l.klookup a
| [] := or.inl rfl
| (hd :: tl) :=
if h₁ : hd.1 = a then
or.inr ⟨h₁.rec_on hd.2, klookup_cons_eq h₁⟩
else
match klookup_eq tl with
| or.inl h₂ := or.inl $ (klookup_cons_ne h₁).trans h₂
| or.inr ⟨b, h₂⟩ := or.inr ⟨b, (klookup_cons_ne h₁).trans h₂⟩
end
theorem klookup_is_some : (l.klookup a).is_some ↔ ∃ (b : β a), b ∈ l.klookup a :=
by simp [option.is_some_iff_exists]
theorem klookup_not_mem_keys : a ∉ l.keys ↔ klookup a l = none :=
by induction l with hd _ ih;
[simp, {by_cases h : hd.1 = a; [simp [h], simp [h, ne.symm h, ih]]}]
@[simp] theorem mem_klookup_of_nodupkeys (nd : l.nodupkeys) : s.2 ∈ l.klookup s.1 ↔ s ∈ l :=
begin
induction l generalizing s,
case list.nil { simp },
case list.cons : hd tl ih {
simp at nd,
by_cases h : hd.1 = s.1,
{ rw klookup_cons_eq h,
cases s with a₁ b₁,
cases hd with a₂ b₂,
dsimp at h,
induction h,
split,
{ simp {contextual := tt} },
{ intro h,
simp at h,
cases h with h h,
{ simp [h] },
{ exact absurd (mem_keys_of_mem h) nd.1 } } },
{ rw [klookup_cons_ne h, mem_cons_iff],
split,
{ exact or.inr ∘ (ih nd.2).mp },
{ intro p,
cases p with p p,
{ induction p, exact false.elim (ne.irrefl h) },
{ exact (ih nd.2).mpr p } } } }
end
theorem perm_klookup (nd₁ : l₁.nodupkeys) (nd₂ : l₂.nodupkeys) (p : l₁ ~ l₂) :
l₁.klookup a = l₂.klookup a :=
begin
induction p,
case list.perm.nil { refl },
case list.perm.skip : hd tl₁ tl₂ p ih nd₁ nd₂ {
by_cases h : hd.1 = a,
{ simp [h] },
{ simp at nd₁ nd₂, simp [h, ih nd₁.2 nd₂.2] } },
case list.perm.swap : s₁ s₂ l nd₂₁ nd₁₂ {
simp at nd₂₁ nd₁₂,
by_cases h₂ : s₂.1 = a,
{ induction h₂, simp [nd₁₂.1] },
{ by_cases h₁ : s₁.1 = a; simp [h₂, h₁] } },
case list.perm.trans : l₁ l₂ l₃ p₁₂ p₂₃ ih₁₂ ih₂₃ nd₁ nd₃ {
have nd₂ : l₂.nodupkeys := (perm_nodupkeys p₁₂).mp nd₁,
exact eq.trans (ih₁₂ nd₁ nd₂) (ih₂₃ nd₂ nd₃) }
end
end klookup
/-- Key-based multiple-value lookup in a list of dependent key-value pairs.
The result is a list of all key-matching values. -/
def klookup_all (a : α) : list (sigma β) → list (β a)
| [] := []
| (hd :: tl) :=
let tl' := klookup_all tl in
if h : hd.1 = a then h.rec_on hd.2 :: tl' else tl'
section klookup_all
variables {a : α} {hd : sigma β} {l l₁ l₂ tl : list (sigma β)}
@[simp] theorem klookup_all_nil : @klookup_all _ β _ a [] = [] :=
rfl
@[simp] theorem klookup_all_cons_eq (h : hd.1 = a) :
(hd :: tl).klookup_all a = h.rec_on hd.2 :: tl.klookup_all a :=
by simp [klookup_all, h]
@[simp] theorem klookup_all_cons_ne (h : hd.1 ≠ a) :
(hd :: tl).klookup_all a = tl.klookup_all a :=
by simp [klookup_all, h]
theorem klookup_all_head [inhabited (β a)] :
(l.klookup_all a).head = (l.klookup a).iget :=
by induction l with hd; [refl, {by_cases hd.1 = a; simp *}]
theorem perm_klookup_all (p : l₁ ~ l₂) : l₁.klookup_all a ~ l₂.klookup_all a :=
begin
induction p,
case list.perm.nil { refl },
case list.perm.skip : hd tl₁ tl₂ p ih {
by_cases h : hd.1 = a; simp [h, ih, perm.skip] },
case list.perm.swap : s₁ s₂ l {
by_cases h₁ : s₁.1 = a; by_cases h₂ : s₂.1 = a; simp [h₁, h₂, perm.swap] },
case list.perm.trans : l₁ l₂ l₃ p₁₂ p₂₃ ih₁₂ ih₂₃ {
exact perm.trans ih₁₂ ih₂₃ }
end
end klookup_all
/-- Key-based single-pair erasure in a list of dependent key-value pairs. The
result is the list minus the first key-matching pair, if one exists. -/
def kerase (a : α) : list (sigma β) → list (sigma β)
| [] := []
| (hd :: tl) := if hd.1 = a then tl else hd :: kerase tl
section kerase
variables {a a₁ a₂ : α} {s hd : sigma β} {l l₁ l₂ tl : list (sigma β)}
@[simp] theorem kerase_nil : @kerase _ β _ a [] = [] :=
rfl
@[simp] theorem kerase_cons_eq (h : hd.1 = a) :
(hd :: tl).kerase a = tl :=
by simp [kerase, h]
@[simp] theorem kerase_cons_ne (h : hd.1 ≠ a) :
(hd :: tl).kerase a = hd :: tl.kerase a :=
by simp [kerase, h]
theorem kerase_cons (a : α) (hd : sigma β) (tl : list (sigma β)) :
hd.1 = a ∧ (hd :: tl).kerase a = tl ∨
hd.1 ≠ a ∧ (hd :: tl).kerase a = hd :: tl.kerase a :=
by by_cases h : hd.1 = a; simp [h]
@[simp] theorem mem_kerase_nil : s ∈ @kerase _ β _ a [] ↔ false :=
by simp
@[simp] theorem kerase_of_not_mem_keys (h : a ∉ l.keys) : l.kerase a = l :=
by induction l with _ _ ih;
[refl, {simp at h, simp [h.1, ne.symm h.1, ih h.2]}]
theorem exists_kerase_eq (h : a ∈ l.keys) :
∃ (b : β a) (l₁ l₂ : list (sigma β)),
a ∉ l₁.keys ∧
l = l₁ ++ ⟨a, b⟩ :: l₂ ∧
l.kerase a = l₁ ++ l₂ :=
begin
induction l,
case list.nil { cases h },
case list.cons : hd tl ih {
by_cases e : hd.1 = a,
{ induction e,
exact ⟨hd.2, [], tl, by simp, by cases hd; refl, by simp⟩ },
{ simp at h,
cases h,
case or.inl : h { exact absurd h (ne.symm e) },
case or.inr : h {
rcases ih h with ⟨b, tl₁, tl₂, h₁, h₂, h₃⟩,
exact ⟨b, hd :: tl₁, tl₂, not_mem_cons_of_ne_of_not_mem (ne.symm e) h₁,
by rw h₂; refl, by simp [e, h₃]⟩ } } }
end
theorem kerase_sublist (a : α) (l : list (sigma β)) : l.kerase a <+ l :=
if h : a ∈ l.keys then
match l, l.kerase a, exists_kerase_eq h with
| _, _, ⟨_, _, _, _, rfl, rfl⟩ := by simp
end
else
by simp [h]
theorem kerase_subset (a : α) (l : list (sigma β)) : l.kerase a ⊆ l :=
subset_of_sublist (kerase_sublist a l)
theorem kerase_sublist_kerase (a : α) : ∀ {l₁ l₂ : list (sigma β)},
l₁ <+ l₂ → l₁.kerase a <+ l₂.kerase a
| _ _ sublist.slnil := sublist.slnil
| _ _ (sublist.cons l₁ l₂ hd sl) :=
if h : hd.1 = a then
by rw [kerase_cons_eq h]; exact (kerase_sublist _ _).trans sl
else
by rw kerase_cons_ne h; exact (kerase_sublist_kerase sl).cons _ _ _
| _ _ (sublist.cons2 l₁ l₂ hd sl) :=
if h : hd.1 = a then
by repeat {rw kerase_cons_eq h}; exact sl
else
by repeat {rw kerase_cons_ne h}; exact (kerase_sublist_kerase sl).cons2 _ _ _
theorem mem_of_mem_kerase : s ∈ l.kerase a → s ∈ l :=
@kerase_subset _ _ _ _ _ _
@[simp] theorem mem_kerase_of_ne (h : s.1 ≠ a) : s ∈ l.kerase a ↔ s ∈ l :=
iff.intro mem_of_mem_kerase $ λ p,
if q : a ∈ l.keys then
match l, l.kerase a, exists_kerase_eq q, p with
| _, _, ⟨_, _, _, _, rfl, rfl⟩, p :=
by clear _match; cases s; simpa [h] using p
end
else
by simp [q, p]
theorem kerase_subset_keys (a : α) (l : list (sigma β)) :
(l.kerase a).keys ⊆ l.keys :=
subset_of_sublist (map_sublist_map _ (kerase_sublist a l))
theorem mem_keys_of_mem_keys_kerase : a₁ ∈ (l.kerase a₂).keys → a₁ ∈ l.keys :=
@kerase_subset_keys _ _ _ _ _ _
@[simp] theorem mem_keys_kerase_of_ne (h : a₂ ≠ a₁) :
a₁ ∈ (l.kerase a₂).keys ↔ a₁ ∈ l.keys :=
iff.intro mem_keys_of_mem_keys_kerase $ λ p,
if q : a₂ ∈ l.keys then
match l, l.kerase a₂, exists_kerase_eq q, p with
| _, _, ⟨_, _, _, _, rfl, rfl⟩, p := by simpa [ne.symm h] using p
end
else
by simp [q, p]
@[simp] theorem nodupkeys_kerase (a : α) :
l.nodupkeys → (l.kerase a).nodupkeys :=
begin
induction l,
case list.nil { simp },
case list.cons : hd tl ih {
intro nd,
simp at nd,
by_cases h : hd.1 = a,
{ simp [h, nd.2] },
{ rw [kerase_cons_ne h, nodupkeys_cons],
exact ⟨mt (mem_keys_kerase_of_ne (ne.symm h)).mp nd.1, ih nd.2⟩ } }
end
@[simp] theorem not_mem_keys_kerase_self (nd : l.nodupkeys) :
a ∉ (l.kerase a).keys :=
begin
induction l,
case list.nil { simp },
case list.cons : hd tl ih {
simp at nd,
by_cases h : hd.1 = a,
{ induction h, simp [nd.1] },
{ simp [h, ne.symm h, ih nd.2] } }
end
theorem kerase_append_left : ∀ {l₁ l₂ : list (sigma β)},
a ∈ l₁.keys → (l₁ ++ l₂).kerase a = l₁.kerase a ++ l₂
| [] _ h := by cases h
| (hd :: tl₁) l₂ h₁ :=
if h₂ : hd.1 = a then
by simp [h₂]
else
by simp at h₁; cases h₁;
[exact absurd h₁ (ne.symm h₂), simp [h₂, kerase_append_left h₁]]
theorem kerase_append_right : ∀ {l₁ l₂ : list (sigma β)},
a ∉ l₁.keys → (l₁ ++ l₂).kerase a = l₁ ++ l₂.kerase a
| [] _ h := rfl
| (_ :: tl₁) l₂ h := by simp at h; simp [ne.symm h.1, kerase_append_right h.2]
theorem kerase_comm (a₁ a₂ : α) (l : list (sigma β)) :
(l.kerase a₁).kerase a₂ = (l.kerase a₂).kerase a₁ :=
if h : a₂ = a₁ then
by simp [h]
else if ha₁ : a₁ ∈ l.keys then
if ha₂ : a₂ ∈ l.keys then
match l, l.kerase a₁, exists_kerase_eq ha₁, ha₂ with
| _, _, ⟨b₁, l₁, l₂, a₁_nin_l₁, rfl, rfl⟩, a₂_in_l₁_app_l₂ :=
if h' : a₂ ∈ l₁.keys then
by simp [kerase_append_left h',
kerase_append_right (mt (mem_keys_kerase_of_ne h).mp a₁_nin_l₁)]
else
by simp [kerase_append_right h', kerase_append_right a₁_nin_l₁,
@kerase_cons_ne _ _ _ a₂ ⟨a₁, b₁⟩ _ (ne.symm h)]
end
else
by simp [ha₂, mt mem_keys_of_mem_keys_kerase ha₂]
else
by simp [ha₁, mt mem_keys_of_mem_keys_kerase ha₁]
@[simp] theorem klookup_kerase (nd : l.nodupkeys) : (l.kerase a).klookup a = none :=
begin
induction l,
case list.nil { simp },
case list.cons : hd tl ih {
simp at nd,
by_cases h₁ : hd.1 = a,
{ by_cases h₂ : a ∈ tl.keys,
{ induction h₁, exact absurd h₂ nd.1 },
{ simp [h₁, klookup_not_mem_keys.mp h₂] } },
{ simp [h₁, ih nd.2] } }
end
theorem ne_of_nodupkeys_of_mem_kerase :
l.nodupkeys → s ∈ l.kerase a → a ≠ s.1 :=
begin
induction l,
case list.nil { simp },
case list.cons : hd tl ih {
intros nd h,
simp at nd,
rcases kerase_cons a hd tl with ⟨he, p⟩ | ⟨hn, p⟩,
{ induction he,
simp [p] at h,
exact ne.symm (ne_of_mem_of_not_mem (mem_keys_of_mem h) nd.1) },
{ simp [hn] at h,
cases h with h h,
{ induction h, exact ne.symm hn },
{ exact ih nd.2 h } } }
end
theorem nodupkeys_kerase_eq_filter (a : α) (nd : l.nodupkeys) :
l.kerase a = filter (λ s, s.1 ≠ a) l :=
begin
induction nd,
case pairwise.nil { refl },
case pairwise.cons : s l n p ih {
by_cases h : s.1 = a,
{ have : filter (λ (t : sigma β), t.1 ≠ a) l = l :=
filter_eq_self.mpr (λ t th, h ▸ ne.symm (n t th)),
simp [h, kerase, filter, this] },
{ simp [h, ih] } }
end
@[simp] theorem mem_kerase_of_nodupkeys (nd : l.nodupkeys) :
s ∈ l.kerase a ↔ s.1 ≠ a ∧ s ∈ l :=
by rw nodupkeys_kerase_eq_filter a nd; simp [and_comm]
theorem perm_kerase (nd₁ : l₁.nodupkeys) (nd₂ : l₂.nodupkeys) (p : l₁ ~ l₂) :
l₁.kerase a ~ l₂.kerase a :=
begin
induction p,
case list.perm.nil { refl },
case list.perm.skip : hd tl₁ tl₂ p ih {
simp at nd₁ nd₂,
by_cases h : hd.1 = a; simp [p, h, ih nd₁.2 nd₂.2, perm.skip] },
case list.perm.swap : s₁ s₂ l nd₂₁ nd₁₂ {
simp at nd₁₂,
by_cases h₂ : s₂.1 = a,
{ induction h₂, simp [nd₁₂.1] },
{ by_cases h₁ : s₁.1 = a; simp [h₂, h₁, perm.swap] } },
case list.perm.trans : l₁ l₂ l₃ p₁₂ p₂₃ ih₁₂ ih₂₃ nd₁ nd₃ {
have nd₂ : l₂.nodupkeys := (perm_nodupkeys p₁₂).mp nd₁,
exact perm.trans (ih₁₂ nd₁ nd₂) (ih₂₃ nd₂ nd₃) }
end
end kerase
/-- `cons` with `kerase` of the first `s`-key-matching pair -/
def kinsert (s : sigma β) (l : list (sigma β)) : list (sigma β) :=
s :: l.kerase s.1
section kinsert
variables {a : α} {s t hd : sigma β} {l l₁ l₂ tl : list (sigma β)}
@[simp] theorem kinsert_eq_cons_kerase : tl.kinsert hd = hd :: tl.kerase hd.1 :=
rfl
@[simp] theorem mem_kinsert : s ∈ kinsert t l ↔ s = t ∨ s ∈ l.kerase t.1 :=
by simp [kinsert]
@[simp] theorem mem_keys_kinsert : a ∈ (l.kinsert s).keys ↔ s.1 = a ∨ a ∈ l.keys :=
by by_cases h : s.1 = a; [simp [h], simp [h, ne.symm h]]
@[simp] theorem nodupkeys_kinsert (s : sigma β) (nd : l.nodupkeys) :
(l.kinsert s).nodupkeys :=
(nodupkeys_cons_of_not_mem_keys (not_mem_keys_kerase_self nd)).mpr $
nodupkeys_kerase _ nd
theorem perm_kinsert (nd₁ : l₁.nodupkeys) (nd₂ : l₂.nodupkeys) (p : l₁ ~ l₂) :
l₁.kinsert s ~ l₂.kinsert s :=
perm.skip s $ perm_kerase nd₁ nd₂ p
end kinsert
/-- Key-based single-pair replacement in a list of dependent key-value pairs.
The result is the list with the first key-matching pair, if it exists, replaced
by the given pair. -/
def kreplace (s : sigma β) : list (sigma β) → list (sigma β)
| [] := []
| (hd :: tl) := if h : hd.1 = s.1 then s :: tl else hd :: kreplace tl
section kreplace
variables {a : α} {s t hd : sigma β} {l l₁ l₂ tl : list (sigma β)}
@[simp] theorem kreplace_nil : kreplace s [] = [] :=
rfl
@[simp] theorem kreplace_cons_eq (h : hd.1 = s.1) :
(hd :: tl).kreplace s = s :: tl :=
by simp [kreplace, h]
@[simp] theorem kreplace_cons_ne (h : hd.1 ≠ s.1) :
(hd :: tl).kreplace s = hd :: tl.kreplace s :=
by simp [kreplace, h]
theorem kreplace_cons (s hd : sigma β) (tl : list (sigma β)) :
hd.1 = s.1 ∧ (hd :: tl).kreplace s = s :: tl ∨
hd.1 ≠ s.1 ∧ (hd :: tl).kreplace s = hd :: tl.kreplace s :=
by by_cases h : hd.1 = s.1; simp [h]
theorem mem_of_mem_kreplace_ne (h : t.1 ≠ s.1) : s ∈ l.kreplace t → s ∈ l :=
begin
induction l generalizing s t,
case list.nil { simp },
case list.cons : hd tl ih {
by_cases p : hd.1 = t.1,
{ rw kreplace_cons_eq p,
exact mem_cons_of_mem hd ∘ mem_of_ne_key_of_mem_cons h },
{ rw [kreplace_cons_ne p, mem_cons_iff, mem_cons_iff],
exact or.imp_right (ih h) } }
end
theorem mem_keys_of_mem_keys_kreplace_ne (h₁ : a ≠ s.1) (h₂ : a ∈ (l.kreplace s).keys) :
a ∈ l.keys :=
let ⟨b, h₃⟩ := exists_mem_of_mem_keys h₂ in
@mem_keys_of_mem _ _ ⟨a, b⟩ _ (mem_of_mem_kreplace_ne (ne.symm h₁) h₃)
@[simp] theorem nodupkeys_kreplace (s : sigma β) :
l.nodupkeys → (l.kreplace s).nodupkeys :=
begin
induction l,
case list.nil { simp },
case list.cons : hd tl ih {
intro nd,
simp at nd,
by_cases p : hd.1 = s.1,
{ rw p at nd, simp [p, nd.1, nd.2] },
{ simp [p, nd.1, ih nd.2, mt (mem_keys_of_mem_keys_kreplace_ne p)] } }
end
theorem perm_kreplace (nd₁ : l₁.nodupkeys) (nd₂ : l₂.nodupkeys) (p : l₁ ~ l₂) :
l₁.kreplace s ~ l₂.kreplace s :=
begin
induction p,
case list.perm.nil { refl },
case list.perm.skip : hd tl₁ tl₂ p ih {
simp at nd₁ nd₂,
by_cases h : hd.1 = s.1; simp [p, h, ih nd₁.2 nd₂.2, perm.skip] },
case list.perm.swap : s₁ s₂ l nd₂₁ nd₁₂ {
simp at nd₂₁ nd₁₂,
by_cases h₂ : s₂.1 = s.1,
{ rw kreplace_cons_eq h₂,
by_cases h₁ : s₁.1 = s.1,
{ rw kreplace_cons_eq h₁,
exact absurd (h₁.trans h₂.symm) nd₁₂.1 },
{ simp [h₁, h₂, perm.swap] } },
{ by_cases h₁ : s₁.1 = s.1; simp [h₁, h₂, perm.swap] } },
case list.perm.trans : l₁ l₂ l₃ p₁₂ p₂₃ ih₁₂ ih₂₃ nd₁ nd₃ {
have nd₂ : l₂.nodupkeys := (perm_nodupkeys p₁₂).mp nd₁,
exact perm.trans (ih₁₂ nd₁ nd₂) (ih₂₃ nd₂ nd₃) }
end
end kreplace
/-- Left-biased key-based union of lists of dependent key-value pairs.
The result of `l₁.kunion l₂` is constructed from `l₁` with `l₂` appended such
that the first pair matching each key in `l₁` is erased from `l₂`. Note that
the result can still have duplicates if duplicates exist in either argument. -/
def kunion : list (sigma β) → list (sigma β) → list (sigma β)
| [] l := l
| (hd :: tl) l := hd :: kunion tl (kerase hd.1 l)
section kunion
variables {a : α} {s hd : sigma β} {l l₁ l₂ l₃ l₄ tl : list (sigma β)}
@[simp] theorem nil_kunion (l : list (sigma β)) : [].kunion l = l :=
rfl
@[simp] theorem kunion_nil : ∀ (l : list (sigma β)), l.kunion [] = l
| [] := rfl
| (_ :: tl) := by rw [kunion, kerase_nil, kunion_nil tl]
@[simp] theorem kunion_cons : (hd :: tl).kunion l = hd :: tl.kunion (l.kerase hd.1) :=
rfl
@[simp] theorem kerase_kunion : ∀ {l₁ : list (sigma β)} (l₂ : list (sigma β)),
(l₁.kerase a).kunion (l₂.kerase a) = (l₁.kunion l₂).kerase a
| [] _ := rfl
| (hd :: _) l := by by_cases h : hd.1 = a;
simp [h, kerase_comm a hd.1 l, kerase_kunion]
@[simp] theorem map_kunion {γ : Type*} (f : sigma β → γ)
(dk : disjoint l₁.keys l₂.keys) : (l₁.kunion l₂).map f = l₁.map f ++ l₂.map f :=
by induction l₁ with _ _ ih; [refl, {simp at dk, simp [dk.1, ih dk.2.symm]}]
theorem keys_kunion (dk : disjoint l₁.keys l₂.keys) :
(l₁.kunion l₂).keys = l₁.keys ++ l₂.keys :=
by simp [keys, dk]
@[simp] theorem kinsert_kunion : (l₁.kinsert s).kunion l₂ = (l₁.kunion l₂).kinsert s :=
by simp
@[simp] theorem kunion_assoc : (l₁.kunion l₂).kunion l₃ = l₁.kunion (l₂.kunion l₃) :=
by induction l₁ generalizing l₂ l₃; simp *
theorem mem_of_mem_kunion : s ∈ l₁.kunion l₂ → s ∈ l₁ ∨ s ∈ l₂ :=
begin
induction l₁ generalizing l₂,
case list.nil { simp },
case list.cons : hd tl ih {
intro h,
simp at h,
cases h,
case or.inl : h { simp [h] },
case or.inr : h {
cases ih h,
case or.inl : h { simp [h] },
case or.inr : h { simp [mem_of_mem_kerase h] } } }
end
theorem mem_kunion_left (l₂ : list (sigma β)) (h : s ∈ l₁) : s ∈ l₁.kunion l₂ :=
by induction l₁ generalizing l₂; simp at h; cases h; simp *
theorem mem_kunion_right (h₁ : s.1 ∉ l₁.keys) (h₂ : s ∈ l₂) : s ∈ l₁.kunion l₂ :=
by induction l₁ generalizing l₂; simp at h₁; cases h₁; simp *
theorem mem_kunion_middle (dk : disjoint (l₁.kunion l₂).keys l₃.keys) (h : s ∈ l₁.kunion l₃) :
s ∈ (l₁.kunion l₂).kunion l₃ :=
match mem_of_mem_kunion h with
| or.inl h := mem_kunion_left _ (mem_kunion_left _ h)
| or.inr h := mem_kunion_right (disjoint_right.mp dk (mem_keys_of_mem h)) h
end
theorem mem_kunion_of_disjoint_keys (dk : disjoint l₁.keys l₂.keys) (h : s ∈ l₁ ∨ s ∈ l₂) :
s ∈ l₁.kunion l₂ :=
begin
cases h with h h,
{ exact mem_kunion_left _ h },
{ by_cases p : s.1 ∈ l₁.keys,
{ exact absurd h (mt mem_keys_of_mem (dk p)) },
{ exact mem_kunion_right p h } }
end
@[simp] theorem mem_kunion_iff (dk : disjoint l₁.keys l₂.keys) : s ∈ l₁.kunion l₂ ↔ s ∈ l₁ ∨ s ∈ l₂ :=
⟨mem_of_mem_kunion, mem_kunion_of_disjoint_keys dk⟩
@[simp] theorem mem_keys_kunion : a ∈ (l₁.kunion l₂).keys ↔ a ∈ l₁.keys ∨ a ∈ l₂.keys :=
by induction l₁ with hd _ ih generalizing l₂;
[simp, {by_cases h : hd.1 = a; [simp [h], simp [h, ne.symm h, ih]]}]
theorem nodupkeys_kunion (nd₁ : l₁.nodupkeys) (nd₂ : l₂.nodupkeys) :
(l₁.kunion l₂).nodupkeys :=
by induction l₁ generalizing l₂; simp at nd₁; simp *
theorem perm_kunion_left (l : list (sigma β)) (p : l₁ ~ l₂) : l₁.kunion l ~ l₂.kunion l :=
begin
induction p generalizing l,
case list.perm.nil { refl },
case list.perm.skip : hd tl₁ tl₂ p ih {
simp [ih (kerase hd.1 l), perm.skip] },
case list.perm.swap : s₁ s₂ l {
simp [kerase_comm, perm.swap] },
case list.perm.trans : l₁ l₂ l₃ p₁₂ p₂₃ ih₁₂ ih₂₃ {
exact perm.trans (ih₁₂ l) (ih₂₃ l) }
end
theorem perm_kunion_right : ∀ (l : list (sigma β)) {l₁ l₂ : list (sigma β)},
l₁.nodupkeys → l₂.nodupkeys → l₁ ~ l₂ → l.kunion l₁ ~ l.kunion l₂
| [] _ _ _ _ p := p
| (hd :: tl) l₁ l₂ nd₁ nd₂ p :=
by simp [perm.skip hd
(perm_kunion_right tl (nodupkeys_kerase hd.1 nd₁)
(nodupkeys_kerase hd.1 nd₂)
(perm_kerase nd₁ nd₂ p))]
theorem perm_kunion (nd₂ : l₂.nodupkeys) (nd₄ : l₄.nodupkeys)
(p₁₃ : l₁ ~ l₃) (p₂₄ : l₂ ~ l₄) : l₁.kunion l₂ ~ l₃.kunion l₄ :=
perm.trans (perm_kunion_left l₂ p₁₃) (perm_kunion_right l₃ nd₂ nd₄ p₂₄)
end kunion
end decidable_eq_α
end αβ
section α₁α₂α₃β₁β₂β₃
universes u v
variables {α₁ α₂ α₃ : Type u} {β₁ : α₁ → Type v} {β₂ : α₂ → Type v} {β₃ : α₃ → Type v}
section keys
variables {s : sigma β₁} {l : list (sigma β₁)} {f : sigma β₁ → sigma β₂}
theorem mem_keys_map_of_mem (f : sigma β₁ → sigma β₂) (ms : s ∈ l) :
(f s).1 ∈ (l.map f).keys :=
mem_keys_of_mem (mem_map_of_mem f ms)
theorem mem_keys_map (ff : sigma.fst_functional f) (h : s.1 ∈ l.keys) :
(f s).1 ∈ (l.map f).keys :=
let ⟨_, m, e⟩ := exists_of_mem_map h in ff e ▸ mem_keys_map_of_mem f m
theorem mem_keys_of_mem_keys_map (fi : sigma.fst_injective f) (h : (f s).1 ∈ (l.map f).keys) :
s.1 ∈ l.keys :=
have h : (sigma.fst ∘ f) s ∈ map (sigma.fst ∘ f) l, by simpa [keys] using h,
let ⟨_, m, e⟩ := exists_of_mem_map h in fi e ▸ mem_keys_of_mem m
-- Is this useful?
theorem mem_keys_of_mem_map (fi : sigma.fst_injective f) (h : f s ∈ l.map f) : s.1 ∈ l.keys :=
let ⟨_, m, e⟩ := exists_of_mem_map h in
fi (sigma.eq_fst e) ▸ mem_keys_of_mem m
@[simp] theorem mem_keys_map_iff (ff : sigma.fst_functional f) (fi : sigma.fst_injective f) :
(f s).1 ∈ (l.map f).keys ↔ s.1 ∈ l.keys :=
⟨mem_keys_of_mem_keys_map fi, mem_keys_map ff⟩
end keys
section nodupkeys
variables {s t : sigma β₁} {l : list (sigma β₁)} {f : sigma β₁ → sigma β₂}
-- Is this useful?
theorem nodupkeys_injective (fi : sigma.fst_injective f) (d : l.nodupkeys)
(ms : s ∈ l) (mt : t ∈ l) (h : f s = f t) : s = t :=
eq_of_nodupkeys_of_eq_fst d ms mt $ fi $ sigma.eq_fst h
theorem nodupkeys_of_nodupkeys_map (ff : sigma.fst_functional f) :
nodupkeys (map f l) → nodupkeys l :=
pairwise_of_pairwise_map f $ λ s t, mt (@ff s t)
theorem nodupkeys_map (fi : sigma.fst_injective f) :
l.nodupkeys → (l.map f).nodupkeys :=
pairwise_map_of_pairwise f
(λ s t (h : s ∈ l ∧ t ∈ l ∧ s.1 ≠ t.1), mt (@fi s t) h.2.2) ∘
pairwise.and_mem.mp
theorem nodupkeys_map_iff (ff : sigma.fst_functional f) (fi : sigma.fst_injective f) :
(l.map f).nodupkeys ↔ l.nodupkeys :=
⟨nodupkeys_of_nodupkeys_map ff, nodupkeys_map fi⟩
-- Is this useful?
theorem mem_map_of_mem_of_mem_keys_map (fi : sigma.fst_injective f) (d : l.nodupkeys)
(ms : s ∈ l) (mfs : (f s).1 ∈ (l.map f).keys) : f s ∈ l.map f :=
begin
simp [keys] at mfs,
rcases mfs with ⟨a, b, mab, ef⟩,
cases s with sa sb,
have ea : a = sa := fi ef,
subst ea,
have eb : b = sb := nodupkeys_functional d mab ms rfl,
subst eb,
exact mem_map_of_mem f mab,
end
end nodupkeys
section map_disjoint
variables {l₁ l₂ : list (sigma β₁)} {f : sigma β₁ → sigma β₂}
theorem map_disjoint_keys_of_disjoint_keys (fi : sigma.fst_injective f)
(dk : disjoint l₁.keys l₂.keys) : disjoint (l₁.map f).keys (l₂.map f).keys :=
λ a h₁ h₂,
have h₁ : a ∈ map (sigma.fst ∘ f) l₁, by simpa [keys] using h₁,
let ⟨s, m, e⟩ := exists_of_mem_map h₁ in
have e : (f s).1 = a := e,
dk (mem_keys_of_mem m) (mem_keys_of_mem_keys_map fi (e.symm ▸ h₂))
theorem disjoint_keys_of_map_disjoint_keys (ff : sigma.fst_functional f)
(dk : disjoint (l₁.map f).keys (l₂.map f).keys) : disjoint l₁.keys l₂.keys :=
λ a h₁ h₂, let ⟨b₁, h₁⟩ := exists_mem_of_mem_keys h₁ in
dk (mem_keys_map_of_mem f h₁) (mem_keys_map ff h₂)
@[simp] theorem map_disjoint_keys (ff : sigma.fst_functional f) (fi : sigma.fst_injective f) :
disjoint (l₁.map f).keys (l₂.map f).keys ↔ disjoint l₁.keys l₂.keys :=
⟨disjoint_keys_of_map_disjoint_keys ff, map_disjoint_keys_of_disjoint_keys fi⟩
end map_disjoint
section decidable_eq_α₁_α₂
variables [decidable_eq α₁] [decidable_eq α₂]
section map
variables {s : sigma β₁} {l : list (sigma β₁)} {f : sigma β₁ → sigma β₂}
@[simp] theorem map_kerase (ff : sigma.fst_functional f) (fi : sigma.fst_injective f) :
(l.kerase s.1).map f = (l.map f).kerase (f s).1 :=
begin
induction l,
case list.nil { simp },
case list.cons : hd tl ih {
by_cases h : (f hd).1 = (f s).1,
{ simp [h, fi h] },
{ simp [h, mt (@ff _ _) h, ih] } }
end
@[simp] theorem map_kinsert (ff : sigma.fst_functional f) (fi : sigma.fst_injective f) :
(l.kinsert s).map f = (l.map f).kinsert (f s) :=
by simp [ff, fi]
end map
end decidable_eq_α₁_α₂
end α₁α₂α₃β₁β₂β₃
section αβ₁β₂
universes u v
variables {α : Type u} {β₁ β₂ : α → Type v}
section nodupkeys
variables {l : list (sigma β₁)}
theorem nodupkeys_map_id_iff (f : ∀ a, β₁ a → β₂ a) :
(l.map (sigma.map id f)).nodupkeys ↔ l.nodupkeys :=
nodupkeys_map_iff (sigma.map_id_fst_functional f) (sigma.map_id_fst_injective f)
end nodupkeys
end αβ₁β₂
end list
|
State Before: α : Type ?u.236438
β : Type ?u.236441
γ : Type ?u.236444
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
n : ℕ
⊢ ↑n ≤ card o ↔ ↑n ≤ o State After: no goals Tactic: rw [← Cardinal.ord_le, Cardinal.ord_nat] |
[STATEMENT]
lemma evaldjf_ex: "Ifm bbs bs (evaldjf f ps) \<longleftrightarrow> (\<exists>p \<in> set ps. Ifm bbs bs (f p))"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. Ifm bbs bs (evaldjf f ps) = (\<exists>p\<in>set ps. Ifm bbs bs (f p))
[PROOF STEP]
by (induct ps) (simp_all add: evaldjf_def djf_Or) |
#include "dot_net_solution.hpp"
#include <bacs/problem/error.hpp>
#include <bacs/problem/split.hpp>
#include <bunsan/filesystem/fstream.hpp>
#include <bunsan/filesystem/operations.hpp>
#include <bunsan/pm/index.hpp>
#include <bunsan/static_initializer.hpp>
#include <boost/filesystem/operations.hpp>
#include <boost/property_tree/ini_parser.hpp>
namespace bacs {
namespace problem {
namespace utilities {
BUNSAN_STATIC_INITIALIZER(bacs_problem_utilities_dot_net_solution, {
BUNSAN_FACTORY_REGISTER_TOKEN(
utility, dot_net_solution,
[](const boost::filesystem::path &location,
const boost::property_tree::ptree &config) {
return utility::make_shared<dot_net_solution>(location, config);
})
})
dot_net_solution::dot_net_solution(const boost::filesystem::path &location,
const boost::property_tree::ptree &config)
: utility(location, config),
m_solution(config.get<std::string>("build.solution")),
m_configuration(config.get_optional<std::string>("build.configuration")),
m_libs(split::get_vector(config, "build.libs")) {}
bool dot_net_solution::make_package(const boost::filesystem::path &destination,
const bunsan::pm::entry & /*package*/,
const Revision & /*revision*/) const {
try {
boost::filesystem::create_directories(destination);
bunsan::pm::index index;
// builder itself
index.source.import.source.push_back(
{".", "bacs/system/utility/dot_net_solution"});
// sources, note: only build section is needed from config
index.source.self.push_back({"src", "src"});
bunsan::filesystem::copy_tree(location(), destination / "src");
// utility configuration
index.package.self.push_back({"etc", "etc"});
boost::filesystem::create_directory(destination / "etc");
boost::property_tree::write_ini((destination / "etc" / target()).string(),
section("call"));
// modules: set binary name
index.source.self.push_back({"modules", "modules"});
boost::filesystem::create_directory(destination / "modules");
bunsan::filesystem::ofstream fout(destination / "modules" /
"utility.cmake");
BUNSAN_FILESYSTEM_FSTREAM_WRAP_BEGIN(fout) {
fout << "set(target " << target().string() << ")\n";
fout << "set(solution " << m_solution.string() << ")\n";
if (m_configuration)
fout << "set(configuration " << m_configuration << ")\n";
fout << "set(libraries";
for (const std::string &lib : m_libs) fout << " " << lib;
fout << ")\n";
} BUNSAN_FILESYSTEM_FSTREAM_WRAP_END(fout)
fout.close();
// dependencies
for (const std::string &lib : m_libs) {
index.source.import.package.push_back(
{".", "bacs/lib/dot_net_solution/" + lib});
}
// save it
index.save(destination / "index");
return true;
} catch (std::exception &) {
BOOST_THROW_EXCEPTION(
utility_make_package_error()
<< utility_make_package_error::destination(destination)
// << utility_make_package_error::package(package)
<< bunsan::enable_nested_current());
}
}
} // namespace utilities
} // namespace problem
} // namespace bacs
|
import metric_spaces.definitions
noncomputable theory
open set
namespace examples
-- Declaring X and element x with type X
inductive X : Type
| x : X
-- A metric that maps everything to zero is a metric on X
instance metric_space_example_X : metric_space X :=
{ dist := λ _ _, 0,
dist_self := λ _, rfl,
eq_of_dist_eq_zero := λ a b _, by {cases a, cases b, refl},
dist_comm := λ _ _, rfl,
dist_triangle := λ _ _ _, show (0 : ℝ) ≤ 0 + 0, by linarith
}
-- The absolute function is a metric on ℝ
instance metric_space_example_R : metric_space ℝ :=
{ dist := λ x y, abs (x - y),
dist_self := λ x, show abs (x - x) = 0, by simp,
eq_of_dist_eq_zero := λ x y, show abs (x - y) = 0 → x = y,
by { rw abs_eq_zero, intro h, linarith [h] },
dist_comm := λ x y, show abs (x - y) = abs (y - x), from abs_sub x y,
dist_triangle := λ x y z, show abs (x - z) ≤ abs (x - y) + abs (y - z),
by { convert abs_add (x - y) (y - z), linarith }
}
-- The discrete metric is a metric on any set X
open tactic
open_locale classical
definition metric_example (X : Type) (x y : X) : ℝ :=
if x = y then 0 else 1
variables {X : Type} {x y : X}
-- Useless tactic just for fun, maybe remove later
private meta def metric_example_tac : tactic unit :=
solve1 $ intros
>> `[unfold metric_example]
>> try `[simp]
instance metric_space_example_discrete : metric_space X :=
{ dist := λ x y, metric_example X x y,
dist_self := λ x, show metric_example X x x = 0, by metric_example_tac,
eq_of_dist_eq_zero := λ x y, show metric_example X x y = 0 → x = y,
by { unfold metric_example, split_ifs, all_goals {finish} },
dist_comm := λ x y, show metric_example X x y = metric_example X y x,
by { unfold metric_example, split_ifs, all_goals {finish} },
dist_triangle := λ x y z, show metric_example X x z ≤ metric_example X x y + metric_example X y z,
begin
unfold metric_example,
split_ifs, all_goals {try {norm_num}},
apply h, rwa [h_1, h_2]
end
}
end examples |
function test_fileformat_asa
% MEM 2gb
% WALLTIME 00:10:00
% DEPENDENCY ft_read_sens ft_read_headmodel ft_read_headshape ft_read_mri read_asa read_asa_dip read_asa_mri read_asa_vol read_asa_bnd read_asa_elc read_asa_msr
elcfile = dccnpath('/home/common/matlab/fieldtrip/data/test/original/electrodes/asa/standard_primed.elc');
volfile = dccnpath('/home/common/matlab/fieldtrip/data/test/original/headmodel/asa/standard.vol');
skinfile = dccnpath('/home/common/matlab/fieldtrip/data/test/original/headshape/asa/standard_skin_14038.vol');
mrifile = dccnpath('/home/common/matlab/fieldtrip/data/test/original/mri/asa/standard.mri');
elec = ft_read_sens(elcfile);
vol = ft_read_headmodel(volfile);
skin = ft_read_headshape(skinfile);
mri = ft_read_mri(mrifile);
|
import data.nat.gcd
variables x y z : ℕ
#check dvd_mul_left
#check dvd_mul_right
#check @dvd_mul_of_dvd_left
#check @dvd_mul_of_dvd_right
example (h₀ : x ∣ y) (h₁ : y ∣ z) : x ∣ z :=
dvd_trans h₀ h₁
example : x ∣ y * x * z :=
begin
apply dvd_mul_of_dvd_left,
apply dvd_mul_left,
end
example : x ∣ x^2 :=
by apply dvd_mul_right |
module Maybe
%default total
maybeAdd : Maybe Int -> Maybe Int -> Maybe Int
maybeAdd x y = case x of
Nothing => Nothing
Just a => case y of
Nothing => Nothing
Just b => Just (a + b)
mAdd : Maybe Int -> Maybe Int -> Maybe Int
mAdd mx my = do x <- mx
y <- my
Just (x + y) |
Require Export Kelley_Set_Theory.
(** Some necessary and additional definitions for the proof **)
Module BasicDefinition.
(* Nest *)
Definition Nest f : Prop := forall A B, A∈f /\ B∈f -> A⊂B \/ B⊂A.
Hint Unfold Nest : Axiom_of_Chioce.
(* Finite Characteristic Set *)
Definition FiniteSet f : Prop :=
Ensemble f /\ (forall F, F∈f -> (forall z, z ⊂ F /\ Finite z -> z∈f))
/\ (forall F, Ensemble F /\ (forall z, z ⊂ F /\ Finite z -> z∈f) -> F∈f).
Hint Unfold FiniteSet : Axiom_of_Chioce.
(* Property of Finite Characteristic Set *)
Hypothesis HPF_def : forall A φ, A ⊂ ∪ φ -> Finite A ->
exists C0 C1 C2, (C0∈φ /\ C1∈φ /\ C2∈φ) /\ A ⊂ (C0 ∪ C1 ∪ C2).
Proposition Property_FinSet : forall f: Class,
FiniteSet f /\ f ≠ Φ -> (forall A B, A ∈ f /\ B ⊂ A -> B ∈ f)
/\ (forall φ, φ ⊂ f /\ Nest φ -> (∪φ) ∈ f).
Proof.
intros; destruct H.
unfold FiniteSet in H; destruct H; split; intros.
- destruct H2; apply H1; intros; split.
+ apply Theorem33 in H3; Ens.
+ intros; destruct H4; apply H1 with (z:=z) in H2; auto.
split; try (apply Theorem28 with (y:=B); split); auto.
- destruct H2; apply H1.
split; try (apply AxiomVI; apply Theorem33 in H2); auto.
intro A; intros; destruct H4.
unfold Nest in H3; apply HPF_def in H4; auto.
destruct H4 as [C0 H4]; destruct H4 as [C1 H4].
destruct H4 as [C2 H4]; destruct H4, H4, H7.
assert (C0 ∈ φ /\ C1 ∈ φ). { split; auto. }
assert (C1 ∈ φ /\ C2 ∈ φ). { split; auto. }
assert (C0 ∈ φ /\ C2 ∈ φ). { split; auto. }
apply H3 in H10; destruct H10.
+ apply Theorem29 in H10; rewrite H10 in H6.
apply H3 in H11; destruct H11.
* apply Theorem29 in H11; rewrite H11 in H6.
unfold Included in H2; apply H2 in H8.
apply H1 with (z:=A) in H8; auto.
* apply Theorem29 in H11; rewrite Theorem6 in H11.
rewrite H11 in H6; unfold Included in H2; apply H2 in H4.
apply H1 with (z:=A) in H4; auto.
+ apply Theorem29 in H10; rewrite Theorem6 in H10.
rewrite H10 in H6; apply H3 in H9; destruct H9.
* apply Theorem29 in H9; rewrite H9 in H6.
unfold Included in H2; apply H2 in H7.
apply H1 with (z:=A) in H7; auto.
* apply Theorem29 in H9; rewrite Theorem6 in H9.
rewrite H9 in H6; unfold Included in H2; apply H2 in H4.
apply H1 with (z:=A) in H4; auto.
Qed.
(* Maximial Member : F is a maximal member of f iff no member of f is properly contained in F. [K55] *)
Definition MaxMember F f : Prop :=
f ≠ Φ -> F∈f /\ (forall x, x∈f -> ~ F ⊊ x).
Hint Unfold MaxMember : Axiom_of_Choice.
(* Minimial Member : Similarly F is a minimal member of f iff no member of f is properly contained in F. [K55] *)
Definition MinMember F f : Prop :=
f ≠ Φ -> F∈f /\ (forall x, x∈f -> ~ x ⊊ F).
Hint Unfold MaxMember MinMember : Axiom_of_Choice.
(* Choice Function *)
Definition Choice_Function ε X : Prop :=
Function ε /\ ran(ε) ⊂ X /\ dom(ε) = pow(X)~[Φ] /\
(forall A, A ∈ dom(ε) -> ε[A] ∈ A).
Hint Unfold Choice_Function : Axiom_of_Choice.
End BasicDefinition.
Export BasicDefinition.
|
%
% CMPT 213: Object Oriented Design in Java - A Course Overview
% Section: Object-Oriented Design
%
% Author: Jeffrey Leung
%
\section{Object-Oriented Design}
\label{sec:object-oriented-design}
\begin{easylist}
& Effective because classes represent stable problem domain concepts
& Design involves identifying classes, responsibilities, and relationships
& \textbf{Object:} Unique software entity with state and behaviours
&& \textbf{State:} Information about an object
&& \textbf{Behaviour:} Methods and operations which view and/or modify state
&& \textbf{Class:} Type of a set of objects with the same behaviours and set of possible states
&&& \textbf{Final class:} Class which cannot be inherited from
&& \textbf{Field/instance data:} Member variable stored by an object
&& \textbf{Method:} Member function of a class
&&& \textbf{Final method:} Method which cannot be overridden
&& Statics:
&&& \textbf{Static/class field:} Field for which only a single instance exists and is shared between all classes
&&& \textbf{Static/class method:} Method which can be called on the class without a constructed object
&& Unique types of objects:
&&& Agent: Object which performs a specific task
&&& Users/roles, events, systems, interfaces
& Anonymous classes:
&& \textbf{Anonymous class:} Single-use implementation of an interface, defined only once within another body of code
&& \textbf{Anonymous object:} Instance of an unnamed class
& Relationships between objects:
&& \textbf{Dependency (uses):} Relationship between two classes where one uses the other (i.e. the first may need to change if the second changes)
&&& \textbf{Coupling:} Relationship between two classes where one is a dependency of the other
&&&& The greater the coupling, the greater the changes required when one component is modified
&&&& Ideally minimized
&& \textbf{Aggregation (has a):} Relationship between two classes where one contains the other
&& \textbf{Inheritance (is a):} Relationship between two classes where one is a subclass of the other (see subsection~\ref{subsec:object-oriented-design:inheritance})
& \textbf{Side effect:} Observable change to state caused by code execution
& \textbf{Idiom:} Common practice
& \textbf{Protected:} Access class which is available at package-level as well as derived classes, but not external code
&& Breaks encapsulation; exposes implementation details to derived classes
&& Difficult because no control over the extending clases
\end{easylist}
\subsection{Public Interface}
\label{subsec:object-oriented-design:public-interface}
\begin{easylist}
& \textbf{Interface:} Set of methods which an implementing class can choose to implement
& Object type cannot be dynamically changed
\end{easylist}
\subsection{Principles}
\label{subsec:object-oriented-design:principles}
\begin{easylist}
& \textbf{Encapsulation:} Characteristic of a module which only exposes some public interfaces, allowing some internal changes to be made without breaking outward interface
&& Modules manage their own state
&& Reduces scope of change (which encourages modification) and cognitive load
& \textbf{Immutability:} Characteristic of an entity which has no methods which change its visible state
&& A modification to an object must return a new object
&& An accessor should return a value or immutable reference
&& Avoids issues from partial setters and shared references
&& \textbf{Final:} Keyword which declares a field to have an immutable reference
& \textbf{Command-Query Separation:} Principle which states that methods should not be both mutator and accessor, to avoid unexpected side effects
&& \textbf{Command:} Mutator method
&&& Should return null
&& \textbf{Query:} Accessor method
& \textbf{Responsibility heuristic:} Tendency to avoid exposing internal details only for external access
\end{easylist}
\subsection{SOLID Principles}
\label{subsec:object-oriented-design:solid-principles}
\begin{easylist}
& \textbf{Single Responsibility Principle:} Each class only has one responsibility
& \textbf{Open-Closed Principle:} Classes must be open for extension but closed for modification
& \textbf{Liskov Substitution Principle:} Subtype objects must be interchangeable with base objects
& \textbf{Interface Segregation Principle:} Models should support multiple possible interfaces
& \textbf{Dependency Inversion Principle:} Code should depend on abstractions, not concrete classes
\end{easylist}
\subsection{Polymorphism}
\label{subsec:object-oriented-design:polymorphism}
\begin{easylist}
& \textbf{Concrete type:} Exact instantiated type of an object
& \textbf{Interface:} Definition of a set of public methods to be implemented
&& A class implements an interface
&& Code to an interface, not a concrete type
&& Can inherit from another object
& \textbf{Polymorphism:} Characteristic of an object which can be one of multiple different concrete types
&& Possible due to composition
&& Allows late binding
& \textbf{Late binding:} Characteristic of a variable which is assigned a specific concrete type at runtime
&& Allows loose coupling
\end{easylist}
\subsection{Inheritance}
\label{subsec:object-oriented-design:inheritance}
\begin{easylist}
& \textbf{Inheritance:} Subclass created from and extending a superclass
&& Allows sharing members (properties and methods)
&& Allows polymorphism between two concrete classes
&& \textbf{Single inheritance:} A subclass may have at most 1 superclass
&& \textbf{Multiple inheritance:} A subclass may have multiple superclasses
&& \textbf{Liskov Substitution Principle (LSP):} Rule which states that class B can inherit from A if and only if, for each method in A, the corresponding method in B accepts the same parameters (or more) and executes the same operations (or more)
&&& I.e. Client code using the base class must be able to use the derived class without modification
&&& Is-a relationships must satisfy the Liskov Substitution Principle
&& Should be used for permanent relationships, not temporary assignments
&& Favor polymorphism over inheritance
& \textbf{Superclass/Base class:} Class from which another class inherits
&& Cannot be assigned to an instance of a subclass
&& Referred to by \lstinline!super!
&& Cannot be final
& \textbf{Subclass/Derived class:} Class which inherits from another
&& Can access non-private members of the superclass
&& Cannot directly access private members of the superclass
&& Can be assigned to an instance of a superclass
& \textbf{Constructor chaining:} Call to a superclass constructor by a constructor in the subclass
&& Ensures base classes are initialized first
&& In Java, if no superclass constructor is called, then superclass default 0-argument constructor is automatically called
& Abstracts:
&& \textbf{Abstract method:} Un-implemented method which must be implemented by any concrete subclass
&& \textbf{Abstract class:} Class with abstract methods
&&& Concrete derived classes must implement all abstract methods
&& Abstract classes vs. interfaces:
&&& Both require implementation of a given set of methods
&&& Abstract classes can have member variables and implemented methods; interfaces cannot
&&& A class can implement multiple interfaces; a class can only have a single (abstract) superclass
\end{easylist}
\subsection{Overriding}
\label{subsec:object-oriented-design:overriding}
\begin{easylist}
& The overriding method:
&& Must have identical signature (except for visibility and return type)
&& Visibility cannot be reduced
&& Cannot throw additional checked exceptions
&& Can return a subclass of the original return type
& Method to override:
&& Cannot be private, static, final
& \textbf{Shadow variable:} Subclass variable which overrides a variable of the superclass
\end{easylist}
\clearpage
|
@testset "AlgAssOrd" begin
include("AlgAssOrd/CSAMaxOrd.jl")
include("AlgAssOrd/PicardGroup.jl")
include("AlgAssOrd/LocallyFreeClassGroup.jl")
end
|
import data.set.basic
variables (R A : Type)
variables (𝕍 : set R → set A) (𝕀 : set A → set R)
open set
-- 𝕍 𝕀 𝕍 = 𝕍 for a contravariant Galois connection
-- for example the one between R=k[X₁,X₂,…,Xₙ] and A=𝔸ⁿ
-- in the theory of algebraic varieties
example
(𝕍_antimono : ∀ J₁ J₂ : set R, J₁ ⊆ J₂ → 𝕍 J₂ ⊆ 𝕍 J₁)
(𝕀_antimono : ∀ W₁ W₂ : set A, W₁ ⊆ W₂ → 𝕀 W₂ ⊆ 𝕀 W₁)
(galois : ∀ J : set R, ∀ W : set A, J ⊆ 𝕀 W ↔ W ⊆ 𝕍 J) :
∀ J : set R, 𝕍 (𝕀 (𝕍 J)) = 𝕍 J :=
begin
intro J,
apply set.subset.antisymm,
{ apply 𝕍_antimono,
rw galois},
{ rw ←galois}
end
|
# Surface Codes Tutorial II
---
The idea we implement here is to realize graphs on surfaces such as the following found in the papers [Feynman Diagrams and Rooted Maps](https://arxiv.org/pdf/1312.0934.pdf) and [Minors and planar embeddings of digraphs](https://www.researchgate.net/publication/37985042_Minors_and_planar_embeddings_of_digraphs), in order to use and study *surface codes*:
Below, we are going to create a class called `SurfaceCodeGraph` which implements a combinatorial object defining a graph which is cellularly embedded in a compact $2$-manifold, i.e. a Riemann surface. This will give us the necessary tools we need to start implementing and studying surface codes on arbitrary surfaces of any genus, and with any qubit connectivity we want. This combinatorial construction is very closely related to quantum gravity, string theory, lattice gauge theories, and number theory (dessins d'enfants), where certain questions in quantum complexity involving partition functions of Ising type models can be translated into questions about L-functions. We will provide references to relevant research papers at the end.
In building the graph, *bipartite graphs* from NetworkX are used to create *black nodes*, `bipartite=1`, and *white nodes*, `bipartite=0`. For more info on creating bipartite graphs see the [NetworkX documentation](https://networkx.github.io/documentation/stable/reference/algorithms/bipartite.html).
```python
from collections import Counter
from typing import Tuple, List
from networkx import MultiGraph
from networkx import nx
from networkx.algorithms import bipartite
from sympy.combinatorics import Permutation
import matplotlib.pyplot as plt
# from SurfaceCodes.utilites import permlist_to_tuple
class SurfaceCodeGraph(MultiGraph):
def __init__(self, sigma: Tuple[Tuple[int]], alpha: Tuple[Tuple[int]]):
super().__init__()
self.sigma = sigma # should include singletons corresponding to fixed points
self.alpha = alpha # should include singletons corresponding to fixed points
f = self.compute_phi()
self.phi = self.permlist_to_tuple(f)
self.build_node_info() # print dictionary for [sigma, alpha, phi]
self.node_dict = self.sigma_dict, self.alpha_dict, self.phi_dict
self.node_info = ["sigma:", self.sigma_dict,
"alpha:", self.alpha_dict,
"phi:", self.phi_dict]
self.code_graph = nx.MultiGraph()
# Create black nodes for each cycle in sigma along with white nodes
# representing "half edges" around the black nodes
for cycle in self.sigma:
self.code_graph.add_node(cycle, bipartite=1)
for node in cycle:
self.code_graph.add_node(node, bipartite=0)
self.code_graph.add_edge(cycle, node)
# Create black nodes for each cycle in phi along with white nodes
# representing "half edges" around the black nodes
for cycle in self.phi:
self.code_graph.add_node(cycle, bipartite=1)
for node in cycle:
self.code_graph.add_edge(cycle, node)
# Create nodes for each cycle in alpha then
# glue the nodes corresponding to a the pairs
for pair in self.alpha:
self.code_graph.add_node(pair)
self.code_graph = nx.contracted_nodes(self.code_graph, pair[0], pair[1], self_loops=True)
# Now contract pair with pair[0] to make sure edges (white nodes) are labeled
# by the pairs in alpha to keep track of the gluing from the previous step
self.code_graph = nx.contracted_nodes(self.code_graph, pair, pair[0], self_loops=True)
# Define the white and black nodes. White correspond to edges labeled by
# cycles in alpha. Black correspond to nodes labeled by cycles in sigma
# (vertices) and phi (faces)
self.black_nodes, self.white_nodes = bipartite.sets(self.code_graph)
def permlist_to_tuple(self, perms):
"""
convert list of lists to tuple of tuples in order to have two level iterables
that are hashable for the dictionaries used later
"""
return tuple(tuple(perm) for perm in perms)
def compute_phi(self):
"""compute the list of lists full cyclic form of phi (faces of dessin [sigma, alpha, phi])"""
s = Permutation(self.sigma)
a = Permutation(self.alpha)
f = ~(a * s)
f = f.full_cyclic_form # prints permutation as a list of lists including all singletons (fixed points)
return f
def build_node_info(self):
count = -1
self.sigma_dict = dict()
for count, cycle in enumerate(self.sigma):
self.sigma_dict[cycle] = count
self.phi_dict = dict()
for count, cycle in enumerate(self.phi, start=count + 1):
self.phi_dict[cycle] = count
self.alpha_dict = dict()
for count, pair in enumerate(self.alpha, start=count + 1):
self.alpha_dict[pair] = count
return tuple([self.sigma_dict, self.alpha_dict, self.phi_dict])
def boundary_1(self, edge):
"""
compute boundary of a single edge given by a white node (cycle in alpha)
"""
boundary1 = [node for node in self.code_graph.neighbors(edge) if node in self.sigma_dict]
return boundary1
def del_1(self, edges: List[Tuple[int]]):
"""
boundary of a list of edges, i.e. an arbitrary 1-chain over Z/2Z
"""
boundary_list = [self.boundary_1(edge) for edge in edges]
a = Counter([y for x in boundary_list for y in x])
boundary_list = [x[0] for x in a.items() if x[1] % 2 == 1]
return boundary_list
def boundary_2(self, face):
"""
compute boundary of a single face
"""
boundary = self.code_graph.neighbors(face)
return boundary
def del_2(self, faces: List[Tuple[int]]):
"""
boundary of a list of faces, i.e. an arbitrary 2-chain over Z/2Z
"""
boundary_list = [self.boundary_2(face) for face in faces]
a = Counter([y for x in boundary_list for y in x])
boundary_list = [x[0] for x in a.items() if x[1] % 2 == 1]
return boundary_list
def coboundary_1(self, star):
"""
compute coboundary of a single star
"""
coboundary = self.code_graph.neighbors(star)
return coboundary
def delta_1(self, stars: List[Tuple[int]]):
"""
coboundary of a list of stars, i.e. an arbitrary 0-cochain over Z/2Z
"""
coboundary_list = [self.coboundary_1(star) for star in stars]
a = Counter([y for x in coboundary_list for y in x])
coboundary_list = [x[0] for x in a.items() if x[1] % 2 == 1]
return coboundary_list
def coboundary_2(self, edge):
"""
compute coboundary of a single edge given by a white node (cycle in alpha)
"""
coboundary2 = [node for node in self.code_graph.neighbors(edge) if node in self.phi_dict]
return coboundary2
def delta_2(self, edges: List[Tuple[int]]):
"""
coboundary of a list of edges, i.e. an arbitrary 1-cochain over Z/2Z
given by a list of cycles in alpha
"""
coboundary_list = [self.coboundary_2(edge) for edge in edges]
a = Counter([y for x in coboundary_list for y in x])
coboundary_list = [x[0] for x in a.items() if x[1] % 2 == 1]
return coboundary_list
def euler_characteristic(self):
"""
Compute the Euler characteristic of the surface in which the graph is embedded
"""
chi = len(self.phi) - len(self.alpha) + len(self.sigma)
return (chi)
def genus(self):
"""
Compute the genus of the surface in which the graph is embedded
"""
g = int(-(len(self.phi) - len(self.alpha) + len(self.sigma) - 2) / 2)
return (g)
def draw(self, node_type='', layout = ''):
"""
Draw graph with vertices, edges, and faces labeled by colored nodes and their integer indices
corresponding to the qubit indices for the surface code
"""
if not node_type in ['cycles', 'dict']:
raise ValueError('node_type can be "cycles" or "dict"')
if layout == 'spring':
pos=nx.spring_layout(self.code_graph)
if layout == 'spectral':
pos=nx.spectral_layout(self.code_graph)
if layout == 'planar':
pos=nx.planar_layout(self.code_graph)
if layout == 'shell':
pos=nx.shell_layout(self.code_graph)
if layout == 'circular':
pos=nx.circular_layout(self.code_graph)
if layout == 'spiral':
pos=nx.spiral_layout(self.code_graph)
if layout == 'random':
pos=nx.random_layout(self.code_graph)
# white nodes
nx.draw_networkx_nodes(self.code_graph, pos,
nodelist=list(self.alpha),
node_color='c',
node_size=500,
alpha=0.3)
# vertex nodes
nx.draw_networkx_nodes(self.code_graph, pos,
nodelist=list(self.sigma),
node_color='b',
node_size=500,
alpha=0.6)
# face nodes
nx.draw_networkx_nodes(self.code_graph, pos,
nodelist=list(self.phi),
node_color='r',
node_size=500,
alpha=0.6)
# edges
nx.draw_networkx_edges(self.code_graph, pos, width=1.0, alpha=0.5)
labels={}
if node_type == 'cycles':
'''
label nodes the cycles of sigma, alpha, and phi
'''
for node in self.alpha_dict:
# stuff = self.alpha_dict[node]
labels[node]=f'$e$({node})'
for node in self.sigma_dict:
# something = self.sigma_dict[node]
labels[node]=f'$v$({node})'
for node in self.phi_dict:
# something2 = self.phi_dict[node]
labels[node]=f'$f$({node})'
nx.draw_networkx_labels(self.code_graph, pos, labels, font_size=12)
if node_type == 'dict':
'''
label nodes with v, e, f and indices given by node_dict corresponding to
qubit indices of surface code
'''
for node in self.alpha_dict:
# stuff = self.alpha_dict[node]
labels[node]=f'$e$({self.alpha_dict[node]})'
for node in self.sigma_dict:
# something = self.sigma_dict[node]
labels[node]=f'$v$({self.sigma_dict[node]})'
for node in self.phi_dict:
# something2 = self.phi_dict[node]
labels[node]=f'$f$({self.phi_dict[node]})'
nx.draw_networkx_labels(self.code_graph, pos, labels, font_size=12)
# plt.axis('off')
# plt.savefig("labels_and_colors.png") # save as png
plt.show() # display
```
# Example 1
---
Here we define two permutations,
\begin{align}
\sigma &= (0,1,2)(3,4,5)(6,7) \\
\alpha &= (0,3)(1,6)(2,4)(5,7).
\end{align}
The cycles in $\sigma$ will correspond to vertices with *half-edges* attached to them in the cyclic ordering specified by each cycle. In this example, there are three vertices. One is labeled by $(0,1,2)$, the next is labeled by $(3,4,5)$, and the third is labeled by $(6,7)$. The cycles labeling each vertex tell us there are three half-edges connected to the first vertex, three on the second vertex, and two on the third vertex.
The permutation $\alpha$ gives us a way of *gluing* the half-edges to each other. So the first cycle of $\alpha$, $(0,3)$, tells us to glue the half-edges $0$ and $3$. Similarly, we glue the half-edges $1$ and $6$ since the second cycle of $\alpha$ is $(1,6)$. So, we can take the cycles in $\alpha$ as labels of the edges of the graph we are creating.
Our class `SurfaceCodeGraph` will create *white* nodes on these edges which are labeled by the cycles of $\alpha$. These wil be important later when we create the class `SurfaceCodeCircuit`. The next thing to note is that once we have this graph glued together, there is a minimal genus surface into which it naturally embeds. The genus of this surface can be computed very easily once we know what the faces are. To compute the faces we need to compute a third permutation $\phi = (\sigma \alpha)^{-1}$. This is done automatically by the class, and can be printed off. In our example
\begin{align}
\phi = (0, 4) (1, 3, 7) (2, 6, 5).
\end{align}
In order to perform computations with permutations we use SymPy. The documentation on permutations can be found [here](https://docs.sympy.org/latest/modules/combinatorics/permutations.html). Let's have a look at our example by creating an instance of `SurfaceCodeGraph` corresponding to the permutations
\begin{align}
\sigma &= (0,1,2)(3,4,5)(6,7) \\
\alpha &= (0,3)(1,6)(2,4)(5,7).
\end{align}
```python
sigma = ((0,1,2),(3,4,5),(6,7))
alpha = ((0,3),(1,6),(2,4),(5,7))
SCG = SurfaceCodeGraph(sigma, alpha)
SCG
```
<__main__.SurfaceCodeGraph at 0x7fc8b6def190>
Now, we can draw the graph with the `draw` method with option `'cycles'` to label the vertex, edge, and face nodes by the cycles from `sigma`, `alpha`, and `phi` respectively, along with a `v`, `e`, or `f`, depending on whether they correspond to a vertex, edge, or face. We can also use the following layout options,
- `'spring'`
- `'spectral'`
- `'planar'`
- `'shell'`
- `'circular'`
- `'spiral'`
- `'random'`
```python
SCG.draw('cycles', 'spring')
```
To see which nodes correspond to *faces*, we can print off $\phi$.
```python
SCG.phi
```
((0, 4), (1, 3, 7), (2, 6, 5))
Now, we can print off the `node_info`, which is a dictionary built by `SurfaceCodeGraph`. The dictionary enumerates the vertices of the graph corresponding to $\sigma$, $\alpha$, and $\phi$, so that we have a complete enumeration of all vertices of the graph created.
```python
SCG.node_info
```
['sigma:',
{(0, 1, 2): 0, (3, 4, 5): 1, (6, 7): 2},
'alpha:',
{(0, 3): 6, (1, 6): 7, (2, 4): 8, (5, 7): 9},
'phi:',
{(0, 4): 3, (1, 3, 7): 4, (2, 6, 5): 5}]
This graph has three *black* vertices corresponding to $\sigma$, `0`, `1`, and `2`. There are four *white* vertices corresponding to $\alpha$, `6`, `7`, `8`, and `9`. It also has three more *black* vertices corresponding to $\phi$, `3`, `4`, and `5`. We can print off all of the nodes at once with their original labels given by the cycles of the permutations $\sigma, \alpha$, and $\phi$ as follows.
```python
SCG.code_graph.nodes
```
NodeView(((0, 1, 2), (3, 4, 5), (6, 7), (0, 4), (1, 3, 7), (2, 6, 5), (0, 3), (1, 6), (2, 4), (5, 7)))
To see the bipartite sets we can use the following methods, which print off the `white_nodes` and `black_nodes`.
```python
bipartite.sets(SCG.code_graph)
```
({(0, 1, 2), (0, 4), (1, 3, 7), (2, 6, 5), (3, 4, 5), (6, 7)},
{(0, 3), (1, 6), (2, 4), (5, 7)})
```python
SCG.white_nodes
```
{(0, 3), (1, 6), (2, 4), (5, 7)}
```python
SCG.black_nodes
```
{(0, 1, 2), (0, 4), (1, 3, 7), (2, 6, 5), (3, 4, 5), (6, 7)}
There is an alternative method for drawing the graph which colors the vertices, edges, and faces with blue, cyan, and red, resepctively. It also prints `v`, `e`, or `f` depending on whether the node corresponds to a vertex, edge, or face, along with the dictionary value corresponding to the integer index that labels the qubits in the surface code (which we discuss a bit later).
```python
SCG.draw('dict', 'spring')
```
We can compute the *Euler characteristic*, which is give by the formula
\begin{align}
\chi &= V-E+F \\
&= |\sigma| - |\alpha| + |\phi|,
\end{align}
which in our case is
\begin{align}
3 - 4 + 3 = 2.
\end{align}
`SurfaceCodeGraph` has a method for computing the Euler characteristic.
```python
SCG.euler_characteristic()
```
2
The next natural thing we might want to know is the *genus* of the surface the graph is naturally embedded in. This can be computed using the formula
\begin{align}
\chi &= 2-2g \\
& \implies 2 = 2-2g \\
& \implies 0 = -2g \\
& \implies 0 = g.
\end{align}
So, we have a genus zero surface, a sphere. `SurfaceCodeGraph` has a method for this as well.
```python
SCG.genus()
```
0
Now, something that is important for working with surface codes is computing the *boundary operator* applied to a list of faces. The boundaries are computed over $\mathbb{Z}/2\mathbb{Z}$-homology. This is in general a map that takes faces to edges, and edges to vertices,
\begin{align}
\partial_2: & F \to E \\
\partial_1: & E \to V.
\end{align}
So, the way we have constructed our graph, this amounts to computing the edge nodes which are connected to a node corresponding to a face. We can do this for a single face, or for a list of faces. Since we are working with $\mathbb{Z}/2\mathbb{Z}$-homology, which is typical in surface code calculations, we only work with lists of faces. In more general settings, such as $\mathbb{Z}$-homology, we can have a vector with integer entries representing that we have multiple copies of faces, but this is more general than we need here, and the coefficients are just zero or one, so lists of faces will suffice.
As an example, if we compute the boundary of the face $(1,3,7)$, we get get a list of *white* nodes (always from $\alpha$) which are the boundary. The list will be $[(0, 3), (1, 6), (5, 7)]$. There is a method in `SurfaceCodeGraph` for computing the boundary of arbitrary lists of faces.
```python
SCG.del_2([(1,3,7)])
```
[(0, 3), (1, 6), (5, 7)]
Now, let's compute the boundary of $[(0, 4), (1,3,7)]$.
```python
SCG.del_2([(0, 4), (1,3,7)])
```
[(2, 4), (1, 6), (5, 7)]
Something important to notice here is that while $e = (0,3)$ is in the boundary of both $(0,4)$ and of $(1,3,7)$, since we are working over $\mathbb{Z}/2\mathbb{Z}$, $2e = 0e = 0$. In other words, two copies is the same as zero copies of an edge since we are working **mod** $2$. Mathematically this can be written as follows,
\begin{align}
\partial_2((0, 4) + (1,3,7)) &= \partial_2((0, 4)) + \partial_2((1,3,7))\\
&= [(2, 4)+(0, 3)] + [(0, 3) + (1, 6) + (5, 7)] \\
&= 2(0,3) + (2, 4) + (1, 6) + (5, 7)\\
&= (2, 4) + (1, 6) + (5, 7).
\end{align}
Now, we can also compute *coboundaries* of vertices (always given by lists of elements from $\sigma$). Coboundaries of vertices are the edges attached to a vertex. Coboundaries of edges are the faces on either side of the edge. So the coboundary maps are
\begin{align}
\delta_1: & V \to E \\
\delta_2: & E \to F.
\end{align}
As an example, let's use the method of `SurfaceCodeGraph` to compute the coboundary of the vertex $(0,1,2)$.
```python
SCG.delta_1([(0,1,2)])
```
[(0, 3), (1, 6), (2, 4)]
This is a list of edges (always given by cycles of $\alpha$, i.e. *white* nodes). Now, Let's compute the *coboundary* of the vertices $[(0,1,2), (3, 4, 5)]$.
```python
SCG.delta_1([(0,1,2), (3,4,5)])
```
[(1, 6), (5, 7)]
Notice, here again we have the white nodes $(0,3)$ and $(2,4)$ are both in the coboundary of the vertex $(0,1,2)$ and of the vertex $(3,4,5)$. However, since they show up twice, their coefficient is $2$, which is $0$ **mod** $2$.
Now, let's use the method `boundary_1` which computes the boundary of a single edge (given by a cycle in alpha, which corresponds to a white node in the graph). This should return a list of vertices labeled by cycles of $\sigma$.
```python
SCG.boundary_1((0,3))
```
[(0, 1, 2), (3, 4, 5)]
```python
SCG.boundary_1((1,6))
```
[(0, 1, 2), (6, 7)]
Next, we compute the boundary of a list of edges, i.e. an arbitrary $1$-chain. Here we use the method `del_1` ($\partial_1: E \to V$) and the method should return a list of vertices labeled by cycles in $\sigma$. Again, remember we are working over $\mathbb{Z}/2\mathbb{Z}$ so if there is an overlap in boundaries between two edges, they cancel **mod** $2$.
```python
SCG.del_1([(0,3), (1,6)])
```
[(3, 4, 5), (6, 7)]
Notice, the boundary vertex $(0,1,2)$ does not appear since we are working **mod** $2$, i.e. because it is in the boundary of both $(0,3)$ and $(1,6)$. Mathematically we have
\begin{align}
\partial_1((0,3) + (1,6)) &= \partial_1((0,3)) + \partial_1((1,6)) \\
&= [(0,1,2)+(3,4,5)] + [(0,1,2)+(6,7)] \\
&= 2(0,1,2)+(3,4,5)+(6, 7)\\
&= (3, 4, 5) + (6, 7).
\end{align}
Of course, we can use the `coboundary_2` method to compute coboundaries of a single edge too. This will return two faces labeled by cycles in $\phi$ that lie on either side of an edge.
```python
SCG.coboundary_2((0,3))
```
[(0, 4), (1, 3, 7)]
```python
SCG.coboundary_2((1,6))
```
[(1, 3, 7), (2, 6, 5)]
Next, let's combute the coboundary of a list of edges, i.e. an arbitrary $1$-cochain. This is done using the method `delta_2`:
\begin{align}
\delta_2:E \to F.
\end{align}
This will return a list of faces lying on either side of the edges, and as usual it will be over $\mathbb{Z}/2\mathbb{Z}$.
```python
SCG.delta_2([(0,3), (1,6)])
```
[(0, 4), (2, 6, 5)]
Mathematically, this is:
\begin{align}
\delta_2((0,3) + (1,6)) &= \delta_2((0,3)) + \delta_2((1,6)) \\
&= [(0, 4) + (1, 3, 7)] + [(1, 3, 7) + (2, 6, 5)] \\
&= (0, 4) + 2(1, 3, 7) + (2, 6, 5)\\
&= (0, 4) + (2, 6, 5),
\end{align}
since we are working over $\mathbb{Z}/2\mathbb{Z}$.
Now, we are going to create a class `SurfaceCodeCircuit`, which builds a quantum circuit in Qiskit corresponding to a `SurfaceCodeGraph`, which is built from the input data $\sigma, \alpha$.
```python
from typing import Tuple
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
# from SurfaceCodes.surface_code_class import SurfaceCodeGraph
# from SurfaceCodes.utilites import permlist_to_tuple
class SurfaceCodeCircuit(QuantumCircuit):
def __init__(self, sigma: Tuple[Tuple[int]], alpha: Tuple[Tuple[int]]):
super().__init__()
self.sigma = sigma
self.alpha = alpha
self.scgraph = SurfaceCodeGraph(self.sigma, self.alpha)
'''
Compute the permutation corresponding to phi and create a
'surface code circuit' based on a (multi)graph 'surface_code_graph'
given by sigma, alpha, and phi
Create quantum and classical registers based on the number of nodes in G
'''
# f = self.scgraph.compute_phi()
self.phi = self.scgraph.phi
self.qr = QuantumRegister(len(self.scgraph.code_graph.nodes))
self.cr = ClassicalRegister(len(self.scgraph.code_graph.nodes))
self.circ = QuantumCircuit(self.qr, self.cr)
self.node_info = self.scgraph.node_dict
self.sigma_dict, self.alpha_dict, self.phi_dict = self.node_info
for cycle in self.sigma:
self.circ.h(self.sigma_dict[cycle])
for cycle in self.phi:
self.circ.h(self.phi_dict[cycle])
def x_measurement(self, qubit: int, cbit: int):
"""Measure 'qubit' in the X-basis, and store the result in 'cbit'
:param qubit, cbit:
:return None
"""
# circuit.measure = measure # fix a bug in qiskit.circuit.measure
self.circ.h(qubit)
self.circ.measure(qubit, cbit)
self.circ.h(qubit)
def star_syndrome_measure(self, vertex: Tuple[int]):
"""
Applies CX gates to surrounding qubits of a star then measures star qubit in X-basis
:param vertex:
:return: self.circ, self.scgraph, self.node_info
"""
for node in self.scgraph.code_graph.neighbors(vertex):
self.circ.cx(self.sigma_dict[vertex], self.alpha_dict[node])
self.circ.barrier()
self.x_measurement(self.sigma_dict[vertex], self.sigma_dict[vertex])
self.circ.barrier()
return self.circ, self.scgraph, self.node_info
def face_syndrome_measure(self, vertex: Tuple[int]):
"""
Applies CZ gates to surrounding qubits of a face then measures face qubit in X-basis
:param vertex:
:return:
"""
for node in self.scgraph.code_graph.neighbors(vertex):
self.circ.cz(self.phi_dict[vertex], self.alpha_dict[node])
self.circ.barrier()
self.x_measurement(self.phi_dict[vertex], self.phi_dict[vertex])
self.circ.barrier()
return self.circ, self.scgraph, self.node_info
def product_Z(self, faces):
"""
Pauli product Z operator for arbitrary 2-chain boundary
"""
boundary_nodes = self.scgraph.del_2(faces)
for node in boundary_nodes:
self.circ.z(self.alpha_dict[node])
def product_X(self, stars):
"""
Pauli product X operator for arbitrary 0-cochain coboundary
"""
coboundary_nodes = self.scgraph.delta_1(stars)
for node in coboundary_nodes:
self.circ.x(self.alpha_dict[node])
def draw_graph(self, node_type='', layout = ''):
if layout == 'spring':
pos=nx.spring_layout(self.scgraph.code_graph)
if layout == 'spectral':
pos=nx.spectral_layout(self.scgraph.code_graph)
if layout == 'planar':
pos=nx.planar_layout(self.scgraph.code_graph)
if layout == 'shell':
pos=nx.shell_layout(self.scgraph.code_graph)
if layout == 'circular':
pos=nx.circular_layout(self.scgraph.code_graph)
if layout == 'spiral':
pos=nx.spiral_layout(self.scgraph.code_graph)
if layout == 'random':
pos=nx.random_layout(self.scgraph.code_graph)
if node_type == 'cycles':
self.scgraph.draw('cycles', layout)
if node_type == 'dict':
self.scgraph.draw('dict', layout)
```
This class will create a Qiskit circuit, with all black nodes of its `SurfaceCodeGraph` (corresponding to $\sigma$ and $\phi$) initialized in the $|+\rangle = H|0\rangle$ state, by applying a Hadamard gate. The *white* nodes, correspnding to the edges of the graph constructed by `SurfaceCodeGraph` (i.e. by cycles of $\alpha$), will be left alone and so will be in the $|0\rangle$ state.
```python
SCC = SurfaceCodeCircuit(sigma, alpha)
```
```python
SCC.circ.draw('mpl')
```
Now, we can draw the corresponding graph, which in this case is the same as the graph we created above for our examples of `SurfaceCodeGraph`.
```python
nx.draw(SCC.scgraph.code_graph, with_labels = True)
```
We can also use the `draw_graph()` method with either `'cycles'` or `'dict'` as the `node_type`. This will draw the same graph as the `SurfaceCodeGraph` method `draw()`. The nodes of the graph will be labeled by a `v`, `e`, or `f` depending on whether the nodes correspond to a vertex, edge, or face. If the option `cycles` is chosen the nodes are labeled by the corresponding cycles from `sigma`, `alpha`, and `phi`. If the option `dict` is chosen for `node_type` they will be labeled by the corresponding qubit indices (integers).
```python
SCC.draw_graph('cycles', 'spring')
```
```python
SCC.draw_graph('dict', 'spring')
```
We can again print out the `node_info`, which is a dictionary from the node lables to integers. The first row is for $\sigma$, the second row is for $\alpha$, and the third row is for $\phi$.
```python
SCC.node_info
```
({(0, 1, 2): 0, (3, 4, 5): 1, (6, 7): 2},
{(0, 3): 6, (1, 6): 7, (2, 4): 8, (5, 7): 9},
{(0, 4): 3, (1, 3, 7): 4, (2, 6, 5): 5})
We can print $\sigma, \alpha$, and $\phi$.
```python
SCC.sigma
```
((0, 1, 2), (3, 4, 5), (6, 7))
```python
SCC.alpha
```
((0, 3), (1, 6), (2, 4), (5, 7))
```python
SCC.phi
```
((0, 4), (1, 3, 7), (2, 6, 5))
We can also print of all of the nodes which are labeles by the cycles of $\sigma, \alpha$, and $\phi$.
```python
SCC.scgraph.code_graph.nodes
```
NodeView(((0, 1, 2), (3, 4, 5), (6, 7), (0, 4), (1, 3, 7), (2, 6, 5), (0, 3), (1, 6), (2, 4), (5, 7)))
Now, there is a `star_syndrome_measure` method in SurfaceCodeCircuit which implements the generalization of the following *syndrome measurement* found on page 108 of [Quantum Computation with Topological Codes: from qubit to topological fault-tolerance](https://arxiv.org/pdf/1504.01444.pdf):
The picture above (on the right) is for *star* syndrome measurements of the *toric code*, however our implementation will work for *arbitrary* surface codes given by *arbitrary* graphs embedded in surfaces. This will apply Controlled-$Z$ gates from a qubit corresponding to a vertex (given by a cycle in $\sigma$) to the target qubits given by the coboundary of that vertex, which are edges connected to it labeled by *white* nodes (corresponding to cycles in $\alpha$). The picture above (on the left) also has *plaquette* measurements. Again, our implementation will work for arbitrary surface codes (for arbitrary graphs embedded in surfaces). The *plaquette syndrome measurement* will apply Controlled-$NOT$ gates with source qubit given by a qubit corresponding to a face, and target qubits given by the boundary of that face. The boundary will correspond to *white* nodes (given by cycles in $\alpha$). Let's apply the star syndrome measurement for the vertex $(0,1,2)$.
```python
SCC.star_syndrome_measure(((0,1,2)))
SCC.circ.draw('mpl')
```
Now, let's apply the plaquette syndrome measurement corresponding to the face $(2,6,5)$.
```python
SCC.face_syndrome_measure(((2, 6, 5)))
SCC.circ.draw('mpl')
```
Again, it is important to note that if our list of faces or stars is given as input for the above two functions has faces with edges in common, an even number of occurences of the same edge means that edge doesn't show up in the output. On the other hand if there are an odd number of occurence of an edge, that edge does show up in the output. This reflects the $\mathbb{Z}/2\mathbb{Z}$-chain complex structure. This can all be phrased in terms of linear algebra and treating $V$, $E$, and $F$ as vector spaces over $\mathbb{Z}/2\mathbb{Z}$. For more background on the math involved see Chapter 3 of [Quantum Computation with Topological Codes: from qubit to topological fault-tolerance](https://arxiv.org/pdf/1504.01444.pdf).
At this point we should mention that a list of faces will form a $2$-chain, and a list of stars (vertices in $\sigma$) forms a $0$-cochain. From this, along with the boundary and coboundary operators we just defined, we can define the Pauli product operators. The first kind of Pauli product operators we define are
\begin{align}
W(c_1) = \bigotimes_{k}W(e_k)^{n(k)},
\end{align}
where $n(k) \in \{0,1\}$, and $c_1$ is a "$1$-chain" given by a list of edges (each edge corresponding to a cycle in $\alpha$). Each $W_k \in \{X_k, Y_k, Z_k\}$ is a Pauli operator that operates on the $k^{th}$ qubit, where $k$ is the index of the qubit corresponding to an edge. We can get this index using `node_info`, in particular `alpha_dict`, the middle dictionary, which gives us the indices of qubits corresponding to each edge (white node).
Now, if we compute the boundary $\partial_2(c_2)$ of a $2$-chain (given by a list of faces), we will get a $1$-chain. This $1$-chain will be a list of edges that form the boundary of the faces. From this, we can compute the "**plaquette operators**", i.e. **face operators**,
\begin{align}
Z(\partial_2f_k) = \bigotimes_{e_j \in \partial_2f_k} Z(e_j)
\end{align}
where $\partial_2f_k$ is the edge list forming the boundary of the face $f_k \in F$. We can also computer the "**star operators**",
\begin{align}
X(\delta_1 v_m) = \bigotimes_{e_j \in \delta_1v_m} X(e_j),
\end{align}
where $\delta_1 v_m$ is the edge list forming the *coboundary* of the vertex $v_m$ (which corresponds to some cycle permutation in $\sigma$). These form the **stabilizer generators** for the surface code. For a refresher on stabilizer generators we refer to the notebooks on [error correction](https://github.com/The-Singularity-Research/error-correction) and on [graph states](https://github.com/The-Singularity-Research/graph-state-quantum-cryptography/blob/master/certifying_graph_states.ipynb). Now, let's define a Pauli product $Z$ operator $Z(\partial_2 c_2)$ for the boundary of an arbitray $2$-chain $c_2$, as well as a Pauli product $X$ operator $X(\delta_1 c_0)$ for the coboundary of an arbitrary $0$-cochain $c_0$. The following image can be found on page 76 of [Quantum Computation with Topological Codes: from qubit to topological fault-tolerance](https://arxiv.org/pdf/1504.01444.pdf), and the table below can be found on page 68.
We can apply the *Pauli product*-$Z$ operator corresponding to arbitrary $2$-chain boundaries. Let's do this for the list of two faces $[(0, 4), (2, 6, 5)]$.
```python
SCC.product_Z([(0, 4), (2, 6, 5)])
SCC.circ.draw('mpl')
```
We can also apply the *Pauli product*-$X$ operator corresponding to arbitrary $0$-cochain coboundaries. Let's do this for the list of two vertices $[(3, 4, 5), (6, 7)]$.
```python
SCC.product_X([(3, 4, 5), (6, 7)])
SCC.circ.draw('mpl')
```
The two methods `product_Z` and `product_X` use the methods `del_2` and `delta_1` of `SurfaceCodeGraph`, respectively, in order to compute boundaries of faces and coboundaries of vertices to apply the Pauli-$Z$ and Pauli-$X$ gates to.
---
## Example 2
---
The following choice for $[\sigma, \alpha]$ will construct a graph on a sphere, which we can check by computing the genus of the surface.
```python
sigma = ((0,1),(2,3,4),(5,6,7),(8,9),(10,11,12),(13,14,15,16),(17,18,19,20),(21,22,23),(24,25,26),(27,28,29,30),(31,32,33,34),(35,36,37),(38,39),(40,41,42),(43,44,45),(46,47))
alpha = ((0,2),(1,10),(3,5),(4,14),(6,8),(7,18),(9,22),(11,13),(12,24),(15,17),(16,28),(19,21),(20,32),(23,36),(25,27),(26,38),(29,31),(30,41),(33,35),(34,44),(37,47),(39,40),(42,43),(45,46))
```
```python
SCG = SurfaceCodeGraph(sigma, alpha)
SCG.genus()
```
0
Now, we know this graph has a planar embedding since its genus is $g = 0$. So, let's attempt to use the `planar` drawing option to draw the graph in the plane.
```python
SCG.draw('dict', 'planar')
```
Clearly, this is a confusing drawing. So, what other options do we have? We can plot with the layout options:
- `'spring'`
- `'spectral'`
- `'planar'`
- `'shell'`
- `'circular'`
- `'spiral'`
- `'random'`
So, let's try the `'spectral'` option.
```python
SCG.draw('dict', 'spectral')
```
This is a little better, but it's still quite messy. Let's find out how many nodes the graph has.
```python
len(SCG.code_graph.nodes())
```
50
The number of vertices is just the number of cycles in `sigma`.
```python
len(SCG.sigma)
```
16
The number of edges is the number of cycles in `alpha`.
```python
len(SCG.alpha)
```
24
The number of faces is the number of cycles in `phi`.
```python
len(SCG.phi)
```
10
Let's print off the faces.
```python
SCG.phi
```
((0, 10, 24, 38, 40, 43, 46, 37, 23, 9, 6, 3),
(1, 2, 14, 11),
(4, 5, 18, 15),
(7, 8, 22, 19),
(12, 13, 28, 25),
(16, 17, 32, 29),
(20, 21, 36, 33),
(26, 27, 41, 39),
(30, 31, 44, 42),
(34, 35, 47, 45))
Now, let's print off all of the nodes, including those labeling the edges given by the cycles in `alpha`.
```python
SCG.code_graph.nodes()
```
NodeView(((0, 1), (2, 3, 4), (5, 6, 7), (8, 9), (10, 11, 12), (13, 14, 15, 16), (17, 18, 19, 20), (21, 22, 23), (24, 25, 26), (27, 28, 29, 30), (31, 32, 33, 34), (35, 36, 37), (38, 39), (40, 41, 42), (43, 44, 45), (46, 47), (0, 10, 24, 38, 40, 43, 46, 37, 23, 9, 6, 3), (1, 2, 14, 11), (4, 5, 18, 15), (7, 8, 22, 19), (12, 13, 28, 25), (16, 17, 32, 29), (20, 21, 36, 33), (26, 27, 41, 39), (30, 31, 44, 42), (34, 35, 47, 45), (0, 2), (1, 10), (3, 5), (4, 14), (6, 8), (7, 18), (9, 22), (11, 13), (12, 24), (15, 17), (16, 28), (19, 21), (20, 32), (23, 36), (25, 27), (26, 38), (29, 31), (30, 41), (33, 35), (34, 44), (37, 47), (39, 40), (42, 43), (45, 46)))
Now, we're going to remove one of the face nodes and all of the edges connected to it.
```python
SCG.code_graph.remove_node((0, 10, 24, 38, 40, 43, 46, 37, 23, 9, 6, 3))
```
```python
len(SCG.code_graph.nodes())
```
49
Now, let's try using the NetworkX methods for drawing the spectral layout of the graph without the newly deleted node.
```python
nx.draw_spectral(SCG.code_graph, with_labels = False)
```
Clearly, this graph can be drawn as a grid in the plane. The way we have constructed it, it is actually isomorphic to a $7 \times 7$ grid of qubits with nearest neighbor connectivity. Let's check this by defining such a graph in NetworkX.
```python
G = nx.Graph()
```
```python
pos = dict()
for x in range(7):
for y in range(7):
G.add_node((x,y))
pos[(x,y)] = (x,y)
if x>0:
G.add_edge((x-1,y),(x,y))
if y>0:
G.add_edge((x,y),(x,y-1))
nx.draw(G, pos=pos, with_labels = True)
```
We can check that the two graphs are isomorphic as follows.
```python
nx.is_isomorphic(SCG.code_graph, G)
```
True
Now, we are going to use a NetworkX method to find the actual isomorphism.
```python
G1, G2 = SCG.code_graph, G
```
```python
GM = nx.isomorphism.GraphMatcher(G1,G2)
GM.is_isomorphic()
```
True
The following gives us the mapping of the actual nodes. The keys in the dictionary are the nodes of the graph `SCG.code_graph` (without the deleted face node), the values are the nodes of the graph we just constructed.
```python
GM.mapping
```
{(0, 1): (0, 0),
(1, 10): (0, 1),
(10, 11, 12): (0, 2),
(12, 24): (0, 3),
(24, 25, 26): (0, 4),
(26, 38): (0, 5),
(38, 39): (0, 6),
(0, 2): (1, 0),
(1, 2, 14, 11): (1, 1),
(11, 13): (1, 2),
(12, 13, 28, 25): (1, 3),
(25, 27): (1, 4),
(26, 27, 41, 39): (1, 5),
(39, 40): (1, 6),
(2, 3, 4): (2, 0),
(4, 14): (2, 1),
(13, 14, 15, 16): (2, 2),
(16, 28): (2, 3),
(27, 28, 29, 30): (2, 4),
(30, 41): (2, 5),
(40, 41, 42): (2, 6),
(3, 5): (3, 0),
(4, 5, 18, 15): (3, 1),
(15, 17): (3, 2),
(16, 17, 32, 29): (3, 3),
(29, 31): (3, 4),
(30, 31, 44, 42): (3, 5),
(42, 43): (3, 6),
(5, 6, 7): (4, 0),
(7, 18): (4, 1),
(17, 18, 19, 20): (4, 2),
(20, 32): (4, 3),
(31, 32, 33, 34): (4, 4),
(34, 44): (4, 5),
(43, 44, 45): (4, 6),
(6, 8): (5, 0),
(7, 8, 22, 19): (5, 1),
(19, 21): (5, 2),
(20, 21, 36, 33): (5, 3),
(33, 35): (5, 4),
(34, 35, 47, 45): (5, 5),
(45, 46): (5, 6),
(8, 9): (6, 0),
(9, 22): (6, 1),
(21, 22, 23): (6, 2),
(23, 36): (6, 3),
(35, 36, 37): (6, 4),
(37, 47): (6, 5),
(46, 47): (6, 6)}
So, we could represent the original graph as a grid of qubits on the sphere, with on face node outside of the grid on the opposite side of the sphere, which is connected to all of the edge nodes around the outside of the grid of qubits we just drew above. To see exactly which nodes correspond to vertices, edges, and faces, let's build a new coloring of the nodes of the graph `G`.
```python
node_color = {(x[0], x[1]): 1-((x[0]+x[1])%2)/2 for x in G.nodes()}
for y in range(1,7,2):
for z in range(1,7,2):
node_color[(y,z)] = .2
node_color = [node_color[x] for x in sorted(node_color.keys())]
```
```python
nx.draw(G, pos = pos, node_color = node_color)
```
Here, the yellow nodes are vertices (cycle in $\sigma$), the blue nodes are edges (cycles in $\alpha$), and the purple nodes are faces (cycles in $\phi$).
---
## References
---
### Quantum Computing and Surface Codes
- [Quantum Computation with Topological Codes: from qubit to topological fault-tolerance](https://arxiv.org/pdf/1504.01444.pdf)
- [A graph-based formalism for surface codes and twists](https://www.youtube.com/watch?v=Ca85qdptceQ)
- [Constructions and Noise Threshold of Hyperbolic Surface Codes](https://arxiv.org/pdf/1506.04029.pdf)
- [Homological Quantum Codes Beyond the Toric Code](https://arxiv.org/pdf/1802.01520.pdf)
- [Hyperbolic Lattices in Circuit Quantum Electrodynamics](https://arxiv.org/pdf/1802.09549.pdf)
- [Quantum Simulation of Hyperbolic Space with Circuit Quantum Electrodynamics: From Graphs to Geometry](https://arxiv.org/pdf/1910.12318.pdf)
- [Quantum Error Correction for Quantum Memories](https://arxiv.org/pdf/1302.3428.pdf)
- [Ribbon Graphs on nLab](https://ncatlab.org/nlab/show/ribbon+graph)
### Quantum Gravity and String Theory
- [Maxim Kontsevich, Intersection Theory on the Moduli Space of Curves and the Matrix Airy Function](http://pagesperso.ihes.fr/~maxim/TEXTS/Intersection%20theory%20and%20Airy%20function.pdf)
- [Ed Witten, On the Kontsevich Model and other Models of Two-Dimensional Gravity](https://lib-extopc.kek.jp/preprints/PDF/1992/9203/9203552.pdf)
- [Lando & Zvonkin, Graphs on Surfaces and Their Applications](https://link.springer.com/book/10.1007/978-3-540-38361-1)
### The Langlands Program and the Generalized Riemann Hypothesis
- [SURFACE ALGEBRAS I: DESSINS D’ENFANTS, SURFACE ALGEBRAS, AND DESSIN
ORDERS](https://arxiv.org/pdf/1810.06750.pdf)
- [SURFACE ALGEBRAS AND SURFACE ORDERS II: AFFINE BUNDLES ON CURVES](https://arxiv.org/pdf/1812.00621.pdf)
### Hardware Related Papers
- [Hyperbolic Lattices in Circuit Quantum Electrodynamics](https://arxiv.org/pdf/1802.09549.pdf)
- [Hyperbolic Lattices in Circuit Quantum Electrodynamics](https://arxiv.org/pdf/1802.09549.pdf)
|
#### 2019-07-31, Huan asked me to create a folder for output, to contain the .pdf, .stat.txt, .nuc.txt files for used samples
#### 2019-07-29, Huan asked me to add sample filter on minimum read number
#### 2019-07-26, Huan asked me to re-implement Strata with .nuc.txt files as input
#### 2019-07-17, Huan asked me to also output stat.txt file of the averaged SHM and error bar
# if (!requireNamespace("BiocManager", quietly = TRUE))
# install.packages("BiocManager")
# BiocManager::install("Biostrings", version = "3.8")
options(stringsAsFactors=FALSE)
#options(stringsAsFactors=FALSE, error=traceback)
### reference: yyx_echo_string_functions.20160420.r
`%.%` <- function(x,y) paste0(x,y)
join = function(sep, vec, ...) paste(collapse=sep, c(vec, ...))
cat0 = function(...) cat(sep="", ...)
echo_str <- function(x, sep=" =\t", collapse=", ") deparse(substitute(x)) %.% sep %.% join(collapse, x)
echo <- function(x, sep=" =\t", collapse=", ") cat0(deparse(substitute(x)), sep, join(collapse, x), "\n");
str_trim_left = function(str, trimLen){
strlen = nchar(str)
start = pmin(strlen, trimLen) + 1
end = strlen
substr(str, start, end)
}
str_left = function(str, len){
strlen = nchar(str)
start = 1
end = pmin(len, strlen)
substr(str, start, end)
}
### ref: yyx_rm_NA.yyx_convert_NA.20141114.r
yyx_NA2FALSE <- function(vec){
vec[is.na(vec)] <- FALSE
vec
}
yyx_convert_NA <- function(vec, default=FALSE){
vec[is.na(vec)] <- default
vec
}
### reference: SHMHelper.R
getBases <- function () {
bases <- c("A","C","G","T","N")
}
getAscii <- function () {
ascii <- c(65,67,71,84,78)
}
getBasecolors <- function () {
basecolors <- brewer.pal(7,"Set1")
}
### reference: Rsub.R
parseArgs <- function(scriptname, ARGS, OPTS=NULL) {
if (length(ARGS) %% 3 != 0)
stop("Error: ARGS must have length divisable by 3")
if (!is.null(OPTS) && length(OPTS) %% 4 != 0)
stop("Error: OPTS must have length divisable by 4")
ARGS <- matrix(ARGS, nrow=length(ARGS)/3, ncol=3, byrow=T, dimnames=list(c(),c("name","type","description")))
OPTS <- if (!is.null(OPTS)) matrix(OPTS, nrow=length(OPTS)/4, ncol=4, byrow=T, dimnames=list(c(),c("name","type","default","description")))
ARGV <- commandArgs(trailingOnly=TRUE)
catargs <- paste0("\t",ARGS[,"name"],"\t",ARGS[,"description"], collapse="\n")
catopts <- if (!is.null(OPTS)) paste0("\t-",OPTS[,"name"],"=",OPTS[,"default"],"\t", OPTS[,"description"], collapse="\n")
usage <- paste("\nUsage: Rscript ",scriptname," [OPTS] ",paste(ARGS[,"name"],collapse=" "),"\n\nOptions(=defaults):\n", catopts,"\n\nArguments:\n", catargs,"\n\n",sep="")
types <- c("character","numeric","integer","logical")
## initialize OPTS
if (!is.null(OPTS)) for (k in 1:nrow(OPTS)) {
if (!OPTS[k,"type"] %in% types)
stop("Unrecognized argument type ",OPTS[k,"type"]," for option ",OPTS[k,"name"],"\n",usage)
cmd <- paste(OPTS[k,"name"],"<<-as.",OPTS[k,"type"],"(\"",OPTS[k,"default"],"\")",sep="")
if(is.na(OPTS[k,"default"]) && OPTS[k,"type"]=="numeric"){
cmd <- OPTS[k,"name"] %.% "<<-NA"
}
# cat(paste0("[CMD] ", cmd, "\n"))
eval(parse(text=cmd))
}
if (length(ARGV) < nrow(ARGS)){
cat(usage)
stop("Not enough arguments.\n") # Yyx note 2019-07-29: stop() may has limit on the length of input string
}
## parse OPTS
k = 1
while(str_left(ARGV[k], 1)=="-"){
now_arg = str_trim_left(ARGV[k], 1)
now_regexec = regexec("(.*)=(.*)", now_arg)
# echo(now_arg)
# print(now_regexec)
if(now_regexec[[1]][1] >= 0){
now_matches = regmatches(now_arg, now_regexec)
now_name = now_matches[[1]][2]
now_value = now_matches[[1]][3]
if(now_name %in% OPTS[, "name"]){
idx <- match(now_name,OPTS[,"name"])
cmd <- paste(now_name,"<<-as.",OPTS[idx,"type"],"(\"",now_value,"\")",sep="")
# cat(paste0("[CMD] ", cmd, "\n"))
eval(parse(text=cmd))
}else{
stop("unrecognized option ",now_name," of ",ARGV[k],"\n",usage)
}
}else{
now_name = now_arg
if(now_name %in% OPTS[, "name"]){
idx <- match(now_name,OPTS[,"name"])
if(OPTS[idx,"type"]=="logical"){
cmd <- paste(OPTS[idx,"name"],"<<-!as.",OPTS[idx,"type"],"(\"",OPTS[idx,"default"],"\")",sep="")
# cat(paste0("[CMD] ", cmd, "\n"))
eval(parse(text=cmd))
}
}else{
# stop("option ",now_name," (",ARGV[k],") is not recognized\n",usage)
stop("unrecognized option or opt=value expression expected instead of ",ARGV[k],"\n",usage)
}
# cat(paste0("Warning: cannot recognize -", ARGV[k], " as -opt=value\n"))
# stop("opt=value expression expected instead of ",ARGV[k],"\n",usage)
}
k = k + 1
}
if (length(ARGV) - k + 1 < nrow(ARGS))
stop("Not enough arguments.\n",usage)
for (i in 1:nrow(ARGS)) {
if (! ARGS[i,"type"] %in% types)
stop("Unrecognized argument type ",ARGS[i,"type"]," for argument ",ARGS[i,"name"],"\n",usage)
cmd <- paste(ARGS[i,"name"],"<<-as.",ARGS[i,"type"],"(\"",ARGV[k],"\")",sep="")
# cat(paste0("[CMD] ", cmd, "\n"))
eval(parse(text=cmd))
k = k + 1
}
if (length(ARGV) - k + 1 > 0){
i = nrow(ARGS)
tail_ARGV_str = paste0(collapse="\",\"", ARGV[k:length(ARGV)])
cmd <- paste(ARGS[i,"name"],"<<-c(",ARGS[i,"name"],",as.",ARGS[i,"type"],"(c(\"",tail_ARGV_str,"\")))",sep="")
# cat(paste0("[CMD] ", cmd, "\n"))
eval(parse(text=cmd))
}
# if (length(ARGV) > i) for (j in (i+1):length(ARGV)) {
# opt <- unlist(strsplit(ARGV[j],"="))
# if (length(opt) != 2)
# stop("opt=value expression expected instead of ",ARGV[j],"\n",usage)
# if (is.null(OPTS) || ! opt[1] %in% OPTS[,"name"])
# stop("optional argument ",opt[1]," not recognized\n",usage)
# idx <- match(opt[1],OPTS[,"name"])
# cmd <- paste(opt[1],"<<-as.",OPTS[idx,"type"],"(\"",opt[2],"\")",sep="")
# eval(parse(text=cmd))
# }
}
### reference: SHMPlot2.noCov.R
ARGS <- c(
"output","character","file path prefix for output",
"statfile","character","file path of one guide (same V) .stat.txt file - 1~2th columns: Pos, Base",
"nucfile","character","file path of .nuc.txt file(s) - columns: Read_ID, base [ACGTN-.] on each position"
)
OPTS <- c(
"tstart","numeric",0,"Start of reference to view",
"tend","numeric",0,"End of reference to view",
"plotrows","numeric",1,"Rows on plot",
"ymax","numeric",0.75,"Maximum y-axis height",
"figureheight","numeric",2,"height in inches",
"showsequence","logical",FALSE,"display sequence on plots",
"regex1","character","AGCT","",
"regex2","character","[AGT](?=G[CT][AT])", "", # this is DGYW/WRCH motif
"cdr1_start","numeric",0,"Start of cdr1 region",
"cdr1_end","numeric",0,"End of cdr1 region",
"cdr2_start","numeric",0,"Start of cdr2 region",
"cdr2_end","numeric",0,"End of cdr2 region",
"cdr3_start","numeric",0,"Start of cdr3 region",
"cdr3_end","numeric",0,"End of cdr3 region",
"annotation","character","","V allele annotation (default: empty for no annotation)",
"mutMin","numeric",NA,"Minimum mutation number for stratification",
"mutMax","numeric",NA,"Maximum mutation number for stratification",
"mutMinProp","numeric",NA,"Minimum mutation number proportion for stratification",
"mutMaxProp","numeric",NA,"Maximum mutation number proportion for stratification",
"minReadNumB","numeric",0,"Minimum read number required for each sample before stratification",
"minReadNumA","numeric",0,"Minimum read number required for each sample after stratification",
"fo","logical",FALSE,"force output (default: stop if output file exists)"
)
#source_local <- function(fname){
# argv <- commandArgs(trailingOnly = FALSE)
# base_dir <- dirname(substring(argv[grep("--file=", argv)], 8))
# source(paste(base_dir, fname, sep="/"))
#}
#
#source_local("Rsub.R")
#source_local("SHMHelper.R")
parseArgs("yyx_SHMPlot2_Strata_ErrBar.20190731.r", ARGS, OPTS)
cat(paste0("Request to read ", length(nucfile), " nuc.txt files\n"))
for(k in 1:length(nucfile)){
cat(paste0("\t", k, "\t'", nucfile[k], "'\n"))
}
cat("\n")
output_pdf_filename = output %.% ".pdf"
output_stat_txt_filename = output %.% ".stat.txt"
output_used_nuc_list_filename = output %.% ".used_nuc_list.tsv"
if(!fo){
if(file.exists(output_pdf_filename)){
stop(paste0("Output pdf file '", output_pdf_filename, "' already exists.\n\tPlease remove it before run me.\n\tOr you can force output with the option '-fo=T'.\n"))
}
if(file.exists(output_stat_txt_filename)){
stop(paste0("Output stat.txt file '", output_stat_txt_filename, "' already exists.\n\tPlease remove it before run me.\n\tOr you can force output with the option '-fo=T'.\n"))
}
}
suppressPackageStartupMessages(library(RColorBrewer, quietly=TRUE))
suppressPackageStartupMessages(library(Biostrings, quietly=TRUE, verbose=FALSE))
bases <- getBases()
basecolors <- getBasecolors()
ascii <- getAscii()
cat("\n")
cat(paste0("Now reading guide '", statfile, "' ...\n"))
data <- read.delim(statfile, header=T, as.is=T)
data = data[, c("Pos", "Base")]
data$Pos = as.integer(data$Pos)
data = data[order(data$Pos),]
if (any(diff(data$Pos) != 1)) stop("Pos column must be sequential")
#echo(dim(data))
cat(" input gene number = " %.% nrow(data) %.% "\n")
refseq <- DNAString(paste(data$Base,collapse=""))
#cat(paste0(" initial nrow = ", nrow(data), "\n"))
each_total_Y_colidx = integer(0)
all_sample_prefixes = character(0)
used_nuc_files = character(0)
for(k in 1:length(nucfile)){
cat("Now reading in " %.% k %.% "-th nuc '" %.% nucfile[k] %.% "' ...\n")
now_sample_prefix = sub("^.*/", "", nucfile[k])
now_sample_prefix = sub("[.].*$", "", now_sample_prefix)
now_data <- read.delim(nucfile[k], header=T, as.is=T)
# echo(dim(now_data))
rownames(now_data) = now_data[,1]
now_data = now_data[,-1]
# echo(dim(now_data))
cat(" original dim = " %.% join(", ", dim(now_data)) %.% "\n")
if(ncol(now_data) != nrow(data)){
cat("Warning: .nuc.txt pos (ncol - 1) is not equal to .stat.txt pos (nrow), so I skip this .nuc.txt file\n")
next
}
# echo(dim(now_data))
## 2019-07-29, add sample filter on minReadNum
if(nrow(now_data) < minReadNumB){
cat("Warning: .nuc.txt read number (nrow=" %.% nrow(now_data) %.% ") is less than minReadNumB (" %.% minReadNumB %.% "), so I skip this .nuc.txt file\n")
next
}
## 2019-07-26, add stratification
### ref: intrinsicMutProfileStrata.20190726.py
eachReadMut = apply(now_data, 1, function(row) sum(row %in% c("A","C","G","T")))
eachReadWt = apply(now_data, 1, function(row) sum(row == "."))
eachReadTotal = eachReadMut + eachReadWt
eachReadMutProp = eachReadMut / eachReadTotal
# echo(length(eachReadTotal))
eachRead_boolIdx = rep(TRUE, nrow(now_data))
if(!is.na(mutMin)){
eachRead_boolIdx = eachRead_boolIdx & yyx_NA2FALSE(eachReadMut >= mutMin)
}
if(!is.na(mutMax)){
eachRead_boolIdx = eachRead_boolIdx & yyx_NA2FALSE(eachReadMut <= mutMax)
}
if(!is.na(mutMinProp)){
eachRead_boolIdx = eachRead_boolIdx & yyx_NA2FALSE(eachReadMutProp >= mutMinProp)
}
if(!is.na(mutMaxProp)){
eachRead_boolIdx = eachRead_boolIdx & yyx_NA2FALSE(eachReadMutProp <= mutMaxProp)
}
now_data = now_data[eachRead_boolIdx, ]
# echo(dim(now_data))
cat(" stratified dim = " %.% join(", ", dim(now_data)) %.% "\n")
## 2019-07-29, add sample filter on minReadNum
if(nrow(now_data) < minReadNumA){
cat("Warning: .nuc.txt read number (nrow=" %.% nrow(now_data) %.% ") is less than minReadNumA (" %.% minReadNumA %.% "), so I skip this .nuc.txt file\n")
next
}
eachPosMut = apply(now_data, 2, function(col) sum(col %in% c("A","C","G","T")))
eachPosWt = apply(now_data, 2, function(col) sum(col == "."))
eachPosTotal = eachPosMut + eachPosWt
# echo(length(eachPosTotal))
# data[["Mut." %.% k]] = eachPosMut
if(now_sample_prefix %in% all_sample_prefixes){
data[["Total." %.% now_sample_prefix %.% "." %.% (sum(all_sample_prefixes==now_sample_prefix)+1)]] = eachPosTotal
data[["Y." %.% now_sample_prefix %.% "." %.% (sum(all_sample_prefixes==now_sample_prefix)+1)]] = yyx_convert_NA(eachPosMut / eachPosTotal, 0)
}else{
data[["Total." %.% now_sample_prefix]] = eachPosTotal
data[["Y." %.% now_sample_prefix]] = yyx_convert_NA(eachPosMut / eachPosTotal, 0)
}
all_sample_prefixes = c(all_sample_prefixes, now_sample_prefix)
used_nuc_files = c(used_nuc_files, nucfile[k])
# cat(paste0(" updated nrow = ", nrow(data), "\n"))
each_total_Y_colidx = c(each_total_Y_colidx, ncol(data)-1, ncol(data))
}
#each_total_Y_colidx = c((1:length(nucfile))*3, (1:length(nucfile))*3-1)
#each_total_Y_colidx = c((1:length(nucfile))*2, (1:length(nucfile))*2-1)
#each_total_Y_colidx = sort(each_total_Y_colidx) + 2
cat("\nIn total, there are " %.% length(all_sample_prefixes) %.% " valid samples: " %.% join(", ", all_sample_prefixes) %.% "\n")
if(ncol(data) <= 2){ # no valid samples, maybe all filtered by minReadNum
cat("Note: because there seem to be no valid samples, so I just exit this R script\n")
q("no")
}
cat("\n")
cat(paste0("Now output used_nuc_list.tsv to '", output_used_nuc_list_filename, "' ...\n"))
write.table(data.frame(sample_name=all_sample_prefixes, nuc_path=used_nuc_files), file=output_used_nuc_list_filename, sep="\t", quote=FALSE, row.names=FALSE, col.names=FALSE)
### reference: intrinsicMutProfileErrBar.20190131.py
data$Total = apply(data[,each_total_Y_colidx], 1, function(row){
total_vec = row[seq(1, length(row), by=2)]
sum(total_vec)
})
data$Y = apply(data[,each_total_Y_colidx], 1, function(row){
total_vec = row[seq(1, length(row), by=2)]
Y_vec = row[seq(2, length(row), by=2)]
Y_vec_2 = Y_vec[total_vec > 0]
mean(Y_vec_2)
})
data$Err = apply(data[,each_total_Y_colidx], 1, function(row){
total_vec = row[seq(1, length(row), by=2)]
Y_vec = row[seq(2, length(row), by=2)]
Y_vec_2 = Y_vec[total_vec > 0]
sd(Y_vec_2)/sqrt(length(Y_vec_2))
})
cat("\n")
cat(paste0("Now output stat.txt to '", output_stat_txt_filename, "' ...\n"))
write.table(data, file=output_stat_txt_filename, sep="\t", quote=FALSE, row.names=FALSE)
data$Y[is.na(data$Y)] = 0
data$Err[is.na(data$Err)] = 0
if (tstart < data$Pos[1]) {
tstart <- data$Pos[1]
}
if (tend == 0 || tend > tail(data$Pos,n=1)) {
tend <- tail(data$Pos,n=1)
}
data$Style <- match(data$Base,bases)
data$cov <- data$Total/max(data$Total)
rowwidth <- ceiling((tend-tstart+1)/plotrows)
tstarts <- tstart+rowwidth*0:(plotrows-1)
tends <- tstarts+rowwidth-1
plotline <- data.frame(x=c(data$Pos-0.49,data$Pos+0.49),y=c(data$Y,data$Y))
plotline <- plotline[order(plotline$x),]
if (ymax==0) { ymax <- 1.1*max(plotline$y[plotline$x >= tstart & plotline$x <= tend]) }
refy <- -ymax/20
refseq_rc <- reverseComplement(refseq)
regex1_plot <- data.frame(x=NA,y=NA)
regex2_plot <- data.frame(x=NA,y=NA)
if (regex1 != "") {
regex1_match <- gregexpr(regex1,as.character(refseq))[[1]]
regex1_match_rc <- gregexpr(regex1,as.character(refseq_rc))[[1]]
if (regex1_match[1] > 0) {
for (i in 1:length(regex1_match)) {
len <- attr(regex1_match,"match.length")[i]
pos <- data$Pos[regex1_match[i]]
regex1_plot <- rbind(regex1_plot,c(pos-0.5,2*refy))
regex1_plot <- rbind(regex1_plot,plotline[plotline$x >= pos - 0.5 & plotline$x <= pos + len - 0.5, ])
regex1_plot <- rbind(regex1_plot,c(pos + len - 0.5,2*refy))
regex1_plot <- rbind(regex1_plot,c(NA,NA))
}
}
if (regex1_match_rc[1] > 0) {
for (i in 1:length(regex1_match_rc)) {
len <- attr(regex1_match_rc,"match.length")[i]
pos <- data$Pos[nrow(data) - regex1_match_rc[i] - len + 2]
regex1_plot <- rbind(regex1_plot,c(pos-0.5,2*refy))
regex1_plot <- rbind(regex1_plot,plotline[plotline$x >= pos - 0.5 & plotline$x <= pos + len - 0.5, ])
regex1_plot <- rbind(regex1_plot,c(pos + len - 0.5,2*refy))
regex1_plot <- rbind(regex1_plot,c(NA,NA))
}
}
}
if (regex2 != "") {
regex2_match <- gregexpr(regex2,as.character(refseq),perl=T)[[1]]
regex2_match_rc <- gregexpr(regex2,as.character(refseq_rc),perl=T)[[1]]
if (regex2_match[1] > 0) {
for (i in 1:length(regex2_match)) {
len <- 4 # attr(regex2_match,"match.length")[i]
pos <- data$Pos[regex2_match[i]]
regex2_plot <- rbind(regex2_plot,c(pos-0.5,2*refy))
regex2_plot <- rbind(regex2_plot,plotline[plotline$x >= pos - 0.5 & plotline$x <= pos + len - 0.5, ])
regex2_plot <- rbind(regex2_plot,c(pos + len - 0.5,2*refy))
regex2_plot <- rbind(regex2_plot,c(NA,NA))
}
}
if (regex2_match_rc[1] > 0) {
for (i in 1:length(regex2_match_rc)) {
len <- 4 # attr(regex2_match_rc,"match.length")[i]
pos <- data$Pos[nrow(data) - regex2_match_rc[i] - len + 2]
regex2_plot <- rbind(regex2_plot,c(pos-0.5,2*refy))
regex2_plot <- rbind(regex2_plot,plotline[plotline$x >= pos - 0.5 & plotline$x <= pos + len - 0.5, ])
regex2_plot <- rbind(regex2_plot,c(pos + len - 0.5,2*refy))
regex2_plot <- rbind(regex2_plot,c(NA,NA))
}
}
}
cat("\n")
cat(paste0("Now output pdf to '", output_pdf_filename, "' ...\n"))
pdf(output_pdf_filename, height=figureheight, width=11)
par(mai=c(0.2,0.75,0.5,0.75),omi=c(0.5,0,0,0))
if(annotation == ""){
par(mai=c(0.2,0.75,0.2,0.75))
}
layout(as.matrix(1:plotrows,ncol=1,nrow=plotrows))
for (i in 1:plotrows) {
plot(c(),c(),ylab="",xaxt="n",xlab="",xlim=c(tstarts[i]-0.5,tends[i]+0.5),ylim=c(refy,ymax),xaxs="i",bty="o")
axis(1,lwd=0,lwd.ticks=1)
if (nrow(regex2_plot) > 1) polygon(regex2_plot, col=rgb(254,196,79,max=255),border=rgb(254,196,79,max=255))
if (nrow(regex1_plot) > 1) polygon(regex1_plot, col=rgb(217,95,14,max=255),border=rgb(217,95,14,max=255))
rect(cdr1_start, -0.5, cdr1_end, ymax+0.2, col = rgb(0,0,0,alpha=0.12), border = "NA")
rect(cdr2_start, -0.5, cdr2_end, ymax+0.2, col = rgb(0,0,0,alpha=0.12), border = "NA")
rect(cdr3_start, -0.5, cdr3_end, ymax+0.2, col = rgb(0,0,0,alpha=0.12), border = "NA")
if ("cov" %in% colnames(data)) {
covpos = c(rep(ymax+0.07, length(data$cov)))
topcovline <- data.frame(x=c(data$Pos-0.49,data$Pos+0.49),y=c(covpos+data$cov/5,covpos+data$cov/5))
topcovline <- topcovline[order(topcovline$x),]
botcovline <- data.frame(x=c(data$Pos-0.49,data$Pos+0.49),y=c(covpos,covpos))
botcovline <- botcovline[order(botcovline$x),]
botcovline$y <- unlist(lapply(botcovline$y,function(y) {max(0,y)}))
#polygon(c(topcovline$x,rev(botcovline$x)),c(topcovline$y,rev(botcovline$y)),col='black',border=T,xpd=TRUE,density=00)
}
if ("Err" %in% colnames(data)) {
toperrline <- data.frame(x=c(data$Pos-0.49,data$Pos+0.49),y=c(data$Y+data$Err,data$Y+data$Err))
toperrline <- toperrline[order(toperrline$x),]
boterrline <- data.frame(x=c(data$Pos-0.49,data$Pos+0.49),y=c(data$Y,data$Y))
#boterrline <- data.frame(x=c(data$Pos-0.49,data$Pos+0.49),y=c(data$Y-data$Err,data$Y-data$Err))
boterrline <- boterrline[order(boterrline$x),]
boterrline$y <- unlist(lapply(boterrline$y,function(y) {max(0,y)}))
polygon(c(toperrline$x,rev(boterrline$x)),c(toperrline$y,rev(boterrline$y)),col="green",border=F)
}
#col=grey(0.5,0.5) --> col="green" on 3/18/2015 --> col=rgb(128,255,0,180)
grid(col=grey(0.5))
if (showsequence) points(data$Pos[1]:tail(data$Pos,n=1),rep(refy,nrow(data)),col=basecolors[data$Style],pch=ascii[data$Style],cex=0.6)
lines(plotline$x,plotline$y)
# if(annotation==''){
# genename = tail(strsplit(datafile, "/")[[1]],1)
# genename = strsplit(genename, ".", fixed=TRUE)[[1]][1]
# }else{
# genename = annotation
# }
# legendwords = paste(genename, " TotalReads=", max(data$Total), sep="")
# legend(240, ymax+0.5, legend=legendwords , xpd=TRUE, cex=.6,bty="n")
if(annotation != ""){
legendwords = paste(annotation, " TotalReads=", max(data$Total), sep="")
legend(240, ymax+0.5, legend=legendwords , xpd=TRUE, cex=.6,bty="n")
}
}
graphics.off()
cat("\nAll done. Congratulations!\n")
|
Specially crafted for the lighter experienced paddler, looking for ultra-manoeuvrability in a board.
This is an ideal board for intermediate and young paddlers, and the narrow profile, short board design allows it to perform very well in small surf or just cruising along. It’s our smallest 6" board, so this gives it the rigidity of a larger board, yet in a far smaller package. All this makes it a personal favourite for kids and teenagers with its eye-catching design, easy of carrying and responsive performance.
Package Contents: INCLUDES: Integrated kick pad Inflation adapter Centre fin. High Pressure hand pump. SUP Backpack Patch Kit & Manual. Action Camera mount kit. * *action camera not included.
EVA Deck footpad 4mm Honeycomb Groove, with an intergraded EVA foam Kick Pad.
DRings for optional Kayak seat.
I'm a SUP novice, but this THRIVE SUP is very sturdy and very good quality. All is included as advertised, just had to buy a paddle separately. Loot delivered my package in a record breaking time...Thanks! |
module Day3 (solvePart1, solvePart2) where
import Data.Complex
import Data.Map (Map, (!))
import qualified Data.Map as Map
createMovementList :: [Complex Double] -> [Int] -> [Complex Double]
createMovementList (f:s:rest) (x:xs) = replicate x f ++ replicate x s ++ createMovementList rest xs
movementList :: [Complex Double]
movementList = createMovementList (iterate (*(0 :+ 1)) (1 :+ 0)) [1..]
positions :: [Complex Double]
positions = scanl (+) (0 :+ 0) movementList
manhattenDistance :: Complex Double -> Int
manhattenDistance c = round (sum (fmap abs c))
solvePart1 :: String -> Int
solvePart1 input = let
n = read input
in manhattenDistance (positions !! (n-1))
solvePart2 :: String -> Int
solvePart2 input = let
n = read input
in populateMap n
populateMap :: Int -> Int
populateMap n = let
foobar (p:ps) m = let
v = eval p m
in if v <= n
then foobar ps (Map.insert p v m)
else v
in foobar positions Map.empty
eval :: Complex Double -> Map (Complex Double) Int -> Int
eval c m
| Map.null m = 1
| otherwise = sum (map snd (neighbours c m))
neighbours :: Complex Double -> Map (Complex Double) Int -> [(Complex Double, Int)]
neighbours (a :+ b) m = let
member k = Map.member k m
entry k = (k, m ! k)
neighbourhood = [(a+x) :+ (b+y) | x <- [-1, 0, 1], y <- [-1, 0, 1], x /= 0 || y /= 0]
in map entry (filter member neighbourhood)
instance (Ord a) => Ord (Complex a) where
(a :+ b) `compare` (c :+ d)
| a > c = GT
| a < c = LT
| b > d = GT
| b < d = LT
| b == d = EQ
|
[STATEMENT]
lemma "generalized_sfw (generalized_fw_join fw\<^sub>1 fw\<^sub>2) p = Some (u, d\<^sub>1,d\<^sub>2) \<longleftrightarrow> (\<exists>r\<^sub>1 r\<^sub>2. generalized_sfw fw\<^sub>1 p = Some (r\<^sub>1,d\<^sub>1) \<and> generalized_sfw fw\<^sub>2 p = Some (r\<^sub>2,d\<^sub>2) \<and> Some u = simple_match_and r\<^sub>1 r\<^sub>2)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. (generalized_sfw (generalized_fw_join fw\<^sub>1 fw\<^sub>2) p = Some (u, d\<^sub>1, d\<^sub>2)) = (\<exists>r\<^sub>1 r\<^sub>2. generalized_sfw fw\<^sub>1 p = Some (r\<^sub>1, d\<^sub>1) \<and> generalized_sfw fw\<^sub>2 p = Some (r\<^sub>2, d\<^sub>2) \<and> Some u = simple_match_and r\<^sub>1 r\<^sub>2)
[PROOF STEP]
by (auto dest: generalized_fw_joinD sym simp add: generalized_fw_joinI) |
module Contexts where
open import Prelude
open import T
open import SubstTheory
module Contexts where
infix 60 _e$_ _$e_
-- Has a hole of type (Γ ⊢ A), produces a term of type (Γ' ⊢ A')
data TCtx (Γ : Ctx) (A : TTp) : (Γ' : Ctx) → (A' : TTp) → Set where
∘ : TCtx Γ A Γ A
_e$_ : ∀{Γ' A' B} (e₁ : TExp Γ' (A' ⇒ B)) (C₂ : TCtx Γ A Γ' A') → TCtx Γ A Γ' B
_$e_ : ∀{Γ' A' B} (C₁ : TCtx Γ A Γ' (A' ⇒ B)) (e₂ : TExp Γ' A') → TCtx Γ A Γ' B
Λ : ∀{A₁ A₂ Γ'} (C : TCtx Γ A (A₁ :: Γ') A₂) → TCtx Γ A Γ' (A₁ ⇒ A₂)
suc : ∀{Γ'} (C : TCtx Γ A Γ' nat) → TCtx Γ A Γ' nat
rec1 : ∀{Γ' B} → (C : TCtx Γ A Γ' nat) → (e₀ : TExp Γ' B) → (es : TExp (B :: Γ') B) →
TCtx Γ A Γ' B
rec2 : ∀{Γ' B} → (e : TExp Γ' nat) → (C₀ : TCtx Γ A Γ' B) → (es : TExp (B :: Γ') B) →
TCtx Γ A Γ' B
rec3 : ∀{Γ' B} → (e : TExp Γ' nat) → (e₀ : TExp Γ' B) → (Cs : TCtx Γ A (B :: Γ') B) →
TCtx Γ A Γ' B
_<_> : ∀{Γ A Γ' A'} → TCtx Γ A Γ' A' → TExp Γ A → TExp Γ' A'
∘ < e' > = e'
(e₁ e$ C₂) < e' > = e₁ $ C₂ < e' >
(C₁ $e e₂) < e' > = C₁ < e' > $ e₂
Λ C < e' > = Λ (C < e' >)
suc C < e' > = suc (C < e' >)
rec1 C e₀ es < e' > = rec (C < e' >) e₀ es
rec2 e C₀ es < e' > = rec e (C₀ < e' >) es
rec3 e e₀ Cs < e' > = rec e e₀ (Cs < e' >)
infix 70 _<<_>> _<_>
_<<_>> : ∀{Γ A Γ' A' Γ'' A''} → TCtx Γ' A' Γ'' A'' → TCtx Γ A Γ' A' →
TCtx Γ A Γ'' A''
∘ << C' >> = C'
(e₁ e$ C₂) << C' >> = e₁ e$ C₂ << C' >>
(C₁ $e e₂) << C' >> = C₁ << C' >> $e e₂
Λ C << C' >> = Λ (C << C' >>)
suc C << C' >> = suc (C << C' >>)
rec1 C e₀ es << C' >> = rec1 (C << C' >>) e₀ es
rec2 e C₀ es << C' >> = rec2 e (C₀ << C' >>) es
rec3 e e₀ Cs << C' >> = rec3 e e₀ (Cs << C' >>)
-- I hate having to prove this sort of theorem.
composing-commutes : ∀{Γ A Γ' A' Γ'' A''} →
(C : TCtx Γ' A' Γ'' A'') →
(C' : TCtx Γ A Γ' A') →
(e : TExp Γ A) →
((C << C' >>) < e >) ≡ C < C' < e > >
composing-commutes ∘ C' e = Refl
composing-commutes (e₁ e$ C) C' e = resp (_$_ e₁) (composing-commutes C C' e)
composing-commutes (C $e e₂) C' e = resp (λ x → x $ e₂) (composing-commutes C C' e)
composing-commutes (Λ C) C' e = resp Λ (composing-commutes C C' e)
composing-commutes (suc C) C' e = resp suc (composing-commutes C C' e)
composing-commutes (rec1 C e₀ es) C' e = resp (λ x → rec x e₀ es) (composing-commutes C C' e)
composing-commutes (rec2 e' C es) C' e = resp (λ x → rec e' x es) (composing-commutes C C' e)
composing-commutes (rec3 e' e₀ C) C' e = resp (λ x → rec e' e₀ x) (composing-commutes C C' e)
-- If the hole is closed, then the rest needs to be too.
tctx-empty-thing : ∀{F : Set} {Γ A A' B} → TCtx [] A (B :: Γ) A' → F
tctx-empty-thing (e₁ e$ C) = tctx-empty-thing C
tctx-empty-thing (C $e e₂) = tctx-empty-thing C
tctx-empty-thing (Λ C) = tctx-empty-thing C
tctx-empty-thing (suc C) = tctx-empty-thing C
tctx-empty-thing (rec1 C e₀ es) = tctx-empty-thing C
tctx-empty-thing (rec2 e C es) = tctx-empty-thing C
tctx-empty-thing (rec3 e e₀ C) = tctx-empty-thing C
-- Very restricted function for weakening a program context where
-- the hole also occurs under no free variables.
weaken-closed-tctx : ∀{Γ A A'} → TCtx [] A [] A' → TCtx Γ A Γ A'
weaken-closed-tctx ∘ = ∘
weaken-closed-tctx (e₁ e$ C) = weaken-closed e₁ e$ weaken-closed-tctx C
weaken-closed-tctx (C $e e₂) = weaken-closed-tctx C $e weaken-closed e₂
weaken-closed-tctx (Λ C) = tctx-empty-thing C
weaken-closed-tctx (suc C) = suc (weaken-closed-tctx C)
weaken-closed-tctx (rec1 C e₀ es) =
rec1 (weaken-closed-tctx C) (weaken-closed e₀) (ren (wk closed-wkγ) es)
weaken-closed-tctx (rec2 e C es) =
rec2 (weaken-closed e) (weaken-closed-tctx C) (ren (wk closed-wkγ) es)
weaken-closed-tctx (rec3 e e₀ C) = tctx-empty-thing C
-- Substitution commutes with a closed context
subst-commutes-w-closed-tctx : ∀{Γ A A'} → (γ : TSubst Γ []) → (C : TCtx [] A [] A') → (e : TExp Γ A) →
C < ssubst γ e > ≡ ssubst γ ((weaken-closed-tctx C) < e >)
subst-commutes-w-closed-tctx γ ∘ e = Refl
subst-commutes-w-closed-tctx γ (e₁ e$ C) e =
resp2 _$_
(symm (closed-subst _ e₁) ≡≡ symm (subren γ closed-wkγ e₁))
(subst-commutes-w-closed-tctx γ C e)
subst-commutes-w-closed-tctx γ (C $e e₂) e =
resp2 _$_
(subst-commutes-w-closed-tctx γ C e)
(symm (closed-subst _ e₂) ≡≡ symm (subren γ closed-wkγ e₂))
subst-commutes-w-closed-tctx γ (Λ C) e = tctx-empty-thing C
subst-commutes-w-closed-tctx γ (suc C) e =
resp suc (subst-commutes-w-closed-tctx γ C e)
subst-commutes-w-closed-tctx γ (rec1 C e₀ es) e with subren (liftγ γ) (wk closed-wkγ) es
... | lol1 with subeq (liftwk γ closed-wkγ) es
... | lol2 with lift-closed-subst (γ o closed-wkγ) es
... | lol3 with symm lol3 ≡≡ symm lol2 ≡≡ symm lol1
... | lol = resp3 rec
(subst-commutes-w-closed-tctx γ C e)
(symm (closed-subst _ e₀) ≡≡ symm (subren γ closed-wkγ e₀))
lol
subst-commutes-w-closed-tctx γ (rec2 en C es) e with subren (liftγ γ) (wk closed-wkγ) es
... | lol1 with subeq (liftwk γ closed-wkγ) es
... | lol2 with lift-closed-subst (γ o closed-wkγ) es
... | lol3 with symm lol3 ≡≡ symm lol2 ≡≡ symm lol1
... | lol = resp3 rec
(symm (closed-subst _ en) ≡≡ symm (subren γ closed-wkγ en))
(subst-commutes-w-closed-tctx γ C e)
lol
subst-commutes-w-closed-tctx γ (rec3 e e₀ C) e₁ = tctx-empty-thing C
open Contexts public
|
open import Relation.Binary.PropositionalEquality using (_≡_; _≢_; refl)
open import Relation.Nullary.Decidable using (False; toWitnessFalse)
open import Data.Fin using (Fin; _≟_)
open import Data.Nat using (ℕ; suc)
open import Data.Product using (_×_; _,_)
open import Common
data Global (n : ℕ) : Set where
endG : Global n
msgSingle : (p q : Fin n) -> p ≢ q -> Label -> Global n -> Global n
private
variable
n : ℕ
p p′ q q′ r s : Fin n
l l′ : Label
g gSub gSub′ : Global n
msgSingle′ : (p q : Fin n) -> {False (p ≟ q)} -> Label -> Global n -> Global n
msgSingle′ p q {p≢q} l gSub = msgSingle p q (toWitnessFalse p≢q) l gSub
size-g : ∀ { n : ℕ } -> (g : Global n) -> ℕ
size-g endG = 0
size-g (msgSingle _ _ _ _ gSub) = suc (size-g gSub)
size-g-reduces :
∀ { p≢q }
-> g ≡ msgSingle {n} p q p≢q l gSub
-> size-g g ≡ suc (size-g gSub)
size-g-reduces {g = endG} ()
size-g-reduces {g = msgSingle _ _ _ _ gSub} refl = refl
msgSingle-subst-left :
∀ { p≢q }
-> g ≡ msgSingle {n} p q p≢q l gSub
-> (p≡p′ : p ≡ p′)
-> g ≡ msgSingle {n} p′ q (≢-subst-left p≢q p≡p′) l gSub
msgSingle-subst-left refl refl = refl
msgSingle-subst-right :
∀ { p≢q }
-> g ≡ msgSingle {n} p q p≢q l gSub
-> (q≡q′ : q ≡ q′)
-> g ≡ msgSingle {n} p q′ (≢-subst-right p≢q q≡q′) l gSub
msgSingle-subst-right refl refl = refl
msgSingle-injective :
∀ { p≢q p′≢q′ }
-> msgSingle {n} p q p≢q l gSub ≡ msgSingle p′ q′ p′≢q′ l′ gSub′
-> p ≡ p′ × q ≡ q′ × l ≡ l′ × gSub ≡ gSub′
msgSingle-injective refl = refl , refl , refl , refl
data _-_→g_ {n : ℕ} : Global n -> Action n -> Global n -> Set where
→g-prefix :
∀ { p≢q p≢q′ }
-> (msgSingle p q p≢q l gSub) - (action p q p≢q′ l) →g gSub
→g-cont :
∀ { p≢q r≢s }
-> gSub - (action p q p≢q l) →g gSub′
-> p ≢ r
-> q ≢ r
-> p ≢ s
-> q ≢ s
-> (msgSingle r s r≢s l′ gSub) - (action p q p≢q l) →g (msgSingle r s r≢s l′ gSub′)
|
lemma mono_restrict_space: "sets M \<le> sets N \<Longrightarrow> sets (restrict_space M X) \<subseteq> sets (restrict_space N X)" |
[STATEMENT]
lemma lfp_the_while_option:
assumes "mono f" and "!!X. X \<subseteq> C \<Longrightarrow> f X \<subseteq> C" and "finite C"
shows "lfp f = the(while_option (\<lambda>A. f A \<noteq> A) f {})"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. lfp f = the (while_option (\<lambda>A. f A \<noteq> A) f {})
[PROOF STEP]
proof-
[PROOF STATE]
proof (state)
goal (1 subgoal):
1. lfp f = the (while_option (\<lambda>A. f A \<noteq> A) f {})
[PROOF STEP]
obtain P where "while_option (\<lambda>A. f A \<noteq> A) f {} = Some P"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. (\<And>P. while_option (\<lambda>A. f A \<noteq> A) f {} = Some P \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
using while_option_finite_subset_Some[OF assms]
[PROOF STATE]
proof (prove)
using this:
(\<And>X. X \<subseteq> C \<Longrightarrow> X \<subseteq> C) \<Longrightarrow> \<exists>P. while_option (\<lambda>A. f A \<noteq> A) f {} = Some P
goal (1 subgoal):
1. (\<And>P. while_option (\<lambda>A. f A \<noteq> A) f {} = Some P \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
while_option (\<lambda>A. f A \<noteq> A) f {} = Some P
goal (1 subgoal):
1. lfp f = the (while_option (\<lambda>A. f A \<noteq> A) f {})
[PROOF STEP]
with while_option_stop2[OF this] lfp_Kleene_iter[OF assms(1)]
[PROOF STATE]
proof (chain)
picking this:
\<exists>k. P = (f ^^ k) {} \<and> \<not> f P \<noteq> P
(f ^^ Suc ?k) {} = (f ^^ ?k) {} \<Longrightarrow> lfp f = (f ^^ ?k) {}
while_option (\<lambda>A. f A \<noteq> A) f {} = Some P
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
\<exists>k. P = (f ^^ k) {} \<and> \<not> f P \<noteq> P
(f ^^ Suc ?k) {} = (f ^^ ?k) {} \<Longrightarrow> lfp f = (f ^^ ?k) {}
while_option (\<lambda>A. f A \<noteq> A) f {} = Some P
goal (1 subgoal):
1. lfp f = the (while_option (\<lambda>A. f A \<noteq> A) f {})
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
lfp f = the (while_option (\<lambda>A. f A \<noteq> A) f {})
goal:
No subgoals!
[PROOF STEP]
qed |
# ==============================================================================
#module NaquadahCore
include("Graphics/GraphTypes.jl")
include("NaquadahTypes.jl")
include("Graphics/Graphics.jl")
include("Events/Events.jl")
include("DOM/Dom.jl")
include("Layout/Layout.jl")
include("Layout/LayoutBuild.jl")
include("Layout/LayoutBegin.jl")
#end
# ==============================================================================
|
# COMP90051 Workshop 5
## Support Vector Machines
***
In this section, we'll explore how the SVM hyperparameters (i.e. the penalty parameter, the kernel, and any kernel parameters) affect the decision surface.
```python
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
from timeit import default_timer as timer
sns.set_style('darkgrid')
plt.rcParams['figure.dpi'] = 108
from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split, StratifiedShuffleSplit, GridSearchCV
```
### 1. Data set
To make visualisation and training easy, we'll consider a small binary classification data set called `cats.csv` (available from the LMS).
It contains observations for 150 cats.
There are two features: heart and body weight measured in kilograms.
The target variable is the sex of the cat (we encode 'male' as`-1` and 'female' as `+1`).
\[Note: the data set originates from the following paper: R. A. Fisher (1947) _The analysis of covariance method for the relation between a part and the whole_, Biometrics **3**, 65–68\]
Ensure that `cats.csv` is located in the same directory as this notebook, then run the following code block to read the CSV file using `pandas`.
```python
full_df = pd.read_csv('cats.csv')
full_df.SEX = full_df.SEX.map({'M': -1, 'F': 1})
full_df.head()
```
Let's split the data into train/test sets so that we can evaluate our trained SVM.
(Note that this is likely to be unreliable for such a small data set.)
```python
train_df, test_df = train_test_split(full_df, test_size=0.2, random_state=1)
```
Since SVMs incorporate a penalty term for the weights (proportional to $\|\mathbf{w}\|_2^2$), it's usually beneficial to _standardise_ the features so that they vary on roughly the same scale.
***
**Exercise:** Complete the code block below to standardise the features, so that each feature has zero mean/unit variance.
_Hint: use `StandardScaler` imported above._
***
```python
scaler = StandardScaler()
X_train = ... # fill in
y_train = ... # fill in
X_test = ... # fill in
y_test = ... # fill in
```
Let's plot the training data. Notice that it's not linearly separable.
```python
plt.scatter(X_train[y_train==1,0], X_train[y_train==1,1], label="Female ($y=1$)", c='r')
plt.scatter(X_train[y_train==-1,0], X_train[y_train==-1,1], label="Male ($y=-1$)", c='b')
plt.xlabel("Heart weight")
plt.ylabel("Body weight")
plt.legend()
plt.show()
```
### 2. Parameter grid search
Since the data is clearly not linearly separable, we're going to fit a kernelised SVM.
To do this, we'll use the `sklearn.svm.SVC` class, which is a wrapper for the popular [LIBSVM](https://www.csie.ntu.edu.tw/~cjlin/libsvm/) library.
\[Aside: LIBSVM solves the dual problem using a variant of the [sequential minimal optimisation (SMO) algorithm](https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/tr-98-14.pdf).\]
The corresponding primal problem is as follows:
$$
\begin{align}
\min_{\mathbf{w}, b, \xi} \phantom{=} & \frac{1}{2} \mathbf{w}^T \mathbf{w} + C \sum_{i = 1}^{n} \xi_i \\
\mathrm{subject~to} \phantom{=} & y_{i}(\mathbf{w}^T \cdot \phi(\mathbf{x_i}) + b) \geq 1 - \xi_i \\
\phantom{=} & \xi_i \geq 0 \ \forall i
\end{align}
$$
Here $C$ is the penalty parameter, $\mathbf{w}$ are the weights, $b$ is the bias and $\phi$ is a mapping to a higher dimensional space---related to the kernel through $K(\mathbf{x}_i, \mathbf{x}_j) = \langle \phi(\mathbf{x}_i), \phi(\mathbf{x}_j) \rangle$.
For now, we'll use the radial basis function (RBF) kernel, which is parameterised in terms of $\gamma$ as follows:
$$
K(\mathbf{x}_i, \mathbf{x}_j) = \exp(-\gamma \|\mathbf{x}_i - \mathbf{x}_j\|^2)
$$
Returning to our classification problem: it's unclear how to set appropriate values for $C$ and $\gamma$ (named `C` and `gamma` in `sklearn`).
A simple way around this is to do an exhaustive cross validation grid search.
Below we define an evenly-spaced grid in log-space.
```python
C_range = np.logspace(-2, 5, 8)
gamma_range = np.logspace(-6, 1, 16)
# Visualise the grid
xx, yy = np.meshgrid(C_range, gamma_range)
plt.plot(xx, yy, 'ko')
plt.xscale('log')
plt.yscale('log')
plt.xlabel('$C$')
plt.ylabel(r'$\gamma$')
plt.show()
```
To do the grid search, we'll use the built-in `sklearn.model_selection.GridSearchCV` class.
It evaluates the model for each combination of parameter values using cross validation, and selects the combination with the best score.
We'll use `StratifiedShuffleSplit` for cross validation (it effectively generates bootstrap samples from the training data, while preserving the class ratio).
```python
cv = StratifiedShuffleSplit(n_splits=30, test_size=0.1, random_state=1)
grid = GridSearchCV(SVC(kernel='rbf'), param_grid={'gamma': gamma_range, 'C': C_range}, cv=cv)
grid.fit(X_train, y_train)
print("The best parameters are {0.best_params_} with an accuracy of {0.best_score_:.3g}".format(grid))
```
***
**Question:** Why aren't we using k-fold cross validation?
***
Below we visualise the cross validation accuracy over the grid of parameters.
```python
scores = grid.cv_results_['mean_test_score'].reshape(C_range.size, gamma_range.size)
plt.figure(figsize=(8, 6))
plt.imshow(scores, cmap='viridis')
plt.colorbar(shrink=0.7)
plt.xticks(np.arange(len(gamma_range)), ["%.2e" % gamma for gamma in gamma_range], rotation=90)
plt.yticks(np.arange(len(C_range)), ["%1.e" % C for C in C_range])
plt.title('Cross validation accuracy')
plt.xlabel(r'$\gamma$')
plt.ylabel('$C$')
plt.show()
```
***
**Question:** Interpret this plot. Is there a clear winning combination of parameters?
***
Now that we've found the "best" parameters, let's fit the SVM on the entire training set (without cross-validation).
(Note: we actually fit all parameter combinations, as they're needed for a plot generated below.)
```python
classifiers = {(C, gamma) : SVC(C=C, gamma=gamma, kernel='rbf').fit(X_train, y_train)
for C in C_range
for gamma in gamma_range}
```
Below we evaluate the "best" classifier on the test set.
```python
best_params = (grid.best_params_["C"], grid.best_params_["gamma"])
best_svm = classifiers[best_params]
best_train_acc = best_svm.score(X_train, y_train)
best_test_acc = best_svm.score(X_test, y_test)
print("The SVM with parameters C={0[0]:.3g}, gamma={0[1]:.3g} has training accuracy {1:.3g} and test accuracy {2:.3g}.".format(best_params, best_train_acc, best_test_acc))
```
***
**Question:** How does this compare to the training accuracy?
***
Below we visualise the decision functions for all parameter combinations (double-click output to expand to 100%)
```python
fig, ax = plt.subplots(C_range.size, gamma_range.size, figsize=(50,20))
border = 0.2
# Build meshgrid over the feature space
X_min = np.amin(X_train, axis=0)
X_max = np.amax(X_train, axis=0)
xx, yy = np.meshgrid(np.linspace(X_min[0] - border, X_max[0] + border, 100),
np.linspace(X_min[1] - border, X_max[1] + border, 100))
# Plot training data + decision function for all feature combinations
for (i, C) in enumerate(C_range):
for (j, gamma) in enumerate(gamma_range):
clf = classifiers[(C, gamma)]
Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
ax[i,j].set_title("gamma={0.gamma:.3g}; C={0.C:.3g}".format(clf),
size='medium')
ax[i,j].pcolormesh(xx, yy, -Z, cmap=plt.cm.RdBu)
ax[i,j].scatter(X_train[y_train==1,0], X_train[y_train==1,1], c='r', edgecolors='k')
ax[i,j].scatter(X_train[y_train==-1,0], X_train[y_train==-1,1], c='b', edgecolors='k')
ax[i,j].set_xticks([])
ax[i,j].set_yticks([])
ax[i,j].axis('tight')
plt.show()
```
***
**Question:** Explain how `gamma` and `C` affect the decision surface qualitatively.
**Extension activity:** Re-run this section using a different kernel (e.g. the built-in polynomial kernel or a custom kernel).
***
|
library(methods)
{{rimport}}('__init__.r')
indir = {{i.indir | R}}
outdir = {{o.outdir | R}}
plink = {{args.plink | R}}
bedfile = Sys.glob(file.path(indir, '*.bed'))
input = tools::file_path_sans_ext(bedfile)
output = file.path(outdir, basename(input))
params = list(
bfile = input,
`check-sex` = T,
out = output
)
cmd = sprintf("%s %s 1>&2", plink, cmdargs(params, equal = ' '))
runcmd(cmd)
sexcheck = read.table(paste0(output, '.sexcheck'), header = T, row.names = NULL, check.names = F)
sex.sample.fail = sexcheck[which(sexcheck$STATUS == 'PROBLEM'), c('FID', 'IID'), drop=F]
write.table(sex.sample.fail, paste0(output, '.sex.fail'), col.names = F, row.names = F, sep = "\t", quote = F)
|
subroutine splev(t,n,c,k,x,y,m,e,ier)
c subroutine splev evaluates in a number of points x(i),i=1,2,...,m
c a spline s(x) of degree k, given in its b-spline representation.
c
c calling sequence:
c call splev(t,n,c,k,x,y,m,e,ier)
c
c input parameters:
c t : array,length n, which contains the position of the knots.
c n : integer, giving the total number of knots of s(x).
c c : array,length n, which contains the b-spline coefficients.
c k : integer, giving the degree of s(x).
c x : array,length m, which contains the points where s(x) must
c be evaluated.
c m : integer, giving the number of points where s(x) must be
c evaluated.
c e : integer, if 0 the spline is extrapolated from the end
c spans for points not in the support, if 1 the spline
c evaluates to zero for those points, and if 2 ier is set to
c 1 and the subroutine returns.
c
c output parameter:
c y : array,length m, giving the value of s(x) at the different
c points.
c ier : error flag
c ier = 0 : normal return
c ier = 1 : argument out of bounds and e == 2
c ier =10 : invalid input data (see restrictions)
c
c restrictions:
c m >= 1
c-- t(k+1) <= x(i) <= x(i+1) <= t(n-k) , i=1,2,...,m-1.
c
c other subroutines required: fpbspl.
c
c references :
c de boor c : on calculating with b-splines, j. approximation theory
c 6 (1972) 50-62.
c cox m.g. : the numerical evaluation of b-splines, j. inst. maths
c applics 10 (1972) 134-149.
c dierckx p. : curve and surface fitting with splines, monographs on
c numerical analysis, oxford university press, 1993.
c
c author :
c p.dierckx
c dept. computer science, k.u.leuven
c celestijnenlaan 200a, b-3001 heverlee, belgium.
c e-mail : [email protected]
c
c latest update : march 1987
c
c++ pearu: 11 aug 2003
c++ - disabled cliping x values to interval [min(t),max(t)]
c++ - removed the restriction of the orderness of x values
c++ - fixed initialization of sp to double precision value
c
c ..scalar arguments..
integer n, k, m, e, ier
c ..array arguments..
real*8 t(n), c(n), x(m), y(m)
c ..local scalars..
integer i, j, k1, l, ll, l1, nk1
c++..
integer k2
c..++
real*8 arg, sp, tb, te
c ..local array..
real*8 h(20)
c ..
c before starting computations a data check is made. if the input data
c are invalid control is immediately repassed to the calling program.
ier = 10
c-- if(m-1) 100,30,10
c++..
if (m .lt. 1) go to 100
c..++
c-- 10 do 20 i=2,m
c-- if(x(i).lt.x(i-1)) go to 100
c-- 20 continue
30 ier = 0
c fetch tb and te, the boundaries of the approximation interval.
k1 = k + 1
c++..
k2 = k1 + 1
c..++
nk1 = n - k1
tb = t(k1)
te = t(nk1 + 1)
l = k1
l1 = l + 1
c main loop for the different points.
do 80 i = 1, m
c fetch a new x-value arg.
arg = x(i)
c check if arg is in the support
if (arg .lt. tb .or. arg .gt. te) then
if (e .eq. 0) then
goto 35
else if (e .eq. 1) then
y(i) = 0
goto 80
else if (e .eq. 2) then
ier = 1
goto 100
endif
endif
c search for knot interval t(l) <= arg < t(l+1)
c++..
35 if (arg .ge. t(l) .or. l1 .eq. k2) go to 40
l1 = l
l = l - 1
go to 35
c..++
40 if(arg .lt. t(l1) .or. l .eq. nk1) go to 50
l = l1
l1 = l + 1
go to 40
c evaluate the non-zero b-splines at arg.
50 call fpbspl(t, n, k, arg, l, h)
c find the value of s(x) at x=arg.
sp = 0.0d0
ll = l - k1
do 60 j = 1, k1
ll = ll + 1
sp = sp + c(ll)*h(j)
60 continue
y(i) = sp
80 continue
100 return
end
|
import inspect
import tempfile
import unittest
import numpy as np
import transformers
from transformers import CLIPConfig, CLIPTextConfig, CLIPVisionConfig, is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax, slow
from .test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
if is_flax_available():
import jax
import jax.numpy as jnp
from transformers.modeling_flax_pytorch_utils import (
convert_pytorch_state_dict_to_flax,
load_flax_weights_in_pytorch_model,
)
from transformers.models.clip.modeling_flax_clip import FlaxCLIPModel, FlaxCLIPTextModel, FlaxCLIPVisionModel
if is_torch_available():
import torch
class FlaxCLIPVisionModelTester:
def __init__(
self,
parent,
batch_size=12,
image_size=30,
patch_size=2,
num_channels=3,
is_training=True,
hidden_size=32,
num_hidden_layers=5,
num_attention_heads=4,
intermediate_size=37,
dropout=0.1,
attention_dropout=0.1,
initializer_range=0.02,
scope=None,
):
self.parent = parent
self.batch_size = batch_size
self.image_size = image_size
self.patch_size = patch_size
self.num_channels = num_channels
self.is_training = is_training
self.hidden_size = hidden_size
self.num_hidden_layers = num_hidden_layers
self.num_attention_heads = num_attention_heads
self.intermediate_size = intermediate_size
self.dropout = dropout
self.attention_dropout = attention_dropout
self.initializer_range = initializer_range
self.scope = scope
def prepare_config_and_inputs(self):
pixel_values = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])
config = CLIPVisionConfig(
image_size=self.image_size,
patch_size=self.patch_size,
num_channels=self.num_channels,
hidden_size=self.hidden_size,
num_hidden_layers=self.num_hidden_layers,
num_attention_heads=self.num_attention_heads,
intermediate_size=self.intermediate_size,
dropout=self.dropout,
attention_dropout=self.attention_dropout,
initializer_range=self.initializer_range,
)
return config, pixel_values
def prepare_config_and_inputs_for_common(self):
config_and_inputs = self.prepare_config_and_inputs()
config, pixel_values = config_and_inputs
inputs_dict = {"pixel_values": pixel_values}
return config, inputs_dict
@require_flax
class FlaxCLIPVisionModelTest(FlaxModelTesterMixin, unittest.TestCase):
"""
Here we also overwrite some of the tests of test_modeling_common.py, as CLIP does not use input_ids, inputs_embeds,
attention_mask and seq_length.
"""
all_model_classes = (FlaxCLIPVisionModel,) if is_flax_available() else ()
def setUp(self):
self.model_tester = FlaxCLIPVisionModelTester(self)
def test_forward_signature(self):
config, _ = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
model = model_class(config)
signature = inspect.signature(model.__call__)
# signature.parameters is an OrderedDict => so arg_names order is deterministic
arg_names = [*signature.parameters.keys()]
expected_arg_names = ["pixel_values"]
self.assertListEqual(arg_names[:1], expected_arg_names)
def test_jit_compilation(self):
config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
with self.subTest(model_class.__name__):
prepared_inputs_dict = self._prepare_for_class(inputs_dict, model_class)
model = model_class(config)
@jax.jit
def model_jitted(pixel_values, **kwargs):
return model(pixel_values=pixel_values, **kwargs).to_tuple()
with self.subTest("JIT Enabled"):
jitted_outputs = model_jitted(**prepared_inputs_dict)
with self.subTest("JIT Disabled"):
with jax.disable_jit():
outputs = model_jitted(**prepared_inputs_dict)
self.assertEqual(len(outputs), len(jitted_outputs))
for jitted_output, output in zip(jitted_outputs, outputs):
self.assertEqual(jitted_output.shape, output.shape)
def test_hidden_states_output(self):
def check_hidden_states_output(inputs_dict, config, model_class):
model = model_class(config)
outputs = model(**self._prepare_for_class(inputs_dict, model_class))
hidden_states = outputs.hidden_states
self.assertEqual(len(hidden_states), self.model_tester.num_hidden_layers + 1)
# CLIP has a different seq_length
image_size = (self.model_tester.image_size, self.model_tester.image_size)
patch_size = (self.model_tester.patch_size, self.model_tester.patch_size)
num_patches = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
seq_length = num_patches + 1
self.assertListEqual(
list(hidden_states[0].shape[-2:]),
[seq_length, self.model_tester.hidden_size],
)
config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
inputs_dict["output_hidden_states"] = True
check_hidden_states_output(inputs_dict, config, model_class)
# check that output_hidden_states also work using config
del inputs_dict["output_hidden_states"]
config.output_hidden_states = True
check_hidden_states_output(inputs_dict, config, model_class)
def test_attention_outputs(self):
config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
config.return_dict = True
# in CLIP, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token)
image_size = (self.model_tester.image_size, self.model_tester.image_size)
patch_size = (self.model_tester.patch_size, self.model_tester.patch_size)
num_patches = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
seq_length = num_patches + 1
for model_class in self.all_model_classes:
inputs_dict["output_attentions"] = True
inputs_dict["output_hidden_states"] = False
model = model_class(config)
outputs = model(**self._prepare_for_class(inputs_dict, model_class))
attentions = outputs.attentions
self.assertEqual(len(attentions), self.model_tester.num_hidden_layers)
# check that output_attentions also work using config
del inputs_dict["output_attentions"]
config.output_attentions = True
model = model_class(config)
outputs = model(**self._prepare_for_class(inputs_dict, model_class))
attentions = outputs.attentions
self.assertEqual(len(attentions), self.model_tester.num_hidden_layers)
self.assertListEqual(
list(attentions[0].shape[-3:]),
[self.model_tester.num_attention_heads, seq_length, seq_length],
)
out_len = len(outputs)
# Check attention is always last and order is fine
inputs_dict["output_attentions"] = True
inputs_dict["output_hidden_states"] = True
model = model_class(config)
outputs = model(**self._prepare_for_class(inputs_dict, model_class))
added_hidden_states = 1
self.assertEqual(out_len + added_hidden_states, len(outputs))
self_attentions = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
self.assertEqual(len(self_attentions), self.model_tester.num_hidden_layers)
self.assertListEqual(
list(self_attentions[0].shape[-3:]),
[self.model_tester.num_attention_heads, seq_length, seq_length],
)
@slow
def test_model_from_pretrained(self):
for model_class_name in self.all_model_classes:
model = model_class_name.from_pretrained("openai/clip-vit-base-patch32", from_pt=True)
outputs = model(np.ones((1, 3, 224, 224)))
self.assertIsNotNone(outputs)
class FlaxCLIPTextModelTester:
def __init__(
self,
parent,
batch_size=12,
seq_length=7,
is_training=True,
use_input_mask=True,
use_labels=True,
vocab_size=99,
hidden_size=32,
num_hidden_layers=5,
num_attention_heads=4,
intermediate_size=37,
dropout=0.1,
attention_dropout=0.1,
max_position_embeddings=512,
initializer_range=0.02,
scope=None,
):
self.parent = parent
self.batch_size = batch_size
self.seq_length = seq_length
self.is_training = is_training
self.use_input_mask = use_input_mask
self.use_labels = use_labels
self.vocab_size = vocab_size
self.hidden_size = hidden_size
self.num_hidden_layers = num_hidden_layers
self.num_attention_heads = num_attention_heads
self.intermediate_size = intermediate_size
self.dropout = dropout
self.attention_dropout = attention_dropout
self.max_position_embeddings = max_position_embeddings
self.initializer_range = initializer_range
self.scope = scope
def prepare_config_and_inputs(self):
input_ids = ids_tensor([self.batch_size, self.seq_length], self.vocab_size)
input_mask = None
if self.use_input_mask:
input_mask = random_attention_mask([self.batch_size, self.seq_length])
if input_mask is not None:
batch_size, seq_length = input_mask.shape
rnd_start_indices = np.random.randint(1, seq_length - 1, size=(batch_size,))
for batch_idx, start_index in enumerate(rnd_start_indices):
input_mask[batch_idx, :start_index] = 1
input_mask[batch_idx, start_index:] = 0
config = CLIPTextConfig(
vocab_size=self.vocab_size,
hidden_size=self.hidden_size,
num_hidden_layers=self.num_hidden_layers,
num_attention_heads=self.num_attention_heads,
intermediate_size=self.intermediate_size,
dropout=self.dropout,
attention_dropout=self.attention_dropout,
max_position_embeddings=self.max_position_embeddings,
initializer_range=self.initializer_range,
)
return config, input_ids, input_mask
def prepare_config_and_inputs_for_common(self):
config_and_inputs = self.prepare_config_and_inputs()
config, input_ids, input_mask = config_and_inputs
inputs_dict = {"input_ids": input_ids, "attention_mask": input_mask}
return config, inputs_dict
@require_flax
class FlaxCLIPTextModelTest(FlaxModelTesterMixin, unittest.TestCase):
all_model_classes = (FlaxCLIPTextModel,) if is_flax_available() else ()
def setUp(self):
self.model_tester = FlaxCLIPTextModelTester(self)
@slow
def test_model_from_pretrained(self):
for model_class_name in self.all_model_classes:
model = model_class_name.from_pretrained("openai/clip-vit-base-patch32", from_pt=True)
outputs = model(np.ones((1, 1)))
self.assertIsNotNone(outputs)
class FlaxCLIPModelTester:
def __init__(self, parent, is_training=True):
self.parent = parent
self.text_model_tester = FlaxCLIPTextModelTester(parent)
self.vision_model_tester = FlaxCLIPVisionModelTester(parent)
self.is_training = is_training
def prepare_config_and_inputs(self):
text_config, input_ids, attention_mask = self.text_model_tester.prepare_config_and_inputs()
vision_config, pixel_values = self.vision_model_tester.prepare_config_and_inputs()
config = CLIPConfig.from_text_vision_configs(text_config, vision_config, projection_dim=64)
return config, input_ids, attention_mask, pixel_values
def prepare_config_and_inputs_for_common(self):
config_and_inputs = self.prepare_config_and_inputs()
config, input_ids, attention_mask, pixel_values = config_and_inputs
inputs_dict = {
"input_ids": input_ids,
"attention_mask": attention_mask,
"pixel_values": pixel_values,
}
return config, inputs_dict
@require_flax
class FlaxCLIPModelTest(FlaxModelTesterMixin, unittest.TestCase):
all_model_classes = (FlaxCLIPModel,) if is_flax_available() else ()
test_attention_outputs = False
def setUp(self):
self.model_tester = FlaxCLIPModelTester(self)
# hidden_states are tested in individual model tests
def test_hidden_states_output(self):
pass
@slow
def test_jit_compilation(self):
config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
with self.subTest(model_class.__name__):
prepared_inputs_dict = self._prepare_for_class(inputs_dict, model_class)
model = model_class(config)
@jax.jit
def model_jitted(input_ids, pixel_values, **kwargs):
return model(input_ids=input_ids, pixel_values=pixel_values, **kwargs).to_tuple()
with self.subTest("JIT Enabled"):
jitted_outputs = model_jitted(**prepared_inputs_dict)
with self.subTest("JIT Disabled"):
with jax.disable_jit():
outputs = model_jitted(**prepared_inputs_dict)
self.assertEqual(len(outputs), len(jitted_outputs))
for jitted_output, output in zip(jitted_outputs[:4], outputs[:4]):
self.assertEqual(jitted_output.shape, output.shape)
def test_forward_signature(self):
config, _ = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
model = model_class(config)
signature = inspect.signature(model.__call__)
# signature.parameters is an OrderedDict => so arg_names order is deterministic
arg_names = [*signature.parameters.keys()]
expected_arg_names = ["input_ids", "pixel_values", "attention_mask", "position_ids"]
self.assertListEqual(arg_names[:4], expected_arg_names)
def test_get_image_features(self):
config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
model = FlaxCLIPModel(config)
@jax.jit
def model_jitted(pixel_values):
return model.get_image_features(pixel_values=pixel_values)
with self.subTest("JIT Enabled"):
jitted_output = model_jitted(inputs_dict["pixel_values"])
with self.subTest("JIT Disabled"):
with jax.disable_jit():
output = model_jitted(inputs_dict["pixel_values"])
self.assertEqual(jitted_output.shape, output.shape)
self.assertTrue(np.allclose(jitted_output, output, atol=1e-3))
def test_get_text_features(self):
config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
model = FlaxCLIPModel(config)
@jax.jit
def model_jitted(input_ids, attention_mask, **kwargs):
return model.get_text_features(input_ids=input_ids, attention_mask=attention_mask)
with self.subTest("JIT Enabled"):
jitted_output = model_jitted(**inputs_dict)
with self.subTest("JIT Disabled"):
with jax.disable_jit():
output = model_jitted(**inputs_dict)
self.assertEqual(jitted_output.shape, output.shape)
self.assertTrue(np.allclose(jitted_output, output, atol=1e-3))
@slow
def test_model_from_pretrained(self):
for model_class_name in self.all_model_classes:
model = model_class_name.from_pretrained("openai/clip-vit-base-patch32", from_pt=True)
outputs = model(input_ids=np.ones((1, 1)), pixel_values=np.ones((1, 3, 224, 224)))
self.assertIsNotNone(outputs)
# overwrite from common since FlaxCLIPModel returns nested output
# which is not supported in the common test
@is_pt_flax_cross_test
def test_equivalence_pt_to_flax(self):
config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
with self.subTest(model_class.__name__):
# prepare inputs
prepared_inputs_dict = self._prepare_for_class(inputs_dict, model_class)
pt_inputs = {k: torch.tensor(v.tolist()) for k, v in prepared_inputs_dict.items()}
# load corresponding PyTorch class
pt_model_class_name = model_class.__name__[4:] # Skip the "Flax" at the beginning
pt_model_class = getattr(transformers, pt_model_class_name)
pt_model = pt_model_class(config).eval()
fx_model = model_class(config, dtype=jnp.float32)
fx_state = convert_pytorch_state_dict_to_flax(pt_model.state_dict(), fx_model)
fx_model.params = fx_state
with torch.no_grad():
pt_outputs = pt_model(**pt_inputs).to_tuple()
# PyTorch CLIPModel returns loss, we skip it here as we don't return loss in JAX/Flax models
pt_outputs = pt_outputs[1:]
fx_outputs = fx_model(**prepared_inputs_dict).to_tuple()
self.assertEqual(len(fx_outputs), len(pt_outputs), "Output lengths differ between Flax and PyTorch")
for fx_output, pt_output in zip(fx_outputs[:4], pt_outputs[:4]):
self.assert_almost_equals(fx_output, pt_output.numpy(), 4e-2)
with tempfile.TemporaryDirectory() as tmpdirname:
pt_model.save_pretrained(tmpdirname)
fx_model_loaded = model_class.from_pretrained(tmpdirname, from_pt=True)
fx_outputs_loaded = fx_model_loaded(**prepared_inputs_dict).to_tuple()
self.assertEqual(
len(fx_outputs_loaded), len(pt_outputs), "Output lengths differ between Flax and PyTorch"
)
for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4], pt_outputs[:4]):
self.assert_almost_equals(fx_output_loaded, pt_output.numpy(), 4e-2)
# overwrite from common since FlaxCLIPModel returns nested output
# which is not supported in the common test
@is_pt_flax_cross_test
def test_equivalence_flax_to_pt(self):
config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
with self.subTest(model_class.__name__):
# prepare inputs
prepared_inputs_dict = self._prepare_for_class(inputs_dict, model_class)
pt_inputs = {k: torch.tensor(v.tolist()) for k, v in prepared_inputs_dict.items()}
# load corresponding PyTorch class
pt_model_class_name = model_class.__name__[4:] # Skip the "Flax" at the beginning
pt_model_class = getattr(transformers, pt_model_class_name)
pt_model = pt_model_class(config).eval()
fx_model = model_class(config, dtype=jnp.float32)
pt_model = load_flax_weights_in_pytorch_model(pt_model, fx_model.params)
# make sure weights are tied in PyTorch
pt_model.tie_weights()
with torch.no_grad():
pt_outputs = pt_model(**pt_inputs).to_tuple()
# PyTorch CLIPModel returns loss, we skip it here as we don't return loss in JAX/Flax models
pt_outputs = pt_outputs[1:]
fx_outputs = fx_model(**prepared_inputs_dict).to_tuple()
self.assertEqual(len(fx_outputs), len(pt_outputs), "Output lengths differ between Flax and PyTorch")
for fx_output, pt_output in zip(fx_outputs[:4], pt_outputs[:4]):
self.assert_almost_equals(fx_output, pt_output.numpy(), 4e-2)
with tempfile.TemporaryDirectory() as tmpdirname:
fx_model.save_pretrained(tmpdirname)
pt_model_loaded = pt_model_class.from_pretrained(tmpdirname, from_flax=True)
with torch.no_grad():
pt_outputs_loaded = pt_model_loaded(**pt_inputs).to_tuple()
pt_outputs_loaded = pt_outputs_loaded[1:]
self.assertEqual(
len(fx_outputs), len(pt_outputs_loaded), "Output lengths differ between Flax and PyTorch"
)
for fx_output, pt_output in zip(fx_outputs[:4], pt_outputs_loaded[:4]):
self.assert_almost_equals(fx_output, pt_output.numpy(), 4e-2)
|
\documentclass{article}
\usepackage[margin=0.2cm]{geometry}
\usepackage{amsmath}
\usepackage{amssymb}
\usepackage{ulem}
\usepackage{hyperref}
\usepackage{minted}
\usepackage{multicol}
\usepackage{graphicx}
\usepackage{float}
\usepackage{subfigure}
\begin{document}
\tableofcontents
\newpage
\section{Hall's marriage theorem}
Let $G=(V,E)=(X+Y,E)$ be a bipartite graph, $G$ has a complete matching from $X$ to $Y$ iff $\forall S\subseteq X\ |S|\leq |N(S)|$,\\
where $N_G(S)=\{y\in Y\mid \exists x\in S\ (x,y)\in E\}$.
\subsubsection{sufficiency}
($\Rightarrow$)\quad
Let $M=\{(x,f(x))\in E\mid x\in X\}\subseteq E$ be a complete matching.\\
$N_G(S)=\{y\in Y\mid \exists x\in S\ (x,y)\in E\}\supseteq \{f(x)\mid x\in S\}$.
\subsubsection{necessity}
($\Leftarrow$)\quad
Apply induction on $|X|$.
\begin{enumerate}
\item When $|X|=1$, the necessity is hold.
\item Suppose that the necessity is hold, for $|X|\leq k$
\item For $|X|=k+1$, $\forall S\subseteq X\ |S|\leq |N_G(X)|$
\begin{itemize}
\item $\forall \varnothing\subsetneq S\subsetneq X\ |N_G(S)|>|S|$\\
Select any edge $e=(x,y)$. Remove the vertices $x,y$ and every edges $(u,v)$ to get $G'$ s.t. $x\in\{u,v\}\lor y\in\{u,v\}$.\\
In $G'$, $\forall \varnothing\subsetneq S\subseteq (X\setminus \{x\})\quad |N_{G'}(S)|\geq |N_{G}(S)|-1\geq |S|$.\\
So we can find a complete matching $M':X'\to Y'$ in $G'$.\\
Thus A complete matching $M:X\to Y$ can generated by $M'\cup \{(x,y)\}$
\item $\exists \varnothing\subsetneq S\subsetneq X\ |N_G(S)|=|S|$\\
Let $G_0=(V_0,E_0),G_1=(V_1,E_1)$ be two induced subgraph of $G$, where $V_0=S+N_G(S),V_1=(X\setminus S)+ (Y\setminus N_G(S))$.
\begin{itemize}
\item For $G_0$: $\forall P\subseteq S\ N_{G_0}(P)=N_{G}(P)$ so $\forall P\subseteq S\ |N_{G_0}(P)|=|N_{G}(P)|\geq |P|$.
\item For $G_1$: We claim that $\forall Q\subseteq (X\setminus S)\ |N_{G_1}(Q)|\geq |Q|$.\\
Otherwise, let $Q_0$ be a subset s.t. $|N_{G_1}(Q_0)|<|Q_0|$.\\
Then $N_{G}(S\cup Q_0)=N_{G}(S)\cup N_{G}(Q_0)$, where $N_{G}(S)=N_{G_0}(S),\ N_{G}(Q_0)\subseteq (N_{G}(S)\cup N_{G_1}(Q)),\ N_{G_1(Q_0)}\cap N_G(S)=\varnothing$.\\
which leads to $|N_{G}(S\cup Q_0)|=|\leq |N_G(S)|+|N_{G_0}(Q_0)| < |S|+|Q_0|$, however $|N_{G}(S\cup Q_0)|\geq |S\cup Q_0|=|S|+|Q_0|$.\\
Therefore in $G_1$, $\forall Q\subseteq (X\setminus S)\ |N_{G_1}(Q)|\geq |Q|$.\\
\end{itemize}
We can find a complete matching by merging the complete matching in $G_0$ and $G_1$.
\end{itemize}
\end{enumerate}
\subsubsection{generalization}
In a bipartite graph $G=(X+Y,E)$
Let $\mathrm{def}_G(S)=|S|-|N_G(S)|$,
then the size of maximum matching in $G$ is $|X|-\max_{\varnothing\subseteq S\subseteq X}\mathrm{def}_G(S)$
\newpage
\section{Havel-Hakimi algorithm}
\subsubsection{the theorem}
Given a list of non-negative integers $(d_1,d_2\ldots d_n)$ where $d_1\geq d_2\geq d_3\ldots d_n\geq 0$.\\
Is there a undirected simple\footnote{no loops $(v,v)$, no dup-edges $k\times (v,v)$} graph $G=(V,E)$ s.t. the degree sequence of $G$ is $(d_1,d_2\ldots d_n)$?
\begin{minted}{python}
from typing import List
def check(deg_seq: List[int]) -> bool:
if len(deg_seq)==0:
return True
head,seq = deg_seq[0],deg_seq[1:]
if len(seq)>=head:
for i in range(head):
seq[i]=seq[i]-1
seq = sorted(seq, reverse=True)
return seq[-1]>=0 and check(seq)
return False
\end{minted}
\subsubsection{proof}
\emph{TODO}
\newpage
\section{graph isomorphism invariant}
\subsection{degree sequence}
$G\cong H\implies f(G)=H(G)$, where $f(G)=\mathrm{multi-set}\{\deg_G(v)\mid v\in G\}$.\\
This is a necessary but not sufficient condition, see the following example, where $H,G$ have the same degree sequence but are not isomorphic to each other.
\begin{minted}{C}
//!/usr/bin/dot
// in graphviz dot
graph G{
1 -- 2
2 -- 3
3 -- 4
4 -- 5
2 -- x
}
graph H{
1 -- 2
2 -- 3
3 -- 4
4 -- 5
3 -- x
}
\end{minted}
\newpage
\section{Lower bound of $\max(\omega(G),\alpha(G))$}
\subsection{futher readings}
\href{https://en.wikipedia.org/wiki/Ramsey_theory}{wikipedia: Ramsey theory}
\subsection{statement}
(Ramsey's Theorem) Every graph with $n$ vertices contains either a clique or an independent set with at least $\frac{1}{2}\log_2 n$ vertices.\\
$\omega(G)$: the clique number.
$\alpha(G)$: the independence number.
\subsection{proof}
\begin{enumerate}
\item $n=1$, hold
\item $n=2$, hold
\item Suppose that $n=1,2,3\ldots k$, the statement is true\\
For $n=k+1$, select a arbitary vertex $u$.
Let $A=\{v\mid \{u,v\}\in E,v\neq u\},\, B=\{v\mid \{u,v\}\not\in E,v\neq u\}$
\begin{itemize}
\item $A$, there exists a clique $C$ of at least $\frac{1}{2}\log_2 |A|$ vertices.
$C+\{u\}$ is still a clique.
\item $B$, there exists a independent set $I$ of at least $\frac{1}{2}\log_2 |B|$ vertices.
$I+\{u\}$ is still an independent set.
\end{itemize}
Therefore, we can find either a clique or an independent set consisting of at least $1+\frac{1}{2}\max\left(\log_2 |A|+\log_2 |B|\right)$\\
$|A+B|=|A|+|B|=n-1=k\implies \max(|A|,|B|)\geq \frac{1}{2}k\implies \max\left(\log_2 |A|,\log_2 |B|\right)\geq -1+\log_2 k$\\
Thus $\max(\omega(G),\alpha(G))\geq 1+\left(-1+\log_2 k\right)=\log_2 k\geq \frac{1}{2}\log_2 n$
\end{enumerate}
\newpage
\section{Sufficient conditions for existence of a hamilton circuit }
\begin{itemize}
\item Dirac's Theorem:
A simple graph $G=(V,E)$ s.t. $|V|\geq 3$ and $\forall v\in V\ \deg(v)\geq \frac{|V|}{2}$ has a Hamilton circuit.
\item Ore's Theorem:
A simple graph $G=(V,E)$ s.t. $|V|\geq 3$ and $\forall \{u,v\}\left( \{u,v\}\not\in E\rightarrow \deg(u)+\deg(v)\geq |V|\right)$
\end{itemize}
\subsection{proof}
\newpage
\section{Kuratowski's Theorem: the equivalent condition of planar graph}
\subsection{statement}
\begin{itemize}
\item \emph{elementary subdivision (expansion)}: Let $G=(V,E)$ be a undirected graph.\\
Delete an edge $\{u,v\}$ and add a vertex $w$, two edges $\{u,w\},\{w,v\}$.\\
(adding a new vertex in the middle of an edge)
\item \emph{subdivision (expansion)}: subdivision of $G$: graphs that can be obtained by performing a series of elementary subdivision on $G$.
\item \emph{smoothing}: the reverse process of subdivision (or expansion).
\item \emph{homeomorphic}: Two graphs $G,H$ are call homeomorphic to each other
if a subdivision of $G$ is isomorphic to $H$
or a subdivision of $H$ is isomorphic to $G$.
\item \emph{theorem} if $H,G$ are homeomorphic graphs then $H$ is an planar graphs iff $G$ is planar.
\item \emph{Kuratowski's Theorem}: A graph $G$ is planar iff it does not have a subgraph that is homeomorphic to $K_{3,3}$ or $K_5$.
\end{itemize}
\newpage
\section{coloring planar graphs}
\emph{the graphs discussed in this section should be simple graphs (no self-loops nor multi-edges)}
\subsection{lemmans}
\begin{itemize}
\item A graph is planar iff its dual graph is planar.
\item \emph{Euler's formula for (connected) planar graph}: $V-E+R=2$,
where $V,E,R$ be the number of vertices, the number of edges, the number of regions.
\item \emph{degree} Define the degree of a vertex and a region,
$\deg(v)=\left|\{e\in E\mid e=\{u,v\}\}\right|$
and
$\deg(r)=\left|\{e\in E\mid \text{$e$ is on the boundary of $r$}\}\right|$
\item \emph{hand-shaking lemma}: For any undirected graph $G=(V,E)$, we have $2|E|=\sum_{v\in V}\deg(v)$\\
Apply it on the dual graph of a planar graph to get the practical property: $2|E|=\sum_{r\in \text{regions}}\deg(r)$
\item \emph{upper bound of edges in planar graph}: For a connected planar graph, if every region $r_i$ has $\deg(r_i)\geq d$,\\
then $2E=\sum_{r\in \text{region}}\deg(r)\geq dR=d(2+E-V)$,
thus $E\leq \frac{d}{d-2}(V-2)$\\
helpful collaries
\begin{itemize}
\item $V\geq 3$, planar, connected $\Rightarrow$ $E\leq 3V-6$
\item $V\geq 3$, planar, connected, no 3-cycle $\Rightarrow$ $E\leq 2V-4$
\item \emph{5 is an upper bound of $\delta$}: Every planar graph has a vertex of degree at most $5$
\end{itemize}
\end{itemize}
\subsection{The Six coloring theorem}
Induction, find the vertex $u$ with the least degree (by previous lemma $\deg(u)\leq 5$), assign a color that differs from all its neighbors' colors to $u$.
\subsection{The Four coloring theorem}
\subsection{The Five coloring theorem}
\begin{enumerate}
\item $V\leq 5$, hold.
\item Suppose that property is hold for $V=1,2,3\ldots k$
\item For $V=k+1$, find the vertex with the least degree denoted as $u$, find a $5$-coloring of $G-u$\\
WLOG, let $\deg(u)=5$, and the five neighbors are colorized with $A,B,C,D,E$.\\
Denote $v_1,v_2,v_2,v_4,v_5$ the neighbors of $v$ \emph{in clockwise order}\footnote{we would partition the plane with the edges $\{u,v_1\},\{u,v_2\},\{u,v_3\},\{u,v_4\},\{u,v_5\}$}\\
\begin{itemize}
\item If there is a path $P$ from $v_1$ to $v_3$ such that the vertices on the path have either color $A$ or color $C$.\\
Consider the circuit $u\to v_1\to P\to v_3\to u$, it split the plane into two region (namely, inner and outer part) where $v_2$ is inside and $v_4,v_5$ are outside.\\
Perform the re-coloring opertion $(A,B,C,D,E)\to (A,D,C,B,E)$ inside the circle.\\
This is still a valid $5$-coloring of $G-u$ and we can now assign color $B$ to $u$ obtaining a $5$-coloring of $G$.
\item $v_1,v_3$ are not connected only using the vertices of color $A$ or $C$.\\
Take the subgraph $H$ induced by all vertices of color $A$ and $C$, $v_1,v_3$ are in different connected component. Perform re-coloring opertion $(A,C)\to (C,A)$ in the connected component of $H$ that contains $v_1$\\
This is still a valid $5$-coloring of $G-u$ and we can now assign color $A$ to $u$ obtaining a $5$-coloring of $G$.
\end{itemize}
\end{enumerate}
\newpage
\subsection*{illustration}
\includegraphics{images/ch5-five-coloring-p1.png}
\includegraphics{images/ch5-five-coloring-p2.png}
\newpage
\section{Number of centroid/center s in a (unrooted) tree}
\newcommand{\ECC}{\mathrm{ECC}}
\newcommand{\V}{\mathrm{Vertex}}
\newcommand{\N}{\mathrm{Neighbor}}
\newcommand{\dis}{\mathrm{dis}}
\newcommand{\subtree}{\mathrm{subtree}}
\newcommand{\height}{\mathrm{height}}
\subsection{center of a tree}
The eccentricity of a vertex in an unrooted tree is the length of the longest simple path beginning at this vertex.
A vertex is called a center if no vertex in the tree has smaller eccentricity than this vertex.\\
Let $\ECC{u}=\max_{v\in \V{T}}\dis{u}{v}$, the vertices with maximum ECC is called centers.
\subsection{counting centers}
only two cases
\begin{itemize}
\item a unique center.
\item two adjacent centers.
\end{itemize}
Suppose that $c\in \V(T)$ is a center of $T$.
Make $c$ the root of $T$ to obtain a rooted tree $T'$.\\
Let $\N(c)=\{u_1,u_2\ldots u_k\}$
s.t. $\height (u_1)=H_1\geq \height (u_2)=H_2\cdots \height (u_k)=H_k$,
then $\ECC_T(u)=H_1+1$\\
Denote the leaf with maximum level in $\subtree(u_i)$ using $L_i$.
\begin{enumerate}
\item $H_1=H_2\geq H_3\geq H_4\cdots H_k$\\
$c$ is the unique center of $T$
\begin{itemize}
\item Centers in $\subtree(u_1)$ or $\subtree(u_2)$ do not exist.\\
Consider the path $c'\to c\to u_2\to L_2$,
we have $\ECC(c')\geq 1+1+H_2=2+H_1>\ECC(u)$.
\item Centers in $\subtree(u_3)\ldots \subtree(u_k)$ do not exist.\\
The path $c'\to u_i\to c\to u_1\to L_1$,
we have $\ECC(c')\geq 1+1+H_1> \ECC(u)$.
\end{itemize}
\item $H_1-1=H_2\geq H_3\geq H_4\cdots H_k$\\
$c,u_1$ are the two adjacent centers of $T$.
The longest simple path from $u_1$ is $u_1\to c\to u_2\to L_2$, $\ECC(u_1)=2+H_2=H_1+1=\ECC(c)$
\begin{itemize}
\item Centers in $\subtree(u_1)-\{u_1\}$ do not exist.\\
path $c'\to u_1\to c\to u_2\to L_2$,
we have $\ECC(c')\geq 2+1+H_2=H_1+2>\ECC(c)$
\item Centers in $\subtree(u_2)\ldots \subtree(u_k)$ do not exist.\\
path $c'\to u_k\to c\to u_1\to L_1$,
we have $\ECC(c')\geq 2+1+H_1>\ECC(c)$
\end{itemize}
\item $H_1-2=H_2\geq H_3\geq H_4\cdots H_k$\\
This is impossible.
Otherwise $\ECC(u_1)=\max(H_1,H_2+1)=H_1<H_1+1 =\ECC(c)$,
$c$ can not be a center of $T$.
Contradiction.
\end{enumerate}
\end{document}
|
{-# OPTIONS --cubical #-}
module Cubical.Categories.Functor where
open import Cubical.Foundations.Prelude
open import Cubical.HITs.PropositionalTruncation
open import Cubical.Categories.Category
private
variable
ℓ𝒞 ℓ𝒞' ℓ𝒟 ℓ𝒟' : Level
record Functor (𝒞 : Precategory ℓ𝒞 ℓ𝒞') (𝒟 : Precategory ℓ𝒟 ℓ𝒟') : Type (ℓ-max (ℓ-max ℓ𝒞 ℓ𝒞') (ℓ-max ℓ𝒟 ℓ𝒟')) where
no-eta-equality
open Precategory
field
F-ob : 𝒞 .ob → 𝒟 .ob
F-hom : {x y : 𝒞 .ob} → 𝒞 .hom x y → 𝒟 .hom (F-ob x) (F-ob y)
F-idn : {x : 𝒞 .ob} → F-hom (𝒞 .idn x) ≡ 𝒟 .idn (F-ob x)
F-seq : {x y z : 𝒞 .ob} (f : 𝒞 .hom x y) (g : 𝒞 .hom y z) → F-hom (𝒞 .seq f g) ≡ 𝒟 .seq (F-hom f) (F-hom g)
is-full = (x y : _) (F[f] : 𝒟 .hom (F-ob x) (F-ob y)) → ∥ Σ (𝒞 .hom x y) (λ f → F-hom f ≡ F[f]) ∥
is-faithful = (x y : _) (f g : 𝒞 .hom x y) → F-hom f ≡ F-hom g → f ≡ g
|
\documentclass[journal]{IEEEtran}
\usepackage{graphicx}
\graphicspath{ {../report/} }
\usepackage{hyperref}
\ifCLASSINFOpdf
\else
\fi
\hyphenation{op-tical net-works semi-conduc-tor}
\begin{document}
\title{GPU Optimized Pedestrian Detection}
\author{Sam Kreter}
\markboth{High Performance Computing}
{Shell \MakeLowercase{\textit{et al.}}: Bare Demo of IEEEtran.cls for IEEE Journals}
\maketitle
\begin{abstract}
The OpenCV library has a good CPU and GPU implementation of a Histogram of Oriented Gradients as well as an Support Vector Machine. This paper will go through the comparisons of the two implementations for finding and identify objects on different size images. It will also look into the effect that the number of threads per block has on the final computation time of the GPU implementation.
\end{abstract}
\begin{IEEEkeywords}
HOG (Histogram of Oriented Gradients), SVM (Support Vector Machine), OpenCV, GPU, Cuda
\end{IEEEkeywords}
\IEEEpeerreviewmaketitle
\section{Introduction}
\IEEEPARstart{P}{edestrian} detection is a main component in many applications such as crowd control systems and people tracking. One common way of implementing a people detection system is using a Histogram of Oriented Gradients to extract the features from an image and an Support Vector Machine to classify each element of the image as a person or not. HOG works by segmenting the image in many windows then creating a histogram of the orientations or directions of each cell of the segment. The histograms are then concatenated together to create a feature vector of floating points. The SVM then takes the feature vector to classify the objects found in the image. \\
\section{Implementation}
In order to implement the Pedestrian detection system, it is necessary to have an implementation of a Histogram of Oriented Gradients and a SVM that is trained on the HOG features of a person in different walking positions. The openCV library comes with both a standard CPU implementation and a accelerated GPU implementation of both the HOG feature extraction as well as the pre trained SVM. \\
\subsection{CPU Implementation}
For OpenCV’s CPU implementation, the HOG feature extractor is abstracted into an object where simple function calls are used to set the different properties and load the image. The object itself comes with a built in function “getDefaultPeopleDetector()” that will return OpenCV’s pre trained SVM which then is passed into a simple “setSVMDetector()” to set the SVM for the object. Then with one call to a detectMultiScale function the openCV will compute the HOG for the image and return the specifications such as the location width and height for the detected objects.
From an interface perspective the GPU implementation works almost the same as the CPU implementations. It is abstracted into an object but instead of instantiating the object, a function call will return a pointer to it. The rest of the implementation follows the CPU except for before the detection is a function call to “upload” the image to the GPU which is an abstraction for the cudamemcpy. \\
\subsection{GPU Implementation}
The GPU implementation under the hood make use of three kernel functions that run on the GPU, one to compute the gradients, one to compute the histogram and one to classify the histogram. Due to the abstraction that OpenCV uses around the Cuda code for the GPU kernels, it was necessary to build the OpenCV library from source and recompile the code base with changes to the number of threads per block passed to the kernel on the GPU.
The library’s original code had 256 hard coded in for the number of threads per block in the compute gradients and classify histogram kernels. The compute histogram uses the number of cells in the histogram as a base for the number of threads per block. \\
After compiling and installing the modified library I used put together the both the CPU and GPU implementations in order to build the pedestrian Detector.
\section{Experiments}
In order to get quantitative results for the speed up that comes with the GPU, I used a simple image of 4 people walking. I then timed booth the CPU and GPU implementations’ computation times. I ran this 5 times for each image sizes 550x366 , 1100x732 , 2200x1464 , 2750x1830 , 5500x3660 as well as re compiling the OpenCV library for each of the threads per block sizes 1, 32, 128, 256, 512, 1024. I then took the average of the 5 runs for each combinations to get a more stable final results. I found that the GPU had the greatest speed up time of 4 times faster than the CPU for 128 threads per block and an image size of 2750x1830 or 5500x3660. \\
\begin{figure}[h]
\caption{Size of the Image vs the Computation Time. All GPU kernels are being called with 128 threads per block.}
\includegraphics[width=9cm]{SizeTime}
\label{fig:SizeTime}
\end{figure}
Figure \ref{fig:SizeTime} shows the increase speed up of the GPU implementation as the size of the image is increased. The figure also shows that as the image size increases, the CPU implementation’s computation time grows at a much faster rate than the GPU implantation does. \\
\begin{figure}[h]
\caption{Number of threads per block vs the Computation Time. It is hard to tell with the scaling that the gpu times continually decrease until 128 threads per block then slowly increase. Image size of 2750x1830 is used for all tests.}
\includegraphics[width=9cm]{ThreadTime}
\label{fig:ThreadTime}
\end{figure}
Figure \ref{fig:ThreadTime} shows that at 1 thread per block the GPU performs much worse than the CPU implementation. This is due to the slow down of having to move the data from the main memory to the GPU’s memory and then the retrieval of the data. After 1 thread per block the GPU takes advantage and hits its maximum speed up at 128 then very slowly starts to have a slower speed up as more threads per block are added. This is due to the overhead of the idle threads per block that do not have work to do on the image.
\section{Challenges}
One of the biggest challenges I faced was the compilation of the OpenCV library with Cuda capabilities from source. This was not the first time building and installing libraries from source but it turned out to be very challenging to have the correct build flags set to compile for the specific GPU software on the AWS Nvidia AMI that I used for deployment. It took many iterations of rebuilding with different flags and installing dependencies to finally get a working version that could be modified rebuild and reinstalled. \\
Anther challenge I faced was dealing with the AWS Nvidia AMI. None of the Cuda examples were installed with the SDK. One of the biggest problems I faced with the AMI was that I would repeatedly get an error “(-217) all CUDA-capable devices are busy or unavailable in function allocate” and would have to completely stop the machine then start it in order to have the proper connection with the GPUs. \\
A final challenge was with the differences between OpenCV 2 and 3’s implementation of Cuda abstraction. In order to make the final program I went through a lot of the source code to find how to use the interfaces for the GPU. \\
\section{Conclusion}
OpenCV shows that for a GPU pedestrian detection system using HOG and the default pre trained SVM should be around 8 times faster than the CPU implementation which can be seen in figure \ref{fig:opencvSpeed}. My final results show that at the fastest point which is using 128 threads per block on and image larger than 2750x1830 I would only have the GPU implementation at 4 times that of the CPU implementation. \\
\begin{figure}[h]
\caption{OpenCV's chart for GPU speed up compared to CPU.}
\includegraphics[width=9cm]{opencvSpeed}
\label{fig:opencvSpeed}
\end{figure}
I also found it interesting that after 1 thread per block the number of threads per block had a very small impact on the processing speed of the GPU. One reason for this is that calculating the grid size and number of blocks based off of the threads per block helps eliminate idle threads.
\ifCLASSOPTIONcaptionsoff
\newpage
\fi
\begin{thebibliography}{1}
\bibitem{OpenCVCuda}
\emph{OpenCV Cuda Comparison} \url{http://opencv.org/platforms/cuda.html}
\bibitem{OpenCVHog}
Tulloch, Andrew. \emph{OpenCV Cuda HOG Docs} \url{http://docs.opencv.org/3.0-beta/modules/cuda/doc/object_detection.html}
\end{thebibliography}
\end{document} |
OFFICIAL WEBSITE®. Vista Alegre Hostel in Alcudia, Majorca.
The Vista Alegre Hostel By Eurotels is an affordable option to enjoy some pleasant holidays in Alcudia. It’s situated on the beachfront at the Alcudia Port and has views of the bay and the Alcudiamar Nautical Club as well as ocean view rooms with balconies and free Wi-Fi Internet access throughout the hotel. Discover our Vista Alegre Hostel at the Alcudia Port now! |
REBOL [
Title: "Red/System compilation error test"
File: %comp-err-test.r
License: "BSD-3 - https://github.com/dockimbel/Red/blob/master/BSD-3-License.txt"
]
change-dir %../ ;; revert to tests/ dir (from runnable)
~~~start-file~~~ "comp-err"
--test-- "sample compilation error test"
--compile-this {
Red/System []
i := 1;
}
--assert parse qt/comp-output [
thru "*** Compilation Error: undefined symbol"
thru "at line: 3"
thru "near: [" thru "i := 1" thru "]"
to end
]
--clean
--test-- "error line reporting test"
--compile-this {
Red/System []
foo: func [][
if true [
either true [
a
][
123
]
]
]
}
--assert parse qt/comp-output [
thru "*** Compilation Error: undefined symbol: a"
thru "at line: 6"
to end
]
--clean
~~~end-file~~~
|
-- Andreas, 2014-09-23
-- Syntax declaration for overloaded constructor.
-- {-# OPTIONS -v scope.operators:50 #-}
syntax c x = ⟦ x ⟧
data D1 : Set where
c : D1
data D2 : Set where
c : D1 → D2
test : D2
test = ⟦ c ⟧
-- Should work.
|
module JS.Nullable
import Data.List.Elem
import JS.Inheritance
import JS.Marshall
import JS.Util
export
data Nullable : Type -> Type where [external]
%foreign "javascript:lambda:()=>null"
prim__null : AnyPtr
export
null : Nullable a
null = believe_me prim__null
export
nonNull : a -> Nullable a
nonNull = believe_me
||| Tests, whether a value of questionable origin is null
export
isNull : a -> Bool
isNull = eqv prim__null
export
maybeToNullable : Maybe a -> Nullable a
maybeToNullable = maybe null nonNull
export
mayUp : (0 _ : JSType a) => Maybe a -> {auto 0 _ : Elem b (Types a)} -> Nullable b
mayUp x = maybe null (\v => nonNull $ up v) x
export
nullableToMaybe : Nullable a -> Maybe a
nullableToMaybe v = if isNull v then Nothing else Just (believe_me v)
export
ToFFI a b => ToFFI (Maybe a) (Nullable b) where
toFFI = maybeToNullable . map toFFI
export
FromFFI a b => FromFFI (Maybe a) (Nullable b) where
fromFFI v = case nullableToMaybe v of
Nothing => Just Nothing
Just x => map Just $ fromFFI x
export
SafeCast a => SafeCast (Nullable a) where
safeCast ptr = if isNull ptr
then Just null
else map nonNull $ safeCast ptr
|
lemma space_empty: "space M = {} \<Longrightarrow> M = count_space {}" |
Suppose $S$ is an open set in the complex plane, and $\mathcal{F}$ is a sequence of holomorphic functions on $S$ such that the range of $\mathcal{F}$ is a bounded set. Then there exists a subsequence $\mathcal{F}'$ of $\mathcal{F}$ and a holomorphic function $g$ on $S$ such that $\mathcal{F}'$ converges uniformly to $g$ on every compact subset of $S$. |
(*
* Copyright 2014, General Dynamics C4 Systems
*
* SPDX-License-Identifier: GPL-2.0-only
*)
theory Ipc_R
imports Finalise_R
begin
context begin interpretation Arch . (*FIXME: arch_split*)
lemmas lookup_slot_wrapper_defs'[simp] =
lookupSourceSlot_def lookupTargetSlot_def lookupPivotSlot_def
lemma getMessageInfo_corres: "corres ((=) \<circ> message_info_map)
(tcb_at t) (tcb_at' t)
(get_message_info t) (getMessageInfo t)"
apply (rule corres_guard_imp)
apply (unfold get_message_info_def getMessageInfo_def fun_app_def)
apply (simp add: ARM_H.msgInfoRegister_def
ARM.msgInfoRegister_def ARM_A.msg_info_register_def)
apply (rule corres_split_eqr[OF asUser_getRegister_corres])
apply (rule corres_trivial, simp add: message_info_from_data_eqv)
apply (wp | simp)+
done
lemma get_mi_inv'[wp]: "\<lbrace>I\<rbrace> getMessageInfo a \<lbrace>\<lambda>x. I\<rbrace>"
by (simp add: getMessageInfo_def, wp)
definition
"get_send_cap_relation rv rv' \<equiv>
(case rv of Some (c, cptr) \<Rightarrow> (\<exists>c' cptr'. rv' = Some (c', cptr') \<and>
cte_map cptr = cptr' \<and>
cap_relation c c')
| None \<Rightarrow> rv' = None)"
lemma cap_relation_mask:
"\<lbrakk> cap_relation c c'; msk' = rights_mask_map msk \<rbrakk> \<Longrightarrow>
cap_relation (mask_cap msk c) (maskCapRights msk' c')"
by simp
lemma lsfco_cte_at':
"\<lbrace>valid_objs' and valid_cap' cap\<rbrace>
lookupSlotForCNodeOp f cap idx depth
\<lbrace>\<lambda>rv. cte_at' rv\<rbrace>, -"
apply (simp add: lookupSlotForCNodeOp_def)
apply (rule conjI)
prefer 2
apply clarsimp
apply (wp)
apply (clarsimp simp: split_def unlessE_def
split del: if_split)
apply (wp hoare_drop_imps throwE_R)
done
declare unifyFailure_wp [wp]
(* FIXME: move *)
lemma unifyFailure_wp_E [wp]:
"\<lbrace>P\<rbrace> f -, \<lbrace>\<lambda>_. E\<rbrace> \<Longrightarrow> \<lbrace>P\<rbrace> unifyFailure f -, \<lbrace>\<lambda>_. E\<rbrace>"
unfolding validE_E_def
by (erule unifyFailure_wp)+
(* FIXME: move *)
lemma unifyFailure_wp2 [wp]:
assumes x: "\<lbrace>P\<rbrace> f \<lbrace>\<lambda>_. Q\<rbrace>"
shows "\<lbrace>P\<rbrace> unifyFailure f \<lbrace>\<lambda>_. Q\<rbrace>"
by (wp x, simp)
definition
ct_relation :: "captransfer \<Rightarrow> cap_transfer \<Rightarrow> bool"
where
"ct_relation ct ct' \<equiv>
ct_receive_root ct = to_bl (ctReceiveRoot ct')
\<and> ct_receive_index ct = to_bl (ctReceiveIndex ct')
\<and> ctReceiveDepth ct' = unat (ct_receive_depth ct)"
(* MOVE *)
lemma valid_ipc_buffer_ptr_aligned_2:
"\<lbrakk>valid_ipc_buffer_ptr' a s; is_aligned y 2 \<rbrakk> \<Longrightarrow> is_aligned (a + y) 2"
unfolding valid_ipc_buffer_ptr'_def
apply clarsimp
apply (erule (1) aligned_add_aligned)
apply (simp add: msg_align_bits)
done
(* MOVE *)
lemma valid_ipc_buffer_ptr'D2:
"\<lbrakk>valid_ipc_buffer_ptr' a s; y < max_ipc_words * 4; is_aligned y 2\<rbrakk> \<Longrightarrow> typ_at' UserDataT (a + y && ~~ mask pageBits) s"
unfolding valid_ipc_buffer_ptr'_def
apply clarsimp
apply (subgoal_tac "(a + y) && ~~ mask pageBits = a && ~~ mask pageBits")
apply simp
apply (rule mask_out_first_mask_some [where n = msg_align_bits])
apply (erule is_aligned_add_helper [THEN conjunct2])
apply (erule order_less_le_trans)
apply (simp add: msg_align_bits max_ipc_words )
apply simp
done
lemma loadCapTransfer_corres:
"corres ct_relation \<top> (valid_ipc_buffer_ptr' buffer) (load_cap_transfer buffer) (loadCapTransfer buffer)"
apply (simp add: load_cap_transfer_def loadCapTransfer_def
captransfer_from_words_def
capTransferDataSize_def capTransferFromWords_def
msgExtraCapBits_def word_size add.commute add.left_commute
msg_max_length_def msg_max_extra_caps_def word_size_def
msgMaxLength_def msgMaxExtraCaps_def msgLengthBits_def wordSize_def wordBits_def
del: upt.simps)
apply (rule corres_guard_imp)
apply (rule corres_split[OF load_word_corres])
apply (rule corres_split[OF load_word_corres])
apply (rule corres_split[OF load_word_corres])
apply (rule_tac P=\<top> and P'=\<top> in corres_inst)
apply (clarsimp simp: ct_relation_def)
apply (wp no_irq_loadWord)+
apply simp
apply (simp add: conj_comms)
apply safe
apply (erule valid_ipc_buffer_ptr_aligned_2, simp add: is_aligned_def)+
apply (erule valid_ipc_buffer_ptr'D2, simp add: max_ipc_words, simp add: is_aligned_def)+
done
lemma getReceiveSlots_corres:
"corres (\<lambda>xs ys. ys = map cte_map xs)
(tcb_at receiver and valid_objs and pspace_aligned)
(tcb_at' receiver and valid_objs' and pspace_aligned' and pspace_distinct' and
case_option \<top> valid_ipc_buffer_ptr' recv_buf)
(get_receive_slots receiver recv_buf)
(getReceiveSlots receiver recv_buf)"
apply (cases recv_buf)
apply (simp add: getReceiveSlots_def)
apply (simp add: getReceiveSlots_def split_def)
apply (rule corres_guard_imp)
apply (rule corres_split[OF loadCapTransfer_corres])
apply (rule corres_empty_on_failure)
apply (rule corres_splitEE)
apply (rule corres_unify_failure)
apply (rule lookup_cap_corres)
apply (simp add: ct_relation_def)
apply simp
apply (rule corres_splitEE)
apply (rule corres_unify_failure)
apply (simp add: ct_relation_def)
apply (erule lookupSlotForCNodeOp_corres [OF _ refl])
apply simp
apply (simp add: split_def liftE_bindE unlessE_whenE)
apply (rule corres_split[OF get_cap_corres])
apply (rule corres_split_norE)
apply (rule corres_whenE)
apply (case_tac cap, auto)[1]
apply (rule corres_trivial, simp)
apply simp
apply (rule corres_trivial, simp add: returnOk_def)
apply (wp lookup_cap_valid lookup_cap_valid' lsfco_cte_at | simp)+
done
lemma get_recv_slot_inv'[wp]:
"\<lbrace> P \<rbrace> getReceiveSlots receiver buf \<lbrace>\<lambda>rv'. P \<rbrace>"
apply (case_tac buf)
apply (simp add: getReceiveSlots_def)
apply (simp add: getReceiveSlots_def
split_def unlessE_def)
apply (wp | simp)+
done
lemma get_rs_cte_at'[wp]:
"\<lbrace>\<top>\<rbrace>
getReceiveSlots receiver recv_buf
\<lbrace>\<lambda>rv s. \<forall>x \<in> set rv. cte_wp_at' (\<lambda>c. cteCap c = capability.NullCap) x s\<rbrace>"
apply (cases recv_buf)
apply (simp add: getReceiveSlots_def)
apply (wp,simp)
apply (clarsimp simp add: getReceiveSlots_def
split_def whenE_def unlessE_whenE)
apply wp
apply simp
apply (rule getCTE_wp)
apply (simp add: cte_wp_at_ctes_of cong: conj_cong)
apply wp+
apply simp
done
lemma get_rs_real_cte_at'[wp]:
"\<lbrace>valid_objs'\<rbrace>
getReceiveSlots receiver recv_buf
\<lbrace>\<lambda>rv s. \<forall>x \<in> set rv. real_cte_at' x s\<rbrace>"
apply (cases recv_buf)
apply (simp add: getReceiveSlots_def)
apply (wp,simp)
apply (clarsimp simp add: getReceiveSlots_def
split_def whenE_def unlessE_whenE)
apply wp
apply simp
apply (wp hoare_drop_imps)[1]
apply simp
apply (wp lookup_cap_valid')+
apply simp
done
declare word_div_1 [simp]
declare word_minus_one_le [simp]
declare word32_minus_one_le [simp]
lemma loadWordUser_corres':
"\<lbrakk> y < unat max_ipc_words; y' = of_nat y * 4 \<rbrakk> \<Longrightarrow>
corres (=) \<top> (valid_ipc_buffer_ptr' a) (load_word_offs a y) (loadWordUser (a + y'))"
apply simp
apply (erule loadWordUser_corres)
done
declare loadWordUser_inv [wp]
lemma getExtraCptrs_inv[wp]:
"\<lbrace>P\<rbrace> getExtraCPtrs buf mi \<lbrace>\<lambda>rv. P\<rbrace>"
apply (cases mi, cases buf, simp_all add: getExtraCPtrs_def)
apply (wp dmo_inv' mapM_wp' loadWord_inv)
done
lemma badge_derived_mask [simp]:
"badge_derived' (maskCapRights R c) c' = badge_derived' c c'"
by (simp add: badge_derived'_def)
declare derived'_not_Null [simp]
lemma maskCapRights_vsCapRef[simp]:
"vsCapRef (maskCapRights msk cap) = vsCapRef cap"
unfolding vsCapRef_def
apply (cases cap, simp_all add: maskCapRights_def isCap_simps Let_def)
apply (rename_tac arch_capability)
apply (case_tac arch_capability;
simp add: maskCapRights_def ARM_H.maskCapRights_def isCap_simps Let_def)
done
lemma corres_set_extra_badge:
"b' = b \<Longrightarrow>
corres dc (in_user_frame buffer)
(valid_ipc_buffer_ptr' buffer and
(\<lambda>_. msg_max_length + 2 + n < unat max_ipc_words))
(set_extra_badge buffer b n) (setExtraBadge buffer b' n)"
apply (rule corres_gen_asm2)
apply (drule storeWordUser_corres [where a=buffer and w=b])
apply (simp add: set_extra_badge_def setExtraBadge_def buffer_cptr_index_def
bufferCPtrOffset_def Let_def)
apply (simp add: word_size word_size_def wordSize_def wordBits_def
bufferCPtrOffset_def buffer_cptr_index_def msgMaxLength_def
msg_max_length_def msgLengthBits_def store_word_offs_def
add.commute add.left_commute)
done
crunch typ_at': setExtraBadge "\<lambda>s. P (typ_at' T p s)"
lemmas setExtraBadge_typ_ats' [wp] = typ_at_lifts [OF setExtraBadge_typ_at']
crunch valid_pspace' [wp]: setExtraBadge valid_pspace'
crunch cte_wp_at' [wp]: setExtraBadge "cte_wp_at' P p"
crunch ipc_buffer' [wp]: setExtraBadge "valid_ipc_buffer_ptr' buffer"
crunch inv'[wp]: getExtraCPtr P (wp: dmo_inv' loadWord_inv)
lemmas unifyFailure_discard2
= corres_injection[OF id_injection unifyFailure_injection, simplified]
lemma deriveCap_not_null:
"\<lbrace>\<top>\<rbrace> deriveCap slot cap \<lbrace>\<lambda>rv. K (rv \<noteq> NullCap \<longrightarrow> cap \<noteq> NullCap)\<rbrace>,-"
apply (simp add: deriveCap_def split del: if_split)
apply (case_tac cap)
apply (simp_all add: Let_def isCap_simps)
apply wp
apply simp
done
lemma deriveCap_derived_foo:
"\<lbrace>\<lambda>s. \<forall>cap'. (cte_wp_at' (\<lambda>cte. badge_derived' cap (cteCap cte)
\<and> capASID cap = capASID (cteCap cte) \<and> cap_asid_base' cap = cap_asid_base' (cteCap cte)
\<and> cap_vptr' cap = cap_vptr' (cteCap cte)) slot s
\<and> valid_objs' s \<and> cap' \<noteq> NullCap \<longrightarrow> cte_wp_at' (is_derived' (ctes_of s) slot cap' \<circ> cteCap) slot s)
\<and> (cte_wp_at' (untyped_derived_eq cap \<circ> cteCap) slot s
\<longrightarrow> cte_wp_at' (untyped_derived_eq cap' \<circ> cteCap) slot s)
\<and> (s \<turnstile>' cap \<longrightarrow> s \<turnstile>' cap') \<and> (cap' \<noteq> NullCap \<longrightarrow> cap \<noteq> NullCap) \<longrightarrow> Q cap' s\<rbrace>
deriveCap slot cap \<lbrace>Q\<rbrace>,-"
using deriveCap_derived[where slot=slot and c'=cap] deriveCap_valid[where slot=slot and c=cap]
deriveCap_untyped_derived[where slot=slot and c'=cap] deriveCap_not_null[where slot=slot and cap=cap]
apply (clarsimp simp: validE_R_def validE_def valid_def split: sum.split)
apply (frule in_inv_by_hoareD[OF deriveCap_inv])
apply (clarsimp simp: o_def)
apply (drule spec, erule mp)
apply safe
apply fastforce
apply (drule spec, drule(1) mp)
apply fastforce
apply (drule spec, drule(1) mp)
apply fastforce
apply (drule spec, drule(1) bspec, simp)
done
lemma valid_mdb_untyped_incD':
"valid_mdb' s \<Longrightarrow> untyped_inc' (ctes_of s)"
by (simp add: valid_mdb'_def valid_mdb_ctes_def)
lemma cteInsert_cte_wp_at:
"\<lbrace>\<lambda>s. cte_wp_at' (\<lambda>c. is_derived' (ctes_of s) src cap (cteCap c)) src s
\<and> valid_mdb' s \<and> valid_objs' s
\<and> (if p = dest then P cap
else cte_wp_at' (\<lambda>c. P (maskedAsFull (cteCap c) cap)) p s)\<rbrace>
cteInsert cap src dest
\<lbrace>\<lambda>uu. cte_wp_at' (\<lambda>c. P (cteCap c)) p\<rbrace>"
apply (simp add: cteInsert_def)
apply (wp updateMDB_weak_cte_wp_at updateCap_cte_wp_at_cases getCTE_wp static_imp_wp
| clarsimp simp: comp_def
| unfold setUntypedCapAsFull_def)+
apply (drule cte_at_cte_wp_atD)
apply (elim exE)
apply (rule_tac x=cte in exI)
apply clarsimp
apply (drule cte_at_cte_wp_atD)
apply (elim exE)
apply (rule_tac x=ctea in exI)
apply clarsimp
apply (cases "p=dest")
apply (clarsimp simp: cte_wp_at'_def)
apply (cases "p=src")
apply clarsimp
apply (intro conjI impI)
apply ((clarsimp simp: cte_wp_at'_def maskedAsFull_def split: if_split_asm)+)[2]
apply clarsimp
apply (rule conjI)
apply (clarsimp simp: maskedAsFull_def cte_wp_at_ctes_of split:if_split_asm)
apply (erule disjE) prefer 2 apply simp
apply (clarsimp simp: is_derived'_def isCap_simps)
apply (drule valid_mdb_untyped_incD')
apply (case_tac cte, case_tac cteb, clarsimp)
apply (drule untyped_incD', (simp add: isCap_simps)+)
apply (frule(1) ctes_of_valid'[where p = p])
apply (clarsimp simp:valid_cap'_def capAligned_def split:if_splits)
apply (drule_tac y ="of_nat fb" in word_plus_mono_right[OF _ is_aligned_no_overflow',rotated])
apply simp+
apply (rule word_of_nat_less)
apply simp
apply (simp add:p_assoc_help)
apply (simp add: max_free_index_def)
apply (clarsimp simp: maskedAsFull_def is_derived'_def badge_derived'_def
isCap_simps capMasterCap_def cte_wp_at_ctes_of
split: if_split_asm capability.splits)
done
lemma cteInsert_weak_cte_wp_at3:
assumes imp:"\<And>c. P c \<Longrightarrow> \<not> isUntypedCap c"
shows " \<lbrace>\<lambda>s. if p = dest then P cap
else cte_wp_at' (\<lambda>c. P (cteCap c)) p s\<rbrace>
cteInsert cap src dest
\<lbrace>\<lambda>uu. cte_wp_at' (\<lambda>c. P (cteCap c)) p\<rbrace>"
by (wp updateMDB_weak_cte_wp_at updateCap_cte_wp_at_cases getCTE_wp' static_imp_wp
| clarsimp simp: comp_def cteInsert_def
| unfold setUntypedCapAsFull_def
| auto simp: cte_wp_at'_def dest!: imp)+
lemma maskedAsFull_null_cap[simp]:
"(maskedAsFull x y = capability.NullCap) = (x = capability.NullCap)"
"(capability.NullCap = maskedAsFull x y) = (x = capability.NullCap)"
by (case_tac x, auto simp:maskedAsFull_def isCap_simps )
lemma maskCapRights_eq_null:
"(RetypeDecls_H.maskCapRights r xa = capability.NullCap) =
(xa = capability.NullCap)"
apply (cases xa; simp add: maskCapRights_def isCap_simps)
apply (rename_tac arch_capability)
apply (case_tac arch_capability)
apply (simp_all add: ARM_H.maskCapRights_def isCap_simps)
done
lemma cte_refs'_maskedAsFull[simp]:
"cte_refs' (maskedAsFull a b) = cte_refs' a"
apply (rule ext)+
apply (case_tac a)
apply (clarsimp simp:maskedAsFull_def isCap_simps)+
done
lemma transferCapsToSlots_corres:
"\<lbrakk> list_all2 (\<lambda>(cap, slot) (cap', slot'). cap_relation cap cap'
\<and> slot' = cte_map slot) caps caps';
mi' = message_info_map mi \<rbrakk> \<Longrightarrow>
corres ((=) \<circ> message_info_map)
(\<lambda>s. valid_objs s \<and> pspace_aligned s \<and> pspace_distinct s \<and> valid_mdb s
\<and> valid_list s
\<and> (case ep of Some x \<Rightarrow> ep_at x s | _ \<Rightarrow> True)
\<and> (\<forall>x \<in> set slots. cte_wp_at (\<lambda>cap. cap = cap.NullCap) x s \<and>
real_cte_at x s)
\<and> (\<forall>(cap, slot) \<in> set caps. valid_cap cap s \<and>
cte_wp_at (\<lambda>cp'. (cap \<noteq> cap.NullCap \<longrightarrow> cp'\<noteq>cap \<longrightarrow> cp' = masked_as_full cap cap )) slot s )
\<and> distinct slots
\<and> in_user_frame buffer s)
(\<lambda>s. valid_pspace' s
\<and> (case ep of Some x \<Rightarrow> ep_at' x s | _ \<Rightarrow> True)
\<and> (\<forall>x \<in> set (map cte_map slots).
cte_wp_at' (\<lambda>cte. cteCap cte = NullCap) x s
\<and> real_cte_at' x s)
\<and> distinct (map cte_map slots)
\<and> valid_ipc_buffer_ptr' buffer s
\<and> (\<forall>(cap, slot) \<in> set caps'. valid_cap' cap s \<and>
cte_wp_at' (\<lambda>cte. cap \<noteq> NullCap \<longrightarrow> cteCap cte \<noteq> cap \<longrightarrow> cteCap cte = maskedAsFull cap cap) slot s)
\<and> 2 + msg_max_length + n + length caps' < unat max_ipc_words)
(transfer_caps_loop ep buffer n caps slots mi)
(transferCapsToSlots ep buffer n caps'
(map cte_map slots) mi')"
(is "\<lbrakk> list_all2 ?P caps caps'; ?v \<rbrakk> \<Longrightarrow> ?corres")
proof (induct caps caps' arbitrary: slots n mi mi' rule: list_all2_induct)
case Nil
show ?case using Nil.prems by (case_tac mi, simp)
next
case (Cons x xs y ys slots n mi mi')
note if_weak_cong[cong] if_cong [cong del]
assume P: "?P x y"
show ?case using Cons.prems P
apply (clarsimp split del: if_split)
apply (simp add: Let_def split_def word_size liftE_bindE
word_bits_conv[symmetric] split del: if_split)
apply (rule corres_const_on_failure)
apply (simp add: dc_def[symmetric] split del: if_split)
apply (rule corres_guard_imp)
apply (rule corres_if2)
apply (case_tac "fst x", auto simp add: isCap_simps)[1]
apply (rule corres_split[OF corres_set_extra_badge])
apply (clarsimp simp: is_cap_simps)
apply (drule conjunct1)
apply simp
apply (rule corres_rel_imp, rule Cons.hyps, simp_all)[1]
apply (case_tac mi, simp)
apply (simp add: split_def)
apply (wp hoare_vcg_const_Ball_lift)
apply (subgoal_tac "obj_ref_of (fst x) = capEPPtr (fst y)")
prefer 2
apply (clarsimp simp: is_cap_simps)
apply (simp add: split_def)
apply (wp hoare_vcg_const_Ball_lift)
apply (rule_tac P="slots = []" and Q="slots \<noteq> []" in corres_disj_division)
apply simp
apply (rule corres_trivial, simp add: returnOk_def)
apply (case_tac mi, simp)
apply (simp add: list_case_If2 split del: if_split)
apply (rule corres_splitEE)
apply (rule unifyFailure_discard2)
apply (case_tac mi, clarsimp)
apply (rule deriveCap_corres)
apply (simp add: remove_rights_def)
apply clarsimp
apply (rule corres_split_norE)
apply (rule corres_whenE)
apply (case_tac cap', auto)[1]
apply (rule corres_trivial, simp)
apply (case_tac mi, simp)
apply simp
apply (simp add: liftE_bindE)
apply (rule corres_split_nor)
apply (rule cteInsert_corres, simp_all add: hd_map)[1]
apply (simp add: tl_map)
apply (rule corres_rel_imp, rule Cons.hyps, simp_all)[1]
apply (wp valid_case_option_post_wp hoare_vcg_const_Ball_lift
hoare_vcg_const_Ball_lift cap_insert_weak_cte_wp_at)
apply (wp hoare_vcg_const_Ball_lift | simp add:split_def del: imp_disj1)+
apply (wp cap_insert_cte_wp_at)
apply (wp valid_case_option_post_wp hoare_vcg_const_Ball_lift
cteInsert_valid_pspace
| simp add: split_def)+
apply (wp cteInsert_weak_cte_wp_at hoare_valid_ipc_buffer_ptr_typ_at')+
apply (wpsimp wp: hoare_vcg_const_Ball_lift cteInsert_cte_wp_at valid_case_option_post_wp
simp: split_def)
apply (unfold whenE_def)
apply wp+
apply (clarsimp simp: conj_comms ball_conj_distrib split del: if_split)
apply (rule_tac Q' ="\<lambda>cap' s. (cap'\<noteq> cap.NullCap \<longrightarrow>
cte_wp_at (is_derived (cdt s) (a, b) cap') (a, b) s
\<and> QM s cap')" for QM
in hoare_post_imp_R)
prefer 2
apply clarsimp
apply assumption
apply (subst imp_conjR)
apply (rule hoare_vcg_conj_liftE_R)
apply (rule derive_cap_is_derived)
apply (wp derive_cap_is_derived_foo)+
apply (simp split del: if_split)
apply (rule_tac Q' ="\<lambda>cap' s. (cap'\<noteq> capability.NullCap \<longrightarrow>
cte_wp_at' (\<lambda>c. is_derived' (ctes_of s) (cte_map (a, b)) cap' (cteCap c)) (cte_map (a, b)) s
\<and> QM s cap')" for QM
in hoare_post_imp_R)
prefer 2
apply clarsimp
apply assumption
apply (subst imp_conjR)
apply (rule hoare_vcg_conj_liftE_R)
apply (rule hoare_post_imp_R[OF deriveCap_derived])
apply (clarsimp simp:cte_wp_at_ctes_of)
apply (wp deriveCap_derived_foo)
apply (clarsimp simp: cte_wp_at_caps_of_state remove_rights_def
real_cte_tcb_valid if_apply_def2
split del: if_split)
apply (rule conjI, (clarsimp split del: if_split)+)
apply (clarsimp simp:conj_comms split del:if_split)
apply (intro conjI allI)
apply (clarsimp split:if_splits)
apply (case_tac "cap = fst x",simp+)
apply (clarsimp simp:masked_as_full_def is_cap_simps cap_master_cap_simps)
apply (clarsimp split del: if_split)
apply (intro conjI)
apply (clarsimp simp:neq_Nil_conv)
apply (drule hd_in_set)
apply (drule(1) bspec)
apply (clarsimp split:if_split_asm)
apply (fastforce simp:neq_Nil_conv)
apply (intro ballI conjI)
apply (clarsimp simp:neq_Nil_conv)
apply (intro impI)
apply (drule(1) bspec[OF _ subsetD[rotated]])
apply (clarsimp simp:neq_Nil_conv)
apply (clarsimp split:if_splits)
apply clarsimp
apply (intro conjI)
apply (drule(1) bspec,clarsimp)+
subgoal for \<dots> aa _ _ capa
by (case_tac "capa = aa"; clarsimp split:if_splits simp:masked_as_full_def is_cap_simps)
apply (case_tac "isEndpointCap (fst y) \<and> capEPPtr (fst y) = the ep \<and> (\<exists>y. ep = Some y)")
apply (clarsimp simp:conj_comms split del:if_split)
apply (subst if_not_P)
apply clarsimp
apply (clarsimp simp:valid_pspace'_def cte_wp_at_ctes_of split del:if_split)
apply (intro conjI)
apply (case_tac "cteCap cte = fst y",clarsimp simp: badge_derived'_def)
apply (clarsimp simp: maskCapRights_eq_null maskedAsFull_def badge_derived'_def isCap_simps
split: if_split_asm)
apply (clarsimp split del: if_split)
apply (case_tac "fst y = capability.NullCap")
apply (clarsimp simp: neq_Nil_conv split del: if_split)+
apply (intro allI impI conjI)
apply (clarsimp split:if_splits)
apply (clarsimp simp:image_def)+
apply (thin_tac "\<forall>x\<in>set ys. Q x" for Q)
apply (drule(1) bspec)+
apply clarsimp+
apply (drule(1) bspec)
apply (rule conjI)
apply clarsimp+
apply (case_tac "cteCap cteb = ab")
by (clarsimp simp: isCap_simps maskedAsFull_def split:if_splits)+
qed
declare constOnFailure_wp [wp]
lemma transferCapsToSlots_pres1[crunch_rules]:
assumes x: "\<And>cap src dest. \<lbrace>P\<rbrace> cteInsert cap src dest \<lbrace>\<lambda>rv. P\<rbrace>"
assumes eb: "\<And>b n. \<lbrace>P\<rbrace> setExtraBadge buffer b n \<lbrace>\<lambda>_. P\<rbrace>"
shows "\<lbrace>P\<rbrace> transferCapsToSlots ep buffer n caps slots mi \<lbrace>\<lambda>rv. P\<rbrace>"
apply (induct caps arbitrary: slots n mi)
apply simp
apply (simp add: Let_def split_def whenE_def
cong: if_cong list.case_cong
split del: if_split)
apply (rule hoare_pre)
apply (wp x eb | assumption | simp split del: if_split | wpc
| wp (once) hoare_drop_imps)+
done
lemma cteInsert_cte_cap_to':
"\<lbrace>ex_cte_cap_to' p and cte_wp_at' (\<lambda>cte. cteCap cte = NullCap) dest\<rbrace>
cteInsert cap src dest
\<lbrace>\<lambda>rv. ex_cte_cap_to' p\<rbrace>"
apply (simp add: ex_cte_cap_to'_def)
apply (rule hoare_pre)
apply (rule hoare_use_eq_irq_node' [OF cteInsert_ksInterruptState])
apply (clarsimp simp:cteInsert_def)
apply (wp hoare_vcg_ex_lift updateMDB_weak_cte_wp_at updateCap_cte_wp_at_cases
setUntypedCapAsFull_cte_wp_at getCTE_wp static_imp_wp)
apply (clarsimp simp:cte_wp_at_ctes_of)
apply (rule_tac x = "cref" in exI)
apply (rule conjI)
apply clarsimp+
done
declare maskCapRights_eq_null[simp]
crunch ex_cte_cap_wp_to' [wp]: setExtraBadge "ex_cte_cap_wp_to' P p"
(rule: ex_cte_cap_to'_pres)
crunch valid_objs' [wp]: setExtraBadge valid_objs'
crunch aligned' [wp]: setExtraBadge pspace_aligned'
crunch distinct' [wp]: setExtraBadge pspace_distinct'
lemma cteInsert_assume_Null:
"\<lbrace>P\<rbrace> cteInsert cap src dest \<lbrace>Q\<rbrace> \<Longrightarrow>
\<lbrace>\<lambda>s. cte_wp_at' (\<lambda>cte. cteCap cte = NullCap) dest s \<longrightarrow> P s\<rbrace>
cteInsert cap src dest
\<lbrace>Q\<rbrace>"
apply (rule hoare_name_pre_state)
apply (erule impCE)
apply (simp add: cteInsert_def)
apply (rule hoare_seq_ext[OF _ getCTE_sp])+
apply (rule hoare_name_pre_state)
apply (clarsimp simp: cte_wp_at_ctes_of)
apply (erule hoare_pre(1))
apply simp
done
crunch mdb'[wp]: setExtraBadge valid_mdb'
lemma cteInsert_weak_cte_wp_at2:
assumes weak:"\<And>c cap. P (maskedAsFull c cap) = P c"
shows
"\<lbrace>\<lambda>s. if p = dest then P cap else cte_wp_at' (\<lambda>c. P (cteCap c)) p s\<rbrace>
cteInsert cap src dest
\<lbrace>\<lambda>uu. cte_wp_at' (\<lambda>c. P (cteCap c)) p\<rbrace>"
apply (rule hoare_pre)
apply (rule hoare_use_eq_irq_node' [OF cteInsert_ksInterruptState])
apply (clarsimp simp:cteInsert_def)
apply (wp hoare_vcg_ex_lift updateMDB_weak_cte_wp_at updateCap_cte_wp_at_cases
setUntypedCapAsFull_cte_wp_at getCTE_wp static_imp_wp)
apply (clarsimp simp:cte_wp_at_ctes_of weak)
apply auto
done
lemma transferCapsToSlots_presM:
assumes x: "\<And>cap src dest. \<lbrace>\<lambda>s. P s \<and> (emx \<longrightarrow> cte_wp_at' (\<lambda>cte. cteCap cte = NullCap) dest s \<and> ex_cte_cap_to' dest s)
\<and> (vo \<longrightarrow> valid_objs' s \<and> valid_cap' cap s \<and> real_cte_at' dest s)
\<and> (drv \<longrightarrow> cte_wp_at' (is_derived' (ctes_of s) src cap \<circ> cteCap) src s
\<and> cte_wp_at' (untyped_derived_eq cap o cteCap) src s
\<and> valid_mdb' s)
\<and> (pad \<longrightarrow> pspace_aligned' s \<and> pspace_distinct' s)\<rbrace>
cteInsert cap src dest \<lbrace>\<lambda>rv. P\<rbrace>"
assumes eb: "\<And>b n. \<lbrace>P\<rbrace> setExtraBadge buffer b n \<lbrace>\<lambda>_. P\<rbrace>"
shows "\<lbrace>\<lambda>s. P s
\<and> (emx \<longrightarrow> (\<forall>x \<in> set slots. ex_cte_cap_to' x s \<and> cte_wp_at' (\<lambda>cte. cteCap cte = NullCap) x s) \<and> distinct slots)
\<and> (vo \<longrightarrow> valid_objs' s \<and> (\<forall>x \<in> set slots. real_cte_at' x s \<and> cte_wp_at' (\<lambda>cte. cteCap cte = NullCap) x s)
\<and> (\<forall>x \<in> set caps. s \<turnstile>' fst x ) \<and> distinct slots)
\<and> (pad \<longrightarrow> pspace_aligned' s \<and> pspace_distinct' s)
\<and> (drv \<longrightarrow> vo \<and> pspace_aligned' s \<and> pspace_distinct' s \<and> valid_mdb' s
\<and> length slots \<le> 1
\<and> (\<forall>x \<in> set caps. s \<turnstile>' fst x \<and> (slots \<noteq> []
\<longrightarrow> cte_wp_at' (\<lambda>cte. fst x \<noteq> NullCap \<longrightarrow> cteCap cte = fst x) (snd x) s)))\<rbrace>
transferCapsToSlots ep buffer n caps slots mi
\<lbrace>\<lambda>rv. P\<rbrace>"
apply (induct caps arbitrary: slots n mi)
apply (simp, wp, simp)
apply (simp add: Let_def split_def whenE_def
cong: if_cong list.case_cong split del: if_split)
apply (rule hoare_pre)
apply (wp eb hoare_vcg_const_Ball_lift hoare_vcg_const_imp_lift
| assumption | wpc)+
apply (rule cteInsert_assume_Null)
apply (wp x hoare_vcg_const_Ball_lift cteInsert_cte_cap_to' static_imp_wp)
apply (rule cteInsert_weak_cte_wp_at2,clarsimp)
apply (wp hoare_vcg_const_Ball_lift static_imp_wp)+
apply (rule cteInsert_weak_cte_wp_at2,clarsimp)
apply (wp hoare_vcg_const_Ball_lift cteInsert_cte_wp_at static_imp_wp
deriveCap_derived_foo)+
apply (thin_tac "\<And>slots. PROP P slots" for P)
apply (clarsimp simp: cte_wp_at_ctes_of remove_rights_def
real_cte_tcb_valid if_apply_def2
split del: if_split)
apply (rule conjI)
apply (clarsimp simp:cte_wp_at_ctes_of untyped_derived_eq_def)
apply (intro conjI allI)
apply (clarsimp simp:Fun.comp_def cte_wp_at_ctes_of)+
apply (clarsimp simp:valid_capAligned)
done
lemmas transferCapsToSlots_pres2
= transferCapsToSlots_presM[where vo=False and emx=True
and drv=False and pad=False, simplified]
lemma transferCapsToSlots_aligned'[wp]:
"\<lbrace>pspace_aligned'\<rbrace>
transferCapsToSlots ep buffer n caps slots mi
\<lbrace>\<lambda>rv. pspace_aligned'\<rbrace>"
by (wp transferCapsToSlots_pres1)
lemma transferCapsToSlots_distinct'[wp]:
"\<lbrace>pspace_distinct'\<rbrace>
transferCapsToSlots ep buffer n caps slots mi
\<lbrace>\<lambda>rv. pspace_distinct'\<rbrace>"
by (wp transferCapsToSlots_pres1)
lemma transferCapsToSlots_typ_at'[wp]:
"\<lbrace>\<lambda>s. P (typ_at' T p s)\<rbrace>
transferCapsToSlots ep buffer n caps slots mi
\<lbrace>\<lambda>rv s. P (typ_at' T p s)\<rbrace>"
by (wp transferCapsToSlots_pres1 setExtraBadge_typ_at')
lemma transferCapsToSlots_valid_objs[wp]:
"\<lbrace>valid_objs' and valid_mdb' and (\<lambda>s. \<forall>x \<in> set slots. real_cte_at' x s \<and> cte_wp_at' (\<lambda>cte. cteCap cte = capability.NullCap) x s)
and (\<lambda>s. \<forall>x \<in> set caps. s \<turnstile>' fst x) and K(distinct slots)\<rbrace>
transferCapsToSlots ep buffer n caps slots mi
\<lbrace>\<lambda>rv. valid_objs'\<rbrace>"
apply (rule hoare_pre)
apply (rule transferCapsToSlots_presM[where vo=True and emx=False and drv=False and pad=False])
apply (wp | simp)+
done
abbreviation(input)
"transferCaps_srcs caps s \<equiv> \<forall>x\<in>set caps. cte_wp_at' (\<lambda>cte. fst x \<noteq> NullCap \<longrightarrow> cteCap cte = fst x) (snd x) s"
lemma transferCapsToSlots_mdb[wp]:
"\<lbrace>\<lambda>s. valid_pspace' s \<and> distinct slots
\<and> length slots \<le> 1
\<and> (\<forall>x \<in> set slots. ex_cte_cap_to' x s \<and> cte_wp_at' (\<lambda>cte. cteCap cte = capability.NullCap) x s)
\<and> (\<forall>x \<in> set slots. real_cte_at' x s)
\<and> transferCaps_srcs caps s\<rbrace>
transferCapsToSlots ep buffer n caps slots mi
\<lbrace>\<lambda>rv. valid_mdb'\<rbrace>"
apply (wp transferCapsToSlots_presM[where drv=True and vo=True and emx=True and pad=True])
apply clarsimp
apply (frule valid_capAligned)
apply (clarsimp simp: cte_wp_at_ctes_of is_derived'_def badge_derived'_def)
apply wp
apply (clarsimp simp: valid_pspace'_def)
apply (clarsimp simp:cte_wp_at_ctes_of)
apply (drule(1) bspec,clarify)
apply (case_tac cte)
apply (clarsimp dest!:ctes_of_valid_cap' split:if_splits)
apply (fastforce simp:valid_cap'_def)
done
crunch no_0' [wp]: setExtraBadge no_0_obj'
lemma transferCapsToSlots_no_0_obj' [wp]:
"\<lbrace>no_0_obj'\<rbrace> transferCapsToSlots ep buffer n caps slots mi \<lbrace>\<lambda>rv. no_0_obj'\<rbrace>"
by (wp transferCapsToSlots_pres1)
lemma transferCapsToSlots_vp[wp]:
"\<lbrace>\<lambda>s. valid_pspace' s \<and> distinct slots
\<and> length slots \<le> 1
\<and> (\<forall>x \<in> set slots. ex_cte_cap_to' x s \<and> cte_wp_at' (\<lambda>cte. cteCap cte = capability.NullCap) x s)
\<and> (\<forall>x \<in> set slots. real_cte_at' x s)
\<and> transferCaps_srcs caps s\<rbrace>
transferCapsToSlots ep buffer n caps slots mi
\<lbrace>\<lambda>rv. valid_pspace'\<rbrace>"
apply (rule hoare_pre)
apply (simp add: valid_pspace'_def | wp)+
apply (fastforce simp: cte_wp_at_ctes_of dest: ctes_of_valid')
done
crunches setExtraBadge, doIPCTransfer
for sch_act [wp]: "\<lambda>s. P (ksSchedulerAction s)"
(wp: crunch_wps mapME_wp' simp: zipWithM_x_mapM)
crunches setExtraBadge
for pred_tcb_at' [wp]: "\<lambda>s. pred_tcb_at' proj P p s"
and ksCurThread[wp]: "\<lambda>s. P (ksCurThread s)"
and ksCurDomain[wp]: "\<lambda>s. P (ksCurDomain s)"
and obj_at' [wp]: "\<lambda>s. P' (obj_at' P p s)"
and queues [wp]: "\<lambda>s. P (ksReadyQueues s)"
and queuesL1 [wp]: "\<lambda>s. P (ksReadyQueuesL1Bitmap s)"
and queuesL2 [wp]: "\<lambda>s. P (ksReadyQueuesL2Bitmap s)"
lemma tcts_sch_act[wp]:
"\<lbrace>\<lambda>s. sch_act_wf (ksSchedulerAction s) s\<rbrace>
transferCapsToSlots ep buffer n caps slots mi
\<lbrace>\<lambda>rv s. sch_act_wf (ksSchedulerAction s) s\<rbrace>"
by (wp sch_act_wf_lift tcb_in_cur_domain'_lift transferCapsToSlots_pres1)
lemma tcts_vq[wp]:
"\<lbrace>Invariants_H.valid_queues\<rbrace> transferCapsToSlots ep buffer n caps slots mi \<lbrace>\<lambda>rv. Invariants_H.valid_queues\<rbrace>"
by (wp valid_queues_lift transferCapsToSlots_pres1)
lemma tcts_vq'[wp]:
"\<lbrace>valid_queues'\<rbrace> transferCapsToSlots ep buffer n caps slots mi \<lbrace>\<lambda>rv. valid_queues'\<rbrace>"
by (wp valid_queues_lift' transferCapsToSlots_pres1)
crunch state_refs_of' [wp]: setExtraBadge "\<lambda>s. P (state_refs_of' s)"
lemma tcts_state_refs_of'[wp]:
"\<lbrace>\<lambda>s. P (state_refs_of' s)\<rbrace>
transferCapsToSlots ep buffer n caps slots mi
\<lbrace>\<lambda>rv s. P (state_refs_of' s)\<rbrace>"
by (wp transferCapsToSlots_pres1)
crunch if_live' [wp]: setExtraBadge if_live_then_nonz_cap'
lemma tcts_iflive[wp]:
"\<lbrace>\<lambda>s. if_live_then_nonz_cap' s \<and> distinct slots \<and>
(\<forall>x\<in>set slots.
ex_cte_cap_to' x s \<and> cte_wp_at' (\<lambda>cte. cteCap cte = capability.NullCap) x s)\<rbrace>
transferCapsToSlots ep buffer n caps slots mi
\<lbrace>\<lambda>rv. if_live_then_nonz_cap'\<rbrace>"
by (wp transferCapsToSlots_pres2 | simp)+
crunch if_unsafe' [wp]: setExtraBadge if_unsafe_then_cap'
lemma tcts_ifunsafe[wp]:
"\<lbrace>\<lambda>s. if_unsafe_then_cap' s \<and> distinct slots \<and>
(\<forall>x\<in>set slots. cte_wp_at' (\<lambda>cte. cteCap cte = capability.NullCap) x s \<and>
ex_cte_cap_to' x s)\<rbrace> transferCapsToSlots ep buffer n caps slots mi
\<lbrace>\<lambda>rv. if_unsafe_then_cap'\<rbrace>"
by (wp transferCapsToSlots_pres2 | simp)+
crunch it[wp]: ensureNoChildren "\<lambda>s. P (ksIdleThread s)"
crunch idle'[wp]: deriveCap "valid_idle'"
crunch valid_idle' [wp]: setExtraBadge valid_idle'
lemma tcts_idle'[wp]:
"\<lbrace>\<lambda>s. valid_idle' s\<rbrace> transferCapsToSlots ep buffer n caps slots mi
\<lbrace>\<lambda>rv. valid_idle'\<rbrace>"
apply (rule hoare_pre)
apply (wp transferCapsToSlots_pres1)
apply simp
done
lemma tcts_ct[wp]:
"\<lbrace>cur_tcb'\<rbrace> transferCapsToSlots ep buffer n caps slots mi \<lbrace>\<lambda>rv. cur_tcb'\<rbrace>"
by (wp transferCapsToSlots_pres1 cur_tcb_lift)
crunch valid_arch_state' [wp]: setExtraBadge valid_arch_state'
lemma transferCapsToSlots_valid_arch [wp]:
"\<lbrace>valid_arch_state'\<rbrace> transferCapsToSlots ep buffer n caps slots mi \<lbrace>\<lambda>rv. valid_arch_state'\<rbrace>"
by (rule transferCapsToSlots_pres1; wp)
crunch valid_global_refs' [wp]: setExtraBadge valid_global_refs'
lemma transferCapsToSlots_valid_globals [wp]:
"\<lbrace>valid_global_refs' and valid_objs' and valid_mdb' and pspace_distinct' and pspace_aligned' and K (distinct slots)
and K (length slots \<le> 1)
and (\<lambda>s. \<forall>x \<in> set slots. real_cte_at' x s \<and> cte_wp_at' (\<lambda>cte. cteCap cte = capability.NullCap) x s)
and transferCaps_srcs caps\<rbrace>
transferCapsToSlots ep buffer n caps slots mi
\<lbrace>\<lambda>rv. valid_global_refs'\<rbrace>"
apply (wp transferCapsToSlots_presM[where vo=True and emx=False and drv=True and pad=True] | clarsimp)+
apply (clarsimp simp:cte_wp_at_ctes_of)
apply (drule(1) bspec,clarsimp)
apply (case_tac cte,clarsimp)
apply (frule(1) CSpace_I.ctes_of_valid_cap')
apply (fastforce simp:valid_cap'_def)
done
crunch irq_node' [wp]: setExtraBadge "\<lambda>s. P (irq_node' s)"
lemma transferCapsToSlots_irq_node'[wp]:
"\<lbrace>\<lambda>s. P (irq_node' s)\<rbrace> transferCapsToSlots ep buffer n caps slots mi \<lbrace>\<lambda>rv s. P (irq_node' s)\<rbrace>"
by (wp transferCapsToSlots_pres1)
lemma valid_irq_handlers_ctes_ofD:
"\<lbrakk> ctes_of s p = Some cte; cteCap cte = IRQHandlerCap irq; valid_irq_handlers' s \<rbrakk>
\<Longrightarrow> irq_issued' irq s"
by (auto simp: valid_irq_handlers'_def cteCaps_of_def ran_def)
crunch valid_irq_handlers' [wp]: setExtraBadge valid_irq_handlers'
lemma transferCapsToSlots_irq_handlers[wp]:
"\<lbrace>valid_irq_handlers' and valid_objs' and valid_mdb' and pspace_distinct' and pspace_aligned'
and K(distinct slots \<and> length slots \<le> 1)
and (\<lambda>s. \<forall>x \<in> set slots. real_cte_at' x s \<and> cte_wp_at' (\<lambda>cte. cteCap cte = capability.NullCap) x s)
and transferCaps_srcs caps\<rbrace>
transferCapsToSlots ep buffer n caps slots mi
\<lbrace>\<lambda>rv. valid_irq_handlers'\<rbrace>"
apply (wp transferCapsToSlots_presM[where vo=True and emx=False and drv=True and pad=False])
apply (clarsimp simp: is_derived'_def cte_wp_at_ctes_of badge_derived'_def)
apply (erule(2) valid_irq_handlers_ctes_ofD)
apply wp
apply (clarsimp simp:cte_wp_at_ctes_of | intro ballI conjI)+
apply (drule(1) bspec,clarsimp)
apply (case_tac cte,clarsimp)
apply (frule(1) CSpace_I.ctes_of_valid_cap')
apply (fastforce simp:valid_cap'_def)
done
crunch irq_state' [wp]: setExtraBadge "\<lambda>s. P (ksInterruptState s)"
lemma setExtraBadge_irq_states'[wp]:
"\<lbrace>valid_irq_states'\<rbrace> setExtraBadge buffer b n \<lbrace>\<lambda>_. valid_irq_states'\<rbrace>"
apply (wp valid_irq_states_lift')
apply (simp add: setExtraBadge_def storeWordUser_def)
apply (wpsimp wp: no_irq dmo_lift' no_irq_storeWord)
apply assumption
done
lemma transferCapsToSlots_irq_states' [wp]:
"\<lbrace>valid_irq_states'\<rbrace> transferCapsToSlots ep buffer n caps slots mi \<lbrace>\<lambda>_. valid_irq_states'\<rbrace>"
by (wp transferCapsToSlots_pres1)
crunch valid_pde_mappings' [wp]: setExtraBadge valid_pde_mappings'
lemma transferCapsToSlots_pde_mappings'[wp]:
"\<lbrace>valid_pde_mappings'\<rbrace> transferCapsToSlots ep buffer n caps slots mi \<lbrace>\<lambda>rv. valid_pde_mappings'\<rbrace>"
by (wp transferCapsToSlots_pres1)
lemma transferCapsToSlots_irqs_masked'[wp]:
"\<lbrace>irqs_masked'\<rbrace> transferCapsToSlots ep buffer n caps slots mi \<lbrace>\<lambda>rv. irqs_masked'\<rbrace>"
by (wp transferCapsToSlots_pres1 irqs_masked_lift)
lemma storeWordUser_vms'[wp]:
"\<lbrace>valid_machine_state'\<rbrace> storeWordUser a w \<lbrace>\<lambda>_. valid_machine_state'\<rbrace>"
proof -
have aligned_offset_ignore:
"\<And>(l::word32) (p::word32) sz. l<4 \<Longrightarrow> p && mask 2 = 0 \<Longrightarrow>
p+l && ~~ mask pageBits = p && ~~ mask pageBits"
proof -
fix l p sz
assume al: "(p::word32) && mask 2 = 0"
assume "(l::word32) < 4" hence less: "l<2^2" by simp
have le: "2 \<le> pageBits" by (simp add: pageBits_def)
show "?thesis l p sz"
by (rule is_aligned_add_helper[simplified is_aligned_mask,
THEN conjunct2, THEN mask_out_first_mask_some,
where n=2, OF al less le])
qed
show ?thesis
apply (simp add: valid_machine_state'_def storeWordUser_def
doMachineOp_def split_def)
apply wp
apply clarsimp
apply (drule use_valid)
apply (rule_tac x=p in storeWord_um_inv, simp+)
apply (drule_tac x=p in spec)
apply (erule disjE, simp_all)
apply (erule conjE)
apply (erule disjE, simp)
apply (simp add: pointerInUserData_def word_size)
apply (subgoal_tac "a && ~~ mask pageBits = p && ~~ mask pageBits", simp)
apply (simp only: is_aligned_mask[of _ 2])
apply (elim disjE, simp_all)
apply (rule aligned_offset_ignore[symmetric], simp+)+
done
qed
lemma setExtraBadge_vms'[wp]:
"\<lbrace>valid_machine_state'\<rbrace> setExtraBadge buffer b n \<lbrace>\<lambda>_. valid_machine_state'\<rbrace>"
by (simp add: setExtraBadge_def) wp
lemma transferCapsToSlots_vms[wp]:
"\<lbrace>\<lambda>s. valid_machine_state' s\<rbrace>
transferCapsToSlots ep buffer n caps slots mi
\<lbrace>\<lambda>_ s. valid_machine_state' s\<rbrace>"
by (wp transferCapsToSlots_pres1)
crunches setExtraBadge, transferCapsToSlots
for pspace_domain_valid[wp]: "pspace_domain_valid"
crunch ct_not_inQ[wp]: setExtraBadge "ct_not_inQ"
lemma tcts_ct_not_inQ[wp]:
"\<lbrace>ct_not_inQ\<rbrace>
transferCapsToSlots ep buffer n caps slots mi
\<lbrace>\<lambda>_. ct_not_inQ\<rbrace>"
by (wp transferCapsToSlots_pres1)
crunch gsUntypedZeroRanges[wp]: setExtraBadge "\<lambda>s. P (gsUntypedZeroRanges s)"
crunch ctes_of[wp]: setExtraBadge "\<lambda>s. P (ctes_of s)"
lemma tcts_zero_ranges[wp]:
"\<lbrace>\<lambda>s. untyped_ranges_zero' s \<and> valid_pspace' s \<and> distinct slots
\<and> (\<forall>x \<in> set slots. ex_cte_cap_to' x s \<and> cte_wp_at' (\<lambda>cte. cteCap cte = capability.NullCap) x s)
\<and> (\<forall>x \<in> set slots. real_cte_at' x s)
\<and> length slots \<le> 1
\<and> transferCaps_srcs caps s\<rbrace>
transferCapsToSlots ep buffer n caps slots mi
\<lbrace>\<lambda>rv. untyped_ranges_zero'\<rbrace>"
apply (wp transferCapsToSlots_presM[where emx=True and vo=True
and drv=True and pad=True])
apply (clarsimp simp: cte_wp_at_ctes_of)
apply (simp add: cteCaps_of_def)
apply (rule hoare_pre, wp untyped_ranges_zero_lift)
apply (simp add: o_def)
apply (clarsimp simp: valid_pspace'_def ball_conj_distrib[symmetric])
apply (drule(1) bspec)
apply (clarsimp simp: cte_wp_at_ctes_of)
apply (case_tac cte, clarsimp)
apply (frule(1) ctes_of_valid_cap')
apply auto[1]
done
crunch ct_idle_or_in_cur_domain'[wp]: setExtraBadge ct_idle_or_in_cur_domain'
crunch ct_idle_or_in_cur_domain'[wp]: transferCapsToSlots ct_idle_or_in_cur_domain'
crunch ksCurDomain[wp]: transferCapsToSlots "\<lambda>s. P (ksCurDomain s)"
crunch ksDomSchedule[wp]: setExtraBadge "\<lambda>s. P (ksDomSchedule s)"
crunch ksDomScheduleIdx[wp]: setExtraBadge "\<lambda>s. P (ksDomScheduleIdx s)"
crunch ksDomSchedule[wp]: transferCapsToSlots "\<lambda>s. P (ksDomSchedule s)"
crunch ksDomScheduleIdx[wp]: transferCapsToSlots "\<lambda>s. P (ksDomScheduleIdx s)"
lemma transferCapsToSlots_invs[wp]:
"\<lbrace>\<lambda>s. invs' s \<and> distinct slots
\<and> (\<forall>x \<in> set slots. cte_wp_at' (\<lambda>cte. cteCap cte = NullCap) x s)
\<and> (\<forall>x \<in> set slots. ex_cte_cap_to' x s)
\<and> (\<forall>x \<in> set slots. real_cte_at' x s)
\<and> length slots \<le> 1
\<and> transferCaps_srcs caps s\<rbrace>
transferCapsToSlots ep buffer n caps slots mi
\<lbrace>\<lambda>rv. invs'\<rbrace>"
apply (simp add: invs'_def valid_state'_def)
apply (wp valid_irq_node_lift)
apply fastforce
done
lemma grs_distinct'[wp]:
"\<lbrace>\<top>\<rbrace> getReceiveSlots t buf \<lbrace>\<lambda>rv s. distinct rv\<rbrace>"
apply (cases buf, simp_all add: getReceiveSlots_def
split_def unlessE_def)
apply (wp, simp)
apply (wp | simp only: distinct.simps list.simps empty_iff)+
apply simp
done
lemma transferCaps_corres:
"\<lbrakk> info' = message_info_map info;
list_all2 (\<lambda>x y. cap_relation (fst x) (fst y) \<and> snd y = cte_map (snd x))
caps caps' \<rbrakk>
\<Longrightarrow>
corres ((=) \<circ> message_info_map)
(tcb_at receiver and valid_objs and
pspace_aligned and pspace_distinct and valid_mdb
and valid_list
and (\<lambda>s. case ep of Some x \<Rightarrow> ep_at x s | _ \<Rightarrow> True)
and case_option \<top> in_user_frame recv_buf
and (\<lambda>s. valid_message_info info)
and transfer_caps_srcs caps)
(tcb_at' receiver and valid_objs' and
pspace_aligned' and pspace_distinct' and no_0_obj' and valid_mdb'
and (\<lambda>s. case ep of Some x \<Rightarrow> ep_at' x s | _ \<Rightarrow> True)
and case_option \<top> valid_ipc_buffer_ptr' recv_buf
and transferCaps_srcs caps'
and (\<lambda>s. length caps' \<le> msgMaxExtraCaps))
(transfer_caps info caps ep receiver recv_buf)
(transferCaps info' caps' ep receiver recv_buf)"
apply (simp add: transfer_caps_def transferCaps_def
getThreadCSpaceRoot)
apply (rule corres_assume_pre)
apply (rule corres_guard_imp)
apply (rule corres_split[OF getReceiveSlots_corres])
apply (rule_tac x=recv_buf in option_corres)
apply (rule_tac P=\<top> and P'=\<top> in corres_inst)
apply (case_tac info, simp)
apply simp
apply (rule corres_rel_imp, rule transferCapsToSlots_corres,
simp_all add: split_def)[1]
apply (case_tac info, simp)
apply (wp hoare_vcg_all_lift get_rs_cte_at static_imp_wp
| simp only: ball_conj_distrib)+
apply (simp add: cte_map_def tcb_cnode_index_def split_def)
apply (clarsimp simp: valid_pspace'_def valid_ipc_buffer_ptr'_def2
split_def
cong: option.case_cong)
apply (drule(1) bspec)
apply (clarsimp simp:cte_wp_at_caps_of_state)
apply (frule(1) Invariants_AI.caps_of_state_valid)
apply (fastforce simp:valid_cap_def)
apply (cases info)
apply (clarsimp simp: msg_max_extra_caps_def valid_message_info_def
max_ipc_words msg_max_length_def
msgMaxExtraCaps_def msgExtraCapBits_def
shiftL_nat valid_pspace'_def)
apply (drule(1) bspec)
apply (clarsimp simp:cte_wp_at_ctes_of)
apply (case_tac cte,clarsimp)
apply (frule(1) ctes_of_valid_cap')
apply (fastforce simp:valid_cap'_def)
done
crunch typ_at'[wp]: transferCaps "\<lambda>s. P (typ_at' T p s)"
lemmas transferCaps_typ_ats[wp] = typ_at_lifts [OF transferCaps_typ_at']
lemma isIRQControlCap_mask [simp]:
"isIRQControlCap (maskCapRights R c) = isIRQControlCap c"
apply (case_tac c)
apply (clarsimp simp: isCap_simps maskCapRights_def Let_def)+
apply (rename_tac arch_capability)
apply (case_tac arch_capability)
apply (clarsimp simp: isCap_simps ARM_H.maskCapRights_def
maskCapRights_def Let_def)+
done
lemma isPageCap_maskCapRights[simp]:
" isArchCap isPageCap (RetypeDecls_H.maskCapRights R c) = isArchCap isPageCap c"
apply (case_tac c; simp add: isCap_simps isArchCap_def maskCapRights_def)
apply (rename_tac arch_capability)
apply (case_tac arch_capability; simp add: isCap_simps ARM_H.maskCapRights_def)
done
lemma capReplyMaster_mask[simp]:
"isReplyCap c \<Longrightarrow> capReplyMaster (maskCapRights R c) = capReplyMaster c"
by (clarsimp simp: isCap_simps maskCapRights_def)
lemma is_derived_mask' [simp]:
"is_derived' m p (maskCapRights R c) = is_derived' m p c"
apply (rule ext)
apply (simp add: is_derived'_def badge_derived'_def)
done
lemma updateCapData_ordering:
"\<lbrakk> (x, capBadge cap) \<in> capBadge_ordering P; updateCapData p d cap \<noteq> NullCap \<rbrakk>
\<Longrightarrow> (x, capBadge (updateCapData p d cap)) \<in> capBadge_ordering P"
apply (cases cap, simp_all add: updateCapData_def isCap_simps Let_def
capBadge_def ARM_H.updateCapData_def
split: if_split_asm)
apply fastforce+
done
lemma lookup_cap_to'[wp]:
"\<lbrace>\<top>\<rbrace> lookupCap t cref \<lbrace>\<lambda>rv s. \<forall>r\<in>cte_refs' rv (irq_node' s). ex_cte_cap_to' r s\<rbrace>,-"
by (simp add: lookupCap_def lookupCapAndSlot_def | wp)+
lemma grs_cap_to'[wp]:
"\<lbrace>\<top>\<rbrace> getReceiveSlots t buf \<lbrace>\<lambda>rv s. \<forall>x \<in> set rv. ex_cte_cap_to' x s\<rbrace>"
apply (cases buf; simp add: getReceiveSlots_def split_def unlessE_def)
apply (wp, simp)
apply (wp | simp | rule hoare_drop_imps)+
done
lemma grs_length'[wp]:
"\<lbrace>\<lambda>s. 1 \<le> n\<rbrace> getReceiveSlots receiver recv_buf \<lbrace>\<lambda>rv s. length rv \<le> n\<rbrace>"
apply (simp add: getReceiveSlots_def split_def unlessE_def)
apply (rule hoare_pre)
apply (wp | wpc | simp)+
done
lemma transferCaps_invs' [wp]:
"\<lbrace>invs' and transferCaps_srcs caps\<rbrace>
transferCaps mi caps ep receiver recv_buf
\<lbrace>\<lambda>rv. invs'\<rbrace>"
apply (simp add: transferCaps_def Let_def split_def)
apply (wp get_rs_cte_at' hoare_vcg_const_Ball_lift
| wpcw | clarsimp)+
done
lemma get_mrs_inv'[wp]:
"\<lbrace>P\<rbrace> getMRs t buf info \<lbrace>\<lambda>rv. P\<rbrace>"
by (simp add: getMRs_def load_word_offs_def getRegister_def
| wp dmo_inv' loadWord_inv mapM_wp'
asUser_inv det_mapM[where S=UNIV] | wpc)+
lemma copyMRs_typ_at':
"\<lbrace>\<lambda>s. P (typ_at' T p s)\<rbrace> copyMRs s sb r rb n \<lbrace>\<lambda>rv s. P (typ_at' T p s)\<rbrace>"
by (simp add: copyMRs_def | wp mapM_wp [where S=UNIV, simplified] | wpc)+
lemmas copyMRs_typ_at_lifts[wp] = typ_at_lifts [OF copyMRs_typ_at']
lemma copy_mrs_invs'[wp]:
"\<lbrace> invs' and tcb_at' s and tcb_at' r \<rbrace> copyMRs s sb r rb n \<lbrace>\<lambda>rv. invs' \<rbrace>"
including no_pre
apply (simp add: copyMRs_def)
apply (wp dmo_invs' no_irq_mapM no_irq_storeWord|
simp add: split_def)
apply (case_tac sb, simp_all)[1]
apply wp+
apply (case_tac rb, simp_all)[1]
apply (wp mapM_wp dmo_invs' no_irq_mapM no_irq_storeWord no_irq_loadWord)
apply blast
apply (rule hoare_strengthen_post)
apply (rule mapM_wp)
apply (wp | simp | blast)+
done
crunch aligned'[wp]: transferCaps pspace_aligned'
(wp: crunch_wps simp: zipWithM_x_mapM)
crunch distinct'[wp]: transferCaps pspace_distinct'
(wp: crunch_wps simp: zipWithM_x_mapM)
crunch aligned'[wp]: setMRs pspace_aligned'
(wp: crunch_wps simp: crunch_simps)
crunch distinct'[wp]: setMRs pspace_distinct'
(wp: crunch_wps simp: crunch_simps)
crunch aligned'[wp]: copyMRs pspace_aligned'
(wp: crunch_wps simp: crunch_simps wp: crunch_wps)
crunch distinct'[wp]: copyMRs pspace_distinct'
(wp: crunch_wps simp: crunch_simps wp: crunch_wps)
crunch aligned'[wp]: setMessageInfo pspace_aligned'
(wp: crunch_wps simp: crunch_simps)
crunch distinct'[wp]: setMessageInfo pspace_distinct'
(wp: crunch_wps simp: crunch_simps)
crunch valid_objs'[wp]: storeWordUser valid_objs'
crunch valid_pspace'[wp]: storeWordUser valid_pspace'
lemma set_mrs_valid_objs' [wp]:
"\<lbrace>valid_objs'\<rbrace> setMRs t a msgs \<lbrace>\<lambda>rv. valid_objs'\<rbrace>"
apply (simp add: setMRs_def zipWithM_x_mapM split_def)
apply (wp asUser_valid_objs crunch_wps)
done
crunch valid_objs'[wp]: copyMRs valid_objs'
(wp: crunch_wps simp: crunch_simps)
crunch valid_queues'[wp]: asUser "Invariants_H.valid_queues'"
(simp: crunch_simps wp: hoare_drop_imps)
lemma setMRs_invs_bits[wp]:
"\<lbrace>valid_pspace'\<rbrace> setMRs t buf mrs \<lbrace>\<lambda>rv. valid_pspace'\<rbrace>"
"\<lbrace>\<lambda>s. sch_act_wf (ksSchedulerAction s) s\<rbrace>
setMRs t buf mrs \<lbrace>\<lambda>rv s. sch_act_wf (ksSchedulerAction s) s\<rbrace>"
"\<lbrace>\<lambda>s. weak_sch_act_wf (ksSchedulerAction s) s\<rbrace>
setMRs t buf mrs \<lbrace>\<lambda>rv s. weak_sch_act_wf (ksSchedulerAction s) s\<rbrace>"
"\<lbrace>Invariants_H.valid_queues\<rbrace> setMRs t buf mrs \<lbrace>\<lambda>rv. Invariants_H.valid_queues\<rbrace>"
"\<lbrace>valid_queues'\<rbrace> setMRs t buf mrs \<lbrace>\<lambda>rv. valid_queues'\<rbrace>"
"\<lbrace>\<lambda>s. P (state_refs_of' s)\<rbrace>
setMRs t buf mrs
\<lbrace>\<lambda>rv s. P (state_refs_of' s)\<rbrace>"
"\<lbrace>if_live_then_nonz_cap'\<rbrace> setMRs t buf mrs \<lbrace>\<lambda>rv. if_live_then_nonz_cap'\<rbrace>"
"\<lbrace>ex_nonz_cap_to' p\<rbrace> setMRs t buf mrs \<lbrace>\<lambda>rv. ex_nonz_cap_to' p\<rbrace>"
"\<lbrace>cur_tcb'\<rbrace> setMRs t buf mrs \<lbrace>\<lambda>rv. cur_tcb'\<rbrace>"
"\<lbrace>if_unsafe_then_cap'\<rbrace> setMRs t buf mrs \<lbrace>\<lambda>rv. if_unsafe_then_cap'\<rbrace>"
by (simp add: setMRs_def zipWithM_x_mapM split_def storeWordUser_def | wp crunch_wps)+
crunch no_0_obj'[wp]: setMRs no_0_obj'
(wp: crunch_wps simp: crunch_simps)
lemma copyMRs_invs_bits[wp]:
"\<lbrace>valid_pspace'\<rbrace> copyMRs s sb r rb n \<lbrace>\<lambda>rv. valid_pspace'\<rbrace>"
"\<lbrace>\<lambda>s. sch_act_wf (ksSchedulerAction s) s\<rbrace> copyMRs s sb r rb n
\<lbrace>\<lambda>rv s. sch_act_wf (ksSchedulerAction s) s\<rbrace>"
"\<lbrace>Invariants_H.valid_queues\<rbrace> copyMRs s sb r rb n \<lbrace>\<lambda>rv. Invariants_H.valid_queues\<rbrace>"
"\<lbrace>valid_queues'\<rbrace> copyMRs s sb r rb n \<lbrace>\<lambda>rv. valid_queues'\<rbrace>"
"\<lbrace>\<lambda>s. P (state_refs_of' s)\<rbrace>
copyMRs s sb r rb n
\<lbrace>\<lambda>rv s. P (state_refs_of' s)\<rbrace>"
"\<lbrace>if_live_then_nonz_cap'\<rbrace> copyMRs s sb r rb n \<lbrace>\<lambda>rv. if_live_then_nonz_cap'\<rbrace>"
"\<lbrace>ex_nonz_cap_to' p\<rbrace> copyMRs s sb r rb n \<lbrace>\<lambda>rv. ex_nonz_cap_to' p\<rbrace>"
"\<lbrace>cur_tcb'\<rbrace> copyMRs s sb r rb n \<lbrace>\<lambda>rv. cur_tcb'\<rbrace>"
"\<lbrace>if_unsafe_then_cap'\<rbrace> copyMRs s sb r rb n \<lbrace>\<lambda>rv. if_unsafe_then_cap'\<rbrace>"
by (simp add: copyMRs_def storeWordUser_def | wp mapM_wp' | wpc)+
crunch no_0_obj'[wp]: copyMRs no_0_obj'
(wp: crunch_wps simp: crunch_simps)
lemma mi_map_length[simp]: "msgLength (message_info_map mi) = mi_length mi"
by (cases mi, simp)
crunch cte_wp_at'[wp]: copyMRs "cte_wp_at' P p"
(wp: crunch_wps)
lemma lookupExtraCaps_srcs[wp]:
"\<lbrace>\<top>\<rbrace> lookupExtraCaps thread buf info \<lbrace>transferCaps_srcs\<rbrace>,-"
apply (simp add: lookupExtraCaps_def lookupCapAndSlot_def
split_def lookupSlotForThread_def
getSlotCap_def)
apply (wp mapME_set[where R=\<top>] getCTE_wp')
apply (rule_tac P=\<top> in hoare_trivE_R)
apply (simp add: cte_wp_at_ctes_of)
apply (wp | simp)+
done
crunch inv[wp]: lookupExtraCaps "P"
(wp: crunch_wps mapME_wp' simp: crunch_simps)
lemma invs_mdb_strengthen':
"invs' s \<longrightarrow> valid_mdb' s" by auto
lemma lookupExtraCaps_length:
"\<lbrace>\<lambda>s. unat (msgExtraCaps mi) \<le> n\<rbrace> lookupExtraCaps thread send_buf mi \<lbrace>\<lambda>rv s. length rv \<le> n\<rbrace>,-"
apply (simp add: lookupExtraCaps_def getExtraCPtrs_def)
apply (rule hoare_pre)
apply (wp mapME_length | wpc)+
apply (clarsimp simp: upto_enum_step_def Suc_unat_diff_1 word_le_sub1)
done
lemma getMessageInfo_msgExtraCaps[wp]:
"\<lbrace>\<top>\<rbrace> getMessageInfo t \<lbrace>\<lambda>rv s. unat (msgExtraCaps rv) \<le> msgMaxExtraCaps\<rbrace>"
apply (simp add: getMessageInfo_def)
apply wp
apply (simp add: messageInfoFromWord_def Let_def msgMaxExtraCaps_def
shiftL_nat)
apply (subst nat_le_Suc_less_imp)
apply (rule unat_less_power)
apply (simp add: word_bits_def msgExtraCapBits_def)
apply (rule and_mask_less'[unfolded mask_2pm1])
apply (simp add: msgExtraCapBits_def)
apply wpsimp+
done
lemma lookupCapAndSlot_corres:
"cptr = to_bl cptr' \<Longrightarrow>
corres (lfr \<oplus> (\<lambda>a b. cap_relation (fst a) (fst b) \<and> snd b = cte_map (snd a)))
(valid_objs and pspace_aligned and tcb_at thread)
(valid_objs' and pspace_distinct' and pspace_aligned' and tcb_at' thread)
(lookup_cap_and_slot thread cptr) (lookupCapAndSlot thread cptr')"
unfolding lookup_cap_and_slot_def lookupCapAndSlot_def
apply (simp add: liftE_bindE split_def)
apply (rule corres_guard_imp)
apply (rule_tac r'="\<lambda>rv rv'. rv' = cte_map (fst rv)"
in corres_splitEE)
apply (rule corres_rel_imp, rule lookupSlotForThread_corres)
apply (simp add: split_def)
apply (rule corres_split[OF getSlotCap_corres])
apply simp
apply (rule corres_returnOkTT, simp)
apply wp+
apply (wp | simp add: liftE_bindE[symmetric])+
done
lemma lookupExtraCaps_corres:
"\<lbrakk> info' = message_info_map info; buffer = buffer'\<rbrakk> \<Longrightarrow>
corres (fr \<oplus> list_all2 (\<lambda>x y. cap_relation (fst x) (fst y) \<and> snd y = cte_map (snd x)))
(valid_objs and pspace_aligned and tcb_at thread and (\<lambda>_. valid_message_info info))
(valid_objs' and pspace_distinct' and pspace_aligned' and tcb_at' thread
and case_option \<top> valid_ipc_buffer_ptr' buffer')
(lookup_extra_caps thread buffer info) (lookupExtraCaps thread buffer' info')"
unfolding lookupExtraCaps_def lookup_extra_caps_def
apply (rule corres_gen_asm)
apply (cases "mi_extra_caps info = 0")
apply (cases info)
apply (simp add: Let_def returnOk_def getExtraCPtrs_def
liftE_bindE upto_enum_step_def mapM_def
sequence_def doMachineOp_return mapME_Nil
split: option.split)
apply (cases info)
apply (rename_tac w1 w2 w3 w4)
apply (simp add: Let_def liftE_bindE)
apply (cases buffer')
apply (simp add: getExtraCPtrs_def mapME_Nil)
apply (rule corres_returnOk)
apply simp
apply (simp add: msgLengthBits_def msgMaxLength_def word_size field_simps
getExtraCPtrs_def upto_enum_step_def upto_enum_word
word_size_def msg_max_length_def liftM_def
Suc_unat_diff_1 word_le_sub1 mapM_map_simp
upt_lhs_sub_map[where x=buffer_cptr_index]
wordSize_def wordBits_def
del: upt.simps)
apply (rule corres_guard_imp)
apply (rule corres_underlying_split)
apply (rule_tac S = "\<lambda>x y. x = y \<and> x < unat w2"
in corres_mapM_list_all2
[where Q = "\<lambda>_. valid_objs and pspace_aligned and tcb_at thread" and r = "(=)"
and Q' = "\<lambda>_. valid_objs' and pspace_aligned' and pspace_distinct' and tcb_at' thread
and case_option \<top> valid_ipc_buffer_ptr' buffer'" and r'="(=)" ])
apply simp
apply simp
apply simp
apply (rule corres_guard_imp)
apply (rule loadWordUser_corres')
apply (clarsimp simp: buffer_cptr_index_def msg_max_length_def
max_ipc_words valid_message_info_def
msg_max_extra_caps_def word_le_nat_alt)
apply (simp add: buffer_cptr_index_def msg_max_length_def)
apply simp
apply simp
apply (simp add: load_word_offs_word_def)
apply (wp | simp)+
apply (subst list_all2_same)
apply (clarsimp simp: max_ipc_words field_simps)
apply (simp add: mapME_def, fold mapME_def)[1]
apply (rule corres_mapME [where S = Id and r'="(\<lambda>x y. cap_relation (fst x) (fst y) \<and> snd y = cte_map (snd x))"])
apply simp
apply simp
apply simp
apply (rule corres_cap_fault [OF lookupCapAndSlot_corres])
apply simp
apply simp
apply (wp | simp)+
apply (simp add: set_zip_same Int_lower1)
apply (wp mapM_wp [OF _ subset_refl] | simp)+
done
crunch ctes_of[wp]: copyMRs "\<lambda>s. P (ctes_of s)"
(wp: threadSet_ctes_of crunch_wps)
lemma copyMRs_valid_mdb[wp]:
"\<lbrace>valid_mdb'\<rbrace> copyMRs t buf t' buf' n \<lbrace>\<lambda>rv. valid_mdb'\<rbrace>"
by (simp add: valid_mdb'_def copyMRs_ctes_of)
lemma doNormalTransfer_corres:
"corres dc
(tcb_at sender and tcb_at receiver and (pspace_aligned:: det_state \<Rightarrow> bool)
and valid_objs and cur_tcb and valid_mdb and valid_list and pspace_distinct
and (\<lambda>s. case ep of Some x \<Rightarrow> ep_at x s | _ \<Rightarrow> True)
and case_option \<top> in_user_frame send_buf
and case_option \<top> in_user_frame recv_buf)
(tcb_at' sender and tcb_at' receiver and valid_objs'
and pspace_aligned' and pspace_distinct' and cur_tcb'
and valid_mdb' and no_0_obj'
and (\<lambda>s. case ep of Some x \<Rightarrow> ep_at' x s | _ \<Rightarrow> True)
and case_option \<top> valid_ipc_buffer_ptr' send_buf
and case_option \<top> valid_ipc_buffer_ptr' recv_buf)
(do_normal_transfer sender send_buf ep badge can_grant receiver recv_buf)
(doNormalTransfer sender send_buf ep badge can_grant receiver recv_buf)"
apply (simp add: do_normal_transfer_def doNormalTransfer_def)
apply (rule corres_guard_imp)
apply (rule corres_split_mapr[OF getMessageInfo_corres])
apply (rule_tac F="valid_message_info mi" in corres_gen_asm)
apply (rule_tac r'="list_all2 (\<lambda>x y. cap_relation (fst x) (fst y) \<and> snd y = cte_map (snd x))"
in corres_split)
apply (rule corres_if[OF refl])
apply (rule corres_split_catch)
apply (rule lookupExtraCaps_corres; simp)
apply (rule corres_trivial, simp)
apply wp+
apply (rule corres_trivial, simp)
apply simp
apply (rule corres_split_eqr[OF copyMRs_corres])
apply (rule corres_split)
apply (rule transferCaps_corres; simp)
apply (rename_tac mi' mi'')
apply (rule_tac F="mi_label mi' = mi_label mi"
in corres_gen_asm)
apply (rule corres_split_nor[OF setMessageInfo_corres])
apply (case_tac mi', clarsimp)
apply (simp add: badge_register_def badgeRegister_def)
apply (fold dc_def)
apply (rule asUser_setRegister_corres)
apply wp
apply simp+
apply ((wp valid_case_option_post_wp hoare_vcg_const_Ball_lift
hoare_case_option_wp
hoare_valid_ipc_buffer_ptr_typ_at' copyMRs_typ_at'
hoare_vcg_const_Ball_lift lookupExtraCaps_length
| simp add: if_apply_def2)+)
apply (wp static_imp_wp | strengthen valid_msg_length_strengthen)+
apply clarsimp
apply auto
done
lemma corres_liftE_lift:
"corres r1 P P' m m' \<Longrightarrow>
corres (f1 \<oplus> r1) P P' (liftE m) (withoutFailure m')"
by simp
lemmas corres_ipc_thread_helper =
corres_split_eqrE[OF corres_liftE_lift [OF getCurThread_corres]]
lemmas corres_ipc_info_helper =
corres_split_maprE [where f = message_info_map, OF _
corres_liftE_lift [OF getMessageInfo_corres]]
crunch typ_at'[wp]: doNormalTransfer "\<lambda>s. P (typ_at' T p s)"
lemmas doNormal_lifts[wp] = typ_at_lifts [OF doNormalTransfer_typ_at']
lemma doNormal_invs'[wp]:
"\<lbrace>tcb_at' sender and tcb_at' receiver and invs'\<rbrace>
doNormalTransfer sender send_buf ep badge
can_grant receiver recv_buf \<lbrace>\<lambda>r. invs'\<rbrace>"
apply (simp add: doNormalTransfer_def)
apply (wp hoare_vcg_const_Ball_lift | simp)+
done
crunch aligned'[wp]: doNormalTransfer pspace_aligned'
(wp: crunch_wps)
crunch distinct'[wp]: doNormalTransfer pspace_distinct'
(wp: crunch_wps)
lemma transferCaps_urz[wp]:
"\<lbrace>untyped_ranges_zero' and valid_pspace'
and (\<lambda>s. (\<forall>x\<in>set caps. cte_wp_at' (\<lambda>cte. fst x \<noteq> capability.NullCap \<longrightarrow> cteCap cte = fst x) (snd x) s))\<rbrace>
transferCaps tag caps ep receiver recv_buf
\<lbrace>\<lambda>r. untyped_ranges_zero'\<rbrace>"
apply (simp add: transferCaps_def)
apply (rule hoare_pre)
apply (wp hoare_vcg_all_lift hoare_vcg_const_imp_lift
| wpc
| simp add: ball_conj_distrib)+
apply clarsimp
done
crunch gsUntypedZeroRanges[wp]: doNormalTransfer "\<lambda>s. P (gsUntypedZeroRanges s)"
(wp: crunch_wps transferCapsToSlots_pres1 ignore: constOnFailure)
lemmas asUser_urz = untyped_ranges_zero_lift[OF asUser_gsUntypedZeroRanges]
crunch urz[wp]: doNormalTransfer "untyped_ranges_zero'"
(ignore: asUser wp: crunch_wps asUser_urz hoare_vcg_const_Ball_lift)
lemma msgFromLookupFailure_map[simp]:
"msgFromLookupFailure (lookup_failure_map lf)
= msg_from_lookup_failure lf"
by (cases lf, simp_all add: lookup_failure_map_def msgFromLookupFailure_def)
lemma asUser_getRestartPC_corres:
"corres (=) (tcb_at t) (tcb_at' t)
(as_user t getRestartPC) (asUser t getRestartPC)"
apply (rule asUser_corres')
apply (rule corres_Id, simp, simp)
apply (rule no_fail_getRestartPC)
done
lemma asUser_mapM_getRegister_corres:
"corres (=) (tcb_at t) (tcb_at' t)
(as_user t (mapM getRegister regs))
(asUser t (mapM getRegister regs))"
apply (rule asUser_corres')
apply (rule corres_Id [OF refl refl])
apply (rule no_fail_mapM)
apply (simp add: getRegister_def)
done
lemma makeArchFaultMessage_corres:
"corres (=) (tcb_at t) (tcb_at' t)
(make_arch_fault_msg f t)
(makeArchFaultMessage (arch_fault_map f) t)"
apply (cases f, clarsimp simp: makeArchFaultMessage_def split: arch_fault.split)
apply (rule corres_guard_imp)
apply (rule corres_split_eqr[OF asUser_getRestartPC_corres])
apply (rule corres_trivial, simp add: arch_fault_map_def)
apply (wp+, auto)
done
lemma makeFaultMessage_corres:
"corres (=) (tcb_at t) (tcb_at' t)
(make_fault_msg ft t)
(makeFaultMessage (fault_map ft) t)"
apply (cases ft, simp_all add: makeFaultMessage_def split del: if_split)
apply (rule corres_guard_imp)
apply (rule corres_split_eqr[OF asUser_getRestartPC_corres])
apply (rule corres_trivial, simp add: fromEnum_def enum_bool)
apply (wp | simp)+
apply (simp add: ARM_H.syscallMessage_def)
apply (rule corres_guard_imp)
apply (rule corres_split_eqr[OF asUser_mapM_getRegister_corres])
apply (rule corres_trivial, simp)
apply (wp | simp)+
apply (simp add: ARM_H.exceptionMessage_def)
apply (rule corres_guard_imp)
apply (rule corres_split_eqr[OF asUser_mapM_getRegister_corres])
apply (rule corres_trivial, simp)
apply (wp | simp)+
apply (rule makeArchFaultMessage_corres)
done
lemma makeFaultMessage_inv[wp]:
"\<lbrace>P\<rbrace> makeFaultMessage ft t \<lbrace>\<lambda>rv. P\<rbrace>"
apply (cases ft, simp_all add: makeFaultMessage_def)
apply (wp asUser_inv mapM_wp' det_mapM[where S=UNIV]
det_getRestartPC getRestartPC_inv
| clarsimp simp: getRegister_def makeArchFaultMessage_def
split: arch_fault.split)+
done
lemmas threadget_fault_corres =
threadGet_corres [where r = fault_rel_optionation
and f = tcb_fault and f' = tcbFault,
simplified tcb_relation_def, simplified]
lemma doFaultTransfer_corres:
"corres dc
(obj_at (\<lambda>ko. \<exists>tcb ft. ko = TCB tcb \<and> tcb_fault tcb = Some ft) sender
and tcb_at receiver and case_option \<top> in_user_frame recv_buf)
(tcb_at' sender and tcb_at' receiver and
case_option \<top> valid_ipc_buffer_ptr' recv_buf)
(do_fault_transfer badge sender receiver recv_buf)
(doFaultTransfer badge sender receiver recv_buf)"
apply (clarsimp simp: do_fault_transfer_def doFaultTransfer_def split_def
ARM_H.badgeRegister_def badge_register_def)
apply (rule_tac Q="\<lambda>fault. K (\<exists>f. fault = Some f) and
tcb_at sender and tcb_at receiver and
case_option \<top> in_user_frame recv_buf"
and Q'="\<lambda>fault'. tcb_at' sender and tcb_at' receiver and
case_option \<top> valid_ipc_buffer_ptr' recv_buf"
in corres_underlying_split)
apply (rule corres_guard_imp)
apply (rule threadget_fault_corres)
apply (clarsimp simp: obj_at_def is_tcb)+
apply (rule corres_assume_pre)
apply (fold assert_opt_def | unfold haskell_fail_def)+
apply (rule corres_assert_opt_assume)
apply (clarsimp split: option.splits
simp: fault_rel_optionation_def assert_opt_def
map_option_case)
defer
defer
apply (clarsimp simp: fault_rel_optionation_def)
apply (wp thread_get_wp)
apply (clarsimp simp: obj_at_def is_tcb)
apply wp
apply (rule corres_guard_imp)
apply (rule corres_split_eqr[OF makeFaultMessage_corres])
apply (rule corres_split_eqr[OF setMRs_corres [OF refl]])
apply (rule corres_split_nor[OF setMessageInfo_corres])
apply simp
apply (rule asUser_setRegister_corres)
apply (wp | simp)+
apply (rule corres_guard_imp)
apply (rule corres_split_eqr[OF makeFaultMessage_corres])
apply (rule corres_split_eqr[OF setMRs_corres [OF refl]])
apply (rule corres_split_nor[OF setMessageInfo_corres])
apply simp
apply (rule asUser_setRegister_corres)
apply (wp | simp)+
done
lemma doFaultTransfer_invs[wp]:
"\<lbrace>invs' and tcb_at' receiver\<rbrace>
doFaultTransfer badge sender receiver recv_buf
\<lbrace>\<lambda>rv. invs'\<rbrace>"
by (simp add: doFaultTransfer_def split_def | wp
| clarsimp split: option.split)+
lemma lookupIPCBuffer_valid_ipc_buffer [wp]:
"\<lbrace>valid_objs'\<rbrace> VSpace_H.lookupIPCBuffer b s \<lbrace>case_option \<top> valid_ipc_buffer_ptr'\<rbrace>"
unfolding lookupIPCBuffer_def ARM_H.lookupIPCBuffer_def
apply (simp add: Let_def getSlotCap_def getThreadBufferSlot_def
locateSlot_conv threadGet_def comp_def)
apply (wp getCTE_wp getObject_tcb_wp | wpc)+
apply (clarsimp simp del: imp_disjL)
apply (drule obj_at_ko_at')
apply (clarsimp simp del: imp_disjL)
apply (rule_tac x = ko in exI)
apply (frule ko_at_cte_ipcbuffer)
apply (clarsimp simp: cte_wp_at_ctes_of simp del: imp_disjL)
apply (clarsimp simp: valid_ipc_buffer_ptr'_def)
apply (frule (1) ko_at_valid_objs')
apply (clarsimp simp: projectKO_opts_defs split: kernel_object.split_asm)
apply (clarsimp simp add: valid_obj'_def valid_tcb'_def
isCap_simps cte_level_bits_def field_simps)
apply (drule bspec [OF _ ranI [where a = "0x40"]])
apply simp
apply (clarsimp simp add: valid_cap'_def)
apply (rule conjI)
apply (rule aligned_add_aligned)
apply (clarsimp simp add: capAligned_def)
apply assumption
apply (erule is_aligned_andI1)
apply (case_tac xd, simp_all add: msg_align_bits)[1]
apply (clarsimp simp: capAligned_def)
apply (drule_tac x =
"(tcbIPCBuffer ko && mask (pageBitsForSize xd)) >> pageBits" in spec)
apply (subst(asm) mult.commute mult.left_commute, subst(asm) shiftl_t2n[symmetric])
apply (simp add: shiftr_shiftl1)
apply (subst (asm) mask_out_add_aligned)
apply (erule is_aligned_weaken [OF _ pbfs_atleast_pageBits])
apply (erule mp)
apply (rule shiftr_less_t2n)
apply (clarsimp simp: pbfs_atleast_pageBits)
apply (rule and_mask_less')
apply (simp add: word_bits_conv)
done
lemma doIPCTransfer_corres:
"corres dc
(tcb_at s and tcb_at r and valid_objs and pspace_aligned
and valid_list
and pspace_distinct and valid_mdb and cur_tcb
and (\<lambda>s. case ep of Some x \<Rightarrow> ep_at x s | _ \<Rightarrow> True))
(tcb_at' s and tcb_at' r and valid_pspace' and cur_tcb'
and (\<lambda>s. case ep of Some x \<Rightarrow> ep_at' x s | _ \<Rightarrow> True))
(do_ipc_transfer s ep bg grt r)
(doIPCTransfer s ep bg grt r)"
apply (simp add: do_ipc_transfer_def doIPCTransfer_def)
apply (rule_tac Q="%receiveBuffer sa. tcb_at s sa \<and> valid_objs sa \<and>
pspace_aligned sa \<and> tcb_at r sa \<and>
cur_tcb sa \<and> valid_mdb sa \<and> valid_list sa \<and> pspace_distinct sa \<and>
(case ep of None \<Rightarrow> True | Some x \<Rightarrow> ep_at x sa) \<and>
case_option (\<lambda>_. True) in_user_frame receiveBuffer sa \<and>
obj_at (\<lambda>ko. \<exists>tcb. ko = TCB tcb
\<comment> \<open>\<exists>ft. tcb_fault tcb = Some ft\<close>) s sa"
in corres_underlying_split)
apply (rule corres_guard_imp)
apply (rule lookupIPCBuffer_corres')
apply auto[2]
apply (rule corres_underlying_split [OF _ _ thread_get_sp threadGet_inv])
apply (rule corres_guard_imp)
apply (rule threadget_fault_corres)
apply simp
defer
apply (rule corres_guard_imp)
apply (subst case_option_If)+
apply (rule corres_if2)
apply (simp add: fault_rel_optionation_def)
apply (rule corres_split_eqr[OF lookupIPCBuffer_corres'])
apply (simp add: dc_def[symmetric])
apply (rule doNormalTransfer_corres)
apply (wp | simp add: valid_pspace'_def)+
apply (simp add: dc_def[symmetric])
apply (rule doFaultTransfer_corres)
apply (clarsimp simp: obj_at_def)
apply (erule ignore_if)
apply (wp|simp add: obj_at_def is_tcb valid_pspace'_def)+
done
crunch ifunsafe[wp]: doIPCTransfer "if_unsafe_then_cap'"
(wp: crunch_wps hoare_vcg_const_Ball_lift get_rs_cte_at' ignore: transferCapsToSlots
simp: zipWithM_x_mapM ball_conj_distrib )
crunch iflive[wp]: doIPCTransfer "if_live_then_nonz_cap'"
(wp: crunch_wps hoare_vcg_const_Ball_lift get_rs_cte_at' ignore: transferCapsToSlots
simp: zipWithM_x_mapM ball_conj_distrib )
lemma valid_pspace_valid_objs'[elim!]:
"valid_pspace' s \<Longrightarrow> valid_objs' s"
by (simp add: valid_pspace'_def)
crunch vp[wp]: doIPCTransfer "valid_pspace'"
(wp: crunch_wps hoare_vcg_const_Ball_lift get_rs_cte_at' wp: transferCapsToSlots_vp simp:ball_conj_distrib )
crunch sch_act_wf[wp]: doIPCTransfer "\<lambda>s. sch_act_wf (ksSchedulerAction s) s"
(wp: crunch_wps get_rs_cte_at' ignore: transferCapsToSlots simp: zipWithM_x_mapM)
crunch vq[wp]: doIPCTransfer "Invariants_H.valid_queues"
(wp: crunch_wps get_rs_cte_at' ignore: transferCapsToSlots simp: zipWithM_x_mapM)
crunch vq'[wp]: doIPCTransfer "valid_queues'"
(wp: crunch_wps get_rs_cte_at' ignore: transferCapsToSlots simp: zipWithM_x_mapM)
crunch state_refs_of[wp]: doIPCTransfer "\<lambda>s. P (state_refs_of' s)"
(wp: crunch_wps get_rs_cte_at' ignore: transferCapsToSlots simp: zipWithM_x_mapM)
crunch ct[wp]: doIPCTransfer "cur_tcb'"
(wp: crunch_wps get_rs_cte_at' ignore: transferCapsToSlots simp: zipWithM_x_mapM)
crunch idle'[wp]: doIPCTransfer "valid_idle'"
(wp: crunch_wps get_rs_cte_at' ignore: transferCapsToSlots simp: zipWithM_x_mapM)
crunch typ_at'[wp]: doIPCTransfer "\<lambda>s. P (typ_at' T p s)"
(wp: crunch_wps simp: zipWithM_x_mapM)
lemmas dit'_typ_ats[wp] = typ_at_lifts [OF doIPCTransfer_typ_at']
crunch irq_node'[wp]: doIPCTransfer "\<lambda>s. P (irq_node' s)"
(wp: crunch_wps simp: crunch_simps)
lemmas dit_irq_node'[wp]
= valid_irq_node_lift [OF doIPCTransfer_irq_node' doIPCTransfer_typ_at']
crunch valid_arch_state'[wp]: doIPCTransfer "valid_arch_state'"
(wp: crunch_wps simp: crunch_simps)
(* Levity: added (20090126 19:32:26) *)
declare asUser_global_refs' [wp]
lemma lec_valid_cap' [wp]:
"\<lbrace>valid_objs'\<rbrace> lookupExtraCaps thread xa mi \<lbrace>\<lambda>rv s. (\<forall>x\<in>set rv. s \<turnstile>' fst x)\<rbrace>, -"
apply (rule hoare_pre, rule hoare_post_imp_R)
apply (rule hoare_vcg_conj_lift_R[where R=valid_objs' and S="\<lambda>_. valid_objs'"])
apply (rule lookupExtraCaps_srcs)
apply wp
apply (clarsimp simp: cte_wp_at_ctes_of)
apply (fastforce elim: ctes_of_valid')
apply simp
done
crunch objs'[wp]: doIPCTransfer "valid_objs'"
( wp: crunch_wps hoare_vcg_const_Ball_lift
transferCapsToSlots_valid_objs
simp: zipWithM_x_mapM ball_conj_distrib )
crunch global_refs'[wp]: doIPCTransfer "valid_global_refs'"
(wp: crunch_wps hoare_vcg_const_Ball_lift threadSet_global_refsT
transferCapsToSlots_valid_globals
simp: zipWithM_x_mapM ball_conj_distrib)
declare asUser_irq_handlers' [wp]
crunch irq_handlers'[wp]: doIPCTransfer "valid_irq_handlers'"
(wp: crunch_wps hoare_vcg_const_Ball_lift threadSet_irq_handlers'
transferCapsToSlots_irq_handlers
simp: zipWithM_x_mapM ball_conj_distrib )
crunch irq_states'[wp]: doIPCTransfer "valid_irq_states'"
(wp: crunch_wps no_irq no_irq_mapM no_irq_storeWord no_irq_loadWord
no_irq_case_option simp: crunch_simps zipWithM_x_mapM)
crunch pde_mappings'[wp]: doIPCTransfer "valid_pde_mappings'"
(wp: crunch_wps simp: crunch_simps)
crunch irqs_masked'[wp]: doIPCTransfer "irqs_masked'"
(wp: crunch_wps simp: crunch_simps rule: irqs_masked_lift)
lemma doIPCTransfer_invs[wp]:
"\<lbrace>invs' and tcb_at' s and tcb_at' r\<rbrace>
doIPCTransfer s ep bg grt r
\<lbrace>\<lambda>rv. invs'\<rbrace>"
apply (simp add: doIPCTransfer_def)
apply (wpsimp wp: hoare_drop_imp)
done
crunch nosch[wp]: doIPCTransfer "\<lambda>s. P (ksSchedulerAction s)"
(wp: hoare_drop_imps hoare_vcg_split_case_option mapM_wp'
simp: split_def zipWithM_x_mapM)
lemma handle_fault_reply_registers_corres:
"corres (=) (tcb_at t) (tcb_at' t)
(do t' \<leftarrow> arch_get_sanitise_register_info t;
y \<leftarrow> as_user t
(zipWithM_x
(\<lambda>r v. setRegister r
(sanitise_register t' r v))
msg_template msg);
return (label = 0)
od)
(do t' \<leftarrow> getSanitiseRegisterInfo t;
y \<leftarrow> asUser t
(zipWithM_x
(\<lambda>r v. setRegister r (sanitiseRegister t' r v))
msg_template msg);
return (label = 0)
od)"
apply (rule corres_guard_imp)
apply (clarsimp simp: arch_get_sanitise_register_info_def getSanitiseRegisterInfo_def)
apply (rule corres_split)
apply (rule asUser_corres')
apply(simp add: setRegister_def sanitise_register_def
sanitiseRegister_def syscallMessage_def)
apply(subst zipWithM_x_modify)+
apply(rule corres_modify')
apply (simp|wp)+
done
lemma handleFaultReply_corres:
"ft' = fault_map ft \<Longrightarrow>
corres (=) (tcb_at t) (tcb_at' t)
(handle_fault_reply ft t label msg)
(handleFaultReply ft' t label msg)"
apply (cases ft)
apply(simp_all add: handleFaultReply_def
handle_arch_fault_reply_def handleArchFaultReply_def
syscallMessage_def exceptionMessage_def
split: arch_fault.split)
by (rule handle_fault_reply_registers_corres)+
crunch typ_at'[wp]: handleFaultReply "\<lambda>s. P (typ_at' T p s)"
lemmas hfr_typ_ats[wp] = typ_at_lifts [OF handleFaultReply_typ_at']
crunch ct'[wp]: handleFaultReply "\<lambda>s. P (ksCurThread s)"
lemma doIPCTransfer_sch_act_simple [wp]:
"\<lbrace>sch_act_simple\<rbrace> doIPCTransfer sender endpoint badge grant receiver \<lbrace>\<lambda>_. sch_act_simple\<rbrace>"
by (simp add: sch_act_simple_def, wp)
lemma possibleSwitchTo_invs'[wp]:
"\<lbrace>invs' and st_tcb_at' runnable' t
and (\<lambda>s. ksSchedulerAction s = ResumeCurrentThread \<longrightarrow> ksCurThread s \<noteq> t)\<rbrace>
possibleSwitchTo t \<lbrace>\<lambda>_. invs'\<rbrace>"
apply (simp add: possibleSwitchTo_def curDomain_def)
apply (wp tcbSchedEnqueue_invs' ssa_invs')
apply (rule hoare_post_imp[OF _ rescheduleRequired_sa_cnt])
apply (wpsimp wp: ssa_invs' threadGet_wp)+
apply (clarsimp dest!: obj_at_ko_at' simp: tcb_in_cur_domain'_def obj_at'_def)
done
crunch cur' [wp]: isFinalCapability "\<lambda>s. P (cur_tcb' s)"
(simp: crunch_simps unless_when
wp: crunch_wps getObject_inv loadObject_default_inv)
crunch ct' [wp]: deleteCallerCap "\<lambda>s. P (ksCurThread s)"
(simp: crunch_simps unless_when
wp: crunch_wps getObject_inv loadObject_default_inv)
lemma getThreadCallerSlot_inv:
"\<lbrace>P\<rbrace> getThreadCallerSlot t \<lbrace>\<lambda>_. P\<rbrace>"
by (simp add: getThreadCallerSlot_def, wp)
lemma deleteCallerCap_ct_not_ksQ:
"\<lbrace>invs' and ct_in_state' simple' and sch_act_sane
and (\<lambda>s. ksCurThread s \<notin> set (ksReadyQueues s p))\<rbrace>
deleteCallerCap t
\<lbrace>\<lambda>rv s. ksCurThread s \<notin> set (ksReadyQueues s p)\<rbrace>"
apply (simp add: deleteCallerCap_def getSlotCap_def getThreadCallerSlot_def locateSlot_conv)
apply (wp getThreadCallerSlot_inv cteDeleteOne_ct_not_ksQ getCTE_wp)
apply (clarsimp simp: cte_wp_at_ctes_of)
done
crunch tcb_at'[wp]: unbindNotification "tcb_at' x"
lemma finaliseCapTrue_standin_tcb_at' [wp]:
"\<lbrace>tcb_at' x\<rbrace> finaliseCapTrue_standin cap v2 \<lbrace>\<lambda>_. tcb_at' x\<rbrace>"
apply (simp add: finaliseCapTrue_standin_def Let_def)
apply (safe)
apply (wp getObject_ntfn_inv
| wpc
| simp)+
done
lemma finaliseCapTrue_standin_cur':
"\<lbrace>\<lambda>s. cur_tcb' s\<rbrace> finaliseCapTrue_standin cap v2 \<lbrace>\<lambda>_ s'. cur_tcb' s'\<rbrace>"
apply (simp add: cur_tcb'_def)
apply (rule hoare_lift_Pf2 [OF _ finaliseCapTrue_standin_ct'])
apply (wp)
done
lemma cteDeleteOne_cur' [wp]:
"\<lbrace>\<lambda>s. cur_tcb' s\<rbrace> cteDeleteOne slot \<lbrace>\<lambda>_ s'. cur_tcb' s'\<rbrace>"
apply (simp add: cteDeleteOne_def unless_def when_def)
apply (wp hoare_drop_imps finaliseCapTrue_standin_cur' isFinalCapability_cur'
| simp add: split_def | wp (once) cur_tcb_lift)+
done
lemma handleFaultReply_cur' [wp]:
"\<lbrace>\<lambda>s. cur_tcb' s\<rbrace> handleFaultReply x0 thread label msg \<lbrace>\<lambda>_ s'. cur_tcb' s'\<rbrace>"
apply (clarsimp simp add: cur_tcb'_def)
apply (rule hoare_lift_Pf2 [OF _ handleFaultReply_ct'])
apply (wp)
done
lemma capClass_Reply:
"capClass cap = ReplyClass tcb \<Longrightarrow> isReplyCap cap \<and> capTCBPtr cap = tcb"
apply (cases cap, simp_all add: isCap_simps)
apply (rename_tac arch_capability)
apply (case_tac arch_capability, simp_all)
done
lemma reply_cap_end_mdb_chain:
"\<lbrakk> cte_wp_at (is_reply_cap_to t) slot s; invs s;
invs' s';
(s, s') \<in> state_relation; ctes_of s' (cte_map slot) = Some cte \<rbrakk>
\<Longrightarrow> (mdbPrev (cteMDBNode cte) \<noteq> nullPointer
\<and> mdbNext (cteMDBNode cte) = nullPointer)
\<and> cte_wp_at' (\<lambda>cte. isReplyCap (cteCap cte) \<and> capReplyMaster (cteCap cte))
(mdbPrev (cteMDBNode cte)) s'"
apply (clarsimp simp only: cte_wp_at_reply_cap_to_ex_rights)
apply (frule(1) pspace_relation_ctes_ofI[OF state_relation_pspace_relation],
clarsimp+)
apply (subgoal_tac "\<exists>slot' rights'. caps_of_state s slot' = Some (cap.ReplyCap t True rights')
\<and> descendants_of slot' (cdt s) = {slot}")
apply (elim state_relationE exE)
apply (clarsimp simp: cdt_relation_def
simp del: split_paired_All)
apply (drule spec, drule(1) mp[OF _ caps_of_state_cte_at])
apply (frule(1) pspace_relation_cte_wp_at[OF _ caps_of_state_cteD],
clarsimp+)
apply (clarsimp simp: descendants_of'_def cte_wp_at_ctes_of)
apply (frule_tac f="\<lambda>S. cte_map slot \<in> S" in arg_cong, simp(no_asm_use))
apply (frule invs_mdb'[unfolded valid_mdb'_def])
apply (rule context_conjI)
apply (clarsimp simp: nullPointer_def valid_mdb_ctes_def)
apply (erule(4) subtree_prev_0)
apply (rule conjI)
apply (rule ccontr)
apply (frule valid_mdb_no_loops, simp add: no_loops_def)
apply (drule_tac x="cte_map slot" in spec)
apply (erule notE, rule r_into_trancl, rule ccontr)
apply (clarsimp simp: mdb_next_unfold valid_mdb_ctes_def nullPointer_def)
apply (rule valid_dlistEn, assumption+)
apply (subgoal_tac "ctes_of s' \<turnstile> cte_map slot \<leadsto> mdbNext (cteMDBNode cte)")
apply (frule(3) class_linksD)
apply (clarsimp simp: isCap_simps dest!: capClass_Reply[OF sym])
apply (drule_tac f="\<lambda>S. mdbNext (cteMDBNode cte) \<in> S" in arg_cong)
apply (simp, erule notE, rule subtree.trans_parent, assumption+)
apply (case_tac ctea, case_tac cte')
apply (clarsimp simp add: parentOf_def isMDBParentOf_CTE)
apply (simp add: sameRegionAs_def2 isCap_simps)
apply (erule subtree.cases)
apply (clarsimp simp: parentOf_def isMDBParentOf_CTE)
apply (clarsimp simp: parentOf_def isMDBParentOf_CTE)
apply (simp add: mdb_next_unfold)
apply (erule subtree.cases)
apply (clarsimp simp: valid_mdb_ctes_def)
apply (erule_tac cte=ctea in valid_dlistEn, assumption)
apply (simp add: mdb_next_unfold)
apply (clarsimp simp: mdb_next_unfold isCap_simps)
apply (drule_tac f="\<lambda>S. c' \<in> S" in arg_cong)
apply (clarsimp simp: no_loops_direct_simp valid_mdb_no_loops)
apply (frule invs_mdb)
apply (drule invs_valid_reply_caps)
apply (clarsimp simp: valid_mdb_def reply_mdb_def
valid_reply_caps_def reply_caps_mdb_def
cte_wp_at_caps_of_state
simp del: split_paired_All)
apply (erule_tac x=slot in allE, erule_tac x=t in allE, erule impE, fast)
apply (elim exEI)
apply clarsimp
apply (subgoal_tac "P" for P, rule sym, rule equalityI, assumption)
apply clarsimp
apply (erule(4) unique_reply_capsD)
apply (simp add: descendants_of_def)
apply (rule r_into_trancl)
apply (simp add: cdt_parent_rel_def is_cdt_parent_def)
done
crunch valid_objs'[wp]: cteDeleteOne "valid_objs'"
(simp: crunch_simps unless_def
wp: crunch_wps getObject_inv loadObject_default_inv)
crunch nosch[wp]: handleFaultReply "\<lambda>s. P (ksSchedulerAction s)"
lemma emptySlot_weak_sch_act[wp]:
"\<lbrace>\<lambda>s. weak_sch_act_wf (ksSchedulerAction s) s\<rbrace>
emptySlot slot irq
\<lbrace>\<lambda>_ s. weak_sch_act_wf (ksSchedulerAction s) s\<rbrace>"
by (wp weak_sch_act_wf_lift tcb_in_cur_domain'_lift)
lemma cancelAllIPC_weak_sch_act_wf[wp]:
"\<lbrace>\<lambda>s. weak_sch_act_wf (ksSchedulerAction s) s\<rbrace>
cancelAllIPC epptr
\<lbrace>\<lambda>_ s. weak_sch_act_wf (ksSchedulerAction s) s\<rbrace>"
apply (simp add: cancelAllIPC_def)
apply (wp rescheduleRequired_weak_sch_act_wf hoare_drop_imp | wpc | simp)+
done
lemma cancelAllSignals_weak_sch_act_wf[wp]:
"\<lbrace>\<lambda>s. weak_sch_act_wf (ksSchedulerAction s) s\<rbrace>
cancelAllSignals ntfnptr
\<lbrace>\<lambda>_ s. weak_sch_act_wf (ksSchedulerAction s) s\<rbrace>"
apply (simp add: cancelAllSignals_def)
apply (wp rescheduleRequired_weak_sch_act_wf hoare_drop_imp | wpc | simp)+
done
crunch weak_sch_act_wf[wp]: finaliseCapTrue_standin "\<lambda>s. weak_sch_act_wf (ksSchedulerAction s) s"
(ignore: setThreadState
simp: crunch_simps
wp: crunch_wps getObject_inv loadObject_default_inv)
lemma cteDeleteOne_weak_sch_act[wp]:
"\<lbrace>\<lambda>s. weak_sch_act_wf (ksSchedulerAction s) s\<rbrace>
cteDeleteOne sl
\<lbrace>\<lambda>_ s. weak_sch_act_wf (ksSchedulerAction s) s\<rbrace>"
apply (simp add: cteDeleteOne_def unless_def)
apply (wp hoare_drop_imps finaliseCapTrue_standin_cur' isFinalCapability_cur'
| simp add: split_def)+
done
crunch weak_sch_act_wf[wp]: emptySlot "\<lambda>s. weak_sch_act_wf (ksSchedulerAction s) s"
crunch pred_tcb_at'[wp]: handleFaultReply "pred_tcb_at' proj P t"
crunch valid_queues[wp]: handleFaultReply "Invariants_H.valid_queues"
crunch valid_queues'[wp]: handleFaultReply "valid_queues'"
crunch tcb_in_cur_domain'[wp]: handleFaultReply "tcb_in_cur_domain' t"
crunch sch_act_wf[wp]: unbindNotification "\<lambda>s. sch_act_wf (ksSchedulerAction s) s"
(wp: sbn_sch_act')
crunch valid_queues'[wp]: cteDeleteOne valid_queues'
(simp: crunch_simps inQ_def
wp: crunch_wps sts_st_tcb' getObject_inv loadObject_default_inv
threadSet_valid_queues' rescheduleRequired_valid_queues'_weak)
lemma cancelSignal_valid_queues'[wp]:
"\<lbrace>valid_queues'\<rbrace> cancelSignal t ntfn \<lbrace>\<lambda>rv. valid_queues'\<rbrace>"
apply (simp add: cancelSignal_def)
apply (rule hoare_pre)
apply (wp getNotification_wp| wpc | simp)+
done
lemma cancelIPC_valid_queues'[wp]:
"\<lbrace>valid_queues' and (\<lambda>s. sch_act_wf (ksSchedulerAction s) s) \<rbrace> cancelIPC t \<lbrace>\<lambda>rv. valid_queues'\<rbrace>"
apply (simp add: cancelIPC_def Let_def getThreadReplySlot_def locateSlot_conv liftM_def)
apply (rule hoare_seq_ext[OF _ gts_sp'])
apply (case_tac state, simp_all) defer 2
apply (rule hoare_pre)
apply ((wp getEndpoint_wp getCTE_wp | wpc | simp)+)[8]
apply (wp cteDeleteOne_valid_queues')
apply (rule_tac Q="\<lambda>_. valid_queues' and (\<lambda>s. sch_act_wf (ksSchedulerAction s) s)" in hoare_post_imp)
apply (clarsimp simp: capHasProperty_def cte_wp_at_ctes_of)
apply (wp threadSet_valid_queues' threadSet_sch_act| simp)+
apply (clarsimp simp: inQ_def)
done
crunch valid_objs'[wp]: handleFaultReply valid_objs'
lemma cte_wp_at_is_reply_cap_toI:
"cte_wp_at ((=) (cap.ReplyCap t False rights)) ptr s
\<Longrightarrow> cte_wp_at (is_reply_cap_to t) ptr s"
by (fastforce simp: cte_wp_at_reply_cap_to_ex_rights)
lemma doReplyTransfer_corres:
"corres dc
(einvs and tcb_at receiver and tcb_at sender
and cte_wp_at ((=) (cap.ReplyCap receiver False rights)) slot)
(invs' and tcb_at' sender and tcb_at' receiver
and valid_pspace' and cte_at' (cte_map slot))
(do_reply_transfer sender receiver slot grant)
(doReplyTransfer sender receiver (cte_map slot) grant)"
apply (simp add: do_reply_transfer_def doReplyTransfer_def cong: option.case_cong)
apply (rule corres_underlying_split [OF _ _ gts_sp gts_sp'])
apply (rule corres_guard_imp)
apply (rule getThreadState_corres, (clarsimp simp add: st_tcb_at_tcb_at)+)
apply (rule_tac F = "awaiting_reply state" in corres_req)
apply (clarsimp simp add: st_tcb_at_def obj_at_def is_tcb)
apply (fastforce simp: invs_def valid_state_def intro: has_reply_cap_cte_wpD
dest: has_reply_cap_cte_wpD
dest!: valid_reply_caps_awaiting_reply cte_wp_at_is_reply_cap_toI)
apply (case_tac state, simp_all add: bind_assoc)
apply (simp add: isReply_def liftM_def)
apply (rule corres_symb_exec_r[OF _ getCTE_sp getCTE_inv, rotated])
apply (rule no_fail_pre, wp)
apply clarsimp
apply (rename_tac mdbnode)
apply (rule_tac P="Q" and Q="Q" and P'="Q'" and Q'="(\<lambda>s. Q' s \<and> R' s)" for Q Q' R'
in stronger_corres_guard_imp[rotated])
apply assumption
apply (rule conjI, assumption)
apply (clarsimp simp: cte_wp_at_ctes_of)
apply (drule cte_wp_at_is_reply_cap_toI)
apply (erule(4) reply_cap_end_mdb_chain)
apply (rule corres_assert_assume[rotated], simp)
apply (simp add: getSlotCap_def)
apply (rule corres_symb_exec_r[OF _ getCTE_sp getCTE_inv, rotated])
apply (rule no_fail_pre, wp)
apply (clarsimp simp: cte_wp_at_ctes_of)
apply (rule corres_assert_assume[rotated])
apply (clarsimp simp: cte_wp_at_ctes_of)
apply (rule corres_guard_imp)
apply (rule corres_split[OF threadget_fault_corres])
apply (case_tac rv, simp_all add: fault_rel_optionation_def bind_assoc)[1]
apply (rule corres_split[OF doIPCTransfer_corres])
apply (rule corres_split[OF cap_delete_one_corres])
apply (rule corres_split[OF setThreadState_corres])
apply simp
apply (rule possibleSwitchTo_corres)
apply (wp set_thread_state_runnable_valid_sched set_thread_state_runnable_weak_valid_sched_action sts_st_tcb_at' sts_st_tcb' sts_valid_queues sts_valid_objs' delete_one_tcbDomain_obj_at'
| simp add: valid_tcb_state'_def)+
apply (strengthen cte_wp_at_reply_cap_can_fast_finalise)
apply (wp hoare_vcg_conj_lift)
apply (rule hoare_strengthen_post [OF do_ipc_transfer_non_null_cte_wp_at])
prefer 2
apply (erule cte_wp_at_weakenE)
apply (fastforce)
apply (clarsimp simp:is_cap_simps)
apply (wp weak_valid_sched_action_lift)+
apply (rule_tac Q="\<lambda>_. valid_queues' and valid_objs' and cur_tcb' and tcb_at' receiver and (\<lambda>s. sch_act_wf (ksSchedulerAction s) s)" in hoare_post_imp, simp add: sch_act_wf_weak)
apply (wp tcb_in_cur_domain'_lift)
defer
apply (simp)
apply (wp)+
apply (clarsimp)
apply (rule conjI, erule invs_valid_objs)
apply (rule conjI, clarsimp)+
apply (rule conjI)
apply (erule cte_wp_at_weakenE)
apply (clarsimp)
apply (rule conjI, rule refl)
apply (fastforce)
apply (clarsimp simp: invs_def valid_sched_def valid_sched_action_def)
apply (simp)
apply (auto simp: invs'_def valid_state'_def)[1]
apply (rule corres_guard_imp)
apply (rule corres_split[OF cap_delete_one_corres])
apply (rule corres_split_mapr[OF getMessageInfo_corres])
apply (rule corres_split_eqr[OF lookupIPCBuffer_corres'])
apply (rule corres_split_eqr[OF getMRs_corres])
apply (simp(no_asm) del: dc_simp)
apply (rule corres_split_eqr[OF handleFaultReply_corres])
apply simp
apply (rule corres_split)
apply (rule threadset_corresT;
clarsimp simp add: tcb_relation_def fault_rel_optionation_def
tcb_cap_cases_def tcb_cte_cases_def exst_same_def)
apply (rule_tac P="valid_sched and cur_tcb and tcb_at receiver"
and P'="tcb_at' receiver and cur_tcb'
and (\<lambda>s. weak_sch_act_wf (ksSchedulerAction s) s)
and Invariants_H.valid_queues and valid_queues' and valid_objs'"
in corres_inst)
apply (case_tac rvb, simp_all)[1]
apply (rule corres_guard_imp)
apply (rule corres_split[OF setThreadState_corres])
apply simp
apply (fold dc_def, rule possibleSwitchTo_corres)
apply simp
apply (wp static_imp_wp static_imp_conj_wp set_thread_state_runnable_weak_valid_sched_action sts_st_tcb_at'
sts_st_tcb' sts_valid_queues | simp | force simp: valid_sched_def valid_sched_action_def valid_tcb_state'_def)+
apply (rule corres_guard_imp)
apply (rule setThreadState_corres)
apply clarsimp+
apply (wp threadSet_cur weak_sch_act_wf_lift_linear threadSet_pred_tcb_no_state
thread_set_not_state_valid_sched threadSet_valid_queues threadSet_valid_queues'
threadSet_tcbDomain_triv threadSet_valid_objs'
| simp add: valid_tcb_state'_def)+
apply (wp threadSet_cur weak_sch_act_wf_lift_linear threadSet_pred_tcb_no_state
thread_set_not_state_valid_sched threadSet_valid_queues threadSet_valid_queues'
| simp add: runnable_def inQ_def valid_tcb'_def)+
apply (rule_tac Q="\<lambda>_. valid_sched and cur_tcb and tcb_at sender and tcb_at receiver and valid_objs and pspace_aligned"
in hoare_strengthen_post [rotated], clarsimp)
apply (wp)
apply (rule hoare_chain [OF cap_delete_one_invs])
apply (assumption)
apply (rule conjI, clarsimp)
apply (clarsimp simp add: invs_def valid_state_def)
apply (rule_tac Q="\<lambda>_. tcb_at' sender and tcb_at' receiver and invs'"
in hoare_strengthen_post [rotated])
apply (solves\<open>auto simp: invs'_def valid_state'_def\<close>)
apply wp
apply clarsimp
apply (rule conjI)
apply (erule cte_wp_at_weakenE)
apply (clarsimp simp add: can_fast_finalise_def)
apply (erule(1) emptyable_cte_wp_atD)
apply (rule allI, rule impI)
apply (clarsimp simp add: is_master_reply_cap_def)
apply (clarsimp)
done
(* when we cannot talk about reply cap rights explicitly (for instance, when a schematic ?rights
would be generated too early *)
lemma doReplyTransfer_corres':
"corres dc
(einvs and tcb_at receiver and tcb_at sender
and cte_wp_at (is_reply_cap_to receiver) slot)
(invs' and tcb_at' sender and tcb_at' receiver
and valid_pspace' and cte_at' (cte_map slot))
(do_reply_transfer sender receiver slot grant)
(doReplyTransfer sender receiver (cte_map slot) grant)"
using doReplyTransfer_corres[of receiver sender _ slot]
by (fastforce simp add: cte_wp_at_reply_cap_to_ex_rights corres_underlying_def)
lemma valid_pspace'_splits[elim!]:
"valid_pspace' s \<Longrightarrow> valid_objs' s"
"valid_pspace' s \<Longrightarrow> pspace_aligned' s"
"valid_pspace' s \<Longrightarrow> pspace_distinct' s"
"valid_pspace' s \<Longrightarrow> valid_mdb' s"
"valid_pspace' s \<Longrightarrow> no_0_obj' s"
by (simp add: valid_pspace'_def)+
lemma sts_valid_pspace_hangers:
"\<lbrace>valid_pspace' and tcb_at' t and
valid_tcb_state' st\<rbrace> setThreadState st t \<lbrace>\<lambda>rv. valid_objs'\<rbrace>"
"\<lbrace>valid_pspace' and tcb_at' t and
valid_tcb_state' st\<rbrace> setThreadState st t \<lbrace>\<lambda>rv. pspace_distinct'\<rbrace>"
"\<lbrace>valid_pspace' and tcb_at' t and
valid_tcb_state' st\<rbrace> setThreadState st t \<lbrace>\<lambda>rv. pspace_aligned'\<rbrace>"
"\<lbrace>valid_pspace' and tcb_at' t and
valid_tcb_state' st\<rbrace> setThreadState st t \<lbrace>\<lambda>rv. valid_mdb'\<rbrace>"
"\<lbrace>valid_pspace' and tcb_at' t and
valid_tcb_state' st\<rbrace> setThreadState st t \<lbrace>\<lambda>rv. no_0_obj'\<rbrace>"
by (safe intro!: hoare_strengthen_post [OF sts'_valid_pspace'_inv])
declare no_fail_getSlotCap [wp]
lemma setupCallerCap_corres:
"corres dc
(st_tcb_at (Not \<circ> halted) sender and tcb_at receiver and
st_tcb_at (Not \<circ> awaiting_reply) sender and valid_reply_caps and
valid_objs and pspace_distinct and pspace_aligned and valid_mdb
and valid_list and
valid_reply_masters and cte_wp_at (\<lambda>c. c = cap.NullCap) (receiver, tcb_cnode_index 3))
(tcb_at' sender and tcb_at' receiver and valid_pspace'
and (\<lambda>s. weak_sch_act_wf (ksSchedulerAction s) s))
(setup_caller_cap sender receiver grant)
(setupCallerCap sender receiver grant)"
supply if_split[split del]
apply (simp add: setup_caller_cap_def setupCallerCap_def
getThreadReplySlot_def locateSlot_conv
getThreadCallerSlot_def)
apply (rule stronger_corres_guard_imp)
apply (rule corres_split_nor)
apply (rule setThreadState_corres)
apply (simp split: option.split)
apply (rule corres_symb_exec_r)
apply (rule_tac F="\<exists>r. cteCap masterCTE = capability.ReplyCap sender True r
\<and> mdbNext (cteMDBNode masterCTE) = nullPointer"
in corres_gen_asm2, clarsimp simp add: isCap_simps)
apply (rule corres_symb_exec_r)
apply (rule_tac F="rv = capability.NullCap"
in corres_gen_asm2, simp)
apply (rule cteInsert_corres)
apply (simp split: if_splits)
apply (simp add: cte_map_def tcbReplySlot_def
tcb_cnode_index_def cte_level_bits_def)
apply (simp add: cte_map_def tcbCallerSlot_def
tcb_cnode_index_def cte_level_bits_def)
apply (rule_tac Q="\<lambda>rv. cte_at' (receiver + 2 ^ cte_level_bits * tcbCallerSlot)"
in valid_prove_more)
apply (wp, (wp getSlotCap_wp)+)
apply blast
apply (rule no_fail_pre, wp)
apply (clarsimp simp: cte_wp_at'_def cte_at'_def)
apply (rule_tac Q="\<lambda>rv. cte_at' (sender + 2 ^ cte_level_bits * tcbReplySlot)"
in valid_prove_more)
apply (wp, (wp getCTE_wp')+)
apply blast
apply (rule no_fail_pre, wp)
apply (clarsimp simp: cte_wp_at_ctes_of)
apply (wp sts_valid_pspace_hangers
| simp add: cte_wp_at_ctes_of)+
apply (clarsimp simp: valid_tcb_state_def st_tcb_at_reply_cap_valid
st_tcb_at_tcb_at st_tcb_at_caller_cap_null
split: option.split)
apply (clarsimp simp: valid_tcb_state'_def valid_cap'_def capAligned_reply_tcbI)
apply (frule(1) st_tcb_at_reply_cap_valid, simp, clarsimp)
apply (clarsimp simp: cte_wp_at_ctes_of cte_wp_at_caps_of_state)
apply (drule pspace_relation_cte_wp_at[rotated, OF caps_of_state_cteD],
erule valid_pspace'_splits, clarsimp+)+
apply (clarsimp simp: cte_wp_at_ctes_of cte_map_def tcbReplySlot_def
tcbCallerSlot_def tcb_cnode_index_def
is_cap_simps)
apply (auto intro: reply_no_descendants_mdbNext_null[OF not_waiting_reply_slot_no_descendants]
simp: cte_index_repair)
done
crunch tcb_at'[wp]: getThreadCallerSlot "tcb_at' t"
lemma getThreadReplySlot_tcb_at'[wp]:
"\<lbrace>tcb_at' t\<rbrace> getThreadReplySlot tcb \<lbrace>\<lambda>_. tcb_at' t\<rbrace>"
by (simp add: getThreadReplySlot_def, wp)
lemma setupCallerCap_tcb_at'[wp]:
"\<lbrace>tcb_at' t\<rbrace> setupCallerCap sender receiver grant \<lbrace>\<lambda>_. tcb_at' t\<rbrace>"
by (simp add: setupCallerCap_def, wp hoare_drop_imp)
crunch ct'[wp]: setupCallerCap "\<lambda>s. P (ksCurThread s)"
(wp: crunch_wps)
lemma cteInsert_sch_act_wf[wp]:
"\<lbrace>\<lambda>s. sch_act_wf (ksSchedulerAction s) s\<rbrace>
cteInsert newCap srcSlot destSlot
\<lbrace>\<lambda>_ s. sch_act_wf (ksSchedulerAction s) s\<rbrace>"
by (wp sch_act_wf_lift tcb_in_cur_domain'_lift)
lemma setupCallerCap_sch_act [wp]:
"\<lbrace>\<lambda>s. sch_act_not t s \<and> sch_act_wf (ksSchedulerAction s) s\<rbrace>
setupCallerCap t r g \<lbrace>\<lambda>_ s. sch_act_wf (ksSchedulerAction s) s\<rbrace>"
apply (simp add: setupCallerCap_def getSlotCap_def getThreadCallerSlot_def
getThreadReplySlot_def locateSlot_conv)
apply (wp getCTE_wp' sts_sch_act' hoare_drop_imps hoare_vcg_all_lift)
apply clarsimp
done
lemma possibleSwitchTo_weak_sch_act_wf[wp]:
"\<lbrace>\<lambda>s. weak_sch_act_wf (ksSchedulerAction s) s \<and> st_tcb_at' runnable' t s\<rbrace>
possibleSwitchTo t \<lbrace>\<lambda>rv s. weak_sch_act_wf (ksSchedulerAction s) s\<rbrace>"
apply (simp add: possibleSwitchTo_def setSchedulerAction_def threadGet_def curDomain_def
bitmap_fun_defs)
apply (wp rescheduleRequired_weak_sch_act_wf
weak_sch_act_wf_lift_linear[where f="tcbSchedEnqueue t"]
getObject_tcb_wp static_imp_wp
| wpc)+
apply (clarsimp simp: obj_at'_def projectKOs weak_sch_act_wf_def ps_clear_def tcb_in_cur_domain'_def)
done
lemmas transferCapsToSlots_pred_tcb_at' =
transferCapsToSlots_pres1 [OF cteInsert_pred_tcb_at']
crunches doIPCTransfer, possibleSwitchTo
for pred_tcb_at'[wp]: "pred_tcb_at' proj P t"
(wp: mapM_wp' crunch_wps simp: zipWithM_x_mapM)
lemma setSchedulerAction_ct_in_domain:
"\<lbrace>\<lambda>s. ct_idle_or_in_cur_domain' s
\<and> p \<noteq> ResumeCurrentThread \<rbrace> setSchedulerAction p
\<lbrace>\<lambda>_. ct_idle_or_in_cur_domain'\<rbrace>"
by (simp add:setSchedulerAction_def | wp)+
crunches setupCallerCap, doIPCTransfer, possibleSwitchTo
for ct_idle_or_in_cur_domain'[wp]: ct_idle_or_in_cur_domain'
and ksCurDomain[wp]: "\<lambda>s. P (ksCurDomain s)"
and ksDomSchedule[wp]: "\<lambda>s. P (ksDomSchedule s)"
(wp: crunch_wps setSchedulerAction_ct_in_domain simp: zipWithM_x_mapM)
crunch tcbDomain_obj_at'[wp]: doIPCTransfer "obj_at' (\<lambda>tcb. P (tcbDomain tcb)) t"
(wp: crunch_wps constOnFailure_wp simp: crunch_simps)
crunches possibleSwitchTo
for tcb_at'[wp]: "tcb_at' t"
and valid_pspace'[wp]: valid_pspace'
(wp: crunch_wps)
lemma sendIPC_corres:
(* call is only true if called in handleSyscall SysCall, which
is always blocking. *)
assumes "call \<longrightarrow> bl"
shows
"corres dc (einvs and st_tcb_at active t and ep_at ep and ex_nonz_cap_to t)
(invs' and sch_act_not t and tcb_at' t and ep_at' ep)
(send_ipc bl call bg cg cgr t ep) (sendIPC bl call bg cg cgr t ep)"
proof -
show ?thesis
apply (insert assms)
apply (unfold send_ipc_def sendIPC_def Let_def)
apply (case_tac bl)
apply clarsimp
apply (rule corres_guard_imp)
apply (rule corres_split[OF getEndpoint_corres,
where
R="\<lambda>rv. einvs and st_tcb_at active t and ep_at ep and
valid_ep rv and obj_at (\<lambda>ob. ob = Endpoint rv) ep
and ex_nonz_cap_to t"
and
R'="\<lambda>rv'. invs' and tcb_at' t and sch_act_not t
and ep_at' ep and valid_ep' rv'"])
apply (case_tac rv)
apply (simp add: ep_relation_def)
apply (rule corres_guard_imp)
apply (rule corres_split[OF setThreadState_corres])
apply simp
apply (rule setEndpoint_corres)
apply (simp add: ep_relation_def)
apply wp+
apply (clarsimp simp: st_tcb_at_tcb_at valid_tcb_state_def)
apply clarsimp
\<comment> \<open>concludes IdleEP if bl branch\<close>
apply (simp add: ep_relation_def)
apply (rule corres_guard_imp)
apply (rule corres_split[OF setThreadState_corres])
apply simp
apply (rule setEndpoint_corres)
apply (simp add: ep_relation_def)
apply wp+
apply (clarsimp simp: st_tcb_at_tcb_at valid_tcb_state_def)
apply clarsimp
\<comment> \<open>concludes SendEP if bl branch\<close>
apply (simp add: ep_relation_def)
apply (rename_tac list)
apply (rule_tac F="list \<noteq> []" in corres_req)
apply (simp add: valid_ep_def)
apply (case_tac list)
apply simp
apply (clarsimp split del: if_split)
apply (rule corres_guard_imp)
apply (rule corres_split[OF setEndpoint_corres])
apply (simp add: ep_relation_def split: list.split)
apply (simp add: isReceive_def split del:if_split)
apply (rule corres_split[OF getThreadState_corres])
apply (rule_tac
F="\<exists>data. recv_state = Structures_A.BlockedOnReceive ep data"
in corres_gen_asm)
apply (clarsimp simp: case_bool_If case_option_If if3_fold
simp del: dc_simp split del: if_split cong: if_cong)
apply (rule corres_split[OF doIPCTransfer_corres])
apply (rule corres_split[OF setThreadState_corres])
apply simp
apply (rule corres_split[OF possibleSwitchTo_corres])
apply (fold when_def)[1]
apply (rule_tac P="call" and P'="call"
in corres_symmetric_bool_cases, blast)
apply (simp add: when_def dc_def[symmetric] split del: if_split)
apply (rule corres_if2, simp)
apply (rule setupCallerCap_corres)
apply (rule setThreadState_corres, simp)
apply (rule corres_trivial)
apply (simp add: when_def dc_def[symmetric] split del: if_split)
apply (simp split del: if_split add: if_apply_def2)
apply (wp hoare_drop_imps)[1]
apply (simp split del: if_split add: if_apply_def2)
apply (wp hoare_drop_imps)[1]
apply (wp | simp)+
apply (wp sts_cur_tcb set_thread_state_runnable_weak_valid_sched_action sts_st_tcb_at_cases)
apply (wp setThreadState_valid_queues' sts_valid_queues sts_weak_sch_act_wf
sts_cur_tcb' setThreadState_tcb' sts_st_tcb_at'_cases)[1]
apply (simp add: valid_tcb_state_def pred_conj_def)
apply (strengthen reply_cap_doesnt_exist_strg disjI2_strg)
apply ((wp hoare_drop_imps do_ipc_transfer_tcb_caps weak_valid_sched_action_lift
| clarsimp simp: is_cap_simps)+)[1]
apply (simp add: pred_conj_def)
apply (strengthen sch_act_wf_weak)
apply (simp add: valid_tcb_state'_def)
apply (wp weak_sch_act_wf_lift_linear tcb_in_cur_domain'_lift hoare_drop_imps)[1]
apply (wp gts_st_tcb_at)+
apply (simp add: pred_conj_def cong: conj_cong)
apply (wp hoare_post_taut)
apply (simp)
apply (wp weak_sch_act_wf_lift_linear set_ep_valid_objs' setEndpoint_valid_mdb')+
apply (clarsimp simp add: invs_def valid_state_def valid_pspace_def ep_redux_simps
ep_redux_simps' st_tcb_at_tcb_at valid_ep_def
cong: list.case_cong)
apply (drule(1) sym_refs_obj_atD[where P="\<lambda>ob. ob = e" for e])
apply (clarsimp simp: st_tcb_at_refs_of_rev st_tcb_at_reply_cap_valid
st_tcb_def2 valid_sched_def valid_sched_action_def)
apply (force simp: st_tcb_def2 dest!: st_tcb_at_caller_cap_null[simplified,rotated])
subgoal by (auto simp: valid_ep'_def invs'_def valid_state'_def split: list.split)
apply wp+
apply (clarsimp simp: ep_at_def2)+
apply (rule corres_guard_imp)
apply (rule corres_split[OF getEndpoint_corres,
where
R="\<lambda>rv. einvs and st_tcb_at active t and ep_at ep and
valid_ep rv and obj_at (\<lambda>k. k = Endpoint rv) ep"
and
R'="\<lambda>rv'. invs' and tcb_at' t and sch_act_not t
and ep_at' ep and valid_ep' rv'"])
apply (rename_tac rv rv')
apply (case_tac rv)
apply (simp add: ep_relation_def)
\<comment> \<open>concludes IdleEP branch if not bl and no ft\<close>
apply (simp add: ep_relation_def)
\<comment> \<open>concludes SendEP branch if not bl and no ft\<close>
apply (simp add: ep_relation_def)
apply (rename_tac list)
apply (rule_tac F="list \<noteq> []" in corres_req)
apply (simp add: valid_ep_def)
apply (case_tac list)
apply simp
apply (rule_tac F="a \<noteq> t" in corres_req)
apply (clarsimp simp: invs_def valid_state_def
valid_pspace_def)
apply (drule(1) sym_refs_obj_atD[where P="\<lambda>ob. ob = e" for e])
apply (clarsimp simp: st_tcb_at_def obj_at_def tcb_bound_refs_def2)
apply fastforce
apply (clarsimp split del: if_split)
apply (rule corres_guard_imp)
apply (rule corres_split[OF setEndpoint_corres])
apply (simp add: ep_relation_def split: list.split)
apply (rule corres_split[OF getThreadState_corres])
apply (rule_tac
F="\<exists>data. recv_state = Structures_A.BlockedOnReceive ep data"
in corres_gen_asm)
apply (clarsimp simp: isReceive_def case_bool_If
split del: if_split cong: if_cong)
apply (rule corres_split[OF doIPCTransfer_corres])
apply (rule corres_split[OF setThreadState_corres])
apply simp
apply (rule possibleSwitchTo_corres)
apply (simp add: if_apply_def2)
apply ((wp sts_cur_tcb set_thread_state_runnable_weak_valid_sched_action sts_st_tcb_at_cases |
simp add: if_apply_def2 split del: if_split)+)[1]
apply (wp setThreadState_valid_queues' sts_valid_queues sts_weak_sch_act_wf
sts_cur_tcb' setThreadState_tcb' sts_st_tcb_at'_cases)
apply (simp add: valid_tcb_state_def pred_conj_def)
apply ((wp hoare_drop_imps do_ipc_transfer_tcb_caps weak_valid_sched_action_lift
| clarsimp simp:is_cap_simps)+)[1]
apply (simp add: valid_tcb_state'_def pred_conj_def)
apply (strengthen sch_act_wf_weak)
apply (wp weak_sch_act_wf_lift_linear hoare_drop_imps)
apply (wp gts_st_tcb_at)+
apply (simp add: pred_conj_def cong: conj_cong)
apply (wp hoare_post_taut)
apply simp
apply (wp weak_sch_act_wf_lift_linear set_ep_valid_objs' setEndpoint_valid_mdb')
apply (clarsimp simp add: invs_def valid_state_def
valid_pspace_def ep_redux_simps ep_redux_simps'
st_tcb_at_tcb_at
cong: list.case_cong)
apply (clarsimp simp: valid_ep_def)
apply (drule(1) sym_refs_obj_atD[where P="\<lambda>ob. ob = e" for e])
apply (clarsimp simp: st_tcb_at_refs_of_rev st_tcb_at_reply_cap_valid
st_tcb_at_caller_cap_null)
apply (fastforce simp: st_tcb_def2 valid_sched_def valid_sched_action_def)
subgoal by (auto simp: valid_ep'_def
split: list.split;
clarsimp simp: invs'_def valid_state'_def)
apply wp+
apply (clarsimp simp: ep_at_def2)+
done
qed
crunch typ_at'[wp]: setMessageInfo "\<lambda>s. P (typ_at' T p s)"
lemmas setMessageInfo_typ_ats[wp] = typ_at_lifts [OF setMessageInfo_typ_at']
(* Annotation added by Simon Winwood (Thu Jul 1 20:54:41 2010) using taint-mode *)
declare tl_drop_1[simp]
crunch cur[wp]: cancel_ipc "cur_tcb"
(wp: select_wp crunch_wps simp: crunch_simps)
crunch valid_objs'[wp]: asUser "valid_objs'"
lemma valid_sched_weak_strg:
"valid_sched s \<longrightarrow> weak_valid_sched_action s"
by (simp add: valid_sched_def valid_sched_action_def)
crunch weak_valid_sched_action[wp]: as_user weak_valid_sched_action
(wp: weak_valid_sched_action_lift)
lemma sendSignal_corres:
"corres dc (einvs and ntfn_at ep) (invs' and ntfn_at' ep)
(send_signal ep bg) (sendSignal ep bg)"
apply (simp add: send_signal_def sendSignal_def Let_def)
apply (rule corres_guard_imp)
apply (rule corres_split[OF getNotification_corres,
where
R = "\<lambda>rv. einvs and ntfn_at ep and valid_ntfn rv and
ko_at (Structures_A.Notification rv) ep" and
R' = "\<lambda>rv'. invs' and ntfn_at' ep and
valid_ntfn' rv' and ko_at' rv' ep"])
defer
apply (wp get_simple_ko_ko_at get_ntfn_ko')+
apply (simp add: invs_valid_objs)+
apply (case_tac "ntfn_obj ntfn")
\<comment> \<open>IdleNtfn\<close>
apply (clarsimp simp add: ntfn_relation_def)
apply (case_tac "ntfnBoundTCB nTFN")
apply clarsimp
apply (rule corres_guard_imp[OF setNotification_corres])
apply (clarsimp simp add: ntfn_relation_def)+
apply (rule corres_guard_imp)
apply (rule corres_split[OF getThreadState_corres])
apply (rule corres_if)
apply (fastforce simp: receive_blocked_def receiveBlocked_def
thread_state_relation_def
split: Structures_A.thread_state.splits
Structures_H.thread_state.splits)
apply (rule corres_split[OF cancel_ipc_corres])
apply (rule corres_split[OF setThreadState_corres])
apply (clarsimp simp: thread_state_relation_def)
apply (simp add: badgeRegister_def badge_register_def)
apply (rule corres_split[OF asUser_setRegister_corres])
apply (rule possibleSwitchTo_corres)
apply wp
apply (wp set_thread_state_runnable_weak_valid_sched_action sts_st_tcb_at'
sts_valid_queues sts_st_tcb' hoare_disjI2
cancel_ipc_cte_wp_at_not_reply_state
| strengthen invs_vobjs_strgs invs_psp_aligned_strg valid_sched_weak_strg
| simp add: valid_tcb_state_def)+
apply (rule_tac Q="\<lambda>rv. invs' and tcb_at' a" in hoare_strengthen_post)
apply wp
apply (clarsimp simp: invs'_def valid_state'_def sch_act_wf_weak
valid_tcb_state'_def)
apply (rule setNotification_corres)
apply (clarsimp simp add: ntfn_relation_def)
apply (wp gts_wp gts_wp' | clarsimp)+
apply (auto simp: valid_ntfn_def receive_blocked_def valid_sched_def invs_cur
elim: pred_tcb_weakenE
intro: st_tcb_at_reply_cap_valid
split: Structures_A.thread_state.splits)[1]
apply (clarsimp simp: valid_ntfn'_def invs'_def valid_state'_def valid_pspace'_def sch_act_wf_weak)
\<comment> \<open>WaitingNtfn\<close>
apply (clarsimp simp add: ntfn_relation_def Let_def)
apply (simp add: update_waiting_ntfn_def)
apply (rename_tac list)
apply (case_tac "tl list = []")
\<comment> \<open>tl list = []\<close>
apply (rule corres_guard_imp)
apply (rule_tac F="list \<noteq> []" in corres_gen_asm)
apply (simp add: list_case_helper split del: if_split)
apply (rule corres_split[OF setNotification_corres])
apply (simp add: ntfn_relation_def)
apply (rule corres_split[OF setThreadState_corres])
apply simp
apply (simp add: badgeRegister_def badge_register_def)
apply (rule corres_split[OF asUser_setRegister_corres])
apply (rule possibleSwitchTo_corres)
apply ((wp | simp)+)[1]
apply (rule_tac Q="\<lambda>_. Invariants_H.valid_queues and valid_queues' and
(\<lambda>s. sch_act_wf (ksSchedulerAction s) s) and
cur_tcb' and
st_tcb_at' runnable' (hd list) and valid_objs'"
in hoare_post_imp, clarsimp simp: pred_tcb_at' elim!: sch_act_wf_weak)
apply (wp | simp)+
apply (wp sts_st_tcb_at' set_thread_state_runnable_weak_valid_sched_action
| simp)+
apply (wp sts_st_tcb_at'_cases sts_valid_queues setThreadState_valid_queues'
setThreadState_st_tcb
| simp)+
apply (wp set_simple_ko_valid_objs set_ntfn_aligned' set_ntfn_valid_objs'
hoare_vcg_disj_lift weak_sch_act_wf_lift_linear
| simp add: valid_tcb_state_def valid_tcb_state'_def)+
apply (clarsimp simp: invs_def valid_state_def valid_ntfn_def
valid_pspace_def ntfn_queued_st_tcb_at valid_sched_def
valid_sched_action_def)
apply (auto simp: valid_ntfn'_def )[1]
apply (clarsimp simp: invs'_def valid_state'_def)
\<comment> \<open>tl list \<noteq> []\<close>
apply (rule corres_guard_imp)
apply (rule_tac F="list \<noteq> []" in corres_gen_asm)
apply (simp add: list_case_helper)
apply (rule corres_split[OF setNotification_corres])
apply (simp add: ntfn_relation_def split:list.splits)
apply (rule corres_split[OF setThreadState_corres])
apply simp
apply (simp add: badgeRegister_def badge_register_def)
apply (rule corres_split[OF asUser_setRegister_corres])
apply (rule possibleSwitchTo_corres)
apply (wp cur_tcb_lift | simp)+
apply (wp sts_st_tcb_at' set_thread_state_runnable_weak_valid_sched_action
| simp)+
apply (wp sts_st_tcb_at'_cases sts_valid_queues setThreadState_valid_queues'
setThreadState_st_tcb
| simp)+
apply (wp set_ntfn_aligned' set_simple_ko_valid_objs set_ntfn_valid_objs'
hoare_vcg_disj_lift weak_sch_act_wf_lift_linear
| simp add: valid_tcb_state_def valid_tcb_state'_def)+
apply (clarsimp simp: invs_def valid_state_def valid_ntfn_def
valid_pspace_def neq_Nil_conv
ntfn_queued_st_tcb_at valid_sched_def valid_sched_action_def
split: option.splits)
apply (auto simp: valid_ntfn'_def neq_Nil_conv invs'_def valid_state'_def
weak_sch_act_wf_def
split: option.splits)[1]
\<comment> \<open>ActiveNtfn\<close>
apply (clarsimp simp add: ntfn_relation_def)
apply (rule corres_guard_imp)
apply (rule setNotification_corres)
apply (simp add: ntfn_relation_def combine_ntfn_badges_def
combine_ntfn_msgs_def)
apply (simp add: invs_def valid_state_def valid_ntfn_def)
apply (simp add: invs'_def valid_state'_def valid_ntfn'_def)
done
lemma valid_Running'[simp]:
"valid_tcb_state' Running = \<top>"
by (rule ext, simp add: valid_tcb_state'_def)
crunch typ'[wp]: setMRs "\<lambda>s. P (typ_at' T p s)"
(wp: crunch_wps simp: zipWithM_x_mapM)
lemma possibleSwitchTo_sch_act[wp]:
"\<lbrace>\<lambda>s. sch_act_wf (ksSchedulerAction s) s \<and> st_tcb_at' runnable' t s\<rbrace>
possibleSwitchTo t
\<lbrace>\<lambda>rv s. sch_act_wf (ksSchedulerAction s) s\<rbrace>"
apply (simp add: possibleSwitchTo_def curDomain_def bitmap_fun_defs)
apply (wp static_imp_wp threadSet_sch_act setQueue_sch_act threadGet_wp
| simp add: unless_def | wpc)+
apply (auto simp: obj_at'_def projectKOs tcb_in_cur_domain'_def)
done
lemma possibleSwitchTo_valid_queues[wp]:
"\<lbrace>Invariants_H.valid_queues and valid_objs' and (\<lambda>s. sch_act_wf (ksSchedulerAction s) s) and st_tcb_at' runnable' t\<rbrace>
possibleSwitchTo t
\<lbrace>\<lambda>rv. Invariants_H.valid_queues\<rbrace>"
apply (simp add: possibleSwitchTo_def curDomain_def bitmap_fun_defs)
apply (wp hoare_drop_imps | wpc | simp)+
apply (auto simp: valid_tcb'_def weak_sch_act_wf_def
dest: pred_tcb_at'
elim!: valid_objs_valid_tcbE)
done
lemma possibleSwitchTo_ksQ':
"\<lbrace>(\<lambda>s. t' \<notin> set (ksReadyQueues s p) \<and> sch_act_not t' s) and K(t' \<noteq> t)\<rbrace>
possibleSwitchTo t
\<lbrace>\<lambda>_ s. t' \<notin> set (ksReadyQueues s p)\<rbrace>"
apply (simp add: possibleSwitchTo_def curDomain_def bitmap_fun_defs)
apply (wp static_imp_wp rescheduleRequired_ksQ' tcbSchedEnqueue_ksQ threadGet_wp
| wpc
| simp split del: if_split)+
apply (auto simp: obj_at'_def)
done
lemma possibleSwitchTo_valid_queues'[wp]:
"\<lbrace>valid_queues' and (\<lambda>s. sch_act_wf (ksSchedulerAction s) s)
and st_tcb_at' runnable' t\<rbrace>
possibleSwitchTo t
\<lbrace>\<lambda>rv. valid_queues'\<rbrace>"
apply (simp add: possibleSwitchTo_def curDomain_def bitmap_fun_defs)
apply (wp static_imp_wp threadGet_wp | wpc | simp)+
apply (auto simp: obj_at'_def)
done
crunch st_refs_of'[wp]: possibleSwitchTo "\<lambda>s. P (state_refs_of' s)"
(wp: crunch_wps)
crunch cap_to'[wp]: possibleSwitchTo "ex_nonz_cap_to' p"
(wp: crunch_wps)
crunch objs'[wp]: possibleSwitchTo valid_objs'
(wp: crunch_wps)
crunch ct[wp]: possibleSwitchTo cur_tcb'
(wp: cur_tcb_lift crunch_wps)
lemma possibleSwitchTo_iflive[wp]:
"\<lbrace>if_live_then_nonz_cap' and ex_nonz_cap_to' t
and (\<lambda>s. sch_act_wf (ksSchedulerAction s) s)\<rbrace>
possibleSwitchTo t
\<lbrace>\<lambda>rv. if_live_then_nonz_cap'\<rbrace>"
apply (simp add: possibleSwitchTo_def curDomain_def)
apply (wp | wpc | simp)+
apply (simp only: imp_conv_disj, wp hoare_vcg_all_lift hoare_vcg_disj_lift)
apply (wp threadGet_wp)+
apply (auto simp: obj_at'_def projectKOs)
done
crunches possibleSwitchTo
for ifunsafe[wp]: if_unsafe_then_cap'
and idle'[wp]: valid_idle'
and global_refs'[wp]: valid_global_refs'
and arch_state'[wp]: valid_arch_state'
and irq_node'[wp]: "\<lambda>s. P (irq_node' s)"
and typ_at'[wp]: "\<lambda>s. P (typ_at' T p s)"
and irq_handlers'[wp]: valid_irq_handlers'
and irq_states'[wp]: valid_irq_states'
and pde_mappigns'[wp]: valid_pde_mappings'
(wp: crunch_wps simp: unless_def tcb_cte_cases_def)
crunches sendSignal
for ct'[wp]: "\<lambda>s. P (ksCurThread s)"
and it'[wp]: "\<lambda>s. P (ksIdleThread s)"
(wp: crunch_wps simp: crunch_simps o_def)
context
notes option.case_cong_weak[cong]
begin
crunches sendSignal, setBoundNotification
for irqs_masked'[wp]: "irqs_masked'"
(wp: crunch_wps getObject_inv loadObject_default_inv
simp: crunch_simps unless_def o_def
rule: irqs_masked_lift)
end
lemma sts_running_valid_queues:
"runnable' st \<Longrightarrow> \<lbrace> Invariants_H.valid_queues \<rbrace> setThreadState st t \<lbrace>\<lambda>_. Invariants_H.valid_queues \<rbrace>"
by (wp sts_valid_queues, clarsimp)
lemma ct_in_state_activatable_imp_simple'[simp]:
"ct_in_state' activatable' s \<Longrightarrow> ct_in_state' simple' s"
apply (simp add: ct_in_state'_def)
apply (erule pred_tcb'_weakenE)
apply (case_tac st; simp)
done
lemma setThreadState_nonqueued_state_update:
"\<lbrace>\<lambda>s. invs' s \<and> st_tcb_at' simple' t s
\<and> st \<in> {Inactive, Running, Restart, IdleThreadState}
\<and> (st \<noteq> Inactive \<longrightarrow> ex_nonz_cap_to' t s)
\<and> (t = ksIdleThread s \<longrightarrow> idle' st)
\<and> (\<not> runnable' st \<longrightarrow> sch_act_simple s)
\<and> (\<not> runnable' st \<longrightarrow> (\<forall>p. t \<notin> set (ksReadyQueues s p)))\<rbrace>
setThreadState st t \<lbrace>\<lambda>rv. invs'\<rbrace>"
apply (simp add: invs'_def valid_state'_def)
apply (rule hoare_pre, wp valid_irq_node_lift
sts_valid_queues
setThreadState_ct_not_inQ)
apply (clarsimp simp: pred_tcb_at')
apply (rule conjI, fastforce simp: valid_tcb_state'_def)
apply (drule simple_st_tcb_at_state_refs_ofD')
apply (drule bound_tcb_at_state_refs_ofD')
apply (rule conjI, fastforce)
apply clarsimp
apply (erule delta_sym_refs)
apply (fastforce split: if_split_asm)
apply (fastforce simp: symreftype_inverse' tcb_bound_refs'_def
split: if_split_asm)
done
lemma cteDeleteOne_reply_cap_to'[wp]:
"\<lbrace>ex_nonz_cap_to' p and
cte_wp_at' (\<lambda>c. isReplyCap (cteCap c)) slot\<rbrace>
cteDeleteOne slot
\<lbrace>\<lambda>rv. ex_nonz_cap_to' p\<rbrace>"
apply (simp add: cteDeleteOne_def ex_nonz_cap_to'_def unless_def)
apply (rule hoare_seq_ext [OF _ getCTE_sp])
apply (rule hoare_assume_pre)
apply (subgoal_tac "isReplyCap (cteCap cte)")
apply (wp hoare_vcg_ex_lift emptySlot_cte_wp_cap_other isFinalCapability_inv
| clarsimp simp: finaliseCap_def isCap_simps | simp
| wp (once) hoare_drop_imps)+
apply (fastforce simp: cte_wp_at_ctes_of)
apply (clarsimp simp: cte_wp_at_ctes_of isCap_simps)
done
crunches setupCallerCap, possibleSwitchTo, asUser, doIPCTransfer
for vms'[wp]: "valid_machine_state'"
(wp: crunch_wps simp: zipWithM_x_mapM_x)
crunch nonz_cap_to'[wp]: cancelSignal "ex_nonz_cap_to' p"
(wp: crunch_wps simp: crunch_simps)
lemma cancelIPC_nonz_cap_to'[wp]:
"\<lbrace>ex_nonz_cap_to' p\<rbrace> cancelIPC t \<lbrace>\<lambda>rv. ex_nonz_cap_to' p\<rbrace>"
apply (simp add: cancelIPC_def getThreadReplySlot_def Let_def
capHasProperty_def)
apply (wp threadSet_cap_to'
| wpc
| simp
| clarsimp elim!: cte_wp_at_weakenE'
| rule hoare_post_imp[where Q="\<lambda>rv. ex_nonz_cap_to' p"])+
done
crunches activateIdleThread, getThreadReplySlot, isFinalCapability
for nosch[wp]: "\<lambda>s. P (ksSchedulerAction s)"
(ignore: setNextPC simp: Let_def)
crunches setupCallerCap, asUser, setMRs, doIPCTransfer, possibleSwitchTo
for pspace_domain_valid[wp]: "pspace_domain_valid"
(wp: crunch_wps simp: zipWithM_x_mapM_x)
crunches setupCallerCap, doIPCTransfer, possibleSwitchTo
for ksDomScheduleIdx[wp]: "\<lambda>s. P (ksDomScheduleIdx s)"
(wp: crunch_wps simp: zipWithM_x_mapM)
lemma setThreadState_not_rct[wp]:
"\<lbrace>\<lambda>s. ksSchedulerAction s \<noteq> ResumeCurrentThread \<rbrace>
setThreadState st t
\<lbrace>\<lambda>_ s. ksSchedulerAction s \<noteq> ResumeCurrentThread \<rbrace>"
apply (simp add: setThreadState_def)
apply (wp)
apply (rule hoare_post_imp [OF _ rescheduleRequired_notresume], simp)
apply (simp)
apply (wp)+
apply simp
done
lemma cancelAllIPC_not_rct[wp]:
"\<lbrace>\<lambda>s. ksSchedulerAction s \<noteq> ResumeCurrentThread \<rbrace>
cancelAllIPC epptr
\<lbrace>\<lambda>_ s. ksSchedulerAction s \<noteq> ResumeCurrentThread \<rbrace>"
apply (simp add: cancelAllIPC_def)
apply (wp | wpc)+
apply (rule hoare_post_imp [OF _ rescheduleRequired_notresume], simp)
apply simp
apply (rule mapM_x_wp_inv)
apply (wp)+
apply (rule hoare_post_imp [OF _ rescheduleRequired_notresume], simp)
apply simp
apply (rule mapM_x_wp_inv)
apply (wp)+
apply (wp hoare_vcg_all_lift hoare_drop_imp)
apply (simp_all)
done
lemma cancelAllSignals_not_rct[wp]:
"\<lbrace>\<lambda>s. ksSchedulerAction s \<noteq> ResumeCurrentThread \<rbrace>
cancelAllSignals epptr
\<lbrace>\<lambda>_ s. ksSchedulerAction s \<noteq> ResumeCurrentThread \<rbrace>"
apply (simp add: cancelAllSignals_def)
apply (wp | wpc)+
apply (rule hoare_post_imp [OF _ rescheduleRequired_notresume], simp)
apply simp
apply (rule mapM_x_wp_inv)
apply (wp)+
apply (wp hoare_vcg_all_lift hoare_drop_imp)
apply (simp_all)
done
crunch not_rct[wp]: finaliseCapTrue_standin "\<lambda>s. ksSchedulerAction s \<noteq> ResumeCurrentThread"
(simp: Let_def)
declare setEndpoint_ct' [wp]
lemma cancelIPC_ResumeCurrentThread_imp_notct[wp]:
"\<lbrace>\<lambda>s. ksSchedulerAction s = ResumeCurrentThread \<longrightarrow> ksCurThread s \<noteq> t'\<rbrace>
cancelIPC t
\<lbrace>\<lambda>_ s. ksSchedulerAction s = ResumeCurrentThread \<longrightarrow> ksCurThread s \<noteq> t'\<rbrace>"
(is "\<lbrace>?PRE t'\<rbrace> _ \<lbrace>_\<rbrace>")
proof -
have aipc: "\<And>t t' ntfn.
\<lbrace>\<lambda>s. ksSchedulerAction s = ResumeCurrentThread \<longrightarrow> ksCurThread s \<noteq> t'\<rbrace>
cancelSignal t ntfn
\<lbrace>\<lambda>_ s. ksSchedulerAction s = ResumeCurrentThread \<longrightarrow> ksCurThread s \<noteq> t'\<rbrace>"
apply (simp add: cancelSignal_def)
apply (wp)[1]
apply (wp hoare_convert_imp)+
apply (rule_tac P="\<lambda>s. ksSchedulerAction s \<noteq> ResumeCurrentThread"
in hoare_weaken_pre)
apply (wpc)
apply (wp | simp)+
apply (wpc, wp+)
apply (rule_tac Q="\<lambda>_. ?PRE t'" in hoare_post_imp, clarsimp)
apply (wp)
apply simp
done
have cdo: "\<And>t t' slot.
\<lbrace>\<lambda>s. ksSchedulerAction s = ResumeCurrentThread \<longrightarrow> ksCurThread s \<noteq> t'\<rbrace>
cteDeleteOne slot
\<lbrace>\<lambda>_ s. ksSchedulerAction s = ResumeCurrentThread \<longrightarrow> ksCurThread s \<noteq> t'\<rbrace>"
apply (simp add: cteDeleteOne_def unless_def split_def)
apply (wp)
apply (wp hoare_convert_imp)[1]
apply (wp)
apply (rule_tac Q="\<lambda>_. ?PRE t'" in hoare_post_imp, clarsimp)
apply (wp hoare_convert_imp | simp)+
done
show ?thesis
apply (simp add: cancelIPC_def Let_def)
apply (wp, wpc)
prefer 4 \<comment> \<open>state = Running\<close>
apply wp
prefer 7 \<comment> \<open>state = Restart\<close>
apply wp
apply (wp)+
apply (wp hoare_convert_imp)[1]
apply (wpc, wp+)
apply (rule_tac Q="\<lambda>_. ?PRE t'" in hoare_post_imp, clarsimp)
apply (wp cdo)+
apply (rule_tac Q="\<lambda>_. ?PRE t'" in hoare_post_imp, clarsimp)
apply ((wp aipc hoare_convert_imp)+)[6]
apply (wp)
apply (wp hoare_convert_imp)[1]
apply (wpc, wp+)
apply (rule_tac Q="\<lambda>_. ?PRE t'" in hoare_post_imp, clarsimp)
apply (wp)
apply (rule_tac Q="\<lambda>_. ?PRE t'" in hoare_post_imp, clarsimp)
apply (wp)
apply simp
done
qed
crunch nosch[wp]: setMRs "\<lambda>s. P (ksSchedulerAction s)"
lemma sai_invs'[wp]:
"\<lbrace>invs' and ex_nonz_cap_to' ntfnptr\<rbrace>
sendSignal ntfnptr badge \<lbrace>\<lambda>y. invs'\<rbrace>"
unfolding sendSignal_def
including no_pre
apply (rule hoare_seq_ext[OF _ get_ntfn_sp'])
apply (case_tac "ntfnObj nTFN", simp_all)
prefer 3
apply (rename_tac list)
apply (case_tac list,
simp_all split del: if_split
add: setMessageInfo_def)[1]
apply (rule hoare_pre)
apply (wp hoare_convert_imp [OF asUser_nosch]
hoare_convert_imp [OF setMRs_sch_act])+
apply (clarsimp simp:conj_comms)
apply (simp add: invs'_def valid_state'_def)
apply ((wp valid_irq_node_lift sts_valid_objs' setThreadState_ct_not_inQ
sts_valid_queues [where st="Structures_H.thread_state.Running", simplified]
set_ntfn_valid_objs' cur_tcb_lift sts_st_tcb'
hoare_convert_imp [OF setNotification_nosch]
| simp split del: if_split)+)[3]
apply (intro conjI[rotated];
(solves \<open>clarsimp simp: invs'_def valid_state'_def valid_pspace'_def\<close>)?)
apply clarsimp
apply (clarsimp simp: invs'_def valid_state'_def split del: if_split)
apply (drule(1) ct_not_in_ntfnQueue, simp+)
apply clarsimp
apply (frule ko_at_valid_objs', clarsimp)
apply (simp add: projectKOs)
apply (clarsimp simp: valid_obj'_def valid_ntfn'_def
split: list.splits)
apply (clarsimp simp: invs'_def valid_state'_def)
apply (clarsimp simp: st_tcb_at_refs_of_rev' valid_idle'_def pred_tcb_at'_def idle_tcb'_def
dest!: sym_refs_ko_atD' sym_refs_st_tcb_atD' sym_refs_obj_atD'
split: list.splits)
apply (clarsimp simp: invs'_def valid_state'_def valid_pspace'_def)
apply (frule(1) ko_at_valid_objs')
apply (simp add: projectKOs)
apply (clarsimp simp: valid_obj'_def valid_ntfn'_def
split: list.splits option.splits)
apply (clarsimp elim!: if_live_then_nonz_capE' simp:invs'_def valid_state'_def)
apply (drule(1) sym_refs_ko_atD')
apply (clarsimp elim!: ko_wp_at'_weakenE
intro!: refs_of_live')
apply (clarsimp split del: if_split)+
apply (frule ko_at_valid_objs', clarsimp)
apply (simp add: projectKOs)
apply (clarsimp simp: valid_obj'_def valid_ntfn'_def split del: if_split)
apply (frule invs_sym')
apply (drule(1) sym_refs_obj_atD')
apply (clarsimp split del: if_split cong: if_cong
simp: st_tcb_at_refs_of_rev' ep_redux_simps' ntfn_bound_refs'_def)
apply (frule st_tcb_at_state_refs_ofD')
apply (erule delta_sym_refs)
apply (fastforce simp: split: if_split_asm)
apply (fastforce simp: tcb_bound_refs'_def set_eq_subset symreftype_inverse'
split: if_split_asm)
apply (clarsimp simp:invs'_def)
apply (frule ko_at_valid_objs')
apply (clarsimp simp: valid_pspace'_def valid_state'_def)
apply (simp add: projectKOs)
apply (clarsimp simp: valid_obj'_def valid_ntfn'_def split del: if_split)
apply (clarsimp simp:invs'_def valid_state'_def valid_pspace'_def)
apply (frule(1) ko_at_valid_objs')
apply (simp add: projectKOs)
apply (clarsimp simp: valid_obj'_def valid_ntfn'_def
split: list.splits option.splits)
apply (case_tac "ntfnBoundTCB nTFN", simp_all)
apply (wp set_ntfn_minor_invs')
apply (fastforce simp: valid_ntfn'_def invs'_def valid_state'_def
elim!: obj_at'_weakenE
dest!: global'_no_ex_cap)
apply (wp add: hoare_convert_imp [OF asUser_nosch]
hoare_convert_imp [OF setMRs_sch_act]
setThreadState_nonqueued_state_update sts_st_tcb'
del: cancelIPC_simple)
apply (clarsimp | wp cancelIPC_ct')+
apply (wp set_ntfn_minor_invs' gts_wp' | clarsimp)+
apply (frule pred_tcb_at')
by (wp set_ntfn_minor_invs'
| rule conjI
| clarsimp elim!: st_tcb_ex_cap''
| fastforce simp: receiveBlocked_def projectKOs pred_tcb_at'_def obj_at'_def
dest!: invs_rct_ct_activatable'
split: thread_state.splits
| fastforce simp: invs'_def valid_state'_def receiveBlocked_def projectKOs
valid_obj'_def valid_ntfn'_def
split: thread_state.splits
dest!: global'_no_ex_cap st_tcb_ex_cap'' ko_at_valid_objs')+
lemma replyFromKernel_corres:
"corres dc (tcb_at t and invs) (tcb_at' t and invs')
(reply_from_kernel t r) (replyFromKernel t r)"
apply (case_tac r)
apply (clarsimp simp: replyFromKernel_def reply_from_kernel_def
badge_register_def badgeRegister_def)
apply (rule corres_guard_imp)
apply (rule corres_split_eqr[OF lookupIPCBuffer_corres])
apply (rule corres_split[OF asUser_setRegister_corres])
apply (rule corres_split_eqr[OF setMRs_corres])
apply simp
apply (rule setMessageInfo_corres)
apply (wp hoare_case_option_wp hoare_valid_ipc_buffer_ptr_typ_at'
| clarsimp)+
done
lemma rfk_invs':
"\<lbrace>invs' and tcb_at' t\<rbrace> replyFromKernel t r \<lbrace>\<lambda>rv. invs'\<rbrace>"
apply (simp add: replyFromKernel_def)
apply (cases r)
apply wpsimp
done
crunch nosch[wp]: replyFromKernel "\<lambda>s. P (ksSchedulerAction s)"
lemma completeSignal_corres:
"corres dc (ntfn_at ntfnptr and tcb_at tcb and pspace_aligned and valid_objs
\<comment> \<open>and obj_at (\<lambda>ko. ko = Notification ntfn \<and> Ipc_A.isActive ntfn) ntfnptr*\<close> )
(ntfn_at' ntfnptr and tcb_at' tcb and valid_pspace' and obj_at' isActive ntfnptr)
(complete_signal ntfnptr tcb) (completeSignal ntfnptr tcb)"
apply (simp add: complete_signal_def completeSignal_def)
apply (rule corres_guard_imp)
apply (rule_tac R'="\<lambda>ntfn. ntfn_at' ntfnptr and tcb_at' tcb and valid_pspace'
and valid_ntfn' ntfn and (\<lambda>_. isActive ntfn)"
in corres_split[OF getNotification_corres])
apply (rule corres_gen_asm2)
apply (case_tac "ntfn_obj rv")
apply (clarsimp simp: ntfn_relation_def isActive_def
split: ntfn.splits Structures_H.notification.splits)+
apply (rule corres_guard2_imp)
apply (simp add: badgeRegister_def badge_register_def)
apply (rule corres_split[OF asUser_setRegister_corres setNotification_corres])
apply (clarsimp simp: ntfn_relation_def)
apply (wp set_simple_ko_valid_objs get_simple_ko_wp getNotification_wp | clarsimp simp: valid_ntfn'_def)+
apply (clarsimp simp: valid_pspace'_def)
apply (frule_tac P="(\<lambda>k. k = ntfn)" in obj_at_valid_objs', assumption)
apply (clarsimp simp: projectKOs valid_obj'_def valid_ntfn'_def obj_at'_def)
done
lemma doNBRecvFailedTransfer_corres:
"corres dc (tcb_at thread)
(tcb_at' thread)
(do_nbrecv_failed_transfer thread)
(doNBRecvFailedTransfer thread)"
unfolding do_nbrecv_failed_transfer_def doNBRecvFailedTransfer_def
by (simp add: badgeRegister_def badge_register_def, rule asUser_setRegister_corres)
lemma receiveIPC_corres:
assumes "is_ep_cap cap" and "cap_relation cap cap'"
shows "
corres dc (einvs and valid_sched and tcb_at thread and valid_cap cap and ex_nonz_cap_to thread
and cte_wp_at (\<lambda>c. c = cap.NullCap) (thread, tcb_cnode_index 3))
(invs' and tcb_at' thread and valid_cap' cap')
(receive_ipc thread cap isBlocking) (receiveIPC thread cap' isBlocking)"
apply (insert assms)
apply (simp add: receive_ipc_def receiveIPC_def
split del: if_split)
apply (case_tac cap, simp_all add: isEndpointCap_def)
apply (rename_tac word1 word2 right)
apply clarsimp
apply (rule corres_guard_imp)
apply (rule corres_split[OF getEndpoint_corres])
apply (rule corres_guard_imp)
apply (rule corres_split[OF getBoundNotification_corres])
apply (rule_tac r'="ntfn_relation" in corres_split)
apply (rule corres_option_split[rotated 2])
apply (rule getNotification_corres)
apply clarsimp
apply (rule corres_trivial, simp add: ntfn_relation_def default_notification_def
default_ntfn_def)
apply (rule corres_if)
apply (clarsimp simp: ntfn_relation_def Ipc_A.isActive_def Endpoint_H.isActive_def
split: Structures_A.ntfn.splits Structures_H.notification.splits)
apply clarsimp
apply (rule completeSignal_corres)
apply (rule_tac P="einvs and valid_sched and tcb_at thread and
ep_at word1 and valid_ep ep and
obj_at (\<lambda>k. k = Endpoint ep) word1
and cte_wp_at (\<lambda>c. c = cap.NullCap) (thread, tcb_cnode_index 3)
and ex_nonz_cap_to thread" and
P'="invs' and tcb_at' thread and ep_at' word1 and
valid_ep' epa"
in corres_inst)
apply (case_tac ep)
\<comment> \<open>IdleEP\<close>
apply (simp add: ep_relation_def)
apply (rule corres_guard_imp)
apply (case_tac isBlocking; simp)
apply (rule corres_split[OF setThreadState_corres])
apply simp
apply (rule setEndpoint_corres)
apply (simp add: ep_relation_def)
apply wp+
apply (rule corres_guard_imp, rule doNBRecvFailedTransfer_corres, simp)
apply simp
apply (clarsimp simp add: invs_def valid_state_def valid_pspace_def
valid_tcb_state_def st_tcb_at_tcb_at)
apply auto[1]
\<comment> \<open>SendEP\<close>
apply (simp add: ep_relation_def)
apply (rename_tac list)
apply (rule_tac F="list \<noteq> []" in corres_req)
apply (clarsimp simp: valid_ep_def)
apply (case_tac list, simp_all split del: if_split)[1]
apply (rule corres_guard_imp)
apply (rule corres_split[OF setEndpoint_corres])
apply (case_tac lista, simp_all add: ep_relation_def)[1]
apply (rule corres_split[OF getThreadState_corres])
apply (rule_tac
F="\<exists>data.
sender_state =
Structures_A.thread_state.BlockedOnSend word1 data"
in corres_gen_asm)
apply (clarsimp simp: isSend_def case_bool_If
case_option_If if3_fold
split del: if_split cong: if_cong)
apply (rule corres_split[OF doIPCTransfer_corres])
apply (simp split del: if_split cong: if_cong)
apply (fold dc_def)[1]
apply (rule_tac P="valid_objs and valid_mdb and valid_list
and valid_sched
and cur_tcb
and valid_reply_caps
and pspace_aligned and pspace_distinct
and st_tcb_at (Not \<circ> awaiting_reply) a
and st_tcb_at (Not \<circ> halted) a
and tcb_at thread and valid_reply_masters
and cte_wp_at (\<lambda>c. c = cap.NullCap)
(thread, tcb_cnode_index 3)"
and P'="tcb_at' a and tcb_at' thread and cur_tcb'
and Invariants_H.valid_queues
and valid_queues'
and valid_pspace'
and valid_objs'
and (\<lambda>s. weak_sch_act_wf (ksSchedulerAction s) s)"
in corres_guard_imp [OF corres_if])
apply (simp add: fault_rel_optionation_def)
apply (rule corres_if2 [OF _ setupCallerCap_corres setThreadState_corres])
apply simp
apply simp
apply (rule corres_split[OF setThreadState_corres])
apply simp
apply (rule possibleSwitchTo_corres)
apply (wp sts_st_tcb_at' set_thread_state_runnable_weak_valid_sched_action
| simp)+
apply (wp sts_st_tcb_at'_cases sts_valid_queues setThreadState_valid_queues'
setThreadState_st_tcb
| simp)+
apply (clarsimp simp: st_tcb_at_tcb_at st_tcb_def2 valid_sched_def
valid_sched_action_def)
apply (clarsimp split: if_split_asm)
apply (clarsimp | wp do_ipc_transfer_tcb_caps)+
apply (rule_tac Q="\<lambda>_ s. sch_act_wf (ksSchedulerAction s) s"
in hoare_post_imp, erule sch_act_wf_weak)
apply (wp sts_st_tcb' gts_st_tcb_at | simp)+
apply (simp cong: list.case_cong)
apply wp
apply simp
apply (wp weak_sch_act_wf_lift_linear setEndpoint_valid_mdb' set_ep_valid_objs')
apply (clarsimp split: list.split)
apply (clarsimp simp add: invs_def valid_state_def st_tcb_at_tcb_at)
apply (clarsimp simp add: valid_ep_def valid_pspace_def)
apply (drule(1) sym_refs_obj_atD[where P="\<lambda>ko. ko = Endpoint e" for e])
apply (fastforce simp: st_tcb_at_refs_of_rev elim: st_tcb_weakenE)
apply (auto simp: valid_ep'_def invs'_def valid_state'_def split: list.split)[1]
\<comment> \<open>RecvEP\<close>
apply (simp add: ep_relation_def)
apply (rule_tac corres_guard_imp)
apply (case_tac isBlocking; simp)
apply (rule corres_split[OF setThreadState_corres])
apply simp
apply (rule setEndpoint_corres)
apply (simp add: ep_relation_def)
apply wp+
apply (rule corres_guard_imp, rule doNBRecvFailedTransfer_corres, simp)
apply simp
apply (clarsimp simp: valid_tcb_state_def)
apply (clarsimp simp add: valid_tcb_state'_def)
apply (wp get_simple_ko_wp[where f=Notification] getNotification_wp gbn_wp gbn_wp'
hoare_vcg_all_lift hoare_vcg_imp_lift hoare_vcg_if_lift
| wpc | simp add: ep_at_def2[symmetric, simplified] | clarsimp)+
apply (clarsimp simp: valid_cap_def invs_psp_aligned invs_valid_objs pred_tcb_at_def
valid_obj_def valid_tcb_def valid_bound_ntfn_def
dest!: invs_valid_objs
elim!: obj_at_valid_objsE
split: option.splits)
apply (auto simp: valid_cap'_def invs_valid_pspace' valid_obj'_def valid_tcb'_def
valid_bound_ntfn'_def obj_at'_def projectKOs pred_tcb_at'_def
dest!: invs_valid_objs' obj_at_valid_objs'
split: option.splits)
done
lemma receiveSignal_corres:
"\<lbrakk> is_ntfn_cap cap; cap_relation cap cap' \<rbrakk> \<Longrightarrow>
corres dc (invs and st_tcb_at active thread and valid_cap cap and ex_nonz_cap_to thread)
(invs' and tcb_at' thread and valid_cap' cap')
(receive_signal thread cap isBlocking) (receiveSignal thread cap' isBlocking)"
apply (simp add: receive_signal_def receiveSignal_def)
apply (case_tac cap, simp_all add: isEndpointCap_def)
apply (rename_tac word1 word2 rights)
apply (rule corres_guard_imp)
apply (rule_tac R="\<lambda>rv. invs and tcb_at thread and st_tcb_at active thread and
ntfn_at word1 and ex_nonz_cap_to thread and
valid_ntfn rv and
obj_at (\<lambda>k. k = Notification rv) word1" and
R'="\<lambda>rv'. invs' and tcb_at' thread and ntfn_at' word1 and
valid_ntfn' rv'"
in corres_split[OF getNotification_corres])
apply clarsimp
apply (case_tac "ntfn_obj rv")
\<comment> \<open>IdleNtfn\<close>
apply (simp add: ntfn_relation_def)
apply (rule corres_guard_imp)
apply (case_tac isBlocking; simp)
apply (rule corres_split[OF setThreadState_corres])
apply simp
apply (rule setNotification_corres)
apply (simp add: ntfn_relation_def)
apply wp+
apply (rule corres_guard_imp, rule doNBRecvFailedTransfer_corres, simp+)
\<comment> \<open>WaitingNtfn\<close>
apply (simp add: ntfn_relation_def)
apply (rule corres_guard_imp)
apply (case_tac isBlocking; simp)
apply (rule corres_split[OF setThreadState_corres])
apply simp
apply (rule setNotification_corres)
apply (simp add: ntfn_relation_def)
apply wp+
apply (rule corres_guard_imp)
apply (rule doNBRecvFailedTransfer_corres, simp+)
\<comment> \<open>ActiveNtfn\<close>
apply (simp add: ntfn_relation_def)
apply (rule corres_guard_imp)
apply (simp add: badgeRegister_def badge_register_def)
apply (rule corres_split[OF asUser_setRegister_corres])
apply (rule setNotification_corres)
apply (simp add: ntfn_relation_def)
apply wp+
apply (fastforce simp: invs_def valid_state_def valid_pspace_def
elim!: st_tcb_weakenE)
apply (clarsimp simp: invs'_def valid_state'_def valid_pspace'_def)
apply wp+
apply (clarsimp simp add: ntfn_at_def2 valid_cap_def st_tcb_at_tcb_at)
apply (clarsimp simp add: valid_cap'_def)
done
lemma tg_sp':
"\<lbrace>P\<rbrace> threadGet f p \<lbrace>\<lambda>t. obj_at' (\<lambda>t'. f t' = t) p and P\<rbrace>"
including no_pre
apply (simp add: threadGet_def)
apply wp
apply (rule hoare_strengthen_post)
apply (rule getObject_tcb_sp)
apply clarsimp
apply (erule obj_at'_weakenE)
apply simp
done
declare lookup_cap_valid' [wp]
lemma sendFaultIPC_corres:
"valid_fault f \<Longrightarrow> fr f f' \<Longrightarrow>
corres (fr \<oplus> dc)
(einvs and st_tcb_at active thread and ex_nonz_cap_to thread)
(invs' and sch_act_not thread and tcb_at' thread)
(send_fault_ipc thread f) (sendFaultIPC thread f')"
apply (simp add: send_fault_ipc_def sendFaultIPC_def
liftE_bindE Let_def)
apply (rule corres_guard_imp)
apply (rule corres_split [where r'="\<lambda>fh fh'. fh = to_bl fh'"])
apply (rule threadGet_corres)
apply (simp add: tcb_relation_def)
apply simp
apply (rule corres_splitEE)
apply (rule corres_cap_fault)
apply (rule lookup_cap_corres, rule refl)
apply (rule_tac P="einvs and st_tcb_at active thread
and valid_cap handler_cap and ex_nonz_cap_to thread"
and P'="invs' and tcb_at' thread and sch_act_not thread
and valid_cap' handlerCap"
in corres_inst)
apply (case_tac handler_cap,
simp_all add: isCap_defs lookup_failure_map_def
case_bool_If If_rearrage
split del: if_split cong: if_cong)[1]
apply (rule corres_guard_imp)
apply (rule corres_if2 [OF refl])
apply (simp add: dc_def[symmetric])
apply (rule corres_split[OF threadset_corres sendIPC_corres], simp_all)[1]
apply (simp add: tcb_relation_def fault_rel_optionation_def exst_same_def)+
apply (wp thread_set_invs_trivial thread_set_no_change_tcb_state
thread_set_typ_at ep_at_typ_at ex_nonz_cap_to_pres
thread_set_cte_wp_at_trivial thread_set_not_state_valid_sched
| simp add: tcb_cap_cases_def)+
apply ((wp threadSet_invs_trivial threadSet_tcb'
| simp add: tcb_cte_cases_def
| wp (once) sch_act_sane_lift)+)[1]
apply (rule corres_trivial, simp add: lookup_failure_map_def)
apply (clarsimp simp: st_tcb_at_tcb_at split: if_split)
apply (simp add: valid_cap_def)
apply (clarsimp simp: valid_cap'_def inQ_def)
apply auto[1]
apply (clarsimp simp: lookup_failure_map_def)
apply wp+
apply (fastforce elim: st_tcb_at_tcb_at)
apply fastforce
done
lemma gets_the_noop_corres:
assumes P: "\<And>s. P s \<Longrightarrow> f s \<noteq> None"
shows "corres dc P P' (gets_the f) (return x)"
apply (clarsimp simp: corres_underlying_def gets_the_def
return_def gets_def bind_def get_def)
apply (clarsimp simp: assert_opt_def return_def dest!: P)
done
lemma handleDoubleFault_corres:
"corres dc (tcb_at thread)
(tcb_at' thread and (\<lambda>s. weak_sch_act_wf (ksSchedulerAction s) s))
(handle_double_fault thread f ft)
(handleDoubleFault thread f' ft')"
apply (simp add: handle_double_fault_def handleDoubleFault_def)
apply (rule corres_guard_imp)
apply (subst bind_return [symmetric],
rule corres_underlying_split [OF setThreadState_corres])
apply simp
apply (rule corres_noop2)
apply (simp add: exs_valid_def return_def)
apply (rule hoare_eq_P)
apply wp
apply (rule asUser_inv)
apply (rule getRestartPC_inv)
apply (wp no_fail_getRestartPC)+
apply (wp|simp)+
done
crunch tcb' [wp]: sendFaultIPC "tcb_at' t" (wp: crunch_wps)
crunch typ_at'[wp]: receiveIPC "\<lambda>s. P (typ_at' T p s)"
(wp: crunch_wps)
lemmas receiveIPC_typ_ats[wp] = typ_at_lifts [OF receiveIPC_typ_at']
crunch typ_at'[wp]: receiveSignal "\<lambda>s. P (typ_at' T p s)"
(wp: crunch_wps)
lemmas receiveAIPC_typ_ats[wp] = typ_at_lifts [OF receiveSignal_typ_at']
declare cart_singleton_empty[simp]
declare cart_singleton_empty2[simp]
crunch aligned'[wp]: setupCallerCap "pspace_aligned'"
(wp: crunch_wps)
crunch distinct'[wp]: setupCallerCap "pspace_distinct'"
(wp: crunch_wps)
crunch cur_tcb[wp]: setupCallerCap "cur_tcb'"
(wp: crunch_wps)
lemma setupCallerCap_state_refs_of[wp]:
"\<lbrace>\<lambda>s. P ((state_refs_of' s) (sender := {r \<in> state_refs_of' s sender. snd r = TCBBound}))\<rbrace>
setupCallerCap sender rcvr grant
\<lbrace>\<lambda>rv s. P (state_refs_of' s)\<rbrace>"
apply (simp add: setupCallerCap_def getThreadCallerSlot_def
getThreadReplySlot_def)
apply (wp hoare_drop_imps)
apply (simp add: fun_upd_def cong: if_cong)
done
crunch sch_act_wf: setupCallerCap
"\<lambda>s. sch_act_wf (ksSchedulerAction s) s"
(wp: crunch_wps ssa_sch_act sts_sch_act rule: sch_act_wf_lift)
lemma setCTE_valid_queues[wp]:
"\<lbrace>Invariants_H.valid_queues\<rbrace> setCTE ptr val \<lbrace>\<lambda>rv. Invariants_H.valid_queues\<rbrace>"
by (wp valid_queues_lift setCTE_pred_tcb_at')
crunch vq[wp]: cteInsert "Invariants_H.valid_queues"
(wp: crunch_wps)
crunch vq[wp]: getThreadCallerSlot "Invariants_H.valid_queues"
(wp: crunch_wps)
crunch vq[wp]: getThreadReplySlot "Invariants_H.valid_queues"
(wp: crunch_wps)
lemma setupCallerCap_vq[wp]:
"\<lbrace>Invariants_H.valid_queues and (\<lambda>s. \<forall>p. send \<notin> set (ksReadyQueues s p))\<rbrace>
setupCallerCap send recv grant \<lbrace>\<lambda>_. Invariants_H.valid_queues\<rbrace>"
apply (simp add: setupCallerCap_def)
apply (wp crunch_wps sts_valid_queues)
apply (fastforce simp: valid_queues_def obj_at'_def inQ_def)
done
crunch vq'[wp]: setupCallerCap "valid_queues'"
(wp: crunch_wps)
lemma is_derived_ReplyCap' [simp]:
"\<And>m p g. is_derived' m p (capability.ReplyCap t False g) =
(\<lambda>c. \<exists> g. c = capability.ReplyCap t True g)"
apply (subst fun_eq_iff)
apply clarsimp
apply (case_tac x, simp_all add: is_derived'_def isCap_simps
badge_derived'_def
vsCapRef_def)
done
lemma unique_master_reply_cap':
"\<And>c t. isReplyCap c \<and> capReplyMaster c \<and> capTCBPtr c = t \<longleftrightarrow>
(\<exists>g . c = capability.ReplyCap t True g)"
by (fastforce simp: isCap_simps conj_comms)
lemma getSlotCap_cte_wp_at:
"\<lbrace>\<top>\<rbrace> getSlotCap sl \<lbrace>\<lambda>rv. cte_wp_at' (\<lambda>c. cteCap c = rv) sl\<rbrace>"
apply (simp add: getSlotCap_def)
apply (wp getCTE_wp)
apply (clarsimp simp: cte_wp_at_ctes_of)
done
crunch no_0_obj'[wp]: setThreadState no_0_obj'
lemma setupCallerCap_vp[wp]:
"\<lbrace>valid_pspace' and tcb_at' sender and tcb_at' rcvr\<rbrace>
setupCallerCap sender rcvr grant \<lbrace>\<lambda>rv. valid_pspace'\<rbrace>"
apply (simp add: valid_pspace'_def setupCallerCap_def getThreadCallerSlot_def
getThreadReplySlot_def locateSlot_conv getSlotCap_def)
apply (wp getCTE_wp)
apply (rule_tac Q="\<lambda>_. valid_pspace' and
tcb_at' sender and tcb_at' rcvr"
in hoare_post_imp)
apply (clarsimp simp: valid_cap'_def o_def cte_wp_at_ctes_of isCap_simps
valid_pspace'_def)
apply (frule(1) ctes_of_valid', simp add: valid_cap'_def capAligned_def)
apply clarsimp
apply (wp | simp add: valid_pspace'_def valid_tcb_state'_def)+
done
declare haskell_assert_inv[wp del]
lemma setupCallerCap_iflive[wp]:
"\<lbrace>if_live_then_nonz_cap' and ex_nonz_cap_to' sender\<rbrace>
setupCallerCap sender rcvr grant
\<lbrace>\<lambda>rv. if_live_then_nonz_cap'\<rbrace>"
unfolding setupCallerCap_def getThreadCallerSlot_def
getThreadReplySlot_def locateSlot_conv
by (wp getSlotCap_cte_wp_at
| simp add: unique_master_reply_cap'
| strengthen eq_imp_strg
| wp (once) hoare_drop_imp[where f="getCTE rs" for rs])+
lemma setupCallerCap_ifunsafe[wp]:
"\<lbrace>if_unsafe_then_cap' and valid_objs' and
ex_nonz_cap_to' rcvr and tcb_at' rcvr\<rbrace>
setupCallerCap sender rcvr grant
\<lbrace>\<lambda>rv. if_unsafe_then_cap'\<rbrace>"
unfolding setupCallerCap_def getThreadCallerSlot_def
getThreadReplySlot_def locateSlot_conv
apply (wp getSlotCap_cte_wp_at
| simp add: unique_master_reply_cap' | strengthen eq_imp_strg
| wp (once) hoare_drop_imp[where f="getCTE rs" for rs])+
apply (rule_tac Q="\<lambda>rv. valid_objs' and tcb_at' rcvr and ex_nonz_cap_to' rcvr"
in hoare_post_imp)
apply (clarsimp simp: ex_nonz_tcb_cte_caps' tcbCallerSlot_def
objBits_def objBitsKO_def dom_def cte_level_bits_def)
apply (wp sts_valid_objs' | simp)+
apply (clarsimp simp: valid_tcb_state'_def)+
done
lemma setupCallerCap_global_refs'[wp]:
"\<lbrace>valid_global_refs'\<rbrace>
setupCallerCap sender rcvr grant
\<lbrace>\<lambda>rv. valid_global_refs'\<rbrace>"
unfolding setupCallerCap_def getThreadCallerSlot_def
getThreadReplySlot_def locateSlot_conv
apply (wp getSlotCap_cte_wp_at
| simp add: o_def unique_master_reply_cap'
| strengthen eq_imp_strg
| wp (once) getCTE_wp | clarsimp simp: cte_wp_at_ctes_of)+
(* at setThreadState *)
apply (rule_tac Q="\<lambda>_. valid_global_refs'" in hoare_post_imp, wpsimp+)
done
crunch valid_arch'[wp]: setupCallerCap "valid_arch_state'"
(wp: hoare_drop_imps)
crunch typ'[wp]: setupCallerCap "\<lambda>s. P (typ_at' T p s)"
crunch irq_node'[wp]: setupCallerCap "\<lambda>s. P (irq_node' s)"
(wp: hoare_drop_imps)
lemma setupCallerCap_irq_handlers'[wp]:
"\<lbrace>valid_irq_handlers'\<rbrace>
setupCallerCap sender rcvr grant
\<lbrace>\<lambda>rv. valid_irq_handlers'\<rbrace>"
unfolding setupCallerCap_def getThreadCallerSlot_def
getThreadReplySlot_def locateSlot_conv
by (wp hoare_drop_imps | simp)+
lemma cteInsert_cap_to':
"\<lbrace>ex_nonz_cap_to' p and cte_wp_at' (\<lambda>c. cteCap c = NullCap) dest\<rbrace>
cteInsert cap src dest
\<lbrace>\<lambda>rv. ex_nonz_cap_to' p\<rbrace>"
apply (simp add: cteInsert_def ex_nonz_cap_to'_def
updateCap_def setUntypedCapAsFull_def
split del: if_split)
apply (rule hoare_pre, rule hoare_vcg_ex_lift)
apply (wp updateMDB_weak_cte_wp_at
setCTE_weak_cte_wp_at
| simp
| rule hoare_drop_imps)+
apply (wp getCTE_wp)
apply clarsimp
apply (rule_tac x=cref in exI)
apply (rule conjI)
apply (clarsimp simp: cte_wp_at_ctes_of)+
done
crunch cap_to'[wp]: setExtraBadge "ex_nonz_cap_to' p"
crunch cap_to'[wp]: doIPCTransfer "ex_nonz_cap_to' p"
(ignore: transferCapsToSlots
wp: crunch_wps transferCapsToSlots_pres2 cteInsert_cap_to' hoare_vcg_const_Ball_lift
simp: zipWithM_x_mapM ball_conj_distrib)
lemma st_tcb_idle':
"\<lbrakk>valid_idle' s; st_tcb_at' P t s\<rbrakk> \<Longrightarrow>
(t = ksIdleThread s) \<longrightarrow> P IdleThreadState"
by (clarsimp simp: valid_idle'_def pred_tcb_at'_def obj_at'_def idle_tcb'_def)
crunch idle'[wp]: getThreadCallerSlot "valid_idle'"
crunch idle'[wp]: getThreadReplySlot "valid_idle'"
crunch it[wp]: setupCallerCap "\<lambda>s. P (ksIdleThread s)"
(simp: updateObject_cte_inv wp: crunch_wps)
lemma setupCallerCap_idle'[wp]:
"\<lbrace>valid_idle' and valid_pspace' and
(\<lambda>s. st \<noteq> ksIdleThread s \<and> rt \<noteq> ksIdleThread s)\<rbrace>
setupCallerCap st rt gr
\<lbrace>\<lambda>_. valid_idle'\<rbrace>"
by (simp add: setupCallerCap_def capRange_def | wp hoare_drop_imps)+
crunch idle'[wp]: doIPCTransfer "valid_idle'"
(wp: crunch_wps simp: crunch_simps ignore: transferCapsToSlots)
crunch it[wp]: setExtraBadge "\<lambda>s. P (ksIdleThread s)"
crunch it[wp]: receiveIPC "\<lambda>s. P (ksIdleThread s)"
(ignore: transferCapsToSlots
wp: transferCapsToSlots_pres2 crunch_wps hoare_vcg_const_Ball_lift
simp: crunch_simps ball_conj_distrib)
crunch irq_states' [wp]: setupCallerCap valid_irq_states'
(wp: crunch_wps)
crunch pde_mappings' [wp]: setupCallerCap valid_pde_mappings'
(wp: crunch_wps)
crunch irqs_masked' [wp]: receiveIPC "irqs_masked'"
(wp: crunch_wps rule: irqs_masked_lift)
crunch ct_not_inQ[wp]: getThreadCallerSlot "ct_not_inQ"
crunch ct_not_inQ[wp]: getThreadReplySlot "ct_not_inQ"
lemma setupCallerCap_ct_not_inQ[wp]:
"\<lbrace>ct_not_inQ\<rbrace> setupCallerCap sender receiver grant \<lbrace>\<lambda>_. ct_not_inQ\<rbrace>"
apply (simp add: setupCallerCap_def)
apply (wp hoare_drop_imp setThreadState_ct_not_inQ)
done
crunch ksQ'[wp]: copyMRs "\<lambda>s. P (ksReadyQueues s)"
(wp: mapM_wp' hoare_drop_imps simp: crunch_simps)
crunch ksQ[wp]: doIPCTransfer "\<lambda>s. P (ksReadyQueues s)"
(wp: hoare_drop_imps hoare_vcg_split_case_option
mapM_wp'
simp: split_def zipWithM_x_mapM)
crunch ct'[wp]: doIPCTransfer "\<lambda>s. P (ksCurThread s)"
(wp: hoare_drop_imps hoare_vcg_split_case_option
mapM_wp'
simp: split_def zipWithM_x_mapM)
lemma asUser_ct_not_inQ[wp]:
"\<lbrace>ct_not_inQ\<rbrace> asUser t m \<lbrace>\<lambda>rv. ct_not_inQ\<rbrace>"
apply (simp add: asUser_def split_def)
apply (wp hoare_drop_imps threadSet_not_inQ | simp)+
done
crunch ct_not_inQ[wp]: copyMRs "ct_not_inQ"
(wp: mapM_wp' hoare_drop_imps simp: crunch_simps)
crunch ct_not_inQ[wp]: doIPCTransfer "ct_not_inQ"
(ignore: getRestartPC setRegister transferCapsToSlots
wp: hoare_drop_imps hoare_vcg_split_case_option
mapM_wp'
simp: split_def zipWithM_x_mapM)
lemma ntfn_q_refs_no_bound_refs': "rf : ntfn_q_refs_of' (ntfnObj ob) \<Longrightarrow> rf ~: ntfn_bound_refs' (ntfnBoundTCB ob')"
by (auto simp add: ntfn_q_refs_of'_def ntfn_bound_refs'_def
split: Structures_H.ntfn.splits)
lemma completeSignal_invs:
"\<lbrace>invs' and tcb_at' tcb\<rbrace>
completeSignal ntfnptr tcb
\<lbrace>\<lambda>_. invs'\<rbrace>"
apply (simp add: completeSignal_def)
apply (rule hoare_seq_ext[OF _ get_ntfn_sp'])
apply (rule hoare_pre)
apply (wp set_ntfn_minor_invs' | wpc | simp)+
apply (rule_tac Q="\<lambda>_ s. (state_refs_of' s ntfnptr = ntfn_bound_refs' (ntfnBoundTCB ntfn))
\<and> ntfn_at' ntfnptr s
\<and> valid_ntfn' (ntfnObj_update (\<lambda>_. Structures_H.ntfn.IdleNtfn) ntfn) s
\<and> ((\<exists>y. ntfnBoundTCB ntfn = Some y) \<longrightarrow> ex_nonz_cap_to' ntfnptr s)
\<and> ntfnptr \<noteq> ksIdleThread s"
in hoare_strengthen_post)
apply ((wp hoare_vcg_ex_lift static_imp_wp | wpc | simp add: valid_ntfn'_def)+)[1]
apply (clarsimp simp: obj_at'_def state_refs_of'_def typ_at'_def ko_wp_at'_def projectKOs split: option.splits)
apply (blast dest: ntfn_q_refs_no_bound_refs')
apply wp
apply (subgoal_tac "valid_ntfn' ntfn s")
apply (subgoal_tac "ntfnptr \<noteq> ksIdleThread s")
apply (fastforce simp: valid_ntfn'_def valid_bound_tcb'_def projectKOs ko_at_state_refs_ofD'
elim: obj_at'_weakenE
if_live_then_nonz_capD'[OF invs_iflive'
obj_at'_real_def[THEN meta_eq_to_obj_eq,
THEN iffD1]])
apply (fastforce simp: valid_idle'_def pred_tcb_at'_def obj_at'_def projectKOs
dest!: invs_valid_idle')
apply (fastforce dest: invs_valid_objs' ko_at_valid_objs'
simp: valid_obj'_def projectKOs)[1]
done
lemma setupCallerCap_urz[wp]:
"\<lbrace>untyped_ranges_zero' and valid_pspace' and tcb_at' sender\<rbrace>
setupCallerCap sender t g \<lbrace>\<lambda>rv. untyped_ranges_zero'\<rbrace>"
apply (simp add: setupCallerCap_def getSlotCap_def
getThreadCallerSlot_def getThreadReplySlot_def
locateSlot_conv)
apply (wp getCTE_wp')
apply (rule_tac Q="\<lambda>_. untyped_ranges_zero' and valid_mdb' and valid_objs'" in hoare_post_imp)
apply (clarsimp simp: cte_wp_at_ctes_of cteCaps_of_def untyped_derived_eq_def
isCap_simps)
apply (wp sts_valid_pspace_hangers)
apply (clarsimp simp: valid_tcb_state'_def)
done
lemmas threadSet_urz = untyped_ranges_zero_lift[where f="cteCaps_of", OF _ threadSet_cteCaps_of]
crunch urz[wp]: doIPCTransfer "untyped_ranges_zero'"
(ignore: threadSet wp: threadSet_urz crunch_wps simp: zipWithM_x_mapM)
crunch gsUntypedZeroRanges[wp]: receiveIPC "\<lambda>s. P (gsUntypedZeroRanges s)"
(wp: crunch_wps transferCapsToSlots_pres1 simp: zipWithM_x_mapM ignore: constOnFailure)
crunch ctes_of[wp]: possibleSwitchTo "\<lambda>s. P (ctes_of s)"
(wp: crunch_wps ignore: constOnFailure)
lemmas possibleSwitchToTo_cteCaps_of[wp]
= cteCaps_of_ctes_of_lift[OF possibleSwitchTo_ctes_of]
(* t = ksCurThread s *)
lemma ri_invs' [wp]:
"\<lbrace>invs' and sch_act_not t
and ct_in_state' simple'
and st_tcb_at' simple' t
and (\<lambda>s. \<forall>p. t \<notin> set (ksReadyQueues s p))
and ex_nonz_cap_to' t
and (\<lambda>s. \<forall>r \<in> zobj_refs' cap. ex_nonz_cap_to' r s)\<rbrace>
receiveIPC t cap isBlocking
\<lbrace>\<lambda>_. invs'\<rbrace>" (is "\<lbrace>?pre\<rbrace> _ \<lbrace>_\<rbrace>")
apply (clarsimp simp: receiveIPC_def)
apply (rule hoare_seq_ext [OF _ get_ep_sp'])
apply (rule hoare_seq_ext [OF _ gbn_sp'])
apply (rule hoare_seq_ext)
(* set up precondition for old proof *)
apply (rule_tac R="ko_at' ep (capEPPtr cap) and ?pre" in hoare_vcg_if_split)
apply (wp completeSignal_invs)
apply (case_tac ep)
\<comment> \<open>endpoint = RecvEP\<close>
apply (simp add: invs'_def valid_state'_def)
apply (rule hoare_pre, wpc, wp valid_irq_node_lift)
apply (simp add: valid_ep'_def)
apply (wp sts_sch_act' hoare_vcg_const_Ball_lift valid_irq_node_lift
sts_valid_queues setThreadState_ct_not_inQ
asUser_urz
| simp add: doNBRecvFailedTransfer_def cteCaps_of_def)+
apply (clarsimp simp: valid_tcb_state'_def pred_tcb_at' o_def)
apply (rule conjI, clarsimp elim!: obj_at'_weakenE)
apply (frule obj_at_valid_objs')
apply (clarsimp simp: valid_pspace'_def)
apply (drule(1) sym_refs_ko_atD')
apply (drule simple_st_tcb_at_state_refs_ofD')
apply (drule bound_tcb_at_state_refs_ofD')
apply (clarsimp simp: st_tcb_at_refs_of_rev' valid_ep'_def
valid_obj'_def projectKOs tcb_bound_refs'_def
dest!: isCapDs)
apply (rule conjI, clarsimp)
apply (drule (1) bspec)
apply (clarsimp dest!: st_tcb_at_state_refs_ofD')
apply (clarsimp simp: set_eq_subset)
apply (rule conjI, erule delta_sym_refs)
apply (clarsimp split: if_split_asm)
apply (rename_tac list one two three fur five six seven eight nine ten eleven)
apply (subgoal_tac "set list \<times> {EPRecv} \<noteq> {}")
apply (thin_tac "\<forall>a b. t \<notin> set (ksReadyQueues one (a, b))") \<comment> \<open>causes slowdown\<close>
apply (safe ; solves \<open>auto\<close>)
apply fastforce
apply fastforce
apply (clarsimp split: if_split_asm)
apply (fastforce simp: valid_pspace'_def global'_no_ex_cap idle'_not_queued)
\<comment> \<open>endpoint = IdleEP\<close>
apply (simp add: invs'_def valid_state'_def)
apply (rule hoare_pre, wpc, wp valid_irq_node_lift)
apply (simp add: valid_ep'_def)
apply (wp sts_sch_act' valid_irq_node_lift
sts_valid_queues setThreadState_ct_not_inQ
asUser_urz
| simp add: doNBRecvFailedTransfer_def cteCaps_of_def)+
apply (clarsimp simp: pred_tcb_at' valid_tcb_state'_def o_def)
apply (rule conjI, clarsimp elim!: obj_at'_weakenE)
apply (subgoal_tac "t \<noteq> capEPPtr cap")
apply (drule simple_st_tcb_at_state_refs_ofD')
apply (drule ko_at_state_refs_ofD')
apply (drule bound_tcb_at_state_refs_ofD')
apply (clarsimp dest!: isCapDs)
apply (rule conjI, erule delta_sym_refs)
apply (clarsimp split: if_split_asm)
apply (clarsimp simp: tcb_bound_refs'_def
dest: symreftype_inverse'
split: if_split_asm)
apply (fastforce simp: global'_no_ex_cap)
apply (clarsimp simp: obj_at'_def pred_tcb_at'_def projectKOs)
\<comment> \<open>endpoint = SendEP\<close>
apply (simp add: invs'_def valid_state'_def)
apply (rename_tac list)
apply (case_tac list, simp_all split del: if_split)
apply (rename_tac sender queue)
apply (rule hoare_pre)
apply (wp valid_irq_node_lift hoare_drop_imps setEndpoint_valid_mdb'
set_ep_valid_objs' sts_st_tcb' sts_sch_act' sts_valid_queues
setThreadState_ct_not_inQ possibleSwitchTo_valid_queues
possibleSwitchTo_valid_queues'
possibleSwitchTo_ct_not_inQ hoare_vcg_all_lift
setEndpoint_ksQ setEndpoint_ct'
| simp add: valid_tcb_state'_def case_bool_If
case_option_If
split del: if_split cong: if_cong
| wp (once) sch_act_sane_lift hoare_vcg_conj_lift hoare_vcg_all_lift
untyped_ranges_zero_lift)+
apply (clarsimp split del: if_split simp: pred_tcb_at')
apply (frule obj_at_valid_objs')
apply (clarsimp simp: valid_pspace'_def)
apply (frule(1) ct_not_in_epQueue, clarsimp, clarsimp)
apply (drule(1) sym_refs_ko_atD')
apply (drule simple_st_tcb_at_state_refs_ofD')
apply (clarsimp simp: projectKOs valid_obj'_def valid_ep'_def
st_tcb_at_refs_of_rev' conj_ac
split del: if_split
cong: if_cong)
apply (frule_tac t=sender in valid_queues_not_runnable'_not_ksQ)
apply (erule pred_tcb'_weakenE, clarsimp)
apply (subgoal_tac "sch_act_not sender s")
prefer 2
apply (clarsimp simp: pred_tcb_at'_def obj_at'_def)
apply (drule st_tcb_at_state_refs_ofD')
apply (simp only: conj_ac(1, 2)[where Q="sym_refs R" for R])
apply (subgoal_tac "distinct (ksIdleThread s # capEPPtr cap # t # sender # queue)")
apply (rule conjI)
apply (clarsimp simp: ep_redux_simps' cong: if_cong)
apply (erule delta_sym_refs)
apply (clarsimp split: if_split_asm)
apply (fastforce simp: tcb_bound_refs'_def
dest: symreftype_inverse'
split: if_split_asm)
apply (clarsimp simp: singleton_tuple_cartesian split: list.split
| rule conjI | drule(1) bspec
| drule st_tcb_at_state_refs_ofD' bound_tcb_at_state_refs_ofD'
| clarsimp elim!: if_live_state_refsE)+
apply (case_tac cap, simp_all add: isEndpointCap_def)
apply (clarsimp simp: global'_no_ex_cap)
apply (rule conjI
| clarsimp simp: singleton_tuple_cartesian split: list.split
| clarsimp elim!: if_live_state_refsE
| clarsimp simp: global'_no_ex_cap idle'_not_queued' idle'_no_refs tcb_bound_refs'_def
| drule(1) bspec | drule st_tcb_at_state_refs_ofD'
| clarsimp simp: set_eq_subset dest!: bound_tcb_at_state_refs_ofD' )+
apply (rule hoare_pre)
apply (wp getNotification_wp | wpc | clarsimp)+
done
(* t = ksCurThread s *)
lemma rai_invs'[wp]:
"\<lbrace>invs' and sch_act_not t
and st_tcb_at' simple' t
and (\<lambda>s. \<forall>p. t \<notin> set (ksReadyQueues s p))
and ex_nonz_cap_to' t
and (\<lambda>s. \<forall>r \<in> zobj_refs' cap. ex_nonz_cap_to' r s)
and (\<lambda>s. \<exists>ntfnptr. isNotificationCap cap
\<and> capNtfnPtr cap = ntfnptr
\<and> obj_at' (\<lambda>ko. ntfnBoundTCB ko = None \<or> ntfnBoundTCB ko = Some t)
ntfnptr s)\<rbrace>
receiveSignal t cap isBlocking
\<lbrace>\<lambda>_. invs'\<rbrace>"
apply (simp add: receiveSignal_def)
apply (rule hoare_seq_ext [OF _ get_ntfn_sp'])
apply (rename_tac ep)
apply (case_tac "ntfnObj ep")
\<comment> \<open>ep = IdleNtfn\<close>
apply (simp add: invs'_def valid_state'_def)
apply (rule hoare_pre)
apply (wp valid_irq_node_lift sts_sch_act' typ_at_lifts
sts_valid_queues setThreadState_ct_not_inQ
asUser_urz
| simp add: valid_ntfn'_def doNBRecvFailedTransfer_def | wpc)+
apply (clarsimp simp: pred_tcb_at' valid_tcb_state'_def)
apply (rule conjI, clarsimp elim!: obj_at'_weakenE)
apply (subgoal_tac "capNtfnPtr cap \<noteq> t")
apply (frule valid_pspace_valid_objs')
apply (frule (1) ko_at_valid_objs')
apply (clarsimp simp: projectKOs)
apply (clarsimp simp: valid_obj'_def valid_ntfn'_def)
apply (rule conjI, clarsimp simp: obj_at'_def split: option.split)
apply (drule simple_st_tcb_at_state_refs_ofD'
ko_at_state_refs_ofD' bound_tcb_at_state_refs_ofD')+
apply (clarsimp dest!: isCapDs)
apply (rule conjI, erule delta_sym_refs)
apply (clarsimp split: if_split_asm)
apply (fastforce simp: tcb_bound_refs'_def symreftype_inverse'
split: if_split_asm)
apply (clarsimp dest!: global'_no_ex_cap)
apply (clarsimp simp: pred_tcb_at'_def obj_at'_def projectKOs)
\<comment> \<open>ep = ActiveNtfn\<close>
apply (simp add: invs'_def valid_state'_def)
apply (rule hoare_pre)
apply (wp valid_irq_node_lift sts_valid_objs' typ_at_lifts static_imp_wp
asUser_urz
| simp add: valid_ntfn'_def)+
apply (clarsimp simp: pred_tcb_at' valid_pspace'_def)
apply (frule (1) ko_at_valid_objs')
apply (clarsimp simp: projectKOs)
apply (clarsimp simp: valid_obj'_def valid_ntfn'_def isCap_simps)
apply (drule simple_st_tcb_at_state_refs_ofD'
ko_at_state_refs_ofD')+
apply (erule delta_sym_refs)
apply (clarsimp split: if_split_asm simp: global'_no_ex_cap)+
\<comment> \<open>ep = WaitingNtfn\<close>
apply (simp add: invs'_def valid_state'_def)
apply (rule hoare_pre)
apply (wp hoare_vcg_const_Ball_lift valid_irq_node_lift sts_sch_act'
sts_valid_queues setThreadState_ct_not_inQ typ_at_lifts
asUser_urz
| simp add: valid_ntfn'_def doNBRecvFailedTransfer_def | wpc)+
apply (clarsimp simp: valid_tcb_state'_def)
apply (frule_tac t=t in not_in_ntfnQueue)
apply (simp)
apply (simp)
apply (erule pred_tcb'_weakenE, clarsimp)
apply (frule ko_at_valid_objs')
apply (clarsimp simp: valid_pspace'_def)
apply (simp add: projectKOs)
apply (clarsimp simp: valid_obj'_def)
apply (clarsimp simp: valid_ntfn'_def pred_tcb_at')
apply (rule conjI, clarsimp elim!: obj_at'_weakenE)
apply (rule conjI, clarsimp simp: obj_at'_def split: option.split)
apply (drule(1) sym_refs_ko_atD')
apply (drule simple_st_tcb_at_state_refs_ofD')
apply (drule bound_tcb_at_state_refs_ofD')
apply (clarsimp simp: st_tcb_at_refs_of_rev'
dest!: isCapDs)
apply (rule conjI, erule delta_sym_refs)
apply (clarsimp split: if_split_asm)
apply (rename_tac list one two three four five six seven eight nine)
apply (subgoal_tac "set list \<times> {NTFNSignal} \<noteq> {}")
apply safe[1]
apply (auto simp: symreftype_inverse' ntfn_bound_refs'_def tcb_bound_refs'_def)[5]
apply (fastforce simp: tcb_bound_refs'_def
split: if_split_asm)
apply (clarsimp dest!: global'_no_ex_cap)
done
lemma getCTE_cap_to_refs[wp]:
"\<lbrace>\<top>\<rbrace> getCTE p \<lbrace>\<lambda>rv s. \<forall>r\<in>zobj_refs' (cteCap rv). ex_nonz_cap_to' r s\<rbrace>"
apply (rule hoare_strengthen_post [OF getCTE_sp])
apply (clarsimp simp: ex_nonz_cap_to'_def)
apply (fastforce elim: cte_wp_at_weakenE')
done
lemma lookupCap_cap_to_refs[wp]:
"\<lbrace>\<top>\<rbrace> lookupCap t cref \<lbrace>\<lambda>rv s. \<forall>r\<in>zobj_refs' rv. ex_nonz_cap_to' r s\<rbrace>,-"
apply (simp add: lookupCap_def lookupCapAndSlot_def split_def
getSlotCap_def)
apply (wp | simp)+
done
lemma arch_stt_objs' [wp]:
"\<lbrace>valid_objs'\<rbrace> Arch.switchToThread t \<lbrace>\<lambda>rv. valid_objs'\<rbrace>"
apply (simp add: ARM_H.switchToThread_def)
apply wp
done
declare zipWithM_x_mapM [simp]
lemma cteInsert_invs_bits[wp]:
"\<lbrace>\<lambda>s. sch_act_wf (ksSchedulerAction s) s\<rbrace>
cteInsert a b c
\<lbrace>\<lambda>rv s. sch_act_wf (ksSchedulerAction s) s\<rbrace>"
"\<lbrace>Invariants_H.valid_queues\<rbrace> cteInsert a b c \<lbrace>\<lambda>rv. Invariants_H.valid_queues\<rbrace>"
"\<lbrace>cur_tcb'\<rbrace> cteInsert a b c \<lbrace>\<lambda>rv. cur_tcb'\<rbrace>"
"\<lbrace>\<lambda>s. P (state_refs_of' s)\<rbrace>
cteInsert a b c
\<lbrace>\<lambda>rv s. P (state_refs_of' s)\<rbrace>"
apply (wp sch_act_wf_lift valid_queues_lift
cur_tcb_lift tcb_in_cur_domain'_lift)+
done
lemma possibleSwitchTo_sch_act_not:
"\<lbrace>sch_act_not t' and K (t \<noteq> t')\<rbrace> possibleSwitchTo t \<lbrace>\<lambda>rv. sch_act_not t'\<rbrace>"
apply (simp add: possibleSwitchTo_def setSchedulerAction_def curDomain_def)
apply (wp hoare_drop_imps | wpc | simp)+
done
crunch vms'[wp]: possibleSwitchTo valid_machine_state'
crunch pspace_domain_valid[wp]: possibleSwitchTo pspace_domain_valid
crunch ct_idle_or_in_cur_domain'[wp]: possibleSwitchTo ct_idle_or_in_cur_domain'
crunch ct'[wp]: possibleSwitchTo "\<lambda>s. P (ksCurThread s)"
crunch it[wp]: possibleSwitchTo "\<lambda>s. P (ksIdleThread s)"
crunch irqs_masked'[wp]: possibleSwitchTo "irqs_masked'"
crunch urz[wp]: possibleSwitchTo "untyped_ranges_zero'"
(simp: crunch_simps unless_def wp: crunch_wps)
lemma si_invs'[wp]:
"\<lbrace>invs' and st_tcb_at' simple' t
and (\<lambda>s. \<forall>p. t \<notin> set (ksReadyQueues s p))
and sch_act_not t
and ex_nonz_cap_to' ep and ex_nonz_cap_to' t\<rbrace>
sendIPC bl call ba cg cgr t ep
\<lbrace>\<lambda>rv. invs'\<rbrace>"
supply if_split[split del]
apply (simp add: sendIPC_def split del: if_split)
apply (rule hoare_seq_ext [OF _ get_ep_sp'])
apply (case_tac epa)
\<comment> \<open>epa = RecvEP\<close>
apply simp
apply (rename_tac list)
apply (case_tac list)
apply simp
apply (simp split del: if_split add: invs'_def valid_state'_def)
apply (rule hoare_pre)
apply (rule_tac P="a\<noteq>t" in hoare_gen_asm)
apply (wp valid_irq_node_lift
sts_valid_objs' set_ep_valid_objs' setEndpoint_valid_mdb' sts_st_tcb' sts_sch_act'
possibleSwitchTo_sch_act_not sts_valid_queues setThreadState_ct_not_inQ
possibleSwitchTo_ksQ' possibleSwitchTo_ct_not_inQ hoare_vcg_all_lift sts_ksQ'
hoare_convert_imp [OF doIPCTransfer_sch_act doIPCTransfer_ct']
hoare_convert_imp [OF setEndpoint_nosch setEndpoint_ct']
hoare_drop_imp [where f="threadGet tcbFault t"]
| rule_tac f="getThreadState a" in hoare_drop_imp
| wp (once) hoare_drop_imp[where R="\<lambda>_ _. call"]
hoare_drop_imp[where R="\<lambda>_ _. \<not> call"]
hoare_drop_imp[where R="\<lambda>_ _. cg"]
| simp add: valid_tcb_state'_def case_bool_If
case_option_If
cong: if_cong
split del: if_split
| wp (once) sch_act_sane_lift tcb_in_cur_domain'_lift hoare_vcg_const_imp_lift)+
apply (clarsimp simp: pred_tcb_at' cong: conj_cong imp_cong
split del: if_split)
apply (frule obj_at_valid_objs', clarsimp)
apply (frule(1) sym_refs_ko_atD')
apply (clarsimp simp: projectKOs valid_obj'_def valid_ep'_def
st_tcb_at_refs_of_rev' pred_tcb_at'
conj_comms fun_upd_def[symmetric]
split del: if_split)
apply (frule pred_tcb_at')
apply (drule simple_st_tcb_at_state_refs_ofD' st_tcb_at_state_refs_ofD')+
apply (clarsimp simp: valid_pspace'_splits)
apply (subst fun_upd_idem[where x=t])
apply (clarsimp split: if_split)
apply (rule conjI, clarsimp simp: obj_at'_def projectKOs)
apply (drule bound_tcb_at_state_refs_ofD')
apply (fastforce simp: tcb_bound_refs'_def)
apply (subgoal_tac "ex_nonz_cap_to' a s")
prefer 2
apply (clarsimp elim!: if_live_state_refsE)
apply clarsimp
apply (rule conjI)
apply (drule bound_tcb_at_state_refs_ofD')
apply (fastforce simp: tcb_bound_refs'_def set_eq_subset)
apply (clarsimp simp: conj_ac)
apply (rule conjI, clarsimp simp: idle'_no_refs)
apply (rule conjI, clarsimp simp: global'_no_ex_cap)
apply (rule conjI)
apply (rule impI)
apply (frule(1) ct_not_in_epQueue, clarsimp, clarsimp)
apply (clarsimp)
apply (simp add: ep_redux_simps')
apply (rule conjI, clarsimp split: if_split)
apply (rule conjI, fastforce simp: tcb_bound_refs'_def set_eq_subset)
apply (clarsimp, erule delta_sym_refs;
solves\<open>auto simp: symreftype_inverse' tcb_bound_refs'_def split: if_split_asm\<close>)
apply (solves\<open>clarsimp split: list.splits\<close>)
\<comment> \<open>epa = IdleEP\<close>
apply (cases bl)
apply (simp add: invs'_def valid_state'_def)
apply (rule hoare_pre, wp valid_irq_node_lift)
apply (simp add: valid_ep'_def)
apply (wp valid_irq_node_lift sts_sch_act' sts_valid_queues
setThreadState_ct_not_inQ)
apply (clarsimp simp: valid_tcb_state'_def pred_tcb_at')
apply (rule conjI, clarsimp elim!: obj_at'_weakenE)
apply (subgoal_tac "ep \<noteq> t")
apply (drule simple_st_tcb_at_state_refs_ofD' ko_at_state_refs_ofD'
bound_tcb_at_state_refs_ofD')+
apply (rule conjI, erule delta_sym_refs)
apply (auto simp: tcb_bound_refs'_def symreftype_inverse'
split: if_split_asm)[2]
apply (fastforce simp: global'_no_ex_cap)
apply (clarsimp simp: pred_tcb_at'_def obj_at'_def projectKOs)
apply simp
apply wp
apply simp
\<comment> \<open>epa = SendEP\<close>
apply (cases bl)
apply (simp add: invs'_def valid_state'_def)
apply (rule hoare_pre, wp valid_irq_node_lift)
apply (simp add: valid_ep'_def)
apply (wp hoare_vcg_const_Ball_lift valid_irq_node_lift sts_sch_act'
sts_valid_queues setThreadState_ct_not_inQ)
apply (clarsimp simp: valid_tcb_state'_def pred_tcb_at')
apply (rule conjI, clarsimp elim!: obj_at'_weakenE)
apply (frule obj_at_valid_objs', clarsimp)
apply (frule(1) sym_refs_ko_atD')
apply (frule pred_tcb_at')
apply (drule simple_st_tcb_at_state_refs_ofD')
apply (drule bound_tcb_at_state_refs_ofD')
apply (clarsimp simp: valid_obj'_def valid_ep'_def
projectKOs st_tcb_at_refs_of_rev')
apply (rule conjI, clarsimp)
apply (drule (1) bspec)
apply (clarsimp dest!: st_tcb_at_state_refs_ofD' bound_tcb_at_state_refs_ofD'
simp: tcb_bound_refs'_def)
apply (clarsimp simp: set_eq_subset)
apply (rule conjI, erule delta_sym_refs)
subgoal by (fastforce simp: obj_at'_def projectKOs symreftype_inverse'
split: if_split_asm)
apply (fastforce simp: tcb_bound_refs'_def symreftype_inverse'
split: if_split_asm)
apply (fastforce simp: global'_no_ex_cap idle'_not_queued)
apply (simp | wp)+
done
lemma sfi_invs_plus':
"\<lbrace>invs' and st_tcb_at' simple' t
and sch_act_not t
and (\<lambda>s. \<forall>p. t \<notin> set (ksReadyQueues s p))
and ex_nonz_cap_to' t\<rbrace>
sendFaultIPC t f
\<lbrace>\<lambda>rv. invs'\<rbrace>, \<lbrace>\<lambda>rv. invs' and st_tcb_at' simple' t
and (\<lambda>s. \<forall>p. t \<notin> set (ksReadyQueues s p))
and sch_act_not t and (\<lambda>s. ksIdleThread s \<noteq> t)\<rbrace>"
apply (simp add: sendFaultIPC_def)
apply (wp threadSet_invs_trivial threadSet_pred_tcb_no_state
threadSet_cap_to'
| wpc | simp)+
apply (rule_tac Q'="\<lambda>rv s. invs' s \<and> sch_act_not t s
\<and> st_tcb_at' simple' t s
\<and> (\<forall>p. t \<notin> set (ksReadyQueues s p))
\<and> ex_nonz_cap_to' t s
\<and> t \<noteq> ksIdleThread s
\<and> (\<forall>r\<in>zobj_refs' rv. ex_nonz_cap_to' r s)"
in hoare_post_imp_R)
apply wp
apply (clarsimp simp: inQ_def pred_tcb_at')
apply (wp | simp)+
apply (clarsimp simp: eq_commute)
apply (subst(asm) global'_no_ex_cap, auto)
done
lemma handleFault_corres:
"fr f f' \<Longrightarrow>
corres dc (einvs and st_tcb_at active thread and ex_nonz_cap_to thread
and (%_. valid_fault f))
(invs' and sch_act_not thread
and (\<lambda>s. \<forall>p. thread \<notin> set(ksReadyQueues s p))
and st_tcb_at' simple' thread and ex_nonz_cap_to' thread)
(handle_fault thread f) (handleFault thread f')"
apply (simp add: handle_fault_def handleFault_def)
apply (rule corres_guard_imp)
apply (subst return_bind [symmetric],
rule corres_split[where P="tcb_at thread",
OF gets_the_noop_corres [where x="()"]])
apply (simp add: tcb_at_def)
apply (rule corres_split_catch)
apply (rule_tac F="valid_fault f" in corres_gen_asm)
apply (rule sendFaultIPC_corres, assumption)
apply simp
apply (rule handleDoubleFault_corres)
apply wp+
apply (rule hoare_post_impErr, rule sfi_invs_plus', simp_all)[1]
apply clarsimp
apply wp+
apply (clarsimp simp: st_tcb_at_tcb_at st_tcb_def2 invs_def
valid_state_def valid_idle_def)
apply auto
done
lemma sts_invs_minor'':
"\<lbrace>st_tcb_at' (\<lambda>st'. tcb_st_refs_of' st' = tcb_st_refs_of' st
\<and> (st \<noteq> Inactive \<and> \<not> idle' st \<longrightarrow>
st' \<noteq> Inactive \<and> \<not> idle' st')) t
and (\<lambda>s. t = ksIdleThread s \<longrightarrow> idle' st)
and (\<lambda>s. (\<exists>p. t \<in> set (ksReadyQueues s p)) \<longrightarrow> runnable' st)
and (\<lambda>s. runnable' st \<and> obj_at' tcbQueued t s
\<longrightarrow> st_tcb_at' runnable' t s)
and (\<lambda>s. \<not> runnable' st \<longrightarrow> sch_act_not t s)
and invs'\<rbrace>
setThreadState st t
\<lbrace>\<lambda>rv. invs'\<rbrace>"
apply (simp add: invs'_def valid_state'_def)
apply (rule hoare_pre)
apply (wp valid_irq_node_lift sts_sch_act' sts_valid_queues
setThreadState_ct_not_inQ)
apply clarsimp
apply (rule conjI)
apply fastforce
apply (rule conjI)
apply (clarsimp simp: pred_tcb_at'_def)
apply (drule obj_at_valid_objs')
apply (clarsimp simp: valid_pspace'_def)
apply (clarsimp simp: valid_obj'_def valid_tcb'_def projectKOs)
subgoal by (cases st, auto simp: valid_tcb_state'_def
split: Structures_H.thread_state.splits)[1]
apply (rule conjI)
apply (clarsimp dest!: st_tcb_at_state_refs_ofD'
elim!: rsubst[where P=sym_refs]
intro!: ext)
apply (clarsimp elim!: st_tcb_ex_cap'')
done
lemma hf_invs' [wp]:
"\<lbrace>invs' and sch_act_not t
and (\<lambda>s. \<forall>p. t \<notin> set(ksReadyQueues s p))
and st_tcb_at' simple' t
and ex_nonz_cap_to' t and (\<lambda>s. t \<noteq> ksIdleThread s)\<rbrace>
handleFault t f \<lbrace>\<lambda>r. invs'\<rbrace>"
apply (simp add: handleFault_def)
apply wp
apply (simp add: handleDoubleFault_def)
apply (wp sts_invs_minor'' dmo_invs')+
apply (rule hoare_post_impErr, rule sfi_invs_plus',
simp_all)
apply (strengthen no_refs_simple_strg')
apply clarsimp
done
declare zipWithM_x_mapM [simp del]
lemma gts_st_tcb':
"\<lbrace>\<top>\<rbrace> getThreadState t \<lbrace>\<lambda>r. st_tcb_at' (\<lambda>st. st = r) t\<rbrace>"
apply (rule hoare_strengthen_post)
apply (rule gts_sp')
apply simp
done
declare setEndpoint_ct' [wp]
lemma setupCallerCap_pred_tcb_unchanged:
"\<lbrace>pred_tcb_at' proj P t and K (t \<noteq> t')\<rbrace>
setupCallerCap t' t'' g
\<lbrace>\<lambda>rv. pred_tcb_at' proj P t\<rbrace>"
apply (simp add: setupCallerCap_def getThreadCallerSlot_def
getThreadReplySlot_def)
apply (wp sts_pred_tcb_neq' hoare_drop_imps)
apply clarsimp
done
lemma si_blk_makes_simple':
"\<lbrace>st_tcb_at' simple' t and K (t \<noteq> t')\<rbrace>
sendIPC True call bdg x x' t' ep
\<lbrace>\<lambda>rv. st_tcb_at' simple' t\<rbrace>"
apply (simp add: sendIPC_def)
apply (rule hoare_seq_ext [OF _ get_ep_inv'])
apply (case_tac xa, simp_all)
apply (rename_tac list)
apply (case_tac list, simp_all add: case_bool_If case_option_If
split del: if_split cong: if_cong)
apply (rule hoare_pre)
apply (wp sts_st_tcb_at'_cases setupCallerCap_pred_tcb_unchanged
hoare_drop_imps)
apply (clarsimp simp: pred_tcb_at' del: disjCI)
apply (wp sts_st_tcb_at'_cases)
apply clarsimp
apply (wp sts_st_tcb_at'_cases)
apply clarsimp
done
lemma si_blk_makes_runnable':
"\<lbrace>st_tcb_at' runnable' t and K (t \<noteq> t')\<rbrace>
sendIPC True call bdg x x' t' ep
\<lbrace>\<lambda>rv. st_tcb_at' runnable' t\<rbrace>"
apply (simp add: sendIPC_def)
apply (rule hoare_seq_ext [OF _ get_ep_inv'])
apply (case_tac xa, simp_all)
apply (rename_tac list)
apply (case_tac list, simp_all add: case_bool_If case_option_If
split del: if_split cong: if_cong)
apply (rule hoare_pre)
apply (wp sts_st_tcb_at'_cases setupCallerCap_pred_tcb_unchanged
hoare_vcg_const_imp_lift hoare_drop_imps
| simp)+
apply (clarsimp del: disjCI simp: pred_tcb_at' elim!: pred_tcb'_weakenE)
apply (wp sts_st_tcb_at'_cases)
apply clarsimp
apply (wp sts_st_tcb_at'_cases)
apply clarsimp
done
crunches possibleSwitchTo, completeSignal
for pred_tcb_at'[wp]: "pred_tcb_at' proj P t"
lemma sendSignal_st_tcb'_Running:
"\<lbrace>st_tcb_at' (\<lambda>st. st = Running \<or> P st) t\<rbrace>
sendSignal ntfnptr bdg
\<lbrace>\<lambda>_. st_tcb_at' (\<lambda>st. st = Running \<or> P st) t\<rbrace>"
apply (simp add: sendSignal_def)
apply (wp sts_st_tcb_at'_cases cancelIPC_st_tcb_at' gts_wp' getNotification_wp static_imp_wp
| wpc | clarsimp simp: pred_tcb_at')+
done
end
end
|
Require Import Blech.Defaults.
Require Import Blech.Bishop.
Require Import Blech.Category.
Require Import Blech.Category.Funct.
Require Import Blech.Category.Bsh.
Definition CoPSh (C: Category): Category := Funct C Bsh.
|
/-
Copyright (c) 2022 Yaël Dillies. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Yaël Dillies
-/
import order.category.PartOrd
import order.hom.lattice
/-!
# The category of lattices
This defines `Lat`, the category of lattices.
Note that `Lat` doesn't correspond to the literature definition of [`Lat`]
(https://ncatlab.org/nlab/show/Lat) as we don't require bottom or top elements. Instead, `Lat`
corresponds to `BddLat`.
## TODO
The free functor from `Lat` to `BddLat` is `X → with_top (with_bot X)`.
-/
universes u
open category_theory
/-- The category of lattices. -/
def Lat := bundled lattice
namespace Lat
instance : has_coe_to_sort Lat Type* := bundled.has_coe_to_sort
instance (X : Lat) : lattice X := X.str
/-- Construct a bundled `Lat` from a `lattice`. -/
def of (α : Type*) [lattice α] : Lat := bundled.of α
@[simp] lemma coe_of (α : Type*) [lattice α] : ↥(of α) = α := rfl
instance : inhabited Lat := ⟨of bool⟩
instance : bundled_hom @lattice_hom :=
{ to_fun := λ _ _ _ _, coe_fn,
id := @lattice_hom.id,
comp := @lattice_hom.comp,
hom_ext := λ X Y _ _, by exactI fun_like.coe_injective }
instance : large_category.{u} Lat := bundled_hom.category lattice_hom
instance : concrete_category Lat := bundled_hom.concrete_category lattice_hom
instance has_forget_to_PartOrd : has_forget₂ Lat PartOrd :=
{ forget₂ := { obj := λ X, ⟨X⟩, map := λ X Y f, f },
forget_comp := rfl }
/-- Constructs an isomorphism of lattices from an order isomorphism between them. -/
@[simps] def iso.mk {α β : Lat.{u}} (e : α ≃o β) : α ≅ β :=
{ hom := e,
inv := e.symm,
hom_inv_id' := by { ext, exact e.symm_apply_apply _ },
inv_hom_id' := by { ext, exact e.apply_symm_apply _ } }
/-- `order_dual` as a functor. -/
@[simps] def dual : Lat ⥤ Lat := { obj := λ X, of Xᵒᵈ, map := λ X Y, lattice_hom.dual }
/-- The equivalence between `Lat` and itself induced by `order_dual` both ways. -/
@[simps functor inverse] def dual_equiv : Lat ≌ Lat :=
equivalence.mk dual dual
(nat_iso.of_components (λ X, iso.mk $ order_iso.dual_dual X) $ λ X Y f, rfl)
(nat_iso.of_components (λ X, iso.mk $ order_iso.dual_dual X) $ λ X Y f, rfl)
end Lat
lemma Lat_dual_comp_forget_to_PartOrd :
Lat.dual ⋙ forget₂ Lat PartOrd =
forget₂ Lat PartOrd ⋙ PartOrd.dual := rfl
|
/* multifit/gsl_multifit.h
*
* Copyright (C) 2000, 2007, 2010 Brian Gough
* Copyright (C) 2013, Patrick Alken
*
* 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 3 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 should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef __GSL_MULTIFIT_H__
#define __GSL_MULTIFIT_H__
#include <stdlib.h>
#include <gsl/gsl_math.h>
#include <gsl/gsl_vector.h>
#include <gsl/gsl_matrix.h>
#include <gsl/gsl_types.h>
#undef __BEGIN_DECLS
#undef __END_DECLS
#ifdef __cplusplus
# define __BEGIN_DECLS extern "C" {
# define __END_DECLS }
#else
# define __BEGIN_DECLS /* empty */
# define __END_DECLS /* empty */
#endif
__BEGIN_DECLS
typedef struct
{
size_t nmax; /* maximum number of observations */
size_t pmax; /* maximum number of parameters */
size_t n; /* number of observations in current SVD decomposition */
size_t p; /* number of parameters in current SVD decomposition */
gsl_matrix * A; /* least squares matrix for SVD, n-by-p */
gsl_matrix * Q;
gsl_matrix * QSI;
gsl_vector * S;
gsl_vector * t;
gsl_vector * xt;
gsl_vector * D;
double rcond; /* reciprocal condition number */
}
gsl_multifit_linear_workspace;
gsl_multifit_linear_workspace *
gsl_multifit_linear_alloc (const size_t n, const size_t p);
void
gsl_multifit_linear_free (gsl_multifit_linear_workspace * w);
int
gsl_multifit_linear (const gsl_matrix * X,
const gsl_vector * y,
gsl_vector * c,
gsl_matrix * cov,
double * chisq,
gsl_multifit_linear_workspace * work);
int
gsl_multifit_linear_tsvd (const gsl_matrix * X,
const gsl_vector * y,
const double tol,
gsl_vector * c,
gsl_matrix * cov,
double * chisq,
size_t * rank,
gsl_multifit_linear_workspace * work);
int
gsl_multifit_linear_svd (const gsl_matrix * X,
gsl_multifit_linear_workspace * work);
int
gsl_multifit_linear_bsvd (const gsl_matrix * X,
gsl_multifit_linear_workspace * work);
size_t
gsl_multifit_linear_rank(const double tol, const gsl_multifit_linear_workspace * work);
int
gsl_multifit_linear_solve (const double lambda,
const gsl_matrix * X,
const gsl_vector * y,
gsl_vector * c,
double *rnorm,
double *snorm,
gsl_multifit_linear_workspace * work);
int
gsl_multifit_linear_applyW(const gsl_matrix * X,
const gsl_vector * w,
const gsl_vector * y,
gsl_matrix * WX,
gsl_vector * Wy);
int
gsl_multifit_linear_stdform1 (const gsl_vector * L,
const gsl_matrix * X,
const gsl_vector * y,
gsl_matrix * Xs,
gsl_vector * ys,
gsl_multifit_linear_workspace * work);
int
gsl_multifit_linear_wstdform1 (const gsl_vector * L,
const gsl_matrix * X,
const gsl_vector * w,
const gsl_vector * y,
gsl_matrix * Xs,
gsl_vector * ys,
gsl_multifit_linear_workspace * work);
int
gsl_multifit_linear_L_decomp (gsl_matrix * L, gsl_vector * tau);
int
gsl_multifit_linear_stdform2 (const gsl_matrix * LQR,
const gsl_vector * Ltau,
const gsl_matrix * X,
const gsl_vector * y,
gsl_matrix * Xs,
gsl_vector * ys,
gsl_matrix * M,
gsl_multifit_linear_workspace * work);
int
gsl_multifit_linear_wstdform2 (const gsl_matrix * LQR,
const gsl_vector * Ltau,
const gsl_matrix * X,
const gsl_vector * w,
const gsl_vector * y,
gsl_matrix * Xs,
gsl_vector * ys,
gsl_matrix * M,
gsl_multifit_linear_workspace * work);
int
gsl_multifit_linear_genform1 (const gsl_vector * L,
const gsl_vector * cs,
gsl_vector * c,
gsl_multifit_linear_workspace * work);
int
gsl_multifit_linear_genform2 (const gsl_matrix * LQR,
const gsl_vector * Ltau,
const gsl_matrix * X,
const gsl_vector * y,
const gsl_vector * cs,
const gsl_matrix * M,
gsl_vector * c,
gsl_multifit_linear_workspace * work);
int
gsl_multifit_linear_wgenform2 (const gsl_matrix * LQR,
const gsl_vector * Ltau,
const gsl_matrix * X,
const gsl_vector * w,
const gsl_vector * y,
const gsl_vector * cs,
const gsl_matrix * M,
gsl_vector * c,
gsl_multifit_linear_workspace * work);
int
gsl_multifit_linear_lreg (const double smin, const double smax,
gsl_vector * reg_param);
int
gsl_multifit_linear_lcurve (const gsl_vector * y,
gsl_vector * reg_param,
gsl_vector * rho, gsl_vector * eta,
gsl_multifit_linear_workspace * work);
int
gsl_multifit_linear_lcorner(const gsl_vector *rho,
const gsl_vector *eta,
size_t *idx);
int
gsl_multifit_linear_lcorner2(const gsl_vector *reg_param,
const gsl_vector *eta,
size_t *idx);
int
gsl_multifit_linear_Lk(const size_t p, const size_t k, gsl_matrix *L);
int
gsl_multifit_linear_Lsobolev(const size_t p, const size_t kmax,
const gsl_vector *alpha, gsl_matrix *L,
gsl_multifit_linear_workspace *work);
int
gsl_multifit_wlinear (const gsl_matrix * X,
const gsl_vector * w,
const gsl_vector * y,
gsl_vector * c,
gsl_matrix * cov,
double * chisq,
gsl_multifit_linear_workspace * work);
int
gsl_multifit_wlinear_tsvd (const gsl_matrix * X,
const gsl_vector * w,
const gsl_vector * y,
const double tol,
gsl_vector * c,
gsl_matrix * cov,
double * chisq,
size_t * rank,
gsl_multifit_linear_workspace * work);
int
gsl_multifit_wlinear_svd (const gsl_matrix * X,
const gsl_vector * w,
const gsl_vector * y,
double tol,
size_t * rank,
gsl_vector * c,
gsl_matrix * cov,
double *chisq,
gsl_multifit_linear_workspace * work);
int
gsl_multifit_wlinear_usvd (const gsl_matrix * X,
const gsl_vector * w,
const gsl_vector * y,
double tol,
size_t * rank,
gsl_vector * c,
gsl_matrix * cov,
double *chisq,
gsl_multifit_linear_workspace * work);
int
gsl_multifit_linear_est (const gsl_vector * x,
const gsl_vector * c,
const gsl_matrix * cov, double *y, double *y_err);
double
gsl_multifit_linear_rcond (const gsl_multifit_linear_workspace * w);
int
gsl_multifit_linear_residuals (const gsl_matrix *X, const gsl_vector *y,
const gsl_vector *c, gsl_vector *r);
/* gcv.c */
int
gsl_multifit_linear_gcv_init(const gsl_vector * y,
gsl_vector * reg_param,
gsl_vector * UTy,
double * delta0,
gsl_multifit_linear_workspace * work);
int
gsl_multifit_linear_gcv_curve(const gsl_vector * reg_param,
const gsl_vector * UTy,
const double delta0,
gsl_vector * G,
gsl_multifit_linear_workspace * work);
int
gsl_multifit_linear_gcv_min(const gsl_vector * reg_param,
const gsl_vector * UTy,
const gsl_vector * G,
const double delta0,
double * lambda,
gsl_multifit_linear_workspace * work);
double
gsl_multifit_linear_gcv_calc(const double lambda,
const gsl_vector * UTy,
const double delta0,
gsl_multifit_linear_workspace * work);
int
gsl_multifit_linear_gcv(const gsl_vector * y,
gsl_vector * reg_param,
gsl_vector * G,
double * lambda,
double * G_lambda,
gsl_multifit_linear_workspace * work);
typedef struct
{
const char * name; /* method name */
int (*wfun)(const gsl_vector *r, gsl_vector *w);
int (*psi_deriv)(const gsl_vector *r, gsl_vector *dpsi);
double tuning_default; /* default tuning constant */
} gsl_multifit_robust_type;
typedef struct
{
double sigma_ols; /* OLS estimate of sigma */
double sigma_mad; /* MAD estimate of sigma */
double sigma_rob; /* robust estimate of sigma */
double sigma; /* final estimate of sigma */
double Rsq; /* R^2 coefficient of determination */
double adj_Rsq; /* degree of freedom adjusted R^2 */
double rmse; /* root mean squared error */
double sse; /* residual sum of squares */
size_t dof; /* degrees of freedom */
size_t numit; /* number of iterations */
gsl_vector *weights; /* final weights */
gsl_vector *r; /* final residuals y - X c */
} gsl_multifit_robust_stats;
typedef struct
{
size_t n; /* number of observations */
size_t p; /* number of parameters */
size_t numit; /* number of iterations */
size_t maxiter; /* maximum iterations */
const gsl_multifit_robust_type *type;
double tune; /* tuning parameter */
gsl_vector *r; /* residuals at current iteration */
gsl_vector *weights; /* weights at current iteration */
gsl_vector *c_prev; /* coefficients from previous iteration */
gsl_vector *resfac; /* multiplicative factors for residuals */
gsl_vector *psi; /* psi(r) */
gsl_vector *dpsi; /* psi'(r) */
gsl_matrix *QSI; /* Q S^{-1} of original matrix X */
gsl_vector *D; /* balancing parameters of original matrix X */
gsl_vector *workn; /* workspace of length n */
gsl_multifit_robust_stats stats; /* various statistics */
gsl_multifit_linear_workspace *multifit_p;
} gsl_multifit_robust_workspace;
/* available types */
GSL_VAR const gsl_multifit_robust_type * gsl_multifit_robust_default;
GSL_VAR const gsl_multifit_robust_type * gsl_multifit_robust_bisquare;
GSL_VAR const gsl_multifit_robust_type * gsl_multifit_robust_cauchy;
GSL_VAR const gsl_multifit_robust_type * gsl_multifit_robust_fair;
GSL_VAR const gsl_multifit_robust_type * gsl_multifit_robust_huber;
GSL_VAR const gsl_multifit_robust_type * gsl_multifit_robust_ols;
GSL_VAR const gsl_multifit_robust_type * gsl_multifit_robust_welsch;
gsl_multifit_robust_workspace *gsl_multifit_robust_alloc(const gsl_multifit_robust_type *T,
const size_t n, const size_t p);
void gsl_multifit_robust_free(gsl_multifit_robust_workspace *w);
int gsl_multifit_robust_tune(const double tune,
gsl_multifit_robust_workspace *w);
int gsl_multifit_robust_maxiter(const size_t maxiter,
gsl_multifit_robust_workspace *w);
const char *gsl_multifit_robust_name(const gsl_multifit_robust_workspace *w);
gsl_multifit_robust_stats gsl_multifit_robust_statistics(const gsl_multifit_robust_workspace *w);
int gsl_multifit_robust_weights(const gsl_vector *r, gsl_vector *wts,
gsl_multifit_robust_workspace *w);
int gsl_multifit_robust(const gsl_matrix * X, const gsl_vector * y,
gsl_vector * c, gsl_matrix *cov,
gsl_multifit_robust_workspace *w);
int gsl_multifit_robust_est(const gsl_vector * x, const gsl_vector * c,
const gsl_matrix * cov, double *y, double *y_err);
int gsl_multifit_robust_residuals(const gsl_matrix * X,
const gsl_vector * y,
const gsl_vector * c, gsl_vector * r,
gsl_multifit_robust_workspace * w);
__END_DECLS
#endif /* __GSL_MULTIFIT_H__ */
|
If $X$ is empty, then $f$ and $g$ are homotopic if and only if $f$ and $g$ are both continuous. |
// Copyright 2016 lyobzik
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "Test.h"
#include <sstream>
#include <fstream>
#include <rapidjson/rapidjson.h>
#include <rapidjson/stringbuffer.h>
#include <rapidjson/writer.h>
#include <boost/algorithm/string/predicate.hpp>
#include "../lib/RapidJsonDefs.h"
namespace TestsCommon {
namespace fs = boost::filesystem;
namespace {
std::string ToString(JsonSchemaValidator::JsonValue const &value) {
using namespace rapidjson;
GenericStringBuffer<UTF8<> > buffer;
Writer<GenericStringBuffer<UTF8<> > > writer(buffer);
value.Accept(writer);
std::string string = buffer.GetString();
return buffer.GetString();
}
std::vector<fs::path> GetTestFiles()
{
fs::directory_iterator it("../thirdparty/json_schema_test_suite/tests/draft3"), endIt;
std::vector<fs::path> test_files;
std::copy_if(it, endIt, std::back_inserter(test_files), [](fs::directory_entry const &entry) -> bool {
return fs::is_regular_file(entry) &&
boost::algorithm::ends_with(entry.path().string(), ".json") &&
entry.path().filename().string() != "ref.json";
});
return test_files;
}
void LoadTestCases(fs::path const &path_to_file, JsonSchemaValidator::JsonDocument &test_case) {
std::ifstream test_file(path_to_file.string());
std::istreambuf_iterator<char> it(test_file), endIt;
std::string test_file_content(it, endIt);
test_case.Parse<0>(test_file_content.c_str());
}
std::string GetStringTestData(JsonSchemaValidator::JsonValue const &test_data) {
std::stringstream ss;
ss << std::boolalpha << std::fixed << "{\"data\": ";
if (test_data.IsObject() || test_data.IsArray()) ss << ToString(test_data);
else if (test_data.IsString()) ss << "\"" << test_data.GetString() << "\"";
else if (test_data.IsDouble()) ss << test_data.GetDouble();
else if (test_data.IsNumber()) ss << test_data.GetInt64();
else if (test_data.IsBool()) ss << test_data.GetBool();
else if (test_data.IsNull()) ss << "null";
ss << "}";
return ss.str();
}
} // namespace
///////////////////////////////////////////////////////////////////////////////////////////////////
Test::Test(std::string const &name, std::string const &schema,
std::string const &inspected_document, bool expect_result)
: name_(name)
, schema_(schema)
, inspected_document_(inspected_document)
, expect_result_(expect_result) {
}
std::string Test::GetName() const {
return name_;
}
std::string Test::GetSchema() const {
return schema_;
}
std::string Test::GetInspectedDocument() const {
return inspected_document_;
}
bool Test::GetExpectResult() const {
return expect_result_;
}
Tests Test::GetTests() {
Tests result;
using namespace JsonSchemaValidator;
for (auto const &file : GetTestFiles()) {
JsonDocument test_cases;
LoadTestCases(file, test_cases);
assert(!test_cases.HasParseError());
assert(test_cases.IsArray());
for (JsonSizeType case_index = 0; case_index < test_cases.Size(); ++case_index) {
JsonValue const &test_case(test_cases[case_index]);
assert(test_case.HasMember("description"));
assert(test_case.HasMember("schema"));
assert(test_case.HasMember("tests"));
assert(test_case["description"].IsString());
assert(test_case["tests"].IsArray());
std::string schema = ToString(test_case["schema"]);
std::string description = test_case["description"].GetString();
JsonValue const &tests(test_case["tests"]);
for (JsonSizeType test_index = 0; test_index < tests.Size(); ++test_index) {
JsonValue const &test(tests[test_index]);
assert(test.HasMember("description"));
assert(test.HasMember("data"));
assert(test.HasMember("valid"));
assert(test["description"].IsString());
assert(test["valid"].IsBool());
std::string test_name = file.filename().string() + "/" + description +
"/" + test["description"].GetString();
result.emplace_back(test_name, schema, GetStringTestData(test["data"]),
test["valid"].GetBool());
}
}
}
return result;
}
} // namespace TestsCommon
|
(* Title: HOL/Auth/n_german_lemma_on_inv__42.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__42 imports n_german_base
begin
section{*All lemmas on causal relation between inv__42 and some rule r*}
lemma n_RecvReqVsinv__42:
assumes a1: "(\<exists> i. i\<le>N\<and>r=n_RecvReq N i)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__42 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__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__42 p__Inv4" apply fastforce done
have "(i=p__Inv4)\<or>(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__Inv4) ''Cmd'')) (Const Inv))))" in exI, auto) done
then have "invHoldForRule s f r (invariants N)" by auto
}
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__Inv4) ''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__42:
assumes a1: "(\<exists> i. i\<le>N\<and>r=n_SendInvE i)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__42 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__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__42 p__Inv4" apply fastforce done
have "(i=p__Inv4)\<or>(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__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__42:
assumes a1: "(\<exists> i. i\<le>N\<and>r=n_SendInvS i)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__42 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__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__42 p__Inv4" apply fastforce done
have "(i=p__Inv4)\<or>(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__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__42:
assumes a1: "(\<exists> i. i\<le>N\<and>r=n_SendInvAck i)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__42 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__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__42 p__Inv4" apply fastforce done
have "(i=p__Inv4)\<or>(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__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__42:
assumes a1: "(\<exists> i. i\<le>N\<and>r=n_RecvInvAck i)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__42 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__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__42 p__Inv4" apply fastforce done
have "(i=p__Inv4)\<or>(i~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(i=p__Inv4)"
have "((formEval (eqn (IVar (Ident ''ExGntd'')) (Const true)) s))\<or>((formEval (neg (eqn (IVar (Ident ''ExGntd'')) (Const true))) s))" by auto
moreover {
assume c1: "((formEval (eqn (IVar (Ident ''ExGntd'')) (Const true)) s))"
have "?P3 s"
apply (cut_tac a1 a2 b1 c1, simp, rule_tac x="(neg (andForm (eqn (IVar (Field (Para (Ident ''Chan2'') p__Inv4) ''Cmd'')) (Const Inv)) (eqn (IVar (Field (Para (Ident ''Chan3'') p__Inv4) ''Cmd'')) (Const InvAck))))" in exI, auto) done
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume c1: "((formEval (neg (eqn (IVar (Ident ''ExGntd'')) (Const true))) s))"
have "?P2 s"
proof(cut_tac a1 a2 b1 c1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately have "invHoldForRule s f r (invariants N)" by satx
}
moreover {
assume b1: "(i~=p__Inv4)"
have "((formEval (eqn (IVar (Ident ''ExGntd'')) (Const true)) s))\<or>((formEval (neg (eqn (IVar (Ident ''ExGntd'')) (Const true))) s))" by auto
moreover {
assume c1: "((formEval (eqn (IVar (Ident ''ExGntd'')) (Const true)) s))"
have "?P3 s"
apply (cut_tac a1 a2 b1 c1, simp, rule_tac x="(neg (andForm (andForm (eqn (IVar (Field (Para (Ident ''Chan2'') p__Inv4) ''Cmd'')) (Const Inv)) (eqn (IVar (Ident ''CurCmd'')) (Const ReqS))) (eqn (IVar (Field (Para (Ident ''Chan3'') i) ''Cmd'')) (Const InvAck))))" in exI, auto) done
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume c1: "((formEval (neg (eqn (IVar (Ident ''ExGntd'')) (Const true))) s))"
have "?P2 s"
proof(cut_tac a1 a2 b1 c1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately have "invHoldForRule s f r (invariants N)" by satx
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_SendGntSVsinv__42:
assumes a1: "(\<exists> i. i\<le>N\<and>r=n_SendGntS i)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__42 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__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__42 p__Inv4" apply fastforce done
have "(i=p__Inv4)\<or>(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__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__42:
assumes a1: "(\<exists> i. i\<le>N\<and>r=n_SendGntE N i)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__42 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__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__42 p__Inv4" apply fastforce done
have "(i=p__Inv4)\<or>(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__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__42:
assumes a1: "(\<exists> i. i\<le>N\<and>r=n_RecvGntS i)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__42 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__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__42 p__Inv4" apply fastforce done
have "(i=p__Inv4)\<or>(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__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__42:
assumes a1: "(\<exists> i. i\<le>N\<and>r=n_RecvGntE i)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__42 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__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__42 p__Inv4" apply fastforce done
have "(i=p__Inv4)\<or>(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__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__42:
assumes a1: "\<exists> i d. i\<le>N\<and>d\<le>N\<and>r=n_Store i d" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__42 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_SendReqESVsinv__42:
assumes a1: "\<exists> i. i\<le>N\<and>r=n_SendReqES i" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__42 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_SendReqSVsinv__42:
assumes a1: "\<exists> j. j\<le>N\<and>r=n_SendReqS j" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__42 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_SendReqEIVsinv__42:
assumes a1: "\<exists> i. i\<le>N\<and>r=n_SendReqEI i" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__42 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
end
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.