Hoare triple specifications for select functions #
This module contains Hoare triple specifications for some functions in Core.
A pointer at a specific location in a list. List cursors are used in loop invariants for the
mvcgen tactic.
Moving the cursor to the left or right takes time linear in the current position of the cursor, so this data structure is not appropriate for run-time code.
- prefix : List α
The elements before to the current position in the list.
- suffix : List α
The elements starting at the current position. If the position is after the last element of the list, then the suffix is empty; otherwise, the first element of the suffix is the current element that the cursor points to.
Appending the prefix to the suffix yields the original list.
Instances For
Creates a cursor at position n in the list l.
The prefix contains the first n elements, and the suffix contains the remaining elements.
If n is larger than the length of the list, the cursor is positioned at the end of the list.
Instances For
@[reducible, inline]
Creates a cursor at the beginning of the list (position 0). The prefix is empty and the suffix is the entire list.
Equations
- List.Cursor.begin l = List.Cursor.at l 0
Instances For
@[reducible, inline]
Creates a cursor at the end of the list. The prefix is the entire list and the suffix is empty.
Equations
- List.Cursor.end l = List.Cursor.at l l.length
Instances For
def
List.Cursor.tail
{α✝ : Type u_1}
{l : List α✝}
(s : l.Cursor)
(h : 0 < s.suffix.length := by get_elem_tactic)
:
l.Cursor
Advances the cursor by one position, moving the current element from the suffix to the prefix.
Requires that the cursor is not already at the end of the list.
Equations
Instances For
theorem
Std.Do.Spec.monadMap_trans
{m : Type u → Type v}
{ps : PostShape}
{o : Type u → Type u_1}
{n : Type u → Type u_2}
{α : Type u}
{f : {β : Type u} → m β → m β}
{x : o α}
{Q : PostCond α ps}
[WP o ps]
[MonadFunctor n o]
[MonadFunctorT m n]
:
theorem
Std.Do.Spec.restoreM_StateT
{m : Type u → Type v}
{ps : PostShape}
{α σ : Type u}
{Q : PostCond α (PostShape.arg σ ps)}
[Monad m]
[WPMonad m ps]
(x : m (α × σ))
:
theorem
Std.Do.Spec.restoreM_ExceptT
{m : Type u → Type v}
{ps : PostShape}
{ε α : Type u}
{Q : PostCond α (PostShape.except ε ps)}
[Monad m]
[WPMonad m ps]
(x : m (Except ε α))
:
theorem
Std.Do.Spec.liftWith_trans
{m : Type u → Type v}
{ps : PostShape}
{o : Type u → Type u_1}
{n : Type u → Type u_2}
{α : Type u}
{Q : PostCond α ps}
[WP o ps]
[MonadControl n o]
[MonadControlT m n]
(f : ({β : Type u} → o β → m (stM m o β)) → m α)
:
theorem
Std.Do.Spec.throw_Except
{m : Type u → Type v}
{ps : PostShape}
{ε α : Type u_1}
{e : ε}
{Q : PostCond α (PostShape.except ε PostShape.pure)}
[Monad m]
[WPMonad m ps]
:
theorem
Std.Do.Spec.throw_Option
{m : Type u → Type v}
{ps : PostShape}
{α : Type}
{e : PUnit}
{Q : PostCond α (PostShape.except PUnit PostShape.pure)}
[Monad m]
[WPMonad m ps]
:
theorem
Std.Do.Spec.get_EStateM
{ε σ : Type u_1}
{Q : PostCond σ (PostShape.except ε (PostShape.arg σ PostShape.pure))}
:
theorem
Std.Do.Spec.set_EStateM
{ε σ : Type}
{s : σ}
{Q : PostCond PUnit (PostShape.except ε (PostShape.arg σ PostShape.pure))}
:
theorem
Std.Do.Spec.modifyGet_EStateM
{ε σ α : Type u_1}
{f : σ → α × σ}
{Q : PostCond α (PostShape.except ε (PostShape.arg σ PostShape.pure))}
:
theorem
Std.Do.Spec.throw_EStateM
{ε σ α : Type u_1}
{e : ε}
{Q : PostCond α (PostShape.except ε (PostShape.arg σ PostShape.pure))}
:
theorem
Std.Do.Spec.tryCatch_EStateM
{α ε σ : Type u_1}
{x : EStateM ε σ α}
{h : ε → EStateM ε σ α}
(Q : PostCond α (PostShape.except ε (PostShape.arg σ PostShape.pure)))
:
theorem
Std.Do.Spec.orElse_EStateM
{α ε σ : Type u_1}
{x : EStateM ε σ α}
{h : Unit → EStateM ε σ α}
(Q : PostCond α (PostShape.except ε (PostShape.arg σ PostShape.pure)))
:
theorem
Std.Do.Spec.adaptExcept_EStateM
{ε ε' α σ : Type u_1}
{x : EStateM ε σ α}
(f : ε → ε')
(Q : PostCond α (PostShape.except ε' (PostShape.arg σ PostShape.pure)))
:
Lifting MonadStateOf #
Lifting MonadReaderOf #
Lifting MonadExceptOf #
theorem
Std.Do.Spec.throw_ReaderT
{m : Type u → Type v}
{sh : PostShape}
{ε : Type u_1}
{ρ α : Type u}
{e : ε}
{Q : PostCond α (PostShape.arg ρ sh)}
[WP m sh]
[MonadExceptOf ε m]
:
theorem
Std.Do.Spec.throw_StateT
{m : Type u → Type v}
{ps : PostShape}
{ε : Type u_1}
{α σ : Type u}
{e : ε}
[WP m ps]
[Monad m]
[MonadExceptOf ε m]
(Q : PostCond α (PostShape.arg σ ps))
:
theorem
Std.Do.Spec.throw_ExceptT_lift
{m : Type u → Type v}
{ps : PostShape}
{ε α ε' : Type u}
{e : ε}
[WP m ps]
[MonadExceptOf ε m]
(Q : PostCond α (PostShape.except ε' ps))
:
theorem
Std.Do.Spec.throw_Option_lift
{m : Type u → Type v}
{ps : PostShape}
{ε α : Type u}
{e : ε}
[WP m ps]
[MonadExceptOf ε m]
(Q : PostCond α (PostShape.except PUnit ps))
:
⦃wp⟦MonadExceptOf.throw e⟧ (fun (o : Option α) => Option.casesOn o (Q.snd.fst PUnit.unit) Q.fst, Q.snd.snd)⦄ MonadExceptOf.throw e ⦃Q⦄
theorem
Std.Do.Spec.tryCatch_ReaderT
{m : Type u → Type v}
{ps : PostShape}
{ε : Type u_1}
{α ρ : Type u}
{x : ReaderT ρ m α}
{h : ε → ReaderT ρ m α}
[WP m ps]
[MonadExceptOf ε m]
(Q : PostCond α (PostShape.arg ρ ps))
:
theorem
Std.Do.Spec.tryCatch_StateT
{m : Type u → Type v}
{ps : PostShape}
{ε : Type u_1}
{α σ : Type u}
{x : StateT σ m α}
{h : ε → StateT σ m α}
[WP m ps]
[Monad m]
[MonadExceptOf ε m]
(Q : PostCond α (PostShape.arg σ ps))
:
theorem
Std.Do.Spec.tryCatch_ExceptT_lift
{m : Type u → Type v}
{ps : PostShape}
{ε α ε' : Type u}
{x : ExceptT ε' m α}
{h : ε → ExceptT ε' m α}
[WP m ps]
[MonadExceptOf ε m]
(Q : PostCond α (PostShape.except ε' ps))
:
theorem
Std.Do.Spec.tryCatch_OptionT_lift
{m : Type u → Type v}
{ps : PostShape}
{ε α : Type u}
{x : OptionT m α}
{h : ε → OptionT m α}
[WP m ps]
[MonadExceptOf ε m]
(Q : PostCond α (PostShape.except PUnit ps))
:
⦃wp⟦MonadExceptOf.tryCatch x h⟧ (fun (o : Option α) => Option.casesOn o (Q.snd.fst PUnit.unit) Q.fst, Q.snd.snd)⦄ MonadExceptOf.tryCatch x h ⦃Q⦄
@[reducible, inline]
abbrev
Std.Do.Invariant
{α : Type u₁}
(xs : List α)
(β : Type u₂)
(ps : PostShape)
:
Type (max u₂ u₁)
The type of loop invariants used by the specifications of for ... in ... loops.
A loop invariant is a PostCond that takes as parameters
- A
List.Cursor xsrepresenting the iteration state of the loop. It is parameterized by the list of elementsxsthat theforloop iterates over. - A state tuple of type
β, which will be a nesting ofMProds representing the elaboration oflet mutvariables and early return.
The loop specification lemmas will use this in the following way:
Before entering the loop, the cursor's prefix is empty and the suffix is xs.
After leaving the loop, the cursor's prefix is xs and the suffix is empty.
During the induction step, the invariant holds for a suffix with head element x.
After running the loop body, the invariant then holds after shifting x to the prefix.
Equations
- Std.Do.Invariant xs β ps = Std.Do.PostCond (xs.Cursor × β) ps
Instances For
@[reducible, inline]
abbrev
Std.Do.Invariant.withEarlyReturn
{β : Type (max u₁ u₂)}
{ps : PostShape}
{α✝ : Type (max u₁ u₂)}
{xs : List α✝}
{γ : Type (max u₁ u₂)}
(onContinue : xs.Cursor → β → Assertion ps)
(onReturn : γ → β → Assertion ps)
(onExcept : ExceptConds ps := ExceptConds.false)
:
Helper definition for specifying loop invariants for loops with early return.
for ... in ... loops with early return of type γ elaborate to a call like this:
forIn (β := MProd (Option γ) ...) (b := ⟨none, ...⟩) collection loopBody
Note that the first component of the MProd state tuple is the optional early return value.
It is none as long as there was no early return and some r if the loop returned early with r.
This function allows to specify different invariants for the loop body depending on whether the loop
terminated early or not. When there was an early return, the loop has effectively finished, which is
encoded by the additional ⌜xs.suffix = []⌝ assertion in the invariant. This assertion is vital for
successfully proving the induction step, as it contradicts with the assumption that
xs.suffix = x::rest of the inductive hypothesis at the start of the loop body, meaning that users
won't need to prove anything about the bogus case where the loop has returned early yet takes
another iteration of the loop body.
Equations
- One or more equations did not get rendered due to their size.
Instances For
theorem
Std.Do.Spec.forIn'_list
{α : Type u₁}
{β : Type (max u₁ u₂)}
{m : Type (max u₁ u₂) → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
{xs : List α}
{init : β}
{f : (a : α) → a ∈ xs → β → m (ForInStep β)}
(inv : Invariant xs β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur ⋯ b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn'_list_const_inv
{α : Type u₁}
{β : Type (max u₁ u₂)}
{m : Type (max u₁ u₂) → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
{xs : List α}
{init : β}
{f : (a : α) → a ∈ xs → β → m (ForInStep β)}
{inv : PostCond β ps}
(step :
∀ (x : α) (hx : x ∈ xs) (b : β),
⦃inv.fst b⦄ f x hx b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst b'
| ForInStep.done b' => inv.fst b', inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn_list
{α : Type u₁}
{β : Type (max u₁ u₂)}
{m : Type (max u₁ u₂) → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
{xs : List α}
{init : β}
{f : α → β → m (ForInStep β)}
(inv : Invariant xs β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn_list_const_inv
{α : Type u₁}
{β : Type (max u₁ u₂)}
{m : Type (max u₁ u₂) → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
{xs : List α}
{init : β}
{f : α → β → m (ForInStep β)}
{inv : PostCond β ps}
(step :
∀ (hd : α) (b : β),
⦃inv.fst b⦄ f hd b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst b'
| ForInStep.done b' => inv.fst b', inv.snd)⦄)
:
theorem
Std.Do.Spec.foldlM_list
{α : Type u₁}
{β : Type (max u₁ u₂)}
{m : Type (max u₁ u₂) → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
{xs : List α}
{init : β}
{f : β → α → m β}
(inv : Invariant xs β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f b cur ⦃(fun (b' : β) => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.foldlM_list_const_inv
{α : Type u₁}
{β : Type (max u₁ u₂)}
{m : Type (max u₁ u₂) → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
{xs : List α}
{init : β}
{f : β → α → m β}
{inv : PostCond β ps}
(step : ∀ (hd : α) (b : β), ⦃inv.fst b⦄ f b hd ⦃(fun (b' : β) => inv.fst b', inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn'_range
{β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
{xs : Legacy.Range}
{init : β}
{f : (a : Nat) → a ∈ xs → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List Nat) (cur : Nat) (suff : List Nat) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur ⋯ b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn_range
{β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
{xs : Legacy.Range}
{init : β}
{f : Nat → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List Nat) (cur : Nat) (suff : List Nat) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn'_rcc
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
[LE α]
[DecidableLE α]
[PRange.UpwardEnumerable α]
[Rxc.IsAlwaysFinite α]
[PRange.LawfulUpwardEnumerable α]
[PRange.LawfulUpwardEnumerableLE α]
{xs : Rcc α}
{init : β}
{f : (a : α) → a ∈ xs → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur ⋯ b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn_rcc
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
[LE α]
[DecidableLE α]
[PRange.UpwardEnumerable α]
[Rxc.IsAlwaysFinite α]
[PRange.LawfulUpwardEnumerable α]
[PRange.LawfulUpwardEnumerableLE α]
{xs : Rcc α}
{init : β}
{f : α → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn'_rco
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
[LE α]
[LT α]
[DecidableLT α]
[PRange.UpwardEnumerable α]
[Rxo.IsAlwaysFinite α]
[PRange.LawfulUpwardEnumerable α]
[PRange.LawfulUpwardEnumerableLE α]
[PRange.LawfulUpwardEnumerableLT α]
{xs : Rco α}
{init : β}
{f : (a : α) → a ∈ xs → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur ⋯ b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn_rco
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
[LE α]
[LT α]
[DecidableLT α]
[PRange.UpwardEnumerable α]
[Rxo.IsAlwaysFinite α]
[PRange.LawfulUpwardEnumerable α]
[PRange.LawfulUpwardEnumerableLE α]
[PRange.LawfulUpwardEnumerableLT α]
{xs : Rco α}
{init : β}
{f : α → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn'_rci
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
[LE α]
[PRange.UpwardEnumerable α]
[Rxi.IsAlwaysFinite α]
[PRange.LawfulUpwardEnumerable α]
[PRange.LawfulUpwardEnumerableLE α]
{xs : Rci α}
{init : β}
{f : (a : α) → a ∈ xs → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur ⋯ b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn_rci
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
[LE α]
[PRange.UpwardEnumerable α]
[Rxi.IsAlwaysFinite α]
[PRange.LawfulUpwardEnumerable α]
[PRange.LawfulUpwardEnumerableLE α]
{xs : Rci α}
{init : β}
{f : α → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn'_roc
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
[LE α]
[DecidableLE α]
[LT α]
[PRange.UpwardEnumerable α]
[Rxc.IsAlwaysFinite α]
[PRange.LawfulUpwardEnumerable α]
[PRange.LawfulUpwardEnumerableLE α]
[PRange.LawfulUpwardEnumerableLT α]
{xs : Roc α}
{init : β}
{f : (a : α) → a ∈ xs → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur ⋯ b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn_roc
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
[LE α]
[DecidableLE α]
[LT α]
[PRange.UpwardEnumerable α]
[Rxc.IsAlwaysFinite α]
[PRange.LawfulUpwardEnumerable α]
[PRange.LawfulUpwardEnumerableLE α]
[PRange.LawfulUpwardEnumerableLT α]
{xs : Roc α}
{init : β}
{f : α → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn'_roo
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
[LT α]
[DecidableLT α]
[PRange.UpwardEnumerable α]
[Rxo.IsAlwaysFinite α]
[PRange.LawfulUpwardEnumerable α]
[PRange.LawfulUpwardEnumerableLT α]
{xs : Roo α}
{init : β}
{f : (a : α) → a ∈ xs → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur ⋯ b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn_roo
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
[LT α]
[DecidableLT α]
[PRange.UpwardEnumerable α]
[Rxo.IsAlwaysFinite α]
[PRange.LawfulUpwardEnumerable α]
[PRange.LawfulUpwardEnumerableLT α]
{xs : Roo α}
{init : β}
{f : α → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn'_roi
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
[LT α]
[DecidableLT α]
[PRange.UpwardEnumerable α]
[Rxi.IsAlwaysFinite α]
[PRange.LawfulUpwardEnumerable α]
[PRange.LawfulUpwardEnumerableLT α]
{xs : Roi α}
{init : β}
{f : (a : α) → a ∈ xs → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur ⋯ b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn_roi
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
[LT α]
[DecidableLT α]
[PRange.UpwardEnumerable α]
[Rxi.IsAlwaysFinite α]
[PRange.LawfulUpwardEnumerable α]
[PRange.LawfulUpwardEnumerableLT α]
{xs : Roi α}
{init : β}
{f : α → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn'_ric
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
[PRange.Least? α]
[LE α]
[DecidableLE α]
[PRange.UpwardEnumerable α]
[Rxc.IsAlwaysFinite α]
[PRange.LawfulUpwardEnumerable α]
[PRange.LawfulUpwardEnumerableLeast? α]
[PRange.LawfulUpwardEnumerableLE α]
{xs : Ric α}
{init : β}
{f : (a : α) → a ∈ xs → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur ⋯ b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn_ric
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
[PRange.Least? α]
[LE α]
[DecidableLE α]
[PRange.UpwardEnumerable α]
[Rxc.IsAlwaysFinite α]
[PRange.LawfulUpwardEnumerable α]
[PRange.LawfulUpwardEnumerableLeast? α]
[PRange.LawfulUpwardEnumerableLE α]
{xs : Ric α}
{init : β}
{f : α → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn'_rio
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
[PRange.Least? α]
[LT α]
[DecidableLT α]
[PRange.UpwardEnumerable α]
[Rxo.IsAlwaysFinite α]
[PRange.LawfulUpwardEnumerable α]
[PRange.LawfulUpwardEnumerableLeast? α]
[PRange.LawfulUpwardEnumerableLT α]
{xs : Rio α}
{init : β}
{f : (a : α) → a ∈ xs → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur ⋯ b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn_rio
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
[PRange.Least? α]
[LT α]
[DecidableLT α]
[PRange.UpwardEnumerable α]
[Rxo.IsAlwaysFinite α]
[PRange.LawfulUpwardEnumerable α]
[PRange.LawfulUpwardEnumerableLeast? α]
[PRange.LawfulUpwardEnumerableLT α]
{xs : Rio α}
{init : β}
{f : α → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn'_rii
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
[PRange.Least? α]
[PRange.UpwardEnumerable α]
[Rxi.IsAlwaysFinite α]
[PRange.LawfulUpwardEnumerable α]
[PRange.LawfulUpwardEnumerableLeast? α]
{xs : Rii α}
{init : β}
{f : (a : α) → a ∈ xs → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur ⋯ b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn_rii
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
[PRange.Least? α]
[PRange.UpwardEnumerable α]
[Rxi.IsAlwaysFinite α]
[PRange.LawfulUpwardEnumerable α]
[PRange.LawfulUpwardEnumerableLeast? α]
{xs : Rii α}
{init : β}
{f : α → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn_slice
{m : Type w → Type x}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
{γ : Type u}
{α β : Type w}
[LawfulMonad m]
{δ : Type w}
[ToIterator (Slice γ) Id α β]
[Iterator α Id β]
[IteratorLoop α Id m]
[LawfulIteratorLoop α Id m]
[Iterators.Finite α Id]
{init : δ}
{f : β → δ → m (ForInStep δ)}
{xs : Slice γ}
(inv : Invariant xs.toList δ ps)
(step :
∀ (pref : List β) (cur : β) (suff : List β) (h : xs.toList = pref ++ cur :: suff) (b : δ),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur b ⦃(fun (r : ForInStep δ) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn_iter
{n : Type (max u_1 u_2) → Type u_3}
{ps : PostShape}
[Monad n]
[WPMonad n ps]
{α β : Type u_2}
{γ : Type (max u_1 u_2)}
[Iterator α Id β]
[Iterators.Finite α Id]
[IteratorLoop α Id n]
[LawfulIteratorLoop α Id n]
{init : γ}
{f : β → γ → n (ForInStep γ)}
{it : Iter β}
(inv : Invariant it.toList γ ps)
(step :
∀ (pref : List β) (cur : β) (suff : List β) (h : it.toList = pref ++ cur :: suff) (b : γ),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur b ⦃(fun (r : ForInStep γ) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := it.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn_iterM_id
{n : Type (max u_1 u_2) → Type u_3}
{ps : PostShape}
[Monad n]
[WPMonad n ps]
{α β γ : Type (max u_1 u_2)}
[Iterator α Id β]
[Iterators.Finite α Id]
[IteratorLoop α Id n]
[LawfulIteratorLoop α Id n]
{init : γ}
{f : β → γ → n (ForInStep γ)}
{it : IterM Id β}
(inv : Invariant it.toList.run γ ps)
(step :
∀ (pref : List β) (cur : β) (suff : List β) (h : it.toList.run = pref ++ cur :: suff) (b : γ),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur b ⦃(fun (r : ForInStep γ) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := it.toList.run, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.foldM_iter
{n : Type (max u_1 u_2) → Type u_3}
{ps : PostShape}
[Monad n]
[WPMonad n ps]
{α β : Type u_2}
{γ : Type (max u_1 u_2)}
[Iterator α Id β]
[Iterators.Finite α Id]
[IteratorLoop α Id n]
[LawfulIteratorLoop α Id n]
{it : Iter β}
{init : γ}
{f : γ → β → n γ}
(inv : Invariant it.toList γ ps)
(step :
∀ (pref : List β) (cur : β) (suff : List β) (h : it.toList = pref ++ cur :: suff) (b : γ),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f b cur ⦃(fun (b' : γ) => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.foldM_iterM_id
{n : Type (max u_1 u_2) → Type u_3}
{ps : PostShape}
[Monad n]
[WPMonad n ps]
{α β γ : Type (max u_1 u_2)}
[Iterator α Id β]
[Iterators.Finite α Id]
[IteratorLoop α Id n]
[LawfulIteratorLoop α Id n]
{it : IterM Id β}
{init : γ}
{f : γ → β → n γ}
(inv : Invariant it.toList.run γ ps)
(step :
∀ (pref : List β) (cur : β) (suff : List β) (h : it.toList.run = pref ++ cur :: suff) (b : γ),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f b cur ⦃(fun (b' : γ) => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.IterM.forIn_filterMapWithPostcondition
{α : Type u₁}
{n : Type u₁ → Type u_1}
{o : Type u₁ → Type u_2}
{β₂ γ : Type u₁}
{m : Type u₁ → Type u_3}
{β : Type u₁}
{ps : PostShape}
[Monad m]
[LawfulMonad m]
[Monad n]
[LawfulMonad n]
[Monad o]
[LawfulMonad o]
[WPMonad o ps]
[MonadLiftT m n]
[LawfulMonadLiftT m n]
[MonadLiftT n o]
[LawfulMonadLiftT n o]
[Iterator α m β]
[Iterators.Finite α m]
[IteratorLoop α m o]
[LawfulIteratorLoop α m o]
{it : IterM m β}
{f : β → Iterators.PostconditionT n (Option β₂)}
{init : γ}
{g : β₂ → γ → o (ForInStep γ)}
{P : Assertion ps}
{Q : PostCond γ ps}
(h :
⦃P⦄ forIn it init fun (out : β) (acc : γ) => do
let __do_lift ← liftM (f out).run
match __do_lift with
| some c => g c acc
| none => Pure.pure (ForInStep.yield acc) ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.forIn_filterMapM
{α : Type u₁}
{n : Type u₁ → Type u_1}
{o : Type u₁ → Type u_2}
{β₂ γ : Type u₁}
{m : Type u₁ → Type u_3}
{β : Type u₁}
{ps : PostShape}
[Monad m]
[LawfulMonad m]
[Monad n]
[LawfulMonad n]
[Monad o]
[LawfulMonad o]
[WPMonad o ps]
[MonadAttach n]
[WeaklyLawfulMonadAttach n]
[MonadLiftT m n]
[LawfulMonadLiftT m n]
[MonadLiftT n o]
[LawfulMonadLiftT n o]
[Iterator α m β]
[Iterators.Finite α m]
[IteratorLoop α m o]
[LawfulIteratorLoop α m o]
{it : IterM m β}
{f : β → n (Option β₂)}
{init : γ}
{g : β₂ → γ → o (ForInStep γ)}
{P : Assertion ps}
{Q : PostCond γ ps}
(h :
⦃P⦄ forIn it init fun (out : β) (acc : γ) => do
let __do_lift ← liftM (f out)
match __do_lift with
| some c => g c acc
| none => Pure.pure (ForInStep.yield acc) ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.forIn_filterMap
{α : Type u₁}
{n : Type u₁ → Type u_1}
{β₂ γ : Type u₁}
{m : Type u₁ → Type u_2}
{β : Type u₁}
{ps : PostShape}
[Monad m]
[LawfulMonad m]
[Monad n]
[LawfulMonad n]
[WPMonad n ps]
[MonadLiftT m n]
[LawfulMonadLiftT m n]
[Iterator α m β]
[Iterators.Finite α m]
[IteratorLoop α m n]
[LawfulIteratorLoop α m n]
{it : IterM m β}
{f : β → Option β₂}
{init : γ}
{g : β₂ → γ → n (ForInStep γ)}
{P : Assertion ps}
{Q : PostCond γ ps}
(h :
⦃P⦄ forIn it init fun (out : β) (acc : γ) =>
match f out with
| some c => g c acc
| none => Pure.pure (ForInStep.yield acc) ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.forIn_mapWithPostcondition
{α : Type u₁}
{n : Type u₁ → Type u_1}
{o : Type u₁ → Type u_2}
{β₂ γ : Type u₁}
{m : Type u₁ → Type u_3}
{β : Type u₁}
{ps : PostShape}
[Monad m]
[LawfulMonad m]
[Monad n]
[LawfulMonad n]
[Monad o]
[LawfulMonad o]
[WPMonad o ps]
[MonadLiftT m n]
[LawfulMonadLiftT m n]
[MonadLiftT n o]
[LawfulMonadLiftT n o]
[Iterator α m β]
[Iterators.Finite α m]
[IteratorLoop α m o]
[LawfulIteratorLoop α m o]
{it : IterM m β}
{f : β → Iterators.PostconditionT n β₂}
{init : γ}
{g : β₂ → γ → o (ForInStep γ)}
{P : Assertion ps}
{Q : PostCond γ ps}
(h :
⦃P⦄ forIn it init fun (out : β) (acc : γ) => do
let __do_lift ← liftM (f out).run
g __do_lift acc ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.forIn_mapM
{α : Type u₁}
{n : Type u₁ → Type u_1}
{o : Type u₁ → Type u_2}
{β₂ γ : Type u₁}
{m : Type u₁ → Type u_3}
{β : Type u₁}
{ps : PostShape}
[Monad m]
[LawfulMonad m]
[Monad n]
[LawfulMonad n]
[Monad o]
[LawfulMonad o]
[WPMonad o ps]
[MonadAttach n]
[WeaklyLawfulMonadAttach n]
[MonadLiftT m n]
[LawfulMonadLiftT m n]
[MonadLiftT n o]
[LawfulMonadLiftT n o]
[Iterator α m β]
[Iterators.Finite α m]
[IteratorLoop α m o]
[LawfulIteratorLoop α m o]
{it : IterM m β}
{f : β → n β₂}
{init : γ}
{g : β₂ → γ → o (ForInStep γ)}
{P : Assertion ps}
{Q : PostCond γ ps}
(h :
⦃P⦄ forIn it init fun (out : β) (acc : γ) => do
let __do_lift ← liftM (f out)
g __do_lift acc ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.forIn_map
{α : Type u₁}
{n : Type u₁ → Type u_1}
{β₂ γ : Type u₁}
{m : Type u₁ → Type u_2}
{β : Type u₁}
{ps : PostShape}
[Monad m]
[LawfulMonad m]
[Monad n]
[LawfulMonad n]
[WPMonad n ps]
[MonadLiftT m n]
[LawfulMonadLiftT m n]
[Iterator α m β]
[Iterators.Finite α m]
[IteratorLoop α m n]
[LawfulIteratorLoop α m n]
{it : IterM m β}
{f : β → β₂}
{init : γ}
{g : β₂ → γ → n (ForInStep γ)}
{P : Assertion ps}
{Q : PostCond γ ps}
(h : ⦃P⦄ forIn it init fun (out : β) (acc : γ) => g (f out) acc ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.forIn_filterWithPostcondition
{α : Type u₁}
{n : Type u₁ → Type u_1}
{o : Type u₁ → Type u_2}
{γ : Type u₁}
{m : Type u₁ → Type u_3}
{β : Type u₁}
{ps : PostShape}
[Monad m]
[LawfulMonad m]
[Monad n]
[LawfulMonad n]
[Monad o]
[LawfulMonad o]
[WPMonad o ps]
[MonadLiftT m n]
[LawfulMonadLiftT m n]
[MonadLiftT n o]
[LawfulMonadLiftT n o]
[Iterator α m β]
[Iterators.Finite α m]
[IteratorLoop α m o]
[LawfulIteratorLoop α m o]
{it : IterM m β}
{f : β → Iterators.PostconditionT n (ULift Bool)}
{init : γ}
{g : β → γ → o (ForInStep γ)}
{P : Assertion ps}
{Q : PostCond γ ps}
(h :
⦃P⦄ forIn it init fun (out : β) (acc : γ) => do
let __do_lift ← liftM (f out).run
if __do_lift.down = true then g out acc else Pure.pure (ForInStep.yield acc) ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.forIn_filterM
{α : Type u₁}
{n : Type u₁ → Type u_1}
{o : Type u₁ → Type u_2}
{γ : Type u₁}
{m : Type u₁ → Type u_3}
{β : Type u₁}
{ps : PostShape}
[Monad m]
[LawfulMonad m]
[Monad n]
[LawfulMonad n]
[Monad o]
[LawfulMonad o]
[WPMonad o ps]
[MonadAttach n]
[WeaklyLawfulMonadAttach n]
[MonadLiftT m n]
[LawfulMonadLiftT m n]
[MonadLiftT n o]
[LawfulMonadLiftT n o]
[Iterator α m β]
[Iterators.Finite α m]
[IteratorLoop α m o]
[LawfulIteratorLoop α m o]
{it : IterM m β}
{f : β → n (ULift Bool)}
{init : γ}
{g : β → γ → o (ForInStep γ)}
{P : Assertion ps}
{Q : PostCond γ ps}
(h :
⦃P⦄ forIn it init fun (out : β) (acc : γ) => do
let __do_lift ← liftM (f out)
if __do_lift.down = true then g out acc else Pure.pure (ForInStep.yield acc) ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.forIn_filter
{α : Type u₁}
{n : Type u₁ → Type u_1}
{γ : Type u₁}
{m : Type u₁ → Type u_2}
{β : Type u₁}
{ps : PostShape}
[Monad m]
[LawfulMonad m]
[Monad n]
[LawfulMonad n]
[WPMonad n ps]
[MonadLiftT m n]
[LawfulMonadLiftT m n]
[Iterator α m β]
[Iterators.Finite α m]
[IteratorLoop α m n]
[LawfulIteratorLoop α m n]
{it : IterM m β}
{f : β → Bool}
{init : γ}
{g : β → γ → n (ForInStep γ)}
{P : Assertion ps}
{Q : PostCond γ ps}
(h :
⦃P⦄ forIn it init fun (out : β) (acc : γ) => if f out = true then g out acc else Pure.pure (ForInStep.yield acc) ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.foldM_filterMapWithPostcondition
{α β γ δ : Type w}
{ps : PostShape}
{m : Type w → Type w'}
{n : Type w → Type w''}
{o : Type w → Type w'''}
[Iterator α m β]
[Iterators.Finite α m]
[Monad m]
[Monad n]
[Monad o]
[LawfulMonad m]
[LawfulMonad n]
[LawfulMonad o]
[WPMonad o ps]
[IteratorLoop α m n]
[IteratorLoop α m o]
[LawfulIteratorLoop α m n]
[LawfulIteratorLoop α m o]
[MonadLiftT m n]
[MonadLiftT n o]
[LawfulMonadLiftT m n]
[LawfulMonadLiftT n o]
{f : β → Iterators.PostconditionT n (Option γ)}
{g : δ → γ → o δ}
{init : δ}
{it : IterM m β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ IterM.foldM
(fun (d : δ) (b : β) => do
let __discr ← liftM (f b).run
match __discr with
| some c => g d c
| x => Pure.pure d)
init it ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.foldM_filterMapM
{α β γ δ : Type w}
{ps : PostShape}
{m : Type w → Type w'}
{n : Type w → Type w''}
{o : Type w → Type w'''}
[Iterator α m β]
[Iterators.Finite α m]
[Monad m]
[LawfulMonad m]
[Monad n]
[MonadAttach n]
[LawfulMonad n]
[WeaklyLawfulMonadAttach n]
[Monad o]
[LawfulMonad o]
[WPMonad o ps]
[IteratorLoop α m n]
[IteratorLoop α m o]
[LawfulIteratorLoop α m n]
[LawfulIteratorLoop α m o]
[MonadLiftT m n]
[MonadLiftT n o]
[LawfulMonadLiftT m n]
[LawfulMonadLiftT n o]
{f : β → n (Option γ)}
{g : δ → γ → o δ}
{init : δ}
{it : IterM m β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ IterM.foldM
(fun (d : δ) (b : β) => do
let __discr ← liftM (f b)
match __discr with
| some c => g d c
| x => Pure.pure d)
init it ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.foldM_mapWithPostcondition
{α β γ δ : Type w}
{ps : PostShape}
{m : Type w → Type w'}
{n : Type w → Type w''}
{o : Type w → Type w'''}
[Iterator α m β]
[Iterators.Finite α m]
[Monad m]
[Monad n]
[Monad o]
[LawfulMonad m]
[LawfulMonad n]
[LawfulMonad o]
[WPMonad o ps]
[IteratorLoop α m n]
[IteratorLoop α m o]
[LawfulIteratorLoop α m n]
[LawfulIteratorLoop α m o]
[MonadLiftT m n]
[MonadLiftT n o]
[LawfulMonadLiftT m n]
[LawfulMonadLiftT n o]
{f : β → Iterators.PostconditionT n γ}
{g : δ → γ → o δ}
{init : δ}
{it : IterM m β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ IterM.foldM
(fun (d : δ) (b : β) => do
let c ← liftM (f b).run
g d c)
init it ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.foldM_mapM
{α β γ δ : Type w}
{ps : PostShape}
{m : Type w → Type w'}
{n : Type w → Type w''}
{o : Type w → Type w'''}
[Iterator α m β]
[Iterators.Finite α m]
[Monad m]
[LawfulMonad m]
[Monad n]
[MonadAttach n]
[LawfulMonad n]
[WeaklyLawfulMonadAttach n]
[Monad o]
[LawfulMonad o]
[WPMonad o ps]
[IteratorLoop α m n]
[IteratorLoop α m o]
[LawfulIteratorLoop α m n]
[LawfulIteratorLoop α m o]
[MonadLiftT m n]
[MonadLiftT n o]
[LawfulMonadLiftT m n]
[LawfulMonadLiftT n o]
{f : β → n γ}
{g : δ → γ → o δ}
{init : δ}
{it : IterM m β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ IterM.foldM
(fun (d : δ) (b : β) => do
let c ← liftM (f b)
g d c)
init it ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.foldM_filterWithPostcondition
{α β δ : Type w}
{ps : PostShape}
{m : Type w → Type w'}
{n : Type w → Type w''}
{o : Type w → Type w'''}
[Iterator α m β]
[Iterators.Finite α m]
[Monad m]
[Monad n]
[Monad o]
[LawfulMonad m]
[LawfulMonad n]
[LawfulMonad o]
[WPMonad o ps]
[IteratorLoop α m n]
[IteratorLoop α m o]
[LawfulIteratorLoop α m n]
[LawfulIteratorLoop α m o]
[MonadLiftT m n]
[MonadLiftT n o]
[LawfulMonadLiftT m n]
[LawfulMonadLiftT n o]
{f : β → Iterators.PostconditionT n (ULift Bool)}
{g : δ → β → o δ}
{init : δ}
{it : IterM m β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ IterM.foldM
(fun (d : δ) (b : β) => do
let __do_lift ← liftM (f b).run
if __do_lift.down = true then g d b else Pure.pure d)
init it ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.foldM_filterM
{α β δ : Type w}
{ps : PostShape}
{m : Type w → Type w'}
{n : Type w → Type w''}
{o : Type w → Type w'''}
[Iterator α m β]
[Iterators.Finite α m]
[Monad m]
[LawfulMonad m]
[Monad n]
[MonadAttach n]
[LawfulMonad n]
[WeaklyLawfulMonadAttach n]
[Monad o]
[LawfulMonad o]
[WPMonad o ps]
[IteratorLoop α m n]
[IteratorLoop α m o]
[LawfulIteratorLoop α m n]
[LawfulIteratorLoop α m o]
[MonadLiftT m n]
[MonadLiftT n o]
[LawfulMonadLiftT m n]
[LawfulMonadLiftT n o]
{f : β → n (ULift Bool)}
{g : δ → β → o δ}
{init : δ}
{it : IterM m β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ IterM.foldM
(fun (d : δ) (b : β) => do
let __do_lift ← liftM (f b)
if __do_lift.down = true then g d b else Pure.pure d)
init it ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.foldM_filterMap
{α β γ δ : Type w}
{m : Type w → Type w'}
{n : Type w → Type w''}
{ps : PostShape}
[Iterator α m β]
[Iterators.Finite α m]
[Monad m]
[Monad n]
[LawfulMonad m]
[LawfulMonad n]
[WPMonad n ps]
[IteratorLoop α m n]
[LawfulIteratorLoop α m n]
[MonadLiftT m n]
[LawfulMonadLiftT m n]
{f : β → Option γ}
{g : δ → γ → n δ}
{init : δ}
{it : IterM m β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ IterM.foldM
(fun (d : δ) (b : β) =>
match f b with
| some c => g d c
| x => Pure.pure d)
init it ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.foldM_map
{α β γ δ : Type w}
{m : Type w → Type w'}
{n : Type w → Type w''}
{ps : PostShape}
[Iterator α m β]
[Iterators.Finite α m]
[Monad m]
[Monad n]
[LawfulMonad m]
[LawfulMonad n]
[WPMonad n ps]
[IteratorLoop α m n]
[LawfulIteratorLoop α m n]
[MonadLiftT m n]
[LawfulMonadLiftT m n]
{f : β → γ}
{g : δ → γ → n δ}
{init : δ}
{it : IterM m β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h : ⦃P⦄ IterM.foldM (fun (d : δ) (b : β) => g d (f b)) init it ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.foldM_filter
{α β δ : Type w}
{m : Type w → Type w'}
{n : Type w → Type w''}
{ps : PostShape}
[Iterator α m β]
[Iterators.Finite α m]
[Monad m]
[Monad n]
[LawfulMonad m]
[LawfulMonad n]
[WPMonad n ps]
[IteratorLoop α m n]
[LawfulIteratorLoop α m n]
[MonadLiftT m n]
[LawfulMonadLiftT m n]
{f : β → Bool}
{g : δ → β → n δ}
{init : δ}
{it : IterM m β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h : ⦃P⦄ IterM.foldM (fun (d : δ) (b : β) => if f b = true then g d b else Pure.pure d) init it ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.fold_filterMapWithPostcondition
{α β γ δ : Type w}
{m : Type w → Type w'}
{ps : PostShape}
{n : Type w → Type w''}
[Iterator α m β]
[Iterators.Finite α m]
[Monad m]
[LawfulMonad m]
[Monad n]
[LawfulMonad n]
[WPMonad n ps]
[IteratorLoop α m n]
[LawfulIteratorLoop α m n]
[MonadLiftT m n]
[LawfulMonadLiftT m n]
{f : β → Iterators.PostconditionT n (Option γ)}
{g : δ → γ → δ}
{init : δ}
{it : IterM m β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ IterM.foldM
(fun (d : δ) (b : β) => do
let __discr ← (f b).run
match __discr with
| some c => Pure.pure (g d c)
| x => Pure.pure d)
init it ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.fold_filterMapM
{α β γ δ : Type w}
{m : Type w → Type w'}
{n : Type w → Type w''}
{ps : PostShape}
[Iterator α m β]
[Iterators.Finite α m]
[Monad m]
[LawfulMonad m]
[Monad n]
[MonadAttach n]
[LawfulMonad n]
[WeaklyLawfulMonadAttach n]
[WPMonad n ps]
[IteratorLoop α m n]
[LawfulIteratorLoop α m n]
[MonadLiftT m n]
[LawfulMonadLiftT m n]
{f : β → n (Option γ)}
{g : δ → γ → δ}
{init : δ}
{it : IterM m β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ IterM.foldM
(fun (d : δ) (b : β) => do
let __discr ← f b
match __discr with
| some c => Pure.pure (g d c)
| x => Pure.pure d)
init it ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.fold_mapWithPostcondition
{α β γ δ : Type w}
{m : Type w → Type w'}
{n : Type w → Type w''}
{ps : PostShape}
[Iterator α m β]
[Iterators.Finite α m]
[Monad m]
[LawfulMonad m]
[Monad n]
[LawfulMonad n]
[WPMonad n ps]
[IteratorLoop α m n]
[LawfulIteratorLoop α m n]
[MonadLiftT m n]
[LawfulMonadLiftT m n]
{f : β → Iterators.PostconditionT n γ}
{g : δ → γ → δ}
{init : δ}
{it : IterM m β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ IterM.foldM
(fun (d : δ) (b : β) => do
let c ← (f b).run
Pure.pure (g d c))
init it ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.fold_mapM
{α β γ δ : Type w}
{m : Type w → Type w'}
{n : Type w → Type w''}
{ps : PostShape}
[Iterator α m β]
[Iterators.Finite α m]
[Monad m]
[LawfulMonad m]
[Monad n]
[MonadAttach n]
[LawfulMonad n]
[WeaklyLawfulMonadAttach n]
[WPMonad n ps]
[IteratorLoop α m n]
[LawfulIteratorLoop α m n]
[MonadLiftT m n]
[LawfulMonadLiftT m n]
{f : β → n γ}
{g : δ → γ → δ}
{init : δ}
{it : IterM m β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ IterM.foldM
(fun (d : δ) (b : β) => do
let c ← f b
Pure.pure (g d c))
init it ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.fold_filterWithPostcondition
{α β δ : Type w}
{m : Type w → Type w'}
{ps : PostShape}
{n : Type w → Type w''}
[Iterator α m β]
[Iterators.Finite α m]
[Monad m]
[LawfulMonad m]
[Monad n]
[LawfulMonad n]
[WPMonad n ps]
[IteratorLoop α m n]
[LawfulIteratorLoop α m n]
[MonadLiftT m n]
[LawfulMonadLiftT m n]
{f : β → Iterators.PostconditionT n (ULift Bool)}
{g : δ → β → δ}
{init : δ}
{it : IterM m β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ IterM.foldM
(fun (d : δ) (b : β) => do
let __do_lift ← (f b).run
Pure.pure (if __do_lift.down = true then g d b else d))
init it ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.fold_filterM
{α β δ : Type w}
{m : Type w → Type w'}
{n : Type w → Type w''}
{ps : PostShape}
[Iterator α m β]
[Iterators.Finite α m]
[Monad m]
[LawfulMonad m]
[Monad n]
[MonadAttach n]
[LawfulMonad n]
[WeaklyLawfulMonadAttach n]
[WPMonad n ps]
[IteratorLoop α m n]
[LawfulIteratorLoop α m n]
[MonadLiftT m n]
[LawfulMonadLiftT m n]
{f : β → n (ULift Bool)}
{g : δ → β → δ}
{init : δ}
{it : IterM m β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ IterM.foldM
(fun (d : δ) (b : β) => do
let __do_lift ← f b
Pure.pure (if __do_lift.down = true then g d b else d))
init it ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.fold_filterMap
{α β γ δ : Type w}
{m : Type w → Type w'}
{ps : PostShape}
[Iterator α m β]
[Iterators.Finite α m]
[Monad m]
[LawfulMonad m]
[WPMonad m ps]
[IteratorLoop α m m]
[LawfulIteratorLoop α m m]
{f : β → Option γ}
{g : δ → γ → δ}
{init : δ}
{it : IterM m β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ IterM.fold
(fun (d : δ) (b : β) =>
match f b with
| some c => g d c
| x => d)
init it ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.fold_map
{α β γ δ : Type w}
{m : Type w → Type w'}
{ps : PostShape}
[Iterator α m β]
[Iterators.Finite α m]
[Monad m]
[LawfulMonad m]
[WPMonad m ps]
[IteratorLoop α m m]
[LawfulIteratorLoop α m m]
{f : β → γ}
{g : δ → γ → δ}
{init : δ}
{it : IterM m β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h : ⦃P⦄ IterM.fold (fun (d : δ) (b : β) => g d (f b)) init it ⦃Q⦄)
:
theorem
Std.Do.Spec.IterM.fold_filter
{α β δ : Type w}
{m : Type w → Type w'}
{ps : PostShape}
[Iterator α m β]
[Iterators.Finite α m]
[Monad m]
[LawfulMonad m]
[WPMonad m ps]
[IteratorLoop α m m]
[LawfulIteratorLoop α m m]
{f : β → Bool}
{g : δ → β → δ}
{init : δ}
{it : IterM m β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h : ⦃P⦄ IterM.fold (fun (d : δ) (b : β) => if f b = true then g d b else d) init it ⦃Q⦄)
:
theorem
Std.Do.Spec.Iter.forIn_filterMapWithPostcondition
{α β β₂ γ : Type w}
[Iterator α Id β]
{ps : PostShape}
{n : Type w → Type u_1}
{o : Type w → Type u_2}
[Monad n]
[LawfulMonad n]
[Monad o]
[LawfulMonad o]
[WPMonad o ps]
[MonadLiftT n o]
[LawfulMonadLiftT n o]
[Iterators.Finite α Id]
[IteratorLoop α Id o]
[LawfulIteratorLoop α Id o]
{it : Iter β}
{f : β → Iterators.PostconditionT n (Option β₂)}
{init : γ}
{g : β₂ → γ → o (ForInStep γ)}
{P : Assertion ps}
{Q : PostCond γ ps}
(h :
⦃P⦄ forIn it init fun (out : β) (acc : γ) => do
let __do_lift ← liftM (f out).run
match __do_lift with
| some c => g c acc
| none => Pure.pure (ForInStep.yield acc) ⦃Q⦄)
:
theorem
Std.Do.Spec.Iter.forIn_filterMapM
{α β β₂ γ : Type w}
[Iterator α Id β]
{ps : PostShape}
{n : Type w → Type u_1}
{o : Type w → Type u_2}
[Monad n]
[LawfulMonad n]
[Monad o]
[LawfulMonad o]
[WPMonad o ps]
[MonadAttach n]
[WeaklyLawfulMonadAttach n]
[MonadLiftT n o]
[LawfulMonadLiftT n o]
[Iterators.Finite α Id]
[IteratorLoop α Id o]
[LawfulIteratorLoop α Id o]
{it : Iter β}
{f : β → n (Option β₂)}
{init : γ}
{g : β₂ → γ → o (ForInStep γ)}
{P : Assertion ps}
{Q : PostCond γ ps}
(h :
⦃P⦄ forIn it init fun (out : β) (acc : γ) => do
let __do_lift ← liftM (f out)
match __do_lift with
| some c => g c acc
| none => Pure.pure (ForInStep.yield acc) ⦃Q⦄)
:
theorem
Std.Do.Spec.Iter.forIn_filterMap
{α β β₂ γ : Type w}
[Iterator α Id β]
{ps : PostShape}
{n : Type w → Type u_1}
[Monad n]
[LawfulMonad n]
[WPMonad n ps]
[Iterators.Finite α Id]
[IteratorLoop α Id n]
[LawfulIteratorLoop α Id n]
{it : Iter β}
{f : β → Option β₂}
{init : γ}
{g : β₂ → γ → n (ForInStep γ)}
{P : Assertion ps}
{Q : PostCond γ ps}
(h :
⦃P⦄ forIn it init fun (out : β) (acc : γ) =>
match f out with
| some c => g c acc
| none => Pure.pure (ForInStep.yield acc) ⦃Q⦄)
:
theorem
Std.Do.Spec.Iter.forIn_mapWithPostcondition
{α β β₂ γ : Type w}
[Iterator α Id β]
{ps : PostShape}
{n : Type w → Type u_1}
{o : Type w → Type u_2}
[Monad n]
[LawfulMonad n]
[Monad o]
[LawfulMonad o]
[WPMonad o ps]
[MonadLiftT n o]
[LawfulMonadLiftT n o]
[Iterators.Finite α Id]
[IteratorLoop α Id o]
[LawfulIteratorLoop α Id o]
{it : Iter β}
{f : β → Iterators.PostconditionT n β₂}
{init : γ}
{g : β₂ → γ → o (ForInStep γ)}
{P : Assertion ps}
{Q : PostCond γ ps}
(h :
⦃P⦄ forIn it init fun (out : β) (acc : γ) => do
let __do_lift ← liftM (f out).run
g __do_lift acc ⦃Q⦄)
:
theorem
Std.Do.Spec.Iter.forIn_mapM
{α β β₂ γ : Type w}
[Iterator α Id β]
{ps : PostShape}
{n : Type w → Type u_1}
{o : Type w → Type u_2}
[Monad n]
[LawfulMonad n]
[Monad o]
[LawfulMonad o]
[WPMonad o ps]
[MonadAttach n]
[WeaklyLawfulMonadAttach n]
[MonadLiftT n o]
[LawfulMonadLiftT n o]
[Iterators.Finite α Id]
[IteratorLoop α Id o]
[LawfulIteratorLoop α Id o]
{it : Iter β}
{f : β → n β₂}
{init : γ}
{g : β₂ → γ → o (ForInStep γ)}
{P : Assertion ps}
{Q : PostCond γ ps}
(h :
⦃P⦄ forIn it init fun (out : β) (acc : γ) => do
let __do_lift ← liftM (f out)
g __do_lift acc ⦃Q⦄)
:
theorem
Std.Do.Spec.Iter.forIn_map
{α β β₂ γ : Type w}
[Iterator α Id β]
{ps : PostShape}
{n : Type w → Type u_1}
[Monad n]
[LawfulMonad n]
[WPMonad n ps]
[Iterators.Finite α Id]
[IteratorLoop α Id n]
[LawfulIteratorLoop α Id n]
{it : Iter β}
{f : β → β₂}
{init : γ}
{g : β₂ → γ → n (ForInStep γ)}
{P : Assertion ps}
{Q : PostCond γ ps}
(h : ⦃P⦄ forIn it init fun (out : β) (acc : γ) => g (f out) acc ⦃Q⦄)
:
theorem
Std.Do.Spec.Iter.forIn_filterWithPostcondition
{α β γ : Type w}
[Iterator α Id β]
{ps : PostShape}
{n : Type w → Type u_1}
{o : Type w → Type u_2}
[Monad n]
[LawfulMonad n]
[Monad o]
[LawfulMonad o]
[WPMonad o ps]
[MonadLiftT n o]
[LawfulMonadLiftT n o]
[Iterators.Finite α Id]
[IteratorLoop α Id o]
[LawfulIteratorLoop α Id o]
{it : Iter β}
{f : β → Iterators.PostconditionT n (ULift Bool)}
{init : γ}
{g : β → γ → o (ForInStep γ)}
{P : Assertion ps}
{Q : PostCond γ ps}
(h :
⦃P⦄ forIn it init fun (out : β) (acc : γ) => do
let __do_lift ← liftM (f out).run
if __do_lift.down = true then g out acc else Pure.pure (ForInStep.yield acc) ⦃Q⦄)
:
theorem
Std.Do.Spec.Iter.forIn_filterM
{α β γ : Type w}
[Iterator α Id β]
{ps : PostShape}
{n : Type w → Type u_1}
{o : Type w → Type u_2}
[Monad n]
[LawfulMonad n]
[Monad o]
[LawfulMonad o]
[WPMonad o ps]
[MonadAttach n]
[WeaklyLawfulMonadAttach n]
[MonadLiftT n o]
[LawfulMonadLiftT n o]
[Iterators.Finite α Id]
[IteratorLoop α Id o]
[LawfulIteratorLoop α Id o]
{it : Iter β}
{f : β → n (ULift Bool)}
{init : γ}
{g : β → γ → o (ForInStep γ)}
{P : Assertion ps}
{Q : PostCond γ ps}
(h :
⦃P⦄ forIn it init fun (out : β) (acc : γ) => do
let __do_lift ← liftM (f out)
if __do_lift.down = true then g out acc else Pure.pure (ForInStep.yield acc) ⦃Q⦄)
:
theorem
Std.Do.Spec.Iter.forIn_filter
{α β γ : Type w}
[Iterator α Id β]
{ps : PostShape}
{n : Type w → Type u_1}
[Monad n]
[LawfulMonad n]
[WPMonad n ps]
[Iterators.Finite α Id]
[IteratorLoop α Id n]
[LawfulIteratorLoop α Id n]
{it : Iter β}
{f : β → Bool}
{init : γ}
{g : β → γ → n (ForInStep γ)}
{P : Assertion ps}
{Q : PostCond γ ps}
(h :
⦃P⦄ forIn it init fun (out : β) (acc : γ) => if f out = true then g out acc else Pure.pure (ForInStep.yield acc) ⦃Q⦄)
:
theorem
Std.Do.Iter.foldM_filterMapWithPostcondition
{ps : PostShape}
{α β γ δ : Type w}
{n : Type w → Type w''}
{o : Type w → Type w'''}
[Iterator α Id β]
[Iterators.Finite α Id]
[Monad n]
[Monad o]
[LawfulMonad n]
[LawfulMonad o]
[WPMonad o ps]
[IteratorLoop α Id n]
[IteratorLoop α Id o]
[LawfulIteratorLoop α Id n]
[LawfulIteratorLoop α Id o]
[MonadLiftT n o]
[LawfulMonadLiftT n o]
{f : β → Iterators.PostconditionT n (Option γ)}
{g : δ → γ → o δ}
{init : δ}
{it : Iter β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ Iter.foldM
(fun (d : δ) (b : β) => do
let __discr ← liftM (f b).run
match __discr with
| some c => g d c
| x => pure d)
init it ⦃Q⦄)
:
theorem
Std.Do.Iter.foldM_filterMapM
{ps : PostShape}
{α β γ δ : Type w}
{n : Type w → Type w''}
{o : Type w → Type w'''}
[Iterator α Id β]
[Iterators.Finite α Id]
[Monad n]
[MonadAttach n]
[LawfulMonad n]
[WeaklyLawfulMonadAttach n]
[Monad o]
[LawfulMonad o]
[WPMonad o ps]
[IteratorLoop α Id n]
[IteratorLoop α Id o]
[LawfulIteratorLoop α Id n]
[LawfulIteratorLoop α Id o]
[MonadLiftT n o]
[LawfulMonadLiftT n o]
{f : β → n (Option γ)}
{g : δ → γ → o δ}
{init : δ}
{it : Iter β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ Iter.foldM
(fun (d : δ) (b : β) => do
let __discr ← liftM (f b)
match __discr with
| some c => g d c
| x => pure d)
init it ⦃Q⦄)
:
theorem
Std.Do.Iter.foldM_mapWithPostcondition
{ps : PostShape}
{α β γ δ : Type w}
{m : Type w → Type w'}
{n : Type w → Type w''}
{o : Type w → Type w'''}
[Iterator α Id β]
[Iterators.Finite α Id]
[Monad m]
[Monad n]
[Monad o]
[LawfulMonad m]
[LawfulMonad n]
[LawfulMonad o]
[WPMonad o ps]
[IteratorLoop α Id n]
[IteratorLoop α Id o]
[LawfulIteratorLoop α Id n]
[LawfulIteratorLoop α Id o]
[MonadLiftT n o]
[LawfulMonadLiftT n o]
{f : β → Iterators.PostconditionT n γ}
{g : δ → γ → o δ}
{init : δ}
{it : Iter β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ Iter.foldM
(fun (d : δ) (b : β) => do
let c ← liftM (f b).run
g d c)
init it ⦃Q⦄)
:
theorem
Std.Do.Iter.foldM_mapM
{ps : PostShape}
{α β γ δ : Type w}
{n : Type w → Type w''}
{o : Type w → Type w'''}
[Iterator α Id β]
[Iterators.Finite α Id]
[Monad n]
[MonadAttach n]
[LawfulMonad n]
[WeaklyLawfulMonadAttach n]
[Monad o]
[LawfulMonad o]
[WPMonad o ps]
[IteratorLoop α Id n]
[IteratorLoop α Id o]
[LawfulIteratorLoop α Id n]
[LawfulIteratorLoop α Id o]
[MonadLiftT n o]
[LawfulMonadLiftT n o]
{f : β → n γ}
{g : δ → γ → o δ}
{init : δ}
{it : Iter β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ Iter.foldM
(fun (d : δ) (b : β) => do
let c ← liftM (f b)
g d c)
init it ⦃Q⦄)
:
theorem
Std.Do.Iter.foldM_filterWithPostcondition
{ps : PostShape}
{α β δ : Type w}
{n : Type w → Type w''}
{o : Type w → Type w'''}
[Iterator α Id β]
[Iterators.Finite α Id]
[Monad n]
[Monad o]
[LawfulMonad n]
[LawfulMonad o]
[WPMonad o ps]
[IteratorLoop α Id n]
[IteratorLoop α Id o]
[LawfulIteratorLoop α Id n]
[LawfulIteratorLoop α Id o]
[MonadLiftT n o]
[LawfulMonadLiftT n o]
{f : β → Iterators.PostconditionT n (ULift Bool)}
{g : δ → β → o δ}
{init : δ}
{it : Iter β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ Iter.foldM
(fun (d : δ) (b : β) => do
let __do_lift ← liftM (f b).run
if __do_lift.down = true then g d b else pure d)
init it ⦃Q⦄)
:
theorem
Std.Do.Iter.foldM_filterM
{ps : PostShape}
{α β δ : Type w}
{n : Type w → Type w''}
{o : Type w → Type w'''}
[Iterator α Id β]
[Iterators.Finite α Id]
[Monad n]
[MonadAttach n]
[LawfulMonad n]
[WeaklyLawfulMonadAttach n]
[Monad o]
[LawfulMonad o]
[WPMonad o ps]
[IteratorLoop α Id n]
[IteratorLoop α Id o]
[LawfulIteratorLoop α Id n]
[LawfulIteratorLoop α Id o]
[MonadLiftT n o]
[LawfulMonadLiftT n o]
{f : β → n (ULift Bool)}
{g : δ → β → o δ}
{init : δ}
{it : Iter β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ Iter.foldM
(fun (d : δ) (b : β) => do
let __do_lift ← liftM (f b)
if __do_lift.down = true then g d b else pure d)
init it ⦃Q⦄)
:
theorem
Std.Do.Iter.foldM_filterMap
{ps : PostShape}
{α β γ δ : Type w}
{n : Type w → Type w''}
[Iterator α Id β]
[Iterators.Finite α Id]
[Monad n]
[LawfulMonad n]
[WPMonad n ps]
[IteratorLoop α Id n]
[LawfulIteratorLoop α Id n]
{f : β → Option γ}
{g : δ → γ → n δ}
{init : δ}
{it : Iter β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ Iter.foldM
(fun (d : δ) (b : β) =>
match f b with
| some c => g d c
| x => pure d)
init it ⦃Q⦄)
:
theorem
Std.Do.Iter.foldM_map
{ps : PostShape}
{α β γ δ : Type w}
{n : Type w → Type w''}
[Iterator α Id β]
[Iterators.Finite α Id]
[Monad n]
[LawfulMonad n]
[WPMonad n ps]
[IteratorLoop α Id n]
[LawfulIteratorLoop α Id n]
{f : β → γ}
{g : δ → γ → n δ}
{init : δ}
{it : Iter β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h : ⦃P⦄ Iter.foldM (fun (d : δ) (b : β) => g d (f b)) init it ⦃Q⦄)
:
theorem
Std.Do.Iter.foldM_filter
{ps : PostShape}
{α β δ : Type w}
{n : Type w → Type w''}
[Iterator α Id β]
[Iterators.Finite α Id]
[Monad n]
[LawfulMonad n]
[WPMonad n ps]
[IteratorLoop α Id n]
[LawfulIteratorLoop α Id n]
{f : β → Bool}
{g : δ → β → n δ}
{init : δ}
{it : Iter β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h : ⦃P⦄ Iter.foldM (fun (d : δ) (b : β) => if f b = true then g d b else pure d) init it ⦃Q⦄)
:
theorem
Std.Do.Iter.fold_filterMapWithPostcondition
{ps : PostShape}
{α β γ δ : Type w}
{n : Type w → Type w''}
[Iterator α Id β]
[Iterators.Finite α Id]
[Monad n]
[LawfulMonad n]
[WPMonad n ps]
[IteratorLoop α Id n]
[LawfulIteratorLoop α Id n]
{f : β → Iterators.PostconditionT n (Option γ)}
{g : δ → γ → δ}
{init : δ}
{it : Iter β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ Iter.foldM
(fun (d : δ) (b : β) => do
let __discr ← (f b).run
match __discr with
| some c => pure (g d c)
| x => pure d)
init it ⦃Q⦄)
:
theorem
Std.Do.Iter.fold_filterMapM
{ps : PostShape}
{α β γ δ : Type w}
{n : Type w → Type w''}
[Iterator α Id β]
[Iterators.Finite α Id]
[Monad n]
[MonadAttach n]
[LawfulMonad n]
[WeaklyLawfulMonadAttach n]
[WPMonad n ps]
[IteratorLoop α Id n]
[LawfulIteratorLoop α Id n]
{f : β → n (Option γ)}
{g : δ → γ → δ}
{init : δ}
{it : Iter β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ Iter.foldM
(fun (d : δ) (b : β) => do
let __discr ← f b
match __discr with
| some c => pure (g d c)
| x => pure d)
init it ⦃Q⦄)
:
theorem
Std.Do.Iter.fold_mapWithPostcondition
{ps : PostShape}
{α β γ δ : Type w}
{n : Type w → Type w''}
[Iterator α Id β]
[Iterators.Finite α Id]
[Monad n]
[LawfulMonad n]
[WPMonad n ps]
[IteratorLoop α Id n]
[LawfulIteratorLoop α Id n]
{f : β → Iterators.PostconditionT n γ}
{g : δ → γ → δ}
{init : δ}
{it : Iter β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ Iter.foldM
(fun (d : δ) (b : β) => do
let c ← (f b).run
pure (g d c))
init it ⦃Q⦄)
:
theorem
Std.Do.Iter.fold_mapM
{ps : PostShape}
{α β γ δ : Type w}
{n : Type w → Type w''}
[Iterator α Id β]
[Iterators.Finite α Id]
[Monad n]
[MonadAttach n]
[LawfulMonad n]
[WeaklyLawfulMonadAttach n]
[WPMonad n ps]
[IteratorLoop α Id n]
[LawfulIteratorLoop α Id n]
{f : β → n γ}
{g : δ → γ → δ}
{init : δ}
{it : Iter β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ Iter.foldM
(fun (d : δ) (b : β) => do
let c ← f b
pure (g d c))
init it ⦃Q⦄)
:
theorem
Std.Do.Iter.fold_filterWithPostcondition
{ps : PostShape}
{α β δ : Type w}
{n : Type w → Type w''}
[Iterator α Id β]
[Iterators.Finite α Id]
[Monad n]
[LawfulMonad n]
[WPMonad n ps]
[IteratorLoop α Id n]
[LawfulIteratorLoop α Id n]
{f : β → Iterators.PostconditionT n (ULift Bool)}
{g : δ → β → δ}
{init : δ}
{it : Iter β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ Iter.foldM
(fun (d : δ) (b : β) => do
let __do_lift ← (f b).run
pure (if __do_lift.down = true then g d b else d))
init it ⦃Q⦄)
:
theorem
Std.Do.Iter.fold_filterM
{ps : PostShape}
{α β δ : Type w}
{n : Type w → Type w''}
[Iterator α Id β]
[Iterators.Finite α Id]
[Monad n]
[MonadAttach n]
[LawfulMonad n]
[WeaklyLawfulMonadAttach n]
[WPMonad n ps]
[IteratorLoop α Id n]
[LawfulIteratorLoop α Id n]
{f : β → n (ULift Bool)}
{g : δ → β → δ}
{init : δ}
{it : Iter β}
{P : Assertion ps}
{Q : PostCond δ ps}
(h :
⦃P⦄ Iter.foldM
(fun (d : δ) (b : β) => do
let __do_lift ← f b
pure (if __do_lift.down = true then g d b else d))
init it ⦃Q⦄)
:
theorem
Std.Do.Spec.forIn'_array
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
{xs : Array α}
{init : β}
{f : (a : α) → a ∈ xs → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur ⋯ b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.forIn_array
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
{xs : Array α}
{init : β}
{f : α → β → m (ForInStep β)}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f cur b ⦃(fun (r : ForInStep β) =>
match r with
| ForInStep.yield b' => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.fst ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'), inv.snd)⦄)
:
theorem
Std.Do.Spec.foldlM_array
{α β : Type u}
{m : Type u → Type v}
{ps : PostShape}
[Monad m]
[WPMonad m ps]
{xs : Array α}
{init : β}
{f : β → α → m β}
(inv : Invariant xs.toList β ps)
(step :
∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.fst ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄ f b cur ⦃(fun (b' : β) => inv.fst ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b'), inv.snd)⦄)
: