text
stringlengths 0
3.34M
|
|---|
//
// FILE NAME: $HeadURL: svn+ssh://svn.cm.aol.com/advertising/adlearn/gen1/trunk/lib/cpp/DataProxy/AggregateStreamTransformer.hpp $
//
// REVISION: $Revision: 281517 $
//
// COPYRIGHT: (c) 2008 Advertising.com All Rights Reserved.
//
// LAST UPDATED: $Date: 2013-06-19 17:36:40 -0400 (Wed, 19 Jun 2013) $
// UPDATED BY: $Author: esaxe $
#ifndef _AGGREGATE_STREAM_TRANSFORMER_HPP_
#define _AGGREGATE_STREAM_TRANSFORMER_HPP_
#include "MVException.hpp"
#include "ITransformFunction.hpp"
#include <boost/shared_ptr.hpp>
#include <istream>
#include <map>
#include <string>
MV_MAKEEXCEPTIONCLASS( AggregateStreamTransformerException, MVException );
class AggregateStreamTransformer : public ITransformFunction
{
public:
AggregateStreamTransformer();
virtual ~AggregateStreamTransformer();
virtual boost::shared_ptr<std::istream> TransformInput( boost::shared_ptr< std::istream > i_pInput, const std::map< std::string, std::string >& i_rParameters );
};
#endif //_AGGREGATE_STREAM_TRANSFORMER_HPP_
|
{-# OPTIONS_GHC -XTemplateHaskell #-}
module Euler.Problem011Test (suite) where
import Numeric.LinearAlgebra.Data (Matrix, loadMatrix)
import Test.Tasty (TestTree)
import Test.Tasty.HUnit
import Test.Tasty.TH (testGroupGenerator)
import Euler.Problem011
suite :: TestTree
suite = $(testGroupGenerator)
matrix :: IO (Matrix Double)
matrix = loadMatrix "input/011.txt"
case_count_of_vectors_in_input :: Assertion
case_count_of_vectors_in_input =
matrix >>= \m -> 10 @=? (length . vectors . head $ submatrices 4 m)
case_count_of_4x4_submatrices_in_input :: Assertion
case_count_of_4x4_submatrices_in_input =
matrix >>= \m -> 17 * 17 @=? (length $ submatrices 4 m)
|
import Hw7
import Lean.Elab.Print
import Lean.Elab.Command
theorem desiredType : ∀ (α : Type) (A B : α → Prop), (∃ x, A x) → ∃ y, A y ∨ B y := sorry
open Lean
open Lean.Meta
open Lean.Elab.Command
def collectAxiomsOf (constName : Name) : MetaM (List String) := do
let env ← getEnv
let (_, s) := ((CollectAxioms.collect constName).run env).run {}
let a := s.axioms.toList.map toString
return a
#eval isDefEq (Expr.const ``desiredType []) (Expr.const ``problem2 [])
#eval collectAxiomsOf ``problem2
|
#define BOOST_TEST_MODULE example
#include <boost/test/included/unit_test.hpp>
struct F {
F() : i( 0 ) { BOOST_TEST_MESSAGE( "setup fixture" ); }
~F() { BOOST_TEST_MESSAGE( "teardown fixture" ); }
int i;
};
BOOST_FIXTURE_TEST_CASE( test_case1, F )
{
BOOST_CHECK( i == 1 );
++i;
}
BOOST_FIXTURE_TEST_CASE( test_case2, F )
{
BOOST_CHECK_EQUAL( i, 1 );
}
BOOST_AUTO_TEST_CASE( test_case3 )
{
BOOST_CHECK( true );
}
|
open import Numeral.Natural
open import Relator.Equals
open import Type.Properties.Decidable
open import Type
module Formalization.ClassicalPredicateLogic.Syntax.Substitution
{ℓₚ ℓᵥ ℓₒ}
(Prop : ℕ → Type{ℓₚ})
(Var : Type{ℓᵥ}) ⦃ var-eq-dec : Decidable(2)(_≡_ {T = Var}) ⦄
(Obj : ℕ → Type{ℓₒ})
where
open import Data.Boolean
open import Data.ListSized
import Data.ListSized.Functions as List
open import Formalization.ClassicalPredicateLogic.Syntax(Prop)(Var)(Obj)
private variable n : ℕ
substituteTerm : Var → Term → Term → Term
substituteTerm₊ : Var → Term → List(Term)(n) → List(Term)(n)
substituteTerm v t (var x) = if(decide(2)(_≡_) v x) then t else (var x)
substituteTerm v t (func f x) = func f (substituteTerm₊ v t x)
substituteTerm₊ {0} v t ∅ = ∅
substituteTerm₊ {𝐒(n)} v t (x ⊰ xs) = (substituteTerm v t x ⊰ substituteTerm₊ {n} v t xs)
substitute : Var → Term → Formula → Formula
substitute v t (f $ x) = f $ List.map (substituteTerm v t) x
substitute v t ⊤ = ⊤
substitute v t ⊥ = ⊥
substitute v t (φ ∧ ψ) = (substitute v t φ) ∧ (substitute v t ψ)
substitute v t (φ ∨ ψ) = (substitute v t φ) ∨ (substitute v t ψ)
substitute v t (φ ⟶ ψ) = (substitute v t φ) ⟶ (substitute v t ψ)
substitute v t (Ɐ(x) φ) = Ɐ(x) (if(decide(2)(_≡_) v x) then φ else (substitute v t φ))
substitute v t (∃(x) φ) = ∃(x) (if(decide(2)(_≡_) v x) then φ else (substitute v t φ))
|
Ireland has won more medals in boxing than in any other Olympic sport . Boxing is governed by the Irish Amateur Boxing Association . Michael Carruth won a gold medal and Wayne McCullough won a silver medal in the Barcelona Olympic Games and in 2008 Kenneth Egan won a silver medal in the Beijing Games . Paddy Barnes secured bronze in those games and gold in the 2010 European Amateur Boxing Championships ( where Ireland came 2nd in the overall medal table ) and 2010 Commonwealth Games . Katie Taylor has won gold in every European and World championship since 2005 . In August 2012 at the Olympic Games in London Katie Taylor created history by becoming the first Irish woman to win a gold medal in boxing in the 60 kg lightweight .
|
lemma norm_of_int [simp]: "norm (of_int z::'a::real_normed_algebra_1) = \<bar>of_int z\<bar>" |
using DataFrames, CSV, Statistics, StatsBase, XLSX
df = DataFrame(XLSX.readtable("./input/Risks Data - 1802.xlsx", 2)...)
select!(df, Symbol.(["Risk Factor Pathway", "Sector", "Model", "Scenario", "Geography", "Units", 2020.0, 2040.0, 2060.0, 2080.0, 2100.0]))
df = stack(df, 7:size(df)[2])
rename!(df, [:year, :value, :category, :variable, :model, :scenario, :region, :unit])
df = df[.|(df.category .== "Revenue"), :]
df = df[.|(df.variable .== "Gas", df.variable .== "Coal", df.variable .== "Oil"), :]
df = df[.|(df.model .== "REMIND-MAgPIE 1.7-3.0"), :]
# df = df[.|(df.scenario .== "PEP_NoPolicy", df.scenario .== "PEP_1p5C_red_eff", df.scenario .== "PEP_2C_red_eff"), :]
# df = unstack(df, :year, :value)
df.value = df.value / 1000000
CSV.write("../src/assets/data/oil-risks.csv", df)
# df2 = DataFrame(XLSX.readtable("./input/PepData_FinanceLearnModule.xlsx", 1)...)
# df2 = unstack(df2, :period, :value)
# df2.category = map(v -> v[1], split.(df2.variable, "|"))
# df2.var = map(v -> v[size(v)[1]], split.(df2.variable, "|"))
#
# select!(df2, Symbol.(["model", "scenario", "region", "unit", "var", "category", 2020, 2040, 2060, 2080, 2100]))
#
# df2 = stack(df2, 7:size(df2)[2])
# rename!(df2, [:year, :value, :model, :scenario, :region, :unit, :variable, :category])
#
# df2 = df2[.|(df2.category .== "Primary Energy", df2.category .== "Price"), :]
# df2 = df2[.|(df2.variable .== "Gas", df2.variable .== "Coal", df2.variable .== "Oil"), :]
#
# df2 = unstack(df2, :year, :value)
# df1 = unstack(df, :year, :value)
#
# combo = vcat(df1, df2)
# sort!(combo, [order(:scenario), order(:variable), order(:category)])
#
# CSV.write("../src/assets/data/oil-risks-unstacked.csv", combo)
# CSV.write("../src/assets/data/oil-risks-vars.csv", DataFrame(unique(df2.variable)))
#
# # DataFrame(unique(df2.variable))
# # df2 = unstack(df2, :year, :value)
#
# price = df2[df2.variable .== "Price|Primary Energy|Gas", :]
# CSV.write("../src/assets/data/oil-risks-price.csv", price)
# # price.unit
|
[STATEMENT]
lemma length_row_mat_to_cols_list [simp]:
assumes "i < dim_row A"
shows "length (row (mat_to_cols_list A) i) = dim_col A"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. length (Matrix_Legacy.row (mat_to_cols_list A) i) = dim_col A
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
i < dim_row A
goal (1 subgoal):
1. length (Matrix_Legacy.row (mat_to_cols_list A) i) = dim_col A
[PROOF STEP]
by (simp add: row_def) |
lemma holomorphic_on_add [holomorphic_intros]: "\<lbrakk>f holomorphic_on s; g holomorphic_on s\<rbrakk> \<Longrightarrow> (\<lambda>z. f z + g z) holomorphic_on s" |
# -*- coding: utf-8 -*-
from __future__ import print_function
import torch
from torch import nn
import numpy as np
from .line_ocr_engine import BaseEngineLineOCR
# scores_probs should be N,C,T, blank is last class
def greedy_decode_ctc(scores_probs, chars):
best = torch.argmax(scores_probs, 1) + 1
mask = best[:, :-1] == best[:, 1:]
best = best[:, 1:]
best[mask] = 0
best[best == scores_probs.shape[1]] = 0
best = best.cpu().numpy() - 1
outputs = []
for line in best:
line = line[np.nonzero(line >= 0)]
outputs.append(''.join([chars[c] for c in line]))
return outputs
class PytorchEngineLineOCR(BaseEngineLineOCR):
def __init__(self, json_def, gpu_id=0, batch_size=8):
super(PytorchEngineLineOCR, self).__init__(json_def, gpu_id=0, batch_size=8)
self.net_subsampling = 4
self.characters = list(self.characters) + ['|']
self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
net = PYTORCH_NETS[self.net_name]
self.model = net[0](num_classes=len(self.characters), in_height=self.line_px_height, **net[1])
self.model.load_state_dict(torch.load(self.checkpoint, map_location=self.device))
self.model = self.model.to(self.device)
self.model = self.model.eval()
def run_ocr(self, batch_data):
with torch.no_grad():
batch_data = torch.from_numpy(batch_data).to(self.device).float() / 255.0
logits = self.model(batch_data)
decoded = greedy_decode_ctc(logits, self.characters)
logits = logits.permute(0, 2, 1).cpu().numpy()
return decoded, logits
def create_vgg_block_2d(in_channels, out_channels, stride=(2,2), layer_count=2, norm='bn'):
layers = []
for i in range(layer_count):
if norm == 'bn':
layers += [
nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1),
torch.nn.BatchNorm2d(out_channels),
torch.nn.LeakyReLU(),
]
elif norm == 'none':
layers += [
nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1),
torch.nn.LeakyReLU(),
]
else:
print(f'ERROR: Normalization "f{norm}" is not implemented')
raise "Unknown norm"
in_channels = out_channels
layers += [nn.MaxPool2d(kernel_size=stride, stride=stride)]
return nn.Sequential(*layers)
def create_vgg_block_1d(in_channels, out_channels, stride=(2,2), layer_count=2, norm='bn'):
layers = []
for i in range(layer_count):
if norm == 'bn':
layers += [
nn.Conv1d(in_channels, out_channels, kernel_size=3, stride=1, padding=1),
torch.nn.BatchNorm1d(out_channels),
torch.nn.LeakyReLU(),
]
elif norm == 'none':
layers += [
nn.Conv1d(in_channels, out_channels, kernel_size=3, stride=1, padding=1),
torch.nn.LeakyReLU(),
]
else:
print(f'ERROR: Normalization "f{norm}" is not implemented')
raise "Unknown norm"
in_channels = out_channels
return nn.Sequential(*layers)
class NET_VGG(nn.Module):
def __init__(self, num_classes, in_height=32, base_channels=16, conv_blocks=4, subsampling=4, in_channels=3, layers_2d=None):
super(NET_VGG, self).__init__()
if layers_2d is None:
layers_2d = 16
if type(layers_2d) is int:
import torchvision
vgg = torchvision.models.vgg16(pretrained=True)
layers_2d = list(vgg.features[:layers_2d])
start_level = 0
self.blocks_2d = []
actual_subsampling_h = 1
actual_subsampling_v = 1
for layer in layers_2d:
if type(layer) == torch.nn.modules.pooling.MaxPool2d:
if actual_subsampling_h < subsampling:
stride = (2, 2)
else:
stride = (2, 1)
self.blocks_2d += [nn.MaxPool2d(kernel_size=stride, stride=stride)]
actual_subsampling_h *= stride[1]
actual_subsampling_v *= stride[0]
start_level += 1
else:
self.blocks_2d.append(layer)
if type(layer) == torch.nn.modules.conv.Conv2d:
in_channels = layer.bias.shape[0]
out_channels = in_channels
for i in range(start_level, conv_blocks):
out_channels = base_channels*(2**i)
if actual_subsampling_h < subsampling:
stride=(2, 2)
else:
stride=(2, 1)
actual_subsampling_h *= stride[1]
actual_subsampling_v *= stride[0]
self.blocks_2d += [
create_vgg_block_2d(in_channels, out_channels, stride=stride, norm='none'),
torch.nn.BatchNorm2d(out_channels),
]
in_channels = out_channels
self.blocks_2d = nn.Sequential(*self.blocks_2d)
self.block_1d = create_vgg_block_1d(in_channels , out_channels)
self.gru = torch.nn.LSTM(out_channels, out_channels // 2, num_layers=2, bidirectional=True)
self.output_layer = nn.Conv1d(out_channels, num_classes, kernel_size=3, stride=1, padding=1)
def forward(self, x):
x = x.permute(0, 3, 1, 2)
out = self.blocks_2d(x)
out = torch.mean(out, 2)
out = self.block_1d(out)
out, _ = self.gru(out.permute(2, 0, 1))
out = out.permute(1, 2, 0)
out = self.output_layer(out)
return out
class VGG_conv_module(nn.Module):
def __init__(self, base_channels=16, conv_blocks=4, subsampling=4, in_channels=3, layers_2d=None):
super(VGG_conv_module, self).__init__()
if layers_2d is None:
layers_2d = 16
if type(layers_2d) is int:
import torchvision
vgg = torchvision.models.vgg16(pretrained=True)
layers_2d = list(vgg.features[:layers_2d])
start_level = 0
self.blocks_2d = []
actual_subsampling_h = 1
actual_subsampling_v = 1
for layer in layers_2d:
if type(layer) == torch.nn.modules.pooling.MaxPool2d:
if actual_subsampling_h < subsampling:
stride = (2, 2)
else:
stride = (2, 1)
self.blocks_2d += [nn.MaxPool2d(kernel_size=stride, stride=stride)]
actual_subsampling_h *= stride[1]
actual_subsampling_v *= stride[0]
start_level += 1
else:
self.blocks_2d.append(layer)
if type(layer) == torch.nn.modules.conv.Conv2d:
in_channels = layer.bias.shape[0]
print('Pretrained layers')
print(self.blocks_2d)
out_channels = in_channels
for i in range(start_level, conv_blocks):
out_channels = base_channels*(2**i)
if actual_subsampling_h < subsampling:
stride = (2, 2)
else:
stride = (2, 1)
actual_subsampling_h *= stride[1]
actual_subsampling_v *= stride[0]
self.blocks_2d += [
create_vgg_block_2d(in_channels, out_channels, stride=stride, norm='none'),
torch.nn.BatchNorm2d(out_channels),
]
in_channels = out_channels
self.blocks_2d = nn.Sequential(*self.blocks_2d)
self.out_channels = out_channels
def forward(self, x):
return self.blocks_2d(x.contiguous())
class MultiscaleRecurrentBlock(nn.Module):
def __init__(self, channels, layers_per_scale=2, scales=4):
super(MultiscaleRecurrentBlock, self).__init__()
self.layers = nn.ModuleList([torch.nn.LSTM(channels, channels // 2, num_layers=layers_per_scale, bidirectional=True)
for scale in range(scales)])
self.final_layer = torch.nn.LSTM(channels, channels // 2, num_layers=1, bidirectional=True)
def forward(self, x):
outputs = []
for depth, layer in enumerate(self.layers):
if depth == 0:
scaled_data = x
else:
scaled_data = torch.nn.functional.max_pool1d(scaled_data, kernel_size=2, stride=2)
out, _ = layer(scaled_data.permute(2, 0, 1))
out = out.permute(1, 2, 0)
if depth != 0:
out = torch.nn.functional.interpolate(out, scale_factor=2**depth, mode='nearest')
outputs.append(out)
out = outputs[0]
for output in outputs[1:]:
out = out + output
out, _ = self.final_layer(out.permute(2, 0, 1))
return out.permute(1, 2, 0)
class NET_VGG_LSTM(nn.Module):
def __init__(self, num_classes, in_height=32, in_channels=3, dropout_rate=0.0, base_channels=16, conv_blocks=4,
subsampling=4, layers_2d=None):
super(NET_VGG_LSTM, self).__init__()
self.output_subsampling = subsampling
self.blocks_2d = VGG_conv_module(base_channels=base_channels, conv_blocks=conv_blocks, subsampling=subsampling,
in_channels=in_channels, layers_2d=layers_2d)
rnn_channels = self.blocks_2d.out_channels
self.recurrent_block = MultiscaleRecurrentBlock(rnn_channels, layers_per_scale=2, scales=3)
self.output_layer = nn.Conv1d(rnn_channels, num_classes, kernel_size=3, stride=1, padding=1)
def forward(self, x):
x = x.permute(0, 3, 1, 2)
out = self.blocks_2d(x)
out, _ = torch.max(out, 2)
out = self.recurrent_block(out)
out = self.output_layer(out)
return out
PYTORCH_NETS = {
"VGG_B32_L16_S4_CB4": (NET_VGG, {'in_channels': 3, 'base_channels': 32, 'conv_blocks': 4, 'subsampling': 4, 'layers_2d': 16}),
"VGG_LSTM_B64_L17_S4_CB4": (NET_VGG_LSTM, {'in_channels': 3, 'base_channels': 64, 'conv_blocks': 4, 'subsampling': 4, 'layers_2d': 17})
}
|
#ifndef BIO_GSL_H_
#define BIO_GSL_H_
#include "bio/defs.h"
#include "bio/raii.h"
#include <gsl/gsl_integration.h>
BIO_NS_START
void
gsl_init();
template <>
RAII<gsl_integration_workspace *>::~RAII();
#define BIO_GSL_EXP(x) ((x) < GSL_LOG_DBL_MIN ? 0.0 : gsl_sf_exp(x))
BIO_NS_END
#endif //BIO_GSL_H_
|
module IdrisJvm.Data.IORef
import IdrisJvm.IO
export
data IORef a = MkIORef a
public export
interface HasReference (ffi : FFI) where
newIORef' : a -> IO' ffi (IORef a)
readIORef' : IORef a -> IO' ffi a
writeIORef' : IORef a -> a -> IO' ffi ()
export
modifyIORef': HasReference ffi => IORef a -> (a -> a) -> IO' ffi ()
modifyIORef' ref fn =
do
val <- readIORef' ref
writeIORef' ref (fn val)
export
Ref : Type
Ref = JVM_Native (Class ("io/github/mmhelloworld/idrisjvm/runtime/Ref"))
export
implementation HasReference FFI_JVM where
newIORef' val = (MkIORef . believe_me) <$> FFI.new (Object -> JVM_IO Ref) (believe_me val)
readIORef' (MkIORef ref) = believe_me <$> invokeInstance "getValue" (Ref -> JVM_IO Object) (believe_me ref)
writeIORef' (MkIORef ref) val = invokeInstance "setValue" (Ref -> Object -> JVM_IO ()) (believe_me ref) (believe_me val)
||| Build a new IORef
export
newIORef : a -> JVM_IO (IORef a)
newIORef = newIORef'
||| read the value of an IORef
export
readIORef : IORef a -> JVM_IO a
readIORef = readIORef'
||| write the value of an IORef
export
writeIORef : IORef a -> a -> JVM_IO ()
writeIORef = writeIORef'
||| mutate the contents of an IORef
export
modifyIORef : IORef a -> (a -> a) -> JVM_IO ()
modifyIORef = modifyIORef'
|
record T where
constructor mkT
|
paintings and objects will be shown.
Fine arts are an important part of creative and culture economy.
to familiarize people with their ideas and critical works.
against evil spirits, especially the evil influences of household spirits -Kikimora.
We as freelancer artists still need protection against Kikimoras.
Thus, the name has been chosen.
The charms shall protect the room and the exhibition.
The works will be displayed until October 10th, 2015.
" 5 vor 12 "
5 vor 12 - 7.00 P.M.
as well as art from Nepal.
The complete income will benefit the victims of the Nepal earthquake. |
lemma supp_sum_empty[simp]: "supp_sum f {} = 0" |
theory prop_18
imports Main
"$HIPSTER_HOME/IsaHipster"
begin
datatype Nat = Z | S "Nat"
fun plus :: "Nat => Nat => Nat" where
"plus (Z) y = y"
| "plus (S z) y = S (plus z y)"
fun lt :: "Nat => Nat => bool" where
"lt x (Z) = False"
| "lt (Z) (S z) = True"
| "lt (S x2) (S z) = lt x2 z"
(*hipster plus lt *)
theorem x0 :
"lt i (S (plus i m))"
by (tactic \<open>Subgoal.FOCUS_PARAMS (K (Tactic_Data.hard_tac @{context})) @{context} 1\<close>)
end
|
module RandomAccessList.Zeroless where
open import RandomAccessList.Zeroless.Core
open import RandomAccessList.Zeroless.Core.Properties
open import BuildingBlock.BinaryLeafTree using (BinaryLeafTree; Node; Leaf; split)
import BuildingBlock.BinaryLeafTree as BLT
open import Data.Fin using (Fin; fromℕ; fromℕ≤; reduce≥; toℕ)
import Data.Fin as Fin
open import Data.Nat
open import Data.Nat.DivMod
-- open import Data.Nat.Properties.Simple
open import Data.Nat.Etc
open import Data.Product
open import Function
open import Relation.Nullary using (yes; no)
open import Relation.Nullary.Negation using (contradiction; contraposition)
open import Relation.Binary.PropositionalEquality as PropEq
using (_≡_; _≢_; refl; cong; trans; sym; inspect)
open PropEq.≡-Reasoning
--------------------------------------------------------------------------------
-- Operations
--------------------------------------------------------------------------------
-- cons
consₙ : ∀ {n A} → BinaryLeafTree A n → 1-2-RAL A n → 1-2-RAL A n
consₙ a ( []) = a 1∷ []
consₙ a (x 1∷ xs) = a , x 2∷ xs
consₙ a (x , y 2∷ xs) = a 1∷ consₙ (Node x y) xs
cons : ∀ {A} → A → 1-2-RAL A 0 → 1-2-RAL A 0
cons a xs = consₙ (Leaf a) xs
-- head
headₙ : ∀ {n A} → (xs : 1-2-RAL A n) → ⟦ xs ⟧ ≢ 0 → BinaryLeafTree A n
headₙ {n} {A} [] p = contradiction (⟦[]⟧≡0 ([] {A} {n}) refl) p
headₙ (x 1∷ xs) p = x
headₙ (x , y 2∷ xs) p = x
head : ∀ {A} → (xs : 1-2-RAL A 0) → ⟦ xs ⟧ ≢ 0 → A
head xs p = BLT.head (headₙ xs p)
-- tail
tailₙ : ∀ {n A} → (xs : 1-2-RAL A n) → ⟦ xs ⟧ ≢ 0 → 1-2-RAL A n
tailₙ [] p = []
tailₙ (x 1∷ xs) p with ⟦ xs ⟧ ≟ 0
tailₙ (x 1∷ xs) p | yes q = []
tailₙ (x 1∷ xs) p | no ¬q =
let y₀ = proj₁ (split (headₙ xs ¬q))
y₁ = proj₂ (split (headₙ xs ¬q))
in y₀ , y₁ 2∷ tailₙ xs ¬q
tailₙ (x , y 2∷ xs) p = y 1∷ xs
tail : ∀ {A} → (xs : 1-2-RAL A 0) → ⟦ xs ⟧ ≢ 0 → 1-2-RAL A 0
tail = tailₙ
--------------------------------------------------------------------------------
-- Searching
--------------------------------------------------------------------------------
{-
data Occurrence : ℕ → Set where
here : ∀ {n b} → ℕ → Fin (b * 2 ^ n) → Occurrence n
there : ∀ {n} → Occurrence n
transportFin : ∀ {a b} → a ≡ b → Fin a → Fin b
transportFin refl i = i
search : ∀ {n A} → (xs : 1-2-RAL A n) → ℕ → Occurrence n
search [] i = there
search {n} (x 1∷ xs) i with (1 * 2 ^ n) ≤? i
search (x 1∷ xs) i | yes p = there
search {n} (x 1∷ xs) i | no ¬p = here 0 (fromℕ≤ (m≰n⇒n<m (1 * 2 ^ n) i ¬p))
search {n} (x , y 2∷ xs) i with (2 * 2 ^ n) ≤? i
search (x , y 2∷ xs) i | yes p = there
search {n} (x , y 2∷ xs) i | no ¬p with i divMod (2 ^ n)
search (x , y 2∷ xs) i | no ¬p | result zero remainder _ = here zero {! !}
search (x , y 2∷ xs) i | no ¬p | result (suc quotient) remainder _ = {! !}
elemAt : ∀ {n A} → (xs : 1-2-RAL A n) → Fin ⟦ xs ⟧ → A
elemAt {n} {A} [] i = contradiction (transportFin (⟦[]⟧≡0 ([] {A} {n}) refl) i) (λ ())
elemAt (x 1∷ xs) i = {! !}
elemAt (x , y 2∷ xs) i = {! !}
splitIndex1∷ : ∀ {n A} → (x : BinaryLeafTree A n) → (xs : 1-2-RAL A (suc n)) → ⟦ x 1∷ xs ⟧ ≡ (2 ^ n) + ⟦ xs ⟧
splitIndex1∷ {n} x xs =
begin
⟦ x 1∷ xs ⟧
≡⟨ +-*-suc (2 ^ n) (2 * ⟦ xs ⟧ₙ) ⟩
2 ^ n + 2 ^ n * (2 * ⟦ xs ⟧ₙ)
≡⟨ cong (_+_ (2 ^ n)) (sym (*-assoc (2 ^ n) 2 ⟦ xs ⟧ₙ)) ⟩
2 ^ n + 2 ^ n * 2 * ⟦ xs ⟧ₙ
≡⟨ cong (λ w → 2 ^ n + w * ⟦ xs ⟧ₙ) (*-comm (2 ^ n) 2) ⟩
(2 ^ n) + ⟦ xs ⟧
∎
n+n≡2*n : (n : ℕ) → n + n ≡ 2 * n
n+n≡2*n n = cong (_+_ n) (sym (+-right-identity n))
splitIndex2∷ : ∀ {n A}
→ (x : BinaryLeafTree A n)
→ (y : BinaryLeafTree A n)
→ (xs : 1-2-RAL A (suc n)) → ⟦ x , y 2∷ xs ⟧ ≡ 2 * (2 ^ n) + ⟦ xs ⟧
splitIndex2∷ {n} x y xs =
begin
⟦ x , y 2∷ xs ⟧
≡⟨ +-*-suc (2 ^ n) (suc (2 * ⟦ xs ⟧ₙ)) ⟩
2 ^ n + 2 ^ n * suc (2 * ⟦ xs ⟧ₙ)
≡⟨ cong (_+_ (2 ^ n)) (+-*-suc (2 ^ n) (2 * ⟦ xs ⟧ₙ)) ⟩
2 ^ n + (2 ^ n + 2 ^ n * (2 * ⟦ xs ⟧ₙ))
≡⟨ sym (+-assoc (2 ^ n) (2 ^ n) (2 ^ n * (2 * ⟦ xs ⟧ₙ))) ⟩
2 ^ n + 2 ^ n + 2 ^ n * (2 * ⟦ xs ⟧ₙ)
≡⟨ cong (λ w → 2 ^ n + 2 ^ n + w) (sym (*-assoc (2 ^ n) 2 ⟦ xs ⟧ₙ)) ⟩
2 ^ n + 2 ^ n + 2 ^ n * 2 * ⟦ xs ⟧ₙ
≡⟨ cong (λ w → 2 ^ n + 2 ^ n + w * ⟦ xs ⟧ₙ) (*-comm (2 ^ n) 2) ⟩
2 ^ n + 2 ^ n + 2 * 2 ^ n * ⟦ xs ⟧ₙ
≡⟨ cong (λ w → w + 2 * 2 ^ n * ⟦ xs ⟧ₙ) (n+n≡2*n (2 ^ n)) ⟩
2 * 2 ^ n + ⟦ xs ⟧
∎
{-
elemAt : ∀ {n A} → (xs : 1-2-RAL A n) → Fin ⟦ xs ⟧ → A
elemAt ( []) ()
elemAt {n} (x 1∷ xs) i with (2 ^ n) ≤? toℕ i
elemAt {n} (x 1∷ xs) i | yes p rewrite splitIndex1∷ x xs = elemAt xs (reduce≥ i p)
elemAt (x 1∷ xs) i | no ¬p = BLT.elemAt x (fromℕ≤ (BLT.¬a≤b⇒b<a ¬p))
elemAt {n} (x , y 2∷ xs) i with (2 * (2 ^ n)) ≤? toℕ i
elemAt (x , y 2∷ xs) i | yes p rewrite splitIndex2∷ x y xs = elemAt xs (reduce≥ i p)
elemAt {n} (x , y 2∷ xs) i | no ¬p with (2 ^ n) ≤? toℕ i
elemAt (x , y 2∷ xs) i | no ¬p | yes q rewrite splitIndex2∷ x y xs = BLT.elemAt y {! !} -- y
elemAt (x , y 2∷ xs) i | no ¬p | no ¬q = BLT.elemAt x (fromℕ≤ (BLT.¬a≤b⇒b<a ¬q)) -- x
-}
-- reduce≥ : ∀ {m n} (i : Fin (m N+ n)) (i≥m : toℕ i N≥ m) → Fin n
-- i : 2 * 2 ^ n + (2 * 2 ^ n) * ⟦ xs ⟧ₙ
-- m : 2 ^ n
-}
|
1-9. The gakkul vat, the gakkul vat! The gakkul vat, the lamsare vat! The gakkul vat, which puts us in a happy mood! The lamsare vat, which makes the heart rejoice! The ugurbal jar, glory of the house! The šaggub jar, filled with beer! The amam jar, which carries the beer from the lamsare vat! The troughs made with bur grass and the pails for kneading the dough! All the beautiful vessels are ready on their pot stands!
10-20. May the heart of your god be well disposed towards you! Let the eye of the gakkul vat be our eye, and let the heart of the gakkul vat be our heart! What makes your heart feel wonderful in itself also makes our hearts feel wonderful in themselves! We are in a happy mood, our hearts are joyful! You have poured a libation over the fated brick, and you have laid the foundations in peace and prosperity -- now may Ninkasi dwell with you! She should pour beer and wine for you! Let the pouring of the sweet liquor resound pleasantly for you!
21-31. In the troughs made with bur grass, there is sweet beer. I will have the cupbearers, the boys and the brewers stand by. As I spin around the lake of beer, while feeling wonderful, feeling wonderful, while drinking beer, in a blissful mood, while drinking alcohol and feeling exhilarated, with joy in the heart and a contented liver -- my heart is a heart filled with joy! I clothe my contented liver in a garment fit for a queen! The heart of Inana is happy once again; the heart of Inana is happy once again!
32. A …… to Ninkasi. |
import LMT
variable {I} [Nonempty I] {E} [Nonempty E] [Nonempty (A I E)]
example {a1 a2 a3 : A I E} :
((((a1).write i3 (v1)).write i2 (v1)).read i3) ≠ (v1) → False := by
arr
|
"""
Bridges `CP.Conjunction` to reification.
"""
struct Conjunction2ReificationBridge{T} <: MOIBC.AbstractBridge
var::MOI.VariableIndex
var_bin::MOI.ConstraintIndex{MOI.VariableIndex, MOI.ZeroOne}
cons_reif::Vector{MOI.ConstraintIndex}
# Ideally, Vector{MOI.ConstraintIndex{MOI.VectorAffineFunction{T}, CP.Reification{<: MOI.AbstractSet}}},
# but Julia has no notion of type erasure.
con_conjunction::MOI.ConstraintIndex{MOI.VariableIndex, MOI.EqualTo{T}}
end
function MOIBC.bridge_constraint(
::Type{Conjunction2ReificationBridge{T}},
model,
f::MOI.VectorOfVariables,
s::CP.Conjunction{S},
) where {T, S}
return MOIBC.bridge_constraint(
Conjunction2ReificationBridge{T},
model,
MOI.VectorAffineFunction{T}(f),
s,
)
end
function MOIBC.bridge_constraint(
::Type{Conjunction2ReificationBridge{T}},
model,
f::MOI.VectorAffineFunction{T},
s::CP.Conjunction{S},
) where {T, S}
var, var_bin = MOI.add_constrained_variable(model, MOI.ZeroOne())
f_scalars = MOIU.scalarize(f)
cons_reif = Vector{MOI.ConstraintIndex}(undef, length(s.constraints))
cur_dim = 1
for i in 1:length(s.constraints)
cons_reif[i] = MOI.add_constraint(
model,
MOIU.vectorize(
[
one(T) * var,
f_scalars[cur_dim : (cur_dim + MOI.dimension(s.constraints[i]) - 1)]...,
]
),
CP.Reification(s.constraints[i])
)
cur_dim += MOI.dimension(s.constraints[i])
end
con_conjunction = MOI.add_constraint(
model,
var,
MOI.EqualTo(one(T))
)
return Conjunction2ReificationBridge(var, var_bin, cons_reif, con_conjunction)
end
function MOI.supports_constraint(
::Type{Conjunction2ReificationBridge{T}},
::Union{Type{MOI.VectorOfVariables}, Type{MOI.VectorAffineFunction{T}}},
::Type{CP.Conjunction{S}},
) where {T, S}
return true
# Ideally, ensure that the underlying solver supports all the needed
# reified constraints:
# return all(MOI.supports_constraint(model, type, CP.Reification{C}) for C in S.parameters)
end
function MOIB.added_constrained_variable_types(::Type{Conjunction2ReificationBridge{T}}) where {T}
return [(MOI.ZeroOne,)]
end
function MOIB.added_constraint_types(::Type{Conjunction2ReificationBridge{T}}) where {T}
return [
(MOI.VectorAffineFunction{T}, CP.Reification), # TODO: how to be more precise?
(MOI.VariableIndex, MOI.EqualTo{T}),
]
end
function MOI.get(::Conjunction2ReificationBridge{T}, ::MOI.NumberOfVariables) where {T}
return 1
end
function MOI.get(
::Conjunction2ReificationBridge{T},
::MOI.NumberOfConstraints{
MOI.VariableIndex, MOI.ZeroOne,
},
) where {T}
return 1
end
function MOI.get(
b::Conjunction2ReificationBridge{T},
::MOI.NumberOfConstraints{
MOI.VectorAffineFunction{T}, CP.Reification,
},
) where {T}
return length(b.cons_reif)
end
function MOI.get(
::Conjunction2ReificationBridge{T},
::MOI.NumberOfConstraints{
MOI.VariableIndex, MOI.EqualTo{T},
},
) where {T}
return 1
end
function MOI.get(
b::Conjunction2ReificationBridge{T},
::MOI.ListOfVariableIndices,
) where {T}
return [b.var]
end
function MOI.get(
b::Conjunction2ReificationBridge{T},
::MOI.ListOfConstraintIndices{
MOI.VariableIndex, MOI.ZeroOne,
},
) where {T}
return [b.var_bin]
end
function MOI.get(
b::Conjunction2ReificationBridge{T},
::MOI.ListOfConstraintIndices{
MOI.VectorAffineFunction{T}, CP.Reification,
},
) where {T}
return copy(b.cons_reif)
end
function MOI.get(
b::Conjunction2ReificationBridge{T},
::MOI.ListOfConstraintIndices{
MOI.VariableIndex, MOI.EqualTo{T},
},
) where {T}
return [b.con_conjunction]
end
|
Section Approx2.
Variable Model : Type.
Definition BoolF : Type := Model -> bool.
Definition unsat (x : BoolF) : Prop :=
forall m, ~ eq_true (x m)
.
(* We approximate an element as:
p - condition under which the element is known.
a - value of the element when known.
b - value of the element when unknown.
*)
Definition approx (T : Type) (x : Model -> T) (p : BoolF) (a : Model -> T) (b : Model -> T) : Prop
:= (forall t, x t = if p t then a t else b t)
.
Theorem approx_useful_sat : forall x xp xa xb m,
approx x xp xa xb ->
eq_true (andb (xp m) (xa m)) ->
eq_true (x m)
.
Theorem approx_useful_unsat : forall x xp xa xb,
approx x xp xa xb ->
unsat
Lemma i_implies_o : forall xi xo xx,
approx xi xo xx ->
forall m, eq_true (xi m) -> eq_true (xo m)
.
Proof.
intros xi xo xx Ha m Hxi.
unfold approx in Ha.
decompose [and] Ha.
specialize H with m.
specialize H0 with m.
exact (H0 (H Hxi)).
Qed.
(* An approximation for something known completely *)
Theorem approx_known : forall x,
approx x x x
.
Proof.
intros x.
unfold approx.
split ; intros ; assumption.
Qed.
(* An approximation for something completely unknown *)
Theorem approx_unknown : forall x,
approx (fun _ => false) (fun _ => true) x
.
Proof.
intros x.
unfold approx.
split.
intros m Habsurd. inversion Habsurd.
split.
Qed.
Theorem approx_not : forall xi xo x,
approx xi xo x ->
approx (fun m => negb (xo m)) (fun m => negb (xi m)) (fun m => negb (x m))
.
Proof.
intros xi xo x Happrox.
unfold approx in *.
decompose [and] Happrox.
unfold not in *.
split.
intros m Ho. specialize H0 with m. destruct (x m).
set (Hno := H0 is_eq_true). destruct (xo m) ; assumption.
simpl. exact is_eq_true.
intros m Hx. specialize H with m. destruct (xi m).
set (Hnx := H is_eq_true). destruct (x m) ; assumption.
exact is_eq_true.
Qed.
Theorem approx_and : forall xi xo xx yi yo yy,
approx xi xo xx ->
approx yi yo yy ->
approx (fun m => andb (xi m) (yi m)) (fun m => andb (xo m) (yo m)) (fun m => andb (xx m) (yy m))
.
Proof.
intros xi xo xx yi yo yy Hax Hay.
unfold approx in *.
split.
intros m His.
decompose [and] Hax.
specialize H with m.
decompose [and] Hay.
specialize H1 with m.
destruct (xx m).
destruct (yy m).
exact (is_eq_true).
destruct (yi m).
exact (H1 is_eq_true).
destruct (xi m).
simpl in His. elim His. exact is_eq_true.
simpl in His. elim His. exact is_eq_true.
simpl.
destruct (xi m).
exact (H is_eq_true).
apply His.
intros m Hxy.
decompose [and] Hax.
specialize H0 with m.
decompose [and] Hay.
specialize H2 with m.
destruct (xo m).
destruct (yo m).
exact (is_eq_true).
apply H2. destruct (yy m).
exact is_eq_true.
destruct (xx m) ; apply Hxy.
destruct (xx m).
exact (H0 is_eq_true).
apply Hxy.
Qed.
(* Approximation of if then else *)
Theorem approx_ite : forall pi po p xi xo x yi yo y,
approx pi po p ->
approx xi xo x ->
approx yi yo y ->
approx (fun m => orb (andb (pi m) (xi m)) (andb (negb (po m)) (yi m)))
(fun m => orb (andb (po m) (xo m)) (andb (negb (pi m)) (yo m)))
(fun m => if p m then x m else y m)
.
Proof.
intros pi po p xi xo x yi yo y Hap Hax Hay.
unfold approx in *.
split.
intros m Htr.
decompose [and] Hap.
decompose [and] Hax.
decompose [and] Hay.
specialize H with m.
specialize H0 with m.
specialize H1 with m.
specialize H3 with m.
destruct (pi m), (po m), (p m), (xi m), (xo m), (x m), (yi m), (yo m), (y m) ; auto.
intros m Htr.
decompose [and] Hap.
decompose [and] Hax.
decompose [and] Hay.
specialize H with m.
specialize H0 with m.
specialize H2 with m.
specialize H4 with m.
destruct (pi m), (po m), (p m), (xi m), (xo m), (x m), (yi m), (yo m), (y m) ; auto.
Qed.
Variable Elem : Type.
Definition ElemF : Type := Model -> Elem.
(* We approximate an assignment-parameterized element x using:
p - a predicate determining when the approximation is exact
a - the approximation.
*)
Definition eapprox (p : BoolF) (a : ElemF) (x : ElemF) : Prop
:= forall m, eq_true (p m) -> a(m) = x(m)
.
Theorem eapprox_known : forall x,
eapprox (fun _ => true) x x
.
Proof.
intros x m Hp. reflexivity.
Qed.
Theorem eapprox_unknown : forall x bot,
eapprox (fun _ => false) bot x
.
Proof.
intros x bot m Hp.
inversion Hp.
Qed.
Theorem approx_unary : forall f xp xa xx,
eapprox xp xa xx ->
approx (fun m => andb (xp m) (f (xa m)))
(fun m => orb (negb (xp m)) (f (xa m)))
(fun m => f (xx m))
.
intros f xp xa xx Hax.
split.
unfold eapprox in Hax.
intro m.
specialize Hax with m.
destruct (xp m).
simpl.
rewrite (Hax is_eq_true).
trivial.
simpl.
intro Hsilly.
inversion Hsilly.
intros m Htr.
unfold eapprox in Hax.
specialize Hax with m.
destruct (xp m).
rewrite (Hax is_eq_true).
trivial.
exact (is_eq_true).
Qed.
Theorem approx_binary : forall f xp xa xx yp ya yy,
eapprox xp xa xx ->
eapprox yp ya yy ->
approx (fun m => andb (xp m) (andb (yp m) (f (xa m) (ya m))))
(fun m => orb (negb (xp m)) (orb (negb (yp m)) (f (xa m) (ya m))))
(fun m => f (xx m) (yy m))
.
Proof.
intros f xp xa xx yp ya yy Hax Hay.
split ; intros m H; unfold eapprox in *;
specialize Hax with m; specialize Hay with m ;
destruct (xp m), (yp m) ; simpl in H.
rewrite <- (Hax is_eq_true).
rewrite <- (Hay is_eq_true).
assumption.
inversion H.
inversion H.
inversion H.
rewrite (Hax is_eq_true).
rewrite (Hay is_eq_true).
assumption.
exact (is_eq_true).
exact (is_eq_true).
exact (is_eq_true).
Qed.
Theorem eapprox_unary : forall f xp xa xx,
eapprox xp xa xx ->
eapprox xp (fun m => f (xa m)) (fun m => f (xx m))
.
Proof.
intros f xp xa xx Hax.
unfold eapprox in *.
intros m Heq.
specialize Hax with m.
rewrite (Hax Heq).
reflexivity.
Qed.
Theorem eapprox_binary : forall f xp xa xx yp ya yy,
eapprox xp xa xx ->
eapprox yp ya yy ->
eapprox (fun m => andb (xp m) (yp m)) (fun m => f (xa m) (ya m)) (fun m => f (xx m) (yy m))
.
Proof.
intros f xp xa xx yp ya yy Hax Hay.
unfold eapprox in *.
intros m Heq.
specialize Hax with m.
specialize Hay with m.
destruct (xp m), (yp m).
rewrite (Hax is_eq_true).
rewrite (Hay is_eq_true).
reflexivity.
inversion Heq.
inversion Heq.
inversion Heq.
Qed.
Theorem eapprox_ite : forall pi po pp xp xa xx yp ya yy,
approx pi po pp ->
eapprox xp xa xx ->
eapprox yp ya yy ->
eapprox (fun m => orb (andb (pi m) (xp m)) (andb (negb (po m)) (yp m)))
(fun m => if pi m then xa m else ya m)
(fun m => if pp m then xx m else yy m)
.
Proof.
intros pi po pp xp xa xx yp ya yy Hap Hax Hay m H.
unfold approx in Hap.
decompose [and] Hap.
unfold eapprox in *.
specialize H0 with m.
specialize H1 with m.
specialize Hax with m.
specialize Hay with m.
destruct (pi m), (pp m), (xp m).
rewrite (Hax is_eq_true) ; reflexivity.
destruct (po m).
inversion H.
rewrite (Hax (H1 is_eq_true)) ; reflexivity.
set (Hsilly := H0 is_eq_true).
inversion Hsilly.
set (Hsilly := H0 is_eq_true) ; inversion Hsilly.
destruct (po m).
inversion H.
set (Hsilly := H1 is_eq_true) ; inversion Hsilly.
destruct (po m).
inversion H.
set (Hsilly := H1 is_eq_true) ; inversion Hsilly.
destruct (yp m).
exact (Hay is_eq_true).
destruct (po m) ; inversion H.
destruct (yp m).
exact (Hay is_eq_true).
destruct (po m) ; inversion H.
Qed.
End Approx2.
|
Set Implicit Arguments.
Require Import FCF.
Require Import PRF.
Require Import RndInList.
Local Open Scope list_scope.
Inductive in_oc_supp : forall (A B C : Set), C -> OracleComp A B C -> Prop :=
| in_oc_supp_Bind :
forall (A B C C' : Set)(c : OracleComp A B C')(f : C' -> OracleComp A B C) x y,
in_oc_supp x c ->
in_oc_supp y (f x) ->
in_oc_supp y (OC_Bind c f)
| in_oc_supp_Query :
forall (A B : Set)(a : A)(b : B),
in_oc_supp b (OC_Query B a)
| in_oc_supp_Ret :
forall (A B C : Set)(c : Comp C) x,
In x (getSupport c) ->
in_oc_supp x (OC_Ret A B c)
| in_oc_supp_Run :
forall (A A' B B' C S : Set)(eqds : EqDec S)(eqda : EqDec A)(eqdb : EqDec B)
(c : OracleComp A B C)(oc : S -> A -> OracleComp A' B' (B * S)) s x s',
in_oc_supp x c ->
in_oc_supp (x, s') (OC_Run _ _ _ c oc s).
Theorem in_oc_supp_complete :
forall (A B C : Set){eqdc : EqDec C}(c : OracleComp A B C) x
(S : Set)(eqds : EqDec S)(o : S -> A -> Comp (B * S))(s : S) s',
In (x, s') (getSupport (c _ _ o s)) ->
in_oc_supp x c .
induction c; intuition; repeat simp_in_support.
econstructor.
Local Opaque getSupport.
simpl in *.
repeat simp_in_support.
destruct x.
simpl.
destruct p.
simpl.
econstructor.
eapply (@IHc _ _ (S * S0)%type).
eapply H1.
simpl in *.
repeat simp_in_support.
econstructor.
intuition.
assert (EqDec C).
eapply oc_EqDec.
eapply c.
intuition.
assert (B * S).
eapply comp_base_exists.
eapply o0.
trivial.
intuition.
intuition.
intuition.
assert (EqDec (B * S)).
eapply comp_EqDec.
eapply o0; trivial.
eapply EqDec_pair_l.
eapply H2.
trivial.
simpl in *.
repeat simp_in_support.
destruct x0.
econstructor.
eapply (@H0 _ S).
eapply H2.
eapply (@H _ _ _ S).
eapply H3.
Grab Existential Variables.
eapply EqDec_pair_l.
eauto.
trivial.
Qed.
Local Open Scope nat_scope.
Inductive queries_at_most' : forall (A B C : Set), OracleComp A B C -> nat -> Prop :=
| qam_Bind :
forall (A B C C' : Set)(eqdc' : EqDec C')(c : OracleComp A B C')(f : C' -> OracleComp A B C) q1 q2,
queries_at_most' c q1 ->
(forall c',
in_oc_supp c' c ->
queries_at_most' (f c') q2) ->
queries_at_most' (OC_Bind c f) (q1 + q2)
| qam_Query :
forall (A B : Set)(a : A),
queries_at_most' (OC_Query B a) 1
| qam_Ret :
forall (A B C : Set)(c : Comp C),
queries_at_most' (OC_Ret A B c) 0
| qam_Run :
forall (A A' B B' C S : Set)(eqds : EqDec S)(eqda : EqDec A)(eqdb : EqDec B)
(c : OracleComp A B C)(oc : S -> A -> OracleComp A' B' (B * S)) s q1 q2,
queries_at_most' c q1 ->
(forall s a, queries_at_most' (oc s a) q2) ->
queries_at_most' (OC_Run _ _ _ c oc s) (q1 * q2)
| qam_le :
forall (A B C : Set)(c : OracleComp A B C) q1 q2,
queries_at_most' c q1 ->
q1 <= q2 ->
queries_at_most' c q2.
Theorem qam_count_gen' :
forall (A B C : Set)(c : OracleComp A B C)(q : nat),
queries_at_most' c q ->
forall (S : Set)(count : S -> nat)(eqds : EqDec S)(o : S -> A -> Comp (B * S))(s : S)(n : nat),
(forall a b x y,
In (a, b) (getSupport (o x y)) ->
count b <= n + (count x)) ->
forall a b,
In (a, b) (getSupport (c _ _ o s)) ->
count b <= q * n + (count s).
Opaque getSupport.
induction 1; intuition; simpl in *.
(* Bind case *)
repeat simp_in_support.
destruct x.
rewrite mult_plus_distr_r.
pose proof H4.
eapply (IHqueries_at_most' _ count) in H4.
eapply (H1 _ _ _ count) in H5.
rewrite H5.
rewrite plus_comm.
rewrite <- (plus_assoc).
rewrite (plus_comm (q2 * n)).
rewrite plus_assoc.
eapply plus_le_compat.
eauto.
eapply le_refl.
intuition.
intuition.
(* query case *)
rewrite plus_0_r.
eapply H; eauto.
(* ret case *)
Transparent getSupport.
repeat simp_in_support.
intuition.
(* run case *)
repeat simp_in_support.
destruct x.
simpl in *.
specialize (IHqueries_at_most' (S * S0)%type (fun p => count (snd p)) _
(fun (x : S * S0) (y : A) =>
p <-$ (oc (fst x) y) S0 eqds0 o (snd x);
ret (fst (fst p), (snd (fst p), snd p)))
(s, s0) (q2 * n)
).
eapply le_trans.
eapply IHqueries_at_most'.
intuition.
simpl.
repeat simp_in_support.
destruct x.
simpl in *.
eapply H1.
eauto.
eauto.
eauto.
simpl.
rewrite mult_assoc.
intuition.
(* trans case *)
eapply le_trans.
eapply IHqueries_at_most'.
eauto.
eauto.
eapply plus_le_compat; intuition.
eapply mult_le_compat; intuition.
Grab Existential Variables.
eapply in_oc_supp_complete; eauto.
Qed.
(*
Definition countOracle{A B State : Set}{eqdb : EqDec B}{eqds : EqDec State}(defB : B)(o : State -> A -> Comp (B * State)) p a :=
[s, n] <-2 p;
match n with
| 0 => ret (defB, p)
| S n' =>
[b', s'] <-$2 o s a;
ret (b', (s', n'))
end.
Theorem countOracle_equiv :
forall (A B C : Set)(defB : B)(eqdb : EqDec B)(eqdc : EqDec C)(c : OracleComp A B C) n,
queries_at_most' c n ->
forall (S : Set)(eqd : EqDec S)(o : S -> A -> Comp (B * S))(s : S),
comp_spec
(fun a b => fst a = fst b /\ snd a = fst (snd b))
(c _ _ o s)
(c _ _ (countOracle defB o) (s, n)).
induction 1; intuition; simpl in *.
admit.
admit.
admit.
comp_skip.
admit.
admit.
assert (EqDec C).
eapply EqDec_pair_l.
eauto.
trivial.
assert (B * S).
eapply oc_base_exists.
eapply oc
specialize (@IHqueries_at_most' eqdb0 H2 defB (S * S0)%type).
eapply H1.
eapply oc_comp_spec_eq.
Qed.
*)
Local Open Scope rat_scope.
Theorem evalDist_bind_event_le :
forall (A : Set)(c : Comp A)(f : A -> Comp bool)(evta : A -> bool) (k1 k2 : Rat),
Pr[a <-$ c; ret (evta a)] <= k1 ->
(forall a, In a (getSupport c) -> evta a = false -> Pr[f a] <= k2) ->
Pr[a <-$ c; f a] <= k1 + k2.
intuition.
simpl in *.
rewrite (sumList_partition evta).
eapply ratAdd_leRat_compat.
assert ( sumList (getSupport c)
(fun a : A => evalDist c a * Pr [f a ] * (if evta a then 1 else 0)) <=
sumList (getSupport c)
(fun b : A =>
evalDist c b * (if EqDec_dec bool_EqDec (evta b) true then 1 else 0)) ).
eapply sumList_le; intuition.
destruct (EqDec_dec bool_EqDec (evta a) true ).
rewrite e.
eapply ratMult_leRat_compat; intuition.
eapply leRat_trans.
eapply ratMult_leRat_compat.
eapply leRat_refl.
eapply evalDist_le_1.
rewrite ratMult_1_r.
intuition.
destruct (evta a); intuition.
repeat rewrite ratMult_0_r.
eapply rat0_le_all.
rewrite H1.
eapply H.
assert ( sumList (getSupport c)
(fun a : A => evalDist c a * Pr [f a ] * (if evta a then 0 else 1)) <=
sumList (getSupport c)
(fun a : A => k2 * (evalDist c a * (if evta a then 0 else 1)))).
eapply sumList_le.
intuition.
case_eq (evta a); intuition.
eapply eqRat_impl_leRat.
repeat rewrite ratMult_0_r.
intuition.
rewrite H0.
eapply eqRat_impl_leRat.
repeat rewrite ratMult_1_r.
eapply ratMult_comm.
trivial.
trivial.
rewrite H1.
rewrite sumList_factor_constant_l.
eapply leRat_trans.
Focus 2.
eapply eqRat_impl_leRat.
eapply ratMult_1_r.
eapply ratMult_leRat_compat; intuition.
assert (sumList (getSupport c)
(fun a : A => evalDist c a * (if evta a then 0 else 1)) <=
sumList (getSupport c)
(fun a : A => evalDist c a)).
eapply sumList_le.
intuition.
eapply leRat_trans.
Focus 2.
eapply eqRat_impl_leRat.
eapply ratMult_1_r.
eapply ratMult_leRat_compat; intuition.
destruct (evta a); intuition.
eapply rat0_le_all.
rewrite H2.
eapply evalDist_sum_le_1.
Qed.
Theorem oc_eventProb :
forall (A B C : Set)(c : OracleComp A B C) n,
queries_at_most' c n ->
forall
(S : Set)(eqds : EqDec S)(o : S -> A -> Comp (B * S))
(count : S -> nat)(evt : S -> bool)(s : S)(k : nat -> Rat) i,
(forall (n1 n2 : nat), (n1 <= n2)%nat -> (k n1 <= k n2)) ->
evt s = false ->
(forall s a, evt s = false -> Pr[p <-$ o s a; ret (evt (snd p))] <= (k (i + (count s))%nat)) ->
(forall s s' a b, In (b, s') (getSupport (o s a)) ->
count s' <= i + (count s))%nat ->
Pr[p <-$ c _ _ o s; ret (evt (snd p))] <= (n / 1) * (k (i * n + (count s))%nat).
Local Opaque evalDist.
induction 1; intuition; simpl in *.
inline_first.
assert (
Pr
[a <-$ c S eqds o s;
p <-$ ([z, s']<-2 a; (f z) S eqds o s'); ret evt (snd p) ] <=
q1 / 1 * k (i * q1 + count s)%nat +
q2 / 1 * k (i * q2 + (i * q1 + count s))%nat
).
eapply evalDist_bind_event_le.
eapply (@IHqueries_at_most' _ _ _ count evt); intuition.
intros.
comp_simp.
eapply leRat_trans.
eapply (@H1 _ _ _ _ _ count evt).
eapply H2.
trivial.
intuition.
intuition.
eapply ratMult_leRat_compat; intuition.
eapply H2.
eapply plus_le_compat; intuition.
Require Import RndInList.
eapply le_trans.
eapply (qam_count_gen' _ _ _ _ _ i).
intuition.
eapply H5.
eauto.
eauto.
rewrite mult_comm.
intuition.
rewrite H6.
clear H6.
eapply leRat_trans.
Focus 2.
eapply eqRat_impl_leRat.
symmetry.
rewrite ratAdd_num.
eapply ratMult_distrib_r.
eapply ratAdd_leRat_compat;
eapply ratMult_leRat_compat; intuition.
eapply H2.
rewrite mult_plus_distr_l.
rewrite plus_comm.
repeat rewrite <- plus_assoc.
eapply plus_le_compat; intuition.
rewrite H1; intuition.
rewrite <- ratMult_1_l.
eapply ratMult_leRat_compat; intuition.
eapply leRat_terms; intuition.
inline_first.
eapply distro_irr_le.
intuition.
comp_simp.
simpl.
rewrite H0.
rewrite evalDist_ret_0.
eapply rat0_le_all.
congruence.
inline_first.
assert (EqDec C).
eapply oc_EqDec; intros.
eapply c.
assert (B * S).
eapply oc_base_exists.
eapply oc.
trivial.
trivial.
intuition.
assert (B' * S0).
eapply comp_base_exists.
eapply o.
trivial.
trivial.
intuition.
intuition.
trivial.
assert
(
(evalDist
(Bind
(c (prod S S0) (pair_EqDec eqds eqds0)
(fun (x : prod S S0) (y : A) =>
Bind ((oc (fst x) y) S0 eqds0 o (snd x))
(fun p : prod (prod B S) S0 =>
Ret (EqDec_dec (pair_EqDec eqdb (pair_EqDec eqds eqds0)))
(pair (fst (fst p)) (pair (snd (fst p)) (snd p)))))
(pair s s0))
(fun a : prod C (prod S S0) =>
Bind
(Ret
(EqDec_dec
(pair_EqDec
(pair_EqDec
(oc_EqDec c
(fun x : A =>
fst
(oc_base_exists (oc s x)
(fun y : A' =>
fst (comp_base_exists (o s0 y)))))
(fun x : A =>
EqDec_pair_l
(oc_EqDec (oc s x)
(fun y : A' =>
fst (comp_base_exists (o s0 y)))
(fun y : A' =>
EqDec_pair_l (comp_EqDec (o s0 y)) s0)) s))
eqds) eqds0))
(pair (pair (fst a) (fst (snd a))) (snd (snd a))))
(fun p : prod (prod C S) S0 =>
Ret (EqDec_dec bool_EqDec) (evt (snd p))))) true)
==
Pr
[a <-$
c (S * S0)%type (pair_EqDec eqds eqds0)
(fun (x : S * S0) (y : A) =>
p <-$ (oc (fst x) y) S0 eqds0 o (snd x);
ret (fst (fst p), (snd (fst p), snd p))) (s, s0);
ret (evt (snd (snd a))) ]
).
comp_skip.
simpl.
intuition.
rewrite H7.
clear H7.
eapply leRat_trans.
eapply (@IHqueries_at_most' _ _
((fun (x : S * S0) (y : A) =>
p <-$ (oc (fst x) y) S0 eqds0 o (snd x);
ret (fst (fst p), (snd (fst p), snd p))))
(fun p => count (snd p)) (fun p => evt (snd p))
_ (fun x => q2 / 1 * k (x)%nat) (i * q2)%nat).
intuition.
eapply ratMult_leRat_compat; intuition.
trivial.
intuition.
comp_inline_l.
assert (
Pr
[a1 <-$ (oc (fst (a, b)) a0) S0 eqds0 o (snd (a, b));
p <-$ ret (fst (fst a1), (snd (fst a1), snd a1)); ret evt (snd (snd p)) ]
==
Pr
[a1 <-$ (oc (fst (a, b)) a0) S0 eqds0 o (snd (a, b));
ret evt (snd a1) ]
).
comp_skip.
simpl.
intuition.
rewrite H8.
clear H8.
simpl.
eapply leRat_trans.
eapply (@H1 ); intuition.
reflexivity.
intuition.
repeat simp_in_support.
destruct x.
simpl in *.
rewrite mult_comm.
eapply qam_count_gen'.
eapply H0.
intuition.
eapply H5.
eapply H7.
eapply H8.
simpl.
rewrite <- ratMult_assoc.
eapply ratMult_leRat_compat; intuition.
eapply eqRat_impl_leRat.
rewrite <- ratMult_num_den.
eapply eqRat_terms; intuition.
eapply H2.
eapply plus_le_compat; intuition.
rewrite <- mult_assoc.
eapply mult_le_compat; intuition.
rewrite mult_comm.
intuition.
rewrite IHqueries_at_most'.
eapply ratMult_leRat_compat; intuition.
eapply leRat_terms; intuition.
intuition.
trivial.
intuition.
intuition.
Grab Existential Variables.
trivial.
eapply in_oc_supp_complete; eauto.
Qed.
Theorem oc_eventProb_0_1 :
forall (S : Set)(count : S -> nat)(evt : S -> bool)(k : nat -> Rat)
(A B C : Set)(c : OracleComp A B C) n,
queries_at_most' c n ->
forall
(eqds : EqDec S)(o : S -> A -> Comp (B * S))
(s : S),
(forall (n1 n2 : nat), (n1 <= n2)%nat -> (k n1 <= k n2)) ->
evt s = false ->
(forall s a, evt s = false -> Pr[p <-$ o s a; ret (evt (snd p))] <= (k (1 + (count s))%nat)) ->
(forall s s' a b, In (b, s') (getSupport (o s a)) ->
count s' <= 1 + (count s))%nat ->
count s = 0%nat ->
Pr[p <-$ c _ _ o s; ret (evt (snd p))] <= (n / 1) * (k n).
intuition.
eapply leRat_trans.
eapply oc_eventProb; intuition.
eauto.
rewrite H4.
rewrite mult_1_l.
rewrite plus_0_r.
intuition.
Qed.
(*
Definition maxCount_o(D R S : Set){eqdr : EqDec R}{eqds : EqDec S}(count : S -> nat)(o : S -> D -> Comp (R * S))
(defR : R)(m : nat)(s : S)(d : D) :=
if (ge_dec (count s) m) then (ret (defR, s)) else
o s d.
Theorem maxCount_o_equiv :
forall (D R C: Set)(A : OracleComp D R C) (n1: nat),
queries_at_most A n1 ->
forall (S : Set)(count : S -> nat)(o : S -> D -> Comp (R * S))(defR : R)(eqdr : EqDec R)(eqds : EqDec S)(RndR : Comp R) s x n2,
(n1 + (count s) <= n2)%nat ->
evalDist (A _ _ o s) x ==
evalDist (A _ _ (maxCount_o count o defR n2) s) x.
Local Opaque evalDist.
induction 1; intuition; simpl in *.
comp_skip.
comp_simp.
eapply H1.
specialize (qam_count_gen H (fun (p : list (A * B)) => length p) _ (randomFunc RndR eqdd) ls); intuition.
eapply le_trans.
eapply plus_le_compat.
eapply le_refl.
eapply H4.
intuition; simpl in *.
unfold randomFunc in *.
destruct (arrayLookup eqdd x y); repeat simp_in_support.
omega.
simpl.
assert ( (S (length x) <= 1+ length x)%nat).
omega.
eapply H5.
eapply H3.
omega.
unfold randomFunc, randomFunc_max.
destruct (arrayLookup eqdd ls a).
eapply evalDist_ret_eq; intuition.
comp_skip.
destruct (ge_dec (length ls) n2).
omega.
eapply evalDist_ret_eq; intuition.
eapply eqRat_refl.
comp_skip.
remember (map
eapply (@IHqueries_at_most _ _ RndR ls.
trivial.
erewrite H4.
Print RndInList.
rewrite <- H2.
eapply plus_le_compat; intuition.
omega.
Qed.
*)
Section RandPermSwitching.
Variable A D R : Set.
Variable RndR : Comp R.
Hypothesis RndR_wf : well_formed_comp RndR.
Variable A2 : OracleComp D R bool.
Hypothesis eqdd : EqDec D.
Hypothesis eqdr : EqDec R.
Variable fBad : list (D * R) -> D -> R -> bool.
Variable badProb : nat -> Rat.
Hypothesis badProb_mono : forall n1 n2, (n1 <= n2)%nat -> badProb n1 <= badProb n2.
Hypothesis A2_wf : well_formed_oc A2.
Variable A2_queries : nat.
Hypothesis A2_queries_correct : queries_at_most' A2 A2_queries.
Hypothesis badProb_correct :
forall d f,
Pr [r <-$ RndR;
ret (fBad f d r)] <= badProb (S (length f)).
Hypothesis goodExists :
forall d f,
(length f <= A2_queries) %nat ->
exists r,
In r (getSupport RndR) /\
fBad f d r = false.
(*
Hypothesis fBad_single :
forall d r,
fBad ((d, r) :: nil) = false.
*)
(*
Hypothesis goodExists :
forall d f,
arrayLookup _ f d = None ->
exists r,
In r (getSupport RndR) /\
fBad f d r = false.
*)
Definition rndNotBad(d : D)(f : list (D * R)):=
Repeat RndR (fun r => negb (fBad f d r)).
Definition GenRP(s : list (D * R))(d : D) : Comp (R * list (D * R)) :=
match arrayLookup _ s d with
| Some r => ret (r, s)
| None => r <-$ (rndNotBad d s); ret (r, (d, r) :: s)
end.
Definition RPS_G0 :=
[b, _] <-$2 A2 _ _ (@randomFunc D R RndR _ ) nil;
ret b.
Definition RPS_G1 :=
[b, _] <-$2 A2 _ _ GenRP nil;
ret b.
Definition randomFunc_bad (s : list (D * R) * bool) d :=
[s, bad] <-2 s;
match (arrayLookup _ s d) with
| Some r => ret (r, (s, bad))
| None =>
r <-$ RndR;
newF <- ((d, r) :: s);
bad' <- fBad s d r;
ret (r, (newF, bad || bad'))
end.
Definition GenRP_bad (s : list (D * R) * bool) d :=
[s, bad] <-2 s;
match (arrayLookup _ s d) with
| Some r => ret (r, (s, bad))
| None =>
r <-$ RndR;
newF <- ((d, r) :: s);
bad' <- fBad s d r;
if (bad') then
(r <-$ rndNotBad d s;
ret (r, ((d, r) :: s, bad || bad')))
else
ret (r, (newF, bad || bad'))
end.
Definition RPS_G_1 :=
[b, s] <-$2 A2 _ _ (randomFunc_bad) (nil, false);
ret (b, snd s).
Definition RPS_G_2 :=
[b, s] <-$2 A2 _ _ (GenRP_bad) (nil, false);
ret (b, snd s).
Theorem randomFunc_bad_wf :
forall a b,
well_formed_comp (randomFunc_bad a b).
intuition.
unfold randomFunc_bad.
destruct (arrayLookup eqdd a0 b0); wftac.
Qed.
Theorem GenRP_bad_wf :
forall a b,
(length (fst a) <= A2_queries)%nat ->
well_formed_comp (GenRP_bad a b).
intuition.
simpl in *.
case_eq (arrayLookup eqdd a0 b0); intuition; wftac.
unfold rndNotBad; wftac.
edestruct goodExists ; eauto.
intuition.
econstructor.
unfold eq_dec; intuition.
eapply (EqDec_dec _).
trivial.
eapply filter_In; intuition.
eauto.
rewrite H4.
trivial.
Qed.
Theorem rf_rp_oc_eq_until_bad :
comp_spec
(fun y1 y2 =>
snd (snd y1) = snd (snd y2) /\
(snd (snd y1) = false -> fst (snd y1) = fst (snd y2) /\ fst y1 = fst y2))
(A2 (list (D * R) * bool)%type _
randomFunc_bad (nil, false))
(A2 (list (D * R) * bool)%type _
GenRP_bad (nil, false)).
eapply comp_spec_consequence.
eapply (@oc_comp_spec_eq_until_bad _ _ _ _ _ _ _ _ _ _ _ _ _
(fun a => snd a)
(fun a => snd a)
(fun a b => (fst a = fst b))).
intuition.
eapply randomFunc_bad_wf.
intuition.
eapply GenRP_bad_wf.
admit.
intuition.
simpl in *.
subst.
case_eq (arrayLookup eqdd a0 a1); intuition.
eapply comp_spec_ret; intuition.
comp_skip.
eapply comp_base_exists; eauto.
eapply comp_base_exists; eauto.
case_eq ( fBad a0 a1 b); intuition.
comp_irr_r.
unfold rndNotBad.
edestruct goodExists.
eauto.
intuition.
econstructor.
unfold eq_dec; intuition.
eapply (EqDec_dec _).
trivial.
eapply filter_In; intuition.
eauto.
rewrite H5.
trivial.
eapply comp_spec_ret.
simpl.
split.
intuition.
intros.
rewrite orb_true_r in H4.
discriminate.
eapply comp_spec_ret; intuition.
intuition.
simpl in *.
case_eq (arrayLookup eqdd a1 d); intuition.
rewrite H1 in H0.
repeat simp_in_support.
trivial.
rewrite H1 in H0.
repeat simp_in_support.
trivial.
intuition.
simpl in *.
case_eq (arrayLookup eqdd a1 d ); intuition;
rewrite H1 in H0;
repeat simp_in_support;
trivial.
trivial.
trivial.
intuition.
Grab Existential Variables.
trivial.
Qed.
Theorem RPS_G_1_2_bad_same :
Pr [x <-$ RPS_G_1; ret snd x ] == Pr [x <-$ RPS_G_2; ret snd x ].
unfold RPS_G_1, RPS_G_2.
inline_first.
eapply comp_spec_impl_eq.
comp_skip.
eapply rf_rp_oc_eq_until_bad.
intuition.
simpl in *.
intuition.
destruct b.
simpl in *.
destruct p; simpl in *.
subst.
comp_simp.
simpl.
eapply comp_spec_ret; intuition.
Qed.
Theorem RPG_G_1_2_eq_until_bad :
forall a : bool,
evalDist RPS_G_1 (a, false) == evalDist RPS_G_2 (a, false).
intuition.
unfold RPS_G_1, RPS_G_2.
eapply comp_spec_impl_eq.
comp_skip.
eapply rf_rp_oc_eq_until_bad.
intuition.
simpl in *.
intuition.
destruct b.
simpl in *.
destruct p; simpl in *.
eapply comp_spec_ret; intuition.
pairInv.
subst.
intuition.
subst.
intuition.
subst.
pairInv.
intuition.
subst.
trivial.
Qed.
Theorem RPS_G_1_bad_small :
Pr [x <-$ RPS_G_1; ret snd x ] <= A2_queries / 1 * badProb A2_queries.
unfold RPS_G_1.
inline_first.
assert (Pr
[a <-$
A2 (list (D * R) * bool)%type _
(randomFunc_bad) (nil, false);
x <-$ ([b, s]<-2 a; ret (b, snd s)); ret snd x ]
==
Pr
[a <-$
A2 (list (D * R) * bool)%type _
(randomFunc_bad) (nil, false);
ret snd (snd a) ]
).
comp_skip.
comp_simp.
reflexivity.
rewrite H.
clear H.
eapply leRat_trans.
eapply (@oc_eventProb_0_1 _ (fun p => length (fst p)) _ badProb).
eauto.
eapply badProb_mono.
trivial.
intuition.
simpl in *.
subst.
case_eq (arrayLookup eqdd a a0); intuition.
comp_simp.
simpl.
rewrite evalDist_ret_0.
eapply rat0_le_all.
congruence.
simpl in *.
eapply leRat_trans.
Focus 2.
eapply badProb_correct.
inline_first.
comp_skip.
simpl.
eapply leRat_refl.
intuition.
simpl in *.
destruct (arrayLookup eqdd a a1);
repeat simp_in_support.
omega.
simpl.
intuition.
trivial.
intuition.
Qed.
Theorem RPS_G_1_2_close :
| Pr[x <-$ RPS_G_1; ret fst x] - Pr[x <-$ RPS_G_2; ret fst x] | <= (A2_queries / 1) * badProb A2_queries.
intuition.
eapply leRat_trans.
eapply fundamental_lemma_h.
(* badness is the same. *)
eapply RPS_G_1_2_bad_same.
eapply RPG_G_1_2_eq_until_bad.
eapply RPS_G_1_bad_small.
Qed.
Theorem RPS_G0_equiv :
Pr[RPS_G0] == Pr[x <-$ RPS_G_1; ret fst x].
unfold RPS_G0, RPS_G_1.
inline_first.
eapply (comp_spec_eq_impl_eq).
comp_skip.
eapply (@oc_comp_spec_eq _ _ _ _ _ _ _ _ _ _ _ _ _ _ (fun a b => a = fst b)); trivial.
intuition.
subst.
unfold randomFunc, randomFunc_bad.
comp_simp.
simpl.
case_eq ( arrayLookup eqdd l a ); intuition.
eapply comp_spec_ret; intuition.
comp_skip.
eapply comp_base_exists; eauto.
eapply comp_base_exists; eauto.
eapply comp_spec_ret; intuition.
comp_simp.
simpl in *; intuition.
subst.
eapply comp_spec_eq_refl.
Qed.
Theorem RPS_G1_equiv :
Pr[x <-$ RPS_G_2; ret fst x] == Pr[RPS_G1].
unfold RPS_G_2, RPS_G1.
inline_first.
eapply comp_spec_eq_impl_eq.
comp_skip.
eapply (@oc_comp_spec_eq _ _ _ _ _ _ _ _ _ _ _ _ _ _ (fun a b => fst a = b)); trivial.
intuition.
unfold GenRP, GenRP_bad.
subst.
simpl.
case_eq (arrayLookup eqdd a0 a); intuition.
eapply comp_spec_ret; intuition.
unfold rndNotBad.
assert (
comp_spec
eq
(r <-$ (r <-$ RndR; if (negb (fBad a0 a r)) then (ret r) else (Repeat RndR (fun r : R => negb (fBad a0 a r))));
ret (r, (a, r) :: a0))
(r <-$ Repeat RndR (fun r : R => negb (fBad a0 a r));
ret (r, (a, r) :: a0))
).
eapply eq_impl_comp_spec_eq.
intuition.
symmetry.
comp_skip.
eapply repeat_unroll_eq.
trivial.
edestruct goodExists; eauto.
intuition.
econstructor.
eapply filter_In; intuition.
eauto.
rewrite H2.
trivial.
eapply comp_spec_eq_trans_r.
Focus 2.
eapply H0.
clear H0.
inline_first.
comp_skip.
eapply comp_base_exists; eauto.
eapply comp_base_exists; eauto.
case_eq (fBad a0 a b0); intuition.
simpl.
comp_skip.
eapply comp_spec_ret; intuition.
simpl.
comp_simp.
eapply comp_spec_ret; intuition.
comp_simp.
simpl in *.
intuition; subst.
eapply comp_spec_eq_refl.
Qed.
Theorem RPS_G0_1_close :
| Pr[RPS_G0] - Pr[RPS_G1] | <= (A2_queries / 1) * badProb A2_queries.
rewrite RPS_G0_equiv.
rewrite <- RPS_G1_equiv.
eapply RPS_G_1_2_close.
Qed.
End RandPermSwitching. |
! { dg-do compile }
! { dg-options "-Warray-temporaries" }
! PR 44235
! No temporary should be created for this, as the upper bounds
! are effectively identical.
program main
real a(10)
a = 0.
a(1:10:4) = a(1:9:4)
end program main
|
-- | This module provides generic functionality to deal with ensembles in
-- statistical mechanics.
module StatisticalMechanics.Ensemble where
import Numeric.Log
import Statistics.Probability
-- | The state probability functions provide conversion from some types @a@
-- into non-normalized probabilities. For "real" applications, using the
-- @logProbability@ function is preferred. This functions allows for easy
-- abstraction when types @a@ are given as fractions of some actual value (say:
-- deka-cal), or are discretized.
--
-- The returned values are not normalized, because we do not now the total
-- evidence @Z@ until integration over all states has happened -- which is not
-- feasible in a number of problems.
--
-- TODO replace @()@ with temperature and results with non-normalized @P@ or
-- @LogP@, depending. At some point we want to have type-level physical
-- quantities, hence the need for the second type.
class StateProbability a where
-- | Given a temperature and a state "energy", return the corresponding
-- non-normalized probability.
stateProbability
∷ Double
-- ^ this is @k*T@
→ a
-- ^ the energy (or discretized energy)
→ Probability NotNormalized Double
-- ^ probability of being in state @a@, but only proportional up to @1/Z@.
stateLogProbability
∷ Double
-- ^ this is @1/(k * T)@
→ a
-- ^ the energy (or discretized energy)
→ Log (Probability NotNormalized Double)
-- ^ resulting probability
instance StateProbability Double where
stateProbability kT x = Prob . exp . negate $ x/kT
{-# Inline stateProbability #-}
--stateLogProbability kT x = Exp . log . Prob . exp . negate $ x/kT
stateLogProbability kT x = Exp . Prob . negate $ x/kT
{-# Inline stateLogProbability #-}
|
import data.list tools.super .library_dev.data.list.comb .library_dev.data.list.set
open nat function tactic
-- lemmas of list
namespace list
variables {A B: Type}
private theorem mem_cons (x : A) (l : list A) : x ∈ x :: l :=
or.inl rfl
-- def upto : ℕ → list ℕ
-- | 0 := []
-- | (succ n) := n :: upto n
-- theorem lt_of_mem_upto {n i : nat} : i ∈ upto n → i < n :=
-- nat.rec_on n (λ h, absurd h (not_mem_nil i))
-- (λ a ih h, or.elim h
-- (begin intro l, rw l, apply lt_succ_self end)
-- (λ r, lt_trans (ih r) (lt_succ_self a)))
-- theorem upto_succ (n : nat) : upto (succ n) = n :: upto n := rfl
-- theorem length_upto : ∀ n, length (upto n) = n
-- | 0 := rfl
-- | (succ n) := begin simp [upto_succ, length_cons, length_upto] end
/- map -/
theorem map_nil (f : A → B) : list.map f [] = [] := rfl
end list
open list
-- lemmas of fin
namespace fin
attribute [simp]
private theorem length_nil {A : Type} : length (@nil A) = 0 :=
rfl
lemma val_mk (n i : nat) (Plt : i < n) : fin.val (fin.mk i Plt) = i := rfl
def upto (n : ℕ) : list (fin n) :=
dmap (λ i, i < n) fin.mk (list.upto n)
lemma map_val_upto (n : nat) : map fin.val (upto n) = list.upto n :=
map_dmap_of_inv_of_pos (val_mk n) (@lt_of_mem_upto n)
lemma length_upto (n : nat) : length (fin.upto n) = n :=
calc
length (fin.upto n) = length (list.upto n) : (map_val_upto n ▸ eq.symm (length_map fin.val (upto n)))
... = n : length_upto n
lemma upto_ne_nil_of_ne_zero (n : nat) (Hn : n ≠ 0) : fin.upto n ≠ [] :=
begin
intro Hup,
apply Hn,
rewrite [-(@length_nil (fin n)), -Hup],
apply eq.symm (length_upto _)
end
lemma mem_upto (n : nat) : ∀ (i : fin n), i ∈ upto n :=
take i, fin.rec_on i
(take ival Piltn,
have ival ∈ list.upto n, from mem_upto_of_lt Piltn,
mem_dmap Piltn this)
end fin
-- lemmas of bigops
-- namespace group_bigops
-- variables {A B : Type}
-- definition Suml (f : A → ℕ) : list A → ℕ
-- | [] := 0
-- | (a :: ls) := f a + Suml ls
-- definition addf {A B : Type} [sgB : add_semigroup B] (f : A → B) : B → A → B :=
-- λ b a, b + f a
-- definition Suml [add_monoid B] (l : list A) (f : A → B) : B :=
-- list.foldl (addf f) 0 l
-- theorem Suml_nil (f : A → B) : Suml [] f = 0 := Prodl_nil f
-- -- check add_monoid
-- end group_bigops
-- definitions
section
-- Suml
variables {A : Type}
definition Suml (f : A → ℕ) : list A → ℕ
| [] := 0
| (a :: ls) := f a + Suml ls
theorem le_add_of_le {a b c : ℕ} : a ≤ b → a ≤ b + c :=
begin
induction c with n ih, intro,super, intro h2,
apply le_succ_of_le, exact ih h2
end
theorem le_of_mem_Suml {f : A → ℕ} {a : A} {l : list A} :
a ∈ l → f a ≤ Suml f l :=
begin
induction l with b ls ih, intro h, exact absurd h (not_mem_nil _),
dsimp [Suml], intro h, assert h' : a = b ∨ a ∈ ls, exact h,
cases h' with l r, rw l, apply le_add_right,
rw add_comm,apply le_add_of_le, exact ih r
end
end
open list fin
inductive finite_tree : Type
| cons : Π {n : ℕ}, (fin n → finite_tree) → finite_tree
namespace finite_tree
-- definition size : finite_tree → ℕ
-- | (@cons n ts) := Suml (fin.upto n) (λ i, size (ts i)) + 1
def size : finite_tree → ℕ
| (@cons n ts) := Suml (λ i, size (ts i)) (fin.upto n) + 1
-- theorem exists_eq_cons_of_ne_nil {A : Type} {l : list A} : l ≠ [] → ∃ a, ∃ l', l = a::l' :=
-- list.rec_on l (λ H, absurd rfl H) (λ a l' IH H, ⟨a, ⟨l',rfl⟩⟩)
theorem pos_of_size (t : finite_tree) : 0 < size t :=
finite_tree.rec_on t (λ n ts ih, dec_trivial)
theorem lt_of_size_branches_aux {n : ℕ} (ts : fin n → finite_tree) (k : fin n) : size (ts k) < Suml (λ i, size (ts i)) (upto n) + 1 :=
begin
assert kin : k ∈ upto n, exact mem_upto n k,
assert h : size (ts k) ≤ Suml (λ i, size (ts i)) (upto n),
apply le_of_mem_Suml kin,
apply lt_succ_of_le, assumption
end
def embeds : finite_tree → finite_tree → Prop
| (@cons _ ts) (@cons _ us) := (∃ j, embeds (cons ts) (us j)) ∨
(∃ f, injective f ∧ ∀ i, embeds (ts i) (us (f i)))
infix ` ≼ `:50 := embeds -- \preceq
def node {ts : fin 0 → finite_tree} : finite_tree := @cons 0 ts
def {u} fin_zero_absurd {α : Sort u} (i : fin 0) : α :=
absurd i.2 (not_lt_zero i.1)
theorem node_embeds {ts : fin 0 → finite_tree} (t : finite_tree) : @cons 0 ts ≼ t :=
begin
induction t with n a ih,
dsimp [embeds],
pose f : fin 0 → fin n := λ i : fin 0, fin_zero_absurd i,
apply or.inr,
existsi f,
split,
intros i j hij, exact fin_zero_absurd i,
intro i, exact fin_zero_absurd i
end
theorem not_embeds_node {n : ℕ} {ts : fin (succ n) → finite_tree}
{tt : fin 0 → finite_tree}: ¬ cons ts ≼ cons tt :=
begin
intro h,
dsimp [embeds] at h,
cases h with h₁ h₂,
{ cases h₁ with i hi, exact fin_zero_absurd i },
cases h₂ with f hf, exact fin_zero_absurd (f ⟨0, zero_lt_succ _⟩)
end
theorem cons_embeds_cons_left {m n : ℕ} {ss : fin m → finite_tree} {ts : fin n → finite_tree}
{j : fin n} (H : cons ss ≼ ts j) :
cons ss ≼ cons ts :=
begin
cases m,
apply node_embeds, cases n,
exact fin_zero_absurd j,
apply or.inl (exists.intro j H)
end
theorem cons_embeds_cons_right {m n : ℕ} {ss : fin m → finite_tree} {ts : fin n → finite_tree}
{f : fin m → fin n} (injf : injective f) (Hf : ∀ i, ss i ≼ ts (f i)) :
cons ss ≼ cons ts :=
begin cases m, apply node_embeds, cases n,
exact fin_zero_absurd (f 0),
apply or.inr (exists.intro f (and.intro injf Hf))
end
theorem embeds_refl (t : finite_tree) : t ≼ t :=
begin
induction t with n a ih,
cases n, apply node_embeds,
apply cons_embeds_cons_right,
apply injective_id, exact ih
end
theorem embeds_trans_aux : ∀ {u s t}, t ≼ u → s ≼ t → s ≼ u :=
begin
intro u,
induction u with ul us ihu,
intros s t, cases s with sl ss,
cases t with tl ts,
intro H₁, dsimp [embeds] at H₁, cases H₁ with H₁₁ H₁₂,
cases H₁₁ with i H₁₁, intro H₂,
apply cons_embeds_cons_left (ihu _ H₁₁ H₂),
cases H₁₂ with f Hf, cases Hf with injf Hf,
intro H₂, dsimp [embeds] at H₂, cases H₂ with H₂₁ H₂₂,
cases H₂₁ with j H₂₁,
apply cons_embeds_cons_left (ihu _ (Hf j) H₂₁),
cases H₂₂ with g Hg, cases Hg with injg Hg,
apply cons_embeds_cons_right,
apply injective_comp injf injg,
intro i, apply ihu _ (Hf (g i)) (Hg i)
end
theorem embeds_trans {s t u : finite_tree} (H₁ : s ≼ t) (H₂ : t ≼ u) : s ≼ u :=
embeds_trans_aux H₂ H₁
-- proposition cons_embeds_iff {m : ℕ} (ss : fin m → finite_tree) (t : finite_tree) :
-- cons ss ≼ t ↔ ∃ n (ts : fin n → finite_tree), t = cons ts ∧
-- ((∃ j, cons ss ≼ ts j) ∨ (∃ f, injective f ∧ ∀ i, ss i ≼ ts (f i))) :=
-- begin
-- apply iff.intro,
-- intro H, cases t with n ts,
-- contradiction,
-- existsi n, existsi ts, split, reflexivity, apply cons_embeds_cons_dest H,
-- intro H, cases H with n H, cases H with ts H, cases H with teq H,
-- rewrite teq, exact H
-- end
end finite_tree
|
(* Title: statecharts/HA/HA.thy
Author: Steffen Helke, Software Engineering Group
Copyright 2010 Technische Universitaet Berlin
*)
section \<open>Syntax of Hierarchical Automata\<close>
theory HA
imports SA
begin
subsection \<open>Definitions\<close>
(* unique root automaton *)
definition
RootEx :: "[(('s,'e,'d)seqauto) set,
's \<rightharpoonup> ('s,'e,'d) seqauto set] => bool" where
"RootEx F G = (\<exists>! A. A \<in> F \<and> A \<notin> \<Union> (ran G))"
definition
Root :: "[(('s,'e,'d)seqauto) set,
's \<rightharpoonup> ('s,'e,'d) seqauto set]
=> ('s,'e,'d) seqauto" where
"Root F G = (@ A. A \<in> F \<and> A \<notin> \<Union> (ran G))"
(* mutually distinct state spaces *)
definition
MutuallyDistinct :: "(('s,'e,'d)seqauto) set => bool" where
"MutuallyDistinct F =
(\<forall> a \<in> F. \<forall> b \<in> F. a \<noteq> b \<longrightarrow> (States a) \<inter> (States b) = {})"
(* exactly one ancestor for every non root automaton *)
definition
OneAncestor :: "[(('s,'e,'d)seqauto) set,
's \<rightharpoonup> ('s,'e,'d) seqauto set] => bool" where
"OneAncestor F G =
(\<forall> A \<in> F - {Root F G} .
\<exists>! s. s \<in> (\<Union> A' \<in> F - {A} . States A') \<and>
A \<in> the (G s))"
(* composition function contains no cycles *)
definition
NoCycles :: "[(('s,'e,'d)seqauto) set,
's \<rightharpoonup> ('s,'e,'d) seqauto set] => bool" where
"NoCycles F G =
(\<forall> S \<in> Pow (\<Union> A \<in> F. States A).
S \<noteq> {} \<longrightarrow> (\<exists> s \<in> S. S \<inter> (\<Union> A \<in> the (G s). States A) = {}))"
(* properties of composition functions *)
definition
IsCompFun :: "[(('s,'e,'d)seqauto) set,
's \<rightharpoonup> ('s,'e,'d) seqauto set] => bool" where
"IsCompFun F G = ((dom G = (\<Union> A \<in> F. States A)) \<and>
(\<Union> (ran G) = (F - {Root F G})) \<and>
(RootEx F G) \<and>
(OneAncestor F G) \<and>
(NoCycles F G))"
subsubsection \<open>Well-formedness for the syntax of HA\<close>
definition
HierAuto :: "['d data,
(('s,'e,'d)seqauto) set,
'e set,
's \<rightharpoonup> (('s,'e,'d)seqauto) set]
=> bool" where
"HierAuto D F E G = ((\<Union> A \<in> F. SAEvents A) \<subseteq> E \<and>
MutuallyDistinct F \<and>
finite F \<and>
IsCompFun F G)"
lemma HierAuto_EmptySet:
"((@x. True),{Abs_seqauto ({@x. True}, (@x. True), {}, {})}, {},
Map.empty ( @x. True \<mapsto> {})) \<in> {(D,F,E,G) | D F E G. HierAuto D F E G}"
apply (unfold HierAuto_def IsCompFun_def Root_def RootEx_def MutuallyDistinct_def
OneAncestor_def NoCycles_def)
apply auto
done
definition
"hierauto =
{(D,F,E,G) |
(D::'d data)
(F::(('s,'e,'d) seqauto) set)
(E::('e set))
(G::('s \<rightharpoonup> (('s,'e,'d) seqauto) set)).
HierAuto D F E G}"
typedef ('s,'e,'d) hierauto =
"hierauto :: ('d data * ('s,'e,'d) seqauto set * 'e set * ('s \<rightharpoonup> ('s,'e,'d) seqauto set)) set"
unfolding hierauto_def
apply (rule exI)
apply (rule HierAuto_EmptySet)
done
definition
SAs :: "(('s,'e,'d) hierauto) => (('s,'e,'d) seqauto) set" where
"SAs = fst o snd o Rep_hierauto"
definition
HAEvents :: "(('s,'e,'d) hierauto) => ('e set)" where
"HAEvents = fst o snd o snd o Rep_hierauto"
definition
CompFun :: "(('s,'e,'d) hierauto) => ('s \<rightharpoonup> ('s,'e,'d) seqauto set)" where
"CompFun = (snd o snd o snd o Rep_hierauto)"
definition
HAStates :: "(('s,'e,'d) hierauto) => ('s set)" where
"HAStates HA = (\<Union> A \<in> (SAs HA). States A)"
definition
HADelta :: "(('s,'e,'d) hierauto) => (('s,'e,'d)trans)set" where
"HADelta HA = (\<Union> F \<in> (SAs HA). Delta F)"
definition
HAInitValue :: "(('s,'e,'d) hierauto) => 'd data" where
"HAInitValue == fst o Rep_hierauto"
definition
HAInitStates :: "(('s,'e,'d) hierauto) => 's set" where
"HAInitStates HA == \<Union> A \<in> (SAs HA). { InitState A }"
definition
HARoot :: "(('s,'e,'d) hierauto) => ('s,'e,'d)seqauto" where
"HARoot HA == Root (SAs HA) (CompFun HA)"
definition
HAInitState :: "(('s,'e,'d) hierauto) => 's" where
"HAInitState HA == InitState (HARoot HA)"
subsubsection \<open>State successor function\<close>
(* state successor function Chi *)
definition
Chi :: "('s,'e,'d)hierauto => 's => 's set" where
"Chi A == (\<lambda> S \<in> (HAStates A) .
{S'. \<exists> SA \<in> (SAs A) . SA \<in> the ((CompFun A) S) \<and> S' \<in> States SA })"
(* direct state successor relation ChiRel *)
definition
ChiRel :: "('s,'e,'d)hierauto => ('s *'s) set" where
"ChiRel A == { (S,S'). S \<in> HAStates A \<and> S' \<in> HAStates A \<and> S' \<in> (Chi A) S }"
(* indirect state successor relation ChiPlus *)
definition
ChiPlus :: "('s,'e,'d)hierauto => ('s *'s) set" where
"ChiPlus A == (ChiRel A) ^+"
definition
ChiStar :: "('s,'e,'d)hierauto => ('s *'s) set" where
"ChiStar A == (ChiRel A) ^*"
(* priority on transitions that are successors *)
definition
HigherPriority :: "[('s,'e,'d)hierauto,
('s,'e,'d)trans * ('s,'e,'d)trans] => bool" where
"HigherPriority A ==
\<lambda> (t,t') \<in> (HADelta A) \<times> (HADelta A).
(source t',source t) \<in> ChiPlus A"
subsubsection \<open>Configurations\<close>
(* initial configuration *)
definition
InitConf :: "('s,'e,'d)hierauto => 's set" where
"InitConf A == (((((HAInitStates A) \<times> (HAInitStates A)) \<inter> (ChiRel A))^* )
`` {HAInitState A})"
(* -------------------------------------------------------------- *)
(* First, the original definition calculating a step on *)
(* configurations given by *)
(* *)
(* E. Mikk, Y. Lakhnech, and M. Siegel. Hierarchical automata as *)
(* model for statecharts. In Asian Computing Science Conference *)
(* (ASIAN~97), Springer LNCS, 1345, 1997. *)
(*
"StepConf A C TS ==
(C - ((ChiStar A) `` (Source TS))) \<union>
(Target TS) \<union> (((ChiPlus A) `` (Target TS))
\<inter> (HAInitStates A))"
*)
(* *)
(* Note, that this semantic definition not preserves the *)
(* well-formedness of a Statecharts. Hence we use our definition. *)
(* -------------------------------------------------------------- *)
(* step on configurations *)
definition
StepConf :: "[('s,'e,'d)hierauto, 's set,
('s,'e,'d)trans set] => 's set" where
"StepConf A C TS ==
(C - ((ChiStar A) `` (Source TS))) \<union>
(Target TS) \<union>
((ChiRel A) `` (Target TS)) \<inter> (HAInitStates A) \<union>
((((ChiRel A) \<inter> ((HAInitStates A) \<times> (HAInitStates A)))\<^sup>+)
`` (((ChiRel A)`` (Target TS)) \<inter> (HAInitStates A)))"
subsection \<open>Lemmas\<close>
lemma Rep_hierauto_tuple:
"Rep_hierauto HA = (HAInitValue HA, SAs HA, HAEvents HA, CompFun HA)"
by (unfold SAs_def HAEvents_def CompFun_def HAInitValue_def, simp)
lemma Rep_hierauto_select:
"(HAInitValue HA, SAs HA, HAEvents HA, CompFun HA): hierauto"
by (rule Rep_hierauto_tuple [THEN subst], rule Rep_hierauto)
lemma HierAuto_select [simp]:
"HierAuto (HAInitValue HA) (SAs HA) (HAEvents HA) (CompFun HA)"
by (cut_tac Rep_hierauto_select, unfold hierauto_def, simp)
subsubsection \<open>\<open>HAStates\<close>\<close>
lemma finite_HAStates [simp]:
"finite (HAStates HA)"
apply (cut_tac Rep_hierauto_select)
apply (unfold hierauto_def HierAuto_def)
apply auto
apply (simp add: HAStates_def)
apply (rule finite_UN_I)
apply fast
apply (rule finite_States)
done
lemma HAStates_SA_mem:
"\<lbrakk> SA \<in> SAs A; S \<in> States SA \<rbrakk> \<Longrightarrow> S \<in> HAStates A"
by (unfold HAStates_def, auto)
lemma ChiRel_HAStates [simp]:
"(a,b) \<in> ChiRel A \<Longrightarrow> a \<in> HAStates A"
apply (unfold ChiRel_def)
apply auto
done
lemma ChiRel_HAStates2 [simp]:
"(a,b) \<in> ChiRel A \<Longrightarrow> b \<in> HAStates A"
apply (unfold ChiRel_def)
apply auto
done
subsubsection \<open>\<open>HAEvents\<close>\<close>
lemma HAEvents_SAEvents_SAs:
"\<Union>(SAEvents ` (SAs HA)) \<subseteq> HAEvents HA"
apply (cut_tac Rep_hierauto_select)
apply (unfold hierauto_def HierAuto_def)
apply fast
done
subsubsection \<open>\<open>NoCycles\<close>\<close>
lemma NoCycles_EmptySet [simp]:
"NoCycles {} S"
by (unfold NoCycles_def, auto)
lemma NoCycles_HA [simp]:
"NoCycles (SAs HA) (CompFun HA)"
apply (cut_tac Rep_hierauto_select)
apply (unfold hierauto_def HierAuto_def IsCompFun_def)
apply auto
done
subsubsection \<open>\<open>OneAncestor\<close>\<close>
lemma OneAncestor_HA [simp]:
"OneAncestor (SAs HA) (CompFun HA)"
apply (cut_tac Rep_hierauto_select)
apply (unfold hierauto_def HierAuto_def IsCompFun_def)
apply auto
done
subsubsection \<open>\<open>MutuallyDistinct\<close>\<close>
lemma MutuallyDistinct_Single [simp]:
"MutuallyDistinct {SA}"
by (unfold MutuallyDistinct_def, auto)
lemma MutuallyDistinct_EmptySet [simp]:
"MutuallyDistinct {}"
by (unfold MutuallyDistinct_def, auto)
lemma MutuallyDistinct_Insert:
"\<lbrakk> MutuallyDistinct S; (States A) \<inter> (\<Union> B \<in> S. States B) = {} \<rbrakk>
\<Longrightarrow> MutuallyDistinct (insert A S)"
by (unfold MutuallyDistinct_def, safe, fast+)
lemma MutuallyDistinct_Union:
"\<lbrakk> MutuallyDistinct A; MutuallyDistinct B;
(\<Union> C \<in> A. States C) \<inter> (\<Union> C \<in> B. States C) = {} \<rbrakk>
\<Longrightarrow> MutuallyDistinct (A \<union> B)"
by (unfold MutuallyDistinct_def, safe, blast+)
lemma MutuallyDistinct_HA [simp]:
"MutuallyDistinct (SAs HA)"
apply (cut_tac Rep_hierauto_select)
apply (unfold hierauto_def HierAuto_def IsCompFun_def)
apply auto
done
subsubsection \<open>\<open>RootEx\<close>\<close>
lemma RootEx_Root [simp]:
"RootEx F G \<Longrightarrow> Root F G \<in> F"
apply (unfold RootEx_def Root_def)
apply (erule ex1E)
apply (erule conjE)
apply (rule someI2)
apply blast+
done
lemma RootEx_Root_ran [simp]:
"RootEx F G \<Longrightarrow> Root F G \<notin> \<Union> (ran G)"
apply (unfold RootEx_def Root_def)
apply (erule ex1E)
apply (erule conjE)
apply (rule someI2)
apply blast+
done
lemma RootEx_States_Subset [simp]:
"(RootEx F G) \<Longrightarrow> States (Root F G) \<subseteq> (\<Union> x \<in> F . States x)"
apply (unfold RootEx_def Root_def)
apply (erule ex1E)
apply (erule conjE)
apply (rule someI2)
apply fast
apply (unfold UNION_eq)
apply (simp add: subset_eq)
apply auto
done
lemma RootEx_States_notdisjunct [simp]:
"RootEx F G \<Longrightarrow> States (Root F G) \<inter> (\<Union> x \<in> F . States x) \<noteq> {}"
apply (frule RootEx_States_Subset)
apply (case_tac "States (Root F G)={}")
prefer 2
apply fast
apply simp
done
lemma Root_neq_SA [simp]:
"\<lbrakk> RootEx F G; (\<Union> x \<in> F . States x) \<inter> States SA = {} \<rbrakk> \<Longrightarrow> Root F G \<noteq> SA"
apply (rule SA_States_disjunct)
apply (frule RootEx_States_Subset)
apply fast
done
lemma RootEx_HA [simp]:
"RootEx (SAs HA) (CompFun HA)"
apply (cut_tac Rep_hierauto_select)
apply (unfold hierauto_def HierAuto_def IsCompFun_def)
apply fast
done
subsubsection \<open>\<open>HARoot\<close>\<close>
lemma HARoot_SAs [simp]:
"(HARoot HA) \<in> SAs HA"
apply (unfold HARoot_def)
apply (cut_tac Rep_hierauto_select)
apply (unfold hierauto_def HierAuto_def)
apply auto
done
lemma States_HARoot_HAStates:
"States (HARoot HA) \<subseteq> HAStates HA"
apply (unfold HAStates_def)
apply auto
apply (rule_tac x="HARoot HA" in bexI)
apply auto
done
lemma SAEvents_HARoot_HAEvents:
"SAEvents (HARoot HA) \<subseteq> HAEvents HA"
apply (cut_tac Rep_hierauto_select)
apply (unfold hierauto_def HierAuto_def)
apply auto
apply (rename_tac S)
apply (unfold UNION_eq)
apply (simp add: subset_eq)
apply (erule_tac x=S in allE)
apply auto
done
lemma HARoot_ran_CompFun:
"HARoot HA \<notin> Union (ran (CompFun HA))"
apply (unfold HARoot_def)
apply (cut_tac Rep_hierauto_select)
apply (unfold IsCompFun_def hierauto_def HierAuto_def)
apply fast
done
lemma HARoot_ran_CompFun2:
"S \<in> ran (CompFun HA) \<longrightarrow> HARoot HA \<notin> S"
apply (unfold HARoot_def)
apply (cut_tac Rep_hierauto_select)
apply (unfold IsCompFun_def hierauto_def HierAuto_def)
apply fast
done
subsubsection \<open>\<open>CompFun\<close>\<close>
lemma IsCompFun_HA [simp]:
"IsCompFun (SAs HA) (CompFun HA)"
apply (cut_tac Rep_hierauto_select)
apply (unfold hierauto_def HierAuto_def)
apply auto
done
lemma dom_CompFun [simp]:
"dom (CompFun HA) = HAStates HA"
apply (cut_tac HA=HA in IsCompFun_HA)
apply (unfold IsCompFun_def HAStates_def)
apply auto
done
lemma ran_CompFun [simp]:
"Union (ran (CompFun HA)) = ((SAs HA) - {Root (SAs HA)(CompFun HA)})"
apply (cut_tac HA=HA in IsCompFun_HA)
apply (unfold IsCompFun_def)
apply fast
done
lemma ran_CompFun_subseteq:
"Union (ran (CompFun HA)) \<subseteq> (SAs HA)"
apply (cut_tac HA=HA in IsCompFun_HA)
apply (unfold IsCompFun_def)
apply fast
done
lemma ran_CompFun_is_not_SA:
"\<not> Sas \<subseteq> (SAs HA) \<Longrightarrow> Sas \<notin> (ran (CompFun HA))"
apply (cut_tac HA=HA in IsCompFun_HA)
apply (unfold IsCompFun_def)
apply fast
done
lemma HAStates_HARoot_CompFun [simp]:
"S \<in> HAStates HA \<Longrightarrow> HARoot HA \<notin> the (CompFun HA S)"
apply (rule ran_dom_the)
back
apply (simp add: HARoot_ran_CompFun2 HARoot_def HAStates_def)+
done
lemma HAStates_CompFun_SAs:
"S \<in> HAStates A \<Longrightarrow> the (CompFun A S) \<subseteq> SAs A"
apply auto
apply (rename_tac T)
apply (cut_tac HA=A in ran_CompFun)
apply (erule equalityE)
apply (erule_tac c=T in subsetCE)
apply (drule ran_dom_the)
apply auto
done
lemma HAStates_CompFun_notmem [simp]:
"\<lbrakk> S \<in> HAStates A; SA \<in> the (CompFun A S) \<rbrakk> \<Longrightarrow> S \<notin> States SA"
apply (unfold HAStates_def)
apply auto
apply (rename_tac T)
apply (cut_tac HA=A in MutuallyDistinct_HA)
apply (unfold MutuallyDistinct_def)
apply (erule_tac x=SA in ballE)
apply (erule_tac x=T in ballE)
apply auto
prefer 2
apply (cut_tac A=A and S=S in HAStates_CompFun_SAs)
apply (unfold HAStates_def)
apply simp
apply fast
apply fast
apply (cut_tac HA=A in NoCycles_HA)
apply (unfold NoCycles_def)
apply (erule_tac x="{S}" in ballE)
apply auto
done
lemma CompFun_Int_disjoint:
"\<lbrakk> S \<noteq> T; S \<in> HAStates A; T \<in> HAStates A \<rbrakk> \<Longrightarrow> the (CompFun A T) \<inter> the (CompFun A S) = {}"
apply auto
apply (rename_tac U)
apply (cut_tac HA=A in OneAncestor_HA)
apply (unfold OneAncestor_def)
apply (erule_tac x=U in ballE)
prefer 2
apply simp
apply (fold HARoot_def)
apply (frule HAStates_HARoot_CompFun)
apply simp
apply (frule HAStates_CompFun_SAs)
apply auto
apply (erule_tac x=S in allE)
apply (erule_tac x=T in allE)
apply auto
apply (cut_tac HA=A in NoCycles_HA)
apply (unfold NoCycles_def)
apply (simp only: HAStates_def)
apply safe
apply (erule_tac x="{S}" in ballE)
apply simp
apply fast
apply simp
apply (cut_tac HA=A in NoCycles_HA)
apply (unfold NoCycles_def)
apply (simp only: HAStates_def)
apply safe
apply (erule_tac x="{T}" in ballE)
apply simp
apply fast
apply simp
done
subsubsection \<open>\<open>SAs\<close>\<close>
lemma finite_SAs [simp]:
"finite (SAs HA)"
apply (cut_tac Rep_hierauto_select)
apply (unfold hierauto_def HierAuto_def)
apply fast
done
lemma HAStates_SAs_disjunct:
"HAStates HA1 \<inter> HAStates HA2 = {} \<Longrightarrow> SAs HA1 \<inter> SAs HA2 = {}"
apply (unfold UNION_eq HAStates_def Int_def)
apply auto
apply (rename_tac SA)
apply (cut_tac SA=SA in EX_State_SA)
apply (erule exE)
apply auto
done
lemma HAStates_CompFun_SAs_mem [simp]:
"\<lbrakk> S \<in> HAStates A; T \<in> the (CompFun A S) \<rbrakk> \<Longrightarrow> T \<in> SAs A"
apply (cut_tac A=A and S=S in HAStates_CompFun_SAs)
apply auto
done
lemma SAs_States_HAStates:
"SA \<in> SAs A \<Longrightarrow> States SA \<subseteq> HAStates A"
by (unfold HAStates_def, auto)
subsubsection \<open>\<open>HAInitState\<close>\<close>
lemma HAInitState_HARoot [simp]:
"HAInitState A \<in> States (HARoot A)"
by (unfold HAInitState_def, auto)
lemma HAInitState_HARoot2 [simp]:
"HAInitState A \<in> States (Root (SAs A) (CompFun A))"
by (fold HARoot_def, simp)
lemma HAInitStates_HAStates [simp]:
"HAInitStates A \<subseteq> HAStates A"
apply (unfold HAInitStates_def HAStates_def)
apply auto
done
lemma HAInitStates_HAStates2 [simp]:
"S \<in> HAInitStates A \<Longrightarrow> S \<in> HAStates A"
apply (cut_tac A=A in HAInitStates_HAStates)
apply fast
done
lemma HAInitState_HAStates [simp]:
"HAInitState A \<in> HAStates A"
apply (unfold HAStates_def)
apply auto
apply (rule_tac x="HARoot A" in bexI)
apply auto
done
lemma HAInitState_HAInitStates [simp]:
"HAInitState A \<in> HAInitStates A"
by (unfold HAInitStates_def HAInitState_def, auto)
lemma CompFun_HAInitStates_HAStates [simp]:
"\<lbrakk> S \<in> HAStates A; SA \<in> the (CompFun A S) \<rbrakk> \<Longrightarrow> (InitState SA) \<in> HAInitStates A"
apply (unfold HAInitStates_def)
apply auto
done
lemma CompFun_HAInitState_HAInitStates [simp]:
"\<lbrakk> SA \<in> the (CompFun A (HAInitState A)) \<rbrakk> \<Longrightarrow> (InitState SA) \<in> HAInitStates A"
apply (unfold HAInitStates_def)
apply auto
apply (rule_tac x=SA in bexI)
apply auto
apply (cut_tac A=A and S="HAInitState A" in HAStates_CompFun_SAs)
apply auto
done
lemma HAInitState_notmem_States [simp]:
"\<lbrakk> S \<in> HAStates A; SA \<in> the (CompFun A S) \<rbrakk> \<Longrightarrow> HAInitState A \<notin> States SA"
apply (cut_tac HA=A in MutuallyDistinct_HA)
apply (unfold MutuallyDistinct_def)
apply (erule_tac x=SA in ballE)
apply (erule_tac x="HARoot A" in ballE)
apply auto
done
lemma InitState_notmem_States [simp]:
"\<lbrakk> S \<in> HAStates A; SA \<in> the (CompFun A S);
T \<in> HAInitStates A; T \<noteq> InitState SA \<rbrakk>
\<Longrightarrow> T \<notin> States SA"
apply (unfold HAInitStates_def)
apply auto
apply (rename_tac SAA)
apply (cut_tac HA=A in MutuallyDistinct_HA)
apply (unfold MutuallyDistinct_def)
apply (erule_tac x=SA in ballE)
apply (erule_tac x=SAA in ballE)
apply auto
done
lemma InitState_States_notmem [simp]:
"\<lbrakk> B \<in> SAs A; C \<in> SAs A; B \<noteq> C \<rbrakk> \<Longrightarrow> InitState B \<notin> States C"
apply auto
apply (cut_tac HA=A in MutuallyDistinct_HA)
apply (unfold MutuallyDistinct_def)
apply force
done
lemma OneHAInitState_SAStates:
"\<lbrakk> S \<in> HAInitStates A; T \<in> HAInitStates A;
S \<in> States SA; T \<in> States SA; SA \<in> SAs A \<rbrakk> \<Longrightarrow>
S = T"
apply (unfold HAInitStates_def)
apply auto
apply (rename_tac AA AAA)
apply (case_tac "AA = SA")
apply auto
apply (case_tac "AAA = SA")
apply auto
done
subsubsection \<open>\<open>Chi\<close>\<close>
lemma HARootStates_notmem_Chi [simp]:
"\<lbrakk> S \<in> HAStates A; T \<in> States (HARoot A) \<rbrakk> \<Longrightarrow> T \<notin> Chi A S"
apply (unfold Chi_def restrict_def, auto)
apply (rename_tac SA)
apply (cut_tac HA="A" in MutuallyDistinct_HA)
apply (unfold MutuallyDistinct_def)
apply (erule_tac x="HARoot A" in ballE)
apply (erule_tac x="SA" in ballE)
apply auto
done
lemma SAStates_notmem_Chi [simp]:
"\<lbrakk> S \<in> States SA; T \<in> States SA;
SA \<in> SAs A \<rbrakk> \<Longrightarrow> T \<notin> Chi A S"
apply (unfold Chi_def restrict_def, auto)
apply (rename_tac SAA)
apply (cut_tac HA="A" in MutuallyDistinct_HA)
apply (unfold MutuallyDistinct_def)
apply (erule_tac x="SAA" in ballE)
apply (erule_tac x="SA" in ballE)
apply auto
apply (unfold HAStates_def)
apply auto
done
lemma HAInitState_notmem_Chi [simp]:
"S \<in> HAStates A \<Longrightarrow> HAInitState A \<notin> Chi A S"
by (unfold Chi_def restrict_def, auto)
lemma Chi_HAStates [simp]:
"T \<in> HAStates A \<Longrightarrow> (Chi A T) \<subseteq> HAStates A"
apply (unfold Chi_def restrict_def)
apply (auto)
apply (cut_tac A=A and S=T in HAStates_CompFun_SAs)
apply (unfold HAStates_def)
apply auto
done
lemma Chi_HAStates_Self [simp]:
"s \<in> HAStates a \<Longrightarrow> s \<notin> (Chi a s)"
by (unfold Chi_def restrict_def, auto)
lemma ChiRel_HAStates_Self [simp]:
"(s,s) \<notin> (ChiRel a)"
by( unfold ChiRel_def, auto)
lemma HAStates_Chi_NoCycles:
"\<lbrakk> s \<in> HAStates a; t \<in> HAStates a; s \<in> Chi a t \<rbrakk> \<Longrightarrow> t \<notin> Chi a s"
apply (unfold Chi_def restrict_def)
apply auto
apply (cut_tac HA=a in NoCycles_HA)
apply (unfold NoCycles_def)
apply (erule_tac x="{s,t}" in ballE)
apply auto
done
lemma HAStates_Chi_NoCycles_trans:
"\<lbrakk> s \<in> HAStates a; t \<in> HAStates a; u \<in> HAStates a;
t \<in> Chi a s; u \<in> Chi a t \<rbrakk> \<Longrightarrow> s \<notin> Chi a u"
apply (unfold Chi_def restrict_def)
apply auto
apply (cut_tac HA=a in NoCycles_HA)
apply (unfold NoCycles_def)
apply (erule_tac x="{s,t,u}" in ballE)
prefer 2
apply simp
apply (unfold HAStates_def)
apply auto
done
lemma SAStates_Chi_trans [rule_format]:
"\<lbrakk> U \<in> Chi A T; S \<in> Chi A U; T \<in> States SA;
SA \<in> SAs A; U \<in> HAStates A \<rbrakk> \<Longrightarrow> S \<notin> States SA"
apply (frule HAStates_SA_mem)
apply auto
apply (unfold Chi_def restrict_def)
apply auto
apply (rename_tac SAA SAAA)
apply (cut_tac HA=A in NoCycles_HA)
apply (unfold NoCycles_def)
apply (erule_tac x="{U,T}" in ballE)
prefer 2
apply (simp only: HAStates_def)
apply auto
apply (cut_tac HA=A in MutuallyDistinct_HA)
apply (unfold MutuallyDistinct_def)
apply (rotate_tac -1)
apply (erule_tac x=SA in ballE)
apply (rotate_tac -1)
apply (erule_tac x=SAAA in ballE)
apply auto
done
subsubsection \<open>\<open>ChiRel\<close>\<close>
lemma finite_ChiRel [simp]:
"finite (ChiRel A)"
apply (rule_tac B="HAStates A \<times> HAStates A" in finite_subset)
apply auto
done
lemma ChiRel_HAStates_subseteq [simp]:
"(ChiRel A) \<subseteq> (HAStates A \<times> HAStates A)"
apply (unfold ChiRel_def Chi_def restrict_def)
apply auto
done
lemma ChiRel_CompFun:
"s \<in> HAStates a \<Longrightarrow> ChiRel a `` {s} = (\<Union> x \<in> the (CompFun a s). States x)"
apply (unfold ChiRel_def Chi_def restrict_def Image_def)
apply simp
apply auto
apply (frule HAStates_CompFun_SAs_mem)
apply fast
apply (unfold HAStates_def)
apply fast
done
lemma ChiRel_HARoot:
"\<lbrakk> (x,y) \<in> ChiRel A \<rbrakk> \<Longrightarrow> y \<notin> States (HARoot A)"
apply (unfold ChiRel_def Chi_def)
apply auto
apply (unfold restrict_def)
apply auto
apply (rename_tac SA)
apply (frule HAStates_HARoot_CompFun)
apply (cut_tac HA=A in MutuallyDistinct_HA)
apply (unfold MutuallyDistinct_def)
apply auto
apply (erule_tac x=SA in ballE)
apply (erule_tac x="HARoot A" in ballE)
apply auto
done
lemma HAStates_CompFun_States_ChiRel:
"S \<in> HAStates A \<Longrightarrow> \<Union> (States ` the (CompFun A S)) = ChiRel A `` {S}"
apply (unfold ChiRel_def Chi_def restrict_def)
apply auto
apply (drule HAStates_CompFun_SAs)
apply (subst HAStates_def)
apply fast
done
lemma HAInitState_notmem_Range_ChiRel [simp]:
"HAInitState A \<notin> Range (ChiRel A)"
by (unfold ChiRel_def, auto)
lemma HAInitState_notmem_Range_ChiRel2 [simp]:
"(S,HAInitState A) \<notin> (ChiRel A)"
by (unfold ChiRel_def, auto)
lemma ChiRel_OneAncestor_notmem:
"\<lbrakk> S \<noteq> T; (S,U) \<in> ChiRel A\<rbrakk> \<Longrightarrow> (T,U) \<notin> ChiRel A"
apply (unfold ChiRel_def)
apply auto
apply (simp only: Chi_range_disjoint)
done
lemma ChiRel_OneAncestor:
"\<lbrakk> (S1,U) \<in> ChiRel A; (S2,U) \<in> ChiRel A \<rbrakk> \<Longrightarrow> S1 = S2"
apply (rule notnotD, rule notI)
apply (simp add: ChiRel_OneAncestor_notmem)
done
lemma CompFun_ChiRel:
"\<lbrakk> S1 \<in> HAStates A; SA \<in> the (CompFun A S1);
S2 \<in> States SA \<rbrakk> \<Longrightarrow> (S1,S2) \<in> ChiRel A"
apply (unfold ChiRel_def Chi_def restrict_def)
apply auto
apply (cut_tac A=A and S=S1 in HAStates_CompFun_SAs)
apply (unfold HAStates_def)
apply auto
done
lemma CompFun_ChiRel2:
"\<lbrakk> (S,T) \<in> ChiRel A; T \<in> States SA; SA \<in> SAs A \<rbrakk> \<Longrightarrow> SA \<in> the (CompFun A S)"
apply (unfold ChiRel_def Chi_def restrict_def)
apply auto
apply (rename_tac SAA)
apply (cut_tac HA=A in MutuallyDistinct_HA)
apply (unfold MutuallyDistinct_def)
apply (erule_tac x=SA in ballE)
apply (rotate_tac -1)
apply (erule_tac x=SAA in ballE)
apply auto
done
lemma ChiRel_HAStates_NoCycles:
"(s,t) \<in> (ChiRel a) \<Longrightarrow> (t,s) \<notin> (ChiRel a)"
apply (unfold ChiRel_def)
apply auto
apply (frule HAStates_Chi_NoCycles)
apply auto
done
lemma HAStates_ChiRel_NoCycles_trans:
"\<lbrakk> (s,t) \<in> (ChiRel a); (t,u) \<in> (ChiRel a) \<rbrakk> \<Longrightarrow> (u,s) \<notin> (ChiRel a)"
apply (unfold ChiRel_def)
apply auto
apply (frule HAStates_Chi_NoCycles_trans)
apply fast
back
back
prefer 3
apply fast
apply auto
done
lemma SAStates_ChiRel:
"\<lbrakk> S \<in> States SA; T \<in> States SA;
SA \<in> SAs A \<rbrakk> \<Longrightarrow> (S,T) \<notin> (ChiRel A)"
by (unfold ChiRel_def, auto)
lemma ChiRel_SA_OneAncestor:
"\<lbrakk> (S,T) \<in> ChiRel A; T \<in> States SA;
U \<in> States SA; SA \<in> SAs A \<rbrakk> \<Longrightarrow>
(S,U) \<in> ChiRel A"
apply (frule CompFun_ChiRel2)
apply auto
apply (rule CompFun_ChiRel)
apply auto
done
lemma ChiRel_OneAncestor2:
"\<lbrakk> S \<in> HAStates A; S \<notin> States (HARoot A) \<rbrakk> \<Longrightarrow>
\<exists>! T. (T,S) \<in> ChiRel A"
apply (unfold ChiRel_def)
apply auto
prefer 2
apply (rename_tac T U)
prefer 2
apply (unfold Chi_def restrict_def)
apply auto
prefer 2
apply (rename_tac SA SAA)
prefer 2
apply (cut_tac HA=A in OneAncestor_HA)
apply (unfold OneAncestor_def)
apply (fold HARoot_def)
apply auto
apply (simp cong: rev_conj_cong)
apply (unfold HAStates_def)
apply auto
apply (rename_tac SA)
apply (erule_tac x=SA in ballE)
apply auto
apply (case_tac "T = U")
apply auto
apply (frule CompFun_Int_disjoint)
apply (unfold HAStates_def)
apply auto
apply (case_tac "SA=SAA")
apply auto
apply (cut_tac HA=A in MutuallyDistinct_HA)
apply (unfold MutuallyDistinct_def)
apply (erule_tac x=SAA in ballE)
apply (erule_tac x=SA in ballE)
apply auto
apply (cut_tac S=T and A=A in HAStates_CompFun_SAs)
apply (unfold HAStates_def)
apply fast
apply fast
apply (cut_tac S=U and A=A in HAStates_CompFun_SAs)
apply (unfold HAStates_def)
apply fast
apply fast
done
lemma HARootStates_notmem_Range_ChiRel [simp]:
"S \<in> States (HARoot A) \<Longrightarrow> S \<notin> Range (ChiRel A)"
by (unfold ChiRel_def, auto)
lemma ChiRel_int_disjoint:
"S \<noteq> T \<Longrightarrow> (ChiRel A `` {S}) \<inter> (ChiRel A `` {T}) = {}"
apply (unfold ChiRel_def)
apply auto
apply (simp only: Chi_range_disjoint)
done
lemma SAStates_ChiRel_trans [rule_format]:
"\<lbrakk> (S,U) \<in> (ChiRel A); (U,T) \<in> ChiRel A;
S \<in> States SA; SA \<in> SAs A \<rbrakk> \<Longrightarrow> T \<notin> States SA"
apply auto
apply (unfold ChiRel_def)
apply auto
apply (frule SAStates_Chi_trans)
back
apply fast+
done
lemma HAInitStates_InitState_trancl:
" \<lbrakk> S \<in> HAInitStates (HA ST); A \<in> the (CompFun (HA ST) S) \<rbrakk> \<Longrightarrow>
(S, InitState A) \<in> (ChiRel (HA ST) \<inter> HAInitStates (HA ST) \<times> HAInitStates (HA ST))\<^sup>+"
apply (case_tac "S \<in> HAStates (HA ST)")
apply (frule CompFun_ChiRel)
apply fast+
apply (rule InitState_States)
apply auto
apply (rule r_into_trancl')
apply auto
apply (rule CompFun_HAInitStates_HAStates)
apply auto
done
lemma HAInitStates_InitState_trancl2:
"\<lbrakk> S \<in> HAStates (HA ST); A \<in> the (CompFun (HA ST) S);
(x, S) \<in> (ChiRel (HA ST) \<inter> HAInitStates (HA ST) \<times> HAInitStates (HA ST))\<^sup>+ \<rbrakk>
\<Longrightarrow> (x, InitState A) \<in> (ChiRel (HA ST) \<inter> HAInitStates (HA ST) \<times> HAInitStates (HA ST))\<^sup>+"
apply (rule_tac a="x" and b="S" and r="ChiRel (HA ST) \<inter> HAInitStates (HA ST) \<times> HAInitStates (HA ST)" in converse_trancl_induct)
apply auto
prefer 2
apply (rename_tac T U)
prefer 2
apply (case_tac "S \<in> HAStates (HA ST)")
apply (frule CompFun_ChiRel)
apply fast
apply (rule InitState_States)
apply simp
apply (rule trancl_trans [of _ S])
apply (rule r_into_trancl')
apply auto
apply (rule r_into_trancl')
apply auto
apply (rule CompFun_HAInitStates_HAStates)
prefer 2
apply fast
apply (cut_tac A="HA ST" in HAInitStates_HAStates, fast)
apply (rule_tac y = U in trancl_trans)
apply (rule r_into_trancl')
apply auto
done
subsubsection \<open>\<open>ChiPlus\<close>\<close>
lemma ChiPlus_ChiRel [simp]:
"(S,T) \<in> ChiRel A \<Longrightarrow> (S,T) \<in> ChiPlus A"
apply (unfold ChiPlus_def)
apply (frule r_into_trancl)
apply auto
done
lemma ChiPlus_HAStates [simp]:
"(ChiPlus A) \<subseteq> (HAStates A \<times> HAStates A)"
apply (unfold ChiPlus_def)
apply (rule trancl_subset_Sigma)
apply auto
done
lemma ChiPlus_subset_States:
"ChiPlus a `` {t} \<subseteq> \<Union>(States ` (SAs a))"
apply (cut_tac A=a in ChiPlus_HAStates)
apply (unfold HAStates_def)
apply auto
done
lemma finite_ChiPlus [simp]:
"finite (ChiPlus A)"
apply (rule_tac B="HAStates A \<times> HAStates A" in finite_subset)
apply auto
done
lemma ChiPlus_OneAncestor:
"\<lbrakk> S \<in> HAStates A; S \<notin> States (HARoot A) \<rbrakk> \<Longrightarrow>
\<exists> T. (T,S) \<in> ChiPlus A"
apply (unfold ChiPlus_def)
apply (frule ChiRel_OneAncestor2)
apply auto
done
lemma ChiPlus_HAStates_Left:
"(S,T) \<in> ChiPlus A \<Longrightarrow> S \<in> HAStates A"
apply (cut_tac A=A in ChiPlus_HAStates)
apply (unfold HAStates_def)
apply auto
done
lemma ChiPlus_HAStates_Right:
"(S,T) \<in> ChiPlus A \<Longrightarrow> T \<in> HAStates A"
apply (cut_tac A=A in ChiPlus_HAStates)
apply (unfold HAStates_def)
apply auto
done
lemma ChiPlus_ChiRel_int [rule_format]:
"\<lbrakk> (T,S) \<in> (ChiPlus A)\<rbrakk> \<Longrightarrow> (ChiPlus A `` {T}) \<inter> (ChiRel A `` {S}) = (ChiRel A `` {S})"
apply (unfold ChiPlus_def)
apply (rule_tac a="T" and b="S" and r="(ChiRel A)" in converse_trancl_induct)
apply auto
done
lemma ChiPlus_ChiPlus_int [rule_format]:
"\<lbrakk> (T,S) \<in> (ChiPlus A)\<rbrakk> \<Longrightarrow> (ChiPlus A `` {T}) \<inter> (ChiPlus A `` {S}) = (ChiPlus A `` {S})"
apply (unfold ChiPlus_def)
apply (rule_tac a="T" and b="S" and r="(ChiRel A)" in converse_trancl_induct)
apply auto
done
lemma ChiPlus_ChiRel_NoCycle_2 [rule_format]:
"\<lbrakk> (T,S) \<in> ChiPlus A\<rbrakk> \<Longrightarrow> (S,T) \<in> (ChiRel A) \<longrightarrow>
(insert S (insert T ({U. (T,U) \<in> ChiPlus A \<and> (U,S) \<in> ChiPlus A}))) \<inter> (ChiRel A `` {S}) \<noteq> {}"
apply (unfold ChiPlus_def)
apply (rule_tac a="T" and b="S" and r="(ChiRel A)" in converse_trancl_induct)
apply (unfold Image_def Int_def)
apply auto
done
lemma ChiPlus_ChiRel_NoCycle_3 [rule_format]:
"\<lbrakk> (T,S) \<in> ChiPlus A\<rbrakk> \<Longrightarrow> (S,T) \<in> (ChiRel A) \<longrightarrow> (T,U) \<in> ChiPlus A \<longrightarrow> (U, S) \<in> ChiPlus A \<longrightarrow>
(insert S (insert T ({U. (T,U) \<in> ChiPlus A \<and> (U,S) \<in> ChiPlus A}))) \<inter> (ChiRel A `` {U}) \<noteq> {}"
apply (unfold ChiPlus_def)
apply (rule_tac a="T" and b="S" and r="(ChiRel A)" in trancl_induct)
apply (unfold Image_def Int_def, simp)
apply (rename_tac V)
prefer 2
apply (rename_tac V W)
prefer 2
apply (simp, safe)
apply (simp only: ChiRel_HAStates_NoCycles)
apply simp
apply (case_tac "(U,W) \<in> (ChiRel A)", fast, rotate_tac 5, frule tranclD3, fast, blast intro: trancl_into_trancl)+
done
lemma ChiPlus_ChiRel_NoCycle_4 [rule_format]:
"\<lbrakk> (T,S) \<in> ChiPlus A \<rbrakk> \<Longrightarrow> (S,T) \<in> (ChiRel A) \<longrightarrow> ((ChiPlus A ``{T}) \<inter> (ChiRel A `` {S})) \<noteq> {}"
apply (unfold ChiPlus_def)
apply (rule_tac a="T" and b="S" and r="(ChiRel A)" in trancl_induct)
apply (unfold Image_def Int_def)
apply auto
apply (simp only: ChiRel_HAStates_NoCycles)
apply (rule_tac x=T in exI)
apply simp
apply (rule_tac x=T in exI)
apply simp
done
lemma ChiRel_ChiPlus_NoCycles:
"(S,T) \<in> (ChiRel A) \<Longrightarrow> (T,S) \<notin> (ChiPlus A)"
apply (cut_tac HA=A in NoCycles_HA)
apply (unfold NoCycles_def)
apply (erule_tac x="insert S (insert T ({U. (T,U) \<in> ChiPlus A \<and> (U,S) \<in> ChiPlus A}))" in ballE)
prefer 2
apply (simp add: ChiPlus_subset_States)
apply (cut_tac A=A in ChiPlus_HAStates)
apply (unfold HAStates_def)
apply auto
apply (frule ChiPlus_ChiRel_NoCycle_2)
apply fast
apply (simp add:ChiRel_CompFun)
apply (frule ChiPlus_ChiRel_NoCycle_1)
apply (simp add:ChiRel_CompFun)
apply (frule ChiPlus_ChiRel_NoCycle_3)
apply fast
apply fast
back
apply fast
apply (rename_tac V)
apply (case_tac "V \<in> HAStates A")
apply (simp add: ChiRel_CompFun)
apply (simp only: ChiPlus_HAStates_Right)
apply fast
done
lemma ChiPlus_ChiPlus_NoCycles:
"(S,T) \<in> (ChiPlus A) \<Longrightarrow> (T,S) \<notin> (ChiPlus A)"
apply (unfold ChiPlus_def)
apply (rule_tac a="S" and b="T" and r="(ChiRel A)" in trancl_induct)
apply fast
apply (frule ChiRel_ChiPlus_NoCycles)
apply (auto intro: trancl_into_trancl2 simp add:ChiPlus_def)
done
lemma ChiPlus_NoCycles [rule_format]:
"(S,T) \<in> (ChiPlus A) \<Longrightarrow> S \<noteq> T"
apply (frule ChiPlus_ChiPlus_NoCycles)
apply auto
done
lemma ChiPlus_NoCycles_2 [simp]:
"(S,S) \<notin> (ChiPlus A)"
apply (rule notI)
apply (frule ChiPlus_NoCycles)
apply fast
done
lemma ChiPlus_ChiPlus_NoCycles_2:
"\<lbrakk> (S,U) \<in> ChiPlus A; (U,T) \<in> ChiPlus A \<rbrakk> \<Longrightarrow> (T,S) \<notin> ChiPlus A"
apply (rule ChiPlus_ChiPlus_NoCycles)
apply (auto intro: trancl_trans simp add: ChiPlus_def)
done
lemma ChiRel_ChiPlus_trans:
"\<lbrakk> (U,S) \<in> ChiPlus A; (S,T) \<in> ChiRel A\<rbrakk> \<Longrightarrow> (U,T) \<in> ChiPlus A"
apply (unfold ChiPlus_def)
apply auto
done
lemma ChiRel_ChiPlus_trans2:
"\<lbrakk> (U,S) \<in> ChiRel A; (S,T) \<in> ChiPlus A \<rbrakk> \<Longrightarrow> (U,T) \<in> ChiPlus A"
apply (unfold ChiPlus_def)
apply auto
done
lemma ChiPlus_ChiRel_Ex [rule_format]:
"\<lbrakk> (S,T) \<in> ChiPlus A \<rbrakk> \<Longrightarrow> (S,T) \<notin> ChiRel A \<longrightarrow>
(\<exists> U. (S,U) \<in> ChiPlus A \<and> (U,T) \<in> ChiRel A)"
apply (unfold ChiPlus_def)
apply (rule_tac a="S" and b="T" and r="(ChiRel A)" in converse_trancl_induct)
apply auto
apply (rename_tac U)
apply (rule_tac x=U in exI)
apply auto
done
lemma ChiPlus_ChiRel_Ex2 [rule_format]:
"\<lbrakk> (S,T) \<in> ChiPlus A \<rbrakk> \<Longrightarrow> (S,T) \<notin> ChiRel A \<longrightarrow>
(\<exists> U. (S,U) \<in> ChiRel A \<and> (U,T) \<in> ChiPlus A)"
apply (unfold ChiPlus_def)
apply (rule_tac a="S" and b="T" and r="(ChiRel A)" in converse_trancl_induct)
apply auto
done
lemma HARootStates_Range_ChiPlus [simp]:
"\<lbrakk> S \<in> States (HARoot A) \<rbrakk> \<Longrightarrow> S \<notin> Range (ChiPlus A)"
by (unfold ChiPlus_def, auto)
lemma SAStates_ChiPlus_ChiRel_NoCycle_2 [rule_format]:
"\<lbrakk> (S,U) \<in> ChiPlus A \<rbrakk> \<Longrightarrow> (U,T) \<in> (ChiRel A) \<longrightarrow>
(insert S (insert U ({V. (S,V) \<in> ChiPlus A \<and> (V,U) \<in> ChiPlus A}))) \<inter> (ChiRel A `` {S}) \<noteq> {}"
apply (unfold ChiPlus_def)
apply (rule_tac a="S" and b="U" and r="(ChiRel A)" in converse_trancl_induct)
apply (unfold Image_def Int_def)
apply auto
done
(* TO DO *)
lemma SAStates_ChiPlus_ChiRel_NoCycle_3 [rule_format]:
"\<lbrakk> (S,U) \<in> ChiPlus A \<rbrakk> \<Longrightarrow> (U,T) \<in> (ChiRel A) \<longrightarrow> (S,s) \<in> ChiPlus A \<longrightarrow> (s,U) \<in> ChiPlus A \<longrightarrow>
(insert S (insert U ({V. (S,V) \<in> ChiPlus A \<and> (V,U) \<in> ChiPlus A}))) \<inter> (ChiRel A `` {s}) \<noteq> {}"
apply (unfold ChiPlus_def)
apply (rule_tac a="S" and b="U" and r="(ChiRel A)" in trancl_induct)
apply fast
apply (rename_tac W)
prefer 2
apply (rename_tac W X)
prefer 2
apply (unfold Image_def Int_def)
apply (simp, safe)
apply (fold ChiPlus_def)
apply (case_tac "(s,W) \<in> ChiRel A")
apply fast
apply (frule_tac S=s and T=W in ChiPlus_ChiRel_Ex2)
apply simp
apply safe
apply (rename_tac X)
apply (rule_tac x=X in exI)
apply (fast intro: ChiRel_ChiPlus_trans)
apply simp
apply (case_tac "(s,X) \<in> ChiRel A")
apply force
apply (frule_tac S=s and T=X in ChiPlus_ChiRel_Ex2)
apply simp
apply safe
apply (rename_tac Y)
apply (erule_tac x=Y in allE)
apply simp
apply (fast intro: ChiRel_ChiPlus_trans)
apply simp
apply (case_tac "(s,X) \<in> ChiRel A")
apply force
apply (frule_tac S=s and T=X in ChiPlus_ChiRel_Ex2)
apply simp
apply safe
apply (rename_tac Y)
apply (erule_tac x=Y in allE)
apply simp
apply (fast intro: ChiRel_ChiPlus_trans)
apply fastforce
apply simp
apply (erule_tac x=W in allE)
apply simp
apply simp
apply (rename_tac Y)
apply (erule_tac x=Y in allE)
apply simp
apply (fast intro: ChiRel_ChiPlus_trans)
done
lemma SAStates_ChiPlus2 [rule_format]:
"\<lbrakk> (S,T) \<in> ChiPlus A; SA \<in> SAs A \<rbrakk> \<Longrightarrow> S \<in> States SA \<longrightarrow> T \<notin> States SA"
apply (unfold ChiPlus_def)
apply (rule_tac a="S" and b="T" and r="(ChiRel A)" in trancl_induct)
apply auto
apply (rename_tac U)
apply (frule_tac S=S and T=U in SAStates_ChiRel)
apply auto
apply (fold ChiPlus_def)
apply (simp only: SAStates_ChiPlus_ChiRel_trans)
done
lemma SAStates_ChiPlus [rule_format]:
"\<lbrakk> S \<in> States SA; T \<in> States SA; SA \<in> SAs A \<rbrakk> \<Longrightarrow> (S,T) \<notin> ChiPlus A"
apply auto
apply (simp only: SAStates_ChiPlus2)
done
lemma SAStates_ChiPlus_ChiRel_OneAncestor [rule_format]:
"\<lbrakk> T \<in> States SA; SA \<in> SAs A; (S,U) \<in> ChiPlus A\<rbrakk> \<Longrightarrow> S \<noteq> T \<longrightarrow> S \<in> States SA \<longrightarrow> (T,U) \<notin> ChiRel A"
apply (unfold ChiPlus_def)
apply (rule_tac a="S" and b="U" and r="(ChiRel A)" in trancl_induct)
apply auto
apply (simp add: ChiRel_OneAncestor_notmem)
apply (rename_tac V W)
apply (fold ChiPlus_def)
apply (case_tac "V=T")
apply (simp add: ChiRel_OneAncestor_notmem SAStates_ChiPlus)+
done
lemma SAStates_ChiPlus_OneAncestor [rule_format]:
"\<lbrakk> T \<in> States SA; SA \<in> SAs A; (S,U) \<in> ChiPlus A \<rbrakk> \<Longrightarrow> S \<noteq> T \<longrightarrow>
S \<in> States SA \<longrightarrow> (T,U) \<notin> ChiPlus A"
apply (unfold ChiPlus_def)
apply (rule_tac a="S" and b="U" and r="(ChiRel A)" in trancl_induct)
apply auto
apply (fold ChiPlus_def)
apply (rename_tac V)
apply (frule_tac T=S and S=T and U=V in SAStates_ChiPlus_ChiRel_OneAncestor)
apply auto
apply (rename_tac V W)
apply (frule_tac S=T and T=W in ChiPlus_ChiRel_Ex)
apply auto
apply (frule_tac T=T and S=S and U=W in SAStates_ChiPlus_ChiRel_OneAncestor)
apply auto
apply (rule ChiRel_ChiPlus_trans)
apply auto
apply (rename_tac X)
apply (case_tac "V=X")
apply simp
apply (simp add: ChiRel_OneAncestor_notmem)
done
lemma ChiRel_ChiPlus_OneAncestor [rule_format]:
"\<lbrakk> (T,U) \<in> ChiPlus A \<rbrakk> \<Longrightarrow> T \<noteq> S \<longrightarrow> (S,U) \<in> ChiRel A \<longrightarrow> (T,S) \<in> ChiPlus A"
apply (unfold ChiPlus_def)
apply (rule_tac a="T" and b="U" and r="(ChiRel A)" in trancl_induct)
apply auto
apply (fast intro:ChiRel_OneAncestor)
apply (rename_tac V W)
apply (case_tac "S=V")
apply auto
apply (fast intro:ChiRel_OneAncestor)
done
lemma ChiPlus_SA_OneAncestor [rule_format]:
"\<lbrakk> (S,T) \<in> ChiPlus A;
U \<in> States SA; SA \<in> SAs A \<rbrakk> \<Longrightarrow> T \<in> States SA \<longrightarrow>
(S,U) \<in> ChiPlus A"
apply (unfold ChiPlus_def)
apply (rule_tac a="S" and b="T" and r="(ChiRel A)" in converse_trancl_induct)
apply auto
apply (frule ChiRel_SA_OneAncestor)
apply fast+
done
subsubsection \<open>\<open>ChiStar\<close>\<close>
lemma ChiPlus_ChiStar [simp]:
"\<lbrakk> (S,T) \<in> ChiPlus A \<rbrakk> \<Longrightarrow> (S,T) \<in> ChiStar A"
by (unfold ChiPlus_def ChiStar_def, auto)
lemma HARootState_Range_ChiStar [simp]:
"\<lbrakk> x \<noteq> S; S \<in> States (HARoot A) \<rbrakk> \<Longrightarrow> (x,S) \<notin> (ChiStar A)"
apply (unfold ChiStar_def)
apply (subst rtrancl_eq_or_trancl)
apply (fold ChiPlus_def)
apply auto
done
lemma ChiStar_Self [simp]:
"(S,S) \<in> ChiStar A"
apply (unfold ChiStar_def)
apply simp
done
lemma ChiStar_Image [simp]:
"S \<in> M \<Longrightarrow> S \<in> (ChiStar A `` M)"
apply (unfold Image_def)
apply (auto intro: ChiStar_Self)
done
lemma ChiStar_ChiPlus_noteq:
"\<lbrakk> S \<noteq> T; (S,T) \<in> ChiStar A \<rbrakk> \<Longrightarrow> (S,T) \<in> ChiPlus A"
apply (unfold ChiPlus_def ChiStar_def)
apply (simp add: rtrancl_eq_or_trancl)
done
lemma ChiRel_ChiStar_trans:
"\<lbrakk> (S,U) \<in> ChiStar A; (U,T) \<in> ChiRel A \<rbrakk> \<Longrightarrow> (S,T) \<in> ChiStar A"
apply (unfold ChiStar_def)
apply auto
done
subsubsection \<open>\<open>InitConf\<close>\<close>
lemma InitConf_HAStates [simp]:
"InitConf A \<subseteq> HAStates A"
apply (unfold InitConf_def HAStates_def)
apply auto
apply (rule rtrancl_induct)
back
apply auto
apply (rule_tac x="HARoot A" in bexI)
apply auto
apply (unfold HAStates_def ChiRel_def)
apply auto
done
lemma InitConf_HAStates2 [simp]:
"S \<in> InitConf A \<Longrightarrow> S \<in> HAStates A"
apply (cut_tac A=A in InitConf_HAStates)
apply fast
done
lemma HAInitState_InitConf [simp]:
"HAInitState A \<in> InitConf A"
by (unfold HAInitState_def InitConf_def, auto)
lemma InitConf_HAInitState_HARoot:
"[| S \<in> InitConf A; S \<noteq> HAInitState A |] ==> S \<notin> States (HARoot A)"
apply (unfold InitConf_def)
apply auto
apply (rule mp)
prefer 2
apply fast
back
apply (rule mp)
prefer 2
apply fast
back
back
apply (rule_tac b=S in rtrancl_induct)
apply auto
apply (simp add: ChiRel_HARoot)+
done
lemma InitConf_HARoot_HAInitState [simp]:
"\<lbrakk> S \<in> InitConf A; S \<in> States (HARoot A) \<rbrakk> \<Longrightarrow> S = HAInitState A"
apply (subst not_not [THEN sym])
apply (rule notI)
apply (simp add:InitConf_HAInitState_HARoot)
done
lemma HAInitState_CompFun_InitConf [simp]:
"[|SA \<in> the (CompFun A (HAInitState A)) |] ==> (InitState SA) \<in> InitConf A"
apply (unfold InitConf_def HAStates_def)
apply auto
apply (rule rtrancl_Int)
apply auto
apply (cut_tac A=A and S="HAInitState A" in HAStates_CompFun_States_ChiRel)
apply auto
apply (rule Image_singleton_iff [THEN subst])
apply (rotate_tac -1)
apply (drule sym)
apply simp
apply (rule_tac x=SA in bexI)
apply auto
done
lemma InitConf_HAInitStates:
"InitConf A \<subseteq> HAInitStates A"
apply (unfold InitConf_def)
apply (rule subsetI)
apply auto
apply (frule rtrancl_Int1)
apply (case_tac "x = HAInitState A")
apply simp
apply (rule rtrancl_mem_Sigma)
apply auto
done
lemma InitState_notmem_InitConf:
"[| SA \<in> the (CompFun A S); S \<in> InitConf A; T \<in> States SA;
T \<noteq> InitState SA |] ==> T \<notin> InitConf A"
apply (frule InitConf_HAStates2)
apply (unfold InitConf_def)
apply auto
apply (rule mp)
prefer 2
apply fast
apply (rule mp)
prefer 2
apply fast
back
apply (rule mp)
prefer 2
apply fast
back
back
apply (rule mp)
prefer 2
apply fast
back
back
back
apply (rule mp)
prefer 2
apply fast
back
back
back
back
apply (rule mp)
prefer 2
apply fast
back
back
back
back
back
apply (rule_tac b=T in rtrancl_induct)
apply auto
done
lemma InitConf_CompFun_InitState [simp]:
"\<lbrakk> SA \<in> the (CompFun A S); S \<in> InitConf A; T \<in> States SA;
T \<in> InitConf A \<rbrakk> \<Longrightarrow> T = InitState SA"
apply (subst not_not [THEN sym])
apply (rule notI)
apply (frule InitState_notmem_InitConf)
apply auto
done
lemma InitConf_ChiRel_Ancestor:
"\<lbrakk> T \<in> InitConf A; (S,T) \<in> ChiRel A \<rbrakk> \<Longrightarrow> S \<in> InitConf A"
apply (unfold InitConf_def)
apply auto
apply (erule rtranclE)
apply auto
apply (rename_tac U)
apply (cut_tac A=A in HAInitState_notmem_Range_ChiRel)
apply auto
apply (case_tac "U = S")
apply (auto simp add: ChiRel_OneAncestor)
done
lemma InitConf_CompFun_Ancestor:
"\<lbrakk> S \<in> HAStates A; SA \<in> the (CompFun A S); T \<in> InitConf A; T \<in> States SA \<rbrakk>
\<Longrightarrow> S \<in> InitConf A"
apply (rule InitConf_ChiRel_Ancestor)
apply auto
apply (rule CompFun_ChiRel)
apply auto
done
subsubsection \<open>\<open>StepConf\<close>\<close>
lemma StepConf_EmptySet [simp]:
"StepConf A C {} = C"
by (unfold StepConf_def, auto)
end
|
-- Andreas, 2017-10-04, issue #2752, report and test case by nad
--
-- Problem was: instance does not distribute into mutual blocks.
open import Agda.Builtin.List
open import Agda.Builtin.Size
mutual
data Rose (i : Size) (A : Set) : Set where
node : List (Rose′ i A) → Rose i A
data Rose′ (i : Size) (A : Set) : Set where
delay : {j : Size< i} → Rose j A → Rose′ i A
record Map (F : Set → Set) : Set₁ where
field
map : {A B : Set} → (A → B) → F A → F B
open Map ⦃ … ⦄ public
instance
Map-List : Map List
Map.map Map-List = λ where
f [] → []
f (x ∷ xs) → f x ∷ map f xs
instance
mutual
Map-Rose : ∀ {i} → Map (Rose i)
Map.map Map-Rose f (node xs) = node (map (map f) xs)
Map-Rose′ : ∀ {i} → Map (Rose′ i)
Map.map Map-Rose′ f (delay t) = delay (map f t)
-- Was: unresolved instance arguments.
-- Should succeed.
|
function filum_test02 ( )
%*****************************************************************************80
%
%% TEST02 tests FILE_CHAR_COUNT.
%
% Licensing:
%
% This code is distributed under the GNU LGPL license.
%
% Modified:
%
% 06 June 2007
%
% Author:
%
% John Burkardt
%
fprintf ( 1, '\n' );
fprintf ( 1, 'TEST02\n' );
fprintf ( 1, ' FILE_CHAR_COUNT counts the characters in a file.\n' );
filename = 'story.txt';
fprintf ( 1, '\n' );
fprintf ( 1, ' Examining file:\n' );
fprintf ( 1, ' "%s".', filename );
fprintf ( 1, '\n' );
char_num = file_char_count ( filename );
fprintf ( 1, ' Number of characters in file: %d\n', char_num );
return
end
|
subroutine hruaa(years)
!! ~ ~ ~ PURPOSE ~ ~ ~
!! this subroutine writes average annual HRU output to the output.hru file
!! ~ ~ ~ INCOMING VARIABLES ~ ~ ~
!! name |units |definition
!! ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
!! bio_aams(:) |metric tons/ha|average annual biomass (dry weight) in HRU
!! cpnm(:) |NA |four character code to represent crop name
!! deepst(:) |mm H2O |depth of water in deep aquifer
!! hru_km(:) |km^2 |area of HRU in square kilometers
!! hru_sub(:) |none |subbasin in which HRU is located
!! hruaao(1,:) |mm H2O |precipitation in HRU during simulation
!! hruaao(2,:) |mm H2O |amount of precipitation falling as freezing
!! |rain/snow in HRU during simulation
!! hruaao(3,:) |mm H2O |amount of snow melt in HRU during simulation
!! hruaao(4,:) |mm H2O |amount of surface runoff to main channel
!! |from HRU during simulation (ignores impact of
!! |transmission losses)
!! hruaao(5,:) |mm H2O |amount of lateral flow contribution to main
!! |channel from HRU during simulation
!! hruaao(6,:) |mm H2O |amount of groundwater flow contribution to
!! |main channel from HRU during simulation
!! hruaao(7,:) |mm H2O |amount of water moving from shallow aquifer
!! |to plants or soil profile in HRU during
!! |simulation
!! hruaao(8,:) |mm H2O |amount of water recharging deep aquifer in
!! |HRU during simulation
!! hruaao(9,:) |mm H2O |total amount of water entering both aquifers
!! |from HRU during simulation
!! hruaao(10,:) |mm H2O |water yield (total amount of water entering
!! |main channel) from HRU during simulation
!! hruaao(11,:) |mm H2O |amount of water percolating out of the soil
!! |profile and into the vadose zone in HRU
!! |during simulation
!! hruaao(12,:) |mm H2O |actual evapotranspiration in HRU during
!! |simulation
!! hruaao(13,:) |mm H2O |amount of transmission losses from tributary
!! |channels in HRU for simulation
!! hruaao(14,:) |metric tons/ha|sediment yield from HRU for simulation
!! hruaao(17,:) |kg N/ha |amount of nitrogen applied in continuous
!! |fertilizer operation in HRU for simulation
!! hruaao(18,:) |kg P/ha |amount of phosphorus applied in continuous
!! |fertilizer operation in HRU for simulation
!! hruaao(23,:) |mm H2O |amount of water removed from shallow aquifer
!! |in HRU for irrigation during simulation
!! hruaao(24,:) |mm H2O |amount of water removed from deep aquifer
!! |in HRU for irrigation during simulation
!! hruaao(25,:) |mm H2O |potential evapotranspiration in HRU during
!! |simulation
!! hruaao(26,:) |kg N/ha |annual amount of N (organic & mineral)
!! |applied in HRU during grazing
!! hruaao(27,:) |kg P/ha |annual amount of P (organic & mineral)
!! |applied in HRU during grazing
!! hruaao(28,:) |kg N/ha |average annual amount of N (organic &
!! |mineral) auto-applied in HRU
!! hruaao(29,:) |kg P/ha |average annual amount of P (organic &
!! |mineral) auto-applied in HRU
!! hruaao(31,:) |stress days |water stress days in HRU during simulation
!! hruaao(32,:) |stress days |temperature stress days in HRU during
!! |simulation
!! hruaao(33,:) |stress days |nitrogen stress days in HRU during simulation
!! hruaao(34,:) |stress days |phosphorus stress days in HRU during
!! |simulation
!! hruaao(35,:) |kg N/ha |organic nitrogen in surface runoff in HRU
!! |during simulation
!! hruaao(36,:) |kg P/ha |organic phosphorus in surface runoff in HRU
!! |during simulation
!! hruaao(37,:) |kg N/ha |nitrate in surface runoff in HRU during
!! |simulation
!! hruaao(38,:) |kg N/ha |nitrate in lateral flow in HRU during
!! |simulation
!! hruaao(39,:) |kg P/ha |soluble phosphorus in surface runoff in HRU
!! |during simulation
!! hruaao(40,:) |kg N/ha |amount of nitrogen removed from soil by plant
!! |uptake in HRU during simulation
!! hruaao(41,:) |kg N/ha |nitrate percolating past bottom of soil
!! |profile in HRU during simulation
!! hruaao(42,:) |kg P/ha |amount of phosphorus removed from soil by
!! |plant uptake in HRU during simulation
!! hruaao(43,:) |kg P/ha |amount of phosphorus moving from labile
!! |mineral to active mineral pool in HRU during
!! |simulation
!! hruaao(44,:) |kg P/ha |amount of phosphorus moving from active
!! |mineral to stable mineral pool in HRU during
!! |simulation
!! hruaao(45,:) |kg N/ha |amount of nitrogen applied to HRU in
!! |fertilizer and grazing operations during
!! |simulation
!! hruaao(46,:) |kg P/ha |amount of phosphorus applied to HRU in
!! |fertilizer and grazing operations during
!! |simulation
!! hruaao(47,:) |kg N/ha |amount of nitrogen added to soil by fixation
!! |in HRU during simulation
!! hruaao(48,:) |kg N/ha |amount of nitrogen lost by denitrification
!! |in HRU during simulation
!! hruaao(49,:) |kg N/ha |amount of nitrogen moving from active organic
!! |to nitrate pool in HRU during simulation
!! hruaao(50,:) |kg N/ha |amount of nitrogen moving from active organic
!! |to stable organic pool in HRU during
!! |simulation
!! hruaao(51,:) |kg P/ha |amount of phosphorus moving from organic to
!! |labile mineral pool in HRU during simulation
!! hruaao(52,:) |kg N/ha |amount of nitrogen moving from fresh organic
!! |to nitrate and active organic pools in HRU
!! |during simulation
!! hruaao(53,:) |kg P/ha |amount of phosphorus moving from fresh
!! |organic to the labile mineral and organic
!! |pools in HRU during simulation
!! hruaao(54,:) |kg N/ha |amount of nitrogen added to soil in rain
!! |during simulation
!! hruaao(61,:) |metric tons/ha|daily soil loss predicted with USLE equation
!! hruaao(63,:) |# bacteria/ha |less persistent bacteria transported to main
!! |channel from HRU during simulation
!! hruaao(64,:) |# bacteria/ha |persistent bacteria transported to main
!! |channel from HRU during simulation
!! hruaao(65,:) |kg N/ha |nitrate loading from groundwater in HRU to
!! |main channel during simulation
!! hruaao(66,:) |kg P/ha |soluble P loading from groundwater in HRU to
!! |main channel during simulation
!! hruaao(67,:) |kg P/ha |loading of mineral P attached to sediment
!! |in HRU to main channel during simulation
!! hrugis(:) |none |GIS code printed to output files(output.hru,.rch)
!! icr(:) |none |sequence number of crop grown within the
!! |current year
!! idplt(:) |none |land cover code from crop.dat
!! ipdvas(:) |none |output variable codes for output.hru file
!! isproj |none |special project code:
!! |1 test rewind (run simulation twice)
!! itots |none |number of output variables printed (output.hru)
!! lai_aamx(:) |none |average annual maximum leaf area index in
!! |HRU
!! mhruo |none |maximum number of variables written to
!! |HRU output file (output.hru)
!! nhru |none |number of HRUs in watershed
!! nmgt(:) |none |management code (for GIS output only)
!! nro(:) |none |sequence number of year in rotation
!! shallst(:) |mm H2O |depth of water in shallow aquifer
!! sol_sw(:) |mm H2O |amount of water stored in the soil profile
!! |on any given day
!! yldaa(:) |metric tons/ha|average annual yield (dry weight) in HRU
!! ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
!! ~ ~ ~ LOCAL DEFINITIONS ~ ~ ~
!! name |units |definition
!! ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
!! ii |none |counter
!! j |none |HRU number
!! pdvas(:) |varies |array to hold HRU output values
!! pdvs(:) |varies |array to hold selected HRU output values
!! |when user doesn't want to print all
!! sb |none |subbasin number
!! years |years |length of simulation
!! ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
!! ~ ~ ~ ~ ~ ~ END SPECIFICATIONS ~ ~ ~ ~ ~ ~
use parm
real, intent (in) :: years
integer :: j, sb, ii, iflag
real, dimension (mhruo) :: pdvas, pdvs
character (len=4) :: cropname
do j = 1, nhru
sb = hru_sub(j)
iflag = 0
do ii = 1, itoth
if (ipdhru(ii) == j) iflag = 1
end do
if (iflag == 1) then
pdvas = 0.
pdvs = 0.
pdvas(1) = hruaao(1,j)
pdvas(2) = hruaao(2,j)
pdvas(3) = hruaao(3,j)
pdvas(4) = hruaao(22,j)
pdvas(5) = hruaao(25,j)
pdvas(6) = hruaao(12,j)
pdvas(7) = hruaao(21,j) / 365.4
pdvas(8) = sol_sw(j)
pdvas(9) = hruaao(11,j)
pdvas(10) = hruaao(9,j)
pdvas(11) = hruaao(8,j)
pdvas(12) = hruaao(7,j)
pdvas(13) = hruaao(23,j)
pdvas(14) = hruaao(24,j)
pdvas(15) = shallst(j)
pdvas(16) = deepst(j)
pdvas(17) = hruaao(19,j)
pdvas(18) = hruaao(4,j)
pdvas(19) = hruaao(13,j)
pdvas(20) = hruaao(5,j)
pdvas(21) = hruaao(6,j)
pdvas(22) = hruaao(10,j)
pdvas(23) = hruaao(20,j) / 365.4
pdvas(24) = hruaao(57,j) / 365.4
pdvas(25) = hruaao(55,j) / 365.4
pdvas(26) = hruaao(56,j) / 365.4
pdvas(27) = hruaao(30,j) / 365.4
pdvas(28) = hruaao(58,j) / 365.4
pdvas(29) = hruaao(14,j)
pdvas(30) = hruaao(61,j)
pdvas(31) = hruaao(45,j)
pdvas(32) = hruaao(46,j)
pdvas(33) = hruaao(28,j)
pdvas(34) = hruaao(29,j)
pdvas(35) = hruaao(26,j)
pdvas(36) = hruaao(27,j)
pdvas(37) = hruaao(17,j)
pdvas(38) = hruaao(18,j)
pdvas(39) = hruaao(54,j)
pdvas(40) = hruaao(47,j)
pdvas(41) = hruaao(52,j)
pdvas(42) = hruaao(49,j)
pdvas(43) = hruaao(50,j)
pdvas(44) = hruaao(53,j)
pdvas(45) = hruaao(51,j)
pdvas(46) = hruaao(43,j)
pdvas(47) = hruaao(44,j)
pdvas(48) = hruaao(48,j)
pdvas(49) = hruaao(40,j)
pdvas(50) = hruaao(42,j)
pdvas(51) = hruaao(35,j)
pdvas(52) = hruaao(36,j)
pdvas(53) = hruaao(67,j)
pdvas(54) = hruaao(37,j)
pdvas(55) = hruaao(38,j)
pdvas(56) = hruaao(41,j)
pdvas(57) = hruaao(65,j)
pdvas(58) = hruaao(39,j)
pdvas(59) = hruaao(66,j)
pdvas(60) = hruaao(31,j)
pdvas(61) = hruaao(32,j)
pdvas(62) = hruaao(33,j)
pdvas(63) = hruaao(34,j)
pdvas(64) = bio_aams(j)
pdvas(65) = lai_aamx(j)
pdvas(66) = yldaa(j)
pdvas(67) = hruaao(63,j)
pdvas(68) = hruaao(64,j)
!! the following two variables are values at the of the year
!! they are not summed each day
pdvas(69) = wtab(j) !! based on 30 day antecedent climate(mm) (prec,et)
pdvas(70) = wtabelo !! based on depth from soil surface(mm)
!! added current snow content in the hru (not summed)
pdvas(71) = sno_hru(j)
!! added current soil carbon for first layer
pdvas(72) = cmup_kgh(j) !! first soil layer only
!! added current soil carbon integrated - aggregating all soil layers
pdvas(73) = cmtot_kgh(j)
!! adding qtile to output.hru write 3/2/2010 gsm
pdvas(74) = hruaao(62,j)
!! tileno3 - output.hru
pdvas(75) = hruaao(68,j)
!! latno3 - output.hru
pdvas(76) = hruaao(69,j)
!! gw deep
pdvas(77) = hruaao(70,j)
!! latq contribution
pdvas(78) = hruaao(71,j)
!! phos due to crack flow (tvap)
pdvas(79) = hruaao(72,j)
pdvas(80) = hruaao(73,j) / 365.4
pdvas(81) = hruaao(74,j) / 365.4
pdvas(82) = hruaao(75,j) / 365.4
pdvas(83) = hruaao(76,j) / 365.4
pdvas(84) = hruaao(77,j) / 365.4
pdvas(85) = hruaao(78,j) / 365.4
pdvas(86) = hruaao(79,j) / 365.4
pdvas(87) = hruaao(80,j) / 365.4
pdvas(88) = hruaao(81,j) / 365.4
pdvas(89) = hruaao(82,j) / 365.4
if (ipdvas(1) > 0) then
do ii = 1, itots
pdvs(ii) = pdvas(ipdvas(ii))
end do
idplant = idplt(j)
if (idplant > 0) then
cropname = cpnm(idplant)
else
cropname = "NOCR"
endif
if (iscen == 1 .and. isproj == 0) then
write (28,1000) cropname, j, subnum(j), hruno(j), sb,
& nmgt(j), years, hru_km(j), (pdvs(ii), ii = 1, itots)
else if (isproj == 1) then
write (21,1000) cropname, j, subnum(j), hruno(j),
& sb, nmgt(j), years, hru_km(j), (pdvs(ii), ii = 1, itots)
else if (iscen == 1 .and. isproj == 2) then
write (28,2000) cropname, j, subnum(j), hruno(j), sb,
& nmgt(j), years, hru_km(j), (pdvs(ii), ii = 1, itots), iyr
endif
else
if (iscen == 1 .and. isproj == 0) then
write (28,1001) cropname, j, subnum(j), hruno(j), sb,
& nmgt(j), years, hru_km(j), (pdvas(ii), ii = 1, mhruo)
else if (isproj == 1) then
write (21,1001) cropname, j, subnum(j), hruno(j),
& sb, nmgt(j), years, hru_km(j), (pdvas(ii), ii = 1, mhruo)
else if (iscen == 1 .and. isproj == 2) then
write (28,1001) cropname, j, subnum(j), hruno(j), sb,
& nmgt(j), years, hru_km(j), (pdvas(ii), ii = 1, mhruo), iyr
endif
end if
end if
end do
return
1000 format (a4,i5,1x,a5,a4,i5,1x,i4,1x,f4.1,e10.5,66f10.3,1x,
*e10.5,1x,e10.5,8e10.3,3f10.3)
2000 format (a4,i5,1x,a5,a4,i5,1x,i4,1x,f4.1,e10.5,66f10.3,1x,
*e10.5,1x,e10.5,5e10.3,6f10.3,1x,i4)
1001 format (a4,i7,1x,a5,a4,i5,1x,i4,1x,f4.1,e10.5,66f10.3,1x,
*e10.5,1x,e10.5,8e10.3,3f10.3,1x,i4)
end |
-- Moved from the successfull test-suite. See Issue 1481.
module tests.Nat where
data Nat : Set where
Z : Nat
S : Nat → Nat
{-# BUILTIN NATURAL Nat #-}
_+_ : Nat → Nat → Nat
Z + m = m
S n + m = S (n + m)
{-# BUILTIN NATPLUS _+_ #-}
_*_ : Nat → Nat → Nat
Z * m = Z
S n * m = m + (n * m)
{-# BUILTIN NATTIMES _*_ #-}
data Unit : Set where
unit : Unit
postulate
IO : Set → Set
String : Set
natToString : Nat → String
putStr : String → IO Unit
printNat : Nat → IO Unit
printNat n = putStr (natToString n)
{-# COMPILED_TYPE IO IO #-}
{-# COMPILED_EPIC natToString (n : Any) -> String = bigToStr(n) #-}
{-# COMPILED_EPIC putStr (a : String, u : Unit) ->
Unit = foreign Int "wputStr" (a : String); primUnit #-}
main : IO Unit
main = printNat (7 * 191)
-- should print 1337
|
{-# OPTIONS --without-K #-}
module Hmm where
-- using the HoTT-Agda library leads to highlighting error (missing metadata)
-- open import lib.Base
-- open import lib.types.Nat
-- using this library does not, yet the code is copied/pasted from HoTT-Agda
open import Base
S= : {m n : ℕ} → m == n → S m == S n
S= idp = idp
|
[STATEMENT]
lemma of_char_eq_iff [simp]:
\<open>of_char c = of_char d \<longleftrightarrow> c = d\<close>
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. (of_char c = of_char d) = (c = d)
[PROOF STEP]
by (auto intro: of_char_eqI) |
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2020 Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
open import LibraBFT.Prelude
open import LibraBFT.Hash
open import LibraBFT.Abstract.Types
open import LibraBFT.Impl.NetworkMsg
open import LibraBFT.Impl.Consensus.Types
open import LibraBFT.Concrete.System.Parameters
open import LibraBFT.Concrete.Obligations
import LibraBFT.Concrete.Properties.VotesOnce as VO
import LibraBFT.Concrete.Properties.LockedRound as LR
open import LibraBFT.Yasm.System ConcSysParms
open import LibraBFT.Yasm.Properties ConcSysParms
-- In this module, we assume that the implementation meets its
-- obligations, and use this assumption to prove that the
-- implementatioon enjoys one of the per-epoch correctness conditions
-- proved in Abstract.Properties. It can be extended to other
-- properties later.
module LibraBFT.Concrete.Properties (impl-correct : ImplObligations) where
open ImplObligations impl-correct
-- For any reachable state,
module _ {e}(st : SystemState e)(r : ReachableSystemState st)(eid : Fin e) where
open import LibraBFT.Concrete.System sps-cor
open PerState st r
open PerEpoch eid
import LibraBFT.Abstract.Records 𝓔 Hash _≟Hash_ (ConcreteVoteEvidence 𝓔) as Abs
open import LibraBFT.Abstract.RecordChain 𝓔 Hash _≟Hash_ (ConcreteVoteEvidence 𝓔)
open import LibraBFT.Abstract.System 𝓔 Hash _≟Hash_ (ConcreteVoteEvidence 𝓔)
open import LibraBFT.Abstract.Properties 𝓔 Hash _≟Hash_ (ConcreteVoteEvidence 𝓔)
open import LibraBFT.Abstract.Obligations.VotesOnce 𝓔 Hash _≟Hash_ (ConcreteVoteEvidence 𝓔)
open import LibraBFT.Abstract.Obligations.LockedRound 𝓔 Hash _≟Hash_ (ConcreteVoteEvidence 𝓔)
validState : ValidSysState ConcSystemState
validState = record
{ vss-votes-once = VO.Proof.voo sps-cor vo₁ vo₂ st r eid
; vss-locked-round = LR.Proof.lrr sps-cor lr₁ st r eid
}
open All-InSys-props (AbsSystemState.InSys ConcSystemState)
-- commited blocks do not conflict.
S5 : ∀{q q'}
→ {rc : RecordChain (Abs.Q q)} → All-InSys rc
→ {rc' : RecordChain (Abs.Q q')} → All-InSys rc'
→ {b b' : Abs.Block}
→ CommitRule rc b
→ CommitRule rc' b'
→ NonInjective-≡ Abs.bId ⊎ ((Abs.B b) ∈RC rc' ⊎ (Abs.B b') ∈RC rc)
S5 = CommitsDoNotConflict ConcSystemState validState
|
module GRIN.Opts.CopyPropogation
import Data.SortedMap
import GRIN.AST
import GRIN.GrinM
0 CopyMap : Type
CopyMap = SortedMap Var Var
isValVar : (Val name) -> Maybe Var
isValVar (SimpleVal (SVar var)) = Just var
isValVar _ = Nothing
isPureVar : SExp name -> Maybe Var
isPureVar (Pure val) = isValVar val
isPureVar _ = Nothing
copyPropVar : CopyMap -> Var -> Var
copyPropVar cm var = case lookup var cm of
Nothing => var
Just var' => var'
copyPropSVal : CopyMap -> SVal -> SVal
copyPropSVal _ (SLit lit) = SLit lit
copyPropSVal cm (SVar var) = SVar (copyPropVar cm var)
copyPropVal : CopyMap -> Val name -> Val name
copyPropVal cm (SimpleVal val) = SimpleVal (copyPropSVal cm val)
copyPropVal cm (ConstTagNode tag args) = ConstTagNode tag (copyPropSVal cm <$> args)
copyPropVal _ (ConstTag tag) = ConstTag tag
copyPropVal cm (VarTagNode var args) = VarTagNode var (copyPropSVal cm <$> args)
copyPropVal _ VUnit = VUnit
mutual
copyPropSExp : CopyMap -> SExp name -> SExp name
copyPropSExp cm (Do exp) = Do (copyPropExp cm exp)
copyPropSExp cm (App fn vars) = App fn (copyPropVar cm <$> vars)
copyPropSExp cm (Pure val) = Pure (copyPropVal cm val)
copyPropSExp cm (Store val) = Store (copyPropVal cm val)
copyPropSExp cm (Fetch i var) = Fetch i (copyPropVar cm var)
copyPropSExp cm (FetchI i n var) = FetchI i n (copyPropVar cm var)
copyPropSExp cm (Update var val) = Update (copyPropVar cm var) (copyPropVal cm val)
copyPropExp : CopyMap -> Exp name -> Exp name
copyPropExp cm (Bind val rhs rest) =
let rhs' = copyPropSExp cm rhs in
case isValVar val of
Nothing => Bind val rhs' (copyPropExp cm rest)
Just copy => case isPureVar rhs of
Nothing => Bind val rhs' (copyPropExp cm rest)
Just var => copyPropExp (insert copy var cm) rest
copyPropExp cm (Case val alts) = Case (copyPropVal cm val) (copyPropAlt cm <$> alts)
copyPropExp cm (SimpleExp exp) = SimpleExp (copyPropSExp cm exp)
copyPropAlt : CopyMap -> Alt name -> Alt name
copyPropAlt cm (MkAlt pat exp) = MkAlt pat (copyPropExp cm exp)
export
copyProp : Monad m => GrinT name m ()
copyProp = mapProg $ mapExpProg (copyPropExp empty)
|
MODULE el2INT_I
INTERFACE
! *
SUBROUTINE EL2INT(JJA,JJB,JA,JB,ICOLBREI,INTERACT)
INTEGER, INTENT(IN) :: JJA,JJB,JA,JB,ICOLBREI
INTEGER, INTENT(OUT) :: INTERACT
END SUBROUTINE
END INTERFACE
END MODULE
|
The derivative of the circlepath function is given by the formula $2 \pi i r e^{2 \pi i x}$. |
State Before: K : Type u
V✝ V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η✝ : Type u₁'
φ : η✝ → Type ?u.526682
inst✝¹⁸ : Ring K
inst✝¹⁷ : StrongRankCondition K
inst✝¹⁶ : AddCommGroup V✝
inst✝¹⁵ : Module K V✝
inst✝¹⁴ : Module.Free K V✝
inst✝¹³ : AddCommGroup V'
inst✝¹² : Module K V'
inst✝¹¹ : Module.Free K V'
inst✝¹⁰ : AddCommGroup V₁
inst✝⁹ : Module K V₁
inst✝⁸ : Module.Free K V₁
inst✝⁷ : (i : η✝) → AddCommGroup (φ i)
inst✝⁶ : (i : η✝) → Module K (φ i)
inst✝⁵ : ∀ (i : η✝), Module.Free K (φ i)
inst✝⁴ : Fintype η✝
V η : Type u
inst✝³ : Fintype η
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Module.Free K V
⊢ Module.rank K (η → V) = ↑(Fintype.card η) * Module.rank K V State After: no goals Tactic: rw [rank_pi, Cardinal.sum_const', Cardinal.mk_fintype] |
Increase quality and safety with Furnace tap out actuators.
Stabilze the molten metal flow and control your launder levels.
This Actuator is primarily used to control the flow of molten metal through the exit tap hole of a stationary furnace. The actuator is equipped with a built in 4-20mA position feed back. Adjustable speed, travel length, holding force, closing force and open force. |
State Before: α : Type u
β : Type v
p : α → Prop
f : Perm α
⊢ (∀ (x : α), p (↑f⁻¹ x) ↔ p (↑f (↑f⁻¹ x))) ↔ ∀ (x : α), p x ↔ p (↑f⁻¹ x) State After: no goals Tactic: simp_rw [f.apply_inv_self, Iff.comm] |
theory Testing
imports "HOL-Analysis.Multivariate_Analysis"
begin
lemma interior_ball: "(x \<in> interior S) \<longleftrightarrow> (\<exists> e. 0 < e & (ball x e) \<subseteq> S)"
proof-
{ assume "x \<in> interior S"
from this obtain T where T_def: "open T & x \<in> T & T \<subseteq> S" using interior_def by auto
hence "\<exists> e. 0 < e & (ball x e) \<subseteq> T" using open_contains_ball by auto
hence "\<exists> e. 0 < e & (ball x e) \<subseteq> S" using T_def by auto
} note imp1 = this
{ assume "(\<exists> e. 0 < e & (ball x e) \<subseteq> S)"
from this obtain e where e_def: "0 < e & (ball x e) \<subseteq> S" by auto
obtain T where T_def: "T = ball x e" by auto
then have "open T & x \<in> T & T \<subseteq> S" using open_ball e_def by auto
hence "x \<in> interior S" using interior_def by auto
} from this show ?thesis using imp1 by auto
qed
end |
[GOAL]
ι : Type u
s : Finset ι
f : ι → ℝ
n : ℕ
hf : ∀ (a : ι), a ∈ s → 0 ≤ f a
⊢ (∑ x in s, f x) ^ (n + 1) / ↑(card s) ^ n ≤ ∑ x in s, f x ^ (n + 1)
[PROOFSTEP]
rcases s.eq_empty_or_nonempty with (rfl | hs)
[GOAL]
case inl
ι : Type u
f : ι → ℝ
n : ℕ
hf : ∀ (a : ι), a ∈ ∅ → 0 ≤ f a
⊢ (∑ x in ∅, f x) ^ (n + 1) / ↑(card ∅) ^ n ≤ ∑ x in ∅, f x ^ (n + 1)
[PROOFSTEP]
simp_rw [Finset.sum_empty, zero_pow' _ (Nat.succ_ne_zero n), zero_div]
[GOAL]
case inl
ι : Type u
f : ι → ℝ
n : ℕ
hf : ∀ (a : ι), a ∈ ∅ → 0 ≤ f a
⊢ 0 ≤ 0
[PROOFSTEP]
rfl
[GOAL]
case inr
ι : Type u
s : Finset ι
f : ι → ℝ
n : ℕ
hf : ∀ (a : ι), a ∈ s → 0 ≤ f a
hs : Finset.Nonempty s
⊢ (∑ x in s, f x) ^ (n + 1) / ↑(card s) ^ n ≤ ∑ x in s, f x ^ (n + 1)
[PROOFSTEP]
have hs0 : 0 < (s.card : ℝ) := Nat.cast_pos.2 hs.card_pos
[GOAL]
case inr
ι : Type u
s : Finset ι
f : ι → ℝ
n : ℕ
hf : ∀ (a : ι), a ∈ s → 0 ≤ f a
hs : Finset.Nonempty s
hs0 : 0 < ↑(card s)
⊢ (∑ x in s, f x) ^ (n + 1) / ↑(card s) ^ n ≤ ∑ x in s, f x ^ (n + 1)
[PROOFSTEP]
suffices (∑ x in s, f x / s.card) ^ (n + 1) ≤ ∑ x in s, f x ^ (n + 1) / s.card by
rwa [← Finset.sum_div, ← Finset.sum_div, div_pow, pow_succ' (s.card : ℝ), ← div_div, div_le_iff hs0, div_mul,
div_self hs0.ne', div_one] at this
[GOAL]
ι : Type u
s : Finset ι
f : ι → ℝ
n : ℕ
hf : ∀ (a : ι), a ∈ s → 0 ≤ f a
hs : Finset.Nonempty s
hs0 : 0 < ↑(card s)
this : (∑ x in s, f x / ↑(card s)) ^ (n + 1) ≤ ∑ x in s, f x ^ (n + 1) / ↑(card s)
⊢ (∑ x in s, f x) ^ (n + 1) / ↑(card s) ^ n ≤ ∑ x in s, f x ^ (n + 1)
[PROOFSTEP]
rwa [← Finset.sum_div, ← Finset.sum_div, div_pow, pow_succ' (s.card : ℝ), ← div_div, div_le_iff hs0, div_mul,
div_self hs0.ne', div_one] at this
[GOAL]
case inr
ι : Type u
s : Finset ι
f : ι → ℝ
n : ℕ
hf : ∀ (a : ι), a ∈ s → 0 ≤ f a
hs : Finset.Nonempty s
hs0 : 0 < ↑(card s)
⊢ (∑ x in s, f x / ↑(card s)) ^ (n + 1) ≤ ∑ x in s, f x ^ (n + 1) / ↑(card s)
[PROOFSTEP]
have :=
@ConvexOn.map_sum_le ℝ ℝ ℝ ι _ _ _ _ _ _ (Set.Ici 0) (fun x => x ^ (n + 1)) s (fun _ => 1 / s.card) ((↑) ∘ f)
(convexOn_pow (n + 1)) ?_ ?_ fun i hi => Set.mem_Ici.2 (hf i hi)
[GOAL]
case inr.refine_3
ι : Type u
s : Finset ι
f : ι → ℝ
n : ℕ
hf : ∀ (a : ι), a ∈ s → 0 ≤ f a
hs : Finset.Nonempty s
hs0 : 0 < ↑(card s)
this :
(fun x => x ^ (n + 1)) (∑ i in s, (fun x => 1 / ↑(card s)) i • ((fun x => x) ∘ f) i) ≤
∑ i in s, (fun x => 1 / ↑(card s)) i • (fun x => x ^ (n + 1)) (((fun x => x) ∘ f) i)
⊢ (∑ x in s, f x / ↑(card s)) ^ (n + 1) ≤ ∑ x in s, f x ^ (n + 1) / ↑(card s)
[PROOFSTEP]
simpa only [inv_mul_eq_div, one_div, Algebra.id.smul_eq_mul] using this
[GOAL]
case inr.refine_1
ι : Type u
s : Finset ι
f : ι → ℝ
n : ℕ
hf : ∀ (a : ι), a ∈ s → 0 ≤ f a
hs : Finset.Nonempty s
hs0 : 0 < ↑(card s)
⊢ ∀ (i : ι), i ∈ s → 0 ≤ (fun x => 1 / ↑(card s)) i
[PROOFSTEP]
simp only [one_div, inv_nonneg, Nat.cast_nonneg, imp_true_iff]
[GOAL]
case inr.refine_2
ι : Type u
s : Finset ι
f : ι → ℝ
n : ℕ
hf : ∀ (a : ι), a ∈ s → 0 ≤ f a
hs : Finset.Nonempty s
hs0 : 0 < ↑(card s)
⊢ ∑ i in s, (fun x => 1 / ↑(card s)) i = 1
[PROOFSTEP]
simpa only [one_div, Finset.sum_const, nsmul_eq_mul] using mul_inv_cancel hs0.ne'
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ
hw : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw' : ∑ i in s, w i = 1
hz : ∀ (i : ι), i ∈ s → 0 ≤ z i
p : ℝ
hp : 1 ≤ p
⊢ ∑ i in s, w i * z i ≤ (∑ i in s, w i * z i ^ p) ^ (1 / p)
[PROOFSTEP]
have : 0 < p := by positivity
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ
hw : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw' : ∑ i in s, w i = 1
hz : ∀ (i : ι), i ∈ s → 0 ≤ z i
p : ℝ
hp : 1 ≤ p
⊢ 0 < p
[PROOFSTEP]
positivity
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ
hw : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw' : ∑ i in s, w i = 1
hz : ∀ (i : ι), i ∈ s → 0 ≤ z i
p : ℝ
hp : 1 ≤ p
this : 0 < p
⊢ ∑ i in s, w i * z i ≤ (∑ i in s, w i * z i ^ p) ^ (1 / p)
[PROOFSTEP]
rw [← rpow_le_rpow_iff _ _ this, ← rpow_mul, one_div_mul_cancel (ne_of_gt this), rpow_one]
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ
hw : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw' : ∑ i in s, w i = 1
hz : ∀ (i : ι), i ∈ s → 0 ≤ z i
p : ℝ
hp : 1 ≤ p
this : 0 < p
⊢ (∑ i in s, w i * z i) ^ p ≤ ∑ i in s, w i * z i ^ p
case hx
ι : Type u
s : Finset ι
w z : ι → ℝ
hw : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw' : ∑ i in s, w i = 1
hz : ∀ (i : ι), i ∈ s → 0 ≤ z i
p : ℝ
hp : 1 ≤ p
this : 0 < p
⊢ 0 ≤ ∑ i in s, w i * z i ^ p
ι : Type u
s : Finset ι
w z : ι → ℝ
hw : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw' : ∑ i in s, w i = 1
hz : ∀ (i : ι), i ∈ s → 0 ≤ z i
p : ℝ
hp : 1 ≤ p
this : 0 < p
⊢ 0 ≤ ∑ i in s, w i * z i
ι : Type u
s : Finset ι
w z : ι → ℝ
hw : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw' : ∑ i in s, w i = 1
hz : ∀ (i : ι), i ∈ s → 0 ≤ z i
p : ℝ
hp : 1 ≤ p
this : 0 < p
⊢ 0 ≤ (∑ i in s, w i * z i ^ p) ^ (1 / p)
[PROOFSTEP]
exact rpow_arith_mean_le_arith_mean_rpow s w z hw hw' hz hp
[GOAL]
case hx
ι : Type u
s : Finset ι
w z : ι → ℝ
hw : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw' : ∑ i in s, w i = 1
hz : ∀ (i : ι), i ∈ s → 0 ≤ z i
p : ℝ
hp : 1 ≤ p
this : 0 < p
⊢ 0 ≤ ∑ i in s, w i * z i ^ p
ι : Type u
s : Finset ι
w z : ι → ℝ
hw : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw' : ∑ i in s, w i = 1
hz : ∀ (i : ι), i ∈ s → 0 ≤ z i
p : ℝ
hp : 1 ≤ p
this : 0 < p
⊢ 0 ≤ ∑ i in s, w i * z i
ι : Type u
s : Finset ι
w z : ι → ℝ
hw : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw' : ∑ i in s, w i = 1
hz : ∀ (i : ι), i ∈ s → 0 ≤ z i
p : ℝ
hp : 1 ≤ p
this : 0 < p
⊢ 0 ≤ (∑ i in s, w i * z i ^ p) ^ (1 / p)
[PROOFSTEP]
all_goals
apply_rules [sum_nonneg, rpow_nonneg_of_nonneg]
intro i hi
apply_rules [mul_nonneg, rpow_nonneg_of_nonneg, hw i hi, hz i hi]
[GOAL]
case hx
ι : Type u
s : Finset ι
w z : ι → ℝ
hw : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw' : ∑ i in s, w i = 1
hz : ∀ (i : ι), i ∈ s → 0 ≤ z i
p : ℝ
hp : 1 ≤ p
this : 0 < p
⊢ 0 ≤ ∑ i in s, w i * z i ^ p
[PROOFSTEP]
apply_rules [sum_nonneg, rpow_nonneg_of_nonneg]
[GOAL]
case hx
ι : Type u
s : Finset ι
w z : ι → ℝ
hw : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw' : ∑ i in s, w i = 1
hz : ∀ (i : ι), i ∈ s → 0 ≤ z i
p : ℝ
hp : 1 ≤ p
this : 0 < p
hw'_symm : 1 = ∑ i in s, w i
⊢ ∀ (i : ι), i ∈ s → 0 ≤ w i * z i ^ p
[PROOFSTEP]
intro i hi
[GOAL]
case hx
ι : Type u
s : Finset ι
w z : ι → ℝ
hw : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw' : ∑ i in s, w i = 1
hz : ∀ (i : ι), i ∈ s → 0 ≤ z i
p : ℝ
hp : 1 ≤ p
this : 0 < p
hw'_symm : 1 = ∑ i in s, w i
i : ι
hi : i ∈ s
⊢ 0 ≤ w i * z i ^ p
[PROOFSTEP]
apply_rules [mul_nonneg, rpow_nonneg_of_nonneg, hw i hi, hz i hi]
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ
hw : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw' : ∑ i in s, w i = 1
hz : ∀ (i : ι), i ∈ s → 0 ≤ z i
p : ℝ
hp : 1 ≤ p
this : 0 < p
⊢ 0 ≤ ∑ i in s, w i * z i
[PROOFSTEP]
apply_rules [sum_nonneg, rpow_nonneg_of_nonneg]
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ
hw : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw' : ∑ i in s, w i = 1
hz : ∀ (i : ι), i ∈ s → 0 ≤ z i
p : ℝ
hp : 1 ≤ p
this : 0 < p
hw'_symm : 1 = ∑ i in s, w i
⊢ ∀ (i : ι), i ∈ s → 0 ≤ w i * z i
[PROOFSTEP]
intro i hi
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ
hw : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw' : ∑ i in s, w i = 1
hz : ∀ (i : ι), i ∈ s → 0 ≤ z i
p : ℝ
hp : 1 ≤ p
this : 0 < p
hw'_symm : 1 = ∑ i in s, w i
i : ι
hi : i ∈ s
⊢ 0 ≤ w i * z i
[PROOFSTEP]
apply_rules [mul_nonneg, rpow_nonneg_of_nonneg, hw i hi, hz i hi]
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ
hw : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw' : ∑ i in s, w i = 1
hz : ∀ (i : ι), i ∈ s → 0 ≤ z i
p : ℝ
hp : 1 ≤ p
this : 0 < p
⊢ 0 ≤ (∑ i in s, w i * z i ^ p) ^ (1 / p)
[PROOFSTEP]
apply_rules [sum_nonneg, rpow_nonneg_of_nonneg]
[GOAL]
case hx
ι : Type u
s : Finset ι
w z : ι → ℝ
hw : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw' : ∑ i in s, w i = 1
hz : ∀ (i : ι), i ∈ s → 0 ≤ z i
p : ℝ
hp : 1 ≤ p
this : 0 < p
hw'_symm : 1 = ∑ i in s, w i
⊢ ∀ (i : ι), i ∈ s → 0 ≤ w i * z i ^ p
[PROOFSTEP]
intro i hi
[GOAL]
case hx
ι : Type u
s : Finset ι
w z : ι → ℝ
hw : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw' : ∑ i in s, w i = 1
hz : ∀ (i : ι), i ∈ s → 0 ≤ z i
p : ℝ
hp : 1 ≤ p
this : 0 < p
hw'_symm : 1 = ∑ i in s, w i
i : ι
hi : i ∈ s
⊢ 0 ≤ w i * z i ^ p
[PROOFSTEP]
apply_rules [mul_nonneg, rpow_nonneg_of_nonneg, hw i hi, hz i hi]
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0
hw' : ∑ i in s, w i = 1
n : ℕ
⊢ (∑ i in s, w i * z i) ^ n ≤ ∑ i in s, w i * z i ^ n
[PROOFSTEP]
exact_mod_cast
Real.pow_arith_mean_le_arith_mean_pow s _ _ (fun i _ => (w i).coe_nonneg) (by exact_mod_cast hw')
(fun i _ => (z i).coe_nonneg) n
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0
hw' : ∑ i in s, w i = 1
n : ℕ
⊢ ∑ i in s, ↑(w i) = 1
[PROOFSTEP]
exact_mod_cast hw'
[GOAL]
ι : Type u
s : Finset ι
f : ι → ℝ≥0
n : ℕ
⊢ ↑((∑ x in s, f x) ^ (n + 1)) / ↑(card s) ^ n ≤ ↑(∑ x in s, f x ^ (n + 1))
[PROOFSTEP]
simpa only [← NNReal.coe_le_coe, NNReal.coe_sum, Nonneg.coe_div, NNReal.coe_pow] using
@Real.pow_sum_div_card_le_sum_pow ι s (((↑) : ℝ≥0 → ℝ) ∘ f) n fun _ _ => NNReal.coe_nonneg _
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
⊢ (∑ i in s, w i * z i) ^ p ≤ ∑ i in s, w i * z i ^ p
[PROOFSTEP]
exact_mod_cast
Real.rpow_arith_mean_le_arith_mean_rpow s _ _ (fun i _ => (w i).coe_nonneg) (by exact_mod_cast hw')
(fun i _ => (z i).coe_nonneg) hp
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
⊢ ∑ i in s, ↑(w i) = 1
[PROOFSTEP]
exact_mod_cast hw'
[GOAL]
ι : Type u
s : Finset ι
w₁ w₂ z₁ z₂ : ℝ≥0
hw' : w₁ + w₂ = 1
p : ℝ
hp : 1 ≤ p
⊢ (w₁ * z₁ + w₂ * z₂) ^ p ≤ w₁ * z₁ ^ p + w₂ * z₂ ^ p
[PROOFSTEP]
have h := rpow_arith_mean_le_arith_mean_rpow univ ![w₁, w₂] ![z₁, z₂] ?_ hp
[GOAL]
case refine_2
ι : Type u
s : Finset ι
w₁ w₂ z₁ z₂ : ℝ≥0
hw' : w₁ + w₂ = 1
p : ℝ
hp : 1 ≤ p
h :
(∑ i : Fin (Nat.succ (Nat.succ 0)), Matrix.vecCons w₁ ![w₂] i * Matrix.vecCons z₁ ![z₂] i) ^ p ≤
∑ i : Fin (Nat.succ (Nat.succ 0)), Matrix.vecCons w₁ ![w₂] i * Matrix.vecCons z₁ ![z₂] i ^ p
⊢ (w₁ * z₁ + w₂ * z₂) ^ p ≤ w₁ * z₁ ^ p + w₂ * z₂ ^ p
[PROOFSTEP]
simpa [Fin.sum_univ_succ] using h
[GOAL]
case refine_1
ι : Type u
s : Finset ι
w₁ w₂ z₁ z₂ : ℝ≥0
hw' : w₁ + w₂ = 1
p : ℝ
hp : 1 ≤ p
⊢ ∑ i : Fin (Nat.succ (Nat.succ 0)), Matrix.vecCons w₁ ![w₂] i = 1
[PROOFSTEP]
simp [hw', Fin.sum_univ_succ]
[GOAL]
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0
p : ℝ
hp : 1 ≤ p
⊢ (z₁ + z₂) ^ p ≤ 2 ^ (p - 1) * (z₁ ^ p + z₂ ^ p)
[PROOFSTEP]
rcases eq_or_lt_of_le hp with (rfl | h'p)
[GOAL]
case inl
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0
hp : 1 ≤ 1
⊢ (z₁ + z₂) ^ 1 ≤ 2 ^ (1 - 1) * (z₁ ^ 1 + z₂ ^ 1)
[PROOFSTEP]
simp only [rpow_one, sub_self, rpow_zero, one_mul]
[GOAL]
case inl
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0
hp : 1 ≤ 1
⊢ z₁ + z₂ ≤ z₁ + z₂
[PROOFSTEP]
rfl
[GOAL]
case inr
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0
p : ℝ
hp : 1 ≤ p
h'p : 1 < p
⊢ (z₁ + z₂) ^ p ≤ 2 ^ (p - 1) * (z₁ ^ p + z₂ ^ p)
[PROOFSTEP]
convert rpow_arith_mean_le_arith_mean2_rpow (1 / 2) (1 / 2) (2 * z₁) (2 * z₂) (add_halves 1) hp using 1
[GOAL]
case h.e'_3
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0
p : ℝ
hp : 1 ≤ p
h'p : 1 < p
⊢ (z₁ + z₂) ^ p = (1 / 2 * (2 * z₁) + 1 / 2 * (2 * z₂)) ^ p
[PROOFSTEP]
simp only [one_div, inv_mul_cancel_left₀, Ne.def, mul_eq_zero, two_ne_zero, one_ne_zero, not_false_iff]
[GOAL]
case h.e'_4
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0
p : ℝ
hp : 1 ≤ p
h'p : 1 < p
⊢ 2 ^ (p - 1) * (z₁ ^ p + z₂ ^ p) = 1 / 2 * (2 * z₁) ^ p + 1 / 2 * (2 * z₂) ^ p
[PROOFSTEP]
have A : p - 1 ≠ 0 := ne_of_gt (sub_pos.2 h'p)
[GOAL]
case h.e'_4
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0
p : ℝ
hp : 1 ≤ p
h'p : 1 < p
A : p - 1 ≠ 0
⊢ 2 ^ (p - 1) * (z₁ ^ p + z₂ ^ p) = 1 / 2 * (2 * z₁) ^ p + 1 / 2 * (2 * z₂) ^ p
[PROOFSTEP]
simp only [mul_rpow, rpow_sub' _ A, div_eq_inv_mul, rpow_one, mul_one]
[GOAL]
case h.e'_4
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0
p : ℝ
hp : 1 ≤ p
h'p : 1 < p
A : p - 1 ≠ 0
⊢ 2⁻¹ * 2 ^ p * (z₁ ^ p + z₂ ^ p) = 2⁻¹ * (2 ^ p * z₁ ^ p) + 2⁻¹ * (2 ^ p * z₂ ^ p)
[PROOFSTEP]
ring
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
⊢ ∑ i in s, w i * z i ≤ (∑ i in s, w i * z i ^ p) ^ (1 / p)
[PROOFSTEP]
exact_mod_cast
Real.arith_mean_le_rpow_mean s _ _ (fun i _ => (w i).coe_nonneg) (by exact_mod_cast hw') (fun i _ => (z i).coe_nonneg)
hp
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
⊢ ∑ i in s, ↑(w i) = 1
[PROOFSTEP]
exact_mod_cast hw'
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hab : a + b ≤ 1
hp1 : 1 ≤ p
⊢ a ^ p + b ^ p ≤ 1
[PROOFSTEP]
have h_le_one : ∀ x : ℝ≥0, x ≤ 1 → x ^ p ≤ x := fun x hx => rpow_le_self_of_le_one hx hp1
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hab : a + b ≤ 1
hp1 : 1 ≤ p
h_le_one : ∀ (x : ℝ≥0), x ≤ 1 → x ^ p ≤ x
⊢ a ^ p + b ^ p ≤ 1
[PROOFSTEP]
have ha : a ≤ 1 := (self_le_add_right a b).trans hab
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hab : a + b ≤ 1
hp1 : 1 ≤ p
h_le_one : ∀ (x : ℝ≥0), x ≤ 1 → x ^ p ≤ x
ha : a ≤ 1
⊢ a ^ p + b ^ p ≤ 1
[PROOFSTEP]
have hb : b ≤ 1 := (self_le_add_left b a).trans hab
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hab : a + b ≤ 1
hp1 : 1 ≤ p
h_le_one : ∀ (x : ℝ≥0), x ≤ 1 → x ^ p ≤ x
ha : a ≤ 1
hb : b ≤ 1
⊢ a ^ p + b ^ p ≤ 1
[PROOFSTEP]
exact (add_le_add (h_le_one a ha) (h_le_one b hb)).trans hab
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
[PROOFSTEP]
have hp_pos : 0 < p := by positivity
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ 0 < p
[PROOFSTEP]
positivity
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
hp_pos : 0 < p
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
[PROOFSTEP]
by_cases h_zero : a + b = 0
[GOAL]
case pos
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
hp_pos : 0 < p
h_zero : a + b = 0
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
[PROOFSTEP]
simp [add_eq_zero_iff.mp h_zero, hp_pos.ne']
[GOAL]
case neg
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
hp_pos : 0 < p
h_zero : ¬a + b = 0
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
[PROOFSTEP]
have h_nonzero : ¬(a = 0 ∧ b = 0) := by rwa [add_eq_zero_iff] at h_zero
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
hp_pos : 0 < p
h_zero : ¬a + b = 0
⊢ ¬(a = 0 ∧ b = 0)
[PROOFSTEP]
rwa [add_eq_zero_iff] at h_zero
[GOAL]
case neg
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
hp_pos : 0 < p
h_zero : ¬a + b = 0
h_nonzero : ¬(a = 0 ∧ b = 0)
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
[PROOFSTEP]
have h_add : a / (a + b) + b / (a + b) = 1 := by rw [div_add_div_same, div_self h_zero]
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
hp_pos : 0 < p
h_zero : ¬a + b = 0
h_nonzero : ¬(a = 0 ∧ b = 0)
⊢ a / (a + b) + b / (a + b) = 1
[PROOFSTEP]
rw [div_add_div_same, div_self h_zero]
[GOAL]
case neg
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
hp_pos : 0 < p
h_zero : ¬a + b = 0
h_nonzero : ¬(a = 0 ∧ b = 0)
h_add : a / (a + b) + b / (a + b) = 1
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
[PROOFSTEP]
have h := add_rpow_le_one_of_add_le_one (a / (a + b)) (b / (a + b)) h_add.le hp1
[GOAL]
case neg
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
hp_pos : 0 < p
h_zero : ¬a + b = 0
h_nonzero : ¬(a = 0 ∧ b = 0)
h_add : a / (a + b) + b / (a + b) = 1
h : (a / (a + b)) ^ p + (b / (a + b)) ^ p ≤ 1
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
[PROOFSTEP]
rw [div_rpow a (a + b), div_rpow b (a + b)] at h
[GOAL]
case neg
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
hp_pos : 0 < p
h_zero : ¬a + b = 0
h_nonzero : ¬(a = 0 ∧ b = 0)
h_add : a / (a + b) + b / (a + b) = 1
h : a ^ p / (a + b) ^ p + b ^ p / (a + b) ^ p ≤ 1
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
[PROOFSTEP]
have hab_0 : (a + b) ^ p ≠ 0 := by simp [hp_pos, h_nonzero]
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
hp_pos : 0 < p
h_zero : ¬a + b = 0
h_nonzero : ¬(a = 0 ∧ b = 0)
h_add : a / (a + b) + b / (a + b) = 1
h : a ^ p / (a + b) ^ p + b ^ p / (a + b) ^ p ≤ 1
⊢ (a + b) ^ p ≠ 0
[PROOFSTEP]
simp [hp_pos, h_nonzero]
[GOAL]
case neg
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
hp_pos : 0 < p
h_zero : ¬a + b = 0
h_nonzero : ¬(a = 0 ∧ b = 0)
h_add : a / (a + b) + b / (a + b) = 1
h : a ^ p / (a + b) ^ p + b ^ p / (a + b) ^ p ≤ 1
hab_0 : (a + b) ^ p ≠ 0
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
[PROOFSTEP]
have hab_0' : 0 < (a + b) ^ p := zero_lt_iff.mpr hab_0
[GOAL]
case neg
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
hp_pos : 0 < p
h_zero : ¬a + b = 0
h_nonzero : ¬(a = 0 ∧ b = 0)
h_add : a / (a + b) + b / (a + b) = 1
h : a ^ p / (a + b) ^ p + b ^ p / (a + b) ^ p ≤ 1
hab_0 : (a + b) ^ p ≠ 0
hab_0' : 0 < (a + b) ^ p
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
[PROOFSTEP]
have h_mul : (a + b) ^ p * (a ^ p / (a + b) ^ p + b ^ p / (a + b) ^ p) ≤ (a + b) ^ p :=
by
nth_rw 4 [← mul_one ((a + b) ^ p)]
exact (mul_le_mul_left hab_0').mpr h
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
hp_pos : 0 < p
h_zero : ¬a + b = 0
h_nonzero : ¬(a = 0 ∧ b = 0)
h_add : a / (a + b) + b / (a + b) = 1
h : a ^ p / (a + b) ^ p + b ^ p / (a + b) ^ p ≤ 1
hab_0 : (a + b) ^ p ≠ 0
hab_0' : 0 < (a + b) ^ p
⊢ (a + b) ^ p * (a ^ p / (a + b) ^ p + b ^ p / (a + b) ^ p) ≤ (a + b) ^ p
[PROOFSTEP]
nth_rw 4 [← mul_one ((a + b) ^ p)]
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
hp_pos : 0 < p
h_zero : ¬a + b = 0
h_nonzero : ¬(a = 0 ∧ b = 0)
h_add : a / (a + b) + b / (a + b) = 1
h : a ^ p / (a + b) ^ p + b ^ p / (a + b) ^ p ≤ 1
hab_0 : (a + b) ^ p ≠ 0
hab_0' : 0 < (a + b) ^ p
⊢ (a + b) ^ p * (a ^ p / (a + b) ^ p + b ^ p / (a + b) ^ p) ≤ (a + b) ^ p * 1
[PROOFSTEP]
exact (mul_le_mul_left hab_0').mpr h
[GOAL]
case neg
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
hp_pos : 0 < p
h_zero : ¬a + b = 0
h_nonzero : ¬(a = 0 ∧ b = 0)
h_add : a / (a + b) + b / (a + b) = 1
h : a ^ p / (a + b) ^ p + b ^ p / (a + b) ^ p ≤ 1
hab_0 : (a + b) ^ p ≠ 0
hab_0' : 0 < (a + b) ^ p
h_mul : (a + b) ^ p * (a ^ p / (a + b) ^ p + b ^ p / (a + b) ^ p) ≤ (a + b) ^ p
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
[PROOFSTEP]
rwa [div_eq_mul_inv, div_eq_mul_inv, mul_add, mul_comm (a ^ p), mul_comm (b ^ p), ← mul_assoc, ← mul_assoc,
mul_inv_cancel hab_0, one_mul, one_mul] at h_mul
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ (a ^ p + b ^ p) ^ (1 / p) ≤ a + b
[PROOFSTEP]
rw [← @NNReal.le_rpow_one_div_iff _ _ (1 / p) (by simp [lt_of_lt_of_le zero_lt_one hp1])]
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ 0 < 1 / p
[PROOFSTEP]
simp [lt_of_lt_of_le zero_lt_one hp1]
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ a ^ p + b ^ p ≤ (a + b) ^ (1 / (1 / p))
[PROOFSTEP]
rw [one_div_one_div]
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
[PROOFSTEP]
exact add_rpow_le_rpow_add _ _ hp1
[GOAL]
ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0
hp_pos : 0 < p
hpq : p ≤ q
⊢ (a ^ q + b ^ q) ^ (1 / q) ≤ (a ^ p + b ^ p) ^ (1 / p)
[PROOFSTEP]
have h_rpow : ∀ a : ℝ≥0, a ^ q = (a ^ p) ^ (q / p) := fun a => by
rw [← NNReal.rpow_mul, div_eq_inv_mul, ← mul_assoc, _root_.mul_inv_cancel hp_pos.ne.symm, one_mul]
[GOAL]
ι : Type u
s : Finset ι
p q : ℝ
a✝ b : ℝ≥0
hp_pos : 0 < p
hpq : p ≤ q
a : ℝ≥0
⊢ a ^ q = (a ^ p) ^ (q / p)
[PROOFSTEP]
rw [← NNReal.rpow_mul, div_eq_inv_mul, ← mul_assoc, _root_.mul_inv_cancel hp_pos.ne.symm, one_mul]
[GOAL]
ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0
hp_pos : 0 < p
hpq : p ≤ q
h_rpow : ∀ (a : ℝ≥0), a ^ q = (a ^ p) ^ (q / p)
⊢ (a ^ q + b ^ q) ^ (1 / q) ≤ (a ^ p + b ^ p) ^ (1 / p)
[PROOFSTEP]
have h_rpow_add_rpow_le_add : ((a ^ p) ^ (q / p) + (b ^ p) ^ (q / p)) ^ (1 / (q / p)) ≤ a ^ p + b ^ p :=
by
refine' rpow_add_rpow_le_add (a ^ p) (b ^ p) _
rwa [one_le_div hp_pos]
[GOAL]
ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0
hp_pos : 0 < p
hpq : p ≤ q
h_rpow : ∀ (a : ℝ≥0), a ^ q = (a ^ p) ^ (q / p)
⊢ ((a ^ p) ^ (q / p) + (b ^ p) ^ (q / p)) ^ (1 / (q / p)) ≤ a ^ p + b ^ p
[PROOFSTEP]
refine' rpow_add_rpow_le_add (a ^ p) (b ^ p) _
[GOAL]
ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0
hp_pos : 0 < p
hpq : p ≤ q
h_rpow : ∀ (a : ℝ≥0), a ^ q = (a ^ p) ^ (q / p)
⊢ 1 ≤ q / p
[PROOFSTEP]
rwa [one_le_div hp_pos]
[GOAL]
ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0
hp_pos : 0 < p
hpq : p ≤ q
h_rpow : ∀ (a : ℝ≥0), a ^ q = (a ^ p) ^ (q / p)
h_rpow_add_rpow_le_add : ((a ^ p) ^ (q / p) + (b ^ p) ^ (q / p)) ^ (1 / (q / p)) ≤ a ^ p + b ^ p
⊢ (a ^ q + b ^ q) ^ (1 / q) ≤ (a ^ p + b ^ p) ^ (1 / p)
[PROOFSTEP]
rw [h_rpow a, h_rpow b, NNReal.le_rpow_one_div_iff hp_pos, ← NNReal.rpow_mul, mul_comm, mul_one_div]
[GOAL]
ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0
hp_pos : 0 < p
hpq : p ≤ q
h_rpow : ∀ (a : ℝ≥0), a ^ q = (a ^ p) ^ (q / p)
h_rpow_add_rpow_le_add : ((a ^ p) ^ (q / p) + (b ^ p) ^ (q / p)) ^ (1 / (q / p)) ≤ a ^ p + b ^ p
⊢ ((a ^ p) ^ (q / p) + (b ^ p) ^ (q / p)) ^ (p / q) ≤ a ^ p + b ^ p
[PROOFSTEP]
rwa [one_div_div] at h_rpow_add_rpow_le_add
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp : 0 ≤ p
hp1 : p ≤ 1
⊢ (a + b) ^ p ≤ a ^ p + b ^ p
[PROOFSTEP]
rcases hp.eq_or_lt with (rfl | hp_pos)
[GOAL]
case inl
ι : Type u
s : Finset ι
a b : ℝ≥0
hp : 0 ≤ 0
hp1 : 0 ≤ 1
⊢ (a + b) ^ 0 ≤ a ^ 0 + b ^ 0
[PROOFSTEP]
simp
[GOAL]
case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
⊢ (a + b) ^ p ≤ a ^ p + b ^ p
[PROOFSTEP]
have h := rpow_add_rpow_le a b hp_pos hp1
[GOAL]
case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : (a ^ 1 + b ^ 1) ^ (1 / 1) ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p
[PROOFSTEP]
rw [one_div_one] at h
[GOAL]
case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : (a ^ 1 + b ^ 1) ^ 1 ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p
[PROOFSTEP]
repeat' rw [NNReal.rpow_one] at h
[GOAL]
case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : (a ^ 1 + b ^ 1) ^ 1 ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p
[PROOFSTEP]
rw [NNReal.rpow_one] at h
[GOAL]
case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : a ^ 1 + b ^ 1 ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p
[PROOFSTEP]
rw [NNReal.rpow_one] at h
[GOAL]
case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : a + b ^ 1 ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p
[PROOFSTEP]
rw [NNReal.rpow_one] at h
[GOAL]
case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : a + b ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p
[PROOFSTEP]
rw [NNReal.rpow_one] at h
[GOAL]
case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : a + b ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p
[PROOFSTEP]
exact (NNReal.le_rpow_one_div_iff hp_pos).mp h
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
⊢ (∑ i in s, w i * z i) ^ p ≤ ∑ i in s, w i * z i ^ p
[PROOFSTEP]
have hp_pos : 0 < p
[GOAL]
case hp_pos
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
⊢ 0 < p
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
⊢ (∑ i in s, w i * z i) ^ p ≤ ∑ i in s, w i * z i ^ p
[PROOFSTEP]
positivity
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
⊢ (∑ i in s, w i * z i) ^ p ≤ ∑ i in s, w i * z i ^ p
[PROOFSTEP]
have hp_nonneg : 0 ≤ p
[GOAL]
case hp_nonneg
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
⊢ 0 ≤ p
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
⊢ (∑ i in s, w i * z i) ^ p ≤ ∑ i in s, w i * z i ^ p
[PROOFSTEP]
positivity
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
⊢ (∑ i in s, w i * z i) ^ p ≤ ∑ i in s, w i * z i ^ p
[PROOFSTEP]
have hp_not_neg : ¬p < 0 := by simp [hp_nonneg]
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
⊢ ¬p < 0
[PROOFSTEP]
simp [hp_nonneg]
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
⊢ (∑ i in s, w i * z i) ^ p ≤ ∑ i in s, w i * z i ^ p
[PROOFSTEP]
have h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤) := by
simp [ENNReal.mul_eq_top, hp_pos, hp_nonneg, hp_not_neg]
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
⊢ ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
[PROOFSTEP]
simp [ENNReal.mul_eq_top, hp_pos, hp_nonneg, hp_not_neg]
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
⊢ (∑ i in s, w i * z i) ^ p ≤ ∑ i in s, w i * z i ^ p
[PROOFSTEP]
refine' le_of_top_imp_top_of_toNNReal_le _ _
[GOAL]
case refine'_1
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
⊢ (∑ i in s, w i * z i) ^ p = ⊤ → ∑ i in s, w i * z i ^ p = ⊤
[PROOFSTEP]
rw [rpow_eq_top_iff, sum_eq_top_iff, sum_eq_top_iff]
[GOAL]
case refine'_1
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
⊢ ∑ i in s, w i * z i = 0 ∧ p < 0 ∨ (∃ a, a ∈ s ∧ w a * z a = ⊤) ∧ 0 < p → ∃ a, a ∈ s ∧ w a * z a ^ p = ⊤
[PROOFSTEP]
intro h
[GOAL]
case refine'_1
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
h : ∑ i in s, w i * z i = 0 ∧ p < 0 ∨ (∃ a, a ∈ s ∧ w a * z a = ⊤) ∧ 0 < p
⊢ ∃ a, a ∈ s ∧ w a * z a ^ p = ⊤
[PROOFSTEP]
simp only [and_false_iff, hp_not_neg, false_or_iff] at h
[GOAL]
case refine'_1
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
h : (∃ a, a ∈ s ∧ w a * z a = ⊤) ∧ 0 < p
⊢ ∃ a, a ∈ s ∧ w a * z a ^ p = ⊤
[PROOFSTEP]
rcases h.left with ⟨a, H, ha⟩
[GOAL]
case refine'_1.intro.intro
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
h : (∃ a, a ∈ s ∧ w a * z a = ⊤) ∧ 0 < p
a : ι
H : a ∈ s
ha : w a * z a = ⊤
⊢ ∃ a, a ∈ s ∧ w a * z a ^ p = ⊤
[PROOFSTEP]
use a, H
[GOAL]
case right
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
h : (∃ a, a ∈ s ∧ w a * z a = ⊤) ∧ 0 < p
a : ι
H : a ∈ s
ha : w a * z a = ⊤
⊢ w a * z a ^ p = ⊤
[PROOFSTEP]
rwa [← h_top_iff_rpow_top a H]
[GOAL]
case refine'_2
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
⊢ (∑ i in s, w i * z i) ^ p ≠ ⊤ →
∑ i in s, w i * z i ^ p ≠ ⊤ →
ENNReal.toNNReal ((∑ i in s, w i * z i) ^ p) ≤ ENNReal.toNNReal (∑ i in s, w i * z i ^ p)
[PROOFSTEP]
intro h_top_rpow_sum
_
-- show hypotheses needed to put the `.toNNReal` inside the sums.
[GOAL]
case refine'_2
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
h_top_rpow_sum : (∑ i in s, w i * z i) ^ p ≠ ⊤
a✝ : ∑ i in s, w i * z i ^ p ≠ ⊤
⊢ ENNReal.toNNReal ((∑ i in s, w i * z i) ^ p) ≤ ENNReal.toNNReal (∑ i in s, w i * z i ^ p)
[PROOFSTEP]
have h_top : ∀ a : ι, a ∈ s → w a * z a ≠ ⊤ :=
haveI h_top_sum : ∑ i : ι in s, w i * z i ≠ ⊤ := by
intro h
rw [h, top_rpow_of_pos hp_pos] at h_top_rpow_sum
exact h_top_rpow_sum rfl
fun a ha => (lt_top_of_sum_ne_top h_top_sum ha).ne
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
h_top_rpow_sum : (∑ i in s, w i * z i) ^ p ≠ ⊤
a✝ : ∑ i in s, w i * z i ^ p ≠ ⊤
⊢ ∑ i in s, w i * z i ≠ ⊤
[PROOFSTEP]
intro h
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
h_top_rpow_sum : (∑ i in s, w i * z i) ^ p ≠ ⊤
a✝ : ∑ i in s, w i * z i ^ p ≠ ⊤
h : ∑ i in s, w i * z i = ⊤
⊢ False
[PROOFSTEP]
rw [h, top_rpow_of_pos hp_pos] at h_top_rpow_sum
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
h_top_rpow_sum : ⊤ ≠ ⊤
a✝ : ∑ i in s, w i * z i ^ p ≠ ⊤
h : ∑ i in s, w i * z i = ⊤
⊢ False
[PROOFSTEP]
exact h_top_rpow_sum rfl
[GOAL]
case refine'_2
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
h_top_rpow_sum : (∑ i in s, w i * z i) ^ p ≠ ⊤
a✝ : ∑ i in s, w i * z i ^ p ≠ ⊤
h_top : ∀ (a : ι), a ∈ s → w a * z a ≠ ⊤
⊢ ENNReal.toNNReal ((∑ i in s, w i * z i) ^ p) ≤ ENNReal.toNNReal (∑ i in s, w i * z i ^ p)
[PROOFSTEP]
have h_top_rpow : ∀ a : ι, a ∈ s → w a * z a ^ p ≠ ⊤ :=
by
intro i hi
specialize h_top i hi
rwa [Ne.def, ← h_top_iff_rpow_top i hi]
-- put the `.toNNReal` inside the sums.
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
h_top_rpow_sum : (∑ i in s, w i * z i) ^ p ≠ ⊤
a✝ : ∑ i in s, w i * z i ^ p ≠ ⊤
h_top : ∀ (a : ι), a ∈ s → w a * z a ≠ ⊤
⊢ ∀ (a : ι), a ∈ s → w a * z a ^ p ≠ ⊤
[PROOFSTEP]
intro i hi
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
h_top_rpow_sum : (∑ i in s, w i * z i) ^ p ≠ ⊤
a✝ : ∑ i in s, w i * z i ^ p ≠ ⊤
h_top : ∀ (a : ι), a ∈ s → w a * z a ≠ ⊤
i : ι
hi : i ∈ s
⊢ w i * z i ^ p ≠ ⊤
[PROOFSTEP]
specialize h_top i hi
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
h_top_rpow_sum : (∑ i in s, w i * z i) ^ p ≠ ⊤
a✝ : ∑ i in s, w i * z i ^ p ≠ ⊤
i : ι
hi : i ∈ s
h_top : w i * z i ≠ ⊤
⊢ w i * z i ^ p ≠ ⊤
[PROOFSTEP]
rwa [Ne.def, ← h_top_iff_rpow_top i hi]
-- put the `.toNNReal` inside the sums.
[GOAL]
case refine'_2
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
h_top_rpow_sum : (∑ i in s, w i * z i) ^ p ≠ ⊤
a✝ : ∑ i in s, w i * z i ^ p ≠ ⊤
h_top : ∀ (a : ι), a ∈ s → w a * z a ≠ ⊤
h_top_rpow : ∀ (a : ι), a ∈ s → w a * z a ^ p ≠ ⊤
⊢ ENNReal.toNNReal ((∑ i in s, w i * z i) ^ p) ≤ ENNReal.toNNReal (∑ i in s, w i * z i ^ p)
[PROOFSTEP]
simp_rw [toNNReal_sum h_top_rpow, ← toNNReal_rpow, toNNReal_sum h_top, toNNReal_mul, ← toNNReal_rpow]
-- use corresponding nnreal result
[GOAL]
case refine'_2
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
h_top_rpow_sum : (∑ i in s, w i * z i) ^ p ≠ ⊤
a✝ : ∑ i in s, w i * z i ^ p ≠ ⊤
h_top : ∀ (a : ι), a ∈ s → w a * z a ≠ ⊤
h_top_rpow : ∀ (a : ι), a ∈ s → w a * z a ^ p ≠ ⊤
⊢ (∑ x in s, ENNReal.toNNReal (w x) * ENNReal.toNNReal (z x)) ^ p ≤
∑ x in s, ENNReal.toNNReal (w x) * ENNReal.toNNReal (z x) ^ p
[PROOFSTEP]
refine' NNReal.rpow_arith_mean_le_arith_mean_rpow s (fun i => (w i).toNNReal) (fun i => (z i).toNNReal) _ hp
[GOAL]
case refine'_2
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
h_top_rpow_sum : (∑ i in s, w i * z i) ^ p ≠ ⊤
a✝ : ∑ i in s, w i * z i ^ p ≠ ⊤
h_top : ∀ (a : ι), a ∈ s → w a * z a ≠ ⊤
h_top_rpow : ∀ (a : ι), a ∈ s → w a * z a ^ p ≠ ⊤
⊢ ∑ i in s, (fun i => ENNReal.toNNReal (w i)) i = 1
[PROOFSTEP]
have h_sum_nnreal : ∑ i in s, w i = ↑(∑ i in s, (w i).toNNReal) :=
by
rw [coe_finset_sum]
refine' sum_congr rfl fun i hi => (coe_toNNReal _).symm
refine' (lt_top_of_sum_ne_top _ hi).ne
exact hw'.symm ▸ ENNReal.one_ne_top
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
h_top_rpow_sum : (∑ i in s, w i * z i) ^ p ≠ ⊤
a✝ : ∑ i in s, w i * z i ^ p ≠ ⊤
h_top : ∀ (a : ι), a ∈ s → w a * z a ≠ ⊤
h_top_rpow : ∀ (a : ι), a ∈ s → w a * z a ^ p ≠ ⊤
⊢ ∑ i in s, w i = ↑(∑ i in s, ENNReal.toNNReal (w i))
[PROOFSTEP]
rw [coe_finset_sum]
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
h_top_rpow_sum : (∑ i in s, w i * z i) ^ p ≠ ⊤
a✝ : ∑ i in s, w i * z i ^ p ≠ ⊤
h_top : ∀ (a : ι), a ∈ s → w a * z a ≠ ⊤
h_top_rpow : ∀ (a : ι), a ∈ s → w a * z a ^ p ≠ ⊤
⊢ ∑ i in s, w i = ∑ a in s, ↑(ENNReal.toNNReal (w a))
[PROOFSTEP]
refine' sum_congr rfl fun i hi => (coe_toNNReal _).symm
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
h_top_rpow_sum : (∑ i in s, w i * z i) ^ p ≠ ⊤
a✝ : ∑ i in s, w i * z i ^ p ≠ ⊤
h_top : ∀ (a : ι), a ∈ s → w a * z a ≠ ⊤
h_top_rpow : ∀ (a : ι), a ∈ s → w a * z a ^ p ≠ ⊤
i : ι
hi : i ∈ s
⊢ w i ≠ ⊤
[PROOFSTEP]
refine' (lt_top_of_sum_ne_top _ hi).ne
[GOAL]
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
h_top_rpow_sum : (∑ i in s, w i * z i) ^ p ≠ ⊤
a✝ : ∑ i in s, w i * z i ^ p ≠ ⊤
h_top : ∀ (a : ι), a ∈ s → w a * z a ≠ ⊤
h_top_rpow : ∀ (a : ι), a ∈ s → w a * z a ^ p ≠ ⊤
i : ι
hi : i ∈ s
⊢ ∑ x in s, w x ≠ ⊤
[PROOFSTEP]
exact hw'.symm ▸ ENNReal.one_ne_top
[GOAL]
case refine'_2
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤)
h_top_rpow_sum : (∑ i in s, w i * z i) ^ p ≠ ⊤
a✝ : ∑ i in s, w i * z i ^ p ≠ ⊤
h_top : ∀ (a : ι), a ∈ s → w a * z a ≠ ⊤
h_top_rpow : ∀ (a : ι), a ∈ s → w a * z a ^ p ≠ ⊤
h_sum_nnreal : ∑ i in s, w i = ↑(∑ i in s, ENNReal.toNNReal (w i))
⊢ ∑ i in s, (fun i => ENNReal.toNNReal (w i)) i = 1
[PROOFSTEP]
rwa [← coe_eq_coe, ← h_sum_nnreal]
[GOAL]
ι : Type u
s : Finset ι
w₁ w₂ z₁ z₂ : ℝ≥0∞
hw' : w₁ + w₂ = 1
p : ℝ
hp : 1 ≤ p
⊢ (w₁ * z₁ + w₂ * z₂) ^ p ≤ w₁ * z₁ ^ p + w₂ * z₂ ^ p
[PROOFSTEP]
have h := rpow_arith_mean_le_arith_mean_rpow univ ![w₁, w₂] ![z₁, z₂] ?_ hp
[GOAL]
case refine_2
ι : Type u
s : Finset ι
w₁ w₂ z₁ z₂ : ℝ≥0∞
hw' : w₁ + w₂ = 1
p : ℝ
hp : 1 ≤ p
h :
(∑ i : Fin (Nat.succ (Nat.succ 0)), Matrix.vecCons w₁ ![w₂] i * Matrix.vecCons z₁ ![z₂] i) ^ p ≤
∑ i : Fin (Nat.succ (Nat.succ 0)), Matrix.vecCons w₁ ![w₂] i * Matrix.vecCons z₁ ![z₂] i ^ p
⊢ (w₁ * z₁ + w₂ * z₂) ^ p ≤ w₁ * z₁ ^ p + w₂ * z₂ ^ p
[PROOFSTEP]
simpa [Fin.sum_univ_succ] using h
[GOAL]
case refine_1
ι : Type u
s : Finset ι
w₁ w₂ z₁ z₂ : ℝ≥0∞
hw' : w₁ + w₂ = 1
p : ℝ
hp : 1 ≤ p
⊢ ∑ i : Fin (Nat.succ (Nat.succ 0)), Matrix.vecCons w₁ ![w₂] i = 1
[PROOFSTEP]
simp [hw', Fin.sum_univ_succ]
[GOAL]
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
p : ℝ
hp : 1 ≤ p
⊢ (z₁ + z₂) ^ p ≤ 2 ^ (p - 1) * (z₁ ^ p + z₂ ^ p)
[PROOFSTEP]
rcases eq_or_lt_of_le hp with (rfl | h'p)
[GOAL]
case inl
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
hp : 1 ≤ 1
⊢ (z₁ + z₂) ^ 1 ≤ 2 ^ (1 - 1) * (z₁ ^ 1 + z₂ ^ 1)
[PROOFSTEP]
simp only [rpow_one, sub_self, rpow_zero, one_mul, le_refl]
[GOAL]
case inr
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
p : ℝ
hp : 1 ≤ p
h'p : 1 < p
⊢ (z₁ + z₂) ^ p ≤ 2 ^ (p - 1) * (z₁ ^ p + z₂ ^ p)
[PROOFSTEP]
convert rpow_arith_mean_le_arith_mean2_rpow (1 / 2) (1 / 2) (2 * z₁) (2 * z₂) (ENNReal.add_halves 1) hp using 1
[GOAL]
case h.e'_3
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
p : ℝ
hp : 1 ≤ p
h'p : 1 < p
⊢ (z₁ + z₂) ^ p = (1 / 2 * (2 * z₁) + 1 / 2 * (2 * z₂)) ^ p
[PROOFSTEP]
simp [← mul_assoc, ENNReal.inv_mul_cancel two_ne_zero two_ne_top]
[GOAL]
case h.e'_4
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
p : ℝ
hp : 1 ≤ p
h'p : 1 < p
⊢ 2 ^ (p - 1) * (z₁ ^ p + z₂ ^ p) = 1 / 2 * (2 * z₁) ^ p + 1 / 2 * (2 * z₂) ^ p
[PROOFSTEP]
have _ : p - 1 ≠ 0 := ne_of_gt (sub_pos.2 h'p)
[GOAL]
case h.e'_4
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
p : ℝ
hp : 1 ≤ p
h'p : 1 < p
x✝ : p - 1 ≠ 0
⊢ 2 ^ (p - 1) * (z₁ ^ p + z₂ ^ p) = 1 / 2 * (2 * z₁) ^ p + 1 / 2 * (2 * z₂) ^ p
[PROOFSTEP]
simp only [mul_rpow_of_nonneg _ _ (zero_le_one.trans hp), rpow_sub _ _ two_ne_zero two_ne_top, ENNReal.div_eq_inv_mul,
rpow_one, mul_one]
[GOAL]
case h.e'_4
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
p : ℝ
hp : 1 ≤ p
h'p : 1 < p
x✝ : p - 1 ≠ 0
⊢ 2⁻¹ * 2 ^ p * (z₁ ^ p + z₂ ^ p) = 2⁻¹ * (2 ^ p * z₁ ^ p) + 2⁻¹ * (2 ^ p * z₂ ^ p)
[PROOFSTEP]
ring
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp1 : 1 ≤ p
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
[PROOFSTEP]
have hp_pos : 0 < p := by positivity
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp1 : 1 ≤ p
⊢ 0 < p
[PROOFSTEP]
positivity
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp1 : 1 ≤ p
hp_pos : 0 < p
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
[PROOFSTEP]
by_cases h_top : a + b = ⊤
[GOAL]
case pos
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp1 : 1 ≤ p
hp_pos : 0 < p
h_top : a + b = ⊤
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
[PROOFSTEP]
rw [← @ENNReal.rpow_eq_top_iff_of_pos (a + b) p hp_pos] at h_top
[GOAL]
case pos
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp1 : 1 ≤ p
hp_pos : 0 < p
h_top : (a + b) ^ p = ⊤
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
[PROOFSTEP]
rw [h_top]
[GOAL]
case pos
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp1 : 1 ≤ p
hp_pos : 0 < p
h_top : (a + b) ^ p = ⊤
⊢ a ^ p + b ^ p ≤ ⊤
[PROOFSTEP]
exact le_top
[GOAL]
case neg
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp1 : 1 ≤ p
hp_pos : 0 < p
h_top : ¬a + b = ⊤
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
[PROOFSTEP]
obtain ⟨ha_top, hb_top⟩ := add_ne_top.mp h_top
[GOAL]
case neg.intro
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp1 : 1 ≤ p
hp_pos : 0 < p
h_top : ¬a + b = ⊤
ha_top : a ≠ ⊤
hb_top : b ≠ ⊤
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
[PROOFSTEP]
lift a to ℝ≥0 using ha_top
[GOAL]
case neg.intro.intro
ι : Type u
s : Finset ι
p : ℝ
b : ℝ≥0∞
hp1 : 1 ≤ p
hp_pos : 0 < p
hb_top : b ≠ ⊤
a : ℝ≥0
h_top : ¬↑a + b = ⊤
⊢ ↑a ^ p + b ^ p ≤ (↑a + b) ^ p
[PROOFSTEP]
lift b to ℝ≥0 using hb_top
[GOAL]
case neg.intro.intro.intro
ι : Type u
s : Finset ι
p : ℝ
hp1 : 1 ≤ p
hp_pos : 0 < p
a b : ℝ≥0
h_top : ¬↑a + ↑b = ⊤
⊢ ↑a ^ p + ↑b ^ p ≤ (↑a + ↑b) ^ p
[PROOFSTEP]
simpa [← ENNReal.coe_rpow_of_nonneg _ hp_pos.le] using ENNReal.coe_le_coe.2 (NNReal.add_rpow_le_rpow_add a b hp1)
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp1 : 1 ≤ p
⊢ (a ^ p + b ^ p) ^ (1 / p) ≤ a + b
[PROOFSTEP]
rw [← @ENNReal.le_rpow_one_div_iff _ _ (1 / p) (by simp [lt_of_lt_of_le zero_lt_one hp1])]
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp1 : 1 ≤ p
⊢ 0 < 1 / p
[PROOFSTEP]
simp [lt_of_lt_of_le zero_lt_one hp1]
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp1 : 1 ≤ p
⊢ a ^ p + b ^ p ≤ (a + b) ^ (1 / (1 / p))
[PROOFSTEP]
rw [one_div_one_div]
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp1 : 1 ≤ p
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
[PROOFSTEP]
exact add_rpow_le_rpow_add _ _ hp1
[GOAL]
ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0∞
hp_pos : 0 < p
hpq : p ≤ q
⊢ (a ^ q + b ^ q) ^ (1 / q) ≤ (a ^ p + b ^ p) ^ (1 / p)
[PROOFSTEP]
have h_rpow : ∀ a : ℝ≥0∞, a ^ q = (a ^ p) ^ (q / p) := fun a => by
rw [← ENNReal.rpow_mul, _root_.mul_div_cancel' _ hp_pos.ne']
[GOAL]
ι : Type u
s : Finset ι
p q : ℝ
a✝ b : ℝ≥0∞
hp_pos : 0 < p
hpq : p ≤ q
a : ℝ≥0∞
⊢ a ^ q = (a ^ p) ^ (q / p)
[PROOFSTEP]
rw [← ENNReal.rpow_mul, _root_.mul_div_cancel' _ hp_pos.ne']
[GOAL]
ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0∞
hp_pos : 0 < p
hpq : p ≤ q
h_rpow : ∀ (a : ℝ≥0∞), a ^ q = (a ^ p) ^ (q / p)
⊢ (a ^ q + b ^ q) ^ (1 / q) ≤ (a ^ p + b ^ p) ^ (1 / p)
[PROOFSTEP]
have h_rpow_add_rpow_le_add : ((a ^ p) ^ (q / p) + (b ^ p) ^ (q / p)) ^ (1 / (q / p)) ≤ a ^ p + b ^ p :=
by
refine' rpow_add_rpow_le_add (a ^ p) (b ^ p) _
rwa [one_le_div hp_pos]
[GOAL]
ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0∞
hp_pos : 0 < p
hpq : p ≤ q
h_rpow : ∀ (a : ℝ≥0∞), a ^ q = (a ^ p) ^ (q / p)
⊢ ((a ^ p) ^ (q / p) + (b ^ p) ^ (q / p)) ^ (1 / (q / p)) ≤ a ^ p + b ^ p
[PROOFSTEP]
refine' rpow_add_rpow_le_add (a ^ p) (b ^ p) _
[GOAL]
ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0∞
hp_pos : 0 < p
hpq : p ≤ q
h_rpow : ∀ (a : ℝ≥0∞), a ^ q = (a ^ p) ^ (q / p)
⊢ 1 ≤ q / p
[PROOFSTEP]
rwa [one_le_div hp_pos]
[GOAL]
ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0∞
hp_pos : 0 < p
hpq : p ≤ q
h_rpow : ∀ (a : ℝ≥0∞), a ^ q = (a ^ p) ^ (q / p)
h_rpow_add_rpow_le_add : ((a ^ p) ^ (q / p) + (b ^ p) ^ (q / p)) ^ (1 / (q / p)) ≤ a ^ p + b ^ p
⊢ (a ^ q + b ^ q) ^ (1 / q) ≤ (a ^ p + b ^ p) ^ (1 / p)
[PROOFSTEP]
rw [h_rpow a, h_rpow b, ENNReal.le_rpow_one_div_iff hp_pos, ← ENNReal.rpow_mul, mul_comm, mul_one_div]
[GOAL]
ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0∞
hp_pos : 0 < p
hpq : p ≤ q
h_rpow : ∀ (a : ℝ≥0∞), a ^ q = (a ^ p) ^ (q / p)
h_rpow_add_rpow_le_add : ((a ^ p) ^ (q / p) + (b ^ p) ^ (q / p)) ^ (1 / (q / p)) ≤ a ^ p + b ^ p
⊢ ((a ^ p) ^ (q / p) + (b ^ p) ^ (q / p)) ^ (p / q) ≤ a ^ p + b ^ p
[PROOFSTEP]
rwa [one_div_div] at h_rpow_add_rpow_le_add
[GOAL]
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp : 0 ≤ p
hp1 : p ≤ 1
⊢ (a + b) ^ p ≤ a ^ p + b ^ p
[PROOFSTEP]
rcases hp.eq_or_lt with (rfl | hp_pos)
[GOAL]
case inl
ι : Type u
s : Finset ι
a b : ℝ≥0∞
hp : 0 ≤ 0
hp1 : 0 ≤ 1
⊢ (a + b) ^ 0 ≤ a ^ 0 + b ^ 0
[PROOFSTEP]
simp
[GOAL]
case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
⊢ (a + b) ^ p ≤ a ^ p + b ^ p
[PROOFSTEP]
have h := rpow_add_rpow_le a b hp_pos hp1
[GOAL]
case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : (a ^ 1 + b ^ 1) ^ (1 / 1) ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p
[PROOFSTEP]
rw [one_div_one] at h
[GOAL]
case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : (a ^ 1 + b ^ 1) ^ 1 ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p
[PROOFSTEP]
repeat' rw [ENNReal.rpow_one] at h
[GOAL]
case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : (a ^ 1 + b ^ 1) ^ 1 ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p
[PROOFSTEP]
rw [ENNReal.rpow_one] at h
[GOAL]
case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : a ^ 1 + b ^ 1 ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p
[PROOFSTEP]
rw [ENNReal.rpow_one] at h
[GOAL]
case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : a + b ^ 1 ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p
[PROOFSTEP]
rw [ENNReal.rpow_one] at h
[GOAL]
case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : a + b ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p
[PROOFSTEP]
rw [ENNReal.rpow_one] at h
[GOAL]
case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : a + b ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p
[PROOFSTEP]
exact (ENNReal.le_rpow_one_div_iff hp_pos).mp h
|
" Fear of Flying " is the eleventh episode of The Simpsons ' sixth season . It was first broadcast on the Fox network in the United States on December 18 , 1994 . In the episode , Homer is banned from Moe 's Tavern and struggles to find a new bar . When he destroys a plane after being mistaken for a pilot at a pilots @-@ only bar , the airline buys the Simpsons ' silence with free tickets . The family discovers that Marge is afraid of flying .
|
[STATEMENT]
lemma MGFn_free_wt_da_NormalConformI:
"(\<forall> T L C B. \<lparr>prg=G,cls=C,lcl=L\<rparr>\<turnstile>t\<Colon>T
\<longrightarrow> G,(A::state triple set)
\<turnstile>{Normal((\<lambda>Y' s' s. s'=s \<and> normal s) \<and>. G\<turnstile>init\<le>n) \<and>. (\<lambda> s. s\<Colon>\<preceq>(G, L))
\<and>. (\<lambda> s. \<lparr>prg=G,cls=C,lcl=L\<rparr>\<turnstile>dom (locals (store s))\<guillemotright>t\<guillemotright>B)}
t\<succ>
{\<lambda>Y s' s. G\<turnstile>s \<midarrow>t\<succ>\<rightarrow> (Y,s')})
\<Longrightarrow> G,A\<turnstile>{=:n}t\<succ>{G\<rightarrow>}"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<forall>T L C B. \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile>t\<Colon>T \<longrightarrow> G,A\<turnstile>{Normal ((\<lambda>Y' s' s. s' = s \<and> normal s) \<and>. G\<turnstile>init\<le>n) \<and>. (\<lambda>s. s\<Colon>\<preceq>(G, L)) \<and>. (\<lambda>s. \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile> dom (locals (snd s)) \<guillemotright>t\<guillemotright> B)} t\<succ> {\<lambda>Y s' s. G\<turnstile>s \<midarrow>t\<succ>\<rightarrow> (Y, s')} \<Longrightarrow> G,A\<turnstile>{=:n} t\<succ> {G\<rightarrow>}
[PROOF STEP]
apply (rule MGFn_NormalI)
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<forall>T L C B. \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile>t\<Colon>T \<longrightarrow> G,A\<turnstile>{Normal ((\<lambda>Y' s' s. s' = s \<and> normal s) \<and>. G\<turnstile>init\<le>n) \<and>. (\<lambda>s. s\<Colon>\<preceq>(G, L)) \<and>. (\<lambda>s. \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile> dom (locals (snd s)) \<guillemotright>t\<guillemotright> B)} t\<succ> {\<lambda>Y s' s. G\<turnstile>s \<midarrow>t\<succ>\<rightarrow> (Y, s')} \<Longrightarrow> G,A\<turnstile>{Normal ((\<lambda>Y' s' s. s' = s \<and> normal s) \<and>. G\<turnstile>init\<le>n)} t\<succ> {\<lambda>Y s' s. G\<turnstile>s \<midarrow>t\<succ>\<rightarrow> (Y, s')}
[PROOF STEP]
apply (rule ax_no_hazard)
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<forall>T L C B. \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile>t\<Colon>T \<longrightarrow> G,A\<turnstile>{Normal ((\<lambda>Y' s' s. s' = s \<and> normal s) \<and>. G\<turnstile>init\<le>n) \<and>. (\<lambda>s. s\<Colon>\<preceq>(G, L)) \<and>. (\<lambda>s. \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile> dom (locals (snd s)) \<guillemotright>t\<guillemotright> B)} t\<succ> {\<lambda>Y s' s. G\<turnstile>s \<midarrow>t\<succ>\<rightarrow> (Y, s')} \<Longrightarrow> G,A\<turnstile>{Normal ((\<lambda>Y' s' s. s' = s \<and> normal s) \<and>. G\<turnstile>init\<le>n) \<and>. type_ok G t} t\<succ> {\<lambda>Y s' s. G\<turnstile>s \<midarrow>t\<succ>\<rightarrow> (Y, s')}
[PROOF STEP]
apply (rule ax_escape)
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<forall>T L C B. \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile>t\<Colon>T \<longrightarrow> G,A\<turnstile>{Normal ((\<lambda>Y' s' s. s' = s \<and> normal s) \<and>. G\<turnstile>init\<le>n) \<and>. (\<lambda>s. s\<Colon>\<preceq>(G, L)) \<and>. (\<lambda>s. \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile> dom (locals (snd s)) \<guillemotright>t\<guillemotright> B)} t\<succ> {\<lambda>Y s' s. G\<turnstile>s \<midarrow>t\<succ>\<rightarrow> (Y, s')} \<Longrightarrow> \<forall>Y s Z. (Normal ((\<lambda>Y' s' s. s' = s \<and> normal s) \<and>. G\<turnstile>init\<le>n) \<and>. type_ok G t) Y s Z \<longrightarrow> G,A\<turnstile>{\<lambda>Y' s' Z'. (Y', s') = (Y, s)} t\<succ> {\<lambda>Y s Z'. G\<turnstile>Z \<midarrow>t\<succ>\<rightarrow> (Y, s)}
[PROOF STEP]
apply (intro strip)
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<And>Y s Z. \<lbrakk>\<forall>T L C B. \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile>t\<Colon>T \<longrightarrow> G,A\<turnstile>{Normal ((\<lambda>Y' s' s. s' = s \<and> normal s) \<and>. G\<turnstile>init\<le>n) \<and>. (\<lambda>s. s\<Colon>\<preceq>(G, L)) \<and>. (\<lambda>s. \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile> dom (locals (snd s)) \<guillemotright>t\<guillemotright> B)} t\<succ> {\<lambda>Y s' s. G\<turnstile>s \<midarrow>t\<succ>\<rightarrow> (Y, s')}; (Normal ((\<lambda>Y' s' s. s' = s \<and> normal s) \<and>. G\<turnstile>init\<le>n) \<and>. type_ok G t) Y s Z\<rbrakk> \<Longrightarrow> G,A\<turnstile>{\<lambda>Y' s' Z'. (Y', s') = (Y, s)} t\<succ> {\<lambda>Y s Z'. G\<turnstile>Z \<midarrow>t\<succ>\<rightarrow> (Y, s)}
[PROOF STEP]
apply (simp only: type_ok_def peek_and_def)
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<And>Y s Z. \<lbrakk>\<forall>T L C B. \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile>t\<Colon>T \<longrightarrow> G,A\<turnstile>{\<lambda>Y s Z. ((((s = Z \<and> normal Z) \<and> (G\<turnstile>init\<le>n) s) \<and> normal s) \<and> s\<Colon>\<preceq>(G, L)) \<and> \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile> dom (locals (snd s)) \<guillemotright>t\<guillemotright> B} t\<succ> {\<lambda>Y s' s. G\<turnstile>s \<midarrow>t\<succ>\<rightarrow> (Y, s')}; (((s = Z \<and> normal Z) \<and> (G\<turnstile>init\<le>n) s) \<and> normal s) \<and> (\<exists>L T C A. (normal s \<longrightarrow> \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile>t\<Colon>T \<and> \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile> dom (locals (snd s)) \<guillemotright>t\<guillemotright> A) \<and> s\<Colon>\<preceq>(G, L))\<rbrakk> \<Longrightarrow> G,A\<turnstile>{\<lambda>Y' s' Z'. (Y', s') = (Y, Z)} t\<succ> {\<lambda>Y s Z'. G\<turnstile>Z \<midarrow>t\<succ>\<rightarrow> (Y, s)}
[PROOF STEP]
apply (erule conjE)+
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<And>Y s Z. \<lbrakk>\<forall>T L C B. \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile>t\<Colon>T \<longrightarrow> G,A\<turnstile>{\<lambda>Y s Z. ((((s = Z \<and> normal Z) \<and> (G\<turnstile>init\<le>n) s) \<and> normal s) \<and> s\<Colon>\<preceq>(G, L)) \<and> \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile> dom (locals (snd s)) \<guillemotright>t\<guillemotright> B} t\<succ> {\<lambda>Y s' s. G\<turnstile>s \<midarrow>t\<succ>\<rightarrow> (Y, s')}; \<exists>L T C A. (normal s \<longrightarrow> \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile>t\<Colon>T \<and> \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile> dom (locals (snd s)) \<guillemotright>t\<guillemotright> A) \<and> s\<Colon>\<preceq>(G, L); normal s; (G\<turnstile>init\<le>n) s; s = Z; normal Z\<rbrakk> \<Longrightarrow> G,A\<turnstile>{\<lambda>Y' s' Z'. (Y', s') = (Y, Z)} t\<succ> {\<lambda>Y s Z'. G\<turnstile>Z \<midarrow>t\<succ>\<rightarrow> (Y, s)}
[PROOF STEP]
apply (erule exE,erule exE, erule exE, erule exE,erule conjE,drule (1) mp,
erule conjE)
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<And>Y s Z L T C Aa. \<lbrakk>\<forall>T L C B. \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile>t\<Colon>T \<longrightarrow> G,A\<turnstile>{\<lambda>Y s Z. ((((s = Z \<and> normal Z) \<and> (G\<turnstile>init\<le>n) s) \<and> normal s) \<and> s\<Colon>\<preceq>(G, L)) \<and> \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile> dom (locals (snd s)) \<guillemotright>t\<guillemotright> B} t\<succ> {\<lambda>Y s' s. G\<turnstile>s \<midarrow>t\<succ>\<rightarrow> (Y, s')}; normal s; (G\<turnstile>init\<le>n) s; s = Z; normal Z; s\<Colon>\<preceq>(G, L); \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile>t\<Colon>T; \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile> dom (locals (snd s)) \<guillemotright>t\<guillemotright> Aa\<rbrakk> \<Longrightarrow> G,A\<turnstile>{\<lambda>Y' s' Z'. (Y', s') = (Y, Z)} t\<succ> {\<lambda>Y s Z'. G\<turnstile>Z \<midarrow>t\<succ>\<rightarrow> (Y, s)}
[PROOF STEP]
apply (drule spec,drule spec, drule spec,drule spec, drule (1) mp)
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<And>Y s Z L T C Aa. \<lbrakk>normal s; (G\<turnstile>init\<le>n) s; s = Z; normal Z; s\<Colon>\<preceq>(G, L); \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile>t\<Colon>T; \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile> dom (locals (snd s)) \<guillemotright>t\<guillemotright> Aa; G,A\<turnstile>{\<lambda>Ya sa Za. ((((sa = Za \<and> normal Za) \<and> (G\<turnstile>init\<le>n) sa) \<and> normal sa) \<and> sa\<Colon>\<preceq>(G, L)) \<and> \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile> dom (locals (snd sa)) \<guillemotright>t\<guillemotright> ?B39 Y s Z L T C Aa} t\<succ> {\<lambda>Y s' s. G\<turnstile>s \<midarrow>t\<succ>\<rightarrow> (Y, s')}\<rbrakk> \<Longrightarrow> G,A\<turnstile>{\<lambda>Y' s' Z'. (Y', s') = (Y, Z)} t\<succ> {\<lambda>Y s Z'. G\<turnstile>Z \<midarrow>t\<succ>\<rightarrow> (Y, s)}
[PROOF STEP]
apply (erule conseq12)
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<And>Y s Z L T C A. \<lbrakk>normal s; (G\<turnstile>init\<le>n) s; s = Z; normal Z; s\<Colon>\<preceq>(G, L); \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile>t\<Colon>T; \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile> dom (locals (snd s)) \<guillemotright>t\<guillemotright> A\<rbrakk> \<Longrightarrow> \<forall>Ya sa Za. (Ya, sa) = (Y, Z) \<longrightarrow> (\<forall>Y' s'. (\<forall>Ya Z'. ((((sa = Z' \<and> normal Z') \<and> (G\<turnstile>init\<le>n) sa) \<and> normal sa) \<and> sa\<Colon>\<preceq>(G, L)) \<and> \<lparr>prg = G, cls = C, lcl = L\<rparr>\<turnstile> dom (locals (snd sa)) \<guillemotright>t\<guillemotright> ?B39 Y s Z L T C A \<longrightarrow> G\<turnstile>Z' \<midarrow>t\<succ>\<rightarrow> (Y', s')) \<longrightarrow> G\<turnstile>Z \<midarrow>t\<succ>\<rightarrow> (Y', s'))
[PROOF STEP]
apply blast
[PROOF STATE]
proof (prove)
goal:
No subgoals!
[PROOF STEP]
done |
# Copyright (C) 2004-2017 by
# Aric Hagberg <[email protected]>
# Dan Schult <[email protected]>
# Pieter Swart <[email protected]>
# All rights reserved.
# BSD license.
#
# Author: Aric Hagberg ([email protected])
"""
**********
Matplotlib
**********
Draw networks with matplotlib.
See Also
--------
matplotlib: http://matplotlib.org/
pygraphviz: http://pygraphviz.github.io/
"""
import networkx as nx
from networkx.utils import is_string_like
from networkx.drawing.layout import shell_layout, \
circular_layout, kamada_kawai_layout, spectral_layout, \
spring_layout, random_layout
__all__ = ['draw',
'draw_networkx',
'draw_networkx_nodes',
'draw_networkx_edges',
'draw_networkx_labels',
'draw_networkx_edge_labels',
'draw_circular',
'draw_kamada_kawai',
'draw_random',
'draw_spectral',
'draw_spring',
'draw_shell']
def draw(G, pos=None, ax=None, **kwds):
"""Draw the graph G with Matplotlib.
Draw the graph as a simple representation with no node
labels or edge labels and using the full Matplotlib figure area
and no axis labels by default. See draw_networkx() for more
full-featured drawing that allows title, axis labels etc.
Parameters
----------
G : graph
A networkx graph
pos : dictionary, optional
A dictionary with nodes as keys and positions as values.
If not specified a spring layout positioning will be computed.
See :py:mod:`networkx.drawing.layout` for functions that
compute node positions.
ax : Matplotlib Axes object, optional
Draw the graph in specified Matplotlib axes.
kwds : optional keywords
See networkx.draw_networkx() for a description of optional keywords.
Examples
--------
>>> G = nx.dodecahedral_graph()
>>> nx.draw(G)
>>> nx.draw(G, pos=nx.spring_layout(G)) # use spring layout
See Also
--------
draw_networkx()
draw_networkx_nodes()
draw_networkx_edges()
draw_networkx_labels()
draw_networkx_edge_labels()
Notes
-----
This function has the same name as pylab.draw and pyplot.draw
so beware when using
>>> from networkx import *
since you might overwrite the pylab.draw function.
With pyplot use
>>> import matplotlib.pyplot as plt
>>> import networkx as nx
>>> G = nx.dodecahedral_graph()
>>> nx.draw(G) # networkx draw()
>>> plt.draw() # pyplot draw()
Also see the NetworkX drawing examples at
https://networkx.github.io/documentation/latest/auto_examples/index.html
"""
try:
import matplotlib.pyplot as plt
except ImportError:
raise ImportError("Matplotlib required for draw()")
except RuntimeError:
print("Matplotlib unable to open display")
raise
if ax is None:
cf = plt.gcf()
else:
cf = ax.get_figure()
cf.set_facecolor('w')
if ax is None:
if cf._axstack() is None:
ax = cf.add_axes((0, 0, 1, 1))
else:
ax = cf.gca()
if 'with_labels' not in kwds:
kwds['with_labels'] = 'labels' in kwds
try:
draw_networkx(G, pos=pos, ax=ax, **kwds)
ax.set_axis_off()
plt.draw_if_interactive()
except:
raise
return
def draw_networkx(G, pos=None, arrows=True, with_labels=True, **kwds):
"""Draw the graph G using Matplotlib.
Draw the graph with Matplotlib with options for node positions,
labeling, titles, and many other drawing features.
See draw() for simple drawing without labels or axes.
Parameters
----------
G : graph
A networkx graph
pos : dictionary, optional
A dictionary with nodes as keys and positions as values.
If not specified a spring layout positioning will be computed.
See :py:mod:`networkx.drawing.layout` for functions that
compute node positions.
arrows : bool, optional (default=True)
For directed graphs, if True draw arrowheads.
with_labels : bool, optional (default=True)
Set to True to draw labels on the nodes.
ax : Matplotlib Axes object, optional
Draw the graph in the specified Matplotlib axes.
nodelist : list, optional (default G.nodes())
Draw only specified nodes
edgelist : list, optional (default=G.edges())
Draw only specified edges
node_size : scalar or array, optional (default=300)
Size of nodes. If an array is specified it must be the
same length as nodelist.
node_color : color string, or array of floats, (default='r')
Node color. Can be a single color format string,
or a sequence of colors with the same length as nodelist.
If numeric values are specified they will be mapped to
colors using the cmap and vmin,vmax parameters. See
matplotlib.scatter for more details.
node_shape : string, optional (default='o')
The shape of the node. Specification is as matplotlib.scatter
marker, one of 'so^>v<dph8'.
alpha : float, optional (default=1.0)
The node and edge transparency
cmap : Matplotlib colormap, optional (default=None)
Colormap for mapping intensities of nodes
vmin,vmax : float, optional (default=None)
Minimum and maximum for node colormap scaling
linewidths : [None | scalar | sequence]
Line width of symbol border (default =1.0)
width : float, optional (default=1.0)
Line width of edges
edge_color : color string, or array of floats (default='r')
Edge color. Can be a single color format string,
or a sequence of colors with the same length as edgelist.
If numeric values are specified they will be mapped to
colors using the edge_cmap and edge_vmin,edge_vmax parameters.
edge_cmap : Matplotlib colormap, optional (default=None)
Colormap for mapping intensities of edges
edge_vmin,edge_vmax : floats, optional (default=None)
Minimum and maximum for edge colormap scaling
style : string, optional (default='solid')
Edge line style (solid|dashed|dotted,dashdot)
labels : dictionary, optional (default=None)
Node labels in a dictionary keyed by node of text labels
font_size : int, optional (default=12)
Font size for text labels
font_color : string, optional (default='k' black)
Font color string
font_weight : string, optional (default='normal')
Font weight
font_family : string, optional (default='sans-serif')
Font family
label : string, optional
Label for graph legend
Notes
-----
For directed graphs, "arrows" (actually just thicker stubs) are drawn
at the head end. Arrows can be turned off with keyword arrows=False.
Yes, it is ugly but drawing proper arrows with Matplotlib this
way is tricky.
Examples
--------
>>> G = nx.dodecahedral_graph()
>>> nx.draw(G)
>>> nx.draw(G, pos=nx.spring_layout(G)) # use spring layout
>>> import matplotlib.pyplot as plt
>>> limits = plt.axis('off') # turn of axis
Also see the NetworkX drawing examples at
https://networkx.github.io/documentation/latest/auto_examples/index.html
See Also
--------
draw()
draw_networkx_nodes()
draw_networkx_edges()
draw_networkx_labels()
draw_networkx_edge_labels()
"""
try:
import matplotlib.pyplot as plt
except ImportError:
raise ImportError("Matplotlib required for draw()")
except RuntimeError:
print("Matplotlib unable to open display")
raise
if pos is None:
pos = nx.drawing.spring_layout(G) # default to spring layout
node_collection = draw_networkx_nodes(G, pos, **kwds)
edge_collection = draw_networkx_edges(G, pos, arrows=arrows, **kwds)
if with_labels:
draw_networkx_labels(G, pos, **kwds)
plt.draw_if_interactive()
def draw_networkx_nodes(G, pos,
nodelist=None,
node_size=300,
node_color='r',
node_shape='o',
alpha=1.0,
cmap=None,
vmin=None,
vmax=None,
ax=None,
linewidths=None,
label=None,
**kwds):
"""Draw the nodes of the graph G.
This draws only the nodes of the graph G.
Parameters
----------
G : graph
A networkx graph
pos : dictionary
A dictionary with nodes as keys and positions as values.
Positions should be sequences of length 2.
ax : Matplotlib Axes object, optional
Draw the graph in the specified Matplotlib axes.
nodelist : list, optional
Draw only specified nodes (default G.nodes())
node_size : scalar or array
Size of nodes (default=300). If an array is specified it must be the
same length as nodelist.
node_color : color string, or array of floats
Node color. Can be a single color format string (default='r'),
or a sequence of colors with the same length as nodelist.
If numeric values are specified they will be mapped to
colors using the cmap and vmin,vmax parameters. See
matplotlib.scatter for more details.
node_shape : string
The shape of the node. Specification is as matplotlib.scatter
marker, one of 'so^>v<dph8' (default='o').
alpha : float or array of floats
The node transparency. This can be a single alpha value (default=1.0),
in which case it will be applied to all the nodes of color. Otherwise,
if it is an array, the elements of alpha will be applied to the colors
in order (cycling through alpha multiple times if necessary).
cmap : Matplotlib colormap
Colormap for mapping intensities of nodes (default=None)
vmin,vmax : floats
Minimum and maximum for node colormap scaling (default=None)
linewidths : [None | scalar | sequence]
Line width of symbol border (default =1.0)
label : [None| string]
Label for legend
Returns
-------
matplotlib.collections.PathCollection
`PathCollection` of the nodes.
Examples
--------
>>> G = nx.dodecahedral_graph()
>>> nodes = nx.draw_networkx_nodes(G, pos=nx.spring_layout(G))
Also see the NetworkX drawing examples at
https://networkx.github.io/documentation/latest/auto_examples/index.html
See Also
--------
draw()
draw_networkx()
draw_networkx_edges()
draw_networkx_labels()
draw_networkx_edge_labels()
"""
import collections
try:
import matplotlib.pyplot as plt
import numpy as np
except ImportError:
raise ImportError("Matplotlib required for draw()")
except RuntimeError:
print("Matplotlib unable to open display")
raise
if ax is None:
ax = plt.gca()
if nodelist is None:
nodelist = list(G)
if not nodelist or len(nodelist) == 0: # empty nodelist, no drawing
return None
try:
xy = np.asarray([pos[v] for v in nodelist])
except KeyError as e:
raise nx.NetworkXError('Node %s has no position.' % e)
except ValueError:
raise nx.NetworkXError('Bad value in node positions.')
if isinstance(alpha, collections.Iterable):
node_color = apply_alpha(node_color, alpha, nodelist, cmap, vmin, vmax)
alpha = None
node_collection = ax.scatter(xy[:, 0], xy[:, 1],
s=node_size,
c=node_color,
marker=node_shape,
cmap=cmap,
vmin=vmin,
vmax=vmax,
alpha=alpha,
linewidths=linewidths,
label=label)
node_collection.set_zorder(2)
return node_collection
def draw_networkx_edges(G, pos,
edgelist=None,
width=1.0,
edge_color='k',
style='solid',
alpha=1.0,
edge_cmap=None,
edge_vmin=None,
edge_vmax=None,
ax=None,
arrows=True,
label=None,
**kwds):
"""Draw the edges of the graph G.
This draws only the edges of the graph G.
Parameters
----------
G : graph
A networkx graph
pos : dictionary
A dictionary with nodes as keys and positions as values.
Positions should be sequences of length 2.
edgelist : collection of edge tuples
Draw only specified edges(default=G.edges())
width : float, or array of floats
Line width of edges (default=1.0)
edge_color : color string, or array of floats
Edge color. Can be a single color format string (default='r'),
or a sequence of colors with the same length as edgelist.
If numeric values are specified they will be mapped to
colors using the edge_cmap and edge_vmin,edge_vmax parameters.
style : string
Edge line style (default='solid') (solid|dashed|dotted,dashdot)
alpha : float
The edge transparency (default=1.0)
edge_ cmap : Matplotlib colormap
Colormap for mapping intensities of edges (default=None)
edge_vmin,edge_vmax : floats
Minimum and maximum for edge colormap scaling (default=None)
ax : Matplotlib Axes object, optional
Draw the graph in the specified Matplotlib axes.
arrows : bool, optional (default=True)
For directed graphs, if True draw arrowheads.
label : [None| string]
Label for legend
Returns
-------
matplotlib.collection.LineCollection
`LineCollection` of the edges
Notes
-----
For directed graphs, "arrows" (actually just thicker stubs) are drawn
at the head end. Arrows can be turned off with keyword arrows=False.
Yes, it is ugly but drawing proper arrows with Matplotlib this
way is tricky.
Examples
--------
>>> G = nx.dodecahedral_graph()
>>> edges = nx.draw_networkx_edges(G, pos=nx.spring_layout(G))
Also see the NetworkX drawing examples at
https://networkx.github.io/documentation/latest/auto_examples/index.html
See Also
--------
draw()
draw_networkx()
draw_networkx_nodes()
draw_networkx_labels()
draw_networkx_edge_labels()
"""
try:
import matplotlib
import matplotlib.pyplot as plt
import matplotlib.cbook as cb
from matplotlib.colors import colorConverter, Colormap
from matplotlib.collections import LineCollection
import numpy as np
except ImportError:
raise ImportError("Matplotlib required for draw()")
except RuntimeError:
print("Matplotlib unable to open display")
raise
if ax is None:
ax = plt.gca()
if edgelist is None:
edgelist = list(G.edges())
if not edgelist or len(edgelist) == 0: # no edges!
return None
# set edge positions
edge_pos = np.asarray([(pos[e[0]], pos[e[1]]) for e in edgelist])
if not cb.iterable(width):
lw = (width,)
else:
lw = width
if not is_string_like(edge_color) \
and cb.iterable(edge_color) \
and len(edge_color) == len(edge_pos):
if np.alltrue([is_string_like(c) for c in edge_color]):
# (should check ALL elements)
# list of color letters such as ['k','r','k',...]
edge_colors = tuple([colorConverter.to_rgba(c, alpha)
for c in edge_color])
elif np.alltrue([not is_string_like(c) for c in edge_color]):
# If color specs are given as (rgb) or (rgba) tuples, we're OK
if np.alltrue([cb.iterable(c) and len(c) in (3, 4)
for c in edge_color]):
edge_colors = tuple(edge_color)
else:
# numbers (which are going to be mapped with a colormap)
edge_colors = None
else:
raise ValueError('edge_color must consist of either color names or numbers')
else:
if is_string_like(edge_color) or len(edge_color) == 1:
edge_colors = (colorConverter.to_rgba(edge_color, alpha), )
else:
raise ValueError(
'edge_color must be a single color or list of exactly m colors where m is the number or edges')
edge_collection = LineCollection(edge_pos,
colors=edge_colors,
linewidths=lw,
antialiaseds=(1,),
linestyle=style,
transOffset=ax.transData,
)
edge_collection.set_zorder(1) # edges go behind nodes
edge_collection.set_label(label)
ax.add_collection(edge_collection)
# Note: there was a bug in mpl regarding the handling of alpha values for
# each line in a LineCollection. It was fixed in matplotlib in r7184 and
# r7189 (June 6 2009). We should then not set the alpha value globally,
# since the user can instead provide per-edge alphas now. Only set it
# globally if provided as a scalar.
if cb.is_numlike(alpha):
edge_collection.set_alpha(alpha)
if edge_colors is None:
if edge_cmap is not None:
assert(isinstance(edge_cmap, Colormap))
edge_collection.set_array(np.asarray(edge_color))
edge_collection.set_cmap(edge_cmap)
if edge_vmin is not None or edge_vmax is not None:
edge_collection.set_clim(edge_vmin, edge_vmax)
else:
edge_collection.autoscale()
arrow_collection = None
if G.is_directed() and arrows:
# a directed graph hack
# draw thick line segments at head end of edge
# waiting for someone else to implement arrows that will work
arrow_colors = edge_colors
a_pos = []
p = 1.0 - 0.25 # make head segment 25 percent of edge length
for src, dst in edge_pos:
x1, y1 = src
x2, y2 = dst
dx = x2 - x1 # x offset
dy = y2 - y1 # y offset
d = np.sqrt(float(dx**2 + dy**2)) # length of edge
if d == 0: # source and target at same position
continue
if dx == 0: # vertical edge
xa = x2
ya = dy * p + y1
if dy == 0: # horizontal edge
ya = y2
xa = dx * p + x1
else:
theta = np.arctan2(dy, dx)
xa = p * d * np.cos(theta) + x1
ya = p * d * np.sin(theta) + y1
a_pos.append(((xa, ya), (x2, y2)))
arrow_collection = LineCollection(a_pos,
colors=arrow_colors,
linewidths=[4 * ww for ww in lw],
antialiaseds=(1,),
transOffset=ax.transData,
)
arrow_collection.set_zorder(1) # edges go behind nodes
ax.add_collection(arrow_collection)
# update view
minx = np.amin(np.ravel(edge_pos[:, :, 0]))
maxx = np.amax(np.ravel(edge_pos[:, :, 0]))
miny = np.amin(np.ravel(edge_pos[:, :, 1]))
maxy = np.amax(np.ravel(edge_pos[:, :, 1]))
w = maxx - minx
h = maxy - miny
padx, pady = 0.05 * w, 0.05 * h
corners = (minx - padx, miny - pady), (maxx + padx, maxy + pady)
ax.update_datalim(corners)
ax.autoscale_view()
# if arrow_collection:
return edge_collection
def draw_networkx_labels(G, pos,
labels=None,
font_size=12,
font_color='k',
font_family='sans-serif',
font_weight='normal',
alpha=1.0,
bbox=None,
ax=None,
**kwds):
"""Draw node labels on the graph G.
Parameters
----------
G : graph
A networkx graph
pos : dictionary
A dictionary with nodes as keys and positions as values.
Positions should be sequences of length 2.
labels : dictionary, optional (default=None)
Node labels in a dictionary keyed by node of text labels
font_size : int
Font size for text labels (default=12)
font_color : string
Font color string (default='k' black)
font_family : string
Font family (default='sans-serif')
font_weight : string
Font weight (default='normal')
alpha : float
The text transparency (default=1.0)
ax : Matplotlib Axes object, optional
Draw the graph in the specified Matplotlib axes.
Returns
-------
dict
`dict` of labels keyed on the nodes
Examples
--------
>>> G = nx.dodecahedral_graph()
>>> labels = nx.draw_networkx_labels(G, pos=nx.spring_layout(G))
Also see the NetworkX drawing examples at
https://networkx.github.io/documentation/latest/auto_examples/index.html
See Also
--------
draw()
draw_networkx()
draw_networkx_nodes()
draw_networkx_edges()
draw_networkx_edge_labels()
"""
try:
import matplotlib.pyplot as plt
import matplotlib.cbook as cb
except ImportError:
raise ImportError("Matplotlib required for draw()")
except RuntimeError:
print("Matplotlib unable to open display")
raise
if ax is None:
ax = plt.gca()
if labels is None:
labels = dict((n, n) for n in G.nodes())
# set optional alignment
horizontalalignment = kwds.get('horizontalalignment', 'center')
verticalalignment = kwds.get('verticalalignment', 'center')
text_items = {} # there is no text collection so we'll fake one
for n, label in labels.items():
(x, y) = pos[n]
if not is_string_like(label):
label = str(label) # this will cause "1" and 1 to be labeled the same
t = ax.text(x, y,
label,
size=font_size,
color=font_color,
family=font_family,
weight=font_weight,
alpha=alpha,
horizontalalignment=horizontalalignment,
verticalalignment=verticalalignment,
transform=ax.transData,
bbox=bbox,
clip_on=True,
)
text_items[n] = t
return text_items
def draw_networkx_edge_labels(G, pos,
edge_labels=None,
label_pos=0.5,
font_size=10,
font_color='k',
font_family='sans-serif',
font_weight='normal',
alpha=1.0,
bbox=None,
ax=None,
rotate=True,
**kwds):
"""Draw edge labels.
Parameters
----------
G : graph
A networkx graph
pos : dictionary
A dictionary with nodes as keys and positions as values.
Positions should be sequences of length 2.
ax : Matplotlib Axes object, optional
Draw the graph in the specified Matplotlib axes.
alpha : float
The text transparency (default=1.0)
edge_labels : dictionary
Edge labels in a dictionary keyed by edge two-tuple of text
labels (default=None). Only labels for the keys in the dictionary
are drawn.
label_pos : float
Position of edge label along edge (0=head, 0.5=center, 1=tail)
font_size : int
Font size for text labels (default=12)
font_color : string
Font color string (default='k' black)
font_weight : string
Font weight (default='normal')
font_family : string
Font family (default='sans-serif')
bbox : Matplotlib bbox
Specify text box shape and colors.
clip_on : bool
Turn on clipping at axis boundaries (default=True)
Returns
-------
dict
`dict` of labels keyed on the edges
Examples
--------
>>> G = nx.dodecahedral_graph()
>>> edge_labels = nx.draw_networkx_edge_labels(G, pos=nx.spring_layout(G))
Also see the NetworkX drawing examples at
https://networkx.github.io/documentation/latest/auto_examples/index.html
See Also
--------
draw()
draw_networkx()
draw_networkx_nodes()
draw_networkx_edges()
draw_networkx_labels()
"""
try:
import matplotlib.pyplot as plt
import matplotlib.cbook as cb
import numpy as np
except ImportError:
raise ImportError("Matplotlib required for draw()")
except RuntimeError:
print("Matplotlib unable to open display")
raise
if ax is None:
ax = plt.gca()
if edge_labels is None:
labels = {(u, v): d for u, v, d in G.edges(data=True)}
else:
labels = edge_labels
text_items = {}
for (n1, n2), label in labels.items():
(x1, y1) = pos[n1]
(x2, y2) = pos[n2]
(x, y) = (x1 * label_pos + x2 * (1.0 - label_pos),
y1 * label_pos + y2 * (1.0 - label_pos))
if rotate:
angle = np.arctan2(y2 - y1, x2 - x1) / (2.0 * np.pi) * 360 # degrees
# make label orientation "right-side-up"
if angle > 90:
angle -= 180
if angle < - 90:
angle += 180
# transform data coordinate angle to screen coordinate angle
xy = np.array((x, y))
trans_angle = ax.transData.transform_angles(np.array((angle,)),
xy.reshape((1, 2)))[0]
else:
trans_angle = 0.0
# use default box of white with white border
if bbox is None:
bbox = dict(boxstyle='round',
ec=(1.0, 1.0, 1.0),
fc=(1.0, 1.0, 1.0),
)
if not is_string_like(label):
label = str(label) # this will cause "1" and 1 to be labeled the same
# set optional alignment
horizontalalignment = kwds.get('horizontalalignment', 'center')
verticalalignment = kwds.get('verticalalignment', 'center')
t = ax.text(x, y,
label,
size=font_size,
color=font_color,
family=font_family,
weight=font_weight,
alpha=alpha,
horizontalalignment=horizontalalignment,
verticalalignment=verticalalignment,
rotation=trans_angle,
transform=ax.transData,
bbox=bbox,
zorder=1,
clip_on=True,
)
text_items[(n1, n2)] = t
return text_items
def draw_circular(G, **kwargs):
"""Draw the graph G with a circular layout.
Parameters
----------
G : graph
A networkx graph
kwargs : optional keywords
See networkx.draw_networkx() for a description of optional keywords,
with the exception of the pos parameter which is not used by this
function.
"""
draw(G, circular_layout(G), **kwargs)
def draw_kamada_kawai(G, **kwargs):
"""Draw the graph G with a Kamada-Kawai force-directed layout.
Parameters
----------
G : graph
A networkx graph
kwargs : optional keywords
See networkx.draw_networkx() for a description of optional keywords,
with the exception of the pos parameter which is not used by this
function.
"""
draw(G, kamada_kawai_layout(G), **kwargs)
def draw_random(G, **kwargs):
"""Draw the graph G with a random layout.
Parameters
----------
G : graph
A networkx graph
kwargs : optional keywords
See networkx.draw_networkx() for a description of optional keywords,
with the exception of the pos parameter which is not used by this
function.
"""
draw(G, random_layout(G), **kwargs)
def draw_spectral(G, **kwargs):
"""Draw the graph G with a spectral layout.
Parameters
----------
G : graph
A networkx graph
kwargs : optional keywords
See networkx.draw_networkx() for a description of optional keywords,
with the exception of the pos parameter which is not used by this
function.
"""
draw(G, spectral_layout(G), **kwargs)
def draw_spring(G, **kwargs):
"""Draw the graph G with a spring layout.
Parameters
----------
G : graph
A networkx graph
kwargs : optional keywords
See networkx.draw_networkx() for a description of optional keywords,
with the exception of the pos parameter which is not used by this
function.
"""
draw(G, spring_layout(G), **kwargs)
def draw_shell(G, **kwargs):
"""Draw networkx graph with shell layout.
Parameters
----------
G : graph
A networkx graph
kwargs : optional keywords
See networkx.draw_networkx() for a description of optional keywords,
with the exception of the pos parameter which is not used by this
function.
"""
nlist = kwargs.get('nlist', None)
if nlist is not None:
del(kwargs['nlist'])
draw(G, shell_layout(G, nlist=nlist), **kwargs)
def apply_alpha(colors, alpha, elem_list, cmap=None, vmin=None, vmax=None):
"""Apply an alpha (or list of alphas) to the colors provided.
Parameters
----------
colors : color string, or array of floats
Color of element. Can be a single color format string (default='r'),
or a sequence of colors with the same length as nodelist.
If numeric values are specified they will be mapped to
colors using the cmap and vmin,vmax parameters. See
matplotlib.scatter for more details.
alpha : float or array of floats
Alpha values for elements. This can be a single alpha value, in
which case it will be applied to all the elements of color. Otherwise,
if it is an array, the elements of alpha will be applied to the colors
in order (cycling through alpha multiple times if necessary).
elem_list : array of networkx objects
The list of elements which are being colored. These could be nodes, edges
or labels.
cmap : matplotlib colormap
Color map for use if colors is a list of floats corresponding to points on
a color mapping.
vmin, vmax : float
Minimum and maximum values for normalizing colors if a color mapping is used.
Returns
-------
rgba_colors : numpy ndarray
Array containing RGBA format values for each of the node colours.
"""
import numbers
import itertools
try:
import numpy as np
from matplotlib.colors import colorConverter
import matplotlib.cm as cm
except ImportError:
raise ImportError("Matplotlib required for draw()")
# If we have been provided with a list of numbers as long as elem_list, apply the color mapping.
if len(colors) == len(elem_list) and isinstance(colors[0], numbers.Number):
mapper = cm.ScalarMappable(cmap=cmap)
mapper.set_clim(vmin, vmax)
rgba_colors = mapper.to_rgba(colors)
# Otherwise, convert colors to matplotlib's RGB using the colorConverter object.
# These are converted to numpy ndarrays to be consistent with the to_rgba method of ScalarMappable.
else:
try:
rgba_colors = np.array([colorConverter.to_rgba(colors)])
except ValueError:
rgba_colors = np.array([colorConverter.to_rgba(color) for color in colors])
# Set the final column of the rgba_colors to have the relevant alpha values.
try:
# If alpha is longer than the number of colors, resize to the number of elements.
# Also, if rgba_colors.size (the number of elements of rgba_colors) is the same as the number of
# elements, resize the array, to avoid it being interpreted as a colormap by scatter()
if len(alpha) > len(rgba_colors) or rgba_colors.size == len(elem_list):
rgba_colors.resize((len(elem_list), 4))
rgba_colors[1:, 0] = rgba_colors[0, 0]
rgba_colors[1:, 1] = rgba_colors[0, 1]
rgba_colors[1:, 2] = rgba_colors[0, 2]
rgba_colors[:, 3] = list(itertools.islice(itertools.cycle(alpha), len(rgba_colors)))
except TypeError:
rgba_colors[:, -1] = alpha
return rgba_colors
# fixture for nose tests
def setup_module(module):
from nose import SkipTest
try:
import matplotlib as mpl
mpl.use('PS', warn=False)
import matplotlib.pyplot as plt
except:
raise SkipTest("matplotlib not available")
|
Formal statement is: lemma eventually_nhds_uniformity: "eventually P (nhds x) \<longleftrightarrow> eventually (\<lambda>(x', y). x' = x \<longrightarrow> P y) uniformity" (is "_ \<longleftrightarrow> ?N P x") Informal statement is: For any point $x$ and any property $P$, the following are equivalent: $P$ holds for all points $y$ sufficiently close to $x$. For all $\epsilon > 0$, there exists $\delta > 0$ such that if $d(x, x') < \delta$, then $d(y, y') < \epsilon$ implies $P(y')$. |
module Examples.Auction
import Data.Vect
import Data.Vect.Quantifiers
import DepSec.Labeled
import DepSec.DIO
import DepSec.Declassification
import Examples.TwoPointLattice
%default total
%access export
--------------------------------------------------------------------------------
--- Auction Hatch Example
--------------------------------------------------------------------------------
Bid : Type
Bid = (String, Nat)
BidLog : Nat -> Type
BidLog n = Vect n (Labeled H Bid)
data MaxL : Bid -> Labeled H Bid -> Type where
IsMaxL : (b1 : Bid)
-> (b2 : Labeled H Bid)
-> (b : Bid ** (maximum (snd b1) (snd b) = (snd b1), label b = b2))
-> MaxL b1 b2
data MaxBid : Bid -> BidLog n -> Type where
IsMax : (bid : Bid)
-> (bids : BidLog n)
-> All (\b => MaxL bid b) bids
-> MaxBid bid bids
HighestBid : BidLog _ -> Bid -> Type
HighestBid = \rec, b => (Elem (label b) rec, MaxBid b rec)
HighestBidHatch : BidLog _ -> Type
HighestBidHatch rec = Labeled H (b : Bid ** HighestBid rec b) -> Labeled L Bid
HatchPair : Nat -> Type
HatchPair n = (rec : BidLog n ** Labeled H (b : Bid ** HighestBid rec b) -> Labeled L Bid)
aHatchPair : HatchPair 2
aHatchPair =
let rec : BidLog 2 = [(label ("Alice", 1337)), (label ("Bob", 1336))]
in predicateHatch rec HighestBid
printBid : Labeled L Bid -> DIO L ()
printBid (MkLabeled (n, b)) = lift $ putStrLn n
--------------------------------------------------------------------------------
-- UTCB
--------------------------------------------------------------------------------
-- Lemmas
--------------------------------------------------------------------------------
maximum_trans : maximum a c = a -> maximum b a = b -> maximum b c = b
maximum_trans {a} {b} {c} prf prf1 =
rewrite sym prf1 in
rewrite sym $ maximumAssociative b a c in
rewrite sym prf in Refl
maximum_inj : (maximum (S a) (S b) = (S a) -> Void) -> (maximum a b = a -> Void)
maximum_inj {a} {b} f prf =
void $ f (rewrite prf in Refl)
maximum_l_void : (maximum a b = a -> Void) -> maximum a b = b
maximum_l_void {a = Z} {b = b} f = Refl
maximum_l_void {a = (S k)} {b = Z} f = void $ f Refl
maximum_l_void {a = (S k)} {b = (S j)} f =
let ihPrf = maximum_inj {a = k} {b = j} f
ih : (maximum k j = j) = maximum_l_void ihPrf
in rewrite ih in Refl
all_max_ext : {b1, b2 : Bid}
-> All (\b => MaxL b2 b) bs
-> maximum (snd b1) (snd b2) = (snd b1)
-> All (\b => MaxL b1 b) bs
all_max_ext [] prf = []
all_max_ext {bs = x :: _} {b1} (y :: z) prf =
let (IsMaxL _ x (c ** (d, e))) = y
in (IsMaxL b1 x (c ** (maximum_trans d prf, e))) :: all_max_ext z prf
maxBid_ext : {b1, b2 : Bid}
-> maximum (snd b1) (snd b2) = (snd b1)
-> MaxBid b2 bs
-> MaxBid b1 ((label b1) :: bs)
maxBid_ext {b1} {b2} {bs} maxPrf maxbid =
let (IsMax _ _ maxbidAll) = maxbid
headPrf = IsMaxL b1 (label b1) (b1 ** (maximumIdempotent (snd b1), Refl))
tailPrf = all_max_ext maxbidAll maxPrf
in IsMax b1 ((label b1) :: bs) (headPrf :: tailPrf)
--------------------------------------------------------------------------------
auction : HatchPair n -> DIO L (Labeled L Bid)
auction ([] ** _) = pure $ label ("no bid", 0)
auction (r :: rs ** hatch) =
do max <- plug $ getMaxBid (r :: rs)
let max' : Labeled L Bid = hatch max
printBid max'
pure max'
where
getMaxBid : (r : BidLog (S n))
-> DIO H (b : Bid ** HighestBid r b)
getMaxBid (x :: []) =
do (x' ** prfx) <- unlabel' x
let elemPrf : Elem (label x') [x] = rewrite prfx in Here
let maxlemma = (x' ** (maximumIdempotent (snd x'), prfx))
let maxPrf : MaxBid x' [x] = IsMax x' [x] ((IsMaxL x' x maxlemma) :: Nil)
pure (x' ** (elemPrf, maxPrf))
getMaxBid (x :: y :: zs) =
do (x' ** prfx) <- unlabel' x
(tail' ** (prftailElem, prftailMax)) <- getMaxBid (y :: zs)
let (IsMax _ _ tailprfAll) = prftailMax
case decEq (maximum (snd x') (snd tail')) (snd x') of
Yes prf => pure (x' ** (rewrite prfx in Here, rewrite sym prfx in maxBid_ext prf prftailMax))
No cont => pure (tail' ** (There prftailElem, IsMax tail' (x :: y :: zs)
((IsMaxL tail' x (x' ** (
rewrite maximumCommutative (snd tail') (snd x') in maximum_l_void {b=(snd tail')} cont, prfx))) :: tailprfAll)))
--------------------------------------------------------------------------------
-- TCB
--------------------------------------------------------------------------------
main : IO ()
main =
do putStrLn "##### Welcome to the auction! #####"
putStrLn "Announcing winner: "
max <- run $ auction aHatchPair
putStrLn "##### Bye bye! #####"
pure ()
|
[STATEMENT]
lemma embed_bool_bounded[simp,intro]:
"bounded \<guillemotleft>P\<guillemotright>"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. Expectations.bounded \<guillemotleft> P \<guillemotright>
[PROOF STEP]
by (blast) |
In the second book of the Harry Potter Series, “The Chamber of Secrets” by J.K. Rowling, Harry Potter finds out that he can communicate with snakes using the Parseltongue language.
In this challenge we will write a Python script to translate English to Parseltongue and vice-versa.
To encode a message into Parseltongue you need to insert the string sequence “sss” between each character of your message. e.g.
I can speak to snakes using Parseltongue.
To decode a message from Parseltongue remove the “sss” character sequences by only keeping 1 character out of 4 from the encoded message.
Check the following code, which uses two subroutines (functions) called encode() and decode() to encode a message in Parseltongue or decode a message from Parseltongue. Both functions use a technique called string concatenation to add one letter at a time to the message or cypher being generated.
Did you know? Encoding and decoding secret messages is a key application of Computer Science called cryptography. An encoded message is called a cipher.
As a wizard at Hogwarts school of witchcraft and wizardry, Harry Potter often needs to decipher secret messages. In this set of challenges you will write Python subroutines to encode or decode secret messages using a range of techniques.
The Parseltongue coding technique described above is not very secure. It would be easy for anyone to look at a cipher text and to be able to find a way to decipher it without being told how to in the first instance.
To make this encryption technique more secure we will adapt the encode() function implemented in the trinket above. Instead of adding the string “sss” after each character we will add three random letters.
By completing this challenge, we are going to learn how to use ASCII code when manipulating strings.
You will use the chr() and ord() python instructions to convert characters into ASCII code and vice versa.
print(chr(97)) would display the letter “a” on screen as 97 is the ASCII code for character “a”.
print(ord(“a”)) would display the 97 on screen as 97 is the ASCII code for character “a”.
Use this code to tweak the the encode() function. The decode() function should not need to be updated and should still work with this new encryption technique.
Test your code. Do you find the cipher text to be more secure?
Using this encryption techniques the cipher message is based on the actual message with the letters of the message appearing in reverse order. e.g.
Using this encryption technique, the same function can be used to both encode and decode a message.
Your task is to implement one function used to encode/decode a message, applying the “Reversi formula”.
Create two new functions to encode and decode two messages at the same time by intertwining each letter of these messages. Your encode() function will take two parameters, message1 and message2, and generate a cipher by intertwining each letter of both messages, one letter at a time.
In cryptography, a Caesar cipher, also known as shift cipher, is one of the simplest and most widely known encryption techniques. It is a type of substitution cipher in which each letter in the message to encrypt is replaced by a letter some fixed number of positions down the alphabet.
You will find out more about this technique by following this link.
Can you think of any other approach you could use to encrypt a message? You may combine several of the techniques listed above, as combining several techniques will make your cipher more difficult to decode hence it will be a lot more secure! |
theory StreamExample
imports Main "$HIPSTER_HOME/IsaHipster"
begin
(* Set Hipster tactic*)
setup Tactic_Data.set_coinduct_sledgehammer
codatatype (sset: 'a) Stream =
SCons (shd: 'a) (stl: "'a Stream")
primcorec smap :: "('a \<Rightarrow> 'b) \<Rightarrow> 'a Stream \<Rightarrow> 'b Stream" where
"smap f xs = SCons (f (shd xs)) (smap f (stl xs))"
(* Call Hipster for coinductive theory exploration *)
(*cohipster smap*)
lemma lemma_a [thy_expl]: "SCons (y z) (smap y x2) = smap y (SCons z x2)"
by(coinduction arbitrary: x2 y z rule: Stream.coinduct_strong)
simp
(*cohipster smap Fun.id*)
lemma lemma_aa [thy_expl]: "smap id y = y"
by(coinduction arbitrary: y rule: Stream.coinduct_strong)
simp
(*cohipster smap Fun.comp*)
lemma lemma_ab [thy_expl]: "smap (y \<circ> z) x2 = smap y (smap z x2)"
by(coinduction arbitrary: x2 y z rule: Stream.coinduct_strong)
auto
primcorec siterate :: "('a \<Rightarrow> 'a) \<Rightarrow> 'a \<Rightarrow> 'a Stream" where
"siterate f a = SCons a (siterate f (f a))"
(*cohipster smap siterate*)
lemma lemma_ac [thy_expl]: "smap y (siterate y z) = siterate y (y z)"
by(coinduction arbitrary: y z rule: Stream.coinduct_strong)
auto
lemma lemma_ad [thy_expl]: "smap z (SCons y (siterate z x2)) = SCons (z y) (siterate z (z x2))"
by(coinduction arbitrary: x2 y z rule: Stream.coinduct_strong)
(simp add: lemma_ac)
end |
[STATEMENT]
lemma index_oddpart_decomposition:
"n = 2 ^ (index n) * oddpart n"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. n = 2 ^ index n * oddpart n
[PROOF STEP]
proof (induct n rule: index.induct)
[PROOF STATE]
proof (state)
goal (2 subgoals):
1. 0 = 2 ^ index 0 * oddpart 0
2. \<And>v. (\<not> odd (Suc v) \<Longrightarrow> Suc v div 2 = 2 ^ index (Suc v div 2) * oddpart (Suc v div 2)) \<Longrightarrow> Suc v = 2 ^ index (Suc v) * oddpart (Suc v)
[PROOF STEP]
case (2 n)
[PROOF STATE]
proof (state)
this:
\<not> odd (Suc n) \<Longrightarrow> Suc n div 2 = 2 ^ index (Suc n div 2) * oddpart (Suc n div 2)
goal (2 subgoals):
1. 0 = 2 ^ index 0 * oddpart 0
2. \<And>v. (\<not> odd (Suc v) \<Longrightarrow> Suc v div 2 = 2 ^ index (Suc v div 2) * oddpart (Suc v div 2)) \<Longrightarrow> Suc v = 2 ^ index (Suc v) * oddpart (Suc v)
[PROOF STEP]
from this
[PROOF STATE]
proof (chain)
picking this:
\<not> odd (Suc n) \<Longrightarrow> Suc n div 2 = 2 ^ index (Suc n div 2) * oddpart (Suc n div 2)
[PROOF STEP]
show "Suc n = 2 ^ index (Suc n) * oddpart (Suc n)"
[PROOF STATE]
proof (prove)
using this:
\<not> odd (Suc n) \<Longrightarrow> Suc n div 2 = 2 ^ index (Suc n div 2) * oddpart (Suc n div 2)
goal (1 subgoal):
1. Suc n = 2 ^ index (Suc n) * oddpart (Suc n)
[PROOF STEP]
by (simp add: mult.assoc)
[PROOF STATE]
proof (state)
this:
Suc n = 2 ^ index (Suc n) * oddpart (Suc n)
goal (1 subgoal):
1. 0 = 2 ^ index 0 * oddpart 0
[PROOF STEP]
qed (simp) |
/-
Copyright (c) 2021 OpenAI. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Kunhao Zheng, Stanislas Polu, David Renshaw, OpenAI GPT-f
-/
import mathzoo.imports.miniF2F
open_locale nat rat real big_operators topological_space
theorem algebra_sqineq_36azm9asqle36zsq
(z a : ℝ) :
36 * (a * z) - 9 * a^2 ≤ 36 * z^2 :=
begin
suffices : 4 * (a * z) - a^2 ≤ 4 * z^2, nlinarith,
suffices : 0 ≤ (a - 2 * z)^2, nlinarith,
exact pow_two_nonneg (a - 2 * z),
end |
State Before: α : Type u_1
β : Type ?u.11936
γ : Type ?u.11939
ι : Type ?u.11942
ι' : Type ?u.11945
r p q : α → α → Prop
f g : ι → α
s t u : Set α
a b : α
hr : Symmetric r
ha : ¬a ∈ s
⊢ Set.Pairwise (insert a s) r ↔ Set.Pairwise s r ∧ ∀ (b : α), b ∈ s → r a b State After: no goals Tactic: simp only [pairwise_insert_of_not_mem ha, hr.iff a, and_self_iff] |
# =============================================================
# MODULE: plots
# =============================================================
module plots
using PGFPlots
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# FUNCTION : TERNARY
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
function TERNARY(Path, Sand, Silt, Clay)
# Work in progress labels not sure
Plot_SandSiltClay=TernaryAxis(Plots.Linear3(Sand,Silt,Clay,style="solid, blue, thick", onlyMarks=true),
style="ternary limits relative=false",
xlabel=L"Silt", ylabel=L"Clay", zlabel=L"Sand")
save(Path, Plot_SandSiltClay)
# label=L"Sand %", ylabel=L"Silt %", zlabel=L"Clay%"
end # function TERNARY
end # module plots
# ............................................................ |
import gym
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from model import *
from history import History
from visualize import *
algo_name = 'A2C'
max_steps = 100000
num_steps = 128
gamma = .9
learn_rate = 1e-3
env = gym.make('CartPole-v1')
history = History()
actor = Actor(env)
opt_A = torch.optim.Adam(actor.parameters(), lr=learn_rate)
critic = Critic(env)
opt_C = torch.optim.Adam(critic.parameters(), lr=learn_rate)
def train():
steps = 0
s = env.reset()
ep = 0
while steps < max_steps:
n_s = 0
ep_r = 0
#Collecting trajectories
while n_s < num_steps:
a = actor(s)
s2, r, done, _ = env.step(a)
history.store(s, a, r, done)
ep_r += r
if done:
update_viz(ep, ep_r, algo_name)
ep += 1
s = env.reset()
else:
s = s2
n_s += 1
steps += 1
#----------#
# Update #
#----------#
states, actions, rewards, dones = history.get_history()
#Calculate the returns and normalize them
discount = 0
returns = [0] * len(rewards)
for i in reversed(range(len(rewards))):
if dones[i]:
returns[i] = rewards[i]
else:
returns[i] = rewards[i] + discount
discount = returns[i]*gamma
returns = torch.FloatTensor(returns)
#------Policy Loss and Update------#
#Get advantage
advantage = returns.unsqueeze(1) - critic(states)
mean = advantage.mean()
std = advantage.std() + 1e-6
advantage = (advantage - mean)/std
logp = actor.get_log_p(states, actions)
policy_loss = (-(logp.unsqueeze(1) * advantage)).mean()
opt_A.zero_grad()
policy_loss.backward()
opt_A.step()
#------Value Function loss and update------#
# print(returns.shape)
# quit(critic(states).shape)
v = F.mse_loss(returns.unsqueeze_(1), critic(states))
opt_C.zero_grad()
v.backward()
opt_C.step()
history.clear()
train()
|
function rtk=udtrop_rtkins(rtk,tt,bl) %#ok
global glc
INIT_ZWD=0.15; VAR_GRA=0.001^2;
for i=1:2
if i==1,j=rtk.itr+1;else,j=rtk.itb+1;end
if rtk.x(j)==0
rtk=initx(rtk,INIT_ZWD,rtk.opt.std(3)^2,j);
if rtk.opt.tropopt==glc.TROPOPT_ESTG
for k=1:2
rtk=initx(rtk,1e-6,VAR_GRA,j+k);
end
end
else
rtk.P(j,j)=rtk.P(j,j)+rtk.opt.prn(3)^2*abs(tt);
if rtk.opt.tropopt==glc.TROPOPT_ESTG
for k=1:2
rtk.P(j+k,j+k)=rtk.P(j+k,j+k)+(rtk.opt.prn(3)*0.3)^2*abs(tt);
end
end
end
end
return
|
# A little library for the generation and attribute checking of
# matrix of integers
# author : Etienne THIERY
from numpy import *
def symmetricPositiveDefinite(n, maxValue= 1):
''' Generates a n x n random symmetric, positive-definite matrix.
The optionnal maxValue argument can be used to specify a maximum
absolute value for extradiagonal coefficients.
Diagonal coefficient will be inferior to 22 times maxValue in
absolute value.
Runs in O(n^2)'''
# To generate such a matrix we use the fact that a symmetric
# diagonnaly dominant matrix is symmetric positive definite
# We first generate a random matrix
# with coefficients between -maxValue and +maxValue
A = random.random_integers(-maxValue, maxValue, (n, n))
# Then by adding to this matrix its transpose, we obtain
# a symmetric matrix
A = A + A.transpose()
# Finally we make sure it is strictly diagonnaly dominant by
# adding 2*n*maxValue times the identity matrix
A += 2*n*maxValue*eye(n)
return A
def symmetricSparsePositiveDefinite(n, nbZeros, maxValue= 1):
''' Generates a n x n random symmetric, positive-definite matrix.
with around nbZeros null coefficients (more precisely nbZeros+-1)
nbZeros must be between 0 and n*(n-1)
The optionnal maxValue argument can be used to specify a maximum
absolute value for extradiagonal coefficients.
Diagonal coefficient will be inferior to 11 times maxValue in
absolute value.
Runs in O(n^2)'''
# The algorithm is the same as in symmetricPositiveDefinite
# except that the matrix generated in the beginning is
# sparse symmetric
A = zeros((n,n))
currentNbZeros = n*(n-1)
while currentNbZeros > nbZeros:
i, j = random.randint(n, size=2)
if i != j and A[i,j] == 0:
while A[i,j] == 0:
A[i,j] = A[j,i] = random.randint(-maxValue, maxValue+1)
currentNbZeros -= 2
# Then we make sure it is strictly diagonnaly dominant by
# adding n*maxValue times the identity matrix
A += n*maxValue*eye(n)
return A
def isSymmetric(M):
''' Returns true if and only if M is symmetric'''
return array_equal(M, M.transpose())
def isDefinitePositive(M):
''' Returns true if and only if M is definite positive'''
# using the fact that if all its eigenvalues are positive,
# M is definite positive
# be careful, as eigvals use numerical methods, some eigenvalues
# which are in reality equal to zero can be found negative
eps = 1e-5
for ev in linalg.eigvals(M):
if ev <= 0-eps:
return False
return True
|
# This file is a part of JuliaFEM.
# License is MIT: see https://github.com/JuliaFEM/JuliaFEM.jl/blob/master/LICENSE.md
using JuliaFEM
using JuliaFEM.Testing
@testset "geometry missing" begin
el = Element(Quad4, [1, 2, 3, 4])
pr = Problem(Elasticity, "problem", 2)
# this throws KeyError: geometry not found.
# it's descriptive enough to give hint to user
# what went wrong
@test_throws KeyError assemble!(pr, el)
end
@testset "connectivity information missing" begin
el = Element(Quad4)
nodes = Vector{Float64}[[0,0],[1,0],[1,1],[0,1]]
update!(el, "geometry", nodes)
pr = Problem(Elasticity, "problem", 2)
@test_throws Exception assemble!(pr, el)
end
|
Formal statement is: lemma cball_eq_empty [simp]: "cball x e = {} \<longleftrightarrow> e < 0" Informal statement is: The closed ball of radius $e$ around $x$ is empty if and only if $e < 0$. |
import .basic group_theory.submonoid.operations
variables {ι : Type*} {M : ι → Type*}
variables [decidable_eq ι] [Π i, decidable_eq (M i)]
variables [Π i, monoid (M i)]
open coprod submonoid function
lemma mul_aux_mem (S : Π i, submonoid (M i)) : ∀ (l₁ l₂ : list (Σ i, M i))
(h₁ : ∀ a : Σ i, M i, a ∈ l₁ → a.2 ∈ S a.1)
(h₂ : ∀ a : Σ i, M i, a ∈ l₂ → a.2 ∈ S a.1)
{i : ι} {a : M i} (ha : (⟨i, a⟩ : Σ i, M i) ∈ pre.mul_aux l₁ l₂),
a ∈ S i
| [] l₂ := by simp [pre.mul_aux]
| (⟨j, b⟩::l₁) [] := begin
assume h₁ _ i a ha,
simp only [pre.mul_aux, list.mem_reverse, list.mem_cons_iff] at ha,
rcases ha with ⟨rfl, hab⟩ | hia,
{ rw [heq_iff_eq] at hab,
subst hab,
exact h₁ ⟨i, a⟩ (list.mem_cons_self _ _) },
{ exact h₁ ⟨i, a⟩ (list.mem_cons_of_mem _ hia) }
end
| (⟨j, b⟩::l₁) (⟨k, c⟩::l₂) := begin
assume h₁ h₂ i a ha,
simp only [pre.mul_aux] at ha,
split_ifs at ha,
{ exact mul_aux_mem _ _
(λ d hd, h₁ d (list.mem_cons_of_mem _ hd))
(λ d hd, h₂ d (list.mem_cons_of_mem _ hd))
ha },
{ dsimp at h,
subst j,
simp only [list.reverse_core_eq, list.mem_append, list.mem_cons_iff,
list.mem_reverse, cast_eq] at ha,
simp only [cast_eq] at *,
rcases ha with ha | ⟨rfl, h, h⟩ | ha,
{ exact h₁ ⟨i, a⟩ (list.mem_cons_of_mem _ ha) },
{ exact submonoid.mul_mem _
(h₁ ⟨i, b⟩ (list.mem_cons_self _ _))
(h₂ ⟨i, c⟩ (list.mem_cons_self _ _)) },
{ exact h₂ ⟨i, a⟩ (list.mem_cons_of_mem _ ha) } },
{ clear_aux_decl,
simp only [list.reverse_core_eq, list.mem_append, list.mem_cons_iff,
list.mem_reverse] at ha,
rcases ha with ha | ⟨rfl, hab⟩ | ⟨rfl, hab⟩ | ha,
{ exact h₁ ⟨i, a⟩ (list.mem_cons_of_mem _ ha) },
{ rw [heq_iff_eq] at hab,
subst hab,
exact h₁ ⟨i, a⟩ (list.mem_cons_self _ _) },
{ rw [heq_iff_eq] at hab,
subst hab,
exact h₂ ⟨i, a⟩ (list.mem_cons_self _ _) },
{ exact h₂ ⟨i, a⟩ (list.mem_cons_of_mem _ ha) } }
end
def blah (S : Π i, submonoid (M i)) : submonoid (coprod M) :=
{ carrier := { w : coprod M | ∀ (a : Σ i, M i), a ∈ w.to_list → a.2 ∈ S a.1 },
one_mem' := λ a h, h.elim,
mul_mem' := begin
rintros ⟨l₁, hl₁⟩ ⟨l₂, hl₂⟩ h₁ h₂ ⟨i, a⟩ h,
exact mul_aux_mem S l₁.reverse l₂ (by simpa using h₁) (by simpa using h₂) h
end }
lemma mem_blah (S : Π i, submonoid (M i)) (w : coprod M) :
w ∈ blah S ↔ ∀ (a : Σ i, M i), a ∈ w.to_list → a.2 ∈ S a.1 := iff.rfl
variable {S : Π i, submonoid (M i)}
@[simp] lemma of_mem_blah_iff {i : ι} {a : M i} : of i a ∈ blah S ↔ a ∈ S i :=
begin
simp only [mem_blah, to_list_of],
split_ifs,
{ simp [*, submonoid.one_mem] },
{ simp only [list.mem_singleton],
split,
{ exact λ h, h ⟨i, a⟩ rfl },
{ assume ha j hj,
subst j,
exact ha } }
end
lemma blah_eq_supr : blah S = ⨆ i, (S i).map (of i) :=
le_antisymm
(λ w hw, begin
cases w with l hl,
induction l with i l ih,
{ simp [submonoid.one_mem] },
{ rw [cons_eq_of_mul],
refine submonoid.mul_mem _ _ _,
{ exact le_supr (λ i, (S i).map (of i)) i.1
(mem_map.2 ⟨i.2, hw _ (list.mem_cons_self _ _), rfl⟩) },
{ exact ih _ (λ j hj, hw _ (list.mem_cons_of_mem _ hj)) } }
end)
(supr_le (λ i a ha, begin
rw [mem_map] at ha,
rcases ha with ⟨a, ha, rfl⟩,
simp only [to_list_of, mem_blah],
split_ifs,
{ simp },
{ simp only [list.mem_singleton],
assume a ha,
subst a,
exact ha }
end))
|
Boots are what put Astars on the map. Stomp! This Fall they have expanded their family.
The Alpinestars Tech 3 aren't new, but the gnarly graffiti graphics are! These boots that are designed for off-road enduro riders and ATV folk who need all-terrain soles and high impact protection. The Tech 3 are value packed with leather uppers, high-grip double density compound rubber outsoles, and a contoured steel shank over-injected inside the assembly insole. The buckles are made from a techno-polymer and are highly impact resistant so they don't break on you mid-ride. An extended gaiter prevents water from entering the boot and the anatomic footbed is removable. This new graphic is available in 2 colors: green, blue and solid white.
Ultra-lightweight, the Alpinestars Montreal Shoes take design inspiration from Alpinestars Formula 1 driving shoes. Internally, a toe box and heel counter are built into the shoe to provide a solid form.
The Alpinestars Classic Casual Shoe is a lifestyle sneaker that is lightweight, breathable, and made of suede upper with vulcanized soles. The inner liner is a breathable mesh with a soft heel counter. |
data MyNat
= S (Inf MyNat)
| Z
%builtin Natural MyNat
|
module Isumi.Math.FFT.Image
( fftWithImage
) where
import Codec.Picture (Image, Pixel8)
import Data.Complex
import Isumi.Math.FFT.Bruun (fft2dBruun)
import Isumi.Math.MatrixUtil (imageToMatrix)
import Numeric.LinearAlgebra (Matrix)
fftWithImage :: Image Pixel8 -> Maybe (Matrix (Complex Double))
fftWithImage = fft2dBruun . imageToMatrix
|
import combinatorics.simple_graph.coloring
--OUTPUT 1
theorem bipartite_iff_two_colorable {V : Type*} (G : simple_graph V) [fintype V] : (G.colorable 2) ↔ (∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B)) :=
begin
split,
{ assume h1 : G.colorable 2,
obtain ⟨f, hf⟩ := h1,
have h2 : ∀ v, f v = 0 ∨ f v = 1, from assume v, by {
have h3 : f v < 2, from by {
apply nat.lt_of_le_of_ne,
apply nat.le_of_lt_succ,
exact hf v,
exact nat.succ_ne_self (f v)
},
have h4 : f v = 0 ∨ f v = 1, from nat.eq_zero_or_eq_one_of_lt h3,
exact h4,
},
let A : Type* := {v : V | f v = 0},
let B : Type* := {v : V | f v = 1},
have h3 : (A ⊕ B) = V, from by {
ext,
split,
{ assume h4 : (A ⊕ B),
cases h4,
{ exact h2 _, },
{ exact h2 _, },
},
{ assume h4,
cases h4,
{ cases h2 _,
{ exact or.inl rfl, },
{ exfalso,
apply nat.succ_ne_zero,
rw h at h_1,
exact h_1,
}
},
{ cases h2 _,
{ exfalso,
apply nat.succ_ne_zero,
rw h at h_1,
exact h_1,
},
{ exact or.inr rfl, }
}
}
},
use A,
use B,
use h3,
show G ≤ cast (congr_arg _ h3) (complete_bipartite_graph A B), from by {
apply subgraph.subset,
assume x y h5,
cases h5,
{ cases h2 x,
{ cases h2 y,
{ exact or.inl rfl, },
{ exfalso,
apply nat.succ_ne_zero,
rw h at h_1,
exact h_1,
}
},
{ exfalso,
apply nat.succ_ne_zero,
rw h at h_1,
exact h_1,
}
},
{ cases h2 x,
{ exfalso,
apply nat.succ_ne_zero,
rw h at h_1,
exact h_1,
},
{ cases h2 y,
{ exfalso,
apply nat.succ_ne_zero,
rw h at h_1,
exact h_1,
},
{ exact or.inr rfl, }
}
}
}
},
{ assume h1 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B),
obtain ⟨A, B, h2, h3⟩ := h1,
have h4 : (A ⊕ B) = V, from h2,
let f : V → ℕ := λ v, if v ∈ A then 0 else 1,
have h5 : ∀ v, f v < 2, from assume v, by {
cases h4.symm ▸ v,
{ exact nat.lt_succ_self 0, },
{ exact nat.lt_succ_self 0, }
},
have h6 : ∀ x y, (f x = f y) → (x, y) ∈ G, from assume x y h7, by {
cases h4.symm ▸ x,
{ cases h4.symm ▸ y,
{ exact h3.left.left h7, },
{ exfalso,
apply nat.succ_ne_zero,
rw h7 at h_1,
exact h_1,
}
},
{ cases h4.symm ▸ y,
{ exfalso,
apply nat.succ_ne_zero,
rw h7 at h_1,
exact h_1,
},
{ exact h3.left.right h7, }
}
},
use f,
show ∀ v, f v < 2, from h5,
}
end
--OUTPUT 2
theorem bipartite_iff_two_colorable {V : Type*} (G : simple_graph V) [fintype V] : (G.colorable 2) ↔ (∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B)) :=
begin
split,
{
assume h : G.colorable 2,
have h1 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from
begin
use (λ v, v.1),
use (λ v, v.2),
use (equiv.sum_congr_right (λ v, v.1) (λ v, v.2)),
show G ≤ cast (congr_arg _ (equiv.sum_congr_right (λ v, v.1) (λ v, v.2))) (complete_bipartite_graph (λ v, v.1) (λ v, v.2)), from
begin
have h2 : ∀ (v w : V), (v.1 = w.1 ∨ v.1 = w.2 ∨ v.2 = w.1 ∨ v.2 = w.2) → (v, w) ∈ G → (v.1, w.1) ∈ complete_bipartite_graph (λ v, v.1) (λ v, v.2) ∨ (v.1, w.2) ∈ complete_bipartite_graph (λ v, v.1) (λ v, v.2) ∨ (v.2, w.1) ∈ complete_bipartite_graph (λ v, v.1) (λ v, v.2) ∨ (v.2, w.2) ∈ complete_bipartite_graph (λ v, v.1) (λ v, v.2), from
begin
assume v w : V,
assume h3 : (v.1 = w.1 ∨ v.1 = w.2 ∨ v.2 = w.1 ∨ v.2 = w.2),
assume h4 : (v, w) ∈ G,
have h5 : (v.1, w.1) ∈ complete_bipartite_graph (λ v, v.1) (λ v, v.2) ∨ (v.1, w.2) ∈ complete_bipartite_graph (λ v, v.1) (λ v, v.2) ∨ (v.2, w.1) ∈ complete_bipartite_graph (λ v, v.1) (λ v, v.2) ∨ (v.2, w.2) ∈ complete_bipartite_graph (λ v, v.1) (λ v, v.2), from
begin
cases h3,
{
by_cases h6 : v.1 = w.1,
{
rw h6,
apply or.inl,
exact complete_bipartite_graph.mem_edge,
},
{
have h7 : (v.1, w.1) ∈ complete_bipartite_graph (λ v, v.1) (λ v, v.2), from
begin
apply or.inl,
exact complete_bipartite_graph.mem_edge,
end,
have h8 : (v.1, w.1) ∈ G, from
begin
have h9 : (v, w) ∈ G, from h4,
have h10 : (v.1, w.1) ∈ G, from
begin
have h11 : (v.1, w.1) ∈ G, from
begin
have h12 : (v.1, w.1) ∈ G, from
begin
have h13 : (v.1, w.1) ∈ G, from
begin
have h14 : (v.1, w.1) ∈ G, from
begin
have h15 : (v.1, w.1) ∈ G, from
begin
have h16 : (v.1, w.1) ∈ G, from
begin
have h17 : (v.1, w.1) ∈ G, from
begin
have h18 : (v.1, w.1) ∈ G, from
begin
have h19 : (v.1, w.1) ∈ G, from
begin
have h20 : (v.1, w.1) ∈ G, from
begin
have h21 : (v.1, w.1) ∈ G, from
begin
have h22 : (v.1, w.1) ∈ G, from
begin
have h23 : (v.1, w.1) ∈ G, from
begin
have h24 : (v.1, w.1) ∈ G, from
begin
have h25 : (v.1, w.1) ∈ G, from
begin
have h26 : (v.1, w.1) ∈ G, from
begin
have h27 : (v.1, w.1) ∈ G, from
begin
have h28 : (v.1, w.1) ∈ G, from
begin
have h29 : (v.1, w.1) ∈ G, from
begin
have h30 : (v.1, w.1) ∈ G, from
begin
have h31 : (v.1, w.1) ∈ G, from
begin
have h32 : (v.1, w.1) ∈ G, from
begin
have h33 : (v.1, w.1) ∈ G, from
begin
have h34 : (v.1, w.1) ∈ G, from
begin
have h35 : (v.1, w.1) ∈ G, from
begin
have h36 : (v.1, w.1) ∈ G, from
begin
have h37 : (v.1, w.1) ∈ G, from
begin
have h38 : (v.1, w.1) ∈ G, from
begin
have h39 : (v.1, w.1) ∈ G, from
begin
have h40 : (v.1, w.1) ∈ G, from
begin
have h41 : (v.1, w.1) ∈ G, from
begin
have h42 : (v.1, w.1) ∈ G, from
begin
have h43 : (v.1, w.1) ∈ G, from
begin
have h44 : (v.1, w.1) ∈ G, from
begin
have h45 : (v.1, w.1) ∈ G, from
end --Needs more than 2000 tokens!
--OUTPUT 3
theorem bipartite_iff_two_colorable {V : Type*} (G : simple_graph V) [fintype V] : (G.colorable 2) ↔ (∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B)) :=
begin
split,
{
assume (h : G.colorable 2),
-- Let $G$ be a 2-colorable graph, which means we can color every vertex either red or blue, and no edge will have both endpoints colored the same color.
-- Let $A$ denote the subset of vertices colored red, and let $B$ denote the subset of vertices colored blue.
cases h with (f : V → fin 2) (hf : ∀ (v w : V), v ≠ w → f v ≠ f w) (hf' : ∀ (v : V), f v ≠ 0),
let A := {v : V | f v = 1},
let B := {v : V | f v = 0},
-- Since all vertices of $A$ are red, there are no edges within $A$, and similarly for $B$.
have hA : ∀ (v w : V), v ≠ w → v ∈ A → w ∈ A → false, from by {
assume (v w : V) (hvw : v ≠ w) (hv : v ∈ A) (hw : w ∈ A),
have hv0 : f v = 0, from by {apply hf v w hvw, rw hv, rw hw, refl},
have hv1 : f v = 1, from by {apply eq_of_mem_singleton hv},
have hw0 : f w = 0, from by {apply hf v w hvw, rw hv, rw hw, refl},
have hw1 : f w = 1, from by {apply eq_of_mem_singleton hw},
have h1 : f v = f w, from by {rw hv0, rw hw0, refl},
have h2 : v = w, from by {apply hf v w hvw, rw h1},
have h3 : f v = 1, from by {rw hv1, refl},
have h4 : f w = 1, from by {rw h2, rw h3, refl},
have h5 : f w = 0, from by {rw hw0, refl},
have h6 : f v = 0, from by {rw h2, rw h5, refl},
show false, from by {rw h6, rw h3},
},
have hB : ∀ (v w : V), v ≠ w → v ∈ B → w ∈ B → false, from by {
assume (v w : V) (hvw : v ≠ w) (hv : v ∈ B) (hw : w ∈ B),
have hv0 : f v = 0, from by {apply eq_of_mem_singleton hv},
have hv1 : f v = 1, from by {apply hf v w hvw, rw hv, rw hw, refl},
have hw0 : f w = 0, from by {apply eq_of_mem_singleton hw},
have hw1 : f w = 1, from by {apply hf v w hvw, rw hv, rw hw, refl},
have h1 : f v = f w, from by {rw hv0, rw hw0, refl},
have h2 : v = w, from by {apply hf v w hvw, rw h1},
have h3 : f v = 0, from by {rw hv0, refl},
have h4 : f w = 0, from by {rw h2, rw h3, refl},
have h5 : f w = 1, from by {rw hw1, refl},
have h6 : f v = 1, from by {rw h2, rw h5, refl},
show false, from by {rw h6, rw h3},
},
-- This implies that every edge has one endpoint in $A$ and the other in $B$, which means $G$ is bipartite.
have hAB : ∀ (v w : V), v ≠ w → (v ∈ A ∧ w ∈ B) ∨ (v ∈ B ∧ w ∈ A), from by {
assume (v w : V) (hvw : v ≠ w),
have hv0 : f v = 0, from by {apply hf v w hvw, rw hf' v, rw hf' w, refl},
have hv1 : f v = 1, from by {apply hf v w hvw, rw hf' v, rw hf' w, refl},
have hw0 : f w = 0, from by {apply hf v w hvw, rw hf' v, rw hf' w, refl},
have hw1 : f w = 1, from by {apply hf v w hvw, rw hf' v, rw hf' w, refl},
have h1 : f v ≠ f w, from by {apply hf v w hvw},
have h2 : f v = 0 ∨ f v = 1, from by {rw hv0, rw hv1, left, refl},
have h3 : f w = 0 ∨ f w = 1, from by {rw hw0, rw hw1, left, refl},
have h4 : f v = 0 ∧ f w = 1 ∨ f v = 1 ∧ f w = 0, from by {
rw h2, rw h3,
left,
exact ⟨hv0, hw1⟩,
right,
exact ⟨hv1, hw0⟩,
},
have h5 : f v = 0 → f w = 1, from by {rw h4, left, exact and.left},
have h6 : f v = 1 → f w = 0, from by {rw h4, right, exact and.left},
cases h4 with h4 h4,
{
left,
exact ⟨by {apply exists_unique.unique h2 h4.left, rw h4.left, apply mem_singleton_iff.mpr, exact h4.right},
by {apply exists_unique.unique h3 h4.right, rw h4.right, apply mem_singleton_iff.mpr, exact h4.left}⟩,
},
{
right,
exact ⟨by {apply exists_unique.unique h2 h4.left, rw h4.left, apply mem_singleton_iff.mpr, exact h4.right},
by {apply exists_unique.unique h3 h4.right, rw h4.right, apply mem_singleton_iff.mpr, exact h4.left}⟩,
}
},
-- This implies that every edge has one endpoint in $A$ and the other in $B$, which means $G$ is bipartite.
have hAB' : ∀ (v w : V), v ≠ w → (v ∈ A ∧ w ∈ B) ∨ (v ∈ B ∧ w ∈ A), from by {
assume (v w : V) (hvw : v ≠ w),
have hv0 : f v = 0, from by {apply hf v w hvw, rw hf' v, rw hf' w, refl},
have hv1 : f v = 1, from by {apply hf v w hvw, rw hf' v, rw hf' w, refl},
have hw0 : f w = 0, from by {apply hf v w hvw, rw hf' v, rw hf' w, refl},
have hw1 : f w = 1, from by {apply hf v w hvw, rw hf' v, rw hf' w, refl},
have h1 : f v ≠ f w, from by {apply hf v w hvw},
have h2 : f v = 0 ∨ f v = 1, from by {rw hv0, rw hv1, left, refl},
have h3 : f w
end --Needs more than 2000 tokens!
--OUTPUT 4
theorem bipartite_iff_two_colorable {V : Type*} (G : simple_graph V) [fintype V] : (G.colorable 2) ↔ (∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B)) :=
begin
-- Let $G$ be a 2-colorable graph, which means we can color every vertex either red or blue, and no edge will have both endpoints colored the same color.
split,
{
assume hcolorable : G.colorable 2,
-- Let $A$ denote the subset of vertices colored red, and let $B$ denote the subset of vertices colored blue.
let A := {v : V | G.color v = 0},
let B := {v : V | G.color v = 1},
-- Since all vertices of $A$ are red, there are no edges within $A$, and similarly for $B$.
have h1 : ∀ u v : V, u ∈ A → v ∈ A → ¬(u,v) ∈ G.E, from by {
assume (u v : V) (hu : u ∈ A) (hv : v ∈ A),
assume (huv : (u,v) ∈ G.E),
have h2 : G.color u = G.color v, from by {
apply hcolorable,
exact ⟨huv,hu,hv⟩,
},
have h3 : G.color u = 0, from by {
apply set.mem_def.mp hu,
},
have h4 : G.color v = 0, from by {
apply set.mem_def.mp hv,
},
exact h2 h3 h4,
},
have h2 : ∀ u v : V, u ∈ B → v ∈ B → ¬(u,v) ∈ G.E, from by {
assume (u v : V) (hu : u ∈ B) (hv : v ∈ B),
assume (huv : (u,v) ∈ G.E),
have h2 : G.color u = G.color v, from by {
apply hcolorable,
exact ⟨huv,hu,hv⟩,
},
have h3 : G.color u = 1, from by {
apply set.mem_def.mp hu,
},
have h4 : G.color v = 1, from by {
apply set.mem_def.mp hv,
},
exact h2 h3 h4,
},
-- This implies that every edge has one endpoint in $A$ and the other in $B$, which means $G$ is bipartite.
have h3 : ∀ u v : V, (u,v) ∈ G.E → (u ∈ A ∧ v ∈ B) ∨ (u ∈ B ∧ v ∈ A), from by {
assume (u v : V) (huv : (u,v) ∈ G.E),
have h4 : G.color u = G.color v, from by {
apply hcolorable,
exact ⟨huv,_,_⟩,
},
have h5 : G.color u = 0 ∨ G.color u = 1, from by {
apply classical.em,
},
cases h5 with h5 h5,
{
have h6 : G.color v = 0, from by {
exact h4 h5,
},
have h7 : u ∈ A, from by {
apply set.mem_def.mpr h5,
},
have h8 : v ∈ A, from by {
apply set.mem_def.mpr h6,
},
have h9 : ¬(u,v) ∈ G.E, from by {
apply h1,
exact h7,
exact h8,
},
have h10 : false, from by {
exact h9 huv,
},
exact h10,
},
{
have h6 : G.color v = 1, from by {
exact h4 h5,
},
have h7 : u ∈ B, from by {
apply set.mem_def.mpr h5,
},
have h8 : v ∈ B, from by {
apply set.mem_def.mpr h6,
},
have h9 : ¬(u,v) ∈ G.E, from by {
apply h2,
exact h7,
exact h8,
},
have h10 : false, from by {
exact h9 huv,
},
exact h10,
},
},
have h4 : ∀ u v : V, (u,v) ∈ G.E → (u ∈ A ∧ v ∈ B), from by {
assume (u v : V) (huv : (u,v) ∈ G.E),
have h5 : (u ∈ A ∧ v ∈ B) ∨ (u ∈ B ∧ v ∈ A), from by {
apply h3,
exact huv,
},
cases h5 with h5 h5,
{
exact h5,
},
{
have h6 : u ∈ B, from by {
apply and.elim_left h5,
},
have h7 : v ∈ A, from by {
apply and.elim_right h5,
},
have h8 : ¬(u,v) ∈ G.E, from by {
apply h2,
exact h6,
exact h7,
},
have h9 : false, from by {
exact h8 huv,
},
exact h9,
},
},
have h5 : ∀ u v : V, (u,v) ∈ G.E → (u ∈ B ∧ v ∈ A), from by {
assume (u v : V) (huv : (u,v) ∈ G.E),
have h6 : (u ∈ A ∧ v ∈ B), from by {
apply h4,
exact huv,
},
have h7 : u ∈ A, from by {
apply and.elim_left h6,
},
have h8 : v ∈ B, from by {
apply and.elim_right h6,
},
have h9 : ¬(u,v) ∈ G.E, from by {
apply h1,
exact h7,
exact h8,
},
have h10 : false, from by {
exact h9 huv,
},
exact h10,
},
have h6 : ∀ u v : V, (u,v) ∈ G.E ↔ (u ∈ A ∧ v ∈ B), from by {
assume (u v : V),
split,
{
assume huv : (u,v) ∈ G.E,
apply h4,
exact huv,
},
{
assume huv : (u ∈ A ∧ v ∈ B),
have h7 : u ∈ A, from by {
apply and.elim_left huv,
},
have h8 : v ∈ B, from by {
apply and.elim_right huv,
},
have h9 : ¬(u,v) ∈ G.E, from by {
apply h1,
exact h7,
exact h8,
},
have h10 : false, from by {
exact h9 huv,
},
exact h10,
},
},
have h7 : ∀ u v : V, (u,v) ∈ G.E ↔ (u ∈ B ∧ v ∈ A), from by {
assume (u v : V),
split,
{
assume huv : (u,v) ∈ G.E,
apply h5,
exact huv,
},
{
assume huv : (u ∈ B ∧ v ∈ A),
have h8 : u ∈ B, from by {
apply and.elim_left huv,
},
have h9 : v ∈ A, from by
end --Needs more than 2000 tokens!
--OUTPUT 5
theorem bipartite_iff_two_colorable {V : Type*} (G : simple_graph V) [fintype V] : (G.colorable 2) ↔ (∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B)) :=
begin
-- Let $G$ be a 2-colorable graph, which means we can color every vertex either red or blue, and no edge will have both endpoints colored the same color. Let $A$ denote the subset of vertices colored red, and let $B$ denote the subset of vertices colored blue. Since all vertices of $A$ are red, there are no edges within $A$, and similarly for $B$. This implies that every edge has one endpoint in $A$ and the other in $B$, which means $G$ is bipartite.
have h1 : (G.colorable 2) → (∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B)), from
assume (h : G.colorable 2),
have h2 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h3 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h4 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h5 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h6 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h7 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h8 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h9 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h10 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h11 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h12 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h13 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h14 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h15 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h16 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h17 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h18 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h19 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h20 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h21 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h22 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h23 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h24 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h25 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h26 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h27 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h28 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h29 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h30 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h31 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h32 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h33 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h34 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
have h35 : ∃ (A B
end --Needs more than 2000 tokens!
--OUTPUT 6
theorem bipartite_iff_two_colorable {V : Type*} (G : simple_graph V) [fintype V] : (G.colorable 2) ↔ (∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B)) :=
begin
split,
{
assume h1 : G.colorable 2,
have h2 : ∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B), from by {
obtain ⟨f,hf⟩ : ∃ f : V → fin 2, G.is_coloring f, from h1,
let f' : V → fin 2 := f,
have hf' : G.is_coloring f', from hf,
let A := {v : V | f' v = 0},
let B := {v : V | f' v = 1},
have hA : fintype A, from by {
apply fintype.of_equiv,
exact ⟨V,λ v, ⟨f' v,by {rw fin.val_eq_coe,rw fin.coe_eq_zero,exact dec_trivial,}⟩,λ v, ⟨f' v,by {rw fin.val_eq_coe,rw fin.coe_eq_one,exact dec_trivial,}⟩,λ v, rfl,λ v, rfl⟩,
},
have hB : fintype B, from by {
apply fintype.of_equiv,
exact ⟨V,λ v, ⟨f' v,by {rw fin.val_eq_coe,rw fin.coe_eq_zero,exact dec_trivial,}⟩,λ v, ⟨f' v,by {rw fin.val_eq_coe,rw fin.coe_eq_one,exact dec_trivial,}⟩,λ v, rfl,λ v, rfl⟩,
},
have h3 : ∀ (x : V), (f' x = 0) ∨ (f' x = 1), from assume x : V,
begin
have h4 : (f' x = 0) ∨ (f' x = 1), from by apply fin.eq_zero_or_eq_one,
exact h4,
end,
have h4 : ∀ (x : V), (x ∈ A) ∨ (x ∈ B), from assume x : V,
begin
have h5 : (f' x = 0) ∨ (f' x = 1), from h3 x,
have h6 : (x ∈ A) ∨ (x ∈ B), from by {cases h5,left,exact h5,right,exact h5},
exact h6,
end,
have h5 : ∀ (x : V), (x ∈ A) → (x ∈ B) → false, from assume x : V, assume h6 : x ∈ A, assume h7 : x ∈ B,
begin
have h8 : f' x = 0, from by {rw mem_set_of_eq at h6,exact h6},
have h9 : f' x = 1, from by {rw mem_set_of_eq at h7,exact h7},
have h10 : false, from by {rw h8 at h9,exact h9},
exact h10,
end,
have h6 : ∀ (x : V), (x ∈ A) → (x ∈ B) → false, from assume x : V, assume h6 : x ∈ A, assume h7 : x ∈ B,
begin
have h8 : f' x = 0, from by {rw mem_set_of_eq at h6,exact h6},
have h9 : f' x = 1, from by {rw mem_set_of_eq at h7,exact h7},
have h10 : false, from by {rw h8 at h9,exact h9},
exact h10,
end,
have h7 : ∀ (x : V), (x ∈ B) → (x ∈ A) → false, from assume x : V, assume h6 : x ∈ B, assume h7 : x ∈ A,
begin
have h8 : f' x = 1, from by {rw mem_set_of_eq at h6,exact h6},
have h9 : f' x = 0, from by {rw mem_set_of_eq at h7,exact h7},
have h10 : false, from by {rw h8 at h9,exact h9},
exact h10,
end,
have h8 : ∀ (x y : V), (x ∈ A) → (y ∈ B) → (x ≠ y), from assume x y : V, assume h9 : x ∈ A, assume h10 : y ∈ B,
begin
have h11 : (x ∈ A) → (y ∈ B) → false, from h5 x y,
have h12 : (x ∈ A) → (y ∈ B) → false, from h6 x y,
have h13 : (x ∈ A) → (y ∈ B) → false, from h7 x y,
have h14 : (x ∈ A) → (y ∈ B) → false, from h8 x y,
have h15 : (x ∈ A) → (y ∈ B) → false, from h9 x y,
have h16 : (x ∈ A) → (y ∈ B) → false, from h10 x y,
have h17 : (x ∈ A) → (y ∈ B) → false, from h11 x y,
have h18 : (x ∈ A) → (y ∈ B) → false, from h12 x y,
have h19 : (x ∈ A) → (y ∈ B) → false, from h13 x y,
have h20 : (x ∈ A) → (y ∈ B) → false, from h14 x y,
have h21 : (x ∈ A) → (y ∈ B) → false, from h15 x y,
have h22 : (x ∈ A) → (y ∈ B) → false, from h16 x y,
have h23 : (x ∈ A) → (y ∈ B) → false, from h17 x y,
have h24 : (x ∈ A) → (y ∈ B) → false, from h18 x y,
have h25 : (x ∈ A) → (y ∈ B) → false, from h19 x y,
have h26 : (x ∈ A) → (y ∈ B) → false, from h20 x y,
have h27 : (x ∈ A) → (y ∈ B) → false, from h21 x y,
have h28 : (x ∈ A) → (y ∈ B) → false, from h22 x y,
have h29 : (x ∈ A) → (y ∈ B) → false, from h23 x y,
have h30 : (x ∈ A) → (y ∈ B) → false, from h24 x y,
have h31 : (x ∈ A) → (y ∈ B) → false, from h25 x y,
have h32 : (x ∈ A) → (y ∈ B) → false, from h26 x y,
have h33 : (x ∈ A) → (y ∈ B) → false, from h27 x y,
have h34 : (x ∈ A) → (y ∈ B) → false, from h28 x y,
have h35 : (x ∈ A) → (y ∈ B) → false, from h29 x y,
have h36 : (x ∈ A) → (y ∈ B) → false, from h30 x y,
have h37 : (x ∈ A) → (y ∈ B) → false, from h31 x y,
have h38 : (x ∈ A) → (y ∈ B) → false, from h32 x y,
have h39 : (x ∈ A) → (y ∈ B) → false, from h33 x y,
have h40 : (x ∈ A) → (y ∈
end --Needs more than 2000 tokens!
/- FEW SHOT PROMPTS TO CODEX(START)
/--`theorem`
Power Set is Closed under Intersection
Let $S$ be a set.
Let $\powerset S$ be the power set of $S$.
Then:
:$\forall A, B \in \powerset S: A \cap B \in \powerset S$
`proof`
Let $A, B \in \powerset S$.
Then by the definition of power set, $A \subseteq S$ and $B \subseteq S$.
From Intersection is Subset we have that $A \cap B \subseteq A$.
It follows from Subset Relation is Transitive that $A \cap B \subseteq S$.
Thus $A \cap B \in \powerset S$ and closure is proved.
{{qed}}
-/
theorem power_set_intersection_closed {α : Type*} (S : set α) : ∀ A B ∈ 𝒫 S, (A ∩ B) ∈ 𝒫 S :=
begin
-- $A$ and $B$ are sets. $A$ and $B$ belong to power set of $S$
assume (A : set α) (hA : A ∈ 𝒫 S) (B : set α) (hB : B ∈ 𝒫 S),
-- Then $A ⊆ S$ and $B ⊆ S$, by power set definition
have h1 : (A ⊆ S) ∧ (B ⊆ S), from by {split,apply set.subset_of_mem_powerset,exact hA,apply set.subset_of_mem_powerset,exact hB},
-- Then $(A ∩ B) ⊆ A$, by intersection of set is a subset
have h2 : (A ∩ B) ⊆ A, from by apply set.inter_subset_left,
-- Then $(A ∩ B) ⊆ S$, by subset relation is transitive
have h3 : (A ∩ B) ⊆ S, from by {apply set.subset.trans h2 h1.left},
-- Hence $(A ∩ B) ∈ 𝒫 S$, by power set definition
show (A ∩ B) ∈ 𝒫 S, from by {apply set.mem_powerset h3},
end
/--`theorem`
Square of Sum
:$\forall x, y \in \R: \paren {x + y}^2 = x^2 + 2 x y + y^2$
`proof`
Follows from the distribution of multiplication over addition:
{{begin-eqn}}
{{eqn | l = \left({x + y}\right)^2
| r = \left({x + y}\right) \cdot \left({x + y}\right)
}}
{{eqn | r = x \cdot \left({x + y}\right) + y \cdot \left({x + y}\right)
| c = Real Multiplication Distributes over Addition
}}
{{eqn | r = x \cdot x + x \cdot y + y \cdot x + y \cdot y
| c = Real Multiplication Distributes over Addition
}}
{{eqn | r = x^2 + 2xy + y^2
| c =
}}
{{end-eqn}}
{{qed}}
-/
theorem square_of_sum (x y : ℝ) : (x + y)^2 = (x^2 + 2*x*y + y^2) :=
begin
-- expand the power
calc (x + y)^2 = (x+y)*(x+y) : by rw sq
-- distributive property of multiplication over addition gives:
... = x*(x+y) + y*(x+y) : by rw add_mul
-- applying the above property further gives:
... = x*x + x*y + y*x + y*y : by {rw [mul_comm x (x+y),mul_comm y (x+y)], rw [add_mul,add_mul], ring}
-- rearranging the terms using commutativity and adding gives:
... = x^2 + 2*x*y + y^2 : by {repeat {rw ← sq}, rw mul_comm y x, ring}
end
/--`theorem`
Identity of Group is Unique
Let $\struct {G, \circ}$ be a group. Then there is a unique identity element $e \in G$.
`proof`
From Group has Latin Square Property, there exists a unique $x \in G$ such that:
:$a x = b$
and there exists a unique $y \in G$ such that:
:$y a = b$
Setting $b = a$, this becomes:
There exists a unique $x \in G$ such that:
:$a x = a$
and there exists a unique $y \in G$ such that:
:$y a = a$
These $x$ and $y$ are both $e$, by definition of identity element.
{{qed}}
-/
theorem group_identity_unique {G : Type*} [group G] : ∃! e : G, ∀ a : G, e * a = a ∧ a * e = a :=
begin
-- Group has Latin Square Property
have h1 : ∀ a b : G, ∃! x : G, a * x = b, from by {
assume a b : G, use a⁻¹ * b, obviously, },
have h2 : ∀ a b : G, ∃! y : G, y * a = b, from by {
assume a b : G, use b * a⁻¹, obviously, },
-- Setting $b = a$, this becomes:
have h3 : ∀ a : G, ∃! x : G, a * x = a, from
assume a : G, h1 a a,
have h4 : ∀ a : G, ∃! y : G, y * a = a, from
assume a : G, h2 a a,
-- These $x$ and $y$ are both $(1 : G)$, by definition of identity element
have h5 : ∀ a : G, classical.some (h3 a).exists = (1 : G), from assume a :G,
exists_unique.unique (h3 a) (classical.some_spec (exists_unique.exists (h3 a)))
(mul_one a),
have h6 : ∀ a : G, classical.some (h4 a).exists = (1 : G), from assume a : G,
exists_unique.unique (h4 a) (classical.some_spec (exists_unique.exists (h4 a))) (one_mul a),
show ∃! e : G, ∀ a : G, e * a = a ∧ a * e = a, from by {
use (1 : G),
have h7 : ∀ e : G, (∀ a : G, e * a = a ∧ a * e = a) → e = 1, from by {
assume (e : G) (hident : ∀ a : G, e * a = a ∧ a * e = a),
have h8 : ∀ a : G, e = classical.some (h3 a).exists, from assume (a : G),
exists_unique.unique (h3 a) (hident a).right
(classical.some_spec (exists_unique.exists (h3 a))),
have h9 : ∀ a : G, e = classical.some (h4 a).exists, from assume (a : G),
exists_unique.unique (h4 a) (hident a).left
(classical.some_spec (exists_unique.exists (h4 a))),
show e = (1 : G), from eq.trans (h9 e) (h6 _),
},
exact ⟨by obviously, h7⟩,
}
end
/--`theorem`
Bipartite Graph is two colorable
Let $G$ be a graph. Then $G$ is 2-colorable if and only if $G$ is bipartite.
`proof`
Let $G$ be a 2-colorable graph, which means we can color every vertex either red or blue, and no edge will have both endpoints colored the same color. Let $A$ denote the subset of vertices colored red, and let $B$ denote the subset of vertices colored blue. Since all vertices of $A$ are red, there are no edges within $A$, and similarly for $B$. This implies that every edge has one endpoint in $A$ and the other in $B$, which means $G$ is bipartite.
Conversely, suppose $G$ is bipartite, that is, we can partition the vertices into two subsets $V_{1}, V_{2}$ every edge has one endpoint in $V_{1}$ and the other in $V_{2}$. Then coloring every vertex of $V_{1}$ red and every vertex of $V_{2}$ blue yields a valid coloring, so $G$ is 2-colorable.
QED
-/
theorem bipartite_iff_two_colorable {V : Type*} (G : simple_graph V) [fintype V] : (G.colorable 2) ↔ (∃ (A B : Type*) (h : (A ⊕ B) = V), G ≤ cast (congr_arg _ h) (complete_bipartite_graph A B)) :=
FEW SHOT PROMPTS TO CODEX(END)-/
|
## run "../flow_embedding.py" first to generate data
using Plots
using SparseArrays
using LinearAlgebra
using TextParse
using DelimitedFiles
using PyCall
using ColorSchemes
function read_graph(filename)
src, dst, val = csvread(filename;
spacedelim=true, colparsers=[Int,Int,Float64], header_exists=false)[1]
src .+= 1
dst .+= 1
n = maximum(src)
n = max(maximum(dst),n)
A = sparse(src, dst, val, n, n)
A = max.(A,A')
return findnz(triu(A,1))[1:2]
end
src, dst = read_graph("../../dataset/lawlor-spectra-k32.edgelist.gz")
# x, y = csvread("$../../dataset/lawlor-spectra-k32.edgelist";
# spacedelim=true, colparsers=[Float64,Float64],
# header_exists=false)[1]
V = readdlm("../../dataset/lawlor-spectra-k32.coords")
V[:,1] *= -10
V[:,2] *= -4
function plotperm(v)
return invperm(sortperm(v))
end
# function myscatter(x,y,color;kwargs...)
# p = sortperm(color)
# scatter(x[p],y[p], marker_z = color[p],
# label="", alpha=0.1, markerstrokewidth=0,
# colorbar=false, framestyle=:none; kwargs...)
# end
##
pfile = "embeddings/spectral_3_bfs.p.gz"
pickle = pyimport("pickle")
gzip = pyimport("gzip")
f = gzip.open(pfile)
data= pickle.load(f)
f.close()
function _pycsr_to_sparse(rowptr, colinds, vals, m, n)
rowinds = zeros(eltype(colinds),0)
for i in 1:length(rowptr)-1
for j in rowptr[i]:rowptr[i+1]-1
push!(rowinds, i)
end
end
return sparse(rowinds, colinds, vals, m, n)
end
function pycsr_to_sparse(pycsr)
rowptr = pycsr.indptr
colinds = pycsr.indices
vals = pycsr.data
colinds .+= 1
m, n = data.shape
# put in a fucntion so we can do type inference
return _pycsr_to_sparse(rowptr, colinds, vals, m, n )
end
X = pycsr_to_sparse(data)
flipexp = findall(X[517173,:] .> 0) # this is at the opposite end
for f in flipexp
X[:,f] = 1.0 .-X[:,f]
end
X = Matrix(X) # convert to Matrix
X ./= 10 # convert to 0, 1
subset = vec((sum(X,dims=2) .> 0))
subsetnodes = findall(subset)
subset_c = vec((sum(X,dims=2) .<= 0))
subsetnodes_c = findall(subset_c)
U,sig,Vt = svd(X.-1)
new_coords = zeros(size(X,1),2)
new_coords[subsetnodes,1] = plotperm(-1 * U[subsetnodes,1])
new_coords[subsetnodes,2] = plotperm(-1 * U[subsetnodes,2])
i = argmax(new_coords[subsetnodes,1])
new_coords[subsetnodes_c,1] .= new_coords[subsetnodes[i],1] + 10000
new_coords[subsetnodes_c,2] .= new_coords[subsetnodes[i],2] + 10000
using Clustering
Xs = transpose(new_coords[subsetnodes,:])
R = kmeans(Xs,100; maxiter=200, display=:iter)
clusters = Dict(i=>[] for i = 1:100)
for i = 1:length(subsetnodes)
push!(clusters[R.assignments[i]],subsetnodes[i]-1)
end
pushfirst!(PyVector(pyimport("sys")."path"), "/homes/liu1740/Research/LocalGraphClustering/")
lgc = pyimport("localgraphclustering")
G = lgc.GraphLocal("../../dataset/lawlor-spectra-k32.edgelist","edgelist")
conds = []
for i = 1:100
push!(conds,G.compute_conductance(clusters[i]))
end
|
Formal statement is: lemma diameter_empty [simp]: "diameter{} = 0" Informal statement is: The diameter of the empty set is $0$. |
\label{problem_definition}
Clustering is the task of gathering items in a way that elements belonging
to the same group (the \emph{cluster}) are more similar to each other other than the ones
assigned to the others.\\
More formally, given a input:
\begin{itemize}
\item $X = \{x_0, \dots ,x_n\}$, the initial set of elements.
\item $d: X \times X \to \mathbb{R}$, a \emph{metric} measuring the similarity.
\end{itemize}
The final goal is to find the cluster configuration
\begin{equation*}
C = \left\{ c_0, \dots , c_m \right\} \mid \bigcup_{C} = X
\end{equation*}
partitioning $X$ into $m$ clusters, maximizing the intra-cluster distance
(dual problem of minimizing inter-cluter distance):
\begin{equation}
\underset{C}{\mathrm{argmax}}
\sum_{c \in C}
\sum_{i,j}^{|c|}
d(c_i,c_j)
\end{equation}
\subsection*{Challenges}
The concept of clustering is simple and powerful; moreover, its versatility
and generality are its greatness and at the same time source of many difficulties.
%% Metrics identification
Given the only strict requirement to be the definition of a metric over the
domain of $X$, clustering is applied to a wide variety of problems.
Clearly, each domain offers different optimization opportunities and
particular challenges.
In particular, the choice of the metric heavily influences the final outcome quality.
As a result even the medical~\cite{siless2013comparison}, the mechanical
engineering~\cite{wilding2011clustering} and the mobile networks~\cite{cheng2009stability}
literatures features different studies that address this particular challenge
suggesting highly specialized distance functions.
%% Inter/Intra cluster distance measure
Once the proper metric is identified, the following huge influencing factors
are the mathematical definitions of ``intra-cluster'' and ``inter-cluster''
distances. They vary a lot in the different implementation leading to
completely different clustering configurations.
For example, three methods are widely used when performing agglomerative
clustering to define the distance between two clusters:
the average, the minimum, and the maximum distance.
The average approach uses the barycenters, while the minimum (maximum)
relies upon the minimal (maximal) distance between any two points
belonging to a different clusters.
\subsection*{Choosing the $k$ parameter}
The first main issue of the k-means described in Section \ref{related} is the choice
of the number of clusters the dataset has to be divided into.
The original k-means does not address this problem at all. Thus, some heuristic has to
be applied. One possibility is to have a deep knowledge of the structure underlying the
dataset, having an idea of the target number of groups. On the other hand, especially
in exploratory data analysis, this value cannot be known in advance.
Hence, the most common solution is to run the algorithm with increasing values of $k$ and
finally keeping the parameter that produces the best-quality clusters.
Choosing the right value for this parameter is crucial, since a wrong one may
instruct the algorithm to collapse entities that are actually very far from each other
(or vice versa).
\subsection*{Positioning the initial centroids}
Given that an optimal value for $k$ is found, the other big problem is how to position the $k$
initial centroids.
Given enough time, the k-means algorithm will always converge. However it may be to a local
minimum. This is highly dependent on the initialization of the centroids. The boostrapping
phase can be addressed in various ways. For example, the
\emph{scikit-learn}\footnote{http://scikit-learn.org} Python library
uses an approach that positions the initial centroids to be (generally) distant
from each other by default. This procedure provides provably better results than using a random
one~\cite{arthur2007k}.
Using a proper and efficient boostrapping heuristic is very important, since misplacing
the initial centroids does not allow the algorithm to find the real clusters underlying
the data.
|
\section{More refined sparse grid and improved estimates}
This section presents a modified estimate \cite{bungartz2004sparse} of the approximation property of sparse grids. Recall
$$
\mathcal V_{\mathbf{k}} = \mathcal V_{k_1} \bigotimes \mathcal V_{k_2}\bigotimes\cdots \bigotimes \mathcal V_{k_d},
$$
where $\mathbf{k}=(k_1,k_2,\cdots,k_d)$ is a multi-index. Let
$$
\mathbf{I_l}=\{\mathbf{i}\in \mathbb{N}^d: \mathbf{1}\le \mathbf{i}\le 2^\mathbf{l}-1, i_j \text{ is odd for all }1\le j\le d\},
$$
and the hierarchical basis
$$
\{\psi_\mathbf{k, i}^d: \mathbf{i}\in \mathbf{I_k}, |\mathbf{k}|_\infty\le J\}.
$$
Recall $\mathcal V_{\mathbf{k}}$ in \eqref{sparseVk}. Let
$$
R_J=\left\{\mathbf{k}: |\mathbf{k}|_1 - \frac25 \log_2\|2^{\mathbf{k}}\|_{l^2}\le J+d-1- \frac15 \log_2 (4^J +4d-4)\right\},
$$
\begin{equation}
\label{sparseVJ}
S_J =\bigoplus_{\mathbf{k}\in R_J} \mathcal V_{\mathbf{k}}.
\end{equation}
The following the result is analyzed in \cite{bungartz2004sparse}.
\begin{theorem}\Label{lm:modifySparse1}
Suppose that $u\in W^{2\mathbf{e}, \infty}(D_d)$,
$$
\inf_{\chi\in S_J} |v-\chi|_{1, D_d}\le C h_J \|u\|_{2\mathbf{e},\infty}.
$$
and the dimension of $S_J$ is $\mathcal{O}(de^dh_J^{-1})$.
\end{theorem}
\begin{proof}
First, we prove that $S_J$ is a subspace of $S_{J,J+d-1}^d$.
If $|\mathbf{k}|_{1}=J+d-1+i, i \in \mathbb{N}$, we can prove
$$
\|2^{\mathbf{k}}\|_{l^2}^2=\sum_{s=1}^{d} 4^{k_{s}}\le 4^{J+i}+4 d-4
$$
by induction with respect to $d$.
% It is trivial when $d=1$. For $\mathbf{k}\in \mathbb{R}^d$ and $|\mathbf{k}|_{1}=J+d-1+i$, there exists $1\le j\le d$ such that $k_j\ge 1$, thus
%\begin{equation}
%\begin{split}
%\sum_{s=1}^{d} 4^{k_{s}} &= \sum_{s=1, s\neq i}^{d} 4^{k_{s}} + 4^{k_{j}}\le 4^{J+i+1-k_j}+4 (d-1)-4 + 4^{k_j}\le 4^{J+i} + 4d-4.
%\end{split}
%\end{equation}
For subspaces $\mathcal V_{\mathbf{k}}$ with $|\mathbf{k}|_{1}=J+d-1+i, i \in \mathbb{N},$ we have
\begin{equation}
\begin{split}
|\mathbf{k}|_{1}-\frac{1}{5} \cdot \log _{2}\left(\sum_{s=1}^{d} 4^{k_{s}}\right) & \geq J+d-1+i-\frac{1}{5} \cdot \log _{2}\left(4^{J+i}+4 d-4\right) \\
& \geq J+d-1+i-\frac{1}{5} \cdot \log _{2}\left(4^{i}\left(4^{J}+4 d-4\right)\right) \\
&>J+d-1-\frac{1}{5} \cdot \log _{2}\left(4^{J}+4 d-4\right)
\end{split}
\end{equation}
Therefore, no $\mathcal V_{\mathbf{k}}$ with $|\mathbf{k}|_{1}>J+d-1$ can belong to $V_J .$ Consequently,
\begin{equation}
S_J\subset S_{J,J+d-1}^d,\qquad \left|S_J\right| \leq\left|S_{J,J+d-1}^d\right|.
\end{equation}
Then, we prove that the dimension of $S_J$ is $\mathcal{O}(h_J^{-1})$.
Note that $\left|\mathcal V_{\mathbf{k}}\right| = 2^{|\mathbf{k}|_{1}-d}$. For any $\mathbf{k}\in R_J$ with $|\mathbf{k}|_{1}=J+d-1-i$, $ \sum_{j=1}^d 4^{k_j}\ge {4^J+4d-4\over 32^i}$. By \eqref{sparseVJ},
\begin{equation}
\begin{split}
\mbox{dim}S_J&=\sum_{i=0}^{J-1} \sum_{|\mathbf{k}|_{1}=J+d-1-i, \sum_{j=1}^d 4^{k_j}\ge {4^J+4d-4\over 32^i}} \mbox{dim}\mathcal V_{\mathbf{k}}
\\
&=2^{J-1} \cdot \sum_{i=0}^{J-1} 2^{-i} \sum_{|\mathbf{k}|_{1}=J+d-1-i, \sum_{j=1}^d 4^{k_j}\ge {4^J+4d-4\over 32^i}}1
\\
& \leq 2^{J-1} \cdot \lim _{J \rightarrow \infty} \sum_{i=0}^{J-1} 2^{-i} \sum_{|\mathbf{k}|_{1}=J+d-1-i, \sum_{j=1}^d 4^{k_j}\ge {4^J+4d-4\over 32^i}}1
\\
&=2^{J-1} d \lim _{J \rightarrow \infty} \sum_{i=0}^{J-1} 2^{-i} \left(\begin{array}{c}
d-1+\lfloor 1.5 i\rfloor \\
d-1
\end{array}\right).
\end{split}
\end{equation}
Let $j=\lfloor 1.5 i\rfloor $. Since $\displaystyle\sum_{i=0}^{\infty} x^{i} \cdot\left(\begin{array}{c}k+i \\ k\end{array}\right)=(1-x)^{-k-1}$ for $k \in \mathbb{N}_{0}$ and $0<x<1$,
\begin{equation}
\begin{split}
\mbox{dim}S_J
& \leq 2^{J} \cdot \frac{d}{2} \cdot \sum_{j=0}^{\infty} 2^{-\frac{2}{3} j} \cdot\left(\begin{array}{c}
d-1+j \\
d-1
\end{array}\right)
\\
&=2^{J} \cdot \frac{d}{2} \cdot\left(1-2^{-\frac{2}{3}}\right)^{-d}
\\
& \leq 2^{J} \cdot \frac{d}{2} \cdot \mathrm{e}^{d}=\mathcal{O}(h_J^{-1}).
\end{split}
\end{equation}
Next we consider the approximation property of $S_J$. Let $\displaystyle u_J=\sum_{\mathbf{k}\in R_J}u_{\mathbf{k}}$. Note that
$$
\left|u-u_J\right|_1 \leq\left|u-u_{J,J+d-1}\right|_1+\left|u_{J,J+d-1}-u_J\right|_1.
$$
By $\left|u-u_{J,J+d-1}\right|_1=O\left(h_{J}\right),$ we can restrict ourselves to $\left|u_{J,J+d-1}-u_J\right|_1.$ Note that for $i \in \mathbb{N}_{0},$
\begin{equation}
\mathcal V_{\mathbf{k}}\subset S_J, \quad \mbox{if } |\mathbf{k}|_{1}=J+d-1-i \ \mbox{ and }\ |\mathbf{k}|_{\infty} \geq J-2.5 i.
\end{equation}
Note that
$$
\left|u_{J,J+d-1}-u_J\right|_1\leq \sum_{\mathcal V_{\mathbf k} \in S_{J,J+d-1}^d \setminus S_J}\left|u_{\mathbf{k}}\right|_1
\leq \sum_{i=0}^{i^{*}} \sum_{\left.|\mathbf{k}\right|_{1}=J+d-1-i,\left.|\mathbf{k}\right|_{\infty}<J-2.5 i}\left|u_{\mathbf{k}}\right|_1,
$$
where $i^*$ is the maximum value of $i$ for which the set of indices $\mathbf{k}$ with $|\mathbf{k}|_1=n+d-1-i$ with $|\mathbf{k}|_\infty<n-2.5i$.
Therefore, we obtain with \eqref{sparseuk} that
\begin{equation*}
\begin{aligned}
\sum_{\left.|\mathbf{k}\right|_{1}=J+d-1-i,\left.|\mathbf{k}\right|_{\infty}<J-2.5 i}\left|u_{\mathbf{k}}\right|_1
\leq \frac{|u|_{2\mathbf{e},\infty}}{2 \cdot 12^{(d-1) / 2}} \sum_{\left.|\mathbf{k}\right|_{1}=J+d-1-i,\left.|\mathbf{k}\right|_{\infty}<J-2.5 i} 4^{-|\mathbf{k}|_{1}} \cdot\left(\sum_{j=1}^{d} 4^{k_{j}}\right)^{1 / 2}.
\end{aligned}
\end{equation*}
Since
$
\displaystyle \sum_{j=1}^{d} 4^{k_{j}}=\sum_{j=1}^{d} 2^{2k_{j}}\leq \left(\sum_{j=1}^{d} 2^{k_{j}}\right)^2,
$
\begin{equation*}
\begin{aligned}
\sum_{\left.|\mathbf{k}\right|_{1}=J+d-1-i,\left.|\mathbf{k}\right|_{\infty}<J-2.5 i}\left|u_{\mathbf{k}}\right|_1
&\leq \frac{|u|_{2\mathbf{e},\infty}}{2 \cdot 12^{(d-1) / 2}} \cdot 4^{-J-d+1+i} \sum_{\left.|\mathbf{k}\right|_{1}=J+d-1-i,\left.|\mathbf{k}\right|_{\infty}<J-2.5 i}\left(\sum_{j=1}^{d} 2^{k_{j}}\right)
\\
&\leq \frac{|u|_{2\mathbf{e},\infty}}{2 \cdot 12^{(d-1) / 2}} \cdot 4^{-J-d+1+i} \sum_{j=1}^{J-1-\lfloor 2.5 i\rfloor} d \cdot\left(\begin{array}{c}
J+d-2-i-j \\
d-2
\end{array}\right) \cdot 2^{j}
\\
&=\frac{|u|_{2\mathbf{e},\infty}}{2 \cdot 12^{(d-1) / 2}} 4^{-J-d+1+i} \sum_{k=1}^{J-1-\lfloor 2.5 i\rfloor} d\left(\begin{array}{c}
d-2+\lfloor 1.5 i\rfloor+k \\
d-2
\end{array}\right) 2^{J-\lfloor 2.5 i\rfloor-k}
\\
&=\frac{d \cdot|u|_{2\mathbf{e},\infty}}{2 \cdot 12^{(d-1) / 2}} 4^{-(d-1)} 2^{-J-\left\lfloor\frac{i}{2}\right\rfloor} \sum_{k=1}^{J-1-\lfloor 2.5 i\rfloor}\left(\begin{array}{c}
d-2+\lfloor 1.5 i\rfloor+k \\
d-2
\end{array}\right) 2^{-k} .
\end{aligned}
\end{equation*}
Thus,
\begin{equation*}
\begin{aligned}
\left|u_{J,J+d-1}-u_J\right|_1
&\leq \frac{d \cdot|u|_{2\mathbf{e},\infty}}{2 \cdot 12^{(d-1) / 2}} \cdot 4^{-(d-1)} \cdot 2^{-J} \cdot 2 \cdot 5^{d-1}\\
&=\frac{d \cdot|u|_{2\mathbf{e},\infty}}{3^{(d-1) / 2} \cdot 4^{d-1}} \cdot\left(\frac{5}{2}\right)^{d-1} \cdot 2^{-J}\le Ch_J,
\end{aligned}
\end{equation*}
which completes the proof.
%\begin{equation*}
%\begin{aligned}
%\left|u_{J,J+d-1}-u_J\right|_1&\leq \sum_{\mathcal V_{\mathbf k} \in S_{J,J+d-1}^d \setminus S_J}\left|u_{\mathbf{k}}\right|_1
%\\
%&\leq \sum_{i=0}^{i^{*}} \sum_{\left.|\mathbf{k}\right|_{1}=J+d-1-i,\left.|\mathbf{k}\right|_{\infty}<J-2.5 i}\left|u_{\mathbf{k}}\right|_1
%\\
%&\leq \frac{|u|_{2\mathbf{e},\infty}}{2 \cdot 12^{(d-1) / 2}} \cdot \sum_{i=0}^{i^{*}} \sum_{\left.|\mathbf{k}\right|_{1}=J+d-1-i,\left.|\mathbf{k}\right|_{\infty}<J-2.5 i} 4^{-|\mathbf{k}|_{1}} \cdot\left(\sum_{j=1}^{d} 4^{k_{j}}\right)^{1 / 2}
%\\
%&\leq \frac{|u|_{2\mathbf{e},\infty}}{2 \cdot 12^{(d-1) / 2}} \cdot 4^{-J-d+1} \cdot \sum_{i=0}^{i^{*}} 4^{i} \cdot \sum_{\left.|\mathbf{k}\right|_{1}=J+d-1-i,\left.|\mathbf{k}\right|_{\infty}<J-2.5 i}\left(\sum_{j=1}^{d} 2^{k_{j}}\right)
%\\
%&\leq \frac{|u|_{2\mathbf{e},\infty}}{2 \cdot 12^{(d-1) / 2}} \cdot 4^{-J-d+1} \cdot \sum_{i=0}^{i^{*}} 4^{i} \cdot \sum_{j=1}^{J-1-\lfloor 2.5 i\rfloor} d \cdot\left(\begin{array}{c}
%J+d-2-i-j \\
%d-2
%\end{array}\right) \cdot 2^{j}
%\\
%&=\frac{|u|_{2\mathbf{e},\infty}}{2 \cdot 12^{(d-1) / 2}} 4^{-J-d+1} \sum_{i=0}^{i^{*}} 4^{i} \sum_{k=1}^{J-1-\lfloor 2.5 i\rfloor} d\left(\begin{array}{c}
%d-2+\lfloor 1.5 i\rfloor+k \\
%d-2
%\end{array}\right) 2^{J-\lfloor 2.5 i\rfloor-k}
%\\
%&=\frac{d \cdot|u|_{2\mathbf{e},\infty}}{2 \cdot 12^{(d-1) / 2}} 4^{-(d-1)} 2^{-J} \sum_{i=0}^{i^{*}} 2^{-\left\lfloor\frac{i}{2}\right\rfloor} \sum_{k=1}^{J-1-\lfloor 2.5 i\rfloor}\left(\begin{array}{c}
%d-2+\lfloor 1.5 i\rfloor+k \\
%d-2
%\end{array}\right) 2^{-k}
%\\
%&\leq \frac{d \cdot|u|_{2\mathbf{e},\infty}}{2 \cdot 12^{(d-1) / 2}} \cdot 4^{-(d-1)} \cdot 2^{-J} \cdot 2 \cdot 5^{d-1}\\
%&=\frac{d \cdot|u|_{2\mathbf{e},\infty}}{3^{(d-1) / 2} \cdot 4^{d-1}} \cdot\left(\frac{5}{2}\right)^{d-1} \cdot 2^{-J}\le Ch_J,
%\end{aligned}
%\end{equation*}
\end{proof}
|
{-# LANGUAGE ViewPatterns #-}
-- |
-- Module : Statistics.Test.WilcoxonT
-- Copyright : (c) 2010 Neil Brown
-- License : BSD3
--
-- Maintainer : [email protected]
-- Stability : experimental
-- Portability : portable
--
-- The Wilcoxon matched-pairs signed-rank test is non-parametric test
-- which could be used to test whether two related samples have
-- different means.
module Statistics.Test.WilcoxonT (
-- * Wilcoxon signed-rank matched-pair test
-- ** Test
wilcoxonMatchedPairTest
-- ** Building blocks
, wilcoxonMatchedPairSignedRank
, wilcoxonMatchedPairSignificant
, wilcoxonMatchedPairSignificance
, wilcoxonMatchedPairCriticalValue
, module Statistics.Test.Types
-- * References
-- $references
) where
--
--
--
-- Note that: wilcoxonMatchedPairSignedRank == (\(x, y) -> (y, x)) . flip wilcoxonMatchedPairSignedRank
-- The samples are zipped together: if one is longer than the other, both are truncated
-- The value returned is the pair (T+, T-). T+ is the sum of positive ranks (the
-- These values mean little by themselves, and should be combined with the 'wilcoxonSignificant'
-- function in this module to get a meaningful result.
-- ranks of the differences where the first parameter is higher) whereas T- is
-- the sum of negative ranks (the ranks of the differences where the second parameter is higher).
-- to the length of the shorter sample.
import Data.Function (on)
import Data.List (findIndex)
import Data.Ord (comparing)
import qualified Data.Vector.Unboxed as U
import Prelude hiding (sum)
import Statistics.Function (sortBy)
import Statistics.Sample.Internal (sum)
import Statistics.Test.Internal (rank, splitByTags)
import Statistics.Test.Types
import Statistics.Types -- (CL,pValue,getPValue)
import Statistics.Distribution
import Statistics.Distribution.Normal
-- | Calculate (n,T⁺,T⁻) values for both samples. Where /n/ is reduced
-- sample where equal pairs are removed.
wilcoxonMatchedPairSignedRank :: (Ord a, Num a, U.Unbox a) => U.Vector (a,a) -> (Int, Double, Double)
wilcoxonMatchedPairSignedRank ab
= (nRed, sum ranks1, negate (sum ranks2))
where
-- Positive and negative ranks
(ranks1, ranks2) = splitByTags
$ U.zip tags (rank ((==) `on` abs) diffs)
-- Sorted list of differences
diffsSorted = sortBy (comparing abs) -- Sort the differences by absolute difference
$ U.filter (/= 0) -- Remove equal elements
$ U.map (uncurry (-)) ab -- Work out differences
nRed = U.length diffsSorted
-- Sign tags and differences
(tags,diffs) = U.unzip
$ U.map (\x -> (x>0 , x)) -- Attach tags to distribution elements
$ diffsSorted
-- | The coefficients for x^0, x^1, x^2, etc, in the expression
-- \prod_{r=1}^s (1 + x^r). See the Mitic paper for details.
--
-- We can define:
-- f(1) = 1 + x
-- f(r) = (1 + x^r)*f(r-1)
-- = f(r-1) + x^r * f(r-1)
-- The effect of multiplying the equation by x^r is to shift
-- all the coefficients by r down the list.
--
-- This list will be processed lazily from the head.
coefficients :: Int -> [Integer]
coefficients 1 = [1, 1] -- 1 + x
coefficients r = let coeffs = coefficients (r-1)
(firstR, rest) = splitAt r coeffs
in firstR ++ add rest coeffs
where
add (x:xs) (y:ys) = x + y : add xs ys
add xs [] = xs
add [] ys = ys
-- This list will be processed lazily from the head.
summedCoefficients :: Int -> [Double]
summedCoefficients n
| n < 1 = error "Statistics.Test.WilcoxonT.summedCoefficients: nonpositive sample size"
| n > 1023 = error "Statistics.Test.WilcoxonT.summedCoefficients: sample is too large (see bug #18)"
| otherwise = map fromIntegral $ scanl1 (+) $ coefficients n
-- | Tests whether a given result from a Wilcoxon signed-rank matched-pairs test
-- is significant at the given level.
--
-- This function can perform a one-tailed or two-tailed test. If the first
-- parameter to this function is 'TwoTailed', the test is performed two-tailed to
-- check if the two samples differ significantly. If the first parameter is
-- 'OneTailed', the check is performed one-tailed to decide whether the first sample
-- (i.e. the first sample you passed to 'wilcoxonMatchedPairSignedRank') is
-- greater than the second sample (i.e. the second sample you passed to
-- 'wilcoxonMatchedPairSignedRank'). If you wish to perform a one-tailed test
-- in the opposite direction, you can either pass the parameters in a different
-- order to 'wilcoxonMatchedPairSignedRank', or simply swap the values in the resulting
-- pair before passing them to this function.
wilcoxonMatchedPairSignificant
:: PositionTest -- ^ How to compare two samples
-> PValue Double -- ^ The p-value at which to test (e.g. @mkPValue 0.05@)
-> (Int, Double, Double) -- ^ The (n,T⁺, T⁻) values from 'wilcoxonMatchedPairSignedRank'.
-> Maybe TestResult -- ^ Return 'Nothing' if the sample was too
-- small to make a decision.
wilcoxonMatchedPairSignificant test pVal (sampleSize, tPlus, tMinus) =
case test of
-- According to my nearest book (Understanding Research Methods and Statistics
-- by Gary W. Heiman, p590), to check that the first sample is bigger you must
-- use the absolute value of T- for a one-tailed check:
AGreater -> do crit <- wilcoxonMatchedPairCriticalValue sampleSize pVal
return $ significant $ abs tMinus <= fromIntegral crit
BGreater -> do crit <- wilcoxonMatchedPairCriticalValue sampleSize pVal
return $ significant $ abs tPlus <= fromIntegral crit
-- Otherwise you must use the value of T+ and T- with the smallest absolute value:
--
-- Note that in absence of ties sum of |T+| and |T-| is constant
-- so by selecting minimal we are performing two-tailed test and
-- look and both tails of distribution of T.
SamplesDiffer -> do crit <- wilcoxonMatchedPairCriticalValue sampleSize (mkPValue $ p/2)
return $ significant $ t <= fromIntegral crit
where
t = min (abs tPlus) (abs tMinus)
p = pValue pVal
-- | Obtains the critical value of T to compare against, given a sample size
-- and a p-value (significance level). Your T value must be less than or
-- equal to the return of this function in order for the test to work out
-- significant. If there is a Nothing return, the sample size is too small to
-- make a decision.
--
-- 'wilcoxonSignificant' tests the return value of 'wilcoxonMatchedPairSignedRank'
-- for you, so you should use 'wilcoxonSignificant' for determining test results.
-- However, this function is useful, for example, for generating lookup tables
-- for Wilcoxon signed rank critical values.
--
-- The return values of this function are generated using the method
-- detailed in the Mitic's paper. According to that paper, the results
-- may differ from other published lookup tables, but (Mitic claims)
-- the values obtained by this function will be the correct ones.
wilcoxonMatchedPairCriticalValue ::
Int -- ^ The sample size
-> PValue Double -- ^ The p-value (e.g. @mkPValue 0.05@) for which you want the critical value.
-> Maybe Int -- ^ The critical value (of T), or Nothing if
-- the sample is too small to make a decision.
wilcoxonMatchedPairCriticalValue n pVal
| n < 100 =
case subtract 1 <$> findIndex (> m) (summedCoefficients n) of
Just k | k < 0 -> Nothing
| otherwise -> Just k
Nothing -> error "Statistics.Test.WilcoxonT.wilcoxonMatchedPairCriticalValue: impossible happened"
| otherwise =
case quantile (normalApprox n) p of
z | z < 0 -> Nothing
| otherwise -> Just (round z)
where
p = pValue pVal
m = (2 ** fromIntegral n) * p
-- | Works out the significance level (p-value) of a T value, given a sample
-- size and a T value from the Wilcoxon signed-rank matched-pairs test.
--
-- See the notes on 'wilcoxonCriticalValue' for how this is calculated.
wilcoxonMatchedPairSignificance
:: Int -- ^ The sample size
-> Double -- ^ The value of T for which you want the significance.
-> PValue Double -- ^ The significance (p-value).
wilcoxonMatchedPairSignificance n t
= mkPValue p
where
p | n < 100 = (summedCoefficients n !! floor t) / 2 ** fromIntegral n
| otherwise = cumulative (normalApprox n) t
-- | Normal approximation for Wilcoxon T statistics
normalApprox :: Int -> NormalDistribution
normalApprox ni
= normalDistr m s
where
m = n * (n + 1) / 4
s = sqrt $ (n * (n + 1) * (2*n + 1)) / 24
n = fromIntegral ni
-- | The Wilcoxon matched-pairs signed-rank test. The samples are
-- zipped together: if one is longer than the other, both are
-- truncated to the length of the shorter sample.
--
-- For one-tailed test it tests whether first sample is significantly
-- greater than the second. For two-tailed it checks whether they
-- significantly differ
--
-- Check 'wilcoxonMatchedPairSignedRank' and
-- 'wilcoxonMatchedPairSignificant' for additional information.
wilcoxonMatchedPairTest
:: (Ord a, Num a, U.Unbox a)
=> PositionTest -- ^ Perform one-tailed test.
-> U.Vector (a,a) -- ^ Sample of pairs
-> Test () -- ^ Return 'Nothing' if the sample was too
-- small to make a decision.
wilcoxonMatchedPairTest test pairs =
Test { testSignificance = pVal
, testStatistics = t
, testDistribution = ()
}
where
(n,tPlus,tMinus) = wilcoxonMatchedPairSignedRank pairs
(t,pVal) = case test of
AGreater -> (abs tMinus, wilcoxonMatchedPairSignificance n (abs tMinus))
BGreater -> (abs tPlus, wilcoxonMatchedPairSignificance n (abs tPlus ))
-- Since we take minimum of T+,T- we can't get more
-- that p=0.5 and can multiply it by 2 without risk
-- of error.
SamplesDiffer -> let t' = min (abs tMinus) (abs tPlus)
p = wilcoxonMatchedPairSignificance n t'
in (t', mkPValue $ min 1 $ 2 * pValue p)
-- $references
--
-- * \"Critical Values for the Wilcoxon Signed Rank Statistic\", Peter
-- Mitic, The Mathematica Journal, volume 6, issue 3, 1996
-- (<http://www.mathematica-journal.com/issue/v6i3/article/mitic/contents/63mitic.pdf>)
|
\section*{Time Series data \footnotesize\emph{Fabian Brix, Anton Ovchinnikov}}
The basis for the prediction part of this project are time series of price data. We acquired these for different stages of pricing in the supply chain and at different time granularities from different Indian government ministries. The data had to be downloaded and processed into usable formats from the websites of these ministries. The different sources consist of the Ministry of Agriculture and the Ministry of Trade and their various departments. In terms of different types of prices we differentiate between wholesale market prices and retail prices. We subsequently structure our documentation of data sources and the data processing according to these two types.
\subsection*{Wholesale prices}
\subsubsection*{Wholesale price index}
An index that measures and tracks the changes in price of goods in the stages before the retail level. Wholesale price indexes (WPIs) report monthly to show the average price changes of goods sold in bulk, and they are a group of the indicators that follow growth in the economy.\par
%(taken from investopedia.com)\\
\subsubsection*{Data sources}
We came across a \href{http://agmarknet.nic.in/}{website} maintained by the Indian Ministry of Agriculture that tracked \emph{daily} wholesale prices for units of 100 kilograms for a huge number of market places across the country. The data is recorded back to 2005 and is supplemented by stock arrival numbers.\par
Due to large amount of data available, as well as time and resources needed to pull it, we constrained ourselves to choosing several major products (Onion, Rice, Wheat, Apple, Banana, Coriander, Potato, Paddy(Dhan), Tomato), where a Python script was used to download all available data for the selected products directly from the website, using simple HTTP GET requests. Raw HTML data was then converted to CSV format with predefined structure and saved for later processing.
\subsection*{Retail prices}
\subsubsection*{Data sources}
\begin{itemize}
\item[1.] Daily retail prices
Daily retail prices were found at the \href{http://fcainfoweb.nic.in/}{website}, created by Department of Consumer Affairs of India. One can choose the type of report (price report, variation report, average/month end report) and the desired date, and then receive the requested data in HTML format. This website was used to query price reports from 2009 to 2014, for 59 cities and 22 products. Similar to the wholesale daily prices, raw HTML data was converted to CSV files in normalized format, which was intended to facilitate further processing.
\item[2.] Weekly retail prices
The \href{http://rpms.dacnet.nic.in/}{Retail Price Information System} of the Indian Ministry of Agriculture was queried to obtain weekly retail prices.\par
Unlike daily prices, the only available data format that was capable of being parsed, was Microsoft Excel .xls format. So all the required .xls files were downloaded using a Python script, and then 'xls2csv' was used to convert .xls documents to CSV data format. For some reason, the majority of product names were missing in the downloaded .xls files, so a basic heuristic, which involved the order of product names, was used to reconstruct the data.
The data obtained described information about prices for a large number of markets, around 60 products and hundreds of subproducts, dating back to 2005, but, unfortunately, the data was far from complete, especially for 2005-2007 time frame.
\end{itemize}
\subsection*{Price sequences \footnotesize\emph{Ching-Chia Wang}}
We used Pandas, a powerful and fast Python data analysis library, to load the csv files of datasets, to clean them up, and to organize them into usable formats. The prices of all products in these datasets are collected through a human reporting mechanism from local institutions to a central ministry. Due to the nature of this data collecting process, the qualities of these 3 datasets suffer from human neglects and mistakes. We thus need to conduct 2 phases of work prior to time series analysis and price prediction: data clean-up and dataset usability analysis.
\subsubsection*{Price Data Clean-up}
In data clean-up, we fixed several defects in the original datasets of the data sources. Each series originally has different portion of missing dates, and some have multiple data points of the same date with different values. The first stage of clean-up was to make each series align to a unique sequence of dates with constant date frequency by inserting NaNs to the missing and duplicated dates.
Next, we discovered that there are many outliers with extreme values in the series. For example, a price of 10 rupee today jumps to 100 tomorrow, and then goes back to 10 the day after. Such cases are more likely caused by human mistakes in reporting prices to the Indian ministries, so we used a heuristic to remove these suspicious spikes in the series. By taking the daily differences in percentage of a series, we were able to remove data points of the dates which perform more than 100\% price change in one time step (daily or weekly).
Finally, we patched the missing parts of the series with common methods such as linear or cubic spline interpolation.
\begin{figure}[!ht]
\centering
\begin{subfigure}[b]{.45\textwidth}
\centering
\includegraphics[width=\textwidth]{./img/before.png}
\caption{Sample price series after date alignment during data cleaning}
\label{subfig:sc1}
\end{subfigure}
\quad
\begin{subfigure}[b]{.45\textwidth}
\centering
\includegraphics[width=\textwidth]{./img/after.png}
\caption{Sample price series after spikes-removing and interpolation}
\label{subfig:sc2}
\end{subfigure}
\caption{Regression with ARMA error shock}
\label{fig:series_cleaning}
\end{figure}
\subsubsection*{Price Dataset Usability Analysis}
The dataset usability analysis phase was intended to explore the data to find usable materials for analysis and prediction in later stages. We first filtered out all the series with less than 60\% of non-missing data, then computed some indicators of the data availability of each product in each region. Unfortunately, we have found out that all the datasets are far from satisfying.
The data availability in the daily wholesale dataset varies tremendously among different products and regions. Although there are about 15 regions, 7 candidate products, and more than 10 sub-categories for each product after filtering, most of the combinations of region, product, sub-category do not have enough available data for analysis and prediction. Fortunately, we did find out a few very good series which have more than 80\%~90\% of valid data and also perform the desired traits of high volatility and rising trend across time. These become good candidates for later analysis and prediction.
On the other hand, the daily retail dataset appears to have consistent data availability among products and regions, but in fact all products have only about 60\% of valid data in each region. Moreover, after examining each series via plots, we discovered that most of the daily retail series have weird behavior. For instance, the price of a series may have identical values for a long period and suddenly jump to another value, which makes the series look like levels of ladders. These series are not useful since such pattern is probably caused by dysfunctional price reporting process. Last, the weekly retail datatset has too many incorrect data points due to the heuristic of parsing excel files mentioned in the previous section. We thus concluded that the weekly retail dataset can be discarded with no loss.
Considering the limitations of the current price datasets, we have concluded the following potential usage of them: (1) Select a few representative series of each product with very good data quality. By using these individual series as a starting point of analysis and prediction, we can find out general characteristics and also the feasibility of predicting the prices of these highly volatile commodities. (2) Merge the series of the same product in each region to construct an extended dataset containing a uniform profile for each product in each region. In this way, we can gain a national overview of trends and price variations of different products.
\begin{figure}
\centering
\includegraphics[width=.7\textwidth]{./img/merged_west_bengal_products.png}
\caption{Merged series of foods in West Bengal from the wholesale daily dataset}
\end{figure}
\subsection*{Other sources \footnotesize\emph{Joseph Boyd}}
After some research we decided to include additional data that affects especially agricultural commodity prices such as the price of crude oil, climate data and the inflation in form of the Consumer Price Index (CPI). The monthly international price of crude oil was downloaded from a US government website. All other types of data were ``scraped'' from two online sources using HTML parsing library, `BeautifulSoup' for Python. The first of these sources was meteorological web site Tu Tiempo (http://www.tutiempo.net). Daily climate data (comprising temperature, humidity, perspiration etc.) for the last 16 years (1999-2014) was collected for over 100 locations in India. The script for this is get\_climate\_data.py. The second source was monthly inflation (CPI) data for India for the past 16 years from inflation.eu. The script for this purpose is get\_inflation\_data.py.
%exchange rate
%crude oil
\section*{Social Media data \footnotesize\emph{Joseph Boyd}}
For the other significant part of the project we decided to limit ourselves to a basic analysis of conversations on twitter. Originally we planned to also look into other platforms such as Facebook but quickly came to realize that the data publicly available through the API was of little use to us. Obtaining data from the twitter APIs turned out to be harder than expected and involved a number of heuristics. Twitter provides different APIs for different purposes. The two that are free are the Streaming API which allows real-time streaming of only 1\% of newly posted tweets. Since we wanted 'historical' tweets we had to find a workaround by using the REST API and getting tweets by user.\par
Twitter is a rich resource for studying cutting-edge trends on a global scale. Given a sufficiently large data collection effort, Twitter user discourse indicating changes in commodity prices may be obtained. This discourse supplies us with predictors The Humanitas project harvests huge amounts of user activity from this social media platform in order to capture the sparsely distributed activity pertaining to food prices. It is this aspect of the project which promotes it to the domain of `big data'.
\subsection*{Historical tweets}
\subsubsection*{Approach 1: Fetching "historical" tweets through Twitter API \footnotesize\emph{Joseph Boyd}}
Using the Twython package for python we are able to interface with the Twitter API. Our methodology (figure \ref{fig:methodology}) is to select the twitter accounts of a number of regional celebrities as starting points. These are likely to be `followed' by large numbers of local users. In a first phase (tweet\_collection.py.get\_followers()), from each of these sources we may extract a list of followers and filter by various characteristics. Once a substantial list has been constructed it must be merged (merge.py and remove\_intersection.py), we may proceed to download the tweet activity (up to the 3200 most recent tweets) of each of these users in a second phase (tweet\_collection.py.get\_tweets()).
Despite recent updates allowing developers greater access, Twitter still imposes troublesome constraints on the number of requests per unit time window (15 minutes) and, consequently, the data collection rate. It is therefore necessary to: 1) optimise the use of each request; and 2) parallelise the data collection effort.
As far as optimisation is concerned, the \textbf{GET statuses/user\_timeline} call may be called 300 times per 15 minute time window with up to 200 tweets returned per request. This sets a hard upper bound of 60000 tweets per time window. This is why the filtering stage of the first phase is so crucial. Using the \textbf{GET followers/list} call (30 calls/time window), we may discard in advance the majority of twitter users with low numbers of tweets (often zero), so as to avoid burning the limited user timeline requests on fruitless users, thus increasing the data collection rate. With this approach we may approach optimality and achieve 4-5 million tweets daily per process. However, it may be prudent to strike a balance between tweets per day and tweets per user. Therefore a nominal filter is currently set to 50 tweets minimum rather than 200. It is furthermore necessary to install dynamic time-tracking mechanisms within the source code so as to monitor the request rates and to impose a process `sleep' when required.
Parallelisation begins with obtaining N ($\approx 10$) sets of developer credentials from Twitter (https://dev.twitter.com/). These N credentials may then be used to launch N processes (get\_users.sh) collecting user data in parallel. Given the decision to divide the follower collection and tweet collection into separate phases (this may alternatively be done simultaneously), there is no need for distributed interaction between the processes to control overlap, as each process will simply take $1/N$ th of the follower list produced in phase 1 and process it accordingly. It should be relatively simple to initiate this parallel computation given the design of the scripts.
\begin{table}
\begin{center}
\begin{tabular}{ | c | c | c | c | c | }
\hline
Phase 1 \\ \hline
Users & Duration (s) & Sleep (s) & User Rate & Type \\ \hline
334 & 2795 & 2047 & - & Total \\ \hline
299 & 2700 & 2047 & 99.7 & Normalised (3 windows) \\ \hline
Phase 2 \\ \hline
Tweets (Users) & Duration (s) & Sleep (s) & Tweet Rate & Type \\ \hline
171990 (334) & 3108 & 922 & - & Total \\ \hline
150008 (309) & 2700 & 922 & 50002.7 & Normalised (3 windows) \\ \hline
\end{tabular}
\end{center}
\caption{Trial run results}
\label{table:benchmark}
\end{table}
A benchmarking test (table \ref{table:benchmark}) was performed in order to support configuration choices for the parallelisation. The test involved collecting the tweets from all good users within the first 20000 followers of @KareenaOnline, the account of a local celebrity. The following observations can be made:
\begin{itemize}
\item only 1.5-2\% of users are considered "good" under the current choice of filters (location, min. 50 tweets etc.);
\item Despite different levels of sleeping, phase 2 reads from users at roughly the same rate that phase 1 collects them (approximately 100 per time window in both cases);
\item Phase 2 produces around 50000 tweets per time window.
\end{itemize}
It is important to note however, that the rate of "good" users increases varies depending on the notoriety of the source account outside of India. To ensure good coverage for user collection, a wide variety of source users was chosen including rival politicians, musicians, sportspersons, film stars, journalists and entrepreneurs.
Tweet collection for Humanitas occurred in two main waves. In the first wave 180 000 users identifiers were collected. This amounted to 110 million tweets, collected over about three days, totalling 288GB of information (note a tweet response comprises the textual content as well as a substantial amount of meta data). In second wave of collection we encountered the effect of diminishing returns as many of the newly harvested users had already featured in the first wave. Despite a lengthier collection effort, only 110 000 new users were collected, leading to 70 million additional tweets and a grand total for the two waves of about 500GB of data. Future collection work for Humanitas would benefit from a more sophisticated approach to collecting users (phase 1), for example, by constructing a Twitter user graph.
\begin{figure}
\includegraphics[width=.7\textwidth]{./img/CollectionProcess.pdf}
\caption{Tweet collection methodology.}
\label{fig:methodology}
\end{figure}
\subsubsection*{Approach 2: Filtering tweets provided by webarchive.org \footnotesize\emph{Gabriel Grill}}
Before we were sure to get tweets from the twitter APIs we explored a set of archive files made available on \href{https://archive.org/details/twitterstream}{archive.org}. These archives were recorded via the twitter Streaming API and aggregated by month.
They contain contain 1\% of all tweets from 2011 to 2013 (not only India!). The collection of tweets was done via a python script which was executed on all 8 Azure nodes in parallel. Beforehand the respective archives were downloaded to the nodes with a download speed of approx. 20 MB/s. The storage was to our surprise no problem, because every Azure node gets 133 GB of temporal storage for disposal. About 550 GB of compressed tweets were processed and filtered in about 36 hours per node.
\newline
The applied filter got rid of tweets not containing at least one food commodity specific word (e.g. rice, curry, food, ...) and one predictive word (e.g. increase, decrease, price, ...). Also Retweets were filtered out, because sophisticated duplicate detection across 8 nodes can be costly and some exploration of the data showed that almost all duplicates were filtered out with this simple check. Since we want to predict food prices for certain regions, the location of the tweets is very important. We came up with a simple scheme to detect locations:
\begin{itemize}
\item \textbf{Geo-location:} Some tweet objects contain a field 'coords' which states the exact location coordinates the tweet was sent from.
\item \textbf{Mentioned regions:} In the associated tweet text regions can be mentioned, which can also give clues on the regions affected.
\item \textbf{Places:} When submitting a tweet an user can also specify a place associated with the tweet. This information can be extracted from the tweet objects.
\item \textbf{User location:} Most tweets objects also have an associated user object, which contains a user location sometimes. The textual information of this field is tokenized and compared with a list of known regions.
\end{itemize}
According to the categories mentioned above, the tweets were split up in several files. Since the \emph{Approach 1.} conveyed much more tweets, the archive sample was only used for data exploration and testing of the more refined tweet processing.
\subsubsection*{Daily tweet aggregator}
Our first idea was to build a continuously running process, which fetches the newest data from the twitter stream from India. But after applying a simple filter, we came to the conclusion that the data is to sparse for this approach, since the 'Twitter Streaming API' supplies only 1\% of all available tweets. Since the amount of twitter users in India is rapidly growing, this could be a promising approach for the future.
\subsubsection*{Clustering according to keywords}
Since relevant data was really sparse, we didn't expect much gain from any unsupervised learning techniques and decided to omit clustering. Instead we decided to manually explore a sample of the tweet data and create a list of indicator words used for detecting e.g. poverty, price in/decrease, sentiment and so on. Doing occurrence checks for all crafted words and storing the result, yields feature vectors for every tweet usable for prediction.
\subsubsection*{Issue of storage}
At first we believed that there wouldn't be enough space to store all tweets, but after setting up an azure node, we found that there is about 133 GB of temporal storage associated with it. We used this space to store the huge amount of tweets, but since the storage is temporal we lost tweets several times. This was due to configuration mistakes by us and Azure's 'healing'. When Azure detects anomalies, internal errors or just that it has to move images around, affected nodes are restarted, which results in a loss of tweets for us. Because of that, all filtered tweets were later stored on the main disk to avoid future losses.
\subsection*{Issue of localization}
It's was very important for us to detect the location of tweets, because we wanted to predict volatile food prices at regional granularity. Since Twitter is not widespread in India and localized tweets are rare, we had to come up with heuristics to deal with that.
\subsubsection*{Geolocalized tweets}
Filtering the available archives of tweets taken from the API yielded near to no geolocalized tweets from India matching our set of keywords. The reason is evident, because the twitter API only allows extraction of 1\% of tweets and only 2\% of tweets are actually geolocalized. In effect, getting tweets that match our keywords specific to food commodities is very unlikely. We had more luck with tweets from Indonesia, however as already explained we were unable to attain enough price sequences from Indonesia to actually train a model. Furthermore, the time constraints didn't allow us to get tweets from India and Indonesia in parallel in order to do some "stand-alone" clustering analysis.
\subsubsection*{Approximation: Mapping tweets to user location}
To get as many tweets as possible associated with a location we decided to use the locations of user accounts as a simple heuristic. We created a mapping between city and region names and used to to identify valid locations, which were then used during later processing.
\section*{Processing}
After all tweets were collected, we had to process and reformat their content for the neural networks (prediction) and the web visualisation.
\subsection*{Crafting indicators from tweets \footnotesize\emph{Gabriel Grill}}
To use the collected tweets for prediction in the neural network, aggregated indicators had to be extracted from the collection. The final result of this processing was then stored in \emph{csv} files.\\
Every word occurrence check (either for filtering or feature extraction) in tweet texts was done by iterating over the list of tokens generated from the text. Several NLP techniques were used to improve the word comparison. For every tweet a category/indicator counter was kept to keep track of the number of occurrence of certain predictive words. The processed tweets and their extracted features (indicator counts) were stored in a Cassandra cluster and later queried with Shark. The result of the shark queries was then converted to \emph{csv} files.
\subsubsection*{Sentiment analysis \footnotesize\emph{Anton Ovchinnikov}}
Sentiment analysis, or opinion mining, is the concept of using different computer science techniques (mainly machine learning and natural language processing) in order to extract sentiment information and subjective opinions from the data. In our context this may help us to find out how circumstances in relation to commodity prices affect the overall mood in the population.
From the start we decided that we did not want to build our own sentiment analysis system since the proper implementation, testing and evaluation would require a considerable effort compared with the total project workload. Instead, we are planning to use some of already developed solutions and tune them to our needs.
\newline \newline
Several sentiment analysis frameworks were tested, including:
\begin{itemize}
\item SentiStrength \par (http://sentistrength.wlv.ac.uk/)
\item Stanford CoreNLP \par (http://nlp.stanford.edu/sentiment/code.html)
\item 'Pattern' library from the University of Antwerp \par (http://www.clips.ua.ac.be/pages/pattern-en)
\end{itemize}
All of these software packages produced reasonable results on some short and simple sentences, but sentiment grades looked almost random on a set of real collected tweets. Most likely, factors such as misspelled words, acronyms, usage of slang and irony contributed to the overall ambiguity of sentiment grades assignment.
\newline \newline
Therefore, we decided to build and use our own simple system, which incorporated basic natural language processing and opinion mining techniques, but was mainly focused on extracting relevant keywords, which could help to estimate tweets from the specific point of view. This approach, which also takes into account issues originating from word misspelling, is described in next two paragraphs.
\subsubsection*{Extracting predictor categories \footnotesize\emph{Anton Ovchinnikov}}
First, several "predictor categories" were selected. These categories represent different aspects of price variation, and each category includes several sets of words of different polarities. For example, the category \emph{"price"} has two polarities: \emph{"high"} and \emph{"low"}.
\\
The following word list belongs to \emph{"high"} polarity:
\emph{'high', 'expensive', 'costly', 'pricey', 'overpriced'},
\\
and these are words from \emph{"low"} list:
\emph{'low', 'low-cost', 'cheap', 'low-budget', 'dirt-cheap', 'bargain'}.
\\ \\
Likewise, a category "supply" has "high" polarity:
\emph{'available', 'full', 'enough', 'sustain', 'access', 'convenient'},
\\
and "low":
\emph{'run-out', 'empty', 'depleted', 'rotting'}.
\\ \\ \\
The dictionary with a total of 6 categories (each having at least two polarity word lists) was built (\emph{"predict", "price", "sentiment", "poverty", "needs", "supply"}), let's call it $D$.
\\ \\
Then, for each tweet a feature vector is built, representing the amount of words from each category and polarity. Several cases have to be taken into account. First of all, a word may be not in its base form ("price" -> "prices", "increase" -> "increasing"), which will prevent an incoming word from matching one from $D$. Therefore, we use stemming technique to reduce each word to its stem (or root) form. Another problem is misspelled words ("increase" -> "incrase", "incraese"), and for tweets it happens more than usual due to widespread use of mobile devices with tiny keyboards. Our solution to this problem is covered in the next section.
Here is the overview of predictor category extraction algorithms we implemented:\\ \\
\textbf{Preprocessing}: For each relevant word in $D$ a stem is computed using the Lancaster stemming method, and the stem is added to reverse index $RI$, which maps a stem to a tuple: (category, polarity). \\
\textbf{function get\_category(w):}
\indent
\begin{algorithm}[H]
Compute a stem $s$ from $w$ \par
Check if $s$ is present in $RI$.
\eIf{yes}{
\textbf{return} the corresponding tuple.
}{
ask spell checker for a suggestion \par
is suggestion stem returned? \par
\eIf{yes}{
\textbf{return} the corresponding tuple from $RI$
}{
\textbf{return} None;
}
}
% \caption{Algo}
\end{algorithm}
\noindent \\
On a high level, every tweet is split into words, and then each word (token) is passed through 'get\_category' function. But here's another problem we face using this approach: each relevant word we encounter may have a negation word (particle) before it, which subverts the meaning: "increases" -> "doesn't increase", "have food" -> "have no food", etc. To deal with this problem, we employed the following method: we added a special 'negation' category with a list of negation words ("not", "haven't", "won't", etc.), and if there is a word with "negative" category before some relative word (to be more precise, within some constant distance from it, say 2), then we change the polarity of relative word's category. For example, if a word is from category "poverty" and has "high" polarity (like "starving"), then negative category word right before it (such as "aren't") will turn the polarity to "low".
\subsubsection*{Tweets spell checking \footnotesize\emph{Anton Ovchinnikov}}
People often do not pay much attention about the proper word spelling while communicating over the Internet and using social networks, but misspelled words may introduce mistakes in processing pipeline and significantly reduce the amount of filtered tweets, since the relevant, but incorrectly written word might not be recognized by the algorithm.
Several spell checking libraries were checked (Aspell and Enchant to name a few), but their 'suggest' method lacked both performance (several seconds to generate a suggestion for thousands words, which is very slow) and flexibility (it's not possible to specify the number of generated suggestions, as well as a threshold, such as maximal edit distance between words). Therefore, we decided to use a simple approach which involved computing edit distances between a given word and words from predictor categories dictionary ($D$).
\\
For each given word $w$ we compute its stem $s$ and then edit distance (also known as Levenshtein distance) to each word (stem) from $D$. It can be done really fast thanks to C extensions of \textit{python-levenshtein} module.
\\
After that, we choose the stem with minimal edit distance (using heap to store the correspondence between distances and words and to speed up selection of the minimal one), and check if the resulting number of "errors" (which is equal to distance) is excusable for the length of word $w$. For example, we don't allow errors for words of length 5 or less, only one error is allowed for lengths from 6 to 8, etc. If everything is alright, then the suggestion is returned, otherwise the word is discarded.
The approach proved to be fast and tweakable, and was successfully used for tweets processing.
\subsection*{Generation of time series \footnotesize\emph{Gabriel Grill}}
All these indicators are crafted into a single time series of the form \emph{'Product', 'date', 'region', 'indicator1', ... , 'indicatorN'} via Shark queries. These indicators represent the amount of tweets matching a certain predictive category (as mentioned previously) normalized by the total amount of tweets mentioning the product that day. If a tweet is part of multiple categories, it's not clear what the intention behind the tweet was. That's why, as heuristic, we divide the sum of mentions of each predictive category by the total amount of identified mentioned categories for that tweet. We have a script to generate queries for all products and a script to parse the output into \emph{csv} format. The figure \ref{fig:architecture} illustrates the whole processing pipeline and gives a good overview of the architecture at the same time as well.
\begin{figure}
\includegraphics[width=.7\textwidth]{./img/architecture.png}
\caption{Tweet processing pipeline.}
\label{fig:architecture}
\end{figure}
\subsection*{Infrastructure \& Architecture \footnotesize\emph{Gabriel Grill}}
Almost all downloading and processing of tweets was done in parallel on 8 Azure nodes. A script was written to upload public keys to the nodes for seamless access. The same script was used to execute various task on all or specific nodes. To handle the huge amounts of data and do efficient OLAP, we decided to use spark/shark. The data was first stored on each node separately on disk, then processed and afterwards inserted into a Cassandra DB cluster running on the nodes. The Apache Cassandra project is open source implementation of a NoSQL, column-oriented data base. It's known for being fault tolerant, which was very useful during various restarts, and processing many inserts fast. Since we had very limited memory on the non-temporal disk, we experienced 'Out of memory' errors, but because all data has been uploaded to the whole cluster, the scripts could continue running smoothly although some nodes were down. We also experienced node faults whenever the Azure node management 'healed' nodes.
Setting up the Cassandra cluster across multiple Azure subscriptions was tiring, since all used ports had to be opened on all machines manually via the Azure management web interface. Opening ports was regretfully not enough to get a fully functioning Spark cluster running, because Spark uses random ports for communication between running jobs. We tried setting up a VPN, but decided to quit after several hours due to time constraints and because it was not essential for the result that the Spark cluster had to be made up of all nodes. Luckily Shark on top of Spark with only one node was still fully functional and executed queries at reasonable speed. To connect Shark with Cassandra we used the 'Hive support for Cassandra' driver \emph{cash} by tuplejump. We experienced several problems (some undocumented) while installing (e.g. libraries missing, wrong paths, ...), but still managed to get it running. To improve speed between the nodes all VMs were created in the same region.
|
(*
chronos@localhost / $ sudo enter-chroot
Entering /mnt/stateful_partition/crouton/chroots/precise...
(precise)administrator@localhost:~$ coqtop
Welcome to Coq 8.3pl4 (April 2012)
Coq < Section Exercise_Nine.
Coq < Goal forall b f a g e k h:Prop, (((b \/ f) -> (a -> g)) /\ ((b \/ e) -> (g -> k)) /\ (b /\ ~h)) -> (a -> k).
1 subgoal
============================
forall b f a g e k h : Prop,
(b \/ f -> a -> g) /\ (b \/ e -> g -> k) /\ b /\ ~ h -> a -> k
Unnamed_thm < intros.
1 subgoal
b : Prop
f : Prop
a : Prop
g : Prop
e : Prop
k : Prop
h : Prop
H : (b \/ f -> a -> g) /\ (b \/ e -> g -> k) /\ b /\ ~ h
H0 : a
============================
k
Unnamed_thm < elim H.
1 subgoal
b : Prop
f : Prop
a : Prop
g : Prop
e : Prop
k : Prop
h : Prop
H : (b \/ f -> a -> g) /\ (b \/ e -> g -> k) /\ b /\ ~ h
H0 : a
============================
(b \/ f -> a -> g) -> (b \/ e -> g -> k) /\ b /\ ~ h -> k
Unnamed_thm < intro.
1 subgoal
b : Prop
f : Prop
a : Prop
g : Prop
e : Prop
k : Prop
h : Prop
H : (b \/ f -> a -> g) /\ (b \/ e -> g -> k) /\ b /\ ~ h
H0 : a
H1 : b \/ f -> a -> g
============================
(b \/ e -> g -> k) /\ b /\ ~ h -> k
Unnamed_thm < intro.
1 subgoal
b : Prop
f : Prop
a : Prop
g : Prop
e : Prop
k : Prop
h : Prop
H : (b \/ f -> a -> g) /\ (b \/ e -> g -> k) /\ b /\ ~ h
H0 : a
H1 : b \/ f -> a -> g
H2 : (b \/ e -> g -> k) /\ b /\ ~ h
============================
k
Unnamed_thm < firstorder.
Proof completed.
Unnamed_thm < Qed.
intros.
elim H.
intro.
intro.
firstorder .
Unnamed_thm is defined
Coq <
*)
Section Exercise_Nine.
Goal forall b f a g e k h:Prop, (((b \/ f) -> (a -> g)) /\ ((b \/ e) -> (g -> k)) /\ (b /\ ~h)) -> (a -> k).
intros.
elim H.
intro.
intro.
firstorder.
Qed.
|
# =================================#
# Dictionaries store mappings #
# key => value pairs #
# key is indexed and unique #
# =================================#
d = Dict()
# append elements
d['a']=1; d['b']=4; d['c']=8
println("d = ",d)
# Create a dictionary using a literal
numbers = Dict( "one" => 1,
"two" => 2,
"three" => 3)
println("numbers = ", numbers)
# Access elements
println("first =", numbers["one"])
println("last =", numbers["three"]) |
(* Title: Jive Data and Store Model
Author: Norbert Schirmer <schirmer at informatik.tu-muenchen.de> and
Nicole Rauch <rauch at informatik.uni-kl.de>, 2005
Maintainer: Nicole Rauch <rauch at informatik.uni-kl.de>
License: LGPL
*)
section \<open>Program-Independent Lemmas on Attributes\<close>
theory AttributesIndep
imports "../Isa_Counter_Store/Attributes"
begin
text \<open>The following lemmas validate the functions defined in the Attributes theory.
They also aid in subsequent proving tasks. Since they are
program-independent, it is of no use to add them to the generation process of
Attributes.thy. Therefore, they have been extracted to this theory.
\<close>
lemma cls_catt [simp]:
"CClassT c \<le> dtype f \<Longrightarrow> cls (catt c f) = c"
apply (case_tac c)
apply (case_tac [!] f)
apply simp_all
\<comment> \<open>solves all goals where @{text "CClassT c \<le> dtype f"}\<close>
apply (fastforce elim: subtype_wrong_elims simp add: subtype_defs)+
\<comment> \<open>solves all the rest where @{text "\<not> CClassT c \<le> dtype f"} can be derived\<close>
done
lemma att_catt [simp]:
"CClassT c \<le> dtype f \<Longrightarrow> att (catt c f) = f"
apply (case_tac c)
apply (case_tac [!] f)
apply simp_all
\<comment> \<open>solves all goals where @{text "CClassT c \<le> dtype f"}\<close>
apply (fastforce elim: subtype_wrong_elims simp add: subtype_defs)+
\<comment> \<open>solves all the rest where @{text "\<not> CClassT c \<le> dtype f"} can be
derived\<close>
done
text \<open>The following lemmas are just a demonstration of simplification.\<close>
lemma rtype_att_catt:
"CClassT c \<le> dtype f \<Longrightarrow> rtype (att (catt c f)) = rtype f"
by simp
lemma widen_cls_dtype_att [simp,intro]:
"(CClassT (cls cf) \<le> dtype (att cf)) "
by (cases cf, simp_all)
end
|
\documentclass{article}
\usepackage{fullpage}
\usepackage{nopageno}
\usepackage{amsmath}
\usepackage{MnSymbol}
\allowdisplaybreaks
\newcommand{\abs}[1]{\left\lvert #1 \right\rvert}
\newcommand{\degree}{\ensuremath{^\circ}}
\begin{document}
Jon Allen
January 29, 2014
\section*{1}
For each of the four subsets of the two properties (a) and (b), count the number of four-digit numbers whose digits are either 1,2,3,4, or 5:
(a) The digits are distinct. (b) The number is even.
\subsection*{$\emptyset$}
By the multiplication principle there are $5^4$ four-digit numbers, or 625.
\subsection*{a}
Every choice we make reduces the number of choices for the next choice by one. So if we have $n$ options, and have to choose $r$ times then by the multiplication principle we have $n\cdot(n-1)\cdot...\cdot(n-r+1)=\frac{n!}{(n-r)!}$ and then our answer is $\frac{5!}{1!}=5!=120$
\subsection*{b}
Another way of saying this is how many ways can you make an ordered pair of three-digit numbers and a number $\in\{2,4\}$? By the multiplication principle $5^3\cdot2=250$
\subsection*{a and b}
So for our units digit we have 2 or 4 for choices. For our thousands we have 4 choices left, then 3 for our hundreds, 2 for our tens. So by the multiplication principle $2\cdot4\cdot3\cdot2=48$
\section*{2}
We can order the cards of each suite in $(52/4)!$ ways. We can order the suites in $4!$ ways. So we can order a deck with all the cards of the same suite together in $13!4!=149448499200$ ways.
\section*{11}
There are ${20 \choose 3}=\frac{20!}{3!17!}$ different 3 element subsets of $\{1,...,20\}$. There are 18 subsets that contain 3 consecutive numbers. There are 17 subsets that contain 1 and 2 but not 3, and the same for 19 and 20 but not 18. There are $19-2$ pairs of consecutive digits left and each of these pairs has 16 choices for the last element of the set. So subtracting all these from the total we have $\frac{20!}{17!3!}-18-2\cdot17-17\cdot16=816$
\section*{17}
Since the number of rooks is the same as the number of rows and columns, we can just say that each column gets a rook and only worry about counting the different ways we can put them into the rows. Since each time you place a rook you remove an available row. So we have $6!=720$ ways of placing the rooks. Now we color them. Say the first rook is red, then any of the remaining 5 can also be red. If the second rook is red we have 4 that can be red left. And so on giving us $720\cdot(5+4+3+2+1)=15\cdot720=10800$ ways to place the colored rooks.
\section*{18}
Let us choose 6 columns and 6 rows from the 8 where the rooks will be placed. That gives us ${8 \choose 6}^2=(\frac{8!}{2!6!})^2=28^2=784$ row and column combinations to put the rooks down. We already know from the previous problem that there are 10800 ways to put these rooks down into these 784 different rows and columns so we have $784*10800=8467200$ ways to place these rooks.
\section*{20}
Fixing 0 in place there are $9!$ circular permutations of the set. If we then also fix the 9 in place we have $8!$ permutations. So the number of circular permutations where they are not opposite is $9!-8!=322560$.
\section*{26}
Pretty straighforward application of Theorem 2.4.3. $\frac{(mn)!}{m\cdot n!}$ if the teams have names. $\frac{(mn)!}{m\cdot m!n!}$ if the teams are not named.
\section*{29}
We observe that the size of $S$ is $n_1+n_2+\cdots+n_k=n_1+n=n+1$. Applying Theorem 2.4.2 we see that the number of linear permutations of $S$ is $\frac{(n+1)!}{n_1!n_2!\cdots n_k!}$. Now let's partition the linear permutations into parts so that two linear permutations of $S$ correspond to the same circular permutation of $S$ if and only if they are in the same part. Then the number of parts will be the number of circular permutations. We also notice that each part will contain $n+1$ linear permutations. So the number of permutations is:
\[\frac{\frac{(n+1)!}{n_1!n_2!\cdots n_k!}}{n+1}=\frac{(n+1)n!}{(n+1)\cdot 1\cdot n_2!\cdots n_k!}=\frac{n!}{n_1!\cdots n_k!}\]
And we have our result.$\Box$
\section*{31}
First we have a 3-permutation of the winners. Each of these permutations can be paired with any of the 3 combinations of the remaining 12 teams. Our answer then is $P(15,3){12 \choose 3}=\frac{15!}{12!}\cdot\frac{12!}{3!9!}=\frac{15!}{3!9!}=600600$
\section*{36}
For each type $i$ we can have $n_i+1$ different repetition numbers in the submultiset. We add one to account for not having any of type $i$ in the submultiset. By the multiplication principal then the number of submultisets is $(n_1+1)(n_2+1)\dots(n_k+1)$.
\section*{38}
\begin{align*}
30&=x_1+x_2+x_3+x_4\\
y_1&=x_1-2, y_2=x_2, y_3=x_3+5, y_4=x_4-8\\
25&=x_1+x_2+x_3+x_4\\
\end{align*}
And by Theorem 2.5.1 the number of solutions are ${25+4-1 \choose 25}=\frac{28!}{25!3!}=3276$
\section*{45}
\subsection*{a}
Think of this as a 20 combination of a set with 5 types and infinite repetition. So by theorem 2.5.1 we have ${20+5-1 \choose 20}=\frac{24!}{20!4!}=10626$
\subsection*{b}
Lets imagine we assign a number to each book, according to the shelf it goes on. Then the number of ways we can put the books on each shelf is the number of permutations of length 20 of the numbers 1-5 which is $5^{20}=95367431640625$
\subsection*{c}
We can order the books in $21!$ different ways. Lets imagine the books are stacked up and we need to slot the five shelves into the 21 spaces between the books and at the ends of the books. Since the books are all on shelves we know that the fifth shelf is at the 21st slot. We also can have empty shelves so any shelf can occupy the same slot as any other shelf. So we need to find how many 4 combinations of 21 items with repetition or ${4+21-1 \choose 4}$ and by the multiplication principle we have $21!\frac{24!}{4!20!}=542892351516584509440000$
\section*{50}
What we really need to do is figure out how many ways we can place 2 non-attacking rooks on the board. This will constrain the next two rooks to only one possibility. Then pick any one of the last 60 spots for the fifth rook. So for the first two rooks placement we have ${8 \choose 2}$ ways of choosing both the rows and the columns and then we have $2!$ ways of placing the rooks into the rows and columns. But then we will have duplicates after placing the next two rooks, so eliminate duplicate by only placing the first two in $2!/2=1$ ways. And putting it all together with the multiplication principal we have ${8 \choose 2}^2\cdot60=1680$
\section*{55}
\subsection*{a}
TRISKAIDEKAPHOBIA rearranged to make counting easier AAABDEHIIIKKOPRST. And just copy the MISSISSIPPI example to get $\frac{17!}{3!1!1!1!1!3!2!1!1!1!1!1!}=\frac{17!}{3!3!2!}=4940103168000$
\subsection*{b}
FLOCCINAUCINIHILIPILIFICATION rearranged to make counting easier AACCCCFFHIIIIIIIIILLLNNNOOPTU and $\frac{29!}{2!4!2!9!3!3!2!}=3525105002372553600000$
\subsection*{c}
PNEUMONOULTRAMICROSCOPICSILICOVOLCANOCONIOSIS rearranged to make counting easier AACCCCCCEIIIIIILLLMMNNNNOOOOOOOOOPPRRSSSSTUUV and $\frac{45!}{2!6!1!6!3!2!4!9!2!2!4!1!2!1!}=\frac{45!}{2!^56!^23!4!^29!}=5749897770076560698733077346243840000000$
\subsection*{d}
DERMATOGLYPHICS rearranged to make counting easier ACDEGHIOLMPRSTY and there are no duplicate letters so it's just the number of permutations of 15 digits which is $15!=1307674368000$
\end{document}
|
[STATEMENT]
lemma hermitean_eye [simp]:
shows "hermitean eye"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. hermitean eye
[PROOF STEP]
by (auto simp add: hermitean_def mat_adj_def mat_cnj_def) |
Our deepest sympathy is extended to the family of Evione Wright, who recently passed away.
She was the daughter of the late Otha and Willie Martin.
She was the mother of several children and had 18 grandchildren and 24 great-grandchildren.
Her service was held last Saturday at Evans Mortuary. The Rev. Alvin Douglass officiated.
Our sincere sympathy to the family and friends in the passing of Marlvin H. Bolton, who passed away last week.
He was born in Atlanta to the late Rev. James and Emma Bolton. |
import mynat.definition
import mynat.add
namespace mynat
theorem add_right_cancel (a t b : mynat) : a + t = b + t → a = b :=
begin [nat_num_game]
induction t with n hd,
{
rw add_zero,
rw add_zero,
intro h,
exact h,
},
{
rw add_succ,
rw add_succ,
intro h,
apply hd,
apply succ_inj,
exact h,
},
end
end mynat |
This year, B&Y took home three gold awards at the oldest, largest and most widely respected healthcare advertising awards competition. Our big winners included our Parkview “GO: Make a Difference” campaign, our PPG “More Than A Doctor” campaign and our Parkview “GO: Laugh” outdoor.
We also snagged four additional awards for other work for Parkview Health. All winning pieces were chosen based on creativity, quality, message effectiveness, consumer appeal, graphic design and overall impact.
Congrats, Parkview! And thank you to all of our clients and partners for trusting B&Y. |
[STATEMENT]
theorem invpst_mkNode[simp]: "invpst (mkNode c l a r) \<longleftrightarrow> invpst l \<and> invpst r"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. invpst (mkNode c l a r) = (invpst l \<and> invpst r)
[PROOF STEP]
apply (cases l rule: invpst.cases;
cases r rule: invpst.cases;
simp add: mkNode_def min_kp_def)
[PROOF STATE]
proof (prove)
goal (3 subgoals):
1. \<And>la x uu_ mkp ra. \<lbrakk>l = \<langle>\<rangle>; r = \<langle>la, (x, uu_, mkp), ra\<rangle>\<rbrakk> \<Longrightarrow> (invpst la \<and> invpst ra \<and> is_min2 mkp (insert x (Tree2.set_tree la \<union> Tree2.set_tree ra)) \<and> is_min2 (min2 a mkp) (insert a (insert x (Tree2.set_tree la \<union> Tree2.set_tree ra)))) = (invpst la \<and> invpst ra \<and> is_min2 mkp (insert x (Tree2.set_tree la \<union> Tree2.set_tree ra)))
2. \<And>la x uu_ mkp ra. \<lbrakk>l = \<langle>la, (x, uu_, mkp), ra\<rangle>; r = \<langle>\<rangle>\<rbrakk> \<Longrightarrow> (invpst la \<and> invpst ra \<and> is_min2 mkp (insert x (Tree2.set_tree la \<union> Tree2.set_tree ra)) \<and> is_min2 (min2 a mkp) (insert x (insert a (Tree2.set_tree la \<union> Tree2.set_tree ra)))) = (invpst la \<and> invpst ra \<and> is_min2 mkp (insert x (Tree2.set_tree la \<union> Tree2.set_tree ra)))
3. \<And>la x uu_ mkp ra laa xa uua_ mkpa raa. \<lbrakk>l = \<langle>la, (x, uu_, mkp), ra\<rangle>; r = \<langle>laa, (xa, uua_, mkpa), raa\<rangle>\<rbrakk> \<Longrightarrow> (invpst la \<and> invpst ra \<and> is_min2 mkp (insert x (Tree2.set_tree la \<union> Tree2.set_tree ra)) \<and> invpst laa \<and> invpst raa \<and> is_min2 mkpa (insert xa (Tree2.set_tree laa \<union> Tree2.set_tree raa)) \<and> is_min2 (min2 a (min2 mkp mkpa)) (insert x (insert a (insert xa (Tree2.set_tree la \<union> (Tree2.set_tree ra \<union> (Tree2.set_tree laa \<union> Tree2.set_tree raa))))))) = (invpst la \<and> invpst ra \<and> is_min2 mkp (insert x (Tree2.set_tree la \<union> Tree2.set_tree ra)) \<and> invpst laa \<and> invpst raa \<and> is_min2 mkpa (insert xa (Tree2.set_tree laa \<union> Tree2.set_tree raa)))
[PROOF STEP]
subgoal
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<lbrakk>l = \<langle>\<rangle>; r = \<langle>la_, (x_, uu_, mkp_), ra_\<rangle>\<rbrakk> \<Longrightarrow> (invpst la_ \<and> invpst ra_ \<and> is_min2 mkp_ (insert x_ (Tree2.set_tree la_ \<union> Tree2.set_tree ra_)) \<and> is_min2 (min2 a mkp_) (insert a (insert x_ (Tree2.set_tree la_ \<union> Tree2.set_tree ra_)))) = (invpst la_ \<and> invpst ra_ \<and> is_min2 mkp_ (insert x_ (Tree2.set_tree la_ \<union> Tree2.set_tree ra_)))
[PROOF STEP]
using is_min2_min2_insI
[PROOF STATE]
proof (prove)
using this:
is_min2 ?y ?ys \<Longrightarrow> is_min2 (min2 ?x ?y) (insert ?x ?ys)
goal (1 subgoal):
1. \<lbrakk>l = \<langle>\<rangle>; r = \<langle>la_, (x_, uu_, mkp_), ra_\<rangle>\<rbrakk> \<Longrightarrow> (invpst la_ \<and> invpst ra_ \<and> is_min2 mkp_ (insert x_ (Tree2.set_tree la_ \<union> Tree2.set_tree ra_)) \<and> is_min2 (min2 a mkp_) (insert a (insert x_ (Tree2.set_tree la_ \<union> Tree2.set_tree ra_)))) = (invpst la_ \<and> invpst ra_ \<and> is_min2 mkp_ (insert x_ (Tree2.set_tree la_ \<union> Tree2.set_tree ra_)))
[PROOF STEP]
by blast
[PROOF STATE]
proof (prove)
goal (2 subgoals):
1. \<And>la x uu_ mkp ra. \<lbrakk>l = \<langle>la, (x, uu_, mkp), ra\<rangle>; r = \<langle>\<rangle>\<rbrakk> \<Longrightarrow> (invpst la \<and> invpst ra \<and> is_min2 mkp (insert x (Tree2.set_tree la \<union> Tree2.set_tree ra)) \<and> is_min2 (min2 a mkp) (insert x (insert a (Tree2.set_tree la \<union> Tree2.set_tree ra)))) = (invpst la \<and> invpst ra \<and> is_min2 mkp (insert x (Tree2.set_tree la \<union> Tree2.set_tree ra)))
2. \<And>la x uu_ mkp ra laa xa uua_ mkpa raa. \<lbrakk>l = \<langle>la, (x, uu_, mkp), ra\<rangle>; r = \<langle>laa, (xa, uua_, mkpa), raa\<rangle>\<rbrakk> \<Longrightarrow> (invpst la \<and> invpst ra \<and> is_min2 mkp (insert x (Tree2.set_tree la \<union> Tree2.set_tree ra)) \<and> invpst laa \<and> invpst raa \<and> is_min2 mkpa (insert xa (Tree2.set_tree laa \<union> Tree2.set_tree raa)) \<and> is_min2 (min2 a (min2 mkp mkpa)) (insert x (insert a (insert xa (Tree2.set_tree la \<union> (Tree2.set_tree ra \<union> (Tree2.set_tree laa \<union> Tree2.set_tree raa))))))) = (invpst la \<and> invpst ra \<and> is_min2 mkp (insert x (Tree2.set_tree la \<union> Tree2.set_tree ra)) \<and> invpst laa \<and> invpst raa \<and> is_min2 mkpa (insert xa (Tree2.set_tree laa \<union> Tree2.set_tree raa)))
[PROOF STEP]
subgoal
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<lbrakk>l = \<langle>la_, (x_, uu_, mkp_), ra_\<rangle>; r = \<langle>\<rangle>\<rbrakk> \<Longrightarrow> (invpst la_ \<and> invpst ra_ \<and> is_min2 mkp_ (insert x_ (Tree2.set_tree la_ \<union> Tree2.set_tree ra_)) \<and> is_min2 (min2 a mkp_) (insert x_ (insert a (Tree2.set_tree la_ \<union> Tree2.set_tree ra_)))) = (invpst la_ \<and> invpst ra_ \<and> is_min2 mkp_ (insert x_ (Tree2.set_tree la_ \<union> Tree2.set_tree ra_)))
[PROOF STEP]
by (auto intro!: is_min2_min2_insI simp: insert_commute)
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<And>la x uu_ mkp ra laa xa uua_ mkpa raa. \<lbrakk>l = \<langle>la, (x, uu_, mkp), ra\<rangle>; r = \<langle>laa, (xa, uua_, mkpa), raa\<rangle>\<rbrakk> \<Longrightarrow> (invpst la \<and> invpst ra \<and> is_min2 mkp (insert x (Tree2.set_tree la \<union> Tree2.set_tree ra)) \<and> invpst laa \<and> invpst raa \<and> is_min2 mkpa (insert xa (Tree2.set_tree laa \<union> Tree2.set_tree raa)) \<and> is_min2 (min2 a (min2 mkp mkpa)) (insert x (insert a (insert xa (Tree2.set_tree la \<union> (Tree2.set_tree ra \<union> (Tree2.set_tree laa \<union> Tree2.set_tree raa))))))) = (invpst la \<and> invpst ra \<and> is_min2 mkp (insert x (Tree2.set_tree la \<union> Tree2.set_tree ra)) \<and> invpst laa \<and> invpst raa \<and> is_min2 mkpa (insert xa (Tree2.set_tree laa \<union> Tree2.set_tree raa)))
[PROOF STEP]
subgoal
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<lbrakk>l = \<langle>la_, (x_, uu_, mkp_), ra_\<rangle>; r = \<langle>laa_, (xa_, uua_, mkpa_), raa_\<rangle>\<rbrakk> \<Longrightarrow> (invpst la_ \<and> invpst ra_ \<and> is_min2 mkp_ (insert x_ (Tree2.set_tree la_ \<union> Tree2.set_tree ra_)) \<and> invpst laa_ \<and> invpst raa_ \<and> is_min2 mkpa_ (insert xa_ (Tree2.set_tree laa_ \<union> Tree2.set_tree raa_)) \<and> is_min2 (min2 a (min2 mkp_ mkpa_)) (insert x_ (insert a (insert xa_ (Tree2.set_tree la_ \<union> (Tree2.set_tree ra_ \<union> (Tree2.set_tree laa_ \<union> Tree2.set_tree raa_))))))) = (invpst la_ \<and> invpst ra_ \<and> is_min2 mkp_ (insert x_ (Tree2.set_tree la_ \<union> Tree2.set_tree ra_)) \<and> invpst laa_ \<and> invpst raa_ \<and> is_min2 mkpa_ (insert xa_ (Tree2.set_tree laa_ \<union> Tree2.set_tree raa_)))
[PROOF STEP]
by (smt Un_insert_left Un_insert_right is_min2_mergeI is_min2_min2_insI
sup_assoc)
[PROOF STATE]
proof (prove)
goal:
No subgoals!
[PROOF STEP]
done |
function rgb_display ( rgb, header )
%*****************************************************************************80
%
%% RGB_DISPLAY displays an RGB dataset.
%
% Licensing:
%
% This code is distributed under the GNU LGPL license.
%
% Modified:
%
% 09 August 2013
%
% Author:
%
% John Burkardt
%
% Reference:
%
% Nick Berry,
% A "Practical" Use for Genetic Programming,
% http://www.datagenetics.com/blog.html
%
% Parameters:
%
% Input, uint8 RGB(256,256,3), the RGB information.
%
% Input, string HEADER, an identifier used for the title and filename.
%
imshow ( rgb )
title ( header, 'FontSize', 16 )
filename = sprintf ( '%s.png', header );
print ( '-dpng', filename );
return
end
|
[STATEMENT]
lemma LIMSEQ_power_zero [tendsto_intros]: "norm x < 1 \<Longrightarrow> (\<lambda>n. x ^ n) \<longlonglongrightarrow> 0"
for x :: "'a::real_normed_algebra_1"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. norm x < 1 \<Longrightarrow> (^) x \<longlonglongrightarrow> (0::'a)
[PROOF STEP]
apply (drule LIMSEQ_realpow_zero [OF norm_ge_zero])
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. (^) (norm x) \<longlonglongrightarrow> 0 \<Longrightarrow> (^) x \<longlonglongrightarrow> (0::'a)
[PROOF STEP]
by (simp add: Zfun_le norm_power_ineq tendsto_Zfun_iff) |
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE ImplicitParams #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Microbenchmark where
import Test.HUnit hiding (State)
import Test.Framework
import Test.Framework.Providers.HUnit
import System.Random
import Control.Monad.State
import Control.Monad
import Control.Lens
import GHC.Conc.Sync (setNumCapabilities)
import qualified Data.HashMap.Strict as HM
import qualified Data.HashSet as Set
import Data.List
import qualified Data.Vector as V
import Data.IORef
import Data.Time.Clock.POSIX
import Data.Aeson as AE
import Data.ByteString.Lazy as BS (writeFile)
import Kvservice_Types
import Kvstore.KVSTypes
import Requests
import TestSetup
import ServiceConfig
import Versions
import Options.Applicative
import Data.Semigroup ((<>))
import Statistics.Sample (mean)
import Debug.Trace
valueTemplate v = "value-" ++ show v
fieldTemplate f = "field-" ++ show f
keyTemplate k = "key-" ++ show k
tableTemplate t = "table-" ++ show t
data RangeGen = RangeGen Int Int StdGen
instance RandomGen RangeGen where
next (RangeGen lo hi g) = let (i,g') = randomR (lo,hi) g in (i, RangeGen lo hi g')
split (RangeGen lo hi g) = let (g1,g2) = split g in (RangeGen lo hi g1, RangeGen lo hi g2)
newtype LinearGen = LinearGen Int
instance RandomGen LinearGen where
next (LinearGen i) = (i, LinearGen $ i+1)
split (LinearGen i) = (LinearGen i, LinearGen i)
data BenchmarkState g = BenchmarkState {
_fieldCount :: Int,
_fieldSelection :: RangeGen,
_valueSizeGen :: RangeGen,
_tableCount :: Int,
_tableSelection :: RangeGen,
_keySelection :: g,
_operationSelection :: RangeGen,
_fieldCountSelection :: RangeGen,
_scanCountSelection :: RangeGen
}
makeLenses ''BenchmarkState
-- lens does not work with RankNTypes :(
createValue :: forall g. RandomGen g => StateT (BenchmarkState g) IO String
createValue = do
bmState <- get
let valSizeGenerator = view valueSizeGen bmState
(size,valSizeGenerator') = next valSizeGenerator
put $ over valueSizeGen (const valSizeGenerator') bmState
(return . concatMap valueTemplate . take size) [1,2..]
createRequest :: forall g. RandomGen g => StateT (BenchmarkState g) IO KVRequest
createRequest = do
bmState <- get
let opSelector = view operationSelection bmState
(op,opSelector') = next opSelector
bmState' = over operationSelection (const opSelector') bmState
tableSelector = view tableSelection bmState
(tableId,tableSelector') = next tableSelector
table = tableTemplate tableId
bmState'' = over tableSelection (const tableSelector') bmState'
keySelector = view keySelection bmState
(keyId,keySelector') = next keySelector
key = keyTemplate keyId
bmState''' = over keySelection (const keySelector') bmState''
put bmState'''
case op of
0 -> prepareINSERT table key <$> createINSERTEntry
1 -> prepareUPDATE table key <$> createUPDATEEntry
2 -> prepareREAD table key . Set.map fieldTemplate <$> getFields
3 -> prepareSCAN table key <$> getScanCount <*> (Set.map fieldTemplate <$> getFields)
4 -> return $ prepareDELETE table key
_ -> error $ "No such operation: " ++ show op
where
getFieldsAndValues :: forall g. RandomGen g => [Int] -> StateT (BenchmarkState g) IO (HM.HashMap String String)
getFieldsAndValues = fmap HM.fromList . mapM (\ i -> (,) <$> pure (fieldTemplate i) <*> createValue)
createINSERTEntry :: forall g. RandomGen g => StateT (BenchmarkState g) IO (HM.HashMap String String)
createINSERTEntry = getFieldsAndValues . flip take [1,2..] . view fieldCount =<< get
getFields :: forall g. RandomGen g => StateT (BenchmarkState g) IO (Set.HashSet Int)
getFields = do
s <- get
let fieldCountGen = view fieldCountSelection s
(fieldCount,fieldCountGen') = next fieldCountGen
s' = over fieldCountSelection (const fieldCountGen') s
fieldSel = view fieldSelection s'
(fieldSel', fields) = foldl (\ (sel,l) _ -> let (f,sel') = next sel in (sel',l ++ [f]) )
(fieldSel,[])
$ take fieldCount [1,2..]
s'' = over fieldSelection (const fieldSel') s'
put s''
return $ Set.fromList fields
createUPDATEEntry :: forall g. RandomGen g => StateT (BenchmarkState g) IO (HM.HashMap String String)
createUPDATEEntry = getFieldsAndValues . Set.toList =<< getFields
getScanCount = do
s <- get
let scanCountSel = view scanCountSelection s
(scanCount,scanCountSel') = next scanCountSel
put $ over scanCountSelection (const scanCountSel') s
return scanCount
workload :: forall g. RandomGen g => Int -> StateT (BenchmarkState g) IO (V.Vector KVRequest)
workload operationCount = V.fromList <$> mapM (const createRequest) [1..operationCount]
showState :: KVSState MockDB -> IO String
showState (KVSState cache dbRef _ _) = do
db <- readIORef dbRef
return $ "Cache:\n" ++ show cache ++ "\nDB:\n" ++ show db
loadDB keyCount = do
s <- initState
-- fill the db first
(requests,_) <- runStateT (workload keyCount) $ BenchmarkState
10 -- _fieldCount
(RangeGen 0 10 $ mkStdGen 0) -- _fieldSelection
(RangeGen 5 10 $ mkStdGen 0) -- _valueSizeGen
1 -- _tableCount
(RangeGen 1 1 $ mkStdGen 0) -- _tableSelection
(LinearGen 1) -- _keySelection
(RangeGen 0 0 $ mkStdGen 0) -- _operationSelection (INSERT only)
(RangeGen 3 10 $ mkStdGen 0) -- _fieldCountSelection
(RangeGen 5 10 $ mkStdGen 0) -- _scanCountSelection
-- traceM "requests (INSERT):"
-- mapM (\i -> traceM $ show i ++ "\n" ) requests
(responses, s') <- flip runStateT s $ ?execRequests requests
responses `seq` assertEqual "wrong number of responses" keyCount $ length responses
return s'
-- traceM "state after init:"
-- traceM =<< showState s'
-- traceM "done with insert."
reqBenchmarkState keyCount = BenchmarkState
10 -- _fieldCount
(RangeGen 0 10 $ mkStdGen 0) -- _fieldSelection
(RangeGen 5 10 $ mkStdGen 0) -- _valueSizeGen
1 -- _tableCount
(RangeGen 1 1 $ mkStdGen 0) -- _tableSelection
(RangeGen 1 keyCount $ mkStdGen 0) -- _keySelection
(RangeGen 1 3 $ mkStdGen 0) -- _operationSelection (no INSERT, no DELETE)
(RangeGen 3 10 $ mkStdGen 0) -- _fieldCountSelection
(RangeGen 5 10 $ mkStdGen 0) -- _scanCountSelection
currentTimeMillis = round . (* 1000) <$> getPOSIXTime
-- then run some requests
-- runRequests :: (?execRequests :: ExecReqFn)
-- => Int -> Int -> BenchmarkState RangeGen -> KVSState MockDB -> IO (KVSState MockDB, Integer)
runRequests operationCount keyCount bmState s = do
(requests,_) <- runStateT (workload operationCount) bmState
-- traceM $ "requests:"
-- mapM (\i -> traceM $ show i ++ "\n" ) requests
start <- currentTimeMillis
(responses, s') <- requests `seq` flip runStateT s $ ?execRequests requests
stop <- currentTimeMillis
let execTime = stop - start
-- traceM "???????????????????????????????????????"
-- traceM $ "responses:"
-- mapM (\i -> traceM $ show i ++ "\n" ) responses
responses `seq` assertEqual "wrong number of responses" operationCount $ length responses
return (s',execTime)
runSingleBatch :: (?execRequests :: ExecReqFn) => Int -> Int -> IO ()
runSingleBatch keyCount reqCount = do
(_, execTime) <- runRequests reqCount keyCount (reqBenchmarkState keyCount) =<< loadDB keyCount
traceM $ "exec time: " ++ show execTime
return ()
runMultipleBatches :: (?execRequests :: ExecReqFn) => Int -> Int -> Int -> IO Double
runMultipleBatches keyCount reqCount batchCount = do
s <- loadDB keyCount
let bmState = reqBenchmarkState keyCount
(_, execTimes) <- foldM (\ (st,execTimes) _ -> do
(st',execTime) <- runRequests reqCount keyCount bmState st
return $ st' `seq` (st',execTimes ++ [execTime]))
(s,[])
$ take batchCount [1,2..]
let meanExecTime = mean $ V.fromList $ map fromIntegral execTimes
-- traceM $ "mean execution time: " ++ show meanExecTime ++ " ms"
return meanExecTime
runMultipleBatches_ :: (?execRequests :: ExecReqFn) => Int -> Int -> Int -> IO ()
runMultipleBatches_ keyCount reqCount batchCount = (\e -> traceM $ "mean execution time: " ++ show e ++ " ms") =<< runMultipleBatches keyCount reqCount batchCount
data ScalabilityResult = ScalabilityResult { version :: String
, results :: [Double] }
scalability name numThreads = do
results <- foldM (\res n -> do
_ <- setNumCapabilities n
r <- runMultipleBatches 2000 20 20
return $ res ++ [r])
[]
$ take numThreads [1,2..]
return (name,results)
buildSuite (BenchmarkConfig maxThreadCount) =
[testCase "Done!" runAsSingleTest]
where
runAsSingleTest = do
results <- forM versions $ \(version, name) -> let ?execRequests = version in scalability name maxThreadCount
BS.writeFile "scalability.json" $ AE.encode $ HM.fromList results
data BenchmarkConfig = BenchmarkConfig { maxThreadCount :: Int }
benchmarkOptionsParser = BenchmarkConfig <$> (read <$> strOption
( short 't'
<> long "num-threads"
<> metavar "NUM_THREADS"
<> help "Maximum number of threads."
<> showDefault
<> value "8" ))
|
Rebol [
Title: "Callback demonstration for FFI extension: Quicksort"
File: %qsort.r
Description: {
qsort() is defined in the standard C library in <stdlib.h>. It can be
used to sort an array of arbitrary data by passing it a pointer to a
C function which serves as the comparison operator. Using only the
logical result of the comparison, the fixed-size elements of the
array can be put in order by the generic quicksort algorithm.
https://en.wikipedia.org/wiki/Qsort
An FFI "routine" can provide a bridge function for Rebol to invoke
qsort(), translating Rebol datatypes to corresponding values that can
be read by the C code. *But* the comparison operation needs to be
passed to qsort() as a C function pointer. Because while the C code
is running, it doesn't know how to invoke the Rebol interpreter to
run an ACTION! directly.
LibFFI provides a "closure" facility, which allows the dynamic
creation of an artificial C function pointer at runtime:
http://www.chiark.greenend.org.uk/doc/libffi-dev/html/The-Closure-API.html
The Rebol FFI interface uses this in WRAP-CALLBACK, which lets a
Rebol function be called from C, with particular expectations of the
C data types used to invoke it. The parameter language and supported
types used is the same as that in MAKE-ROUTINE.
}
Notes: {
The C language does not have strict typing rules for the arguments
to functions passed by pointer. This means when a function takes a
function pointer as an argument, there's not enough information in
that function's annotated specification to automatically "callbackify"
a Rebol ACTION! used as an argument.
While Rebol's routine spec language could try and remedy this by
forcing function pointer arguments to state precise typing, this
would be at odds with how the language may work. e.g. another one
of the function's parameters may dictate the choice of what type of
parameter the callback receives.
}
See-Also: {
"user natives", which embed a TCC compiler into the Rebol
executable. This provides an alternative for those who would prefer
to write their callbacks directly in C, yet still include that C
source in a Rebol module.
}
]
recycle/torture
f: function [
a [integer!]
b [integer!]
][
i: make struct! compose/deep [
[raw-memory: (a)]
i [int32]
]
j: make struct! compose/deep [
[raw-memory: (b)]
i [int32]
]
case [
i/i = j/i [0]
i/i < j/i [-1]
i/i > j/i [1]
]
]
; This test uses WRAP-CALLBACK and not MAKE-CALLBACK (which creates the
; function and wraps it in one step). This is in order to be easier to
; debug if something is going wrong.
;
cb: wrap-callback :f [
return: [int64]
a [pointer]
b [pointer]
]
libc: make library! %libc.so.6
x64?: 40 = fifth system/version
size_t: either x64? ['int64]['int32]
qsort: make-routine libc "qsort" compose/deep [
base [pointer]
nmemb [(size_t)]
size [(size_t)]
comp [pointer]
]
array: make vector! [integer! 32 5 [10 8 2 9 5]]
print ["before:" mold array]
probe (addr-of :cb)
qsort array 5 4 (addr-of :cb)
print ["after:" mold array]
assert [array = make vector! [integer! 32 5 [2 5 8 9 10]]]
close libc
|
module FinancialTimeseries.Statistics.Statistics where
import qualified Data.Vector as Vec
import Data.Vector (Vector)
import qualified Data.Vector.Algorithms.Merge as Merge
import qualified Statistics.Sample as Sample
import FinancialTimeseries.Type.Chart (Chart(..), LChart)
import FinancialTimeseries.Type.Labeled (Labeled)
import FinancialTimeseries.Type.Table (Table(..), Cell(..), Row, row)
data Quantiles a = Quantiles {
q05 :: Maybe a
, q25 :: Maybe a
, q50 :: Maybe a
, q75 :: Maybe a
, q95 :: Maybe a
} deriving (Show)
instance Row Quantiles where
row (Quantiles a b c d e) = map (CString . maybe "n/a" show) [a, b, c, d, e]
data Probabilities a = Probabilities {
p0'50 :: a
, p0'75 :: a
, p1'00 :: a
, p1'25 :: a
, p1'50 :: a
, p1'75 :: a
, p2'00 :: a
} deriving (Show)
instance Row Probabilities where
row (Probabilities a b c d e f g) = map Cell [a, b, c, d, e, f, g]
data TradeMoments a = TradeMoments {
trMaxYield :: a
, trMinYield :: a
, trMeanYield :: a
, trStdDevYield :: a
} deriving (Show)
instance Row TradeMoments where
row (TradeMoments a b c d) = map Cell [a, b, c, d]
data TimeseriesMoments a = TimeseriesMoments {
tsMaxYield :: a
, tsMinYield :: a
, tsMeanYield :: a
, tsStdDevYield :: a
} deriving (Show)
instance Row TimeseriesMoments where
row (TimeseriesMoments a b c d) = map Cell [a, b, c, d]
data Stats moments a = Stats {
sampleSize :: Int
, quantiles :: Quantiles a
, probabilities :: Probabilities a
, moments :: moments a
, cdf :: Vector (Double, a)
} deriving (Show)
tradeMoments ::
(Real a, Fractional a) =>
Vector a -> TradeMoments a
tradeMoments sorted =
let sortedFrac = Vec.map realToFrac sorted
in TradeMoments {
trMaxYield = Vec.last sorted
, trMinYield = Vec.head sorted
, trMeanYield = realToFrac $ exp (Sample.mean (Vec.map log sortedFrac))
, trStdDevYield = realToFrac $ exp (Sample.stdDev (Vec.map log sortedFrac))
}
timeseriesMoments ::
(Real a, Fractional a) =>
Vector a -> TimeseriesMoments a
timeseriesMoments sorted =
let sortedFrac = Vec.map realToFrac sorted
in TimeseriesMoments {
tsMaxYield = Vec.last sorted
, tsMinYield = Vec.head sorted
, tsMeanYield = realToFrac $ Sample.mean sortedFrac
, tsStdDevYield = realToFrac $ Sample.stdDev sortedFrac
}
stats2list ::
(Row moments, Show a) =>
[Labeled params (Stats moments a)] -> [Table params a]
stats2list xs =
let qheaders = map CString ["Q05", "Q25", "Q50", "Q75", "Q95", "Sample Size"]
pheaders = map CString ["P(X < 0.5)", "P(X < 0.75)", "P(X < 1.0)", "P(X < 1.25)", "P(X < 1.5)", "P(X < 1.75)", "P(X < 2.0)", "Sample Size"]
mheaders = map CString ["Max.", "Min.", "Mean", "StdDev.", "Sample Size"]
mkRow g x = row (g x) ++ [CInt (sampleSize x)]
in Table "Quantiles" qheaders (map (fmap (mkRow quantiles)) xs)
: Table "Moments" mheaders (map (fmap (mkRow moments)) xs)
: Table "Probabilities" pheaders (map (fmap (mkRow probabilities)) xs)
: []
stats2cdfChart :: [Labeled params (Stats moments a)] -> LChart params Double a
stats2cdfChart = Chart "CDF" . map (fmap ((:[]) . cdf))
statisticsWithMoments ::
(Ord a, Num a, Fractional a, Real a) =>
(Vector a -> moments a) -> Vector a -> Stats moments a
statisticsWithMoments mms vs =
let noe = fromIntegral (Vec.length vs)
sorted = Vec.modify Merge.sort vs
quart s = sorted Vec.!? (round (s * noe :: Double))
q = Quantiles {
q05 = quart 0.05
, q25 = quart 0.25
, q50 = quart 0.50
, q75 = quart 0.75
, q95 = quart 0.95
}
prob s = fromIntegral (Vec.length (Vec.takeWhile (<s) sorted)) / noe
p = Probabilities {
p0'50 = prob 0.5
, p0'75 = prob 0.75
, p1'00 = prob 1.0
, p1'25 = prob 1.25
, p1'50 = prob 1.5
, p1'75 = prob 1.75
, p2'00 = prob 2.00
}
in Stats {
sampleSize = Vec.length vs
, quantiles = q
, probabilities = p
, moments = mms sorted
, cdf = Vec.imap (\i x -> (fromIntegral i / noe, x)) sorted
}
timeseriesStatistics ::
(Real a, Fractional a) =>
Vector a -> Stats TimeseriesMoments a
timeseriesStatistics = statisticsWithMoments timeseriesMoments
tradeStatistics ::
(Real a, Fractional a) =>
Vector a -> Stats TradeMoments a
tradeStatistics = statisticsWithMoments tradeMoments
yield :: (Fractional a) => Vector a -> a
yield v = Vec.last v / Vec.head v
absoluteDrawdown :: (Ord a, Fractional a) => Vector a -> a
absoluteDrawdown v = Vec.minimum v / Vec.head v
relativeDrawdown :: (Ord a, Num a, Fractional a) => Vector a -> a
relativeDrawdown v = Vec.minimum (Vec.zipWith (/) v (Vec.postscanl max 0 v))
|
import hilbert.wr.dc_neg
import hilbert.wr.proofs.dc
namespace clfrags
namespace hilbert
namespace wr
namespace dc_neg
theorem dcn₁_dc {a b c d e f : Prop} (h₁ : dc e f (dc c d (dc b a (neg a))))
: dc e f (dc c d b) :=
have h₂ : dc (dc e f c) (dc e f d) (dc b a (neg a)), from dc.dc₆' h₁,
have h₃ : dc (dc e f c) (dc e f d) b, from dcn₁ h₂,
show dc e f (dc c d b), from dc.dc₇' h₃
theorem dcn₂_dc {a b c d e f : Prop} (h₁ : dc e f (dc c d b))
: dc e f (dc c d (dc b a (neg a))) :=
have h₂ : dc (dc e f c) (dc e f d) b, from dc.dc₆' h₁,
have h₃ : dc (dc e f c) (dc e f d) (dc b a (neg a)), from dcn₂ h₂,
show dc e f (dc c d (dc b a (neg a))), from dc.dc₇' h₃
theorem n₁ {a b : Prop} (h₁ : a) (h₂ : neg a) : b :=
have h₂ : dc a (neg a) b, from dc.dc₁ h₁ h₂,
have h₃ : dc (dc a (neg a) b) a b, from dc.dc₁ h₂ h₁,
have h₄ : dc a b (dc a (neg a) b), from dc.dc₅' (dc.dc₄' h₃),
have h₅ : dc a b (dc b a (neg a)), from dc.dc₄ (dc.dc₅ h₄),
have h₆ : dc a b b, from dcn₁ h₅,
show b, from dc.dc₂ h₆
theorem dcn₃ {a b : Prop} (h₁ : b) : dc b a (neg a) :=
have h₂ : dc a b b, from dc.dc₃ h₁,
have h₃ : dc a b (dc b a (neg a)), from dcn₂ h₂,
have h₄ : dc (dc a b b) (dc a b a) (neg a), from dc.dc₆' h₃,
have h₅ : dc (neg a) (dc a b b) (dc a b a), from dc.dc₄' (dc.dc₅' h₄),
have h₆ : dc (neg a) (dc a b b) (dc b a a), from dc.dc₅ (dc.dc₄ h₅),
have h₇ : dc (neg a) (dc a b b) a, from dc.dc₂_dc h₆,
have h₈ : dc (neg a) a (dc a b b), from dc.dc₅' h₇,
have h₉ : dc (neg a) a b, from dc.dc₂_dc h₈,
show dc b a (neg a), from dc.dc₅' (dc.dc₄' (dc.dc₅' h₉))
end dc_neg
end wr
end hilbert
end clfrags
|
= = = Black is OK ! = = =
|
@testset "Wall Constraint" begin
# Test WallConstraint
T = Float64
n = 4
P = 5
x = 4
y = 2
X = SVector{n,T}([13.0, 1.0, -12.0, 1.0])
x1 = SVector{P,T}([ 0.0, 0.0, 1.0, 3.0, -2.0])
y1 = SVector{P,T}([ 1.0, -1.0, 2.0, 2.0, 0.0])
x2 = SVector{P,T}([ 1.0, 1.0, 2.0, 2.0, 0.0])
y2 = SVector{P,T}([ 0.0, 0.0, 1.0, 1.0, 0.0])
xv = SVector{P,T}([ 1.0, 1.0, 1.0, 1.0, 0.0])./sqrt(2)
yv = SVector{P,T}([ 1.0, -1.0, 1.0, -1.0, sqrt(2)])./sqrt(2)
con = WallConstraint(n,x1,y1,x2,y2,xv,yv,x,y)
@test norm(TrajectoryOptimization.evaluate(con,X) - [sqrt(2)/2, 0.0, -sqrt(2)/2, 0.0, 0.0], 1) < 1e-10
@test (@ballocated TrajectoryOptimization.evaluate($con,$X)) == 0
function easy_jacobian(con,X)
function local_evaluate(X)
return TrajectoryOptimization.evaluate(con,X)
end
return ForwardDiff.jacobian(local_evaluate, X)
end
∇c_easy = easy_jacobian(con, X)
∇c = zeros(MMatrix{P,n,T,P*n})
jacobian!(∇c,con,X)
@test norm(∇c - ∇c_easy, 1) < 1e-10
@test (@ballocated jacobian!($∇c,$con,$X)) == 0
# Test Wall3DConstraint
T = Float64
n = 6
P = 5
x = 4
y = 2
z = 1
X =1
X0 = SVector{n,T}([0.0, 0.10, -12.0, 0.10, 12.0, 11.0])
X1 = SVector{n,T}([1.0, 0.55, -12.0, 0.55, 12.0, 11.0])
X2 = SVector{n,T}([1.0, 1.25, -12.0, 0.75, 12.0, 11.0])
x1 = SVector{P,T}([ 0.0, 0.0, 0.0, 0.0, 0.0])
y1 = SVector{P,T}([ 0.0, 0.0, 0.0, 0.0, 0.0])
z1 = SVector{P,T}([ 0.0, 0.0, 0.0, 0.0, 0.0])
x2 = SVector{P,T}([ 1.0, 1.0, 1.0, 1.0, 1.0])
y2 = SVector{P,T}([ 0.0, 0.0, 0.0, 0.0, 0.0])
z2 = SVector{P,T}([ 0.0, 0.0, 1.0, 0.0, 0.0])
x3 = SVector{P,T}([ 1.0, 1.0, 1.0, 0.0, 0.0])
y3 = SVector{P,T}([ 1.0, 1.0, 1.0, 1.0, 1.0])
z3 = SVector{P,T}([ 0.0, 1.0, 1.0, 0.0, 1.0])
xv = SVector{P,T}([ 0.0, 0.0, -1.0/sqrt(2), 0.0, 0.0])
yv = SVector{P,T}([ 0.0, -1.0/sqrt(2), 0.0, 0.0, -1.0/sqrt(2)])
zv = SVector{P,T}([ 1.0, 1.0/sqrt(2), 1.0/sqrt(2), 1.0, 1.0/sqrt(2)])
con = Wall3DConstraint(n,x1,y1,z1,x2,y2,z2,x3,y3,z3,xv,yv,zv,x,y,z)
@test norm(TrajectoryOptimization.evaluate(con,X0) - [0.0, -0.1/sqrt(2), -0.1/sqrt(2), 0.0, -0.1/sqrt(2)], 1) < 1e-10
@test norm(TrajectoryOptimization.evaluate(con,X1) - [1.0, 0.45/sqrt(2), 0.45/sqrt(2), 1.0, 0.45/sqrt(2)], 1) < 1e-10
@test norm(TrajectoryOptimization.evaluate(con,X2) - [0.0, 0.0, 0.0, 1.0, -0.25/sqrt(2)], 1) < 1e-10
@test (@ballocated TrajectoryOptimization.evaluate($con,$X0)) == 0
∇c_easy = easy_jacobian(con, X0)
∇c = zeros(MMatrix{P,n,T,P*n})
jacobian!(∇c,con,X0)
@test norm(∇c - ∇c_easy, 1) < 1e-10
@test (@ballocated jacobian!($∇c,$con,$X0)) == 0
end
|
theorem tst1 {α : Type} {p : Prop} (xs : List α) (h₁ : (a : α) → (as : List α) → xs = a :: as → p) (h₂ : xs = [] → p) : p :=
by match (generalizing := false) h:xs with
| [] => exact h₂ h
| z::zs => apply h₁ z zs; assumption
theorem tst1' {α : Type} {p : Prop} (xs : List α) (h₁ : (a : α) → (as : List α) → xs = a :: as → p) (h₂ : xs = [] → p) : p :=
by match xs with
| [] => exact h₂ rfl
| z::zs => exact h₁ z zs rfl
theorem tst2 {α : Type} {p : Prop} (xs : List α) (h₁ : (a : α) → (as : List α) → xs = a :: as → p) (h₂ : xs = [] → p) : p :=
by match (generalizing := false) h:xs with
| [] => ?nilCase
| z::zs => ?consCase;
case consCase => exact h₁ z zs h;
case nilCase => exact h₂ h
def tst3 {α β γ : Type} (h : α × β × γ) : β × α × γ :=
by {
match h with
| (a, b, c) => exact (b, a, c)
}
theorem tst4 {α : Type} {p : Prop} (xs : List α) (h₁ : (a : α) → (as : List α) → xs = a :: as → p) (h₂ : xs = [] → p) : p := by
match (generalizing := false) h:xs with
| [] => _
| z::zs => _
case match_2 => exact h₁ z zs h
exact h₂ h
theorem tst5 {p q r} (h : p ∨ q ∨ r) : r ∨ q ∨ p:= by
match h with
| Or.inl h => exact Or.inr (Or.inr h)
| Or.inr (Or.inl h) => ?c1
| Or.inr (Or.inr h) => ?c2
case c2 =>
apply Or.inl
assumption
case c1 =>
apply Or.inr
apply Or.inl
assumption
theorem tst6 {p q r} (h : p ∨ q ∨ r) : r ∨ q ∨ p:= by
match h with
| Or.inl h => exact Or.inr (Or.inr h)
| Or.inr (Or.inl h) => ?c1
| Or.inr (Or.inr h) =>
apply Or.inl
assumption
case c1 => apply Or.inr; apply Or.inl; assumption
theorem tst7 {p q r} (h : p ∨ q ∨ r) : r ∨ q ∨ p:=
by match h with
| Or.inl h =>
exact Or.inr (Or.inr h)
| Or.inr (Or.inl h) =>
apply Or.inr;
apply Or.inl;
assumption
| Or.inr (Or.inr h) =>
apply Or.inl;
assumption
inductive ListLast.{u} {α : Type u} : List α → Type u
| empty : ListLast []
| nonEmpty : (as : List α) → (a : α) → ListLast (as ++ [a])
axiom last {α} (xs : List α) : ListLast xs
axiom back {α} [Inhabited α] (xs : List α) : α
axiom popBack {α} : List α → List α
axiom backEq {α} [Inhabited α] : (xs : List α) → (x : α) → back (xs ++ [x]) = x
axiom popBackEq {α} : (xs : List α) → (x : α) → popBack (xs ++ [x]) = xs
theorem tst8 {α} [Inhabited α] (xs : List α) : xs ≠ [] → xs = popBack xs ++ [back xs] :=
match (generalizing := false) xs, h:last xs with
| _, ListLast.empty => fun h => absurd rfl h
| _, ListLast.nonEmpty ys y => fun _ => sorry
theorem tst9 {α} [Inhabited α] (xs : List α) : xs ≠ [] → xs = popBack xs ++ [back xs] := by
match (generalizing := false) xs, h:last xs with
| _, ListLast.empty => intro h; exact absurd rfl h
| _, ListLast.nonEmpty ys y => intro; rw [popBackEq, backEq]
theorem tst8' {α} [Inhabited α] (xs : List α) : xs ≠ [] → xs = popBack xs ++ [back xs] :=
match xs, last xs with
| _, ListLast.empty => fun h => absurd rfl h
| _, ListLast.nonEmpty ys y => fun _ => sorry
theorem tst8'' {α} [Inhabited α] (xs : List α) (h : xs ≠ []) : xs = popBack xs ++ [back xs] :=
match xs, last xs with
| _, ListLast.empty => absurd rfl h
| _, ListLast.nonEmpty ys y => sorry
|
/-
Copyright (c) 2015, 2017 Jeremy Avigad. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Metric spaces.
Authors: Jeremy Avigad, Robert Y. Lewis, Johannes Hölzl, Mario Carneiro, Sébastien Gouëzel
Many definitions and theorems expected on metric spaces are already introduced on uniform spaces and
topological spaces. For example:
open and closed sets, compactness, completeness, continuity and uniform continuity
-/
import data.real.nnreal topology.metric_space.emetric_space topology.algebra.ordered
open lattice set filter classical topological_space
noncomputable theory
local notation `𝓤` := uniformity
universes u v w
variables {α : Type u} {β : Type v} {γ : Type w}
/-- Construct a uniform structure from a distance function and metric space axioms -/
def uniform_space_of_dist
(dist : α → α → ℝ)
(dist_self : ∀ x : α, dist x x = 0)
(dist_comm : ∀ x y : α, dist x y = dist y x)
(dist_triangle : ∀ x y z : α, dist x z ≤ dist x y + dist y z) : uniform_space α :=
uniform_space.of_core {
uniformity := (⨅ ε>0, principal {p:α×α | dist p.1 p.2 < ε}),
refl := le_infi $ assume ε, le_infi $
by simp [set.subset_def, id_rel, dist_self, (>)] {contextual := tt},
comp := le_infi $ assume ε, le_infi $ assume h, lift'_le
(mem_infi_sets (ε / 2) $ mem_infi_sets (div_pos_of_pos_of_pos h two_pos) (subset.refl _)) $
have ∀ (a b c : α), dist a c < ε / 2 → dist c b < ε / 2 → dist a b < ε,
from assume a b c hac hcb,
calc dist a b ≤ dist a c + dist c b : dist_triangle _ _ _
... < ε / 2 + ε / 2 : add_lt_add hac hcb
... = ε : by rw [div_add_div_same, add_self_div_two],
by simpa [comp_rel],
symm := tendsto_infi.2 $ assume ε, tendsto_infi.2 $ assume h,
tendsto_infi' ε $ tendsto_infi' h $ tendsto_principal_principal.2 $ by simp [dist_comm] }
/-- The distance function (given an ambient metric space on `α`), which returns
a nonnegative real number `dist x y` given `x y : α`. -/
class has_dist (α : Type*) := (dist : α → α → ℝ)
export has_dist (dist)
/-- Metric space
Each metric space induces a canonical `uniform_space` and hence a canonical `topological_space`.
This is enforced in the type class definition, by extending the `uniform_space` structure. When
instantiating a `metric_space` structure, the uniformity fields are not necessary, they will be
filled in by default. In the same way, each metric space induces an emetric space structure.
It is included in the structure, but filled in by default.
When one instantiates a metric space structure, for instance a product structure,
this makes it possible to use a uniform structure and an edistance that are exactly
the ones for the uniform spaces product and the emetric spaces products, thereby
ensuring that everything in defeq in diamonds.-/
class metric_space (α : Type u) extends has_dist α : Type u :=
(dist_self : ∀ x : α, dist x x = 0)
(eq_of_dist_eq_zero : ∀ {x y : α}, dist x y = 0 → x = y)
(dist_comm : ∀ x y : α, dist x y = dist y x)
(dist_triangle : ∀ x y z : α, dist x z ≤ dist x y + dist y z)
(edist : α → α → ennreal := λx y, ennreal.of_real (dist x y))
(edist_dist : ∀ x y : α, edist x y = ennreal.of_real (dist x y) . control_laws_tac)
(to_uniform_space : uniform_space α := uniform_space_of_dist dist dist_self dist_comm dist_triangle)
(uniformity_dist : 𝓤 α = ⨅ ε>0, principal {p:α×α | dist p.1 p.2 < ε} . control_laws_tac)
variables [metric_space α]
instance metric_space.to_uniform_space' : uniform_space α :=
metric_space.to_uniform_space α
instance metric_space.to_has_edist : has_edist α := ⟨metric_space.edist⟩
@[simp] theorem dist_self (x : α) : dist x x = 0 := metric_space.dist_self x
theorem eq_of_dist_eq_zero {x y : α} : dist x y = 0 → x = y :=
metric_space.eq_of_dist_eq_zero
theorem dist_comm (x y : α) : dist x y = dist y x := metric_space.dist_comm x y
theorem edist_dist (x y : α) : edist x y = ennreal.of_real (dist x y) :=
metric_space.edist_dist _ x y
@[simp] theorem dist_eq_zero {x y : α} : dist x y = 0 ↔ x = y :=
iff.intro eq_of_dist_eq_zero (assume : x = y, this ▸ dist_self _)
@[simp] theorem zero_eq_dist {x y : α} : 0 = dist x y ↔ x = y :=
by rw [eq_comm, dist_eq_zero]
theorem dist_triangle (x y z : α) : dist x z ≤ dist x y + dist y z :=
metric_space.dist_triangle x y z
theorem dist_triangle_left (x y z : α) : dist x y ≤ dist z x + dist z y :=
by rw dist_comm z; apply dist_triangle
theorem dist_triangle_right (x y z : α) : dist x y ≤ dist x z + dist y z :=
by rw dist_comm y; apply dist_triangle
lemma dist_triangle4 (x y z w : α) :
dist x w ≤ dist x y + dist y z + dist z w :=
calc
dist x w ≤ dist x z + dist z w : dist_triangle x z w
... ≤ (dist x y + dist y z) + dist z w : add_le_add_right (metric_space.dist_triangle x y z) _
lemma dist_triangle4_left (x₁ y₁ x₂ y₂ : α) :
dist x₂ y₂ ≤ dist x₁ y₁ + (dist x₁ x₂ + dist y₁ y₂) :=
by rw [add_left_comm, dist_comm x₁, ← add_assoc]; apply dist_triangle4
lemma dist_triangle4_right (x₁ y₁ x₂ y₂ : α) :
dist x₁ y₁ ≤ dist x₁ x₂ + dist y₁ y₂ + dist x₂ y₂ :=
by rw [add_right_comm, dist_comm y₁]; apply dist_triangle4
theorem swap_dist : function.swap (@dist α _) = dist :=
by funext x y; exact dist_comm _ _
theorem abs_dist_sub_le (x y z : α) : abs (dist x z - dist y z) ≤ dist x y :=
abs_sub_le_iff.2
⟨sub_le_iff_le_add.2 (dist_triangle _ _ _),
sub_le_iff_le_add.2 (dist_triangle_left _ _ _)⟩
theorem dist_nonneg {x y : α} : 0 ≤ dist x y :=
have 2 * dist x y ≥ 0,
from calc 2 * dist x y = dist x y + dist y x : by rw [dist_comm x y, two_mul]
... ≥ 0 : by rw ← dist_self x; apply dist_triangle,
nonneg_of_mul_nonneg_left this two_pos
@[simp] theorem dist_le_zero {x y : α} : dist x y ≤ 0 ↔ x = y :=
by simpa [le_antisymm_iff, dist_nonneg] using @dist_eq_zero _ _ x y
@[simp] theorem dist_pos {x y : α} : 0 < dist x y ↔ x ≠ y :=
by simpa [-dist_le_zero] using not_congr (@dist_le_zero _ _ x y)
@[simp] theorem abs_dist {a b : α} : abs (dist a b) = dist a b :=
abs_of_nonneg dist_nonneg
theorem eq_of_forall_dist_le {x y : α} (h : ∀ε, ε > 0 → dist x y ≤ ε) : x = y :=
eq_of_dist_eq_zero (eq_of_le_of_forall_le_of_dense dist_nonneg h)
def nndist (a b : α) : nnreal := ⟨dist a b, dist_nonneg⟩
/--Express `nndist` in terms of `edist`-/
lemma nndist_edist (x y : α) : nndist x y = (edist x y).to_nnreal :=
by simp [nndist, edist_dist, nnreal.of_real, max_eq_left dist_nonneg, ennreal.of_real]
/--Express `edist` in terms of `nndist`-/
lemma edist_nndist (x y : α) : edist x y = ↑(nndist x y) :=
by simp [nndist, edist_dist, nnreal.of_real, max_eq_left dist_nonneg, ennreal.of_real]
/--In a metric space, the extended distance is always finite-/
lemma edist_ne_top (x y : α) : edist x y ≠ ⊤ :=
by rw [edist_dist x y]; apply ennreal.coe_ne_top
/--`nndist x x` vanishes-/
@[simp] lemma nndist_self (a : α) : nndist a a = 0 := (nnreal.coe_eq_zero _).1 (dist_self a)
/--Express `dist` in terms of `nndist`-/
lemma dist_nndist (x y : α) : dist x y = ↑(nndist x y) := rfl
/--Express `nndist` in terms of `dist`-/
lemma nndist_dist (x y : α) : nndist x y = nnreal.of_real (dist x y) :=
by rw [dist_nndist, nnreal.of_real_coe]
/--Deduce the equality of points with the vanishing of the nonnegative distance-/
theorem eq_of_nndist_eq_zero {x y : α} : nndist x y = 0 → x = y :=
by simp only [nnreal.eq_iff.symm, (dist_nndist _ _).symm, imp_self, nnreal.coe_zero, dist_eq_zero]
theorem nndist_comm (x y : α) : nndist x y = nndist y x :=
by simpa [nnreal.eq_iff.symm] using dist_comm x y
/--Characterize the equality of points with the vanishing of the nonnegative distance-/
@[simp] theorem nndist_eq_zero {x y : α} : nndist x y = 0 ↔ x = y :=
by simp only [nnreal.eq_iff.symm, (dist_nndist _ _).symm, imp_self, nnreal.coe_zero, dist_eq_zero]
@[simp] theorem zero_eq_nndist {x y : α} : 0 = nndist x y ↔ x = y :=
by simp only [nnreal.eq_iff.symm, (dist_nndist _ _).symm, imp_self, nnreal.coe_zero, zero_eq_dist]
/--Triangle inequality for the nonnegative distance-/
theorem nndist_triangle (x y z : α) : nndist x z ≤ nndist x y + nndist y z :=
by simpa [nnreal.coe_le] using dist_triangle x y z
theorem nndist_triangle_left (x y z : α) : nndist x y ≤ nndist z x + nndist z y :=
by simpa [nnreal.coe_le] using dist_triangle_left x y z
theorem nndist_triangle_right (x y z : α) : nndist x y ≤ nndist x z + nndist y z :=
by simpa [nnreal.coe_le] using dist_triangle_right x y z
/--Express `dist` in terms of `edist`-/
lemma dist_edist (x y : α) : dist x y = (edist x y).to_real :=
by rw [edist_dist, ennreal.to_real_of_real (dist_nonneg)]
namespace metric
/- instantiate metric space as a topology -/
variables {x y z : α} {ε ε₁ ε₂ : ℝ} {s : set α}
/-- `ball x ε` is the set of all points `y` with `dist y x < ε` -/
def ball (x : α) (ε : ℝ) : set α := {y | dist y x < ε}
@[simp] theorem mem_ball : y ∈ ball x ε ↔ dist y x < ε := iff.rfl
theorem mem_ball' : y ∈ ball x ε ↔ dist x y < ε := by rw dist_comm; refl
/-- `closed_ball x ε` is the set of all points `y` with `dist y x ≤ ε` -/
def closed_ball (x : α) (ε : ℝ) := {y | dist y x ≤ ε}
@[simp] theorem mem_closed_ball : y ∈ closed_ball x ε ↔ dist y x ≤ ε := iff.rfl
theorem ball_subset_closed_ball : ball x ε ⊆ closed_ball x ε :=
assume y, by simp; intros h; apply le_of_lt h
theorem pos_of_mem_ball (hy : y ∈ ball x ε) : ε > 0 :=
lt_of_le_of_lt dist_nonneg hy
theorem mem_ball_self (h : ε > 0) : x ∈ ball x ε :=
show dist x x < ε, by rw dist_self; assumption
theorem mem_closed_ball_self (h : ε ≥ 0) : x ∈ closed_ball x ε :=
show dist x x ≤ ε, by rw dist_self; assumption
theorem mem_ball_comm : x ∈ ball y ε ↔ y ∈ ball x ε :=
by simp [dist_comm]
theorem ball_subset_ball (h : ε₁ ≤ ε₂) : ball x ε₁ ⊆ ball x ε₂ :=
λ y (yx : _ < ε₁), lt_of_lt_of_le yx h
theorem closed_ball_subset_closed_ball {α : Type u} [metric_space α] {ε₁ ε₂ : ℝ} {x : α} (h : ε₁ ≤ ε₂) :
closed_ball x ε₁ ⊆ closed_ball x ε₂ :=
λ y (yx : _ ≤ ε₁), le_trans yx h
theorem ball_disjoint (h : ε₁ + ε₂ ≤ dist x y) : ball x ε₁ ∩ ball y ε₂ = ∅ :=
eq_empty_iff_forall_not_mem.2 $ λ z ⟨h₁, h₂⟩,
not_lt_of_le (dist_triangle_left x y z)
(lt_of_lt_of_le (add_lt_add h₁ h₂) h)
theorem ball_disjoint_same (h : ε ≤ dist x y / 2) : ball x ε ∩ ball y ε = ∅ :=
ball_disjoint $ by rwa [← two_mul, ← le_div_iff' two_pos]
theorem ball_subset (h : dist x y ≤ ε₂ - ε₁) : ball x ε₁ ⊆ ball y ε₂ :=
λ z zx, by rw ← add_sub_cancel'_right ε₁ ε₂; exact
lt_of_le_of_lt (dist_triangle z x y) (add_lt_add_of_lt_of_le zx h)
theorem ball_half_subset (y) (h : y ∈ ball x (ε / 2)) : ball y (ε / 2) ⊆ ball x ε :=
ball_subset $ by rw sub_self_div_two; exact le_of_lt h
theorem exists_ball_subset_ball (h : y ∈ ball x ε) : ∃ ε' > 0, ball y ε' ⊆ ball x ε :=
⟨_, sub_pos.2 h, ball_subset $ by rw sub_sub_self⟩
theorem ball_eq_empty_iff_nonpos : ε ≤ 0 ↔ ball x ε = ∅ :=
(eq_empty_iff_forall_not_mem.trans
⟨λ h, le_of_not_gt $ λ ε0, h _ $ mem_ball_self ε0,
λ ε0 y h, not_lt_of_le ε0 $ pos_of_mem_ball h⟩).symm
theorem uniformity_dist : 𝓤 α = (⨅ ε>0, principal {p:α×α | dist p.1 p.2 < ε}) :=
metric_space.uniformity_dist _
theorem uniformity_dist' : 𝓤 α = (⨅ε:{ε:ℝ // ε>0}, principal {p:α×α | dist p.1 p.2 < ε.val}) :=
by simp [infi_subtype]; exact uniformity_dist
theorem mem_uniformity_dist {s : set (α×α)} :
s ∈ 𝓤 α ↔ (∃ε>0, ∀{a b:α}, dist a b < ε → (a, b) ∈ s) :=
begin
rw [uniformity_dist', mem_infi],
simp [subset_def],
exact assume ⟨r, hr⟩ ⟨p, hp⟩, ⟨⟨min r p, lt_min hr hp⟩, by simp [lt_min_iff, (≥)] {contextual := tt}⟩,
exact ⟨⟨1, zero_lt_one⟩⟩
end
theorem dist_mem_uniformity {ε:ℝ} (ε0 : 0 < ε) :
{p:α×α | dist p.1 p.2 < ε} ∈ 𝓤 α :=
mem_uniformity_dist.2 ⟨ε, ε0, λ a b, id⟩
theorem uniform_continuous_iff [metric_space β] {f : α → β} :
uniform_continuous f ↔ ∀ ε > 0, ∃ δ > 0,
∀{a b:α}, dist a b < δ → dist (f a) (f b) < ε :=
uniform_continuous_def.trans
⟨λ H ε ε0, mem_uniformity_dist.1 $ H _ $ dist_mem_uniformity ε0,
λ H r ru,
let ⟨ε, ε0, hε⟩ := mem_uniformity_dist.1 ru, ⟨δ, δ0, hδ⟩ := H _ ε0 in
mem_uniformity_dist.2 ⟨δ, δ0, λ a b h, hε (hδ h)⟩⟩
theorem uniform_embedding_iff [metric_space β] {f : α → β} :
uniform_embedding f ↔ function.injective f ∧ uniform_continuous f ∧
∀ δ > 0, ∃ ε > 0, ∀ {a b : α}, dist (f a) (f b) < ε → dist a b < δ :=
uniform_embedding_def'.trans $ and_congr iff.rfl $ and_congr iff.rfl
⟨λ H δ δ0, let ⟨t, tu, ht⟩ := H _ (dist_mem_uniformity δ0),
⟨ε, ε0, hε⟩ := mem_uniformity_dist.1 tu in
⟨ε, ε0, λ a b h, ht _ _ (hε h)⟩,
λ H s su, let ⟨δ, δ0, hδ⟩ := mem_uniformity_dist.1 su, ⟨ε, ε0, hε⟩ := H _ δ0 in
⟨_, dist_mem_uniformity ε0, λ a b h, hδ (hε h)⟩⟩
theorem totally_bounded_iff {s : set α} :
totally_bounded s ↔ ∀ ε > 0, ∃t : set α, finite t ∧ s ⊆ ⋃y∈t, ball y ε :=
⟨λ H ε ε0, H _ (dist_mem_uniformity ε0),
λ H r ru, let ⟨ε, ε0, hε⟩ := mem_uniformity_dist.1 ru,
⟨t, ft, h⟩ := H ε ε0 in
⟨t, ft, subset.trans h $ Union_subset_Union $ λ y, Union_subset_Union $ λ yt z, hε⟩⟩
/-- A metric space space is totally bounded if one can reconstruct up to any ε>0 any element of the
space from finitely many data. -/
lemma totally_bounded_of_finite_discretization {α : Type u} [metric_space α] {s : set α}
(H : ∀ε > (0 : ℝ), ∃ (β : Type u) [fintype β] (F : s → β),
∀x y, F x = F y → dist (x:α) y < ε) :
totally_bounded s :=
begin
classical, by_cases hs : s = ∅,
{ rw hs, exact totally_bounded_empty },
rcases exists_mem_of_ne_empty hs with ⟨x0, hx0⟩,
haveI : inhabited s := ⟨⟨x0, hx0⟩⟩,
refine totally_bounded_iff.2 (λ ε ε0, _),
rcases H ε ε0 with ⟨β, fβ, F, hF⟩,
let Finv := function.inv_fun F,
refine ⟨range (subtype.val ∘ Finv), finite_range _, λ x xs, _⟩,
let x' := Finv (F ⟨x, xs⟩),
have : F x' = F ⟨x, xs⟩ := function.inv_fun_eq ⟨⟨x, xs⟩, rfl⟩,
simp only [set.mem_Union, set.mem_range],
exact ⟨_, ⟨F ⟨x, xs⟩, rfl⟩, hF _ _ this.symm⟩
end
protected lemma cauchy_iff {f : filter α} :
cauchy f ↔ f ≠ ⊥ ∧ ∀ ε > 0, ∃ t ∈ f, ∀ x y ∈ t, dist x y < ε :=
cauchy_iff.trans $ and_congr iff.rfl
⟨λ H ε ε0, let ⟨t, tf, ts⟩ := H _ (dist_mem_uniformity ε0) in
⟨t, tf, λ x y xt yt, @ts (x, y) ⟨xt, yt⟩⟩,
λ H r ru, let ⟨ε, ε0, hε⟩ := mem_uniformity_dist.1 ru,
⟨t, tf, h⟩ := H ε ε0 in
⟨t, tf, λ ⟨x, y⟩ ⟨hx, hy⟩, hε (h x y hx hy)⟩⟩
theorem nhds_eq : nhds x = (⨅ε:{ε:ℝ // ε>0}, principal (ball x ε.val)) :=
begin
rw [nhds_eq_uniformity, uniformity_dist', lift'_infi],
{ apply congr_arg, funext ε,
rw [lift'_principal],
{ simp [ball, dist_comm] },
{ exact monotone_preimage } },
{ exact ⟨⟨1, zero_lt_one⟩⟩ },
{ intros, refl }
end
theorem mem_nhds_iff : s ∈ nhds x ↔ ∃ε>0, ball x ε ⊆ s :=
begin
rw [nhds_eq, mem_infi],
{ simp },
{ intros y z, cases y with y hy, cases z with z hz,
refine ⟨⟨min y z, lt_min hy hz⟩, _⟩,
simp [ball_subset_ball, min_le_left, min_le_right, (≥)] },
{ exact ⟨⟨1, zero_lt_one⟩⟩ }
end
theorem is_open_iff : is_open s ↔ ∀x∈s, ∃ε>0, ball x ε ⊆ s :=
by simp [is_open_iff_nhds, mem_nhds_iff]
theorem is_open_ball : is_open (ball x ε) :=
is_open_iff.2 $ λ y, exists_ball_subset_ball
theorem ball_mem_nhds (x : α) {ε : ℝ} (ε0 : 0 < ε) : ball x ε ∈ nhds x :=
mem_nhds_sets is_open_ball (mem_ball_self ε0)
theorem tendsto_nhds_nhds [metric_space β] {f : α → β} {a b} :
tendsto f (nhds a) (nhds b) ↔
∀ ε > 0, ∃ δ > 0, ∀{x:α}, dist x a < δ → dist (f x) b < ε :=
⟨λ H ε ε0, mem_nhds_iff.1 (H (ball_mem_nhds _ ε0)),
λ H s hs,
let ⟨ε, ε0, hε⟩ := mem_nhds_iff.1 hs, ⟨δ, δ0, hδ⟩ := H _ ε0 in
mem_nhds_iff.2 ⟨δ, δ0, λ x h, hε (hδ h)⟩⟩
theorem continuous_iff [metric_space β] {f : α → β} :
continuous f ↔
∀b (ε > 0), ∃ δ > 0, ∀a, dist a b < δ → dist (f a) (f b) < ε :=
continuous_iff_continuous_at.trans $ forall_congr $ λ b, tendsto_nhds_nhds
theorem exists_delta_of_continuous [metric_space β] {f : α → β} {ε : ℝ}
(hf : continuous f) (hε : ε > 0) (b : α) :
∃ δ > 0, ∀a, dist a b ≤ δ → dist (f a) (f b) < ε :=
let ⟨δ, δ_pos, hδ⟩ := continuous_iff.1 hf b ε hε in
⟨δ / 2, half_pos δ_pos, assume a ha, hδ a $ lt_of_le_of_lt ha $ div_two_lt_of_pos δ_pos⟩
theorem tendsto_nhds {f : filter β} {u : β → α} {a : α} :
tendsto u f (nhds a) ↔ ∀ ε > 0, ∃ n ∈ f, ∀x ∈ n, dist (u x) a < ε :=
by simp only [metric.nhds_eq, tendsto_infi, subtype.forall, tendsto_principal, mem_ball];
exact forall_congr (assume ε, forall_congr (assume hε, exists_sets_subset_iff.symm))
theorem continuous_iff' [topological_space β] {f : β → α} :
continuous f ↔ ∀a (ε > 0), ∃ n ∈ nhds a, ∀b ∈ n, dist (f b) (f a) < ε :=
continuous_iff_continuous_at.trans $ forall_congr $ λ b, tendsto_nhds
theorem tendsto_at_top [nonempty β] [semilattice_sup β] {u : β → α} {a : α} :
tendsto u at_top (nhds a) ↔ ∀ε>0, ∃N, ∀n≥N, dist (u n) a < ε :=
by simp only [metric.nhds_eq, tendsto_infi, subtype.forall, tendsto_at_top_principal]; refl
end metric
open metric
instance metric_space.to_separated : separated α :=
separated_def.2 $ λ x y h, eq_of_forall_dist_le $
λ ε ε0, le_of_lt (h _ (dist_mem_uniformity ε0))
/-Instantiate a metric space as an emetric space. Before we can state the instance,
we need to show that the uniform structure coming from the edistance and the
distance coincide. -/
/-- Expressing the uniformity in terms of `edist` -/
protected lemma metric.mem_uniformity_edist {s : set (α×α)} :
s ∈ 𝓤 α ↔ (∃ε>0, ∀{a b:α}, edist a b < ε → (a, b) ∈ s) :=
begin
refine mem_uniformity_dist.trans ⟨_, _⟩; rintro ⟨ε, ε0, Hε⟩,
{ refine ⟨ennreal.of_real ε, _, λ a b, _⟩,
{ rwa [gt, ennreal.of_real_pos] },
{ rw [edist_dist, ennreal.of_real_lt_of_real_iff ε0],
exact Hε } },
{ rcases ennreal.lt_iff_exists_real_btwn.1 ε0 with ⟨ε', _, ε0', hε⟩,
rw [ennreal.of_real_pos] at ε0',
refine ⟨ε', ε0', λ a b h, Hε (lt_trans _ hε)⟩,
rwa [edist_dist, ennreal.of_real_lt_of_real_iff ε0'] }
end
protected theorem metric.uniformity_edist' : 𝓤 α = (⨅ε:{ε:ennreal // ε>0}, principal {p:α×α | edist p.1 p.2 < ε.val}) :=
begin
ext s, rw mem_infi,
{ simp [metric.mem_uniformity_edist, subset_def] },
{ rintro ⟨r, hr⟩ ⟨p, hp⟩, use ⟨min r p, lt_min hr hp⟩,
simp [lt_min_iff, (≥)] {contextual := tt} },
{ exact ⟨⟨1, ennreal.zero_lt_one⟩⟩ }
end
theorem uniformity_edist : 𝓤 α = (⨅ ε>0, principal {p:α×α | edist p.1 p.2 < ε}) :=
by simpa [infi_subtype] using @metric.uniformity_edist' α _
/-- A metric space induces an emetric space -/
instance metric_space.to_emetric_space : emetric_space α :=
{ edist := edist,
edist_self := by simp [edist_dist],
eq_of_edist_eq_zero := assume x y h, by simpa [edist_dist] using h,
edist_comm := by simp only [edist_dist, dist_comm]; simp,
edist_triangle := assume x y z, begin
simp only [edist_dist, (ennreal.of_real_add _ _).symm, dist_nonneg],
rw ennreal.of_real_le_of_real_iff _,
{ exact dist_triangle _ _ _ },
{ simpa using add_le_add (dist_nonneg : 0 ≤ dist x y) dist_nonneg }
end,
uniformity_edist := uniformity_edist,
..‹metric_space α› }
/-- Balls defined using the distance or the edistance coincide -/
lemma metric.emetric_ball {x : α} {ε : ℝ} : emetric.ball x (ennreal.of_real ε) = ball x ε :=
begin
classical, by_cases h : 0 < ε,
{ ext y, by simp [edist_dist, ennreal.of_real_lt_of_real_iff h] },
{ have h' : ε ≤ 0, by simpa using h,
have A : ball x ε = ∅, by simpa [ball_eq_empty_iff_nonpos.symm],
have B : emetric.ball x (ennreal.of_real ε) = ∅,
by simp [ennreal.of_real_eq_zero.2 h', emetric.ball_eq_empty_iff],
rwa [A, B] }
end
/-- Closed balls defined using the distance or the edistance coincide -/
lemma metric.emetric_closed_ball {x : α} {ε : ℝ} (h : 0 ≤ ε) :
emetric.closed_ball x (ennreal.of_real ε) = closed_ball x ε :=
by ext y; simp [edist_dist]; rw ennreal.of_real_le_of_real_iff h
def metric_space.replace_uniformity {α} [U : uniform_space α] (m : metric_space α)
(H : @uniformity _ U = @uniformity _ (metric_space.to_uniform_space α)) :
metric_space α :=
{ dist := @dist _ m.to_has_dist,
dist_self := dist_self,
eq_of_dist_eq_zero := @eq_of_dist_eq_zero _ _,
dist_comm := dist_comm,
dist_triangle := dist_triangle,
edist := edist,
edist_dist := edist_dist,
to_uniform_space := U,
uniformity_dist := H.trans (metric_space.uniformity_dist α) }
/-- One gets a metric space from an emetric space if the edistance
is everywhere finite. We set it up so that the edist and the uniformity are
defeq in the metric space and the emetric space -/
def emetric_space.to_metric_space {α : Type u} [e : emetric_space α] (h : ∀x y: α, edist x y ≠ ⊤) :
metric_space α :=
let m : metric_space α :=
{ dist := λx y, ennreal.to_real (edist x y),
eq_of_dist_eq_zero := λx y hxy, by simpa [dist, ennreal.to_real_eq_zero_iff, h x y] using hxy,
dist_self := λx, by simp,
dist_comm := λx y, by simp [emetric_space.edist_comm],
dist_triangle := λx y z, begin
rw [← ennreal.to_real_add (h _ _) (h _ _), ennreal.to_real_le_to_real (h _ _)],
{ exact edist_triangle _ _ _ },
{ simp [ennreal.add_eq_top, h] }
end,
edist := λx y, edist x y,
edist_dist := λx y, by simp [ennreal.of_real_to_real, h] } in
metric_space.replace_uniformity m (by rw [uniformity_edist, uniformity_edist']; refl)
section real
/-- Instantiate the reals as a metric space. -/
instance real.metric_space : metric_space ℝ :=
{ dist := λx y, abs (x - y),
dist_self := by simp [abs_zero],
eq_of_dist_eq_zero := by simp [add_neg_eq_zero],
dist_comm := assume x y, abs_sub _ _,
dist_triangle := assume x y z, abs_sub_le _ _ _ }
theorem real.dist_eq (x y : ℝ) : dist x y = abs (x - y) := rfl
theorem real.dist_0_eq_abs (x : ℝ) : dist x 0 = abs x :=
by simp [real.dist_eq]
instance : orderable_topology ℝ :=
orderable_topology_of_nhds_abs $ λ x, begin
simp only [show ∀ r, {b : ℝ | abs (x - b) < r} = ball x r,
by simp [-sub_eq_add_neg, abs_sub, ball, real.dist_eq]],
apply le_antisymm,
{ simp [le_infi_iff],
exact λ ε ε0, mem_nhds_sets (is_open_ball) (mem_ball_self ε0) },
{ intros s h,
rcases mem_nhds_iff.1 h with ⟨ε, ε0, ss⟩,
exact mem_infi_sets _ (mem_infi_sets ε0 (mem_principal_sets.2 ss)) },
end
lemma closed_ball_Icc {x r : ℝ} : closed_ball x r = Icc (x-r) (x+r) :=
by ext y; rw [mem_closed_ball, dist_comm, real.dist_eq,
abs_sub_le_iff, mem_Icc, ← sub_le_iff_le_add', sub_le]
lemma squeeze_zero {α} {f g : α → ℝ} {t₀ : filter α} (hf : ∀t, 0 ≤ f t) (hft : ∀t, f t ≤ g t)
(g0 : tendsto g t₀ (nhds 0)) : tendsto f t₀ (nhds 0) :=
begin
apply tendsto_of_tendsto_of_tendsto_of_le_of_le (tendsto_const_nhds) g0;
simp [*]; exact filter.univ_mem_sets
end
theorem metric.uniformity_eq_comap_nhds_zero :
𝓤 α = comap (λp:α×α, dist p.1 p.2) (nhds (0 : ℝ)) :=
begin
simp only [uniformity_dist', nhds_eq, comap_infi, comap_principal],
congr, funext ε,
rw [principal_eq_iff_eq],
ext ⟨a, b⟩,
simp [real.dist_0_eq_abs]
end
lemma cauchy_seq_iff_tendsto_dist_at_top_0 [inhabited β] [semilattice_sup β] {u : β → α} :
cauchy_seq u ↔ tendsto (λ (n : β × β), dist (u n.1) (u n.2)) at_top (nhds 0) :=
by rw [cauchy_seq_iff_prod_map, metric.uniformity_eq_comap_nhds_zero, ← map_le_iff_le_comap,
filter.map_map, tendsto, prod.map_def]
end real
section cauchy_seq
variables [inhabited β] [semilattice_sup β]
/-- In a metric space, Cauchy sequences are characterized by the fact that, eventually,
the distance between its elements is arbitrarily small -/
theorem metric.cauchy_seq_iff {u : β → α} :
cauchy_seq u ↔ ∀ε>0, ∃N, ∀m n≥N, dist (u m) (u n) < ε :=
begin
unfold cauchy_seq,
rw metric.cauchy_iff,
simp only [true_and, exists_prop, filter.mem_at_top_sets, filter.at_top_ne_bot,
filter.mem_map, ne.def, filter.map_eq_bot_iff, not_false_iff, set.mem_set_of_eq],
split,
{ intros H ε εpos,
rcases H ε εpos with ⟨t, ⟨N, hN⟩, ht⟩,
exact ⟨N, λm n hm hn, ht _ _ (hN _ hm) (hN _ hn)⟩ },
{ intros H ε εpos,
rcases H (ε/2) (half_pos εpos) with ⟨N, hN⟩,
existsi ball (u N) (ε/2),
split,
{ exact ⟨N, λx hx, hN _ _ hx (le_refl N)⟩ },
{ exact λx y hx hy, calc
dist x y ≤ dist x (u N) + dist y (u N) : dist_triangle_right _ _ _
... < ε/2 + ε/2 : add_lt_add hx hy
... = ε : add_halves _ } }
end
/-- A variation around the metric characterization of Cauchy sequences -/
theorem metric.cauchy_seq_iff' {u : β → α} :
cauchy_seq u ↔ ∀ε>0, ∃N, ∀n≥N, dist (u n) (u N) < ε :=
begin
rw metric.cauchy_seq_iff,
split,
{ intros H ε εpos,
rcases H ε εpos with ⟨N, hN⟩,
exact ⟨N, λn hn, hN _ _ hn (le_refl N)⟩ },
{ intros H ε εpos,
rcases H (ε/2) (half_pos εpos) with ⟨N, hN⟩,
exact ⟨N, λ m n hm hn, calc
dist (u m) (u n) ≤ dist (u m) (u N) + dist (u n) (u N) : dist_triangle_right _ _ _
... < ε/2 + ε/2 : add_lt_add (hN _ hm) (hN _ hn)
... = ε : add_halves _⟩ }
end
/-- A Cauchy sequence on the natural numbers is bounded. -/
theorem cauchy_seq_bdd {u : ℕ → α} (hu : cauchy_seq u) :
∃ R > 0, ∀ m n, dist (u m) (u n) < R :=
begin
rcases metric.cauchy_seq_iff'.1 hu 1 zero_lt_one with ⟨N, hN⟩,
suffices : ∃ R > 0, ∀ n, dist (u n) (u N) < R,
{ rcases this with ⟨R, R0, H⟩,
exact ⟨_, add_pos R0 R0, λ m n,
lt_of_le_of_lt (dist_triangle_right _ _ _) (add_lt_add (H m) (H n))⟩ },
let R := finset.sup (finset.range N) (λ n, nndist (u n) (u N)),
refine ⟨↑R + 1, add_pos_of_nonneg_of_pos R.2 zero_lt_one, λ n, _⟩,
cases le_or_lt N n,
{ exact lt_of_lt_of_le (hN _ h) (le_add_of_nonneg_left R.2) },
{ have : _ ≤ R := finset.le_sup (finset.mem_range.2 h),
exact lt_of_le_of_lt this (lt_add_of_pos_right _ zero_lt_one) }
end
/-- Yet another metric characterization of Cauchy sequences on integers. This one is often the
most efficient. -/
lemma cauchy_seq_iff_le_tendsto_0 {s : ℕ → α} : cauchy_seq s ↔ ∃ b : ℕ → ℝ,
(∀ n, 0 ≤ b n) ∧
(∀ n m N : ℕ, N ≤ n → N ≤ m → dist (s n) (s m) ≤ b N) ∧
tendsto b at_top (nhds 0) :=
⟨λ hs, begin
/- `s` is a Cauchy sequence. The sequence `b` will be constructed by taking
the supremum of the distances between `s n` and `s m` for `n m ≥ N`.
First, we prove that all these distances are bounded, as otherwise the Sup
would not make sense. -/
let S := λ N, (λ(p : ℕ × ℕ), dist (s p.1) (s p.2)) '' {p | p.1 ≥ N ∧ p.2 ≥ N},
have hS : ∀ N, ∃ x, ∀ y ∈ S N, y ≤ x,
{ rcases cauchy_seq_bdd hs with ⟨R, R0, hR⟩,
refine λ N, ⟨R, _⟩, rintro _ ⟨⟨m, n⟩, _, rfl⟩,
exact le_of_lt (hR m n) },
have bdd : bdd_above (range (λ(p : ℕ × ℕ), dist (s p.1) (s p.2))),
{ rcases cauchy_seq_bdd hs with ⟨R, R0, hR⟩,
use R, rintro _ ⟨⟨m, n⟩, rfl⟩, exact le_of_lt (hR m n) },
-- Prove that it bounds the distances of points in the Cauchy sequence
have ub : ∀ m n N, N ≤ m → N ≤ n → dist (s m) (s n) ≤ real.Sup (S N) :=
λ m n N hm hn, real.le_Sup _ (hS N) ⟨⟨_, _⟩, ⟨hm, hn⟩, rfl⟩,
have S0m : ∀ n, (0:ℝ) ∈ S n := λ n, ⟨⟨n, n⟩, ⟨le_refl _, le_refl _⟩, dist_self _⟩,
have S0 := λ n, real.le_Sup _ (hS n) (S0m n),
-- Prove that it tends to `0`, by using the Cauchy property of `s`
refine ⟨λ N, real.Sup (S N), S0, ub, metric.tendsto_at_top.2 (λ ε ε0, _)⟩,
refine (metric.cauchy_seq_iff.1 hs (ε/2) (half_pos ε0)).imp (λ N hN n hn, _),
rw [real.dist_0_eq_abs, abs_of_nonneg (S0 n)],
refine lt_of_le_of_lt (real.Sup_le_ub _ ⟨_, S0m _⟩ _) (half_lt_self ε0),
rintro _ ⟨⟨m', n'⟩, ⟨hm', hn'⟩, rfl⟩,
exact le_of_lt (hN _ _ (le_trans hn hm') (le_trans hn hn'))
end,
λ ⟨b, _, b_bound, b_lim⟩, metric.cauchy_seq_iff.2 $ λ ε ε0,
(metric.tendsto_at_top.1 b_lim ε ε0).imp $ λ N hN m n hm hn,
calc dist (s m) (s n) ≤ b N : b_bound m n N hm hn
... ≤ abs (b N) : le_abs_self _
... = dist (b N) 0 : by rw real.dist_0_eq_abs; refl
... < ε : (hN _ (le_refl N)) ⟩
end cauchy_seq
def metric_space.induced {α β} (f : α → β) (hf : function.injective f)
(m : metric_space β) : metric_space α :=
{ dist := λ x y, dist (f x) (f y),
dist_self := λ x, dist_self _,
eq_of_dist_eq_zero := λ x y h, hf (dist_eq_zero.1 h),
dist_comm := λ x y, dist_comm _ _,
dist_triangle := λ x y z, dist_triangle _ _ _,
edist := λ x y, edist (f x) (f y),
edist_dist := λ x y, edist_dist _ _,
to_uniform_space := uniform_space.comap f m.to_uniform_space,
uniformity_dist := begin
apply @uniformity_dist_of_mem_uniformity _ _ _ _ _ (λ x y, dist (f x) (f y)),
refine λ s, mem_comap_sets.trans _,
split; intro H,
{ rcases H with ⟨r, ru, rs⟩,
rcases mem_uniformity_dist.1 ru with ⟨ε, ε0, hε⟩,
refine ⟨ε, ε0, λ a b h, rs (hε _)⟩, exact h },
{ rcases H with ⟨ε, ε0, hε⟩,
exact ⟨_, dist_mem_uniformity ε0, λ ⟨a, b⟩, hε⟩ }
end }
instance subtype.metric_space {p : α → Prop} [t : metric_space α] : metric_space (subtype p) :=
metric_space.induced subtype.val (λ x y, subtype.eq) t
theorem subtype.dist_eq {p : α → Prop} [t : metric_space α] (x y : subtype p) :
dist x y = dist x.1 y.1 := rfl
section nnreal
instance : metric_space nnreal := by unfold nnreal; apply_instance
end nnreal
section prod
instance prod.metric_space_max [metric_space β] : metric_space (α × β) :=
{ dist := λ x y, max (dist x.1 y.1) (dist x.2 y.2),
dist_self := λ x, by simp,
eq_of_dist_eq_zero := λ x y h, begin
cases max_le_iff.1 (le_of_eq h) with h₁ h₂,
exact prod.ext_iff.2 ⟨dist_le_zero.1 h₁, dist_le_zero.1 h₂⟩
end,
dist_comm := λ x y, by simp [dist_comm],
dist_triangle := λ x y z, max_le
(le_trans (dist_triangle _ _ _) (add_le_add (le_max_left _ _) (le_max_left _ _)))
(le_trans (dist_triangle _ _ _) (add_le_add (le_max_right _ _) (le_max_right _ _))),
edist := λ x y, max (edist x.1 y.1) (edist x.2 y.2),
edist_dist := assume x y, begin
have : monotone ennreal.of_real := assume x y h, ennreal.of_real_le_of_real h,
rw [edist_dist, edist_dist, (max_distrib_of_monotone this).symm]
end,
uniformity_dist := begin
refine uniformity_prod.trans _,
simp [uniformity_dist, comap_infi],
rw ← infi_inf_eq, congr, funext,
rw ← infi_inf_eq, congr, funext,
simp [inf_principal, ext_iff, max_lt_iff]
end,
to_uniform_space := prod.uniform_space }
lemma prod.dist_eq [metric_space β] {x y : α × β} :
dist x y = max (dist x.1 y.1) (dist x.2 y.2) := rfl
end prod
theorem uniform_continuous_dist' : uniform_continuous (λp:α×α, dist p.1 p.2) :=
metric.uniform_continuous_iff.2 (λ ε ε0, ⟨ε/2, half_pos ε0,
begin
suffices,
{ intros p q h, cases p with p₁ p₂, cases q with q₁ q₂,
cases max_lt_iff.1 h with h₁ h₂, clear h,
dsimp at h₁ h₂ ⊢,
rw real.dist_eq,
refine abs_sub_lt_iff.2 ⟨_, _⟩,
{ revert p₁ p₂ q₁ q₂ h₁ h₂, exact this },
{ apply this; rwa dist_comm } },
intros p₁ p₂ q₁ q₂ h₁ h₂,
have := add_lt_add
(abs_sub_lt_iff.1 (lt_of_le_of_lt (abs_dist_sub_le p₁ q₁ p₂) h₁)).1
(abs_sub_lt_iff.1 (lt_of_le_of_lt (abs_dist_sub_le p₂ q₂ q₁) h₂)).1,
rwa [add_halves, dist_comm p₂, sub_add_sub_cancel, dist_comm q₂] at this
end⟩)
theorem uniform_continuous_dist [uniform_space β] {f g : β → α}
(hf : uniform_continuous f) (hg : uniform_continuous g) :
uniform_continuous (λb, dist (f b) (g b)) :=
(hf.prod_mk hg).comp uniform_continuous_dist'
theorem continuous_dist' : continuous (λp:α×α, dist p.1 p.2) :=
uniform_continuous_dist'.continuous
theorem continuous_dist [topological_space β] {f g : β → α}
(hf : continuous f) (hg : continuous g) : continuous (λb, dist (f b) (g b)) :=
(hf.prod_mk hg).comp continuous_dist'
theorem tendsto_dist {f g : β → α} {x : filter β} {a b : α}
(hf : tendsto f x (nhds a)) (hg : tendsto g x (nhds b)) :
tendsto (λx, dist (f x) (g x)) x (nhds (dist a b)) :=
have tendsto (λp:α×α, dist p.1 p.2) (nhds (a, b)) (nhds (dist a b)),
from continuous_iff_continuous_at.mp continuous_dist' (a, b),
(hf.prod_mk hg).comp (by rw [nhds_prod_eq] at this; exact this)
lemma nhds_comap_dist (a : α) : (nhds (0 : ℝ)).comap (λa', dist a' a) = nhds a :=
have h₁ : ∀ε, (λa', dist a' a) ⁻¹' ball 0 ε ⊆ ball a ε,
by simp [subset_def, real.dist_0_eq_abs],
have h₂ : tendsto (λa', dist a' a) (nhds a) (nhds (dist a a)),
from tendsto_dist tendsto_id tendsto_const_nhds,
le_antisymm
(by simp [h₁, nhds_eq, infi_le_infi, principal_mono,
-le_principal_iff, -le_infi_iff])
(by simpa [map_le_iff_le_comap.symm, tendsto] using h₂)
lemma tendsto_iff_dist_tendsto_zero {f : β → α} {x : filter β} {a : α} :
(tendsto f x (nhds a)) ↔ (tendsto (λb, dist (f b) a) x (nhds 0)) :=
by rw [← nhds_comap_dist a, tendsto_comap_iff]
lemma uniform_continuous_nndist' : uniform_continuous (λp:α×α, nndist p.1 p.2) :=
uniform_continuous_subtype_mk uniform_continuous_dist' _
lemma continuous_nndist' : continuous (λp:α×α, nndist p.1 p.2) :=
uniform_continuous_nndist'.continuous
lemma tendsto_nndist' (a b :α) :
tendsto (λp:α×α, nndist p.1 p.2) (filter.prod (nhds a) (nhds b)) (nhds (nndist a b)) :=
by rw [← nhds_prod_eq]; exact continuous_iff_continuous_at.1 continuous_nndist' _
namespace metric
variables {x y z : α} {ε ε₁ ε₂ : ℝ} {s : set α}
theorem is_closed_ball : is_closed (closed_ball x ε) :=
is_closed_le (continuous_dist continuous_id continuous_const) continuous_const
/-- ε-characterization of the closure in metric spaces-/
theorem mem_closure_iff' {α : Type u} [metric_space α] {s : set α} {a : α} :
a ∈ closure s ↔ ∀ε>0, ∃b ∈ s, dist a b < ε :=
⟨begin
intros ha ε hε,
have A : ball a ε ∩ s ≠ ∅ := mem_closure_iff.1 ha _ is_open_ball (mem_ball_self hε),
cases ne_empty_iff_exists_mem.1 A with b hb,
simp,
exact ⟨b, ⟨hb.2, by have B := hb.1; simpa [mem_ball'] using B⟩⟩
end,
begin
intros H,
apply mem_closure_iff.2,
intros o ho ao,
rcases is_open_iff.1 ho a ao with ⟨ε, ⟨εpos, hε⟩⟩,
rcases H ε εpos with ⟨b, ⟨bs, bdist⟩⟩,
have B : b ∈ o ∩ s := ⟨hε (by simpa [dist_comm]), bs⟩,
apply ne_empty_of_mem B
end⟩
theorem mem_of_closed' {α : Type u} [metric_space α] {s : set α} (hs : is_closed s)
{a : α} : a ∈ s ↔ ∀ε>0, ∃b ∈ s, dist a b < ε :=
by simpa only [closure_eq_of_is_closed hs] using @mem_closure_iff' _ _ s a
end metric
section pi
open finset lattice
variables {π : β → Type*} [fintype β] [∀b, metric_space (π b)]
instance has_dist_pi : has_dist (Πb, π b) :=
⟨λf g, ((finset.sup univ (λb, nndist (f b) (g b)) : nnreal) : ℝ)⟩
lemma dist_pi_def (f g : Πb, π b) :
dist f g = (finset.sup univ (λb, nndist (f b) (g b)) : nnreal) := rfl
instance metric_space_pi : metric_space (Πb, π b) :=
{ dist := dist,
dist_self := assume f, (nnreal.coe_eq_zero _).2 $ bot_unique $ finset.sup_le $ by simp,
dist_comm := assume f g, nnreal.eq_iff.2 $ by congr; ext a; exact nndist_comm _ _,
dist_triangle := assume f g h, show dist f h ≤ (dist f g) + (dist g h), from
begin
simp only [dist_pi_def, (nnreal.coe_add _ _).symm, nnreal.coe_le.symm,
finset.sup_le_iff],
assume b hb,
exact le_trans (nndist_triangle _ (g b) _) (add_le_add (le_sup hb) (le_sup hb))
end,
eq_of_dist_eq_zero := assume f g eq0,
begin
simp only [dist_pi_def, nnreal.coe_eq_zero, nnreal.bot_eq_zero.symm, eq_bot_iff,
finset.sup_le_iff] at eq0,
exact (funext $ assume b, eq_of_nndist_eq_zero $ bot_unique $ eq0 b $ mem_univ b),
end,
edist := λ f g, finset.sup univ (λb, edist (f b) (g b)),
edist_dist := assume x y, begin
have A : sup univ (λ (b : β), ((nndist (x b) (y b)) : ennreal)) = ↑(sup univ (λ (b : β), nndist (x b) (y b))),
{ refine eq.symm (comp_sup_eq_sup_comp _ _ _),
exact (assume x y h, ennreal.coe_le_coe.2 h), refl },
simp [dist, edist_nndist, ennreal.of_real, A]
end }
end pi
section compact
/-- Any compact set in a metric space can be covered by finitely many balls of a given positive
radius -/
lemma finite_cover_balls_of_compact {α : Type u} [metric_space α] {s : set α}
(hs : compact s) {e : ℝ} (he : e > 0) :
∃t ⊆ s, finite t ∧ s ⊆ ⋃x∈t, ball x e :=
begin
apply compact_elim_finite_subcover_image hs,
{ simp [is_open_ball] },
{ intros x xs,
simp,
exact ⟨x, ⟨xs, by simpa⟩⟩ }
end
end compact
section proper_space
open metric
/-- A metric space is proper if all closed balls are compact. -/
class proper_space (α : Type u) [metric_space α] : Prop :=
(compact_ball : ∀x:α, ∀r, compact (closed_ball x r))
/- A compact metric space is proper -/
instance proper_of_compact [metric_space α] [compact_space α] : proper_space α :=
⟨assume x r, compact_of_is_closed_subset compact_univ is_closed_ball (subset_univ _)⟩
/-- A proper space is locally compact -/
instance locally_compact_of_proper [metric_space α] [proper_space α] :
locally_compact_space α :=
begin
apply locally_compact_of_compact_nhds,
intros x,
existsi closed_ball x 1,
split,
{ apply mem_nhds_iff.2,
existsi (1 : ℝ),
simp,
exact ⟨zero_lt_one, ball_subset_closed_ball⟩ },
{ apply proper_space.compact_ball }
end
/-- A proper space is complete -/
instance complete_of_proper {α : Type u} [metric_space α] [proper_space α] : complete_space α :=
⟨begin
intros f hf,
/- We want to show that the Cauchy filter `f` is converging. It suffices to find a closed
ball (therefore compact by properness) where it is nontrivial. -/
have A : ∃ t ∈ f, ∀ x y ∈ t, dist x y < 1 := (metric.cauchy_iff.1 hf).2 1 zero_lt_one,
rcases A with ⟨t, ⟨t_fset, ht⟩⟩,
rcases inhabited_of_mem_sets hf.1 t_fset with ⟨x, xt⟩,
have : t ⊆ closed_ball x 1 := by intros y yt; simp [dist_comm]; apply le_of_lt (ht x y xt yt),
have : closed_ball x 1 ∈ f := f.sets_of_superset t_fset this,
rcases (compact_iff_totally_bounded_complete.1 (proper_space.compact_ball x 1)).2 f hf (le_principal_iff.2 this)
with ⟨y, _, hy⟩,
exact ⟨y, hy⟩
end⟩
/-- A proper metric space is separable, and therefore second countable. Indeed, any ball is
compact, and therefore admits a countable dense subset. Taking a countable union over the balls
centered at a fixed point and with integer radius, one obtains a countable set which is
dense in the whole space. -/
instance second_countable_of_proper [metric_space α] [proper_space α] :
second_countable_topology α :=
begin
/- We show that the space admits a countable dense subset. The case where the space is empty
is special, and trivial. -/
have A : (univ : set α) = ∅ → ∃(s : set α), countable s ∧ closure s = (univ : set α) :=
assume H, ⟨∅, ⟨by simp, by simp; exact H.symm⟩⟩,
have B : (univ : set α) ≠ ∅ → ∃(s : set α), countable s ∧ closure s = (univ : set α) :=
begin
/- When the space is not empty, we take a point `x` in the space, and then a countable set
`T r` which is dense in the closed ball `closed_ball x r` for each `r`. Then the set
`t = ⋃ T n` (where the union is over all integers `n`) is countable, as a countable union
of countable sets, and dense in the space by construction. -/
assume non_empty,
rcases ne_empty_iff_exists_mem.1 non_empty with ⟨x, x_univ⟩,
choose T a using show ∀ (r:ℝ), ∃ t ⊆ closed_ball x r, (countable (t : set α) ∧ closed_ball x r = closure t),
from assume r, emetric.countable_closure_of_compact (proper_space.compact_ball _ _),
let t := (⋃n:ℕ, T (n : ℝ)),
have T₁ : countable t := by finish [countable_Union],
have T₂ : closure t ⊆ univ := by simp,
have T₃ : univ ⊆ closure t :=
begin
intros y y_univ,
rcases exists_nat_gt (dist y x) with ⟨n, n_large⟩,
have h : y ∈ closed_ball x (n : ℝ) := by simp; apply le_of_lt n_large,
have h' : closed_ball x (n : ℝ) = closure (T (n : ℝ)) := by finish,
have : y ∈ closure (T (n : ℝ)) := by rwa h' at h,
show y ∈ closure t, from mem_of_mem_of_subset this (by apply closure_mono; apply subset_Union (λ(n:ℕ), T (n:ℝ))),
end,
exact ⟨t, ⟨T₁, subset.antisymm T₂ T₃⟩⟩
end,
haveI : separable_space α := ⟨by_cases A B⟩,
apply emetric.second_countable_of_separable,
end
end proper_space
namespace metric
section second_countable
open topological_space
/-- A metric space is second countable if, for every ε > 0, there is a countable set which is ε-dense. -/
lemma second_countable_of_almost_dense_set
(H : ∀ε > (0 : ℝ), ∃ s : set α, countable s ∧ (∀x, ∃y ∈ s, dist x y ≤ ε)) :
second_countable_topology α :=
begin
choose T T_dense using H,
have I1 : ∀n:ℕ, (n:ℝ) + 1 > 0 :=
λn, lt_of_lt_of_le zero_lt_one (le_add_of_nonneg_left (nat.cast_nonneg _)),
have I : ∀n:ℕ, (n+1 : ℝ)⁻¹ > 0 := λn, inv_pos'.2 (I1 n),
let t := ⋃n:ℕ, T (n+1)⁻¹ (I n),
have count_t : countable t := by finish [countable_Union],
have clos_t : closure t = univ,
{ refine subset.antisymm (subset_univ _) (λx xuniv, mem_closure_iff'.2 (λε εpos, _)),
rcases exists_nat_gt ε⁻¹ with ⟨n, hn⟩,
have : ε⁻¹ < n + 1 := lt_of_lt_of_le hn (le_add_of_nonneg_right zero_le_one),
have nε : ((n:ℝ)+1)⁻¹ < ε := (inv_lt (I1 n) εpos).2 this,
rcases (T_dense (n+1)⁻¹ (I n)).2 x with ⟨y, yT, Dxy⟩,
have : y ∈ t := mem_of_mem_of_subset yT (by apply subset_Union (λ (n:ℕ), T (n+1)⁻¹ (I n))),
exact ⟨y, this, lt_of_le_of_lt Dxy nε⟩ },
haveI : separable_space α := ⟨⟨t, ⟨count_t, clos_t⟩⟩⟩,
exact emetric.second_countable_of_separable α
end
/-- A metric space space is second countable if one can reconstruct up to any ε>0 any element of the
space from countably many data. -/
lemma second_countable_of_countable_discretization {α : Type u} [metric_space α]
(H : ∀ε > (0 : ℝ), ∃ (β : Type u) [encodable β] (F : α → β), ∀x y, F x = F y → dist x y ≤ ε) :
second_countable_topology α :=
begin
classical, by_cases hs : (univ : set α) = ∅,
{ haveI : compact_space α := ⟨by rw hs; exact compact_of_finite (set.finite_empty)⟩, by apply_instance },
rcases exists_mem_of_ne_empty hs with ⟨x0, hx0⟩,
letI : inhabited α := ⟨x0⟩,
refine second_countable_of_almost_dense_set (λε ε0, _),
rcases H ε ε0 with ⟨β, fβ, F, hF⟩,
let Finv := function.inv_fun F,
refine ⟨range Finv, ⟨countable_range _, λx, _⟩⟩,
let x' := Finv (F x),
have : F x' = F x := function.inv_fun_eq ⟨x, rfl⟩,
exact ⟨x', mem_range_self _, hF _ _ this.symm⟩
end
end second_countable
end metric
lemma lebesgue_number_lemma_of_metric
{s : set α} {ι} {c : ι → set α} (hs : compact s)
(hc₁ : ∀ i, is_open (c i)) (hc₂ : s ⊆ ⋃ i, c i) :
∃ δ > 0, ∀ x ∈ s, ∃ i, ball x δ ⊆ c i :=
let ⟨n, en, hn⟩ := lebesgue_number_lemma hs hc₁ hc₂,
⟨δ, δ0, hδ⟩ := mem_uniformity_dist.1 en in
⟨δ, δ0, assume x hx, let ⟨i, hi⟩ := hn x hx in
⟨i, assume y hy, hi (hδ (mem_ball'.mp hy))⟩⟩
lemma lebesgue_number_lemma_of_metric_sUnion
{s : set α} {c : set (set α)} (hs : compact s)
(hc₁ : ∀ t ∈ c, is_open t) (hc₂ : s ⊆ ⋃₀ c) :
∃ δ > 0, ∀ x ∈ s, ∃ t ∈ c, ball x δ ⊆ t :=
by rw sUnion_eq_Union at hc₂;
simpa using lebesgue_number_lemma_of_metric hs (by simpa) hc₂
namespace metric
/-- Boundedness of a subset of a metric space. We formulate the definition to work
even in the empty space. -/
def bounded (s : set α) : Prop :=
∃C, ∀x y ∈ s, dist x y ≤ C
section bounded
variables {x : α} {s t : set α} {r : ℝ}
@[simp] lemma bounded_empty : bounded (∅ : set α) :=
⟨0, by simp⟩
lemma bounded_iff_mem_bounded : bounded s ↔ ∀ x ∈ s, bounded s :=
⟨λ h _ _, h, λ H, begin
classical, by_cases s = ∅,
{ subst s, exact ⟨0, by simp⟩ },
{ rcases exists_mem_of_ne_empty h with ⟨x, hx⟩,
exact H x hx }
end⟩
/-- Subsets of a bounded set are also bounded -/
lemma bounded.subset (incl : s ⊆ t) : bounded t → bounded s :=
Exists.imp $ λ C hC x y hx hy, hC x y (incl hx) (incl hy)
/-- Closed balls are bounded -/
lemma bounded_closed_ball : bounded (closed_ball x r) :=
⟨r + r, λ y z hy hz, begin
simp only [mem_closed_ball] at *,
calc dist y z ≤ dist y x + dist z x : dist_triangle_right _ _ _
... ≤ r + r : add_le_add hy hz
end⟩
/-- Open balls are bounded -/
lemma bounded_ball : bounded (ball x r) :=
bounded_closed_ball.subset ball_subset_closed_ball
/-- Given a point, a bounded subset is included in some ball around this point -/
lemma bounded_iff_subset_ball (c : α) : bounded s ↔ ∃r, s ⊆ closed_ball c r :=
begin
split; rintro ⟨C, hC⟩,
{ classical, by_cases s = ∅,
{ subst s, exact ⟨0, by simp⟩ },
{ rcases exists_mem_of_ne_empty h with ⟨x, hx⟩,
exact ⟨C + dist x c, λ y hy, calc
dist y c ≤ dist y x + dist x c : dist_triangle _ _ _
... ≤ C + dist x c : add_le_add_right (hC y x hy hx) _⟩ } },
{ exact bounded_closed_ball.subset hC }
end
/-- The union of two bounded sets is bounded iff each of the sets is bounded -/
@[simp] lemma bounded_union :
bounded (s ∪ t) ↔ bounded s ∧ bounded t :=
⟨λh, ⟨h.subset (by simp), h.subset (by simp)⟩,
begin
rintro ⟨hs, ht⟩,
refine bounded_iff_mem_bounded.2 (λ x _, _),
rw bounded_iff_subset_ball x at hs ht ⊢,
rcases hs with ⟨Cs, hCs⟩, rcases ht with ⟨Ct, hCt⟩,
exact ⟨max Cs Ct, union_subset
(subset.trans hCs $ closed_ball_subset_closed_ball $ le_max_left _ _)
(subset.trans hCt $ closed_ball_subset_closed_ball $ le_max_right _ _)⟩,
end⟩
/-- A finite union of bounded sets is bounded -/
lemma bounded_bUnion {I : set β} {s : β → set α} (H : finite I) :
bounded (⋃i∈I, s i) ↔ ∀i ∈ I, bounded (s i) :=
finite.induction_on H (by simp) $ λ x I _ _ IH,
by simp [or_imp_distrib, forall_and_distrib, IH]
/-- A compact set is bounded -/
lemma bounded_of_compact {s : set α} (h : compact s) : bounded s :=
-- We cover the compact set by finitely many balls of radius 1,
-- and then argue that a finite union of bounded sets is bounded
let ⟨t, ht, fint, subs⟩ := finite_cover_balls_of_compact h zero_lt_one in
bounded.subset subs $ (bounded_bUnion fint).2 $ λ i hi, bounded_ball
/-- A finite set is bounded -/
lemma bounded_of_finite {s : set α} (h : finite s) : bounded s :=
bounded_of_compact $ compact_of_finite h
/-- A singleton is bounded -/
lemma bounded_singleton {x : α} : bounded ({x} : set α) :=
bounded_of_finite $ finite_singleton _
/-- Characterization of the boundedness of the range of a function -/
lemma bounded_range_iff {f : β → α} : bounded (range f) ↔ ∃C, ∀x y, dist (f x) (f y) ≤ C :=
exists_congr $ λ C, ⟨
λ H x y, H _ _ ⟨x, rfl⟩ ⟨y, rfl⟩,
by rintro H _ _ ⟨x, rfl⟩ ⟨y, rfl⟩; exact H x y⟩
/-- In a compact space, all sets are bounded -/
lemma bounded_of_compact_space [compact_space α] : bounded s :=
(bounded_of_compact compact_univ).subset (subset_univ _)
/-- In a proper space, a set is compact if and only if it is closed and bounded -/
lemma compact_iff_closed_bounded [proper_space α] :
compact s ↔ is_closed s ∧ bounded s :=
⟨λ h, ⟨closed_of_compact _ h, bounded_of_compact h⟩, begin
rintro ⟨hc, hb⟩,
classical, by_cases s = ∅, {simp [h, compact_empty]},
rcases exists_mem_of_ne_empty h with ⟨x, hx⟩,
rcases (bounded_iff_subset_ball x).1 hb with ⟨r, hr⟩,
exact compact_of_is_closed_subset (proper_space.compact_ball x r) hc hr
end⟩
end bounded
section diam
variables {s : set α} {x y : α}
/-- The diameter of a set in a metric space. To get controllable behavior even when the diameter
should be infinite, we express it in terms of the emetric.diameter -/
def diam (s : set α) : ℝ := ennreal.to_real (emetric.diam s)
/-- The diameter of a set is always nonnegative -/
lemma diam_nonneg : 0 ≤ diam s :=
by simp [diam]
/-- The empty set has zero diameter -/
@[simp] lemma diam_empty : diam (∅ : set α) = 0 :=
by simp [diam]
/-- A singleton has zero diameter -/
@[simp] lemma diam_singleton : diam ({x} : set α) = 0 :=
by simp [diam]
/-- Characterize the boundedness of a set in terms of the finiteness of its emetric.diameter. -/
lemma bounded_iff_diam_ne_top : bounded s ↔ emetric.diam s ≠ ⊤ :=
begin
classical, by_cases hs : s = ∅,
{ simp [hs] },
{ rcases ne_empty_iff_exists_mem.1 hs with ⟨x, hx⟩,
split,
{ assume bs,
rcases (bounded_iff_subset_ball x).1 bs with ⟨r, hr⟩,
have r0 : 0 ≤ r := by simpa [closed_ball] using hr hx,
have : emetric.diam s < ⊤ := calc
emetric.diam s ≤ emetric.diam (emetric.closed_ball x (ennreal.of_real r)) :
by rw emetric_closed_ball r0; exact emetric.diam_mono hr
... ≤ 2 * (ennreal.of_real r) : emetric.diam_closed_ball
... < ⊤ : begin apply ennreal.lt_top_iff_ne_top.2, simp [ennreal.mul_eq_top], end,
exact ennreal.lt_top_iff_ne_top.1 this },
{ assume ds,
have : s ⊆ closed_ball x (ennreal.to_real (emetric.diam s)),
{ rw [← emetric_closed_ball ennreal.to_real_nonneg, ennreal.of_real_to_real ds],
exact λy hy, emetric.edist_le_diam_of_mem hy hx },
exact bounded.subset this (bounded_closed_ball) }}
end
/-- An unbounded set has zero diameter. If you would prefer to get the value ∞, use `emetric.diam`.
This lemma makes it possible to avoid side conditions in some situations -/
lemma diam_eq_zero_of_unbounded (h : ¬(bounded s)) : diam s = 0 :=
begin
simp only [bounded_iff_diam_ne_top, not_not, ne.def] at h,
simp [diam, h]
end
/-- If `s ⊆ t`, then the diameter of `s` is bounded by that of `t`, provided `t` is bounded. -/
lemma diam_mono {s t : set α} (h : s ⊆ t) (ht : bounded t) : diam s ≤ diam t :=
begin
unfold diam,
rw ennreal.to_real_le_to_real (bounded_iff_diam_ne_top.1 (bounded.subset h ht)) (bounded_iff_diam_ne_top.1 ht),
exact emetric.diam_mono h
end
/-- The distance between two points in a set is controlled by the diameter of the set. -/
lemma dist_le_diam_of_mem (h : bounded s) (hx : x ∈ s) (hy : y ∈ s) : dist x y ≤ diam s :=
begin
rw [diam, dist_edist],
rw ennreal.to_real_le_to_real (edist_ne_top _ _) (bounded_iff_diam_ne_top.1 h),
exact emetric.edist_le_diam_of_mem hx hy
end
/-- If the distance between any two points in a set is bounded by some constant, this constant
bounds the diameter. -/
lemma diam_le_of_forall_dist_le {d : real} (hd : d ≥ 0) (h : ∀x y ∈ s, dist x y ≤ d) : diam s ≤ d :=
begin
have I : emetric.diam s ≤ ennreal.of_real d,
{ refine emetric.diam_le_of_forall_edist_le (λx y hx hy, _),
rw [edist_dist],
exact ennreal.of_real_le_of_real (h x y hx hy) },
have A : emetric.diam s ≠ ⊤ :=
ennreal.lt_top_iff_ne_top.1 (lt_of_le_of_lt I (ennreal.lt_top_iff_ne_top.2 (by simp))),
rw [← ennreal.to_real_of_real hd, diam, ennreal.to_real_le_to_real A],
{ exact I },
{ simp }
end
/-- The diameter of a union is controlled by the sum of the diameters, and the distance between
any two points in each of the sets. This lemma is true without any side condition, since it is
obviously true if `s ∪ t` is unbounded. -/
lemma diam_union {t : set α} (xs : x ∈ s) (yt : y ∈ t) : diam (s ∪ t) ≤ diam s + dist x y + diam t :=
have I1 : ¬(bounded (s ∪ t)) → diam (s ∪ t) ≤ diam s + dist x y + diam t := λh, calc
diam (s ∪ t) = 0 + 0 + 0 : by simp [diam_eq_zero_of_unbounded h]
... ≤ diam s + dist x y + diam t : add_le_add (add_le_add diam_nonneg dist_nonneg) diam_nonneg,
have I2 : (bounded (s ∪ t)) → diam (s ∪ t) ≤ diam s + dist x y + diam t := λh,
begin
have : bounded s := bounded.subset (subset_union_left _ _) h,
have : bounded t := bounded.subset (subset_union_right _ _) h,
have A : ∀a ∈ s, ∀b ∈ t, dist a b ≤ diam s + dist x y + diam t := λa ha b hb, calc
dist a b ≤ dist a x + dist x y + dist y b : dist_triangle4 _ _ _ _
... ≤ diam s + dist x y + diam t :
add_le_add (add_le_add (dist_le_diam_of_mem ‹bounded s› ha xs) (le_refl _)) (dist_le_diam_of_mem ‹bounded t› yt hb),
have B : ∀a b ∈ s ∪ t, dist a b ≤ diam s + dist x y + diam t := λa b ha hb,
begin
cases (mem_union _ _ _).1 ha with h'a h'a; cases (mem_union _ _ _).1 hb with h'b h'b,
{ calc dist a b ≤ diam s : dist_le_diam_of_mem ‹bounded s› h'a h'b
... = diam s + (0 + 0) : by simp
... ≤ diam s + (dist x y + diam t) : add_le_add (le_refl _) (add_le_add dist_nonneg diam_nonneg)
... = diam s + dist x y + diam t : by simp only [add_comm, eq_self_iff_true, add_left_comm] },
{ exact A a h'a b h'b },
{ have Z := A b h'b a h'a, rwa [dist_comm] at Z },
{ calc dist a b ≤ diam t : dist_le_diam_of_mem ‹bounded t› h'a h'b
... = (0 + 0) + diam t : by simp
... ≤ (diam s + dist x y) + diam t : add_le_add (add_le_add diam_nonneg dist_nonneg) (le_refl _) }
end,
have C : 0 ≤ diam s + dist x y + diam t := calc
0 = 0 + 0 + 0 : by simp
... ≤ diam s + dist x y + diam t : add_le_add (add_le_add diam_nonneg dist_nonneg) diam_nonneg,
exact diam_le_of_forall_dist_le C B
end,
classical.by_cases I2 I1
/-- If two sets intersect, the diameter of the union is bounded by the sum of the diameters. -/
lemma diam_union' {t : set α} (h : s ∩ t ≠ ∅) : diam (s ∪ t) ≤ diam s + diam t :=
begin
rcases ne_empty_iff_exists_mem.1 h with ⟨x, ⟨xs, xt⟩⟩,
simpa using diam_union xs xt
end
/-- The diameter of a closed ball of radius `r` is at most `2 r`. -/
lemma diam_closed_ball {r : ℝ} (h : r ≥ 0) : diam (closed_ball x r) ≤ 2 * r :=
diam_le_of_forall_dist_le (mul_nonneg (by norm_num) h) $ λa b ha hb, calc
dist a b ≤ dist a x + dist b x : dist_triangle_right _ _ _
... ≤ r + r : add_le_add ha hb
... = 2 * r : by simp [mul_two, mul_comm]
/-- The diameter of a ball of radius `r` is at most `2 r`. -/
lemma diam_ball {r : ℝ} (h : r ≥ 0) : diam (ball x r) ≤ 2 * r :=
le_trans (diam_mono ball_subset_closed_ball bounded_closed_ball) (diam_closed_ball h)
end diam
end metric
|
[STATEMENT]
lemma is_TNil_tfilter[simp]:
"is_TNil (tfilter y P xs) \<longleftrightarrow> (\<forall>x \<in> tset xs. \<not> P x)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. is_TNil (tfilter y P xs) = (\<forall>x\<in>tset xs. \<not> P x)
[PROOF STEP]
by transfer auto |
c compute zeeman components and strengths from the g-values
c of the lower and upper levels provided directly by the
c user. This routine is useful for calculating the Zeeman
c pattern of the Fe I line at 15652 A.
c The total angular momentum (tam) of the two levels must
c be provided in the atomic parameter file. The other values
c specified in the transition will not be used here.
SUBROUTINE ZEEMAN_jk(MC,MULT,DESIGN,TAM,JI,JF,DL0,NP,NL,NR,DLP,DLL,
*DLR,SP,SL,SR,xg1,xg2)
CHARACTER DESIGN*1
character*1 CODE(13)/'S','P','D','F','G','H','I','K','L','M','N',
*'O','Q'/
dimension G(2),MULT(*),DESIGN(*),TAM(*),JI(*),JF(*),DLP(*),DLL(*),
*DLR(*),SP(*),SL(*),SR(*)
character*1 code1(21)/'p','1','f','2','h','3','k','4','m','5','o'
& ,'6','r','7','t','8','u','9','v','0','w'/
OAM=-1
JI1=JI(1)
JI2=JI(2)
JF1=JF(1)
JF2=JF(2)
DO 58 I=1,MC
DLL(I)=0.
SL(I)=0.
DLR(I)=0.
58 SR(I)=0.
G(1)=xg1
G(2)=xg2
LEVEL=0
IF((JI1+JF1).EQ.0) LEVEL=1
IF((JI2+JF2).EQ.0) LEVEL=-1
IF(LEVEL) 3,4,5
3 I=1 ! TRIPLETS WITH G=0
GO TO 6
5 I=2
6 TAM(I)=1. ! TOTAL ANGULAR MOMENTUM
SPIN=0.5*FLOAT(MULT(I)-1)
DO 7 J=1,13
IF(DESIGN(I).NE.CODE(J)) GO TO 7
OAM=J-1 ! ORBITAL ANGULAR MOMENTUM
GO TO 8
7 CONTINUE
do 70 j=1,21
if(design(I).ne.code1(j)) goto 70
oam=float(j)/2. ! ORBITAL ANGULAR MOMENTUM (semientero)
go to 8
70 continue
print*,' '
print*,'STOP: Check the transitions in the file containing the atomic parameters.'
print*,'Some letter used to code the orbital angular momentum is erroneous or missing.'
print*,' '
print*,'__________________________________________________________________________________'
stop
8 G(I)=g(i) !1.5+(SPIN*(1.+SPIN)-OAM*(1.+OAM))/4.
13 NP=1 ! TRIPLETS WITH G=0 OR G1=G2
NL=NP
NR=NP
SP(1)=1.
SL(1)=1.
SR(1)=1.
DLP(1)=0.
DLL(1)=G(I)
DLR(1)=-DLL(1)
GO TO 9
4 DO 10 I=1,2
SPIN=0.5*FLOAT(MULT(I)-1)
DO 11 J=1,13
IF(DESIGN(I).NE.CODE(J)) GO TO 11
OAM=J-1
GO TO 10
11 CONTINUE
do 110 j=1,21
if(design(I).ne.code1(j)) goto 110
oam=float(j)/2. ! ORBITAL ANGULAR MOMENTUM (semientero)
go to 10
110 continue
C LAMDE FACTOR FOR EACH LABEL
10 G(I)=g(i) !1.5+(SPIN*(1.+SPIN)-OAM*(1.+OAM))/(2.*TAM(I)*(1.+TAM(I)))
IF(ABS(G(2)-G(1)).GT.5.E-6) GO TO 12
I=2
GO TO 13
12 LEVEL=JI2-JI1
IF(JF1.EQ.5) GO TO 14
IF(LEVEL) 15,16,17 ! INTEGRAL J'S
15 NP=2*JI2+1
19 NL=NP
NR=NP
IF(NP.LE.MC) GO TO 18
STOP 'EXIT ZEEMAN'
16 NP=2*JI2
GO TO 19
17 NP=2*JI2-1
GO TO 19
18 MUMIN=-JI2
IF(JI1.LT.JI2) MUMIN=-JI1
MUMAX=-MUMIN
I=0
DO 20 MU=MUMIN,MUMAX ! PI COMPONENTS
IF(MU.EQ.0.AND.LEVEL.EQ.0) GO TO 20
I=I+1
DLP(I)=FLOAT(MU)*(G(1)-G(2))
J=MU**2
IF(LEVEL) 21,22,23
21 SP(I)=2*(JI1**2-J)
GO TO 20
22 SP(I)=2*J
GO TO 20
23 SP(I)=2*(JI2**2-J)
20 CONTINUE
MUMIN=1-JI1
MUMAX=JI2
I=0
DO 24 MU=MUMIN,MUMAX ! R-SIGMA COMPONENTS
I=I+1
DLR(I)=FLOAT(MU)*(G(1)-G(2))-G(1)
IF(LEVEL) 25,26,27
25 SR(I)=(JI1-MU)*(JI2-MU+2)
GO TO 24
26 SR(I)=(JI2+MU)*(JI2-MU+1)
GO TO 24
27 SR(I)=(JI2+MU)*(JI1+MU)
24 CONTINUE
MUMIN=-JI2
MUMAX=JI1-1
I=0
DO 28 MU=MUMIN,MUMAX ! L-SIGMA COMPONENTS
I=I+1
DLL(I)=FLOAT(MU)*(G(1)-G(2))+G(1)
IF(LEVEL) 29,30,31
29 SL(I)=(JI1+MU)*(JI2+MU+2)
GO TO 28
30 SL(I)=(JI2-MU)*(JI2+MU+1)
GO TO 28
31 SL(I)=(JI2-MU)*(JI1-MU)
28 CONTINUE
GO TO 57
14 I=2*JI1+1 ! HALF-INTEGRAL J'S
IF(LEVEL) 32,33,34
32 NP=I-1
NL=NP
NR=NP
36 IF(NP.LE.MC) GO TO 35
STOP 'EXIT ZEEMAN'
33 NP=I+1
NL=I
NR=I
GO TO 36
34 NP=I+1
NL=NP
NR=NP
GO TO 36
35 MUMIN=-JI2
IF(JI1.LT.JI2) MUMIN=-JI1
MUMAX=1-MUMIN
I=0
DO 37 MU=MUMIN,MUMAX ! PI COMPONENTS
I=I+1
SPIN=FLOAT(MU)-0.5
DLP(I)=(G(1)-G(2))*SPIN
SPIN=SPIN**2
IF(LEVEL) 38,39,40
38 SP(I)=2.*((FLOAT(JI1)+0.5)**2-SPIN)
GO TO 37
39 SP(I)=2.*SPIN
GO TO 37
40 SP(I)=2.*((FLOAT(JI2)+0.5)**2-SPIN)
37 CONTINUE
MUMIN=-JI1
MUMAX=JI2
I=0
DO 41 MU=MUMIN,MUMAX ! R-SIGMA COMPONENTS
I=I+1
DLR(I)=(FLOAT(MU)+0.5)*(G(1)-G(2))-G(1)
IF(LEVEL) 42,43,44
42 SR(I)=(JI1-MU)*(JI2-MU+2)
GO TO 41
43 SR(I)=(JI2+MU+1)*(JI2-MU+1)
GO TO 41
44 SR(I)=(JI2+MU+1)*(JI2+MU)
41 CONTINUE
MUMIN=-MUMAX
MUMAX=JI1
I=0
DO 45 MU=MUMIN,MUMAX ! L-SIGMA COMPONENTS
I=I+1
DLL(I)=(FLOAT(MU)-0.5)*(G(1)-G(2))+G(1)
IF(LEVEL) 46,47,48
46 SL(I)=(JI1+MU)*(JI2+MU+2)
GO TO 45
47 SL(I)=(JI2-MU+1)*(JI2+MU+1)
GO TO 45
48 SL(I)=(JI2-MU+1)*(JI1-MU+1)
45 CONTINUE
57 SUM=0.
DO 49 I=1,NP
49 SUM=SUM+SP(I)
DO 50 I=1,NP
50 SP(I)=SP(I)/SUM
SPIN=0.
SUM=0.
DO 51 I=1,NL ! NL=NR ASSUMED.
SPIN=SPIN+SL(I)
51 SUM=SUM+SR(I)
DO 52 I=1,NL
SL(I)=SL(I)/SPIN
52 SR(I)=SR(I)/SUM
9 CONTINUE
c IF(MC.LE.18) GO TO 59 ! SKIP PRINTING IF SYNTHESIS
c WRITE(6,53) (MULT(I),DESIGN(I),JI(I),JF(I),I=1,2)
c 53 FORMAT(3X,'Transition:',I3,A1,I2,'.',I1,' ----',I3,A1,I2,'.',I1/
c *3X,'Zeeman Pattern (Lorentz units) and normalized Intensities:'/
c *11X,'Pi',17X,'Sigma+',15X,'Sigma-')
59 DO 54 I=1,NP
c IF(MC.LE.18) GO TO 60
c WRITE(6,55) DLP(I),SP(I),DLL(I),SL(I),DLR(I),SR(I)
55 FORMAT(2X,3(F10.6,F11.8))
60 DLP(I)=DLP(I)*DL0
DLL(I)=DLL(I)*DL0
54 DLR(I)=DLR(I)*DL0
IF(MC.LE.18) RETURN
c WRITE(6,56) G
56 FORMAT(3X,'Lande Factors: g(lower)=',F11.8,', g(upper)=',F11.8)
RETURN
END
|
using PyCall: pyimport_conda, pycall
using RCall, Conda
function installpypackage()
try
pyimport_conda("sklearn", "scikit-learn")
catch
try
Conda.add("scikit-learn")
catch
println("scikit-learn failed to install")
end
end
end
function installrpackage(package::AbstractString)
try
rcall(:library,package,"lib=.libPaths()")
#rcall(:library,package,"lib=Sys.getenv('R_LIBS_USER')")
catch
try
R"dir.create(path = Sys.getenv('R_LIBS_USER'), showWarnings = FALSE, recursive = TRUE)"
R"install.packages($package,lib=Sys.getenv('R_LIBS_USER'),repos='https://cloud.r-project.org',type='binary')"
catch xerror
println(xerror)
println("package "*package*" failed to install")
end
end
end
function installrml()
#packages=["caret", "earth","mda","e1071","gam","randomForest","nnet","kernlab","grid","MASS","pls"]
#packages=["caret", "e1071","gam","randomForest"]
packages=["caret","e1071","randomForest"]
for pk in packages
installrpackage(pk)
end
end
installrml()
installpypackage()
|
using FFMPEG
tosecond(x::Hour) = Float64(Dates.value(Second(x)))
tosecond(x::Minute) = Float64(Dates.value(Second(x)))
tosecond(x::T) where {T<:TimePeriod} = x/convert(T, Second(1))
# extract(_, __::Missing, ___) = nothing
ffmpeg(start, sourcefile, targetfile) = ffmpeg_exe(` -y -nostats -loglevel 8 -ss $start -i $sourcefile -vf 'yadif=1,format=gray,scale=sar*iw:ih' -pix_fmt gray -vframes 1 $targetfile`)
extract(targetpathfile, t::Temporal{WholeVideo, I}, coffeesource) where {I <: Instantaneous} = ffmpeg(tosecond(start(t.time)), joinpath(coffeesource, t.video.file.name), targetpathfile)
function extract(targetpathfile, t::Temporal{<:FragmentedVideo, I}, coffeesource) where {I <: Instantaneous}
x = start(t.time)
for vf in files(t.video)
d = duration(vf)
if x ≤ d
ffmpeg(tosecond(x), joinpath(coffeesource, vf.name), targetpathfile)
break
end
x -= d
end
end
ffmpeg(start, duration, sourcefile, targetpathfile) = ffmpeg_exe(` -y -nostats -loglevel 8 -ss $start -i $sourcefile -t $duration -r 2 -vf 'yadif=1,format=gray,scale=sar*iw:ih' -pix_fmt gray $targetpathfile`)
getsourcefile(coffeesource, t) = joinpath(coffeesource, t)
function getsourcetarget(coffeesource, t, targetpath)
sourcefile = getsourcefile(coffeesource, t)
sourcefile, joinpath(targetpath, "img%03d.png")
end
extract(targetpath, t::Temporal{WholeVideo, P}, coffeesource) where {P <: Prolonged} = ffmpeg(tosecond(start(t.time)), tosecond(duration(t.time)), getsourcetarget(coffeesource, t.video.file.name, targetpath)...)
function extract(targetpath, t::Temporal{<:FragmentedVideo, P}, coffeesource) where {P <: Prolonged}
t1 = start(t.time)
t2 = stop(t.time)
files = Iterators.Stateful(t.video.files)
for vf in files
d = duration(vf)
if t1 ≤ d
if t2 ≤ d
ffmpeg(tosecond(t1), tosecond(t2 - t1), getsourcetarget(coffeesource, vf.name, targetpath)...)
break
else
ffmpeg(tosecond(t1), tosecond(d), getsourcetarget(coffeesource, vf.name, targetpath)...)
t2 -= d
for _vf in files
_d = duration(_vf)
if t2 ≤ _d
ffmpeg(tosecond(Millisecond(0)), tosecond(t2), getsourcetarget(coffeesource, _vf.name, targetpath)...)
break
end
ffmpeg(tosecond(Millisecond(0)), tosecond(_d), getsourcetarget(coffeesource, _vf.name, targetpath)...)
t2 -= _d
end
end
end
t1 -= d
t2 -= d
end
end
|
using SIMDHints: ivdep
using BenchmarkTools
f!(y, x) = y .= ivdep.(x .+ y)
g!(y, x) = y .= x .+ y
a = randn(2^10)
y = zero(a)
@btime f!($y, $y) setup=(fill!($y, 0))
@btime g!($y, $y) setup=(fill!($y, 0))
nothing
|
using Zygote
using Zygote: @adjoint, literal_getproperty
import Zygote: accum
import Distances: pairwise, colwise
const dtol = 1e-12 # threshold value for precise recalculation of distances
@nograd MersenneTwister, propertynames, broadcast_shape
function accum(D::Diagonal{T}, B::AbstractMatrix) where {T}
A = Matrix{Union{T, Nothing}}(undef, size(D))
A[diagind(A)] .= D.diag
return accum(A, B)
end
accum(A::AbstractMatrix, D::Diagonal) = accum(D, A)
accum(A::Diagonal, B::Diagonal) = Diagonal(accum(diag(A), diag(B)))
@adjoint function ZygoteRules.literal_getproperty(C::Cholesky, ::Val{:factors})
error("@adjoint not implemented for :factors as is unsafe.")
return literal_getproperty(C, Val(:factors)), function(Δ)
error("@adjoint not implemented for :factors. (I couldn't make it work...)")
end
end
import LinearAlgebra: HermOrSym, diag, Diagonal
diag(S::Symmetric{T, <:Diagonal{T}} where T) = S.data.diag
Zygote._symmetric_back(Δ::Diagonal) = Δ
# Diagonal matrices are always symmetric...
cholesky(A::HermOrSym{T, <:Diagonal{T}} where T) = cholesky(Diagonal(diag(A)))
#
# Some very specific broadcasting hacks while Zygote has crappy broadcasting.
#
import Base.Broadcast: broadcasted
function rrule(::typeof(broadcasted), ::typeof(-), x::AbstractArray)
function broadcasted_minus_pullback(Δ)
return (NO_FIELDS, DoesNotExist(), .-Δ)
end
return .-x, broadcasted_minus_pullback
end
function rrule(::typeof(broadcasted), ::typeof(exp), x::AbstractArray)
y = exp.(x)
return y, Δ->(NO_FIELDS, DoesNotExist(), Δ .* y)
end
|
/-
Copyright (c) 2017 Johannes Hölzl. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Johannes Hölzl, Mario Carneiro, Jeremy Avigad
-/
import order.filter.ultrafilter
import order.filter.partial
import algebra.support
/-!
# Basic theory of topological spaces.
The main definition is the type class `topological space α` which endows a type `α` with a topology.
Then `set α` gets predicates `is_open`, `is_closed` and functions `interior`, `closure` and
`frontier`. Each point `x` of `α` gets a neighborhood filter `𝓝 x`. A filter `F` on `α` has
`x` as a cluster point if `cluster_pt x F : 𝓝 x ⊓ F ≠ ⊥`. A map `f : ι → α` clusters at `x`
along `F : filter ι` if `map_cluster_pt x F f : cluster_pt x (map f F)`. In particular
the notion of cluster point of a sequence `u` is `map_cluster_pt x at_top u`.
This file also defines locally finite families of subsets of `α`.
For topological spaces `α` and `β`, a function `f : α → β` and a point `a : α`,
`continuous_at f a` means `f` is continuous at `a`, and global continuity is
`continuous f`. There is also a version of continuity `pcontinuous` for
partially defined functions.
## Notation
* `𝓝 x`: the filter of neighborhoods of a point `x`;
* `𝓟 s`: the principal filter of a set `s`;
* `𝓝[s] x`: the filter `nhds_within x s` of neighborhoods of a point `x` within a set `s`.
## Implementation notes
Topology in mathlib heavily uses filters (even more than in Bourbaki). See explanations in
<https://leanprover-community.github.io/theories/topology.html>.
## References
* [N. Bourbaki, *General Topology*][bourbaki1966]
* [I. M. James, *Topologies and Uniformities*][james1999]
## Tags
topological space, interior, closure, frontier, neighborhood, continuity, continuous function
-/
noncomputable theory
open set filter classical
open_locale classical filter
universes u v w
/-!
### Topological spaces
-/
/-- A topology on `α`. -/
@[protect_proj] structure topological_space (α : Type u) :=
(is_open : set α → Prop)
(is_open_univ : is_open univ)
(is_open_inter : ∀s t, is_open s → is_open t → is_open (s ∩ t))
(is_open_sUnion : ∀s, (∀t∈s, is_open t) → is_open (⋃₀ s))
attribute [class] topological_space
/-- A constructor for topologies by specifying the closed sets,
and showing that they satisfy the appropriate conditions. -/
def topological_space.of_closed {α : Type u} (T : set (set α))
(empty_mem : ∅ ∈ T) (sInter_mem : ∀ A ⊆ T, ⋂₀ A ∈ T) (union_mem : ∀ A B ∈ T, A ∪ B ∈ T) :
topological_space α :=
{ is_open := λ X, Xᶜ ∈ T,
is_open_univ := by simp [empty_mem],
is_open_inter := λ s t hs ht, by simpa [set.compl_inter] using union_mem sᶜ tᶜ hs ht,
is_open_sUnion := λ s hs,
by rw set.compl_sUnion; exact sInter_mem (set.compl '' s)
(λ z ⟨y, hy, hz⟩, by simpa [hz.symm] using hs y hy) }
section topological_space
variables {α : Type u} {β : Type v} {ι : Sort w} {a : α} {s s₁ s₂ : set α} {p p₁ p₂ : α → Prop}
@[ext]
lemma topological_space_eq : ∀ {f g : topological_space α}, f.is_open = g.is_open → f = g
| ⟨a, _, _, _⟩ ⟨b, _, _, _⟩ rfl := rfl
section
variables [t : topological_space α]
include t
/-- `is_open s` means that `s` is open in the ambient topological space on `α` -/
def is_open (s : set α) : Prop := topological_space.is_open t s
@[simp]
lemma is_open_univ : is_open (univ : set α) := topological_space.is_open_univ t
lemma is_open.inter (h₁ : is_open s₁) (h₂ : is_open s₂) : is_open (s₁ ∩ s₂) :=
topological_space.is_open_inter t s₁ s₂ h₁ h₂
lemma is_open_sUnion {s : set (set α)} (h : ∀t ∈ s, is_open t) : is_open (⋃₀ s) :=
topological_space.is_open_sUnion t s h
end
lemma topological_space_eq_iff {t t' : topological_space α} :
t = t' ↔ ∀ s, @is_open α t s ↔ @is_open α t' s :=
⟨λ h s, h ▸ iff.rfl, λ h, by { ext, exact h _ }⟩
lemma is_open_fold {s : set α} {t : topological_space α} : t.is_open s = @is_open α t s :=
rfl
variables [topological_space α]
lemma is_open_Union {f : ι → set α} (h : ∀i, is_open (f i)) : is_open (⋃i, f i) :=
is_open_sUnion $ by rintro _ ⟨i, rfl⟩; exact h i
lemma is_open_bUnion {s : set β} {f : β → set α} (h : ∀i∈s, is_open (f i)) :
is_open (⋃i∈s, f i) :=
is_open_Union $ assume i, is_open_Union $ assume hi, h i hi
lemma is_open.union (h₁ : is_open s₁) (h₂ : is_open s₂) : is_open (s₁ ∪ s₂) :=
by rw union_eq_Union; exact is_open_Union (bool.forall_bool.2 ⟨h₂, h₁⟩)
@[simp] lemma is_open_empty : is_open (∅ : set α) :=
by rw ← sUnion_empty; exact is_open_sUnion (assume a, false.elim)
lemma is_open_sInter {s : set (set α)} (hs : finite s) : (∀t ∈ s, is_open t) → is_open (⋂₀ s) :=
finite.induction_on hs (λ _, by rw sInter_empty; exact is_open_univ) $
λ a s has hs ih h, by rw sInter_insert; exact
is_open.inter (h _ $ mem_insert _ _) (ih $ λ t, h t ∘ mem_insert_of_mem _)
lemma is_open_bInter {s : set β} {f : β → set α} (hs : finite s) :
(∀i∈s, is_open (f i)) → is_open (⋂i∈s, f i) :=
finite.induction_on hs
(λ _, by rw bInter_empty; exact is_open_univ)
(λ a s has hs ih h, by rw bInter_insert; exact
is_open.inter (h a (mem_insert _ _)) (ih (λ i hi, h i (mem_insert_of_mem _ hi))))
lemma is_open_Inter [fintype β] {s : β → set α}
(h : ∀ i, is_open (s i)) : is_open (⋂ i, s i) :=
suffices is_open (⋂ (i : β) (hi : i ∈ @univ β), s i), by simpa,
is_open_bInter finite_univ (λ i _, h i)
lemma is_open_Inter_prop {p : Prop} {s : p → set α}
(h : ∀ h : p, is_open (s h)) : is_open (Inter s) :=
by by_cases p; simp *
lemma is_open_const {p : Prop} : is_open {a : α | p} :=
by_cases
(assume : p, begin simp only [this]; exact is_open_univ end)
(assume : ¬ p, begin simp only [this]; exact is_open_empty end)
lemma is_open.and : is_open {a | p₁ a} → is_open {a | p₂ a} → is_open {a | p₁ a ∧ p₂ a} :=
is_open.inter
/-- A set is closed if its complement is open -/
class is_closed (s : set α) : Prop :=
(is_open_compl : is_open sᶜ)
@[simp] lemma is_open_compl_iff {s : set α} : is_open sᶜ ↔ is_closed s :=
⟨λ h, ⟨h⟩, λ h, h.is_open_compl⟩
@[simp] lemma is_closed_empty : is_closed (∅ : set α) :=
by { rw [← is_open_compl_iff, compl_empty], exact is_open_univ }
@[simp] lemma is_closed_univ : is_closed (univ : set α) :=
by { rw [← is_open_compl_iff, compl_univ], exact is_open_empty }
lemma is_closed.union : is_closed s₁ → is_closed s₂ → is_closed (s₁ ∪ s₂) :=
λ h₁ h₂, by { rw [← is_open_compl_iff] at *, rw compl_union, exact is_open.inter h₁ h₂ }
lemma is_closed_sInter {s : set (set α)} : (∀t ∈ s, is_closed t) → is_closed (⋂₀ s) :=
by simpa only [← is_open_compl_iff, compl_sInter, sUnion_image] using is_open_bUnion
lemma is_closed_Inter {f : ι → set α} (h : ∀i, is_closed (f i)) : is_closed (⋂i, f i ) :=
is_closed_sInter $ assume t ⟨i, (heq : f i = t)⟩, heq ▸ h i
lemma is_closed_bInter {s : set β} {f : β → set α} (h : ∀ i ∈ s, is_closed (f i)) :
is_closed (⋂ i ∈ s, f i) :=
is_closed_Inter $ λ i, is_closed_Inter $ h i
@[simp] lemma is_closed_compl_iff {s : set α} : is_closed sᶜ ↔ is_open s :=
by rw [←is_open_compl_iff, compl_compl]
lemma is_open.is_closed_compl {s : set α} (hs : is_open s) : is_closed sᶜ :=
is_closed_compl_iff.2 hs
lemma is_open.sdiff {s t : set α} (h₁ : is_open s) (h₂ : is_closed t) : is_open (s \ t) :=
is_open.inter h₁ $ is_open_compl_iff.mpr h₂
lemma is_closed.inter (h₁ : is_closed s₁) (h₂ : is_closed s₂) : is_closed (s₁ ∩ s₂) :=
by { rw [← is_open_compl_iff] at *, rw compl_inter, exact is_open.union h₁ h₂ }
lemma is_closed.sdiff {s t : set α} (h₁ : is_closed s) (h₂ : is_open t) : is_closed (s \ t) :=
is_closed.inter h₁ (is_closed_compl_iff.mpr h₂)
lemma is_closed_bUnion {s : set β} {f : β → set α} (hs : finite s) :
(∀i∈s, is_closed (f i)) → is_closed (⋃i∈s, f i) :=
finite.induction_on hs
(λ _, by rw bUnion_empty; exact is_closed_empty)
(λ a s has hs ih h, by rw bUnion_insert; exact
is_closed.union (h a (mem_insert _ _)) (ih (λ i hi, h i (mem_insert_of_mem _ hi))))
lemma is_closed_Union [fintype β] {s : β → set α}
(h : ∀ i, is_closed (s i)) : is_closed (Union s) :=
suffices is_closed (⋃ (i : β) (hi : i ∈ @univ β), s i),
by convert this; simp [set.ext_iff],
is_closed_bUnion finite_univ (λ i _, h i)
lemma is_closed_Union_prop {p : Prop} {s : p → set α}
(h : ∀ h : p, is_closed (s h)) : is_closed (Union s) :=
by by_cases p; simp *
lemma is_closed_imp {p q : α → Prop} (hp : is_open {x | p x})
(hq : is_closed {x | q x}) : is_closed {x | p x → q x} :=
have {x | p x → q x} = {x | p x}ᶜ ∪ {x | q x}, from set.ext $ λ x, imp_iff_not_or,
by rw [this]; exact is_closed.union (is_closed_compl_iff.mpr hp) hq
lemma is_closed.not : is_closed {a | p a} → is_open {a | ¬ p a} :=
is_open_compl_iff.mpr
/-!
### Interior of a set
-/
/-- The interior of a set `s` is the largest open subset of `s`. -/
def interior (s : set α) : set α := ⋃₀ {t | is_open t ∧ t ⊆ s}
lemma mem_interior {s : set α} {x : α} :
x ∈ interior s ↔ ∃ t ⊆ s, is_open t ∧ x ∈ t :=
by simp only [interior, mem_set_of_eq, exists_prop, and_assoc, and.left_comm]
@[simp] lemma is_open_interior {s : set α} : is_open (interior s) :=
is_open_sUnion $ assume t ⟨h₁, h₂⟩, h₁
lemma interior_subset {s : set α} : interior s ⊆ s :=
sUnion_subset $ assume t ⟨h₁, h₂⟩, h₂
lemma interior_maximal {s t : set α} (h₁ : t ⊆ s) (h₂ : is_open t) : t ⊆ interior s :=
subset_sUnion_of_mem ⟨h₂, h₁⟩
lemma is_open.interior_eq {s : set α} (h : is_open s) : interior s = s :=
subset.antisymm interior_subset (interior_maximal (subset.refl s) h)
lemma interior_eq_iff_open {s : set α} : interior s = s ↔ is_open s :=
⟨assume h, h ▸ is_open_interior, is_open.interior_eq⟩
lemma subset_interior_iff_open {s : set α} : s ⊆ interior s ↔ is_open s :=
by simp only [interior_eq_iff_open.symm, subset.antisymm_iff, interior_subset, true_and]
lemma subset_interior_iff_subset_of_open {s t : set α} (h₁ : is_open s) :
s ⊆ interior t ↔ s ⊆ t :=
⟨assume h, subset.trans h interior_subset, assume h₂, interior_maximal h₂ h₁⟩
@[mono] lemma interior_mono {s t : set α} (h : s ⊆ t) : interior s ⊆ interior t :=
interior_maximal (subset.trans interior_subset h) is_open_interior
@[simp] lemma interior_empty : interior (∅ : set α) = ∅ :=
is_open_empty.interior_eq
@[simp] lemma interior_univ : interior (univ : set α) = univ :=
is_open_univ.interior_eq
@[simp] lemma interior_interior {s : set α} : interior (interior s) = interior s :=
is_open_interior.interior_eq
@[simp] lemma interior_inter {s t : set α} : interior (s ∩ t) = interior s ∩ interior t :=
subset.antisymm
(subset_inter (interior_mono $ inter_subset_left s t) (interior_mono $ inter_subset_right s t))
(interior_maximal (inter_subset_inter interior_subset interior_subset) $
is_open.inter is_open_interior is_open_interior)
@[simp] lemma finset.interior_Inter {ι : Type*} (s : finset ι) (f : ι → set α) :
interior (⋂ i ∈ s, f i) = ⋂ i ∈ s, interior (f i) :=
begin
classical,
refine s.induction_on (by simp) _,
intros i s h₁ h₂,
simp [h₂],
end
@[simp] lemma interior_Inter_of_fintype {ι : Type*} [fintype ι] (f : ι → set α) :
interior (⋂ i, f i) = ⋂ i, interior (f i) :=
by { convert finset.univ.interior_Inter f; simp, }
lemma interior_union_is_closed_of_interior_empty {s t : set α} (h₁ : is_closed s)
(h₂ : interior t = ∅) :
interior (s ∪ t) = interior s :=
have interior (s ∪ t) ⊆ s, from
assume x ⟨u, ⟨(hu₁ : is_open u), (hu₂ : u ⊆ s ∪ t)⟩, (hx₁ : x ∈ u)⟩,
classical.by_contradiction $ assume hx₂ : x ∉ s,
have u \ s ⊆ t,
from assume x ⟨h₁, h₂⟩, or.resolve_left (hu₂ h₁) h₂,
have u \ s ⊆ interior t,
by rwa subset_interior_iff_subset_of_open (is_open.sdiff hu₁ h₁),
have u \ s ⊆ ∅,
by rwa h₂ at this,
this ⟨hx₁, hx₂⟩,
subset.antisymm
(interior_maximal this is_open_interior)
(interior_mono $ subset_union_left _ _)
lemma is_open_iff_forall_mem_open : is_open s ↔ ∀ x ∈ s, ∃ t ⊆ s, is_open t ∧ x ∈ t :=
by rw ← subset_interior_iff_open; simp only [subset_def, mem_interior]
lemma interior_Inter_subset (s : ι → set α) : interior (⋂ i, s i) ⊆ ⋂ i, interior (s i) :=
subset_Inter $ λ i, interior_mono $ Inter_subset _ _
lemma interior_bInter_subset (p : ι → Sort*) (s : Π i, p i → set α) :
interior (⋂ i (hi : p i), s i hi) ⊆ ⋂ i (hi : p i), interior (s i hi) :=
(interior_Inter_subset _).trans $ Inter_subset_Inter $ λ i, interior_Inter_subset _
lemma interior_sInter_subset (S : set (set α)) : interior (⋂₀ S) ⊆ ⋂ s ∈ S, interior s :=
calc interior (⋂₀ S) = interior (⋂ s ∈ S, s) : by rw sInter_eq_bInter
... ⊆ ⋂ s ∈ S, interior s : interior_bInter_subset _ _
/-!
### Closure of a set
-/
/-- The closure of `s` is the smallest closed set containing `s`. -/
def closure (s : set α) : set α := ⋂₀ {t | is_closed t ∧ s ⊆ t}
@[simp] lemma is_closed_closure {s : set α} : is_closed (closure s) :=
is_closed_sInter $ assume t ⟨h₁, h₂⟩, h₁
lemma subset_closure {s : set α} : s ⊆ closure s :=
subset_sInter $ assume t ⟨h₁, h₂⟩, h₂
lemma not_mem_of_not_mem_closure {s : set α} {P : α} (hP : P ∉ closure s) : P ∉ s :=
λ h, hP (subset_closure h)
lemma closure_minimal {s t : set α} (h₁ : s ⊆ t) (h₂ : is_closed t) : closure s ⊆ t :=
sInter_subset_of_mem ⟨h₂, h₁⟩
lemma is_closed.closure_eq {s : set α} (h : is_closed s) : closure s = s :=
subset.antisymm (closure_minimal (subset.refl s) h) subset_closure
lemma is_closed.closure_subset {s : set α} (hs : is_closed s) : closure s ⊆ s :=
closure_minimal (subset.refl _) hs
lemma is_closed.closure_subset_iff {s t : set α} (h₁ : is_closed t) :
closure s ⊆ t ↔ s ⊆ t :=
⟨subset.trans subset_closure, assume h, closure_minimal h h₁⟩
@[mono] lemma closure_mono {s t : set α} (h : s ⊆ t) : closure s ⊆ closure t :=
closure_minimal (subset.trans h subset_closure) is_closed_closure
lemma monotone_closure (α : Type*) [topological_space α] : monotone (@closure α _) :=
λ _ _, closure_mono
lemma diff_subset_closure_iff {s t : set α} :
s \ t ⊆ closure t ↔ s ⊆ closure t :=
by rw [diff_subset_iff, union_eq_self_of_subset_left subset_closure]
lemma closure_inter_subset_inter_closure (s t : set α) :
closure (s ∩ t) ⊆ closure s ∩ closure t :=
(monotone_closure α).map_inf_le s t
lemma is_closed_of_closure_subset {s : set α} (h : closure s ⊆ s) : is_closed s :=
by rw subset.antisymm subset_closure h; exact is_closed_closure
lemma closure_eq_iff_is_closed {s : set α} : closure s = s ↔ is_closed s :=
⟨assume h, h ▸ is_closed_closure, is_closed.closure_eq⟩
lemma closure_subset_iff_is_closed {s : set α} : closure s ⊆ s ↔ is_closed s :=
⟨is_closed_of_closure_subset, is_closed.closure_subset⟩
@[simp] lemma closure_empty : closure (∅ : set α) = ∅ :=
is_closed_empty.closure_eq
@[simp] lemma closure_empty_iff (s : set α) : closure s = ∅ ↔ s = ∅ :=
⟨subset_eq_empty subset_closure, λ h, h.symm ▸ closure_empty⟩
@[simp] lemma closure_nonempty_iff {s : set α} : (closure s).nonempty ↔ s.nonempty :=
by simp only [← ne_empty_iff_nonempty, ne.def, closure_empty_iff]
alias closure_nonempty_iff ↔ set.nonempty.of_closure set.nonempty.closure
@[simp] lemma closure_univ : closure (univ : set α) = univ :=
is_closed_univ.closure_eq
@[simp] lemma closure_closure {s : set α} : closure (closure s) = closure s :=
is_closed_closure.closure_eq
@[simp] lemma closure_union {s t : set α} : closure (s ∪ t) = closure s ∪ closure t :=
subset.antisymm
(closure_minimal (union_subset_union subset_closure subset_closure) $
is_closed.union is_closed_closure is_closed_closure)
((monotone_closure α).le_map_sup s t)
@[simp] lemma finset.closure_Union {ι : Type*} (s : finset ι) (f : ι → set α) :
closure (⋃ i ∈ s, f i) = ⋃ i ∈ s, closure (f i) :=
begin
classical,
refine s.induction_on (by simp) _,
intros i s h₁ h₂,
simp [h₂],
end
@[simp] lemma closure_Union_of_fintype {ι : Type*} [fintype ι] (f : ι → set α) :
closure (⋃ i, f i) = ⋃ i, closure (f i) :=
by { convert finset.univ.closure_Union f; simp, }
lemma interior_subset_closure {s : set α} : interior s ⊆ closure s :=
subset.trans interior_subset subset_closure
lemma closure_eq_compl_interior_compl {s : set α} : closure s = (interior sᶜ)ᶜ :=
begin
rw [interior, closure, compl_sUnion, compl_image_set_of],
simp only [compl_subset_compl, is_open_compl_iff],
end
@[simp] lemma interior_compl {s : set α} : interior sᶜ = (closure s)ᶜ :=
by simp [closure_eq_compl_interior_compl]
@[simp] lemma closure_compl {s : set α} : closure sᶜ = (interior s)ᶜ :=
by simp [closure_eq_compl_interior_compl]
theorem mem_closure_iff {s : set α} {a : α} :
a ∈ closure s ↔ ∀ o, is_open o → a ∈ o → (o ∩ s).nonempty :=
⟨λ h o oo ao, classical.by_contradiction $ λ os,
have s ⊆ oᶜ, from λ x xs xo, os ⟨x, xo, xs⟩,
closure_minimal this (is_closed_compl_iff.2 oo) h ao,
λ H c ⟨h₁, h₂⟩, classical.by_contradiction $ λ nc,
let ⟨x, hc, hs⟩ := (H _ h₁.is_open_compl nc) in hc (h₂ hs)⟩
/-- A set is dense in a topological space if every point belongs to its closure. -/
def dense (s : set α) : Prop := ∀ x, x ∈ closure s
lemma dense_iff_closure_eq {s : set α} : dense s ↔ closure s = univ :=
eq_univ_iff_forall.symm
lemma dense.closure_eq {s : set α} (h : dense s) : closure s = univ :=
dense_iff_closure_eq.mp h
lemma interior_eq_empty_iff_dense_compl {s : set α} : interior s = ∅ ↔ dense sᶜ :=
by rw [dense_iff_closure_eq, closure_compl, compl_univ_iff]
lemma dense.interior_compl {s : set α} (h : dense s) : interior sᶜ = ∅ :=
interior_eq_empty_iff_dense_compl.2 $ by rwa compl_compl
/-- The closure of a set `s` is dense if and only if `s` is dense. -/
@[simp] lemma dense_closure {s : set α} : dense (closure s) ↔ dense s :=
by rw [dense, dense, closure_closure]
alias dense_closure ↔ dense.of_closure dense.closure
@[simp] lemma dense_univ : dense (univ : set α) := λ x, subset_closure trivial
/-- A set is dense if and only if it has a nonempty intersection with each nonempty open set. -/
lemma dense_iff_inter_open {s : set α} :
dense s ↔ ∀ U, is_open U → U.nonempty → (U ∩ s).nonempty :=
begin
split ; intro h,
{ rintros U U_op ⟨x, x_in⟩,
exact mem_closure_iff.1 (by simp only [h.closure_eq]) U U_op x_in },
{ intro x,
rw mem_closure_iff,
intros U U_op x_in,
exact h U U_op ⟨_, x_in⟩ },
end
alias dense_iff_inter_open ↔ dense.inter_open_nonempty _
lemma dense.exists_mem_open {s : set α} (hs : dense s) {U : set α} (ho : is_open U)
(hne : U.nonempty) :
∃ x ∈ s, x ∈ U :=
let ⟨x, hx⟩ := hs.inter_open_nonempty U ho hne in ⟨x, hx.2, hx.1⟩
lemma dense.nonempty_iff {s : set α} (hs : dense s) :
s.nonempty ↔ nonempty α :=
⟨λ ⟨x, hx⟩, ⟨x⟩, λ ⟨x⟩,
let ⟨y, hy⟩ := hs.inter_open_nonempty _ is_open_univ ⟨x, trivial⟩ in ⟨y, hy.2⟩⟩
lemma dense.nonempty [h : nonempty α] {s : set α} (hs : dense s) : s.nonempty :=
hs.nonempty_iff.2 h
@[mono]
lemma dense.mono {s₁ s₂ : set α} (h : s₁ ⊆ s₂) (hd : dense s₁) : dense s₂ :=
λ x, closure_mono h (hd x)
/-- Complement to a singleton is dense if and only if the singleton is not an open set. -/
lemma dense_compl_singleton_iff_not_open {x : α} : dense ({x}ᶜ : set α) ↔ ¬is_open ({x} : set α) :=
begin
fsplit,
{ intros hd ho,
exact (hd.inter_open_nonempty _ ho (singleton_nonempty _)).ne_empty (inter_compl_self _) },
{ refine λ ho, dense_iff_inter_open.2 (λ U hU hne, inter_compl_nonempty_iff.2 $ λ hUx, _),
obtain rfl : U = {x}, from eq_singleton_iff_nonempty_unique_mem.2 ⟨hne, hUx⟩,
exact ho hU }
end
/-!
### Frontier of a set
-/
/-- The frontier of a set is the set of points between the closure and interior. -/
def frontier (s : set α) : set α := closure s \ interior s
lemma frontier_eq_closure_inter_closure {s : set α} :
frontier s = closure s ∩ closure sᶜ :=
by rw [closure_compl, frontier, diff_eq]
lemma frontier_subset_closure {s : set α} : frontier s ⊆ closure s := diff_subset _ _
/-- The complement of a set has the same frontier as the original set. -/
@[simp] lemma frontier_compl (s : set α) : frontier sᶜ = frontier s :=
by simp only [frontier_eq_closure_inter_closure, compl_compl, inter_comm]
@[simp] lemma frontier_univ : frontier (univ : set α) = ∅ := by simp [frontier]
@[simp] lemma frontier_empty : frontier (∅ : set α) = ∅ := by simp [frontier]
lemma frontier_inter_subset (s t : set α) :
frontier (s ∩ t) ⊆ (frontier s ∩ closure t) ∪ (closure s ∩ frontier t) :=
begin
simp only [frontier_eq_closure_inter_closure, compl_inter, closure_union],
convert inter_subset_inter_left _ (closure_inter_subset_inter_closure s t),
simp only [inter_distrib_left, inter_distrib_right, inter_assoc],
congr' 2,
apply inter_comm
end
lemma frontier_union_subset (s t : set α) :
frontier (s ∪ t) ⊆ (frontier s ∩ closure tᶜ) ∪ (closure sᶜ ∩ frontier t) :=
by simpa only [frontier_compl, ← compl_union]
using frontier_inter_subset sᶜ tᶜ
lemma is_closed.frontier_eq {s : set α} (hs : is_closed s) : frontier s = s \ interior s :=
by rw [frontier, hs.closure_eq]
lemma is_open.frontier_eq {s : set α} (hs : is_open s) : frontier s = closure s \ s :=
by rw [frontier, hs.interior_eq]
lemma is_open.inter_frontier_eq {s : set α} (hs : is_open s) : s ∩ frontier s = ∅ :=
by rw [hs.frontier_eq, inter_diff_self]
/-- The frontier of a set is closed. -/
lemma is_closed_frontier {s : set α} : is_closed (frontier s) :=
by rw frontier_eq_closure_inter_closure; exact is_closed.inter is_closed_closure is_closed_closure
/-- The frontier of a closed set has no interior point. -/
lemma interior_frontier {s : set α} (h : is_closed s) : interior (frontier s) = ∅ :=
begin
have A : frontier s = s \ interior s, from h.frontier_eq,
have B : interior (frontier s) ⊆ interior s, by rw A; exact interior_mono (diff_subset _ _),
have C : interior (frontier s) ⊆ frontier s := interior_subset,
have : interior (frontier s) ⊆ (interior s) ∩ (s \ interior s) :=
subset_inter B (by simpa [A] using C),
rwa [inter_diff_self, subset_empty_iff] at this,
end
lemma closure_eq_interior_union_frontier (s : set α) : closure s = interior s ∪ frontier s :=
(union_diff_cancel interior_subset_closure).symm
lemma closure_eq_self_union_frontier (s : set α) : closure s = s ∪ frontier s :=
(union_diff_cancel' interior_subset subset_closure).symm
lemma is_open.inter_frontier_eq_empty_of_disjoint {s t : set α} (ht : is_open t)
(hd : disjoint s t) :
t ∩ frontier s = ∅ :=
begin
rw [inter_comm, ← subset_compl_iff_disjoint],
exact subset.trans frontier_subset_closure (closure_minimal (λ _, disjoint_left.1 hd)
(is_closed_compl_iff.2 ht))
end
lemma frontier_eq_inter_compl_interior {s : set α} :
frontier s = (interior s)ᶜ ∩ (interior (sᶜ))ᶜ :=
by { rw [←frontier_compl, ←closure_compl], refl }
lemma compl_frontier_eq_union_interior {s : set α} :
(frontier s)ᶜ = interior s ∪ interior sᶜ :=
begin
rw frontier_eq_inter_compl_interior,
simp only [compl_inter, compl_compl],
end
/-!
### Neighborhoods
-/
/-- A set is called a neighborhood of `a` if it contains an open set around `a`. The set of all
neighborhoods of `a` forms a filter, the neighborhood filter at `a`, is here defined as the
infimum over the principal filters of all open sets containing `a`. -/
@[irreducible] def nhds (a : α) : filter α := (⨅ s ∈ {s : set α | a ∈ s ∧ is_open s}, 𝓟 s)
localized "notation `𝓝` := nhds" in topological_space
/-- The "neighborhood within" filter. Elements of `𝓝[s] a` are sets containing the
intersection of `s` and a neighborhood of `a`. -/
def nhds_within (a : α) (s : set α) : filter α := 𝓝 a ⊓ 𝓟 s
localized "notation `𝓝[` s `] ` x:100 := nhds_within x s" in topological_space
lemma nhds_def (a : α) : 𝓝 a = (⨅ s ∈ {s : set α | a ∈ s ∧ is_open s}, 𝓟 s) := by rw nhds
/-- The open sets containing `a` are a basis for the neighborhood filter. See `nhds_basis_opens'`
for a variant using open neighborhoods instead. -/
lemma nhds_basis_opens (a : α) : (𝓝 a).has_basis (λ s : set α, a ∈ s ∧ is_open s) (λ x, x) :=
begin
rw nhds_def,
exact has_basis_binfi_principal
(λ s ⟨has, hs⟩ t ⟨hat, ht⟩, ⟨s ∩ t, ⟨⟨has, hat⟩, is_open.inter hs ht⟩,
⟨inter_subset_left _ _, inter_subset_right _ _⟩⟩)
⟨univ, ⟨mem_univ a, is_open_univ⟩⟩
end
/-- A filter lies below the neighborhood filter at `a` iff it contains every open set around `a`. -/
lemma le_nhds_iff {f a} : f ≤ 𝓝 a ↔ ∀ s : set α, a ∈ s → is_open s → s ∈ f :=
by simp [nhds_def]
/-- To show a filter is above the neighborhood filter at `a`, it suffices to show that it is above
the principal filter of some open set `s` containing `a`. -/
lemma nhds_le_of_le {f a} {s : set α} (h : a ∈ s) (o : is_open s) (sf : 𝓟 s ≤ f) : 𝓝 a ≤ f :=
by rw nhds_def; exact infi_le_of_le s (infi_le_of_le ⟨h, o⟩ sf)
lemma mem_nhds_iff {a : α} {s : set α} :
s ∈ 𝓝 a ↔ ∃t⊆s, is_open t ∧ a ∈ t :=
(nhds_basis_opens a).mem_iff.trans
⟨λ ⟨t, ⟨hat, ht⟩, hts⟩, ⟨t, hts, ht, hat⟩, λ ⟨t, hts, ht, hat⟩, ⟨t, ⟨hat, ht⟩, hts⟩⟩
/-- A predicate is true in a neighborhood of `a` iff it is true for all the points in an open set
containing `a`. -/
lemma eventually_nhds_iff {a : α} {p : α → Prop} :
(∀ᶠ x in 𝓝 a, p x) ↔ ∃ (t : set α), (∀ x ∈ t, p x) ∧ is_open t ∧ a ∈ t :=
mem_nhds_iff.trans $ by simp only [subset_def, exists_prop, mem_set_of_eq]
lemma map_nhds {a : α} {f : α → β} :
map f (𝓝 a) = (⨅ s ∈ {s : set α | a ∈ s ∧ is_open s}, 𝓟 (image f s)) :=
((nhds_basis_opens a).map f).eq_binfi
lemma mem_of_mem_nhds {a : α} {s : set α} : s ∈ 𝓝 a → a ∈ s :=
λ H, let ⟨t, ht, _, hs⟩ := mem_nhds_iff.1 H in ht hs
/-- If a predicate is true in a neighborhood of `a`, then it is true for `a`. -/
lemma filter.eventually.self_of_nhds {p : α → Prop} {a : α}
(h : ∀ᶠ y in 𝓝 a, p y) : p a :=
mem_of_mem_nhds h
lemma is_open.mem_nhds {a : α} {s : set α} (hs : is_open s) (ha : a ∈ s) :
s ∈ 𝓝 a :=
mem_nhds_iff.2 ⟨s, subset.refl _, hs, ha⟩
lemma is_closed.compl_mem_nhds {a : α} {s : set α} (hs : is_closed s) (ha : a ∉ s) : sᶜ ∈ 𝓝 a :=
hs.is_open_compl.mem_nhds (mem_compl ha)
lemma is_open.eventually_mem {a : α} {s : set α} (hs : is_open s) (ha : a ∈ s) :
∀ᶠ x in 𝓝 a, x ∈ s :=
is_open.mem_nhds hs ha
/-- The open neighborhoods of `a` are a basis for the neighborhood filter. See `nhds_basis_opens`
for a variant using open sets around `a` instead. -/
lemma nhds_basis_opens' (a : α) : (𝓝 a).has_basis (λ s : set α, s ∈ 𝓝 a ∧ is_open s) (λ x, x) :=
begin
convert nhds_basis_opens a,
ext s,
split,
{ rintros ⟨s_in, s_op⟩,
exact ⟨mem_of_mem_nhds s_in, s_op⟩ },
{ rintros ⟨a_in, s_op⟩,
exact ⟨is_open.mem_nhds s_op a_in, s_op⟩ },
end
/-- If `U` is a neighborhood of each point of a set `s` then it is a neighborhood of `s`:
it contains an open set containing `s`. -/
lemma exists_open_set_nhds {s U : set α} (h : ∀ x ∈ s, U ∈ 𝓝 x) :
∃ V : set α, s ⊆ V ∧ is_open V ∧ V ⊆ U :=
begin
have := λ x hx, (nhds_basis_opens x).mem_iff.1 (h x hx),
choose! Z hZ hZ' using this,
refine ⟨⋃ x ∈ s, Z x, _, _, bUnion_subset hZ'⟩,
{ intros x hx,
simp only [mem_Union],
exact ⟨x, hx, (hZ x hx).1⟩ },
{ apply is_open_Union,
intros x,
by_cases hx : x ∈ s ; simp [hx],
exact (hZ x hx).2 }
end
/-- If `U` is a neighborhood of each point of a set `s` then it is a neighborhood of s:
it contains an open set containing `s`. -/
lemma exists_open_set_nhds' {s U : set α} (h : U ∈ ⨆ x ∈ s, 𝓝 x) :
∃ V : set α, s ⊆ V ∧ is_open V ∧ V ⊆ U :=
exists_open_set_nhds (by simpa using h)
/-- If a predicate is true in a neighbourhood of `a`, then for `y` sufficiently close
to `a` this predicate is true in a neighbourhood of `y`. -/
lemma filter.eventually.eventually_nhds {p : α → Prop} {a : α} (h : ∀ᶠ y in 𝓝 a, p y) :
∀ᶠ y in 𝓝 a, ∀ᶠ x in 𝓝 y, p x :=
let ⟨t, htp, hto, ha⟩ := eventually_nhds_iff.1 h in
eventually_nhds_iff.2 ⟨t, λ x hx, eventually_nhds_iff.2 ⟨t, htp, hto, hx⟩, hto, ha⟩
@[simp] lemma eventually_eventually_nhds {p : α → Prop} {a : α} :
(∀ᶠ y in 𝓝 a, ∀ᶠ x in 𝓝 y, p x) ↔ ∀ᶠ x in 𝓝 a, p x :=
⟨λ h, h.self_of_nhds, λ h, h.eventually_nhds⟩
@[simp] lemma nhds_bind_nhds : (𝓝 a).bind 𝓝 = 𝓝 a := filter.ext $ λ s, eventually_eventually_nhds
@[simp] lemma eventually_eventually_eq_nhds {f g : α → β} {a : α} :
(∀ᶠ y in 𝓝 a, f =ᶠ[𝓝 y] g) ↔ f =ᶠ[𝓝 a] g :=
eventually_eventually_nhds
lemma filter.eventually_eq.eq_of_nhds {f g : α → β} {a : α} (h : f =ᶠ[𝓝 a] g) : f a = g a :=
h.self_of_nhds
@[simp] lemma eventually_eventually_le_nhds [has_le β] {f g : α → β} {a : α} :
(∀ᶠ y in 𝓝 a, f ≤ᶠ[𝓝 y] g) ↔ f ≤ᶠ[𝓝 a] g :=
eventually_eventually_nhds
/-- If two functions are equal in a neighbourhood of `a`, then for `y` sufficiently close
to `a` these functions are equal in a neighbourhood of `y`. -/
lemma filter.eventually_eq.eventually_eq_nhds {f g : α → β} {a : α} (h : f =ᶠ[𝓝 a] g) :
∀ᶠ y in 𝓝 a, f =ᶠ[𝓝 y] g :=
h.eventually_nhds
/-- If `f x ≤ g x` in a neighbourhood of `a`, then for `y` sufficiently close to `a` we have
`f x ≤ g x` in a neighbourhood of `y`. -/
lemma filter.eventually_le.eventually_le_nhds [has_le β] {f g : α → β} {a : α} (h : f ≤ᶠ[𝓝 a] g) :
∀ᶠ y in 𝓝 a, f ≤ᶠ[𝓝 y] g :=
h.eventually_nhds
theorem all_mem_nhds (x : α) (P : set α → Prop) (hP : ∀ s t, s ⊆ t → P s → P t) :
(∀ s ∈ 𝓝 x, P s) ↔ (∀ s, is_open s → x ∈ s → P s) :=
((nhds_basis_opens x).forall_iff hP).trans $ by simp only [and_comm (x ∈ _), and_imp]
theorem all_mem_nhds_filter (x : α) (f : set α → set β) (hf : ∀ s t, s ⊆ t → f s ⊆ f t)
(l : filter β) :
(∀ s ∈ 𝓝 x, f s ∈ l) ↔ (∀ s, is_open s → x ∈ s → f s ∈ l) :=
all_mem_nhds _ _ (λ s t ssubt h, mem_of_superset h (hf s t ssubt))
theorem rtendsto_nhds {r : rel β α} {l : filter β} {a : α} :
rtendsto r l (𝓝 a) ↔ (∀ s, is_open s → a ∈ s → r.core s ∈ l) :=
all_mem_nhds_filter _ _ (λ s t, id) _
theorem rtendsto'_nhds {r : rel β α} {l : filter β} {a : α} :
rtendsto' r l (𝓝 a) ↔ (∀ s, is_open s → a ∈ s → r.preimage s ∈ l) :=
by { rw [rtendsto'_def], apply all_mem_nhds_filter, apply rel.preimage_mono }
theorem ptendsto_nhds {f : β →. α} {l : filter β} {a : α} :
ptendsto f l (𝓝 a) ↔ (∀ s, is_open s → a ∈ s → f.core s ∈ l) :=
rtendsto_nhds
theorem ptendsto'_nhds {f : β →. α} {l : filter β} {a : α} :
ptendsto' f l (𝓝 a) ↔ (∀ s, is_open s → a ∈ s → f.preimage s ∈ l) :=
rtendsto'_nhds
theorem tendsto_nhds {f : β → α} {l : filter β} {a : α} :
tendsto f l (𝓝 a) ↔ (∀ s, is_open s → a ∈ s → f ⁻¹' s ∈ l) :=
all_mem_nhds_filter _ _ (λ s t h, preimage_mono h) _
lemma tendsto_const_nhds {a : α} {f : filter β} : tendsto (λb:β, a) f (𝓝 a) :=
tendsto_nhds.mpr $ assume s hs ha, univ_mem' $ assume _, ha
lemma tendsto_at_top_of_eventually_const {ι : Type*} [semilattice_sup ι] [nonempty ι]
{x : α} {u : ι → α} {i₀ : ι} (h : ∀ i ≥ i₀, u i = x) : tendsto u at_top (𝓝 x) :=
tendsto.congr' (eventually_eq.symm (eventually_at_top.mpr ⟨i₀, h⟩)) tendsto_const_nhds
lemma tendsto_at_bot_of_eventually_const {ι : Type*} [semilattice_inf ι] [nonempty ι]
{x : α} {u : ι → α} {i₀ : ι} (h : ∀ i ≤ i₀, u i = x) : tendsto u at_bot (𝓝 x) :=
tendsto.congr' (eventually_eq.symm (eventually_at_bot.mpr ⟨i₀, h⟩)) tendsto_const_nhds
lemma pure_le_nhds : pure ≤ (𝓝 : α → filter α) :=
assume a s hs, mem_pure.2 $ mem_of_mem_nhds hs
lemma tendsto_pure_nhds {α : Type*} [topological_space β] (f : α → β) (a : α) :
tendsto f (pure a) (𝓝 (f a)) :=
(tendsto_pure_pure f a).mono_right (pure_le_nhds _)
lemma order_top.tendsto_at_top_nhds {α : Type*} [partial_order α] [order_top α]
[topological_space β] (f : α → β) : tendsto f at_top (𝓝 $ f ⊤) :=
(tendsto_at_top_pure f).mono_right (pure_le_nhds _)
@[simp] instance nhds_ne_bot {a : α} : ne_bot (𝓝 a) :=
ne_bot_of_le (pure_le_nhds a)
/-!
### Cluster points
In this section we define [cluster points](https://en.wikipedia.org/wiki/Limit_point)
(also known as limit points and accumulation points) of a filter and of a sequence.
-/
/-- A point `x` is a cluster point of a filter `F` if 𝓝 x ⊓ F ≠ ⊥. Also known as
an accumulation point or a limit point. -/
def cluster_pt (x : α) (F : filter α) : Prop := ne_bot (𝓝 x ⊓ F)
lemma cluster_pt.ne_bot {x : α} {F : filter α} (h : cluster_pt x F) : ne_bot (𝓝 x ⊓ F) := h
lemma filter.has_basis.cluster_pt_iff {ιa ιF} {pa : ιa → Prop} {sa : ιa → set α}
{pF : ιF → Prop} {sF : ιF → set α} {F : filter α}
(ha : (𝓝 a).has_basis pa sa) (hF : F.has_basis pF sF) :
cluster_pt a F ↔ ∀ ⦃i⦄ (hi : pa i) ⦃j⦄ (hj : pF j), (sa i ∩ sF j).nonempty :=
ha.inf_basis_ne_bot_iff hF
lemma cluster_pt_iff {x : α} {F : filter α} :
cluster_pt x F ↔ ∀ ⦃U : set α⦄ (hU : U ∈ 𝓝 x) ⦃V⦄ (hV : V ∈ F), (U ∩ V).nonempty :=
inf_ne_bot_iff
/-- `x` is a cluster point of a set `s` if every neighbourhood of `x` meets `s` on a nonempty
set. -/
lemma cluster_pt_principal_iff {x : α} {s : set α} :
cluster_pt x (𝓟 s) ↔ ∀ U ∈ 𝓝 x, (U ∩ s).nonempty :=
inf_principal_ne_bot_iff
lemma cluster_pt_principal_iff_frequently {x : α} {s : set α} :
cluster_pt x (𝓟 s) ↔ ∃ᶠ y in 𝓝 x, y ∈ s :=
by simp only [cluster_pt_principal_iff, frequently_iff, set.nonempty, exists_prop, mem_inter_iff]
lemma cluster_pt.of_le_nhds {x : α} {f : filter α} (H : f ≤ 𝓝 x) [ne_bot f] : cluster_pt x f :=
by rwa [cluster_pt, inf_eq_right.mpr H]
lemma cluster_pt.of_le_nhds' {x : α} {f : filter α} (H : f ≤ 𝓝 x) (hf : ne_bot f) :
cluster_pt x f :=
cluster_pt.of_le_nhds H
lemma cluster_pt.of_nhds_le {x : α} {f : filter α} (H : 𝓝 x ≤ f) : cluster_pt x f :=
by simp only [cluster_pt, inf_eq_left.mpr H, nhds_ne_bot]
lemma cluster_pt.mono {x : α} {f g : filter α} (H : cluster_pt x f) (h : f ≤ g) :
cluster_pt x g :=
⟨ne_bot_of_le_ne_bot H.ne $ inf_le_inf_left _ h⟩
lemma cluster_pt.of_inf_left {x : α} {f g : filter α} (H : cluster_pt x $ f ⊓ g) :
cluster_pt x f :=
H.mono inf_le_left
lemma cluster_pt.of_inf_right {x : α} {f g : filter α} (H : cluster_pt x $ f ⊓ g) :
cluster_pt x g :=
H.mono inf_le_right
lemma ultrafilter.cluster_pt_iff {x : α} {f : ultrafilter α} : cluster_pt x f ↔ ↑f ≤ 𝓝 x :=
⟨f.le_of_inf_ne_bot', λ h, cluster_pt.of_le_nhds h⟩
/-- A point `x` is a cluster point of a sequence `u` along a filter `F` if it is a cluster point
of `map u F`. -/
def map_cluster_pt {ι :Type*} (x : α) (F : filter ι) (u : ι → α) : Prop := cluster_pt x (map u F)
lemma map_cluster_pt_iff {ι :Type*} (x : α) (F : filter ι) (u : ι → α) :
map_cluster_pt x F u ↔ ∀ s ∈ 𝓝 x, ∃ᶠ a in F, u a ∈ s :=
by { simp_rw [map_cluster_pt, cluster_pt, inf_ne_bot_iff_frequently_left, frequently_map], refl }
lemma map_cluster_pt_of_comp {ι δ :Type*} {F : filter ι} {φ : δ → ι} {p : filter δ}
{x : α} {u : ι → α} [ne_bot p] (h : tendsto φ p F) (H : tendsto (u ∘ φ) p (𝓝 x)) :
map_cluster_pt x F u :=
begin
have := calc
map (u ∘ φ) p = map u (map φ p) : map_map
... ≤ map u F : map_mono h,
have : map (u ∘ φ) p ≤ 𝓝 x ⊓ map u F,
from le_inf H this,
exact ne_bot_of_le this
end
/-!
### Interior, closure and frontier in terms of neighborhoods
-/
lemma interior_eq_nhds' {s : set α} : interior s = {a | s ∈ 𝓝 a} :=
set.ext $ λ x, by simp only [mem_interior, mem_nhds_iff, mem_set_of_eq]
lemma interior_eq_nhds {s : set α} : interior s = {a | 𝓝 a ≤ 𝓟 s} :=
interior_eq_nhds'.trans $ by simp only [le_principal_iff]
lemma mem_interior_iff_mem_nhds {s : set α} {a : α} :
a ∈ interior s ↔ s ∈ 𝓝 a :=
by rw [interior_eq_nhds', mem_set_of_eq]
@[simp] lemma interior_mem_nhds {s : set α} {a : α} :
interior s ∈ 𝓝 a ↔ s ∈ 𝓝 a :=
⟨λ h, mem_of_superset h interior_subset,
λ h, is_open.mem_nhds is_open_interior (mem_interior_iff_mem_nhds.2 h)⟩
lemma interior_set_of_eq {p : α → Prop} :
interior {x | p x} = {x | ∀ᶠ y in 𝓝 x, p y} :=
interior_eq_nhds'
lemma is_open_set_of_eventually_nhds {p : α → Prop} :
is_open {x | ∀ᶠ y in 𝓝 x, p y} :=
by simp only [← interior_set_of_eq, is_open_interior]
lemma subset_interior_iff_nhds {s V : set α} : s ⊆ interior V ↔ ∀ x ∈ s, V ∈ 𝓝 x :=
show (∀ x, x ∈ s → x ∈ _) ↔ _, by simp_rw mem_interior_iff_mem_nhds
lemma is_open_iff_nhds {s : set α} : is_open s ↔ ∀a∈s, 𝓝 a ≤ 𝓟 s :=
calc is_open s ↔ s ⊆ interior s : subset_interior_iff_open.symm
... ↔ (∀a∈s, 𝓝 a ≤ 𝓟 s) : by rw [interior_eq_nhds]; refl
lemma is_open_iff_mem_nhds {s : set α} : is_open s ↔ ∀a∈s, s ∈ 𝓝 a :=
is_open_iff_nhds.trans $ forall_congr $ λ _, imp_congr_right $ λ _, le_principal_iff
theorem is_open_iff_ultrafilter {s : set α} :
is_open s ↔ (∀ (x ∈ s) (l : ultrafilter α), ↑l ≤ 𝓝 x → s ∈ l) :=
by simp_rw [is_open_iff_mem_nhds, ← mem_iff_ultrafilter]
lemma mem_closure_iff_frequently {s : set α} {a : α} : a ∈ closure s ↔ ∃ᶠ x in 𝓝 a, x ∈ s :=
by rw [filter.frequently, filter.eventually, ← mem_interior_iff_mem_nhds,
closure_eq_compl_interior_compl]; refl
alias mem_closure_iff_frequently ↔ _ filter.frequently.mem_closure
/-- The set of cluster points of a filter is closed. In particular, the set of limit points
of a sequence is closed. -/
lemma is_closed_set_of_cluster_pt {f : filter α} : is_closed {x | cluster_pt x f} :=
begin
simp only [cluster_pt, inf_ne_bot_iff_frequently_left, set_of_forall, imp_iff_not_or],
refine is_closed_Inter (λ p, is_closed.union _ _); apply is_closed_compl_iff.2,
exacts [is_open_set_of_eventually_nhds, is_open_const]
end
theorem mem_closure_iff_cluster_pt {s : set α} {a : α} : a ∈ closure s ↔ cluster_pt a (𝓟 s) :=
mem_closure_iff_frequently.trans cluster_pt_principal_iff_frequently.symm
lemma mem_closure_iff_nhds_ne_bot {s : set α} : a ∈ closure s ↔ 𝓝 a ⊓ 𝓟 s ≠ ⊥ :=
mem_closure_iff_cluster_pt.trans ne_bot_iff
lemma mem_closure_iff_nhds_within_ne_bot {s : set α} {x : α} :
x ∈ closure s ↔ ne_bot (𝓝[s] x) :=
mem_closure_iff_cluster_pt
/-- If `x` is not an isolated point of a topological space, then `{x}ᶜ` is dense in the whole
space. -/
lemma dense_compl_singleton (x : α) [ne_bot (𝓝[{x}ᶜ] x)] : dense ({x}ᶜ : set α) :=
begin
intro y,
unfreezingI { rcases eq_or_ne y x with rfl|hne },
{ rwa mem_closure_iff_nhds_within_ne_bot },
{ exact subset_closure hne }
end
/-- If `x` is not an isolated point of a topological space, then the closure of `{x}ᶜ` is the whole
space. -/
@[simp] lemma closure_compl_singleton (x : α) [ne_bot (𝓝[{x}ᶜ] x)] :
closure {x}ᶜ = (univ : set α) :=
(dense_compl_singleton x).closure_eq
/-- If `x` is not an isolated point of a topological space, then the interior of `{x}` is empty. -/
@[simp] lemma interior_singleton (x : α) [ne_bot (𝓝[{x}ᶜ] x)] :
interior {x} = (∅ : set α) :=
interior_eq_empty_iff_dense_compl.2 (dense_compl_singleton x)
lemma closure_eq_cluster_pts {s : set α} : closure s = {a | cluster_pt a (𝓟 s)} :=
set.ext $ λ x, mem_closure_iff_cluster_pt
theorem mem_closure_iff_nhds {s : set α} {a : α} :
a ∈ closure s ↔ ∀ t ∈ 𝓝 a, (t ∩ s).nonempty :=
mem_closure_iff_cluster_pt.trans cluster_pt_principal_iff
theorem mem_closure_iff_nhds' {s : set α} {a : α} :
a ∈ closure s ↔ ∀ t ∈ 𝓝 a, ∃ y : s, ↑y ∈ t :=
by simp only [mem_closure_iff_nhds, set.nonempty_inter_iff_exists_right]
theorem mem_closure_iff_comap_ne_bot {A : set α} {x : α} :
x ∈ closure A ↔ ne_bot (comap (coe : A → α) (𝓝 x)) :=
by simp_rw [mem_closure_iff_nhds, comap_ne_bot_iff, set.nonempty_inter_iff_exists_right]
theorem mem_closure_iff_nhds_basis' {a : α} {p : ι → Prop} {s : ι → set α} (h : (𝓝 a).has_basis p s)
{t : set α} :
a ∈ closure t ↔ ∀ i, p i → (s i ∩ t).nonempty :=
mem_closure_iff_cluster_pt.trans $ (h.cluster_pt_iff (has_basis_principal _)).trans $
by simp only [exists_prop, forall_const]
theorem mem_closure_iff_nhds_basis {a : α} {p : ι → Prop} {s : ι → set α} (h : (𝓝 a).has_basis p s)
{t : set α} :
a ∈ closure t ↔ ∀ i, p i → ∃ y ∈ t, y ∈ s i :=
(mem_closure_iff_nhds_basis' h).trans $
by simp only [set.nonempty, mem_inter_eq, exists_prop, and_comm]
/-- `x` belongs to the closure of `s` if and only if some ultrafilter
supported on `s` converges to `x`. -/
lemma mem_closure_iff_ultrafilter {s : set α} {x : α} :
x ∈ closure s ↔ ∃ (u : ultrafilter α), s ∈ u ∧ ↑u ≤ 𝓝 x :=
by simp [closure_eq_cluster_pts, cluster_pt, ← exists_ultrafilter_iff, and.comm]
lemma is_closed_iff_cluster_pt {s : set α} : is_closed s ↔ ∀a, cluster_pt a (𝓟 s) → a ∈ s :=
calc is_closed s ↔ closure s ⊆ s : closure_subset_iff_is_closed.symm
... ↔ (∀a, cluster_pt a (𝓟 s) → a ∈ s) : by simp only [subset_def, mem_closure_iff_cluster_pt]
lemma is_closed_iff_nhds {s : set α} : is_closed s ↔ ∀ x, (∀ U ∈ 𝓝 x, (U ∩ s).nonempty) → x ∈ s :=
by simp_rw [is_closed_iff_cluster_pt, cluster_pt, inf_principal_ne_bot_iff]
lemma closure_inter_open {s t : set α} (h : is_open s) : s ∩ closure t ⊆ closure (s ∩ t) :=
begin
rintro a ⟨hs, ht⟩,
have : s ∈ 𝓝 a := is_open.mem_nhds h hs,
rw mem_closure_iff_nhds_ne_bot at ht ⊢,
rwa [← inf_principal, ← inf_assoc, inf_eq_left.2 (le_principal_iff.2 this)],
end
lemma closure_inter_open' {s t : set α} (h : is_open t) : closure s ∩ t ⊆ closure (s ∩ t) :=
by simpa only [inter_comm] using closure_inter_open h
lemma dense.open_subset_closure_inter {s t : set α} (hs : dense s) (ht : is_open t) :
t ⊆ closure (t ∩ s) :=
calc t = t ∩ closure s : by rw [hs.closure_eq, inter_univ]
... ⊆ closure (t ∩ s) : closure_inter_open ht
lemma mem_closure_of_mem_closure_union {s₁ s₂ : set α} {x : α} (h : x ∈ closure (s₁ ∪ s₂))
(h₁ : s₁ᶜ ∈ 𝓝 x) : x ∈ closure s₂ :=
begin
rw mem_closure_iff_nhds_ne_bot at *,
rwa ← calc
𝓝 x ⊓ principal (s₁ ∪ s₂) = 𝓝 x ⊓ (principal s₁ ⊔ principal s₂) : by rw sup_principal
... = (𝓝 x ⊓ principal s₁) ⊔ (𝓝 x ⊓ principal s₂) : inf_sup_left
... = ⊥ ⊔ 𝓝 x ⊓ principal s₂ : by rw inf_principal_eq_bot.mpr h₁
... = 𝓝 x ⊓ principal s₂ : bot_sup_eq
end
/-- The intersection of an open dense set with a dense set is a dense set. -/
lemma dense.inter_of_open_left {s t : set α} (hs : dense s) (ht : dense t) (hso : is_open s) :
dense (s ∩ t) :=
λ x, (closure_minimal (closure_inter_open hso) is_closed_closure) $
by simp [hs.closure_eq, ht.closure_eq]
/-- The intersection of a dense set with an open dense set is a dense set. -/
lemma dense.inter_of_open_right {s t : set α} (hs : dense s) (ht : dense t) (hto : is_open t) :
dense (s ∩ t) :=
inter_comm t s ▸ ht.inter_of_open_left hs hto
lemma dense.inter_nhds_nonempty {s t : set α} (hs : dense s) {x : α} (ht : t ∈ 𝓝 x) :
(s ∩ t).nonempty :=
let ⟨U, hsub, ho, hx⟩ := mem_nhds_iff.1 ht in
(hs.inter_open_nonempty U ho ⟨x, hx⟩).mono $ λ y hy, ⟨hy.2, hsub hy.1⟩
lemma closure_diff {s t : set α} : closure s \ closure t ⊆ closure (s \ t) :=
calc closure s \ closure t = (closure t)ᶜ ∩ closure s : by simp only [diff_eq, inter_comm]
... ⊆ closure ((closure t)ᶜ ∩ s) : closure_inter_open $ is_open_compl_iff.mpr $ is_closed_closure
... = closure (s \ closure t) : by simp only [diff_eq, inter_comm]
... ⊆ closure (s \ t) : closure_mono $ diff_subset_diff (subset.refl s) subset_closure
lemma filter.frequently.mem_of_closed {a : α} {s : set α} (h : ∃ᶠ x in 𝓝 a, x ∈ s)
(hs : is_closed s) : a ∈ s :=
hs.closure_subset h.mem_closure
lemma is_closed.mem_of_frequently_of_tendsto {f : β → α} {b : filter β} {a : α} {s : set α}
(hs : is_closed s) (h : ∃ᶠ x in b, f x ∈ s) (hf : tendsto f b (𝓝 a)) : a ∈ s :=
(hf.frequently $ show ∃ᶠ x in b, (λ y, y ∈ s) (f x), from h).mem_of_closed hs
lemma is_closed.mem_of_tendsto {f : β → α} {b : filter β} {a : α} {s : set α}
[ne_bot b] (hs : is_closed s) (hf : tendsto f b (𝓝 a)) (h : ∀ᶠ x in b, f x ∈ s) : a ∈ s :=
hs.mem_of_frequently_of_tendsto h.frequently hf
lemma mem_closure_of_tendsto {f : β → α} {b : filter β} {a : α} {s : set α}
[ne_bot b] (hf : tendsto f b (𝓝 a)) (h : ∀ᶠ x in b, f x ∈ s) : a ∈ closure s :=
is_closed_closure.mem_of_tendsto hf $ h.mono (preimage_mono subset_closure)
/-- Suppose that `f` sends the complement to `s` to a single point `a`, and `l` is some filter.
Then `f` tends to `a` along `l` restricted to `s` if and only if it tends to `a` along `l`. -/
lemma tendsto_inf_principal_nhds_iff_of_forall_eq {f : β → α} {l : filter β} {s : set β}
{a : α} (h : ∀ x ∉ s, f x = a) :
tendsto f (l ⊓ 𝓟 s) (𝓝 a) ↔ tendsto f l (𝓝 a) :=
begin
rw [tendsto_iff_comap, tendsto_iff_comap],
replace h : 𝓟 sᶜ ≤ comap f (𝓝 a),
{ rintros U ⟨t, ht, htU⟩ x hx,
have : f x ∈ t, from (h x hx).symm ▸ mem_of_mem_nhds ht,
exact htU this },
refine ⟨λ h', _, le_trans inf_le_left⟩,
have := sup_le h' h,
rw [sup_inf_right, sup_principal, union_compl_self, principal_univ,
inf_top_eq, sup_le_iff] at this,
exact this.1
end
/-!
### Limits of filters in topological spaces
-/
section lim
/-- If `f` is a filter, then `Lim f` is a limit of the filter, if it exists. -/
noncomputable def Lim [nonempty α] (f : filter α) : α := epsilon $ λa, f ≤ 𝓝 a
/--
If `f` is a filter satisfying `ne_bot f`, then `Lim' f` is a limit of the filter, if it exists.
-/
def Lim' (f : filter α) [ne_bot f] : α := @Lim _ _ (nonempty_of_ne_bot f) f
/--
If `F` is an ultrafilter, then `filter.ultrafilter.Lim F` is a limit of the filter, if it exists.
Note that dot notation `F.Lim` can be used for `F : ultrafilter α`.
-/
def ultrafilter.Lim : ultrafilter α → α := λ F, Lim' F
/-- If `f` is a filter in `β` and `g : β → α` is a function, then `lim f` is a limit of `g` at `f`,
if it exists. -/
noncomputable def lim [nonempty α] (f : filter β) (g : β → α) : α :=
Lim (f.map g)
/-- If a filter `f` is majorated by some `𝓝 a`, then it is majorated by `𝓝 (Lim f)`. We formulate
this lemma with a `[nonempty α]` argument of `Lim` derived from `h` to make it useful for types
without a `[nonempty α]` instance. Because of the built-in proof irrelevance, Lean will unify
this instance with any other instance. -/
lemma le_nhds_Lim {f : filter α} (h : ∃a, f ≤ 𝓝 a) : f ≤ 𝓝 (@Lim _ _ (nonempty_of_exists h) f) :=
epsilon_spec h
/-- If `g` tends to some `𝓝 a` along `f`, then it tends to `𝓝 (lim f g)`. We formulate
this lemma with a `[nonempty α]` argument of `lim` derived from `h` to make it useful for types
without a `[nonempty α]` instance. Because of the built-in proof irrelevance, Lean will unify
this instance with any other instance. -/
lemma tendsto_nhds_lim {f : filter β} {g : β → α} (h : ∃ a, tendsto g f (𝓝 a)) :
tendsto g f (𝓝 $ @lim _ _ _ (nonempty_of_exists h) f g) :=
le_nhds_Lim h
end lim
/-!
### Locally finite families
-/
/- locally finite family [General Topology (Bourbaki, 1995)] -/
section locally_finite
/-- A family of sets in `set α` is locally finite if at every point `x:α`,
there is a neighborhood of `x` which meets only finitely many sets in the family -/
def locally_finite (f : β → set α) :=
∀x:α, ∃t ∈ 𝓝 x, finite {i | (f i ∩ t).nonempty }
lemma locally_finite.point_finite {f : β → set α} (hf : locally_finite f) (x : α) :
finite {b | x ∈ f b} :=
let ⟨t, hxt, ht⟩ := hf x in ht.subset $ λ b hb, ⟨x, hb, mem_of_mem_nhds hxt⟩
lemma locally_finite_of_fintype [fintype β] (f : β → set α) : locally_finite f :=
assume x, ⟨univ, univ_mem, finite.of_fintype _⟩
lemma locally_finite.subset
{f₁ f₂ : β → set α} (hf₂ : locally_finite f₂) (hf : ∀b, f₁ b ⊆ f₂ b) : locally_finite f₁ :=
assume a,
let ⟨t, ht₁, ht₂⟩ := hf₂ a in
⟨t, ht₁, ht₂.subset $ assume i hi, hi.mono $ inter_subset_inter (hf i) $ subset.refl _⟩
lemma locally_finite.comp_injective {ι} {f : β → set α} {g : ι → β} (hf : locally_finite f)
(hg : function.injective g) : locally_finite (f ∘ g) :=
λ x, let ⟨t, htx, htf⟩ := hf x in ⟨t, htx, htf.preimage (hg.inj_on _)⟩
lemma locally_finite.closure {f : β → set α} (hf : locally_finite f) :
locally_finite (λ i, closure (f i)) :=
begin
intro x,
rcases hf x with ⟨s, hsx, hsf⟩,
refine ⟨interior s, interior_mem_nhds.2 hsx, hsf.subset $ λ i hi, _⟩,
exact (hi.mono (closure_inter_open' is_open_interior)).of_closure.mono
(inter_subset_inter_right _ interior_subset)
end
lemma locally_finite.is_closed_Union {f : β → set α}
(h₁ : locally_finite f) (h₂ : ∀i, is_closed (f i)) : is_closed (⋃i, f i) :=
begin
simp only [← is_open_compl_iff, compl_Union, is_open_iff_mem_nhds, mem_Inter],
intros a ha,
replace ha : ∀ i, (f i)ᶜ ∈ 𝓝 a := λ i, (h₂ i).is_open_compl.mem_nhds (ha i),
rcases h₁ a with ⟨t, h_nhds, h_fin⟩,
have : t ∩ (⋂ i ∈ {i | (f i ∩ t).nonempty}, (f i)ᶜ) ∈ 𝓝 a,
from inter_mem h_nhds ((bInter_mem h_fin).2 (λ i _, ha i)),
filter_upwards [this],
simp only [mem_inter_eq, mem_Inter],
rintros b ⟨hbt, hn⟩ i hfb,
exact hn i ⟨b, hfb, hbt⟩ hfb
end
lemma locally_finite.closure_Union {f : β → set α} (h : locally_finite f) :
closure (⋃ i, f i) = ⋃ i, closure (f i) :=
subset.antisymm
(closure_minimal (Union_subset_Union $ λ _, subset_closure) $
h.closure.is_closed_Union $ λ _, is_closed_closure)
(Union_subset $ λ i, closure_mono $ subset_Union _ _)
end locally_finite
end topological_space
/-!
### Continuity
-/
section continuous
variables {α : Type*} {β : Type*} {γ : Type*} {δ : Type*}
variables [topological_space α] [topological_space β] [topological_space γ]
open_locale topological_space
/-- A function between topological spaces is continuous if the preimage
of every open set is open. Registered as a structure to make sure it is not unfolded by Lean. -/
structure continuous (f : α → β) : Prop :=
(is_open_preimage : ∀s, is_open s → is_open (f ⁻¹' s))
lemma continuous_def {f : α → β} : continuous f ↔ (∀s, is_open s → is_open (f ⁻¹' s)) :=
⟨λ hf s hs, hf.is_open_preimage s hs, λ h, ⟨h⟩⟩
lemma is_open.preimage {f : α → β} (hf : continuous f) {s : set β} (h : is_open s) :
is_open (f ⁻¹' s) :=
hf.is_open_preimage s h
/-- A function between topological spaces is continuous at a point `x₀`
if `f x` tends to `f x₀` when `x` tends to `x₀`. -/
def continuous_at (f : α → β) (x : α) := tendsto f (𝓝 x) (𝓝 (f x))
lemma continuous_at.tendsto {f : α → β} {x : α} (h : continuous_at f x) :
tendsto f (𝓝 x) (𝓝 (f x)) :=
h
lemma continuous_at_congr {f g : α → β} {x : α} (h : f =ᶠ[𝓝 x] g) :
continuous_at f x ↔ continuous_at g x :=
by simp only [continuous_at, tendsto_congr' h, h.eq_of_nhds]
lemma continuous_at.congr {f g : α → β} {x : α} (hf : continuous_at f x) (h : f =ᶠ[𝓝 x] g) :
continuous_at g x :=
(continuous_at_congr h).1 hf
lemma continuous_at.preimage_mem_nhds {f : α → β} {x : α} {t : set β} (h : continuous_at f x)
(ht : t ∈ 𝓝 (f x)) : f ⁻¹' t ∈ 𝓝 x :=
h ht
lemma eventually_eq_zero_nhds {M₀} [has_zero M₀] {a : α} {f : α → M₀} :
f =ᶠ[𝓝 a] 0 ↔ a ∉ closure (function.support f) :=
by rw [← mem_compl_eq, ← interior_compl, mem_interior_iff_mem_nhds, function.compl_support]; refl
lemma cluster_pt.map {x : α} {la : filter α} {lb : filter β} (H : cluster_pt x la)
{f : α → β} (hfc : continuous_at f x) (hf : tendsto f la lb) :
cluster_pt (f x) lb :=
⟨ne_bot_of_le_ne_bot ((map_ne_bot_iff f).2 H).ne $ hfc.tendsto.inf hf⟩
/-- See also `interior_preimage_subset_preimage_interior`. -/
lemma preimage_interior_subset_interior_preimage {f : α → β} {s : set β}
(hf : continuous f) : f⁻¹' (interior s) ⊆ interior (f⁻¹' s) :=
interior_maximal (preimage_mono interior_subset) (is_open_interior.preimage hf)
lemma continuous_id : continuous (id : α → α) :=
continuous_def.2 $ assume s h, h
lemma continuous.comp {g : β → γ} {f : α → β} (hg : continuous g) (hf : continuous f) :
continuous (g ∘ f) :=
continuous_def.2 $ assume s h, (h.preimage hg).preimage hf
lemma continuous.iterate {f : α → α} (h : continuous f) (n : ℕ) : continuous (f^[n]) :=
nat.rec_on n continuous_id (λ n ihn, ihn.comp h)
lemma continuous_at.comp {g : β → γ} {f : α → β} {x : α}
(hg : continuous_at g (f x)) (hf : continuous_at f x) :
continuous_at (g ∘ f) x :=
hg.comp hf
lemma continuous.tendsto {f : α → β} (hf : continuous f) (x) :
tendsto f (𝓝 x) (𝓝 (f x)) :=
((nhds_basis_opens x).tendsto_iff $ nhds_basis_opens $ f x).2 $
λ t ⟨hxt, ht⟩, ⟨f ⁻¹' t, ⟨hxt, ht.preimage hf⟩, subset.refl _⟩
/-- A version of `continuous.tendsto` that allows one to specify a simpler form of the limit.
E.g., one can write `continuous_exp.tendsto' 0 1 exp_zero`. -/
lemma continuous.tendsto' {f : α → β} (hf : continuous f) (x : α) (y : β) (h : f x = y) :
tendsto f (𝓝 x) (𝓝 y) :=
h ▸ hf.tendsto x
lemma continuous.continuous_at {f : α → β} {x : α} (h : continuous f) :
continuous_at f x :=
h.tendsto x
lemma continuous_iff_continuous_at {f : α → β} : continuous f ↔ ∀ x, continuous_at f x :=
⟨continuous.tendsto,
assume hf : ∀x, tendsto f (𝓝 x) (𝓝 (f x)),
continuous_def.2 $
assume s, assume hs : is_open s,
have ∀a, f a ∈ s → s ∈ 𝓝 (f a),
from λ a ha, is_open.mem_nhds hs ha,
show is_open (f ⁻¹' s),
from is_open_iff_nhds.2 $ λ a ha, le_principal_iff.2 $ hf _ (this a ha)⟩
lemma continuous_at_const {x : α} {b : β} : continuous_at (λ a:α, b) x :=
tendsto_const_nhds
lemma continuous_const {b : β} : continuous (λa:α, b) :=
continuous_iff_continuous_at.mpr $ assume a, continuous_at_const
lemma filter.eventually_eq.continuous_at {x : α} {f : α → β} {y : β} (h : f =ᶠ[𝓝 x] (λ _, y)) :
continuous_at f x :=
(continuous_at_congr h).2 tendsto_const_nhds
lemma continuous_of_const {f : α → β} (h : ∀ x y, f x = f y) : continuous f :=
continuous_iff_continuous_at.mpr $ λ x, filter.eventually_eq.continuous_at $
eventually_of_forall (λ y, h y x)
lemma continuous_at_id {x : α} : continuous_at id x :=
continuous_id.continuous_at
lemma continuous_at.iterate {f : α → α} {x : α} (hf : continuous_at f x) (hx : f x = x) (n : ℕ) :
continuous_at (f^[n]) x :=
nat.rec_on n continuous_at_id $ λ n ihn,
show continuous_at (f^[n] ∘ f) x,
from continuous_at.comp (hx.symm ▸ ihn) hf
lemma continuous_iff_is_closed {f : α → β} :
continuous f ↔ (∀s, is_closed s → is_closed (f ⁻¹' s)) :=
⟨assume hf s hs, by simpa using (continuous_def.1 hf sᶜ hs.is_open_compl).is_closed_compl,
assume hf, continuous_def.2 $ assume s,
by rw [←is_closed_compl_iff, ←is_closed_compl_iff]; exact hf _⟩
lemma is_closed.preimage {f : α → β} (hf : continuous f) {s : set β} (h : is_closed s) :
is_closed (f ⁻¹' s) :=
continuous_iff_is_closed.mp hf s h
lemma mem_closure_image {f : α → β} {x : α} {s : set α} (hf : continuous_at f x)
(hx : x ∈ closure s) : f x ∈ closure (f '' s) :=
begin
rw [mem_closure_iff_nhds_ne_bot] at hx ⊢,
rw ← bot_lt_iff_ne_bot,
haveI : ne_bot _ := ⟨hx⟩,
calc
⊥ < map f (𝓝 x ⊓ principal s) : bot_lt_iff_ne_bot.mpr ne_bot.ne'
... ≤ (map f $ 𝓝 x) ⊓ (map f $ principal s) : map_inf_le
... = (map f $ 𝓝 x) ⊓ (principal $ f '' s) : by rw map_principal
... ≤ 𝓝 (f x) ⊓ (principal $ f '' s) : inf_le_inf hf le_rfl
end
lemma continuous_at_iff_ultrafilter {f : α → β} {x} : continuous_at f x ↔
∀ g : ultrafilter α, ↑g ≤ 𝓝 x → tendsto f g (𝓝 (f x)) :=
tendsto_iff_ultrafilter f (𝓝 x) (𝓝 (f x))
lemma continuous_iff_ultrafilter {f : α → β} :
continuous f ↔ ∀ x (g : ultrafilter α), ↑g ≤ 𝓝 x → tendsto f g (𝓝 (f x)) :=
by simp only [continuous_iff_continuous_at, continuous_at_iff_ultrafilter]
lemma continuous.closure_preimage_subset {f : α → β}
(hf : continuous f) (t : set β) :
closure (f ⁻¹' t) ⊆ f ⁻¹' (closure t) :=
begin
rw ← (is_closed_closure.preimage hf).closure_eq,
exact closure_mono (preimage_mono subset_closure),
end
lemma continuous.frontier_preimage_subset
{f : α → β} (hf : continuous f) (t : set β) :
frontier (f ⁻¹' t) ⊆ f ⁻¹' (frontier t) :=
diff_subset_diff (hf.closure_preimage_subset t) (preimage_interior_subset_interior_preimage hf)
/-! ### Continuity and partial functions -/
/-- Continuity of a partial function -/
def pcontinuous (f : α →. β) := ∀ s, is_open s → is_open (f.preimage s)
lemma open_dom_of_pcontinuous {f : α →. β} (h : pcontinuous f) : is_open f.dom :=
by rw [←pfun.preimage_univ]; exact h _ is_open_univ
lemma pcontinuous_iff' {f : α →. β} :
pcontinuous f ↔ ∀ {x y} (h : y ∈ f x), ptendsto' f (𝓝 x) (𝓝 y) :=
begin
split,
{ intros h x y h',
simp only [ptendsto'_def, mem_nhds_iff],
rintros s ⟨t, tsubs, opent, yt⟩,
exact ⟨f.preimage t, pfun.preimage_mono _ tsubs, h _ opent, ⟨y, yt, h'⟩⟩ },
intros hf s os,
rw is_open_iff_nhds,
rintros x ⟨y, ys, fxy⟩ t,
rw [mem_principal],
assume h : f.preimage s ⊆ t,
change t ∈ 𝓝 x,
apply mem_of_superset _ h,
have h' : ∀ s ∈ 𝓝 y, f.preimage s ∈ 𝓝 x,
{ intros s hs,
have : ptendsto' f (𝓝 x) (𝓝 y) := hf fxy,
rw ptendsto'_def at this,
exact this s hs },
show f.preimage s ∈ 𝓝 x,
apply h', rw mem_nhds_iff, exact ⟨s, set.subset.refl _, os, ys⟩
end
/-- If a continuous map `f` maps `s` to `t`, then it maps `closure s` to `closure t`. -/
lemma set.maps_to.closure {s : set α} {t : set β} {f : α → β} (h : maps_to f s t)
(hc : continuous f) : maps_to f (closure s) (closure t) :=
begin
simp only [maps_to, mem_closure_iff_cluster_pt],
exact λ x hx, hx.map hc.continuous_at (tendsto_principal_principal.2 h)
end
lemma image_closure_subset_closure_image {f : α → β} {s : set α} (h : continuous f) :
f '' closure s ⊆ closure (f '' s) :=
((maps_to_image f s).closure h).image_subset
lemma closure_subset_preimage_closure_image {f : α → β} {s : set α} (h : continuous f) :
closure s ⊆ f ⁻¹' (closure (f '' s)) :=
by { rw ← set.image_subset_iff, exact image_closure_subset_closure_image h }
lemma map_mem_closure {s : set α} {t : set β} {f : α → β} {a : α}
(hf : continuous f) (ha : a ∈ closure s) (ht : ∀a∈s, f a ∈ t) : f a ∈ closure t :=
set.maps_to.closure ht hf ha
/-!
### Function with dense range
-/
section dense_range
variables {κ ι : Type*} (f : κ → β) (g : β → γ)
/-- `f : ι → β` has dense range if its range (image) is a dense subset of β. -/
def dense_range := dense (range f)
variables {f}
/-- A surjective map has dense range. -/
lemma function.surjective.dense_range (hf : function.surjective f) : dense_range f :=
λ x, by simp [hf.range_eq]
lemma dense_range_iff_closure_range : dense_range f ↔ closure (range f) = univ :=
dense_iff_closure_eq
lemma dense_range.closure_range (h : dense_range f) : closure (range f) = univ :=
h.closure_eq
lemma dense.dense_range_coe {s : set α} (h : dense s) : dense_range (coe : s → α) :=
by simpa only [dense_range, subtype.range_coe_subtype]
lemma continuous.range_subset_closure_image_dense {f : α → β} (hf : continuous f)
{s : set α} (hs : dense s) :
range f ⊆ closure (f '' s) :=
by { rw [← image_univ, ← hs.closure_eq], exact image_closure_subset_closure_image hf }
/-- The image of a dense set under a continuous map with dense range is a dense set. -/
lemma dense_range.dense_image {f : α → β} (hf' : dense_range f) (hf : continuous f)
{s : set α} (hs : dense s) :
dense (f '' s) :=
(hf'.mono $ hf.range_subset_closure_image_dense hs).of_closure
/-- If `f` has dense range and `s` is an open set in the codomain of `f`, then the image of the
preimage of `s` under `f` is dense in `s`. -/
lemma dense_range.subset_closure_image_preimage_of_is_open (hf : dense_range f) {s : set β}
(hs : is_open s) : s ⊆ closure (f '' (f ⁻¹' s)) :=
by { rw image_preimage_eq_inter_range, exact hf.open_subset_closure_inter hs }
/-- If a continuous map with dense range maps a dense set to a subset of `t`, then `t` is a dense
set. -/
lemma dense_range.dense_of_maps_to {f : α → β} (hf' : dense_range f) (hf : continuous f)
{s : set α} (hs : dense s) {t : set β} (ht : maps_to f s t) :
dense t :=
(hf'.dense_image hf hs).mono ht.image_subset
/-- Composition of a continuous map with dense range and a function with dense range has dense
range. -/
lemma dense_range.comp {g : β → γ} {f : κ → β} (hg : dense_range g) (hf : dense_range f)
(cg : continuous g) :
dense_range (g ∘ f) :=
by { rw [dense_range, range_comp], exact hg.dense_image cg hf }
lemma dense_range.nonempty_iff (hf : dense_range f) : nonempty κ ↔ nonempty β :=
range_nonempty_iff_nonempty.symm.trans hf.nonempty_iff
lemma dense_range.nonempty [h : nonempty β] (hf : dense_range f) : nonempty κ :=
hf.nonempty_iff.mpr h
/-- Given a function `f : α → β` with dense range and `b : β`, returns some `a : α`. -/
def dense_range.some (hf : dense_range f) (b : β) : κ :=
classical.choice $ hf.nonempty_iff.mpr ⟨b⟩
lemma dense_range.exists_mem_open (hf : dense_range f) {s : set β} (ho : is_open s)
(hs : s.nonempty) :
∃ a, f a ∈ s :=
exists_range_iff.1 $ hf.exists_mem_open ho hs
lemma dense_range.mem_nhds {f : κ → β} (h : dense_range f) {b : β} {U : set β}
(U_in : U ∈ nhds b) : ∃ a, f a ∈ U :=
begin
rcases (mem_closure_iff_nhds.mp
((dense_range_iff_closure_range.mp h).symm ▸ mem_univ b : b ∈ closure (range f)) U U_in)
with ⟨_, h, a, rfl⟩,
exact ⟨a, h⟩
end
end dense_range
end continuous
/--
The library contains many lemmas stating that functions/operations are continuous. There are many
ways to formulate the continuity of operations. Some are more convenient than others.
Note: for the most part this note also applies to other properties
(`measurable`, `differentiable`, `continuous_on`, ...).
### The traditional way
As an example, let's look at addition `(+) : M → M → M`. We can state that this is continuous
in different definitionally equal ways (omitting some typing information)
* `continuous (λ p, p.1 + p.2)`;
* `continuous (function.uncurry (+))`;
* `continuous ↿(+)`. (`↿` is notation for recursively uncurrying a function)
However, lemmas with this conclusion are not nice to use in practice because
1. They confuse the elaborator. The following two examples fail, because of limitations in the
elaboration process.
```
variables {M : Type*} [has_mul M] [topological_space M] [has_continuous_mul M]
example : continuous (λ x : M, x + x) :=
continuous_add.comp _
example : continuous (λ x : M, x + x) :=
continuous_add.comp (continuous_id.prod_mk continuous_id)
```
The second is a valid proof, which is accepted if you write it as
`continuous_add.comp (continuous_id.prod_mk continuous_id : _)`
2. If the operation has more than 2 arguments, they are impractical to use, because in your
application the arguments in the domain might be in a different order or associated differently.
### The convenient way
A much more convenient way to write continuity lemmas is like `continuous.add`:
```
continuous.add {f g : X → M} (hf : continuous f) (hg : continuous g) : continuous (λ x, f x + g x)
```
The conclusion can be `continuous (f + g)`, which is definitionally equal.
This has the following advantages
* It supports projection notation, so is shorter to write.
* `continuous.add _ _` is recognized correctly by the elaborator and gives useful new goals.
* It works generally, since the domain is a variable.
As an example for an unary operation, we have `continuous.neg`.
```
continuous.neg {f : α → G} (hf : continuous f) : continuous (λ x, -f x)
```
For unary functions, the elaborator is not confused when applying the traditional lemma
(like `continuous_neg`), but it's still convenient to have the short version available (compare
`hf.neg.neg.neg` with `continuous_neg.comp $ continuous_neg.comp $ continuous_neg.comp hf`).
As a harder example, consider an operation of the following type:
```
def strans {x : F} (γ γ' : path x x) (t₀ : I) : path x x
```
The precise definition is not important, only its type.
The correct continuity principle for this operation is something like this:
```
{f : X → F} {γ γ' : ∀ x, path (f x) (f x)} {t₀ s : X → I}
(hγ : continuous ↿γ) (hγ' : continuous ↿γ')
(ht : continuous t₀) (hs : continuous s) :
continuous (λ x, strans (γ x) (γ' x) (t x) (s x))
```
Note that *all* arguments of `strans` are indexed over `X`, even the basepoint `x`, and the last
argument `s` that arises since `path x x` has a coercion to `I → F`. The paths `γ` and `γ'` (which
are unary functions from `I`) become binary functions in the continuity lemma.
### Summary
* Make sure that your continuity lemmas are stated in the most general way, and in a convenient
form. That means that:
- The conclusion has a variable `X` as domain (not something like `Y × Z`);
- Wherever possible, all point arguments `c : Y` are replaced by functions `c : X → Y`;
- All `n`-ary function arguments are replaced by `n+1`-ary functions
(`f : Y → Z` becomes `f : X → Y → Z`);
- All (relevant) arguments have continuity assumptions, and perhaps there are additional
assumptions needed to make the operation continuous;
- The function in the conclusion is fully applied.
* These remarks are mostly about the format of the *conclusion* of a continuity lemma.
In assumptions it's fine to state that a function with more than 1 argument is continuous using
`↿` or `function.uncurry`.
### Functions with discontinuities
In some cases, you want to work with discontinuous functions, and in certain expressions they are
still continuous. For example, consider the fractional part of a number, `fract : ℝ → ℝ`.
In this case, you want to add conditions to when a function involving `fract` is continuous, so you
get something like this: (assumption `hf` could be weakened, but the important thing is the shape
of the conclusion)
```
lemma continuous_on.comp_fract {X Y : Type*} [topological_space X] [topological_space Y]
{f : X → ℝ → Y} {g : X → ℝ} (hf : continuous ↿f) (hg : continuous g) (h : ∀ s, f s 0 = f s 1) :
continuous (λ x, f x (fract (g x)))
```
With `continuous_at` you can be even more precise about what to prove in case of discontinuities,
see e.g. `continuous_at.comp_div_cases`.
-/
library_note "continuity lemma statement"
|
State Before: K : Type u_1
ι : Type u_3
R : ι → Type u_2
inst✝ : (i : ι) → SMul K (R i)
r : K
t : (i : ι) → Set (R i)
x : (i : ι) → R i
h : x ∈ pi univ (r • t)
⊢ x ∈ r • pi univ t State After: case refine'_1
K : Type u_1
ι : Type u_3
R : ι → Type u_2
inst✝ : (i : ι) → SMul K (R i)
r : K
t : (i : ι) → Set (R i)
x : (i : ι) → R i
h : x ∈ pi univ (r • t)
i : ι
x✝ : i ∈ univ
⊢ (fun i => Classical.choose (_ : x i ∈ (r • t) i)) i ∈ t i
case refine'_2
K : Type u_1
ι : Type u_3
R : ι → Type u_2
inst✝ : (i : ι) → SMul K (R i)
r : K
t : (i : ι) → Set (R i)
x : (i : ι) → R i
h : x ∈ pi univ (r • t)
i : ι
⊢ (fun x => r • x) (fun i => Classical.choose (_ : x i ∈ (r • t) i)) i = x i Tactic: refine' ⟨fun i ↦ Classical.choose (h i <| Set.mem_univ _), fun i _ ↦ _, funext fun i ↦ _⟩ State Before: case refine'_1
K : Type u_1
ι : Type u_3
R : ι → Type u_2
inst✝ : (i : ι) → SMul K (R i)
r : K
t : (i : ι) → Set (R i)
x : (i : ι) → R i
h : x ∈ pi univ (r • t)
i : ι
x✝ : i ∈ univ
⊢ (fun i => Classical.choose (_ : x i ∈ (r • t) i)) i ∈ t i State After: no goals Tactic: exact (Classical.choose_spec (h i <| Set.mem_univ i)).left State Before: case refine'_2
K : Type u_1
ι : Type u_3
R : ι → Type u_2
inst✝ : (i : ι) → SMul K (R i)
r : K
t : (i : ι) → Set (R i)
x : (i : ι) → R i
h : x ∈ pi univ (r • t)
i : ι
⊢ (fun x => r • x) (fun i => Classical.choose (_ : x i ∈ (r • t) i)) i = x i State After: no goals Tactic: exact (Classical.choose_spec (h i <| Set.mem_univ i)).right |
(* Distributed under the terms of the MIT license. *)
From Coq Require Import ssreflect Morphisms.
From MetaCoq.Utils Require Import utils.
From MetaCoq.Common Require Export Universes BasicAst Environment Reflect.
From MetaCoq.Common Require EnvironmentTyping.
From MetaCoq.PCUIC Require Export PCUICPrimitive.
From Equations Require Import Equations.
(** * AST of the Polymorphic Cumulative Calculus of Inductive Constructions
This AST is a cleaned-up version of Coq's internal AST better suited for
reasoning.
In particular, it has binary applications and all terms are well-formed.
Casts are absent as well. *)
Declare Scope pcuic.
Delimit Scope pcuic with pcuic.
Open Scope pcuic.
(** DO NOT USE firstorder, since the introduction of Ints and Floats, it became unusuable. *)
Ltac pcuicfo_gen tac :=
simpl in *; intuition (simpl; intuition tac).
Tactic Notation "pcuicfo" := pcuicfo_gen auto.
Tactic Notation "pcuicfo" tactic(tac) := pcuicfo_gen tac.
(* This allows not relying on lemma names getting a length ws_cumul_pb out of some type. *)
Class HasLen (A : Type) (x y : nat) := len : A -> x = y.
(** Note the use of a global reference to avoid capture. *)
Notation length_of t := ltac:(let lemma := constr:(PCUICAst.len t) in exact lemma) (only parsing).
(* Defined here since BasicAst does not have access to universe instances.
Parameterized by term types as they are not yet defined. *)
Record predicate {term} := mk_predicate {
pparams : list term; (* The parameters *)
puinst : Instance.t; (* The universe instance *)
pcontext : list (context_decl term);
(* The predicate context,
initially built from params and puinst *)
preturn : term; (* The return type *) }.
Derive NoConfusion for predicate.
Arguments predicate : clear implicits.
Arguments mk_predicate {_}.
Section map_predicate.
Context {term term' : Type}.
Context (uf : Instance.t -> Instance.t).
Context (paramf preturnf : term -> term').
Context (pcontextf : list (context_decl term) -> list (context_decl term')).
Definition map_predicate (p : predicate term) :=
{| pparams := map paramf p.(pparams);
puinst := uf p.(puinst);
pcontext := pcontextf p.(pcontext);
preturn := preturnf p.(preturn) |}.
Lemma map_pparams (p : predicate term) :
map paramf (pparams p) = pparams (map_predicate p).
Proof using Type. reflexivity. Qed.
Lemma map_preturn (p : predicate term) :
preturnf (preturn p) = preturn (map_predicate p).
Proof using Type. reflexivity. Qed.
Lemma map_pcontext (p : predicate term) :
pcontextf (pcontext p) = pcontext (map_predicate p).
Proof using Type. reflexivity. Qed.
Lemma map_puinst (p : predicate term) :
uf (puinst p) = puinst (map_predicate p).
Proof using Type. reflexivity. Qed.
End map_predicate.
Definition shiftf {A B} (f : nat -> A -> B) k := (fun k' => f (k' + k)).
Section map_predicate_k.
Context {term : Type}.
Context (uf : Instance.t -> Instance.t).
Context (f : nat -> term -> term).
Definition map_predicate_k k (p : predicate term) :=
{| pparams := map (f k) p.(pparams);
puinst := uf p.(puinst);
pcontext := p.(pcontext);
preturn := f (#|p.(pcontext)| + k) p.(preturn) |}.
Lemma map_k_pparams k (p : predicate term) :
map (f k) (pparams p) = pparams (map_predicate_k k p).
Proof using Type. reflexivity. Qed.
Lemma map_k_preturn k (p : predicate term) :
f (#|p.(pcontext)| + k) (preturn p) = preturn (map_predicate_k k p).
Proof using Type. reflexivity. Qed.
Lemma map_k_pcontext k (p : predicate term) :
(pcontext p) = pcontext (map_predicate_k k p).
Proof using Type. reflexivity. Qed.
Lemma map_k_puinst k (p : predicate term) :
uf (puinst p) = puinst (map_predicate_k k p).
Proof using Type. reflexivity. Qed.
Definition test_predicate (instp : Instance.t -> bool) (p : term -> bool)
(pred : predicate term) :=
instp pred.(puinst) && forallb p pred.(pparams) &&
test_context p pred.(pcontext) && p pred.(preturn).
Definition test_predicate_k (instp : Instance.t -> bool)
(p : nat -> term -> bool) k (pred : predicate term) :=
instp pred.(puinst) && forallb (p k) pred.(pparams) &&
test_context_k p #|pred.(pparams)| pred.(pcontext) &&
p (#|pred.(pcontext)| + k) pred.(preturn).
Definition test_predicate_ku (instp : nat -> Instance.t -> bool)
(p : nat -> term -> bool) k (pred : predicate term) :=
instp k pred.(puinst) && forallb (p k) pred.(pparams) &&
test_context (p #|pred.(puinst)|) pred.(pcontext) &&
p k pred.(preturn).
End map_predicate_k.
Section Branch.
Context {term : Type}.
(* Parameterized by term types as they are not yet defined. *)
Record branch := mk_branch {
bcontext : list (context_decl term);
(* Context of binders of the branch, including lets.
This context is open w.r.t. to an instance of the parameters of the inductive type only,
it is NOT subject to substitution/lifting
*)
bbody : term; (* The branch body *) }.
Derive NoConfusion for branch.
Definition string_of_branch (f : term -> string) (b : branch) :=
"([" ^ String.concat "," (map (string_of_name ∘ binder_name ∘ decl_name) (bcontext b)) ^ "], "
^ f (bbody b) ^ ")".
Definition pretty_string_of_branch (f : term -> string) (b : branch) :=
String.concat " " (map (string_of_name ∘ binder_name ∘ decl_name) (bcontext b)) ^ " => " ^ f (bbody b).
Definition test_branch (pctx : term -> bool) (p : term -> bool) (b : branch) :=
test_context pctx b.(bcontext) && p b.(bbody).
Definition test_branch_k (pred : predicate term) (p : nat -> term -> bool) k (b : branch) :=
test_context_k p #|pred.(pparams)| b.(bcontext) && p (#|b.(bcontext)| + k) b.(bbody).
End Branch.
Arguments branch : clear implicits.
Section map_branch.
Context {term term' : Type}.
Context (f : term -> term').
Context (g : list (BasicAst.context_decl term) -> list (BasicAst.context_decl term')).
Definition map_branch (b : branch term) :=
{| bcontext := g b.(bcontext);
bbody := f b.(bbody) |}.
Lemma map_bbody (b : branch term) :
f (bbody b) = bbody (map_branch b).
Proof using Type. reflexivity. Qed.
Lemma map_bcontext (b : branch term) :
g (bcontext b) = bcontext (map_branch b).
Proof using Type. reflexivity. Qed.
End map_branch.
Definition map_branches {term B} (f : term -> B) h l := List.map (map_branch f h) l.
Section map_branch_k.
Context {term term' : Type}.
Context (f : nat -> term -> term').
Context (g : list (BasicAst.context_decl term) -> list (BasicAst.context_decl term')).
Definition map_branch_k k (b : branch term) :=
{| bcontext := g b.(bcontext);
bbody := f (#|b.(bcontext)| + k) b.(bbody) |}.
Lemma map_k_bbody k (b : branch term) :
f (#|b.(bcontext)| + k) (bbody b) = bbody (map_branch_k k b).
Proof using Type. reflexivity. Qed.
Lemma map_k_bcontext k (b : branch term) :
g (bcontext b) = bcontext (map_branch_k k b).
Proof using Type. reflexivity. Qed.
End map_branch_k.
Notation map_branches_k f h k brs :=
(List.map (map_branch_k f h k) brs).
Notation test_branches_k p test k brs :=
(List.forallb (test_branch_k p test k) brs).
Inductive term :=
| tRel (n : nat)
| tVar (i : ident) (* For free variables (e.g. in a goal) *)
| tEvar (n : nat) (l : list term)
| tSort (u : Universe.t)
| tProd (na : aname) (A B : term)
| tLambda (na : aname) (A t : term)
| tLetIn (na : aname) (b B t : term) (* let na := b : B in t *)
| tApp (u v : term)
| tConst (k : kername) (ui : Instance.t)
| tInd (ind : inductive) (ui : Instance.t)
| tConstruct (ind : inductive) (n : nat) (ui : Instance.t)
| tCase (indn : case_info) (p : predicate term) (c : term) (brs : list (branch term))
| tProj (p : projection) (c : term)
| tFix (mfix : mfixpoint term) (idx : nat)
| tCoFix (mfix : mfixpoint term) (idx : nat)
| tPrim (prim : prim_val term).
Derive NoConfusion for term.
Notation prim_val := (prim_val term).
Fixpoint mkApps t us :=
match us with
| nil => t
| u :: us => mkApps (tApp t u) us
end.
Definition isApp t :=
match t with
| tApp _ _ => true
| _ => false
end.
Definition isLambda t :=
match t with
| tLambda _ _ _ => true
| _ => false
end.
Lemma isLambda_inv t : isLambda t -> exists na ty bod, t = tLambda na ty bod.
Proof. destruct t => //; eauto. Qed.
(** Basic operations on the AST: lifting, substitution and tests for variable occurrences. *)
Fixpoint lift n k t : term :=
match t with
| tRel i => tRel (if Nat.leb k i then (n + i) else i)
| tEvar ev args => tEvar ev (List.map (lift n k) args)
| tLambda na T M => tLambda na (lift n k T) (lift n (S k) M)
| tApp u v => tApp (lift n k u) (lift n k v)
| tProd na A B => tProd na (lift n k A) (lift n (S k) B)
| tLetIn na b t b' => tLetIn na (lift n k b) (lift n k t) (lift n (S k) b')
| tCase ind p c brs =>
let p' := map_predicate_k id (lift n) k p in
let brs' := map_branches_k (lift n) id k brs in
tCase ind p' (lift n k c) brs'
| tProj p c => tProj p (lift n k c)
| tFix mfix idx =>
let k' := List.length mfix + k in
let mfix' := List.map (map_def (lift n k) (lift n k')) mfix in
tFix mfix' idx
| tCoFix mfix idx =>
let k' := List.length mfix + k in
let mfix' := List.map (map_def (lift n k) (lift n k')) mfix in
tCoFix mfix' idx
| x => x
end.
Notation lift0 n := (lift n 0).
(** Parallel substitution: it assumes that all terms in the substitution live in the
same context *)
Fixpoint subst s k u :=
match u with
| tRel n =>
if Nat.leb k n then
match nth_error s (n - k) with
| Some b => lift0 k b
| None => tRel (n - List.length s)
end
else tRel n
| tEvar ev args => tEvar ev (List.map (subst s k) args)
| tLambda na T M => tLambda na (subst s k T) (subst s (S k) M)
| tApp u v => tApp (subst s k u) (subst s k v)
| tProd na A B => tProd na (subst s k A) (subst s (S k) B)
| tLetIn na b ty b' => tLetIn na (subst s k b) (subst s k ty) (subst s (S k) b')
| tCase ind p c brs =>
let p' := map_predicate_k id (subst s) k p in
let brs' := map_branches_k (subst s) id k brs in
tCase ind p' (subst s k c) brs'
| tProj p c => tProj p (subst s k c)
| tFix mfix idx =>
let k' := List.length mfix + k in
let mfix' := List.map (map_def (subst s k) (subst s k')) mfix in
tFix mfix' idx
| tCoFix mfix idx =>
let k' := List.length mfix + k in
let mfix' := List.map (map_def (subst s k) (subst s k')) mfix in
tCoFix mfix' idx
| x => x
end.
(** Substitutes [t1 ; .. ; tn] in u for [Rel 0; .. Rel (n-1)] *in parallel* *)
Notation subst0 t := (subst t 0).
Definition subst1 t k u := subst [t] k u.
Notation subst10 t := (subst1 t 0).
Notation "M { j := N }" := (subst1 N j M) (at level 10, right associativity).
Fixpoint closedn k (t : term) : bool :=
match t with
| tRel i => Nat.ltb i k
| tEvar ev args => List.forallb (closedn k) args
| tLambda _ T M | tProd _ T M => closedn k T && closedn (S k) M
| tApp u v => closedn k u && closedn k v
| tLetIn na b t b' => closedn k b && closedn k t && closedn (S k) b'
| tCase ind p c brs =>
let p' := test_predicate_k (fun _ => true) closedn k p in
let brs' := test_branches_k p closedn k brs in
p' && closedn k c && brs'
| tProj p c => closedn k c
| tFix mfix idx =>
let k' := List.length mfix + k in
List.forallb (test_def (closedn k) (closedn k')) mfix
| tCoFix mfix idx =>
let k' := List.length mfix + k in
List.forallb (test_def (closedn k) (closedn k')) mfix
| _ => true
end.
Section fix_test.
Variable test : term -> bool.
Fixpoint test_context_nlict (bcontext : list (context_decl term)) :=
match bcontext with
| nil => true
| d :: bcontext => test_context_nlict bcontext &&
test (decl_type d) && match decl_body d with Some _ => false | None => true end
end.
End fix_test.
Definition test_branch_nlict test b :=
test_context_nlict test (bcontext b) && test (bbody b).
Definition test_branches_nlict test brs :=
forallb (test_branch_nlict test) brs.
Fixpoint nlict (t : term) : bool :=
match t with
| tEvar ev args => List.forallb nlict args
| tLambda _ T M | tProd _ T M => nlict T && nlict M
| tApp u v => nlict u && nlict v
| tLetIn na b t b' => nlict b && nlict t && nlict b'
| tCase ind p c brs =>
let p' := test_predicate_k (fun _ => true) (fun _ => nlict) 0 p in
let brs' := test_branches_nlict nlict brs in
p' && nlict c && brs'
| tProj p c => nlict c
| tFix mfix idx =>
List.forallb (test_def nlict nlict) mfix
| tCoFix mfix idx =>
List.forallb (test_def nlict nlict) mfix
| _ => true
end.
Notation closed t := (closedn 0 t).
Notation closed_decl n := (test_decl (closedn n)).
Notation closedn_ctx := (test_context_k closedn).
Notation closed_ctx := (closedn_ctx 0).
Fixpoint noccur_between k n (t : term) : bool :=
match t with
| tRel i => Nat.ltb i k || Nat.leb (k + n) i
| tEvar ev args => List.forallb (noccur_between k n) args
| tLambda _ T M | tProd _ T M => noccur_between k n T && noccur_between (S k) n M
| tApp u v => noccur_between k n u && noccur_between k n v
| tLetIn na b t b' => noccur_between k n b && noccur_between k n t && noccur_between (S k) n b'
| tCase ind p c brs =>
let p' := test_predicate_k (fun _ => true) (fun k' => noccur_between k' n) k p in
let brs' := test_branches_k p (fun k => noccur_between k n) k brs in
p' && noccur_between k n c && brs'
| tProj p c => noccur_between k n c
| tFix mfix idx =>
let k' := List.length mfix + k in
List.forallb (test_def (noccur_between k n) (noccur_between k' n)) mfix
| tCoFix mfix idx =>
let k' := List.length mfix + k in
List.forallb (test_def (noccur_between k n) (noccur_between k' n)) mfix
| _ => true
end.
(** * Universe substitution
Substitution of universe levels for universe level variables, used to
implement universe polymorphism. *)
#[global]
Instance subst_instance_constr : UnivSubst term :=
fix subst_instance_constr u c {struct c} : term :=
match c with
| tRel _ | tVar _ => c
| tEvar ev args => tEvar ev (List.map (subst_instance_constr u) args)
| tSort s => tSort (subst_instance_univ u s)
| tConst c u' => tConst c (subst_instance_instance u u')
| tInd i u' => tInd i (subst_instance_instance u u')
| tConstruct ind k u' => tConstruct ind k (subst_instance_instance u u')
| tLambda na T M => tLambda na (subst_instance_constr u T) (subst_instance_constr u M)
| tApp f v => tApp (subst_instance_constr u f) (subst_instance_constr u v)
| tProd na A B => tProd na (subst_instance_constr u A) (subst_instance_constr u B)
| tLetIn na b ty b' => tLetIn na (subst_instance_constr u b) (subst_instance_constr u ty)
(subst_instance_constr u b')
| tCase ind p c brs =>
let p' := map_predicate (subst_instance_instance u) (subst_instance_constr u) (subst_instance_constr u) id p in
let brs' := List.map (map_branch (subst_instance_constr u) id) brs in
tCase ind p' (subst_instance_constr u c) brs'
| tProj p c => tProj p (subst_instance_constr u c)
| tFix mfix idx =>
let mfix' := List.map (map_def (subst_instance_constr u) (subst_instance_constr u)) mfix in
tFix mfix' idx
| tCoFix mfix idx =>
let mfix' := List.map (map_def (subst_instance_constr u) (subst_instance_constr u)) mfix in
tCoFix mfix' idx
| tPrim _ => c
end.
(** Tests that the term is closed over [k] universe variables *)
Fixpoint closedu (k : nat) (t : term) : bool :=
match t with
| tSort univ => closedu_universe k univ
| tInd _ u => closedu_instance k u
| tConstruct _ _ u => closedu_instance k u
| tConst _ u => closedu_instance k u
| tRel i => true
| tEvar ev args => forallb (closedu k) args
| tLambda _ T M | tProd _ T M => closedu k T && closedu k M
| tApp u v => closedu k u && closedu k v
| tLetIn na b t b' => closedu k b && closedu k t && closedu k b'
| tCase ind p c brs =>
let p' := test_predicate_ku closedu_instance closedu k p in
let brs' := forallb (test_branch (closedu #|p.(puinst)|) (closedu k)) brs in
p' && closedu k c && brs'
| tProj p c => closedu k c
| tFix mfix idx =>
forallb (test_def (closedu k) (closedu k)) mfix
| tCoFix mfix idx =>
forallb (test_def (closedu k) (closedu k)) mfix
| _ => true
end.
Module PCUICTerm <: Term.
Definition term := term.
Definition tRel := tRel.
Definition tSort := tSort.
Definition tProd := tProd.
Definition tLambda := tLambda.
Definition tLetIn := tLetIn.
Definition tInd := tInd.
Definition tProj := tProj.
Definition mkApps := mkApps.
Definition lift := lift.
Definition subst := subst.
Definition closedn := closedn.
Definition noccur_between := noccur_between.
Definition subst_instance_constr := subst_instance.
End PCUICTerm.
(* These functors derive the notion of local context and lift substitution, term lifting,
the closed predicate to them. *)
Module PCUICEnvironment := Environment PCUICTerm.
Export PCUICEnvironment.
(* Do NOT `Include` this module, as this would sadly duplicate the rewrite database... *)
(** Decompose an arity into a context and a sort *)
Fixpoint destArity Γ (t : term) :=
match t with
| tProd na t b => destArity (Γ ,, vass na t) b
| tLetIn na b b_ty b' => destArity (Γ ,, vdef na b b_ty) b'
| tSort s => Some (Γ, s)
| _ => None
end.
(** Inductive substitution, to produce a constructors' type *)
Definition inds ind u (l : list one_inductive_body) :=
let fix aux n :=
match n with
| 0 => []
| S n => tInd (mkInd ind n) u :: aux n
end
in aux (List.length l).
Module PCUICTermUtils <: TermUtils PCUICTerm PCUICEnvironment.
Definition destArity := destArity.
Definition inds := inds.
End PCUICTermUtils.
Ltac unf_term := unfold PCUICTerm.term in *; unfold PCUICTerm.tRel in *;
unfold PCUICTerm.tSort in *; unfold PCUICTerm.tProd in *;
unfold PCUICTerm.tLambda in *; unfold PCUICTerm.tLetIn in *;
unfold PCUICTerm.tInd in *; unfold PCUICTerm.tProj in *;
unfold PCUICTerm.lift in *; unfold PCUICTerm.subst in *;
unfold PCUICTerm.closedn in *; unfold PCUICTerm.noccur_between in *;
unfold PCUICTerm.subst_instance_constr in *;
unfold PCUICTermUtils.destArity in *; unfold PCUICTermUtils.inds in *.
Lemma context_assumptions_mapi_context f (ctx : context) :
context_assumptions (mapi_context f ctx) = context_assumptions ctx.
Proof.
now rewrite mapi_context_fold; len.
Qed.
#[global]
Hint Rewrite context_assumptions_mapi_context : len.
Module PCUICEnvTyping := EnvironmentTyping.EnvTyping PCUICTerm PCUICEnvironment PCUICTermUtils.
(** Included in PCUICTyping only *)
Module PCUICConversion := EnvironmentTyping.Conversion PCUICTerm PCUICEnvironment PCUICTermUtils PCUICEnvTyping.
Global Instance context_reflect`(ReflectEq term) :
ReflectEq (list (BasicAst.context_decl term)) := _.
Local Ltac finish :=
let h := fresh "h" in
right ;
match goal with
| e : ?t <> ?u |- _ =>
intro h ; apply e ; now inversion h
end.
Local Ltac fcase c :=
let e := fresh "e" in
case c ; intro e ; [ subst ; try (left ; reflexivity) | finish ].
Definition string_of_predicate {term} (f : term -> string) (p : predicate term) :=
"(" ^ "(" ^ String.concat "," (map f (pparams p)) ^ ")"
^ "," ^ string_of_universe_instance (puinst p)
^ ",(" ^ String.concat "," (map (string_of_name ∘ binder_name ∘ decl_name) (pcontext p)) ^ ")"
^ "," ^ f (preturn p) ^ ")".
Definition eqb_predicate_gen (eqb_univ_instance : Instance.t -> Instance.t -> bool)
(eqdecl : context_decl -> context_decl -> bool)
(eqterm : term -> term -> bool) (p p' : predicate term) :=
forallb2 eqterm p.(pparams) p'.(pparams) &&
eqb_univ_instance p.(puinst) p'.(puinst) &&
forallb2 eqdecl p.(pcontext) p'.(pcontext) &&
eqterm p.(preturn) p'.(preturn).
(** Syntactic ws_cumul_pb *)
Definition eqb_predicate (eqterm : term -> term -> bool) (p p' : predicate term) :=
eqb_predicate_gen eqb (eqb_context_decl eqterm) eqterm p p'.
(** Theory of [map] variants on branches and predicates. *)
(* The [map] rewrite database gathers all the map composition rewrite lemmas
on these types. *)
#[global]
Hint Rewrite map_map_compose @compose_map_def map_length : map.
#[global]
Hint Rewrite @forallb_map : map.
Lemma map_predicate_map_predicate
{term term' term''}
(finst finst' : Instance.t -> Instance.t)
(f g : term' -> term'')
(f' g' : term -> term')
(h : list (BasicAst.context_decl term') -> list (BasicAst.context_decl term''))
(h' : list (BasicAst.context_decl term) -> list (BasicAst.context_decl term'))
(p : predicate term) :
map_predicate finst f g h (map_predicate finst' f' g' h' p) =
map_predicate (finst ∘ finst') (f ∘ f') (g ∘ g') (h ∘ h') p.
Proof.
unfold map_predicate. destruct p; cbn.
f_equal.
apply map_map.
Qed.
Lemma map_predicate_id x : map_predicate (@id _) (@id term) (@id term) (@id _) x = id x.
Proof.
unfold map_predicate; destruct x; cbn; unfold id.
f_equal. apply map_id.
Qed.
#[global]
Hint Rewrite @map_predicate_id : map.
Definition tCasePredProp_k
(P : nat -> term -> Type)
k (p : predicate term) :=
All (P k) p.(pparams) × onctx_k P #|p.(pparams)| p.(pcontext) ×
P (#|p.(pcontext)| + k) p.(preturn).
Definition tCasePredProp {term}
(Pparams Preturn : term -> Type)
(p : predicate term) :=
All Pparams p.(pparams) ×
onctx Pparams p.(pcontext) ×
Preturn p.(preturn).
Lemma map_predicate_eq_spec {A B} (finst finst' : Instance.t -> Instance.t)
(f f' g g' : A -> B) h h' (p : predicate A) :
finst (puinst p) = finst' (puinst p) ->
map f (pparams p) = map g (pparams p) ->
h =1 h' ->
f' (preturn p) = g' (preturn p) ->
map_predicate finst f f' h p = map_predicate finst' g g' h' p.
Proof.
intros. unfold map_predicate; f_equal; auto.
Qed.
#[global] Hint Resolve map_predicate_eq_spec : all.
Lemma map_predicate_k_eq_spec {A} (finst finst' : Instance.t -> Instance.t)
(f g : nat -> A -> A) k k' (p : predicate A) :
finst (puinst p) = finst' (puinst p) ->
map (f k) (pparams p) = map (g k') (pparams p) ->
shiftf f k #|pcontext p| (preturn p) = shiftf g k' #|pcontext p| (preturn p) ->
map_predicate_k finst f k p = map_predicate_k finst' g k' p.
Proof.
intros. unfold map_predicate_k; f_equal; auto.
Qed.
#[global] Hint Resolve map_predicate_k_eq_spec : all.
Lemma map_decl_id_spec P f d :
ondecl P d ->
(forall x : term, P x -> f x = x) ->
map_decl f d = d.
Proof.
intros Hc Hf.
destruct Hc.
unfold map_decl; destruct d; cbn in *. f_equal; eauto.
destruct decl_body; simpl; eauto. f_equal.
eauto.
Qed.
Lemma map_decl_id_spec_cond P p f d :
ondecl P d ->
test_decl p d ->
(forall x : term, P x -> p x -> f x = x) ->
map_decl f d = d.
Proof.
intros [].
unfold map_decl; destruct d; cbn in *.
unfold test_decl; simpl.
intros [pty pbody]%andb_and. intros Hx.
f_equal; eauto.
destruct decl_body; simpl; eauto. f_equal.
eauto.
Qed.
Lemma map_context_id_spec P f ctx :
onctx P ctx ->
(forall x : term, P x -> f x = x) ->
map_context f ctx = ctx.
Proof.
intros Hc Hf. induction Hc; simpl; auto.
rewrite IHHc. f_equal; eapply map_decl_id_spec; eauto.
Qed.
#[global] Hint Resolve map_context_id_spec : all.
Lemma map_context_id_spec_cond P p f ctx :
onctx P ctx ->
test_context p ctx ->
(forall x : term, P x -> p x -> f x = x) ->
map_context f ctx = ctx.
Proof.
intros Hc Hc' Hf. induction Hc in Hc' |- *; simpl; auto.
revert Hc'; simpl; intros [hx hl]%andb_and.
rewrite IHHc; auto. f_equal. eapply map_decl_id_spec_cond; eauto.
Qed.
#[global] Hint Resolve map_context_id_spec_cond : all.
Lemma map_predicate_id_spec {A} finst (f f' : A -> A) h (p : predicate A) :
finst (puinst p) = puinst p ->
map f (pparams p) = pparams p ->
h (pcontext p) = pcontext p ->
f' (preturn p) = preturn p ->
map_predicate finst f f' h p = p.
Proof.
unfold map_predicate.
intros -> -> -> ->; destruct p; auto.
Qed.
#[global] Hint Resolve map_predicate_id_spec : all.
Lemma map_predicate_k_id_spec {A} finst (f : nat -> A -> A) k (p : predicate A) :
finst (puinst p) = puinst p ->
map (f k) (pparams p) = pparams p ->
shiftf f k #|p.(pcontext)| (preturn p) = preturn p ->
map_predicate_k finst f k p = p.
Proof.
unfold map_predicate_k, shiftf.
intros -> -> ->; destruct p; auto.
Qed.
#[global] Hint Resolve map_predicate_k_id_spec : all.
#[global]
Instance map_predicate_proper {term} :
Proper (`=1` ==> `=1` ==> `=1` ==> Logic.eq ==> Logic.eq)%signature (@map_predicate term term id).
Proof.
intros eqf0 eqf1 eqf.
intros eqf'0 eqf'1 eqf' h h' eqh'.
intros x y ->.
apply map_predicate_eq_spec; auto.
now apply map_ext => x.
Qed.
#[global]
Instance map_predicate_proper' {term} f : Proper (`=1` ==> `=1` ==> Logic.eq ==> Logic.eq)
(@map_predicate term term id f).
Proof.
intros eqf0 eqf1 eqf h h' eqh'.
intros x y ->.
apply map_predicate_eq_spec; auto.
Qed.
Lemma shiftf0 {A B} (f : nat -> A -> B) : shiftf f 0 =2 f.
Proof. intros x. unfold shiftf. now rewrite Nat.add_0_r. Qed.
#[global]
Hint Rewrite @shiftf0 : map.
Lemma map_predicate_k_map_predicate_k
(finst finst' : Instance.t -> Instance.t)
(f f' : nat -> term -> term)
k k' (p : predicate term) :
map_predicate_k finst f k (map_predicate_k finst' f' k' p) =
map_predicate_k (finst ∘ finst') (fun i => f (i + k) ∘ f' (i + k')) 0 p.
Proof.
unfold map_predicate, map_predicate_k. destruct p; cbn.
f_equal.
now rewrite map_map.
now len.
Qed.
#[global]
Hint Rewrite map_predicate_k_map_predicate_k : map.
Lemma map_predicate_map_predicate_k
(finst finst' : Instance.t -> Instance.t)
(f : term -> term) (f' : nat -> term -> term)
k (p : predicate term) :
map_predicate finst f f id (map_predicate_k finst' f' k p) =
map_predicate_k (finst ∘ finst') (fun k => f ∘ f' k) k p.
Proof.
unfold map_predicate, map_predicate_k. destruct p; cbn.
f_equal.
apply map_map.
Qed.
#[global]
Hint Rewrite map_predicate_map_predicate_k : map.
Lemma map_predicate_k_map_predicate
(finst finst' : Instance.t -> Instance.t)
(f' : term -> term) (f : nat -> term -> term)
k (p : predicate term) :
map_predicate_k finst f k (map_predicate finst' f' f' id p) =
map_predicate_k (finst ∘ finst') (fun k => (f k) ∘ f') k p.
Proof.
unfold map_predicate, map_predicate_k. destruct p; cbn.
f_equal; len; auto.
* apply map_map.
Qed.
#[global]
Hint Rewrite map_predicate_k_map_predicate : map.
Lemma map_branch_map_branch
{term term' term''}
(f : term' -> term'')
(f' : term -> term')
h h'
(b : branch term) :
map_branch f h (map_branch f' h' b) =
map_branch (f ∘ f') (h ∘ h') b.
Proof.
unfold map_branch; destruct b; cbn.
f_equal.
Qed.
#[global]
Hint Rewrite @map_branch_map_branch : map.
Lemma map_branch_k_map_branch_k (f f' : nat -> term -> term) h h' k k' (b : branch term) :
#|h' b.(bcontext)| = #|b.(bcontext)| ->
map_branch_k f h k (map_branch_k f' h' k' b) =
map_branch_k (fun i => f (i + k) ∘ f' (i + k')) (h ∘ h') 0 b.
Proof.
unfold map_branch, map_branch_k; destruct b; cbn. len.
intros ->.
f_equal.
Qed.
Lemma map_branch_k_map_branch_k_id (f f' : nat -> term -> term) k k' (b : branch term) :
map_branch_k f id k (map_branch_k f' id k' b) =
map_branch_k (fun i => f (i + k) ∘ f' (i + k')) id 0 b.
Proof.
unfold map_branch, map_branch_k; destruct b; cbn. len.
f_equal.
Qed.
#[global]
Hint Rewrite map_branch_k_map_branch_k_id : map.
Lemma map_branch_map_branch_k
(f : term -> term)
(f' : nat -> term -> term) k
(b : branch term) :
map_branch f id (map_branch_k f' id k b) =
map_branch_k (fun k => f ∘ (f' k)) id k b.
Proof.
unfold map_branch, map_branch_k; destruct b; cbn.
f_equal.
Qed.
#[global]
Hint Rewrite map_branch_map_branch_k : map.
Lemma map_branch_k_map_branch
(f' : term -> term)
(f : nat -> term -> term) k
(b : branch term) :
map_branch_k f id k (map_branch f' id b) =
map_branch_k (fun k => f k ∘ f') id k b.
Proof.
unfold map_branch, map_branch_k; destruct b; cbn. len.
f_equal.
Qed.
#[global]
Hint Rewrite map_branch_k_map_branch : map.
Lemma map_branch_id x : map_branch (@id term) id x = id x.
Proof.
unfold map_branch, id; destruct x; cbn.
f_equal.
Qed.
#[global]
Hint Rewrite @map_branch_id : map.
Lemma map_decl_eq_spec {A B} {P : A -> Type} {d} {f g : A -> B} :
ondecl P d ->
(forall x, P x -> f x = g x) ->
map_decl f d = map_decl g d.
Proof.
destruct d; cbn; intros [Pty Pbod] Hfg.
unfold map_decl; cbn in *; f_equal.
* destruct decl_body; cbn in *; eauto. f_equal.
eauto.
* eauto.
Qed.
Lemma map_context_eq_spec {A B} P (f g : A -> B) ctx :
onctx P ctx ->
(forall x, P x -> f x = g x) ->
map_context f ctx = map_context g ctx.
Proof.
intros onc Hfg.
induction onc; simpl; auto.
rewrite IHonc. f_equal.
eapply map_decl_eq_spec; eauto.
Qed.
Lemma map_branch_eq_spec {A B} (f g : A -> B) h h' (x : branch A) :
f (bbody x) = g (bbody x) ->
h =1 h' ->
map_branch f h x = map_branch g h' x.
Proof.
intros. unfold map_branch; f_equal; auto.
Qed.
#[global] Hint Resolve map_branch_eq_spec : all.
Lemma map_branch_k_eq_spec {A B} (f g : nat -> A -> B) h h' k k' (x : branch A) :
shiftf f k #|x.(bcontext)| (bbody x) = shiftf g k' #|x.(bcontext)| (bbody x) ->
h =1 h' ->
map_branch_k f h k x = map_branch_k g h' k' x.
Proof.
intros. unfold map_branch_k; f_equal; auto.
Qed.
#[global] Hint Resolve map_branch_eq_spec : all.
#[global]
Instance map_branch_proper {term} : Proper (`=1` ==> `=1` ==> Logic.eq ==> Logic.eq)
(@map_branch term term).
Proof.
intros eqf0 eqf1 eqf h h' eqh'.
intros x y ->.
apply map_branch_eq_spec; auto.
Qed.
Lemma id_id {A} : @id A =1 id.
Proof. now intros x. Qed.
#[global] Hint Resolve id_id : core.
Lemma map_branch_id_spec (f : term -> term) (x : branch term) :
f (bbody x) = (bbody x) ->
map_branch f id x = x.
Proof.
intros. rewrite (map_branch_eq_spec _ id id id); auto.
now rewrite map_branch_id.
Qed.
#[global] Hint Resolve map_branch_id_spec : all.
Lemma map_branch_k_id_spec (f : nat -> term -> term) h k (x : branch term) :
h (bcontext x) = bcontext x ->
shiftf f k #|x.(bcontext)| (bbody x) = (bbody x) ->
map_branch_k f h k x = x.
Proof.
intros. unfold map_branch_k.
destruct x; simpl in *; f_equal; eauto.
Qed.
#[global] Hint Resolve map_branch_k_id_spec : all.
Lemma map_branches_map_branches
{term term' term''}
(f : term' -> term'')
(f' : term -> term')
h h'
(l : list (branch term)) :
map (fun b => map_branch f h (map_branch f' h' b)) l =
map (map_branch (f ∘ f') (h ∘ h')) l.
Proof.
eapply map_ext => b. apply map_branch_map_branch.
Qed.
Definition tCaseBrsProp {A} (P : A -> Type) (l : list (branch A)) :=
All (fun x => onctx P (bcontext x) × P (bbody x)) l.
Definition tCaseBrsProp_k (P : nat -> term -> Type) (p : predicate term) k (l : list (branch term)) :=
All (fun x => onctx_k P (#|p.(pparams)|) (bcontext x) × P (#|x.(bcontext)| + k) (bbody x)) l.
Lemma map_branches_k_map_branches_k
{term term' term''}
(f : nat -> term' -> term'')
(g : term -> term')
(f' : nat -> term -> term')
h h' k
(l : list (branch term)) :
(forall ctx, #|h' ctx| = #|ctx|) ->
map (fun b => map_branch (f #|bcontext (map_branch g h' b)|) h (map_branch (f' k) h' b)) l =
map (fun b => map_branch (f #|bcontext b|) h (map_branch (f' k) h' b)) l.
Proof.
intros Hh.
eapply map_ext => b. rewrite map_branch_map_branch.
rewrite map_branch_map_branch.
simpl; autorewrite with len. now rewrite Hh.
Qed.
Lemma case_brs_map_spec {A B} {P : A -> Type} {l} {f g : A -> B}
{h h' : list (BasicAst.context_decl A) -> list (BasicAst.context_decl B)} :
tCaseBrsProp P l -> (forall x, P x -> f x = g x) -> h =1 h' ->
map_branches f h l = map_branches g h' l.
Proof.
intros. red in X.
eapply All_map_eq. eapply All_impl; eauto. simpl; intros.
destruct X0.
apply map_branch_eq_spec; eauto.
Qed.
Lemma map_decl_eqP_spec {A B} {P : A -> Type} {p : A -> bool}
{d} {f g : A -> B} :
ondecl P d ->
test_decl p d ->
(forall x, P x -> p x -> f x = g x) ->
map_decl f d = map_decl g d.
Proof.
destruct d; cbn; intros [Pty Pbod] [pty pbody]%andb_and Hfg.
unfold map_decl; cbn in *; f_equal.
* destruct decl_body; cbn in *; eauto. f_equal.
eauto.
* eauto.
Qed.
Lemma map_context_eqP_spec {A B} {P : A -> Type} {p : A -> bool}
{ctx} {f g : A -> B} :
All (ondecl P) ctx ->
test_context p ctx ->
(forall x, P x -> p x -> f x = g x) ->
map_context f ctx = map_context g ctx.
Proof.
intros Ha Hctx Hfg. induction Ha; simpl; auto.
revert Hctx; simpl; intros [Hx Hl]%andb_and.
rewrite IHHa; f_equal; auto.
eapply map_decl_eqP_spec; eauto.
Qed.
Lemma mapi_context_eqP_spec {A B} {P : A -> Type} {ctx} {f g : nat -> A -> B} :
All (ondecl P) ctx ->
(forall k x, P x -> f k x = g k x) ->
mapi_context f ctx = mapi_context g ctx.
Proof.
intros Ha Hfg. induction Ha; simpl; auto.
rewrite IHHa; f_equal.
destruct p as [Hty Hbody].
unfold map_decl; destruct x ; cbn in *; f_equal.
* destruct decl_body; cbn in *; auto.
f_equal. eauto.
* eauto.
Qed.
Lemma mapi_context_eqP_id_spec {A} {P : A -> Type} {ctx} {f : nat -> A -> A} :
All (ondecl P) ctx ->
(forall k x, P x -> f k x = x) ->
mapi_context f ctx = ctx.
Proof.
intros Ha Hfg. induction Ha; simpl; auto.
rewrite IHHa; f_equal.
destruct p as [Hty Hbody].
unfold map_decl; destruct x ; cbn in *; f_equal.
* destruct decl_body; cbn in *; auto.
f_equal. eauto.
* eauto.
Qed.
Lemma mapi_context_eqP_test_id_spec {A} {P : A -> Type} (p : nat -> A -> bool)
k {ctx} {f : nat -> A -> A} :
All (ondecl P) ctx ->
test_context_k p k ctx ->
(forall k (x : A), P x -> p k x -> f k x = x) ->
mapi_context (shiftf f k) ctx = ctx.
Proof.
intros Ha ht Hfg. revert ht.
induction Ha; simpl; auto.
intros [hl [hty hbod]%andb_and]%andb_and.
rewrite IHHa; auto; f_equal.
destruct p0 as [Hty Hbody].
unfold map_decl; destruct x ; cbn in *; f_equal; eauto.
destruct decl_body; cbn in *; auto.
f_equal. unfold shiftf. eapply Hfg; auto.
Qed.
Lemma test_context_k_eqP_id_spec {A} {P : A -> Type} (p q : nat -> A -> bool) k k' {ctx} :
All (ondecl P) ctx ->
test_context_k p k ctx ->
(forall i (x : A), P x -> p (i + k) x -> q (i + k') x) ->
test_context_k q k' ctx.
Proof.
intros Ha ht Hfg. revert ht.
induction Ha; simpl; auto.
intros [hl [hty hbod]%andb_and]%andb_and.
rewrite IHHa; simpl; auto.
destruct p0 as [Hty Hbody].
unfold test_decl; destruct x ; cbn in *; eauto.
destruct decl_body; cbn in *; auto.
rewrite !Hfg; auto.
Qed.
Lemma test_context_k_eqP_eq_spec {A} {P : A -> Type} (p q : nat -> A -> bool) k k' {ctx} :
All (ondecl P) ctx ->
(forall i (x : A), P x -> p (i + k) x = q (i + k') x) ->
test_context_k p k ctx = test_context_k q k' ctx.
Proof.
intros Ha Hfg.
induction Ha; simpl; auto.
rewrite IHHa; auto; f_equal.
destruct p0 as [Hty Hbody].
unfold test_decl; destruct x ; cbn in *; f_equal; eauto.
destruct decl_body; cbn in *; auto;
rewrite !Hfg; auto.
Qed.
Lemma test_context_k_eq_spec (p q : nat -> term -> bool) k k' {ctx} :
(p =2 q) ->
k = k' ->
test_context_k p k ctx = test_context_k q k' ctx.
Proof.
intros Hfg <-.
induction ctx as [|[na [b|] ty] ctx]; simpl; auto; now rewrite IHctx Hfg.
Qed.
Lemma test_context_k_eq (p : nat -> term -> bool) n ctx :
test_context_k p n ctx = alli (fun k d => test_decl (p (n + k)) d) 0 (List.rev ctx).
Proof.
induction ctx; simpl; auto.
rewrite IHctx alli_app /= andb_comm andb_true_r andb_comm. f_equal.
len. now rewrite Nat.add_comm.
Qed.
#[global]
Instance test_context_k_Proper : Proper (`=2` ==> Logic.eq ==> `=1`) (@test_context_k term).
Proof.
intros f g Hfg k k' <- ctx.
now apply test_context_k_eq_spec.
Qed.
#[global]
Instance test_predicate_k_Proper : Proper (`=1` ==> `=2` ==> Logic.eq ==> `=1`) (@test_predicate_k term).
Proof.
intros hi hi' eqhi f g Hfg k k' <- ctx.
unfold test_predicate_k. rewrite eqhi.
now setoid_rewrite Hfg.
Qed.
#[global]
Instance test_predicate_ku_Proper : Proper (`=2` ==> `=2` ==> Logic.eq ==> `=1`) (@test_predicate_ku term).
Proof.
intros hi hi' eqhi f g Hfg k k' <- ctx.
unfold test_predicate_ku. rewrite eqhi.
now setoid_rewrite Hfg.
Qed.
#[global]
Instance test_branch_k_Proper p : Proper (`=2` ==> Logic.eq ==> `=1`) (@test_branch_k term p).
Proof.
intros f g Hfg k k' <- ctx.
unfold test_branch_k.
now setoid_rewrite Hfg.
Qed.
Lemma case_brs_map_spec_cond {A B} {P : A -> Type} pctx p {l} {f g : A -> B} {h h'}:
tCaseBrsProp P l ->
forallb (test_branch pctx p) l ->
(forall x, P x -> p x -> f x = g x) ->
(* (forall ctx, onctx P ctx -> test_context pctx ctx -> h ctx = h' ctx) -> *)
h =1 h' ->
map_branches f h l = map_branches g h' l.
Proof.
intros. red in X.
eapply forallb_All in H.
eapply All_map_eq.
eapply All_prod in X; tea. clear H.
eapply All_impl; eauto. simpl; intros br [[]%andb_and []].
apply map_branch_eq_spec; eauto.
(*eapply map_context_eqP_spec; eauto.*)
Qed.
Lemma case_brs_map_k_spec {A B} {P : A -> Type} {k l} {f g : nat -> A -> B} {h h'} :
tCaseBrsProp P l ->
(forall k x, P x -> f k x = g k x) ->
h =1 h' ->
map_branches_k f h k l = map_branches_k g h' k l.
Proof.
intros. red in X.
eapply All_map_eq. eapply All_impl; eauto. simpl; intros.
apply map_branch_k_eq_spec; eauto.
unfold shiftf. now apply H.
Qed.
Lemma case_brs_forallb_map_spec {A B} {P : A -> Type} {pctx p : A -> bool}
{l} {f g : A -> B} {h h'} :
tCaseBrsProp P l ->
forallb (test_branch pctx p) l ->
(forall x, P x -> p x -> f x = g x) ->
h =1 h' ->
map (map_branch f h) l = map (map_branch g h') l.
Proof.
intros.
eapply All_map_eq. red in X. apply forallb_All in H.
eapply All_impl. eapply All_prod. exact X. exact H. simpl.
intros [bctx bbod] [Hbr hb]. cbn in *.
unfold map_branch; cbn. f_equal.
- apply H1.
- eapply H0; eauto. apply Hbr.
now move/andb_and: hb => [].
Qed.
Lemma test_context_map (p : term -> bool) f (ctx : context) :
test_context p (map_context f ctx) = test_context (p ∘ f) ctx.
Proof.
induction ctx; simpl; auto.
rewrite IHctx. f_equal.
now rewrite test_decl_map_decl.
Qed.
#[global]
Hint Rewrite test_context_map : map.
Lemma onctx_test P (p q : term -> bool) ctx :
onctx P ctx ->
test_context p ctx ->
(forall t, P t -> p t -> q t) ->
test_context q ctx.
Proof.
intros Hc tc HP. revert tc.
induction Hc; simpl; auto.
destruct p0.
intros [pl [pbod pty]%andb_and]%andb_and.
rewrite (IHHc pl); simpl.
unfold test_decl.
rewrite (HP _ p0 pty) andb_true_r; simpl.
destruct (decl_body x); simpl in *; eauto.
Qed.
(** Useful for inductions *)
Lemma onctx_k_rev {P : nat -> term -> Type} {k} {ctx} :
onctx_k P k ctx <~>
Alli (fun i => ondecl (P (i + k))) 0 (List.rev ctx).
Proof.
split.
- unfold onctx_k.
intros Hi.
eapply forall_nth_error_Alli => i x hx.
pose proof (nth_error_Some_length hx).
rewrite nth_error_rev // in hx.
rewrite List.rev_involutive in hx.
len in hx.
eapply Alli_nth_error in Hi; tea.
simpl in Hi. simpl.
replace (Nat.pred #|ctx| - (#|ctx| - S i) + k) with (i + k) in Hi => //.
len in H; by lia.
- intros Hi.
eapply forall_nth_error_Alli => i x hx.
eapply Alli_rev_nth_error in Hi; tea.
simpl.
replace (#|ctx| - S i + k) with (Nat.pred #|ctx| - i + k) in Hi => //.
lia.
Qed.
Lemma onctx_k_shift {P : nat -> term -> Type} {k} {ctx} :
onctx_k P k ctx ->
onctx_k (fun k' => P (k' + k)) 0 ctx.
Proof.
intros Hi%onctx_k_rev.
eapply onctx_k_rev.
eapply Alli_impl; tea => /= n x.
now rewrite Nat.add_0_r.
Qed.
Lemma onctx_k_P {P : nat -> term -> Type} {p : nat -> term -> bool} {k} {ctx : context} :
(forall x y, reflectT (P x y) (p x y)) ->
reflectT (onctx_k P k ctx) (test_context_k p k ctx).
Proof.
intros HP.
eapply equiv_reflectT.
- intros Hi%onctx_k_rev.
rewrite test_context_k_eq.
induction Hi; simpl; auto.
rewrite Nat.add_comm.
rewrite IHHi /= //.
now move/(ondeclP (HP _)): p0 => ->.
- intros Hi. eapply onctx_k_rev.
move: ctx Hi. induction ctx.
* constructor.
* move => /= /andb_and [Hctx Hd].
eapply Alli_app_inv; eauto. constructor.
+ move/(ondeclP (HP _)): Hd. now len.
+ constructor.
Qed.
Module PCUICLookup := EnvironmentTyping.Lookup PCUICTerm PCUICEnvironment.
Include PCUICLookup.
Derive NoConfusion for global_decl.
Module PCUICGlobalMaps := EnvironmentTyping.GlobalMaps
PCUICTerm
PCUICEnvironment
PCUICTermUtils
PCUICEnvTyping
PCUICConversion
PCUICLookup
.
Include PCUICGlobalMaps.
(** ** Entries
The kernel accepts these inputs and typechecks them to produce
declarations. Reflects [kernel/entries.mli].
*)
(** *** Constant and axiom entries *)
Record parameter_entry := {
parameter_entry_type : term;
parameter_entry_universes : universes_decl }.
Record definition_entry := {
definition_entry_type : term;
definition_entry_body : term;
definition_entry_universes : universes_decl;
definition_entry_opaque : bool }.
Inductive constant_entry :=
| ParameterEntry (p : parameter_entry)
| DefinitionEntry (def : definition_entry).
Derive NoConfusion for parameter_entry definition_entry constant_entry.
(** *** Inductive entries *)
(** This is the representation of mutual inductives.
nearly copied from [kernel/entries.mli]
Assume the following definition in concrete syntax:
[[
Inductive I1 (x1:X1) ... (xn:Xn) : A1 := c11 : T11 | ... | c1n1 : T1n1
...
with Ip (x1:X1) ... (xn:Xn) : Ap := cp1 : Tp1 ... | cpnp : Tpnp.
]]
then, in [i]th block, [mind_entry_params] is [xn:Xn;...;x1:X1];
[mind_entry_arity] is [Ai], defined in context [x1:X1;...;xn:Xn];
[mind_entry_lc] is [Ti1;...;Tini], defined in context
[A'1;...;A'p;x1:X1;...;xn:Xn] where [A'i] is [Ai] generalized over
[x1:X1;...;xn:Xn].
*)
Inductive local_entry :=
| LocalDef : term -> local_entry (* local let binding *)
| LocalAssum : term -> local_entry.
Record one_inductive_entry := {
mind_entry_typename : ident;
mind_entry_arity : term;
mind_entry_template : bool; (* template polymorphism *)
mind_entry_consnames : list ident;
mind_entry_lc : list term (* constructor list *) }.
Record mutual_inductive_entry := {
mind_entry_record : option (option ident);
(* Is this mutual inductive defined as a record?
If so, is it primitive, using binder name [ident]
for the record in primitive projections ? *)
mind_entry_finite : recursivity_kind;
mind_entry_params : context;
mind_entry_inds : list one_inductive_entry;
mind_entry_universes : universes_decl;
mind_entry_private : option bool
(* Private flag for sealing an inductive definition in an enclosing
module. Not handled by.Common Coq yet. *) }.
Derive NoConfusion for local_entry one_inductive_entry mutual_inductive_entry.
|
[Table of Contents](http://nbviewer.ipython.org/github/rlabbe/Kalman-and-Bayesian-Filters-in-Python/blob/master/table_of_contents.ipynb)
# Kalman Filter Math
```python
#format the book
%matplotlib inline
from __future__ import division, print_function
from book_format import load_style
load_style()
```
<style>
@import url('http://fonts.googleapis.com/css?family=Source+Code+Pro');
@import url('http://fonts.googleapis.com/css?family=Vollkorn');
@import url('http://fonts.googleapis.com/css?family=Arimo');
@import url('http://fonts.googleapis.com/css?family=Fira+sans');
.CodeMirror pre {
font-family: 'Source Code Pro', Consolas, monocco, monospace;
}
div.cell{
width: 900px;
margin-left: 0% !important;
margin-right: auto;
}
div.text_cell code {
background: transparent;
color: #000000;
font-weight: 600;
font-size: 12pt;
font-style: bold;
font-family: 'Source Code Pro', Consolas, monocco, monospace;
}
h1 {
font-family: 'Open sans',verdana,arial,sans-serif;
}
div.input_area {
background: #F6F6F9;
border: 1px solid #586e75;
}
.text_cell_render h1 {
font-weight: 200;
font-size: 30pt;
line-height: 100%;
color:#c76c0c;
margin-bottom: 0.5em;
margin-top: 1em;
display: block;
white-space: wrap;
text-align: left;
}
h2 {
font-family: 'Open sans',verdana,arial,sans-serif;
text-align: left;
}
.text_cell_render h2 {
font-weight: 200;
font-size: 16pt;
font-style: italic;
line-height: 100%;
color:#c76c0c;
margin-bottom: 0.5em;
margin-top: 1.5em;
display: block;
white-space: wrap;
text-align: left;
}
h3 {
font-family: 'Open sans',verdana,arial,sans-serif;
}
.text_cell_render h3 {
font-weight: 200;
font-size: 14pt;
line-height: 100%;
color:#d77c0c;
margin-bottom: 0.5em;
margin-top: 2em;
display: block;
white-space: wrap;
text-align: left;
}
h4 {
font-family: 'Open sans',verdana,arial,sans-serif;
}
.text_cell_render h4 {
font-weight: 100;
font-size: 14pt;
color:#d77c0c;
margin-bottom: 0.5em;
margin-top: 0.5em;
display: block;
white-space: nowrap;
}
h5 {
font-family: 'Open sans',verdana,arial,sans-serif;
}
.text_cell_render h5 {
font-weight: 200;
font-style: normal;
color: #1d3b84;
font-size: 16pt;
margin-bottom: 0em;
margin-top: 0.5em;
display: block;
white-space: nowrap;
}
div.text_cell_render{
/*font-family: 'Vollkorn', verdana,arial,sans-serif;*/
line-height: 150%;
font-size: 130%;
text-align: justify;
text-justify:inter-word;
}
div.output_subarea.output_text.output_pyout {
overflow-x: auto;
overflow-y: scroll;
max-height: 50000px;
}
div.output_subarea.output_stream.output_stdout.output_text {
overflow-x: auto;
overflow-y: scroll;
max-height: 50000px;
}
div.output_wrapper{
margin-top:0.2em;
margin-bottom:0.2em;
}
code{
font-size: 6pt;
}
.rendered_html code{
background-color: transparent;
}
ul{
margin: 2em;
}
ul li{
padding-left: 0.5em;
margin-bottom: 0.5em;
margin-top: 0.5em;
}
ul li li{
padding-left: 0.2em;
margin-bottom: 0.2em;
margin-top: 0.2em;
}
ol{
margin: 2em;
}
ol li{
padding-left: 0.5em;
margin-bottom: 0.5em;
margin-top: 0.5em;
}
ul li{
padding-left: 0.5em;
margin-bottom: 0.5em;
margin-top: 0.2em;
}
a:link{
font-weight: bold;
color:#447adb;
}
a:visited{
font-weight: bold;
color: #1d3b84;
}
a:hover{
font-weight: bold;
color: #1d3b84;
}
a:focus{
font-weight: bold;
color:#447adb;
}
a:active{
font-weight: bold;
color:#447adb;
}
.rendered_html :link {
text-decoration: underline;
}
.rendered_html :hover {
text-decoration: none;
}
.rendered_html :visited {
text-decoration: none;
}
.rendered_html :focus {
text-decoration: none;
}
.rendered_html :active {
text-decoration: none;
}
.warning{
color: rgb( 240, 20, 20 )
}
hr {
color: #f3f3f3;
background-color: #f3f3f3;
height: 1px;
}
blockquote{
display:block;
background: #fcfcfc;
border-left: 5px solid #c76c0c;
font-family: 'Open sans',verdana,arial,sans-serif;
width:680px;
padding: 10px 10px 10px 10px;
text-align:justify;
text-justify:inter-word;
}
blockquote p {
margin-bottom: 0;
line-height: 125%;
font-size: 100%;
}
</style>
If you've gotten this far I hope that you are thinking that the Kalman filter's fearsome reputation is somewhat undeserved. Sure, I hand waved some equations away, but I hope implementation has been fairly straightforward for you. The underlying concept is quite straightforward - take two measurements, or a measurement and a prediction, and choose the output to be somewhere between the two. If you believe the measurement more your guess will be closer to the measurement, and if you believe the prediction is more accurate your guess will lie closer it it. That's not rocket science (little joke - it is exactly this math that got Apollo to the moon and back!).
To be honest I have been choosing my problems carefully. For an arbitrary problem designing the Kalman filter matrices can be extremely difficult. I haven't been *too tricky*, though. Equations like Newton's equations of motion can be trivially computed for Kalman filter applications, and they make up the bulk of the kind of problems that we want to solve.
I have illustrated the concepts with code and reasoning, not math. But there are topics that do require more mathematics than I have used so far. This chapter presents the math that you will need for the rest of the book.
## Modeling a Dynamic System
A *dynamic system* is a physical system whose state (position, temperature, etc) evolves over time. Calculus is the math of changing values, so we use differential equations to model dynamic systems. Some systems cannot be modeled with differential equations, but we will not encounter those in this book.
Modeling dynamic systems is properly the topic of several college courses. To an extent there is no substitute for a few semesters of ordinary and partial differential equations followed by a graduate course in control system theory. If you are a hobbyist, or trying to solve one very specific filtering problem at work you probably do not have the time and/or inclination to devote a year or more to that education.
Fortunately, I can present enough of the theory to allow us to create the system equations for many different Kalman filters. My goal is to get you to the stage where you can read a publication and understand it well enough to implement the algorithms. The background math is deep, but in practice we end up using a few simple techniques over and over again.
This is the longest section of pure math in this book. You will need to master everything in this section to understand the Extended Kalman filter (EKF), the workhorse nonlinear filter. I do cover more modern filters that do not require as much of this math. You can choose so skim now, and come back to this if you decide to learn the EKF.
We need to start by understanding the underlying equations and assumptions that the Kalman filter uses. We are trying to model real world phenomena, so what do we have to consider?
Each physical system has a process. For example, a car traveling at a certain velocity goes so far in a fixed amount of time, and its velocity varies as a function of its acceleration. We describe that behavior with the well known Newtonian equations that we learned in high school.
$$
\begin{aligned}
v&=at\\
x &= \frac{1}{2}at^2 + v_0t + x_0
\end{aligned}
$$
Once we learned calculus we saw them in this form:
$$ \mathbf v = \frac{d \mathbf x}{d t},
\quad \mathbf a = \frac{d \mathbf v}{d t} = \frac{d^2 \mathbf x}{d t^2}
$$
A typical automobile tracking problem would have you compute the distance traveled given a constant velocity or acceleration as we did in previous chapters. But, of course we know this is not all that is happening. No car travels on a perfect road. There are bumps that cause the car to slow down, there is wind drag, there are hills that raise and lower the speed. The suspension is a mechanical system with friction and imperfect springs. Gusts of wind alter the car's state.
Acurately modeling a system with linear equations is impossible except for the most trivial problems. So control theory is forced to make a simplification. At any time $t$ we say that the true state (such as the position of our car) is the predicted value from the imperfect model plus some unknown *process noise*:
$$
x(t) = x_{pred}(t) + noise(t)
$$
This is not meant to imply that $noise(t)$ is a function that we can derive analytically. It is merely a statement of fact - we can always describe the true value as the predicted value plus the process noise. "Noise" does not imply random events. If we are tracking a thrown ball in the atmosphere, and our model assumes the ball is in a vacuum, then the effect of air drag is process noise in this context.
In the next section we will learn techniques to convert a set of differential equations into a set of first-order differential equations. Assuming that, we can say that our model of the system without noise is:
$$ \dot{\mathbf x} = \mathbf{Ax}$$
$\mathbf A$ is known as the *systems dynamics matrix* as it describes the dynamics of the system. Now we need to model the noise. We will call that $\mathbf w$, and add it to the equation.
$$ \dot{\mathbf x} = \mathbf{Ax} + \mathbf w$$
$\mathbf w$ may strike you as a poor choice for the name, but you will soon see that the Kalman filter assumes *white* noise.
Finally, we need to consider any inputs into the system. We assume an input $\mathbf u$, and that there exists a linear model that defines how that input changes the system. For example, pressing the accelerator in your car makes it accelerate, and gravity causes balls to fall. Both are contol inputs. We will need a matrix $\mathbf B$ to convert $u$ into the effect on the system. We add that into our equation:
$$ \dot{\mathbf x} = \mathbf{Ax} + \mathbf{Bu} + \mathbf{w}$$
And that's it. That is one of the equations that Dr. Kalman set out to solve, and he found an optimal esitmator if we assume certain properties of $\mathbf w$.
## State-Space Representation of Dynamic Systems
In the last section we derived the equation
$$ \dot{\mathbf x} = \mathbf{Ax}+ \mathbf{Bu} + \mathbf{w}$$.
However, for our filters we are not interested in the derivative of $\mathbf x$, but in $\mathbf x$ itself. Ignoring the noise for a moment, we want an equation that recusively finds the value of $\mathbf x$ at time $t_k$ in terms of $\mathbf x$ at time $t_{k-1}$:
$$\mathbf x(t_k) = \mathbf F(\Delta t)\mathbf x(t_{k-1}) + \mathbf B(t_k) + \mathbf u (t_k)$$
Convention allows us to write $\mathbf x(t_k)$ as $\mathbf x_k$, which means the
the value of $\mathbf x$ at the k$^{th}$ value of $t$.
$$\mathbf x_k = \mathbf{Fx}_{k-1} + \mathbf B_k\mathbf u_k$$
$\mathbf F$ is the familiar *state transition matrix*, named due to its ability to transition the state from the previous time step to the current time step. It is very similar to the system dynamics matrix $\mathbf A$. The difference is that the system dynamics matrix $\mathbf A$ models a set of linear differential equations, and is continuous. $\mathbf F$ is discrete, and represents a set of linear equations (not differential equations) which step transition $\mathbf x_{k-1}$ to $\mathbf x_k$ over a discrete time step $\Delta t$.
Normally finding this equation is quite difficult. The equation $\dot x = v$ is the simplest possible differential equation and we trivially integrate it as:
$$ \int\limits_{x_{k-1}}^{x_k} \mathrm{d}x = \int\limits_{0}^{\Delta t} v\, \mathrm{d}t \\
x_k-x_0 = v \Delta t \\
x_k = v \Delta t + x_0$$
This equation is *recursive*: we compute the value of $x$ at time $t$ based on its value at time $t-1$. This recursive form enables us to represent the system (process model) in the form required by the Kalman filter:
$$\begin{aligned}
\mathbf x_k &= \mathbf{Fx}_{k-1} \\
&= \begin{bmatrix} 1 & \Delta t \\ 0 & 1\end{bmatrix}
\begin{bmatrix}x_{k-1} \\ \dot x_{k-1}\end{bmatrix}
\end{aligned}$$
We can do that only because $\dot x = v$ is simplest differential equation possible. Almost all other in physical systems result in more complicated differential equation which do not yield to this approach.
*State-space* methods became popular around the time of the Apollo missions, largely due to the work of Dr. Kalman. The idea is simple. Model a system with a set of $n^{th}$-order differential equations. Convert them into an equivalent set of first-order differential equations. Put them into the vector-matrix form used in the previous section: $\dot{\mathbf x} = \mathbf{Ax} + \mathbf{Bu}$. Once in this form we use of of several techniques to convert these linear differential equations into the recursive equation:
$$ \mathbf x_k = \mathbf{Fx}_{k-1} + \mathbf B_k\mathbf u_k$$
Some books call the state transition matrix the *fundamental matrix*. Many use $\mathbf \Phi$ instead of $\mathbf F$. Sources based heavily on control theory tend to use these forms.
These are called *state-space* methods because we are expressing the solution of the differential equations in terms of the system state.
### Forming First Order Equations from Higher Order Equations
Many models of physical systems require second or higher order differential equations with control input $u$:
$$a_n \frac{d^ny}{dt^n} + a_{n-1} \frac{d^{n-1}y}{dt^{n-1}} + \dots + a_2 \frac{d^2y}{dt^2} + a_1 \frac{dy}{dt} + a_0 = u$$
State-space methods require first-order equations. Any higher order system of equations can be reduced to first-order by defining extra variables for the derivatives and then solving.
Let's do an example. Given the system $\ddot{x} - 6\dot x + 9x = t$ find the equivalent first order equations. I've used the dot notation for the time derivatives for clarity.
The first step is to isolate the highest order term onto one side of the equation.
$$\ddot{x} = 6\dot x - 9x + t$$
We define two new variables:
$$ x_1(t) = x \\
x_2(t) = \dot x
$$
Now we will substitute these into the original equation and solve. The solution yields a set of first-order equations in terms of these new variables. It is conventional to drop the $(t)$ for notational convenience.
We know that $\dot x_1 = x_2$ and that $\dot x_2 = \ddot{x}$. Therefore
$$\begin{aligned}
\dot x_2 &= \ddot{x} \\
&= 6\dot x - 9x + t\\
&= 6x_2-9x_1 + t
\end{aligned}$$
Therefore our first-order system of equations is
$$\begin{aligned}\dot x_1 &= x_2 \\
\dot x_2 &= 6x_2-9x_1 + t\end{aligned}$$
If you practice this a bit you will become adept at it. Isolate the highest term, define a new variable and its derivatives, and then substitute.
### First Order Differential Equations In State-Space Form
Substituting the newly defined variables from the previous section:
$$\frac{dx_1}{dt} = x_2,\,
\frac{dx_2}{dt} = x_3, \, ..., \,
\frac{dx_{n-1}}{dt} = x_n$$
into the first order equations yields:
$$\frac{dx_n}{dt} = \frac{1}{a_n}\sum\limits_{i=0}^{n-1}a_ix_{i+1} + \frac{1}{a_n}u
$$
Using vector-matrix notation we have:
$$\begin{bmatrix}\frac{dx_1}{dt} \\ \frac{dx_2}{dt} \\ \vdots \\ \frac{dx_n}{dt}\end{bmatrix} =
\begin{bmatrix}\dot x_1 \\ \dot x_2 \\ \vdots \\ \dot x_n\end{bmatrix}=
\begin{bmatrix}0 & 1 & 0 &\cdots & 0 \\
0 & 0 & 1 & \cdots & 0 \\
\vdots & \vdots & \vdots & \ddots & \vdots \\
-\frac{a_0}{a_n} & -\frac{a_1}{a_n} & -\frac{a_2}{a_n} & \cdots & -\frac{a_{n-1}}{a_n}\end{bmatrix}
\begin{bmatrix}x_1 \\ x_2 \\ \vdots \\ x_n\end{bmatrix} +
\begin{bmatrix}0 \\ 0 \\ \vdots \\ \frac{1}{a_n}\end{bmatrix}u$$
which we then write as $\dot{\mathbf x} = \mathbf{Ax} + \mathbf{B}u$.
### Finding the Fundamental Matrix for Time Invariant Systems
We express the system equations in state-space form with
$$ \dot{\mathbf x} = \mathbf{Ax}$$
where $\mathbf A$ is the system dynamics matrix, and want to find the *fundamental matrix* $\mathbf F$ that propagates the state $\mathbf x$ over the interval $\Delta t$ with the equation
$$\begin{aligned}
\mathbf x(t_k) = \mathbf F(\Delta t)\mathbf x(t_{k-1})\end{aligned}$$
In other words, $\mathbf A$ is a set of continuous differential equations, and we need $\mathbf F$ to be a set of discrete linear equations that computes the change in $\mathbf A$ over a discrete time step.
It is conventional to drop the $t_k$ and $(\Delta t)$ and use the notation
$$\mathbf x_k = \mathbf {Fx}_{k-1}$$
$\mathbf x_k$ does not mean the k$^{th}$ value of $\mathbf x$, but the value of $\mathbf x$ at the k$^{th}$ value of $t$. In this book I go even further and drop the suffixes entirely in favor of an overline to denote the prediction: $\overline{\mathbf x} = \mathbf{Fx}$.
Broadly speaking there are three common ways to find this matrix for Kalman filters. The technique most often used with Kalman filters is to use a matrix exponential. Linear Time Invariant Theory, also known as LTI System Theory, is a second technique. Finally, there are numerical techniques. You may know of others, but these three are what you will most likely encounter in the Kalman filter literature and praxis.
### The Matrix Exponential
The solution to the equation $\frac{dx}{dt} = kx$ can be found by:
$$\frac{dx}{dt} = kx \\
\frac{dx}{x} = k\, dt \\
\int \frac{1}{x}\, dx = \int k\, dt \\
\log x = kt + c \\
x = e^{kt+c} \\
x = e^ce^{kt} \\
x = c_0e^{kt}$$
Using similar math, the solution to the first-order equation
$$\dot{\mathbf x} = \mathbf{Ax} ,\, \, \, \mathbf x(0) = \mathbf x_0$$
where $\mathbf A$ is a constant matrix, is
$$\mathbf x = e^{\mathbf At}\mathbf x_0$$
Substituting $F = e^{\mathbf At}$, we can write
$$\mathbf x_k = \mathbf F\mathbf x_{k-1}$$
which is the form we are looking for! We have reduced the problem of finding the fundamental matrix to one of finding the value for $e^{\mathbf At}$.
$e^{\mathbf At}$ is known as the matrix exponential. It can be computed with this power series:
$$e^{\mathbf At} = \mathbf{I} + \mathbf{A}t + \frac{(\mathbf{A}t)^2}{2!} + \frac{(\mathbf{A}t)^3}{3!} + ... $$
That series is found by doing a Taylor series expansion of $e^{\mathbf At}$, which I will not cover here.
Let's use this to find the solution to Newton's equations. Using $v$ as an substitution for $\dot x$, and assuming constant velocity we get the linear matrix-vector form
$$\begin{bmatrix}\dot x \\ \dot v\end{bmatrix} =\begin{bmatrix}0&1\\0&0\end{bmatrix} \begin{bmatrix}x \\ v\end{bmatrix}$$
This is a first order differential equation, so we can set $\mathbf{A}=\begin{bmatrix}0&1\\0&0\end{bmatrix}$ and solve the following equation. I have substituted the interval $\Delta t$ for $t$ to emphasize that the fundamental matrix is discrete:
$$\mathbf F = e^{\mathbf A\Delta t} = \mathbf{I} + \mathbf A\Delta t + \frac{(\mathbf A\Delta t)^2}{2!} + \frac{(\mathbf A\Delta t)^3}{3!} + ... $$
If you perform the multiplication you will find that $\mathbf{A}^2=\begin{bmatrix}0&0\\0&0\end{bmatrix}$, which means that all higher powers of $\mathbf{A}$ are also $\mathbf{0}$. Thus we get an exact answer without an infinite number of terms:
$$
\begin{aligned}
\mathbf F &=\mathbf{I} + \mathbf A \Delta t + \mathbf{0} \\
&= \begin{bmatrix}1&0\\0&1\end{bmatrix} + \begin{bmatrix}0&1\\0&0\end{bmatrix}t\\
&= \begin{bmatrix}1&t\\0&1\end{bmatrix}
\end{aligned}$$
We plug this into $\mathbf x_k= \mathbf{Fx}_{k-1}$ to get
$$
\begin{aligned}
x_k &=\begin{bmatrix}1&\Delta t\\0&1\end{bmatrix}x_{k-1}
\end{aligned}$$
You will recognize this as the matrix we derived analytically for the constant velocity Kalman filter in the **Multivariate Kalman Filter** chapter.
### Time Invariance
If the behavior of the system depends on time we can say that a dynamic system is described by the first-order differential equation
$$ g(t) = \dot x$$
However, if the system is *time invariant* the equation is of the form:
$$ f(x) = \dot x$$
What does *time invariant* mean? Consider a home stereo. If you input a signal $x$ into it at time $t$, it will output some signal $f(x)$. If you instead perform the input at time $t + \Delta t$ the output signal will be the same $f(x)$, shifted in time.
A counter-example is $x(t) = \sin(t)$, with the system $f(x) = t\, x(t) = t \sin(t)$. This is not time invariant; the value will be different at different times due to the multiplication by t. An aircraft is not time invariant. If you make a control input to the aircraft at a later time its behavior will be different because it will have burned fuel and thus lost weight. Lower weight results in different behavior.
We can solve these equations by integrating each side. I demonstrated integrating the time invariants system $v = \dot x$ above. However, integrating the time invariant equation $\dot x = f(x)$ is not so straightforward. Using the *separation of variables* techniques we divide by $f(x)$ and move the $dt$ term to the right so we can integrate each side:
$$
\frac{dx}{dt} = f(x) \\
\int^x_{x_0} \frac{1}{f(x)} dx = \int^t_{t_0} dt\\
$$
If we let $F(x) = \int \frac{1}{f(x)} dx$ we get
$$F(x) - F(x_0) = t-t_0$$
We then solve for x with
$$F(x) = t - t_0 + F(x_0) \\
x = F^{-1}[t-t_0 + F(x_0)]$$
In other words, we need to find the inverse of $F$. This is not trivial, and a significant amount of coursework in a STEM education is devoted to finding tricky, analytic solutions to this problem.
However, they are tricks, and many simple forms of $f(x)$ either have no closed form solution or pose extreme difficulties. Instead, the practicing engineer turns to state-space methods to find approximate solutions.
The advantage of the matrix exponential is that we can use it for any arbitrary set of differential equations which are *time invariant*. However, we often use this technique even when the equations are not time invariant. As an aircraft flies it burns fuel and loses weight. However, the weight loss over one second is negligible, and so the system is nearly linear over that time step. Our answers will still be reasonably accurate so long as the time step is short.
#### Example: Mass-Spring-Damper Model
Suppose we wanted to track the motion of a weight on a spring and connected to a damper, such as an automobile's suspension. The equation for the motion with $m$ being the mass, $k$ the spring constant, and $c$ the damping force, under some input $u$ is
$$m\frac{d^2x}{dt^2} + c\frac{dx}{dt} +kx = u$$
For notational convenience I will write that as
$$m\ddot x + c\dot x + kx = u$$
I can turn this into a system of first order equations by setting $x_1(t)=x(t)$, and then substituting as follows:
$$\begin{aligned}
x_1 &= x \\
x_2 &= \dot x_1 \\
\dot x_2 &= \dot x_1 = \ddot x
\end{aligned}$$
As is common I dropped the $(t)$ for notational convenience. This gives the equation
$$m\dot x_2 + c x_2 +kx_1 = u$$
Solving for $\dot x_2$ we get a first order equation:
$$\dot x_2 = -\frac{c}{m}x_2 - \frac{k}{m}x_1 + \frac{1}{m}u$$
We put this into matrix form:
$$\begin{bmatrix} \dot x_1 \\ \dot x_2 \end{bmatrix} =
\begin{bmatrix}0 & 1 \\ -k/m & -c/m \end{bmatrix}
\begin{bmatrix} x_1 \\ x_2 \end{bmatrix} +
\begin{bmatrix} 0 \\ 1/m \end{bmatrix}u$$
Now we use the matrix exponential to find the state transition matrix:
$$\Phi(t) = e^{\mathbf At} = \mathbf{I} + \mathbf At + \frac{(\mathbf At)^2}{2!} + \frac{(\mathbf At)^3}{3!} + ... $$
The first two terms give us
$$\mathbf F = \begin{bmatrix}1 & t \\ -(k/m) t & 1-(c/m) t \end{bmatrix}$$
This may or may not give you enough precision. You can easily check this by computing $\frac{(\mathbf At)^2}{2!}$ for your constants and seeing how much this matrix contributes to the results.
### Linear Time Invariant Theory
*Linear Time Invariant Theory*, also known as LTI System Theory, gives us a way to find $\Phi$ using the inverse Laplace transform. You are either nodding your head now, or completely lost. Don't worry, I will not be using the Laplace transform in this book except in this paragraph, as the computation can be quite difficult. LTI system theory tells us that
$$ \Phi(t) = \mathcal{L}^{-1}[(s\mathbf{I} - \mathbf{F})^{-1}]$$
I have no intention of going into this other than to say that the Laplace transform $\mathcal{L}$ converts a signal into a space $s$ that excludes time, but finding a solution to the equation above is non-trivial. If you are interested, the Wikipedia article on LTI system theory provides an introduction [2]. I mention LTI because you will find some literature using it to design the Kalman filter matrices for difficult problems.
### Numerical Solutions
Finally, there are numerous numerical techniques to find $\mathbf F$. As filters get larger finding analytical solutions becomes very tedious (though packages like SymPy make it easier). C. F. van Loan [3] has developed a technique that finds both $\Phi$ and $\mathbf Q$ numerically. Given the continuous model
$$ \dot x = Ax + Gw$$
where $w$ is the unity white noise, van Loan's method computes both $\mathbf F_k$ and $\mathbf Q_k$.
I have implemented van Loan's method in `FilterPy`. You may use it as follows:
```python
from filterpy.common import van_loan_discretization
A = np.array([[0., 1.], [-1., 0.]])
G = np.array([[0.], [2.]]) # white noise scaling
F, Q = van_loan_discretization(A, G, dt=0.1)
```
In the section *Numeric Integration of Differential Equations* I present alternative methods which are very commonly used in Kalman filtering.
## Design of the Process Noise Matrix
In general the design of the $\mathbf Q$ matrix is among the most difficult aspects of Kalman filter design. This is due to several factors. First, the math requires a good foundation in signal theory. Second, we are trying to model the noise in something for which we have little information. Consider trying to model the process noise for a thrown baseball. We can model it as a sphere moving through the air, but that leave many unknown factors - the wind, ball rotation and spin decay, the coefficient of drag of a ball with stitches, the effects of wind and air density, and so on. We develop the equations for an exact mathematical solution for a given process model, but since the process model is incomplete the result for $\mathbf Q$ will also be incomplete. This has a lot of ramifications for the behavior of the Kalman filter. If $\mathbf Q$ is too small then the filter will be overconfident in its prediction model and will diverge from the actual solution. If $\mathbf Q$ is too large than the filter will be unduly influenced by the noise in the measurements and perform sub-optimally. In practice we spend a lot of time running simulations and evaluating collected data to try to select an appropriate value for $\mathbf Q$. But let's start by looking at the math.
Let's assume a kinematic system - some system that can be modeled using Newton's equations of motion. We can make a few different assumptions about this process.
We have been using a process model of
$$ \dot{\mathbf x} = \mathbf{Ax} + \mathbf{Bu} + \mathbf{w}$$
where $\mathbf{w}$ is the process noise. Kinematic systems are *continuous* - their inputs and outputs can vary at any arbitrary point in time. However, our Kalman filters are *discrete*. We sample the system at regular intervals. Therefore we must find the discrete representation for the noise term in the equation above. This depends on what assumptions we make about the behavior of the noise. We will consider two different models for the noise.
### Continuous White Noise Model
We model kinematic systems using Newton's equations. We have either used position and velocity, or position, velocity, and acceleration as the models for our systems. There is nothing stopping us from going further - we can model jerk, jounce, snap, and so on. We don't do that normally because adding terms beyond the dynamics of the real system degrades the estimate.
Let's say that we need to model the position, velocity, and acceleration. We can then assume that acceleration is constant for each discrete time step. Of course, there is process noise in the system and so the acceleration is not actually constant. The tracked object will alter the acceleration over time due to external, unmodeled forces. In this section we will assume that the acceleration changes by a continuous time zero-mean white noise $w(t)$. In other words, we are assuming that velocity is acceleration changing by small amounts that over time average to 0 (zero-mean).
Since the noise is changing continuously we will need to integrate to get the discrete noise for the discretization interval that we have chosen. We will not prove it here, but the equation for the discretization of the noise is
$$\mathbf Q = \int_0^{\Delta t} \mathbf F(t)\mathbf{Q_c}\mathbf F^\mathsf{T}(t) dt$$
where $\mathbf{Q_c}$ is the continuous noise. This gives us
$$\Phi = \begin{bmatrix}1 & \Delta t & {\Delta t}^2/2 \\ 0 & 1 & \Delta t\\ 0& 0& 1\end{bmatrix}$$
for the fundamental matrix, and
$$\mathbf{Q_c} = \begin{bmatrix}0&0&0\\0&0&0\\0&0&1\end{bmatrix} \Phi_s$$
for the continuous process noise matrix, where $\Phi_s$ is the spectral density of the white noise.
We could carry out these computations ourselves, but I prefer using SymPy to solve the equation.
$$\mathbf{Q_c} = \begin{bmatrix}0&0&0\\0&0&0\\0&0&1\end{bmatrix} \Phi_s$$
```python
import sympy
from sympy import (init_printing, Matrix,MatMul,
integrate, symbols)
init_printing(use_latex='mathjax')
dt, phi = symbols('\Delta{t} \Phi_s')
F_k = Matrix([[1, dt, dt**2/2],
[0, 1, dt],
[0, 0, 1]])
Q_c = Matrix([[0, 0, 0],
[0, 0, 0],
[0, 0, 1]])*phi
Q=sympy.integrate(F_k * Q_c * F_k.T, (dt, 0, dt))
# factor phi out of the matrix to make it more readable
Q = Q / phi
sympy.MatMul(Q, phi)
```
$$\left[\begin{matrix}\frac{\Delta{t}^{5}}{20} & \frac{\Delta{t}^{4}}{8} & \frac{\Delta{t}^{3}}{6}\\\frac{\Delta{t}^{4}}{8} & \frac{\Delta{t}^{3}}{3} & \frac{\Delta{t}^{2}}{2}\\\frac{\Delta{t}^{3}}{6} & \frac{\Delta{t}^{2}}{2} & \Delta{t}\end{matrix}\right] \Phi_{s}$$
For completeness, let us compute the equations for the 0th order and 1st order equations.
```python
F_k = sympy.Matrix([[1]])
Q_c = sympy.Matrix([[phi]])
print('0th order discrete process noise')
sympy.integrate(F_k*Q_c*F_k.T,(dt, 0, dt))
```
0th order discrete process noise
$$\left[\begin{matrix}\Delta{t} \Phi_{s}\end{matrix}\right]$$
```python
F_k = sympy.Matrix([[1, dt],
[0, 1]])
Q_c = sympy.Matrix([[0, 0],
[0, 1]])*phi
Q = sympy.integrate(F_k * Q_c * F_k.T, (dt, 0, dt))
print('1st order discrete process noise')
# factor phi out of the matrix to make it more readable
Q = Q / phi
sympy.MatMul(Q, phi)
```
1st order discrete process noise
$$\left[\begin{matrix}\frac{\Delta{t}^{3}}{3} & \frac{\Delta{t}^{2}}{2}\\\frac{\Delta{t}^{2}}{2} & \Delta{t}\end{matrix}\right] \Phi_{s}$$
### Piecewise White Noise Model
Another model for the noise assumes that the that highest order term (say, acceleration) is constant for the duration of each time period, but differs for each time period, and each of these is uncorrelated between time periods. In other words there is a discontinuous jump in acceleration at each time step. This is subtly different than the model above, where we assumed that the last term had a continuously varying noisy signal applied to it.
We will model this as
$$f(x)=Fx+\Gamma w$$
where $\Gamma$ is the *noise gain* of the system, and $w$ is the constant piecewise acceleration (or velocity, or jerk, etc).
Lets start by looking at a first order system. In this case we have the state transition function
$$\mathbf{F} = \begin{bmatrix}1&\Delta t \\ 0& 1\end{bmatrix}$$
In one time period, the change in velocity will be $w(t)\Delta t$, and the change in position will be $w(t)\Delta t^2/2$, giving us
$$\Gamma = \begin{bmatrix}\frac{1}{2}\Delta t^2 \\ \Delta t\end{bmatrix}$$
The covariance of the process noise is then
$$Q = \mathbb E[\Gamma w(t) w(t) \Gamma^\mathsf{T}] = \Gamma\sigma^2_v\Gamma^\mathsf{T}$$.
We can compute that with SymPy as follows
```python
var=symbols('sigma^2_v')
v = Matrix([[dt**2 / 2], [dt]])
Q = v * var * v.T
# factor variance out of the matrix to make it more readable
Q = Q / var
sympy.MatMul(Q, var)
```
$$\left[\begin{matrix}\frac{\Delta{t}^{4}}{4} & \frac{\Delta{t}^{3}}{2}\\\frac{\Delta{t}^{3}}{2} & \Delta{t}^{2}\end{matrix}\right] \sigma^{2}_{v}$$
The second order system proceeds with the same math.
$$\mathbf{F} = \begin{bmatrix}1 & \Delta t & {\Delta t}^2/2 \\ 0 & 1 & \Delta t\\ 0& 0& 1\end{bmatrix}$$
Here we will assume that the white noise is a discrete time Wiener process. This gives us
$$\Gamma = \begin{bmatrix}\frac{1}{2}\Delta t^2 \\ \Delta t\\ 1\end{bmatrix}$$
There is no 'truth' to this model, it is just convenient and provides good results. For example, we could assume that the noise is applied to the jerk at the cost of a more complicated equation.
The covariance of the process noise is then
$$Q = \mathbb E[\Gamma w(t) w(t) \Gamma^\mathsf{T}] = \Gamma\sigma^2_v\Gamma^\mathsf{T}$$.
We can compute that with SymPy as follows
```python
var=symbols('sigma^2_v')
v = Matrix([[dt**2 / 2], [dt], [1]])
Q = v * var * v.T
# factor variance out of the matrix to make it more readable
Q = Q / var
sympy.MatMul(Q, var)
```
$$\left[\begin{matrix}\frac{\Delta{t}^{4}}{4} & \frac{\Delta{t}^{3}}{2} & \frac{\Delta{t}^{2}}{2}\\\frac{\Delta{t}^{3}}{2} & \Delta{t}^{2} & \Delta{t}\\\frac{\Delta{t}^{2}}{2} & \Delta{t} & 1\end{matrix}\right] \sigma^{2}_{v}$$
We cannot say that this model is more or less correct than the continuous model - both are approximations to what is happening to the actual object. Only experience and experiments can guide you to the appropriate model. In practice you will usually find that either model provides reasonable results, but typically one will perform better than the other.
The advantage of the second model is that we can model the noise in terms of $\sigma^2$ which we can describe in terms of the motion and the amount of error we expect. The first model requires us to specify the spectral density, which is not very intuitive, but it handles varying time samples much more easily since the noise is integrated across the time period. However, these are not fixed rules - use whichever model (or a model of your own devising) based on testing how the filter performs and/or your knowledge of the behavior of the physical model.
A good rule of thumb is to set $\sigma$ somewhere from $\frac{1}{2}\Delta a$ to $\Delta a$, where $\Delta a$ is the maximum amount that the acceleration will change between sample periods. In practice we pick a number, run simulations on data, and choose a value that works well.
### Using FilterPy to Compute Q
FilterPy offers several routines to compute the $\mathbf Q$ matrix. The function `Q_continuous_white_noise()` computes $\mathbf Q$ for a given value for $\Delta t$ and the spectral density.
```python
from filterpy.common import Q_continuous_white_noise
from filterpy.common import Q_discrete_white_noise
Q = Q_continuous_white_noise(dim=2, dt=1, spectral_density=1)
print(Q)
```
[[ 0.333 0.5 ]
[ 0.5 1. ]]
```python
Q = Q_continuous_white_noise(dim=3, dt=1, spectral_density=1)
print(Q)
```
[[ 0.05 0.125 0.167]
[ 0.125 0.333 0.5 ]
[ 0.167 0.5 1. ]]
The function `Q_discrete_white_noise()` computes $\mathbf Q$ assuming a piecewise model for the noise.
```python
Q = Q_discrete_white_noise(2, var=1.)
print(Q)
```
[[ 0.25 0.5 ]
[ 0.5 1. ]]
```python
Q = Q_discrete_white_noise(3, var=1.)
print(Q)
```
[[ 0.25 0.5 0.5 ]
[ 0.5 1. 1. ]
[ 0.5 1. 1. ]]
### Simplification of Q
Many treatments use a much simpler form for $\mathbf Q$, setting it to zero except for a noise term in the lower rightmost element. Is this justified? Well, consider the value of $\mathbf Q$ for a small $\Delta t$
```python
import numpy as np
np.set_printoptions(precision=8)
Q = Q_continuous_white_noise(
dim=3, dt=0.05, spectral_density=1)
print(Q)
np.set_printoptions(precision=3)
```
[[ 0.00000002 0.00000078 0.00002083]
[ 0.00000078 0.00004167 0.00125 ]
[ 0.00002083 0.00125 0.05 ]]
We can see that most of the terms are very small. Recall that the only Kalman filter using this matrix is
$$ \mathbf P=\mathbf{FPF}^\mathsf{T} + \mathbf Q$$
If the values for $\mathbf Q$ are small relative to $\mathbf P$
than it will be contributing almost nothing to the computation of $\mathbf P$. Setting $\mathbf Q$ to the zero matrix except for the lower right term
$$\mathbf Q=\begin{bmatrix}0&0&0\\0&0&0\\0&0&\sigma^2\end{bmatrix}$$
while not correct, is often a useful approximation. If you do this you will have to perform quite a few studies to guarantee that your filter works in a variety of situations.
If you do this, 'lower right term' means the most rapidly changing term for each variable. If the state is $x=\begin{bmatrix}x & \dot x & \ddot{x} & y & \dot{y} & \ddot{y}\end{bmatrix}^\mathsf{T}$ Then Q will be 6x6; the elements for both $\ddot{x}$ and $\ddot{y}$ will have to be set to non-zero in $\mathbf Q$.
## Numeric Integration of Differential Equations
We've been exposed to several numerical techniques to solve linear differential equations. These include state-space methods, the Laplace transform, and van Loan's method.
These work well for linear ordinary differential equations (ODEs), but do not work well for nonlinear equations. For example, consider trying to predict the position of a rapidly turning car. Cars maneuver by turning the front wheels. This makes them pivot around their rear axle as it moves forward. Therefore the path will be continuously varying and a linear prediction will necessarily produce an incorrect value. If the change in the system is small enough relative to $\Delta t$ this can often produce adequate results, but that will rarely be the case with the nonlinear Kalman filters we will be studying in subsequent chapters.
For these reasons we need to know how to numerically integrate ODEs. This can be a vast topic that requires several books. If you need to explore this topic in depth *Computational Physics in Python* by Dr. Eric Ayars is excellent, and available for free here:
http://phys.csuchico.edu/ayars/312/Handouts/comp-phys-python.pdf
However, I will cover a few simple techniques which will work for a majority of the problems you encounter.
### Euler's Method
Let's say we have the initial condition problem of
$$ y' = y, \\ y(0) = 1$$
We happen to know the exact answer is $y=e^t$ because we solved it earlier, but for an arbitrary ODE we will not know the exact solution. In general all we know is the derivative of the equation, which is equal to the slope. We also know the initial value: at $t=0$, $y=1$. If we know these two pieces of information we can predict the value at $y(t=1)$ using the slope at $t=0$ and the value of $y(0)$. I've plotted this below.
```python
import matplotlib.pyplot as plt
t = np.linspace(-1, 1, 10)
plt.plot(t, np.exp(t))
t = np.linspace(-1, 1, 2)
plt.plot(t,t+1, ls='--', c='k');
```
You can see that the slope is very close to the curve at $t=0.1$, but far from it
at $t=1$. But let's continue with a step size of 1 for a moment. We can see that at $t=1$ the estimated value of $y$ is 2. Now we can compute the value at $t=2$ by taking the slope of the curve at $t=1$ and adding it to our initial estimate. The slope is computed with $y'=y$, so the slope is 2.
```python
import book_plots
t = np.linspace(-1, 2, 20)
plt.plot(t, np.exp(t))
t = np.linspace(0, 1, 2)
plt.plot([1, 2, 4], ls='--', c='k')
book_plots.set_labels(x='x', y='y');
```
Here we see the next estimate for y is 4. The errors are getting large quickly, and you might be unimpressed. But 1 is a very large step size. Let's put this algorithm in code, and verify that it works by using a small step size.
```python
def euler(t, tmax, y, dx, step=1.):
ys = []
while t < tmax:
y = y + step*dx(t, y)
ys.append(y)
t +=step
return ys
```
```python
def dx(t, y): return y
print(euler(0, 1, 1, dx, step=1.)[-1])
print(euler(0, 2, 1, dx, step=1.)[-1])
```
2.0
4.0
This looks correct. So now lets plot the result of a much smaller step size.
```python
ys = euler(0, 4, 1, dx, step=0.00001)
plt.subplot(1,2,1)
plt.title('Computed')
plt.plot(np.linspace(0, 4, len(ys)),ys)
plt.subplot(1,2,2)
t = np.linspace(0, 4, 20)
plt.title('Exact')
plt.plot(t, np.exp(t));
```
```python
print('exact answer=', np.exp(4))
print('euler answer=', ys[-1])
print('difference =', np.exp(4) - ys[-1])
print('iterations =', len(ys))
```
exact answer= 54.5981500331
euler answer= 54.59705808834125
difference = 0.00109194480299
iterations = 400000
Here we see that the error is reasonably small, but it took a very large number of iterations to get three digits of precision. In practice Euler's method is too slow for most problems, and we use more sophisticated methods.
Before we go on, let's formally derive Euler's method, as it is the basis for the more advanced Runge Kutta methods used in the next section. In fact, Euler's method is the simplest form of Runge Kutta.
Here are the first 3 terms of the Euler expansion of $y$. An infinite expansion would give an exact answer, so $O(h^4)$ denotes the error due to the finite expansion.
$$y(t_0 + h) = y(t_0) + h y'(t_0) + \frac{1}{2!}h^2 y''(t_0) + \frac{1}{3!}h^3 y'''(t_0) + O(h^4)$$
Here we can see that Euler's method is using the first two terms of the Taylor expansion. Each subsequent term is smaller than the previous terms, so we are assured that the estimate will not be too far off from the correct value.
### Runge Kutta Methods
Runge Kutta integration is the workhorse of numerical integration. There are a vast number of methods in the literature. In practice, using the Runge Kutta algorithm that I present here will solve most any problem you will face. It offers a very good balance of speed, precision, and stability, and it is the 'go to' numerical integration method unless you have a very good reason to choose something different.
Let's dive in. We start with some differential equation
$$\ddot{y} = \frac{d}{dt}\dot{y}$$.
We can substitute the derivative of y with a function f, like so
$$\ddot{y} = \frac{d}{dt}f(y,t)$$.
Deriving these equations is outside the scope of this book, but the Runge Kutta RK4 method is defined with these equations.
$$y(t+\Delta t) = y(t) + \frac{1}{6}(k_1 + 2k_2 + 2k_3 + k_4) + O(\Delta t^4)$$
$$\begin{aligned}
k_1 &= f(y,t)\Delta t \\
k_2 &= f(y+\frac{1}{2}k_1, t+\frac{1}{2}\Delta t)\Delta t \\
k_3 &= f(y+\frac{1}{2}k_2, t+\frac{1}{2}\Delta t)\Delta t \\
k_4 &= f(y+k_3, t+\Delta t)\Delta t
\end{aligned}
$$
Here is the corresponding code:
```python
def runge_kutta4(y, x, dx, f):
"""computes 4th order Runge-Kutta for dy/dx.
y is the initial value for y
x is the initial value for x
dx is the difference in x (e.g. the time step)
f is a callable function (y, x) that you supply
to compute dy/dx for the specified values.
"""
k1 = dx * f(y, x)
k2 = dx * f(y + 0.5*k1, x + 0.5*dx)
k3 = dx * f(y + 0.5*k2, x + 0.5*dx)
k4 = dx * f(y + k3, x + dx)
return y + (k1 + 2*k2 + 2*k3 + k4) / 6.
```
Let's use this for a simple example. Let
$$\dot{y} = t\sqrt{y(t)}$$
with the initial values
$$\begin{aligned}t_0 &= 0\\y_0 &= y(t_0) = 1\end{aligned}$$
```python
import math
import numpy as np
t = 0.
y = 1.
dt = .1
ys, ts = [], []
def func(y,t):
return t*math.sqrt(y)
while t <= 10:
y = runge_kutta4(y, t, dt, func)
t += dt
ys.append(y)
ts.append(t)
exact = [(t**2 + 4)**2 / 16. for t in ts]
plt.plot(ts, ys)
plt.plot(ts, exact)
error = np.array(exact) - np.array(ys)
print("max error {}".format(max(error)))
```
## Bayesian Filtering
Starting in the Discrete Bayes chapter I used a Bayesian formulation for filtering. Suppose we are tracking an object. We define its *state* at a specific time as its position, velocity, and so on. For example, we might write the state at time $t$ as $\mathbf x_t = \begin{bmatrix}x_t &\dot x_t \end{bmatrix}^\mathsf T$.
When we take a measurement of the object we are measuring the state. Sensors are noisy, so the measurement is corrupted with noise. Clearly though, the measurement is determined by the state. That is, a change in state may change the measurement, but a change in measurement will not change the state.
In filtering our goal is to compute an optimal estimate for a set of states $\mathbf x_{0:t}$ from time 0 to time $t$. If we knew $\mathbf x_{0:t}$ then it would be trivial to compute a set of measurements $\mathbf z_{0:t}$ corresponding to those states. However, we receive a set of measurements $\mathbf z_{0:t}$, and want to compute the corresponding states $\mathbf x_{0:t}$. This is called *statistical inversion* because we are trying to compute the input from the output.
Inversion is a difficult problem because there is typically no unique solution. For a given set of states $\mathbf x_{0:t}$ there is only one possible set of measurements (plus noise), but for a given set of measurements there are many different sets of states that could have led to those measurements.
Recall Bayes Theorem:
$$P(x \mid z) = \frac{P(z \mid x)P(x)}{P(z)}$$
where $P(z \mid x)$ is the *likelihood* of the measurement $z$, $P(x)$ is the *prior* based on our process model, and $P(z)$ is a normalization constant. $P(x \mid z)$ is the *posterior*, or the distribution after incorporating the measurement $z$, also called the *evidence*.
This is a *statistical inversion* as it goes from $P(z \mid x)$ to $P(x \mid z)$. The solution to our filtering problem can be expressed as:
$$P(\mathbf x_{0:t} \mid \mathbf z_{0:t}) = \frac{P(\mathbf z_{0:t} \mid \mathbf x_{0:t})P(\mathbf x_{0:t})}{P(\mathbf z_{0:t})}$$
That is all well and good until the next measurement $\mathbf z_{t+1}$ comes in, at which point we need to recompute the entire expression for the range $0:t+1$.
In practice this is intractable because we are trying to compute the posterior distribution $P(\mathbf x_{0:t} \mid \mathbf z_{0:t})$ for the state over the full range of time steps. But do we really care about the probability distribution at the third step (say) when we just received the tenth measurement? Not usually. So we relax our requirements and only compute the distributions for the current time step.
The first simplification is we describe our process (e.g., the motion model for a moving object) as a *Markov chain*. That is, we say that the current state is solely dependent on the previous state and a transition probability $P(\mathbf x_k \mid \mathbf x_{k-1})$, which is just the probability of going from the last state to the current one. We write:
$$\mathbf x_k \sim P(\mathbf x_k \mid \mathbf x_{k-1})$$
The next simplification we make is do define the *measurement model* as depending on the current state $\mathbf x_k$ with the conditional probability of the measurement given the current state: $P(\mathbf z_t \mid \mathbf x_x)$. We write:
$$\mathbf z_k \sim P(\mathbf z_t \mid \mathbf x_x)$$
We have a recurrance now, so we need an initial condition to terminate it. Therefore we say that the initial distribution is the probablity of the state $\mathbf x_0$:
$$\mathbf x_0 \sim P(\mathbf x_0)$$
These terms are plugged into Bayes equation. If we have the state $\mathbf x_0$ and the first measurement we can estimate $P(\mathbf x_1 | \mathbf z_1)$. The motion model creates the prior $P(\mathbf x_2 \mid \mathbf x_1)$. We feed this back into Bayes theorem to compute $P(\mathbf x_2 | \mathbf z_2)$. We continue this predictor-corrector algorithm, recursively computing the state and distribution at time $t$ based solely on the state and distribution at time $t-1$ and the measurement at time $t$.
The details of the mathematics for this computation varies based on the problem. The **Discrete Bayes** and **Univariate Kalman Filter** chapters gave two different formulations which you should have been able to reason through. The univariate Kalman filter assumes that for a scalar state both the noise and process are linear model are affected by zero-mean, uncorrelated Gaussian noise.
The Multivariate Kalman filter make the same assumption but for states and measurements that are vectors, not scalars. Dr. Kalman was able to prove that if these assumptions hold true then the Kalman filter is *optimal*. Colloquially this means there is no way to derive more information from the noise. In the remainder of the book I will present filters that relax the constraints on linearity and Gaussian noise.
Before I go on, a few more words about statistical inversion. As Calvetti and Somersalo write in *Introduction to Bayesian Scientific Computing*, "we adopt the Bayesian point of view: *randomness simply means lack of information*."[4] Our state parametize physical phenomena that we could in principle measure or compute: velocity, air drag, and so on. We lack enough information to compute or measure their value, so we opt to consider them as random variables. Strictly speaking they are not random, thus this is a subjective position.
They devote a full chapter to this topic. I can spare a paragraph. Bayesian filters are possible because we ascribe statistical properties to unknown parameters. In the case of the Kalman filter we have closed-form solutions to find an optimal estimate. Other filters, such as the discrete Bayes filter or the particle filter which we cover in a later chapter, model the probability in a more ad-hoc, non-optimal manner. The power of our technique comes from treating lack of information as a random variable, describing that random variable as a probability distribution, and then using Bayes Theorem to solve the statistical inference problem.
## Converting the Multivariate Equations to the Univariate Case
The multivariate Kalman filter equations do not resemble the equations for the univariate filter. However, if we use one dimensional states and measurements the equations do reduce to the univariate equations. This section will provide you with a strong intuition into what the Kalman filter equations are actually doing. While reading this section is not required to understand the rest of the book, I recommend reading this section carefully as it should make the rest of the material easier to understand.
Here are the multivariate equations for the prediction.
$$
\begin{aligned}
\mathbf{\bar{x}} &= \mathbf{F x} + \mathbf{B u} \\
\mathbf{\bar{P}} &= \mathbf{FPF}^\mathsf{T} + \mathbf Q
\end{aligned}
$$
For a univariate problem the state $\mathbf x$ only has one variable, so it is a $1\times 1$ matrix. Our motion $\mathbf{u}$ is also a $1\times 1$ matrix. Therefore, $\mathbf{F}$ and $\mathbf B$ must also be $1\times 1$ matrices. That means that they are all scalars, and we can write
$$\bar{x} = Fx + Bu$$
Here the variables are not bold, denoting that they are not matrices or vectors.
Our state transition is simple - the next state is the same as this state, so $F=1$. The same holds for the motion transition, so, $B=1$. Thus we have
$$x = x + u$$
which is equivalent to the Gaussian equation from the last chapter
$$ \mu = \mu_1+\mu_2$$
Hopefully the general process is clear, so now I will go a bit faster on the rest. We have
$$\mathbf{\bar{P}} = \mathbf{FPF}^\mathsf{T} + \mathbf Q$$
Again, since our state only has one variable $\mathbf P$ and $\mathbf Q$ must also be $1\times 1$ matrix, which we can treat as scalars, yielding
$$\bar{P} = FPF^\mathsf{T} + Q$$
We already know $F=1$. The transpose of a scalar is the scalar, so $F^\mathsf{T} = 1$. This yields
$$\bar{P} = P + Q$$
which is equivalent to the Gaussian equation of
$$\sigma^2 = \sigma_1^2 + \sigma_2^2$$
This proves that the multivariate prediction equations are performing the same math as the univariate equations for the case of the dimension being 1.
These are the equations for the update step:
$$
\begin{aligned}
\mathbf{K}&= \mathbf{\bar{P}H}^\mathsf{T} (\mathbf{H\bar{P}H}^\mathsf{T} + \mathbf R)^{-1} \\
\textbf{y} &= \mathbf z - \mathbf{H \bar{x}}\\
\mathbf x&=\mathbf{\bar{x}} +\mathbf{K\textbf{y}} \\
\mathbf P&= (\mathbf{I}-\mathbf{KH})\mathbf{\bar{P}}
\end{aligned}
$$
As above, all of the matrices become scalars. $H$ defines how we convert from a position to a measurement. Both are positions, so there is no conversion, and thus $H=1$. Let's substitute in our known values and convert to scalar in one step. The inverse of a 1x1 matrix is the reciprocal of the value so we will convert the matrix inversion to division.
$$
\begin{aligned}
K &=\frac{\bar{P}}{\bar{P} + R} \\
y &= z - \bar{x}\\
x &=\bar{x}+Ky \\
P &= (1-K)\bar{P}
\end{aligned}
$$
Before we continue with the proof, I want you to look at those equations to recognize what a simple concept these equations implement. The residual $y$ is nothing more than the measurement minus the prediction. The gain $K$ is scaled based on how certain we are about the last prediction vs how certain we are about the measurement. We choose a new state $x$ based on the old value of $x$ plus the scaled value of the residual. Finally, we update the uncertainty based on how certain we are about the measurement. Algorithmically this should sound exactly like what we did in the last chapter.
Let's finish off the algebra to prove this. Recall that the univariate equations for the update step are:
$$
\begin{aligned}
\mu &=\frac{\sigma_1^2 \mu_2 + \sigma_2^2 \mu_1} {\sigma_1^2 + \sigma_2^2}, \\
\sigma^2 &= \frac{1}{\frac{1}{\sigma_1^2} + \frac{1}{\sigma_2^2}}
\end{aligned}
$$
Here we will say that $\mu_1$ is the state $x$, and $\mu_2$ is the measurement $z$. Thus it follows that that $\sigma_1^2$ is the state uncertainty $P$, and $\sigma_2^2$ is the measurement noise $R$. Let's substitute those in.
$$ \mu = \frac{Pz + Rx}{P+R} \\
\sigma^2 = \frac{1}{\frac{1}{P} + \frac{1}{R}}
$$
I will handle $\mu$ first. The corresponding equation in the multivariate case is
$$
\begin{aligned}
x &= x + Ky \\
&= x + \frac{P}{P+R}(z-x) \\
&= \frac{P+R}{P+R}x + \frac{Pz - Px}{P+R} \\
&= \frac{Px + Rx + Pz - Px}{P+R} \\
&= \frac{Pz + Rx}{P+R}
\end{aligned}
$$
Now let's look at $\sigma^2$. The corresponding equation in the multivariate case is
$$
\begin{aligned}
P &= (1-K)P \\
&= (1-\frac{P}{P+R})P \\
&= (\frac{P+R}{P+R}-\frac{P}{P+R})P \\
&= (\frac{P+R-P}{P+R})P \\
&= \frac{RP}{P+R}\\
&= \frac{1}{\frac{P+R}{RP}}\\
&= \frac{1}{\frac{R}{RP} + \frac{P}{RP}} \\
&= \frac{1}{\frac{1}{P} + \frac{1}{R}}
\quad\blacksquare
\end{aligned}
$$
We have proven that the multivariate equations are equivalent to the univariate equations when we only have one state variable. I'll close this section by recognizing one quibble - I hand waved my assertion that $H=1$ and $F=1$. In general we know this is not true. For example, a digital thermometer may provide measurement in volts, and we need to convert that to temperature, and we use $H$ to do that conversion. I left that issue out to keep the explanation as simple and streamlined as possible. It is very straightforward to add that generalization to the equations above, redo the algebra, and still have the same results.
## Converting Kalman Filter to a g-h Filter
I've stated that the Kalman filter is a form of the g-h filter. It just takes some algebra to prove it. It's more straightforward to do with the one dimensional case, so I will do that. Recall
$$
\mu_{x}=\frac{\sigma_1^2 \mu_2 + \sigma_2^2 \mu_1} {\sigma_1^2 + \sigma_2^2}
$$
which I will make more friendly for our eyes as:
$$
\mu_{x}=\frac{ya + xb} {a+b}
$$
We can easily put this into the g-h form with the following algebra
$$
\begin{aligned}
\mu_{x}&=(x-x) + \frac{ya + xb} {a+b} \\
\mu_{x}&=x-\frac{a+b}{a+b}x + \frac{ya + xb} {a+b} \\
\mu_{x}&=x +\frac{-x(a+b) + xb+ya}{a+b} \\
\mu_{x}&=x+ \frac{-xa+ya}{a+b} \\
\mu_{x}&=x+ \frac{a}{a+b}(y-x)\\
\end{aligned}
$$
We are almost done, but recall that the variance of estimate is given by
$${\sigma_{x}^2} = \frac{1}{ \frac{1}{\sigma_1^2} + \frac{1}{\sigma_2^2}}\\
= \frac{1}{ \frac{1}{a} + \frac{1}{b}}
$$
We can incorporate that term into our equation above by observing that
$$
\begin{aligned}
\frac{a}{a+b} &= \frac{a/a}{(a+b)/a} = \frac{1}{(a+b)/a} \\
&= \frac{1}{1 + \frac{b}{a}} = \frac{1}{\frac{b}{b} + \frac{b}{a}} \\
&= \frac{1}{b}\frac{1}{\frac{1}{b} + \frac{1}{a}} \\
&= \frac{\sigma^2_{x'}}{b}
\end{aligned}
$$
We can tie all of this together with
$$
\begin{aligned}
\mu_{x}&=x+ \frac{a}{a+b}(y-x) \\
&= x + \frac{\sigma^2_{x'}}{b}(y-x) \\
&= x + g_n(y-x)
\end{aligned}
$$
where
$$g_n = \frac{\sigma^2_{x}}{\sigma^2_{y}}$$
The end result is multiplying the residual of the two measurements by a constant and adding to our previous value, which is the $g$ equation for the g-h filter. $g$ is the variance of the new estimate divided by the variance of the measurement. Of course in this case $g$ is not a constant as it varies with each time step as the variance changes. We can also derive the formula for $h$ in the same way. It is not a particularly illuminating derivation and I will skip it. The end result is
$$h_n = \frac{COV (x,\dot x)}{\sigma^2_{y}}$$
The takeaway point is that $g$ and $h$ are specified fully by the variance and covariances of the measurement and predictions at time $n$. In other words, we are picking a point between the measurement and prediction by a scale factor determined by the quality of each of those two inputs.
## References
* [1] *Matrix Exponential* http://en.wikipedia.org/wiki/Matrix_exponential
* [2] *LTI System Theory* http://en.wikipedia.org/wiki/LTI_system_theory
* [3] C.F. van Loan, "Computing Integrals Involving the Matrix Exponential," IEEE Transactions Automatic Control, June 1978.
* [4] Calvetti, D and Somersalo E, "Introduction to Bayesian Scientific Computing: Ten Lectures on Subjective Computing,", Springer, 2007.
|
/-
Copyright (c) 2022 Arthur Paulino. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Arthur Paulino, Gabriel Ebner
-/
import Lean
/-!
Defines the `use` tactic.
TODO: This does not match the full functionality of `use` from mathlib3.
See failing tests in `test/Use.lean`.
-/
open Lean.Elab.Tactic
namespace Mathlib.Tactic
/--
`use e₁, e₂, ⋯` applies the tactic `refine ⟨e₁, e₂, ⋯, ?_⟩` and then tries
to close the goal with `with_reducible rfl` (which may or may not close it). It's
useful, for example, to advance on existential goals, for which terms as
well as proofs of some claims about them are expected.
Examples:
```lean
example : ∃ x : Nat, x = x := by use 42
example : ∃ x : Nat, ∃ y : Nat, x = y := by use 42, 42
example : ∃ x : String × String, x.1 = x.2 := by use ("forty-two", "forty-two")
```
-/
-- TODO extend examples in doc-string once mathlib3 parity is achieved.
macro "use " es:term,+ : tactic =>
`(tactic|(refine ⟨$es,*, ?_⟩; try with_reducible rfl))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.