Proof Assistant Projects
Collection
Digesting proof assistant libraries for AI ingestion. • 84 items • Updated • 3
fact stringlengths 14 11.5k | type stringclasses 22
values | library stringclasses 7
values | imports listlengths 0 7 | filename stringclasses 136
values | symbolic_name stringlengths 1 36 | docstring stringclasses 1
value |
|---|---|---|---|---|---|---|
ioE : Type -> Type := | Input : ioE (list nat) (** Ask for a list of [nat] from the environment. *) | Output : list nat -> ioE unit (** Send a list of [nat]. *) . (** Events are wrapped as ITrees using [ITree.trigger], and composed using monadic operations [bind] and [ret]. *) (** Read some input, and echo it back, app... | Inductive | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | ioE | |
write_one : itree ioE unit := xs <- ITree.trigger Input;; ITree.trigger (Output (xs ++ [1])). (** We can _interpret_ interaction trees by giving semantics to their events individually, as a _handler_: a function of type [forall R, ioE R -> M R] for some monad [M]. *) (** The handler [handle_io] below responds to every ... | Definition | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | write_one | |
handle_io : forall R, ioE R -> Monads.stateT (list nat) (itree void1) R := fun R e log => match e with | Input => ret (log, [0]) | Output o => ret (log ++ o, tt) end. (** [interp] lifts any handler into an _interpreter_, of type [forall R, itree ioE R -> M R]. *) | Definition | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | handle_io | |
interp_io : forall R, itree ioE R -> itree void1 (list nat * R) := fun R t => Monads.run_stateT (interp handle_io t) []. (** We can now interpret [write_one]. *) | Definition | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | interp_io | |
interpreted_write_one : itree void1 (list nat * unit) := interp_io _ write_one. (** Intuitively, [interp_io] replaces every [ITree.trigger] in the definition of [write_one] with [handle_io]: [[ interpreted_write_one = xs <- handle_io _ Input;; handle_io _ (Output (xs ++ [1])) ]] We can prove such a lemma in a more rest... | Definition | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | interpreted_write_one | |
interp_write_one F (handle_io : forall R, ioE R -> itree F R) : interp handle_io write_one ≈ (xs <- handle_io _ Input;; handle_io _ (Output (xs ++ [1]))). Proof. unfold write_one. (* Use lemmas from [ITree.Simple] ([theories/Simple.v]). *) (* ADMITTED *) rewrite interp_bind. rewrite interp_trigger. setoid_rewrite inter... | Lemma | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | interp_write_one | |
E := void1. (** ** Factorial *) (** This is the Coq specification -- the usual mathematical definition. *) | Definition | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | E | |
factorial_spec (n : nat) : nat := match n with | 0 => 1 | S m => n * factorial_spec m end. (** The generic [rec] interface of the library's [Interp] module can be used to define a single recursive function. The more general [mrec] (from which [rec] is defined) allows multiple, mutually recursive definitions. The argume... | Fixpoint | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | factorial_spec | |
fact_body (x : nat) : itree (callE nat nat +' E) nat := match x with | 0 => Ret 1 | S m => y <- call m ;; (* Recursively compute [y := m!] *) Ret (x * y) end. (** The factorial function itself is defined as an ITree by "tying the knot" using [rec]. *) | Definition | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | fact_body | |
factorial (n : nat) : itree E nat := rec fact_body n. (** *** Evaluation *) (** Contrary to definitions by [Fixpoint], there are no restrictions on the arguments of recursive calls: [rec] may thus produce diverging computations, and Coq will not naively reduce [factorial 5]. We can force the computation with fuel, e.g.... | Definition | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | factorial | |
fact_5 : factorial 5 ≈ Ret 120. Proof. tau_steps. reflexivity. Qed. (** *** Alternative notation *) (** An equivalent definition with a [rec-fix] notation looking like [fix], where the recursive call can be given a more specific name. *) | Example | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | fact_5 | |
factorial' : nat -> itree E nat := rec-fix fact x := match x with | 0 => Ret 1 | S m => y <- fact m ;; Ret (x * y) end. (** These two definitions are definitionally equal. *) | Definition | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | factorial' | |
factorial_same : factorial = factorial'. Proof. reflexivity. Qed. (** *** Correctness *) (** [rec] is actually a special version of [interp], which replaces every [call] in [fact_body] with [factorial] itself. *) | Lemma | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | factorial_same | |
unfold_factorial : forall x, factorial x ≈ match x with | 0 => Ret 1 | S m => y <- factorial m ;; Ret (x * y) end. Proof. intros x. unfold factorial. (* ADMITTED *) rewrite rec_as_interp; unfold fact_body at 2. destruct x. - rewrite interp_ret. reflexivity. - rewrite interp_bind. rewrite interp_recursive_call. setoid_r... | Lemma | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | unfold_factorial | |
factorial_correct : forall n, factorial n ≈ Ret (factorial_spec n). Proof. intros n. (* ADMITTED *) induction n as [ | n' IH ]. - (* n = 0 *) rewrite unfold_factorial. reflexivity. - (* n = S n' *) rewrite unfold_factorial. rewrite IH. (* Induction hypothesis *) rewrite bind_ret. simpl. reflexivity. Qed. (* /ADMITTED *... | Lemma | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | factorial_correct | |
factorial_correct' : forall n, factorial n ≈ Ret (factorial_spec n). Proof. intros n. unfold factorial. induction n as [ | n' IH ]. - (* n = 0 *) tau_steps. (* Just compute away. *) reflexivity. - (* n = S n' *) rewrite rec_as_interp. unfold fact_body at 2. autorewrite with itree. rewrite IH. (* Induction hypothesis *)... | Lemma | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | factorial_correct' | |
fib_spec (n : nat) : nat := match n with | 0 => 0 | S n' => match n' with | 0 => 1 | S n'' => fib_spec n'' + fib_spec n' end end. | Fixpoint | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | fib_spec | |
fib_body : nat -> itree (callE nat nat +' E) nat (* ADMITDEF *) := fun n => match n with | 0 => Ret 0 | S n' => match n' with | 0 => Ret 1 | S n'' => y1 <- call n'' ;; y2 <- call n' ;; Ret (y1 + y2) end end. (* /ADMITDEF *) | Definition | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | fib_body | |
fib n : itree E nat := rec fib_body n. | Definition | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | fib | |
fib_3_6 : mapT fib [4;5;6] ≈ Ret [3; 5; 8]. Proof. (* Use [tau_steps] to compute. *) (* ADMITTED *) tau_steps. reflexivity. Qed. (* /ADMITTED *) (** Since fib uses two recursive calls, we need to strengthen the induction hypothesis. One way to do that is to prove the property for all [m <= n]. You may find the followin... | Example | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | fib_3_6 | |
fib_correct_aux : forall n m, m <= n -> fib m ≈ Ret (fib_spec m). Proof. intros n. unfold fib. induction n as [ | n' IH ]; intros. - (* n = 0 *) apply Nat.le_0_r in H. subst m. (* ADMIT *) rewrite rec_as_interp. simpl. rewrite interp_ret. (* alternatively, [tau_steps], or [autorewrite with itree] *) reflexivity. (* /AD... | Lemma | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | fib_correct_aux | |
fib_correct : forall n, fib n ≈ Ret (fib_spec n). Proof. (* ADMITTED *) intros n. eapply fib_correct_aux. reflexivity. Qed. (* /ADMITTED *) (** ** Logarithm *) (** An example of a function which is not structurally recursive. [log_ b n]: logarithm of [n] in base [b]. Specification: [log_ b (b ^ y) ≈ Ret y] when [1 < b]... | Lemma | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | fib_correct | |
log (b : nat) : nat -> itree E nat (* ADMITDEF *) := rec-fix log_b n := if n <=? 1 then Ret O else y <- log_b (n / b) ;; Ret (S y). (* /ADMITDEF *) | Definition | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | log | |
log_2_64 : log 2 (2 ^ 6) ≈ Ret 6. Proof. (* ADMITTED *) tau_steps. reflexivity. Qed. (* /ADMITTED *) (** These lemmas take care of the boring arithmetic. *) | Example | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | log_2_64 | |
log_correct_helper : forall b y, 1 < b -> (b * b ^ y <=? 1) = false. Proof. intros. apply Nat.leb_gt. apply Nat.lt_1_mul_pos; auto. apply Nat.neq_0_lt_0. intro. apply (Nat.pow_nonzero b y); lia. Qed. | Lemma | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | log_correct_helper | |
log_correct_helper2 : forall b y, 1 < b -> (b * b ^ y / b) = (b ^ y). Proof. intros; rewrite Nat.mul_comm, Nat.div_mul; lia. Qed. | Lemma | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | log_correct_helper2 | |
log_correct : forall b y, 1 < b -> log b (b ^ y) ≈ Ret y. Proof. intros b y H. (* ADMITTED *) unfold log, rec_fix. induction y. - rewrite rec_as_interp; cbn. autorewrite with itree. reflexivity. - rewrite rec_as_interp; cbn. (* (b * b ^ y <=? 1) = false *) rewrite log_correct_helper by auto. autorewrite with itree. (* ... | Lemma | examples | [
"From ITree Require Import\n Simple."
] | examples/IntroductionSolutions.v | log_correct | |
stateE (S:Type) : Type -> Type := | Get : stateE S S | Put : S -> stateE S unit. (* We can define an interpretation of [stateE] events into itrees with no events as follows. Note that we split out the "node functor", which is parameterized by the interpreter on the recursive calls, separating it from the CoFixpoint. Th... | Variant | examples | [
"From Coq Require Import\n Morphisms.",
"From Paco Require Import paco.",
"From ExtLib Require Import\n Monads.",
"From Paco Require Import paco."
] | examples/ITreePredicatesExample.v | stateE | |
stateT (S:Type) (M:Type -> Type) (R:Type) := S -> M (S * R)%type. | Definition | examples | [
"From Coq Require Import\n Morphisms.",
"From Paco Require Import paco.",
"From ExtLib Require Import\n Monads.",
"From Paco Require Import paco."
] | examples/ITreePredicatesExample.v | stateT | |
interpret_stateF (S:Type) {R} (rec : itree (stateE S) R -> stateT S (itree void1) R) (t : itree (stateE S) R) : stateT S (itree void1) R := fun s => match observe t with | RetF r => ret (s, r) | TauF t => Tau (rec t s) | VisF Get k => Tau (rec (k s) s) | VisF (Put s') k => Tau (rec (k tt) s') end. CoFixpoint interpret_... | Definition | examples | [
"From Coq Require Import\n Morphisms.",
"From Paco Require Import paco.",
"From ExtLib Require Import\n Monads.",
"From Paco Require Import paco."
] | examples/ITreePredicatesExample.v | interpret_stateF | |
unfold_interpret_state : forall {S R} (t : itree (stateE S) R) (s:S), observe (interpret_state t s) = observe (interpret_stateF interpret_state t s). Proof. reflexivity. Qed. (* Rewriting ---------------------------------------------------------------- *) (* To enable rewriting under the [interpret_state] function, we ... | Lemma | examples | [
"From Coq Require Import\n Morphisms.",
"From Paco Require Import paco.",
"From ExtLib Require Import\n Monads.",
"From Paco Require Import paco."
] | examples/ITreePredicatesExample.v | unfold_interpret_state | |
proper_interpret_state {S R} : Proper ((@eq_itree (stateE S) R _ eq) ==> (@eq S) ==> (@eq_itree void1 (S * R) _ eq)) interpret_state. Proof. ginit. gcofix CIH. intros x y H0 x2 y0 H1. rewrite (itree_eta (interpret_state x x2)). rewrite (itree_eta (interpret_state y y0)). rewrite !unfold_interpret_state. subst. punfold ... | Instance | examples | [
"From Coq Require Import\n Morphisms.",
"From Paco Require Import paco.",
"From ExtLib Require Import\n Monads.",
"From Paco Require Import paco."
] | examples/ITreePredicatesExample.v | proper_interpret_state | |
NoGetsF {S R} (rec : itree (stateE S) R -> Prop) : itreeF (stateE S) R (itree (stateE S) R) -> Prop := | isRet : forall (r:R), NoGetsF rec (RetF r) | isTau : forall t, rec t -> NoGetsF rec (TauF t) | isPut : forall (k : unit -> itree (stateE S) R), forall (s:S), rec (k tt) -> NoGetsF rec (VisF (Put s) k). Global Hint C... | Variant | examples | [
"From Coq Require Import\n Morphisms.",
"From Paco Require Import paco.",
"From ExtLib Require Import\n Monads.",
"From Paco Require Import paco."
] | examples/ITreePredicatesExample.v | NoGetsF | |
NoGets_ {S R} (rec : itree (stateE S) R -> Prop) (t : itree (stateE S) R) : Prop := NoGetsF rec (observe t). (* Next, we need to prove that [NoGets_] is a monotone function on relations, which means that paco can take its greatest fixpoint. Monotonicity of [NoGets_] depends on monotonicity of [NoGetsF]. Fortunately, pa... | Definition | examples | [
"From Coq Require Import\n Morphisms.",
"From Paco Require Import paco.",
"From ExtLib Require Import\n Monads.",
"From Paco Require Import paco."
] | examples/ITreePredicatesExample.v | NoGets_ | |
monotone_NoGetsF : forall {S R} t (r r' : itree (stateE S) R -> Prop) (IN: NoGetsF r t) (LE: forall y, r y -> r' y), NoGetsF r' t. Proof. pmonauto. Qed. (* SAZ: we need to do a couple of reductions to expose the structure of the lemma so that pmonauto can work. Note that [cbn] and [simple] don't work here because they ... | Lemma | examples | [
"From Coq Require Import\n Morphisms.",
"From Paco Require Import paco.",
"From ExtLib Require Import\n Monads.",
"From Paco Require Import paco."
] | examples/ITreePredicatesExample.v | monotone_NoGetsF | |
monotone_NoGets_ : forall {S R}, monotone1 (@NoGets_ S R). Proof. do 2 red. pmonauto. Qed. Global Hint Resolve monotone_NoGets_ : paco. (* Finally, we can define the [NoGets] predicate by simply applying paco1 starting from bot1 (the least prediate). We would use paco2 and bot2 for a binary relation, paco3 and bot3 for... | Lemma | examples | [
"From Coq Require Import\n Morphisms.",
"From Paco Require Import paco.",
"From ExtLib Require Import\n Monads.",
"From Paco Require Import paco."
] | examples/ITreePredicatesExample.v | monotone_NoGets_ | |
NoGets {S R} : itree (stateE S) R -> Prop := paco1 NoGets_ bot1. (* Using a coinductive predicate -------------------------------------------- *) (* Now that we have defined [NoGets], we can use that predicate to do a coinductive proof. Intuitively, if we interpret an itree of type [itree (stateE S) R] that satisfies t... | Definition | examples | [
"From Coq Require Import\n Morphisms.",
"From Paco Require Import paco.",
"From ExtLib Require Import\n Monads.",
"From Paco Require Import paco."
] | examples/ITreePredicatesExample.v | NoGets | |
state_independent : forall {S R} (t:itree (stateE S) R) (H: NoGets t), forall s s', ('(s,x) <- interpret_state t s ;; ret x) ≅ ('(s,x) <- interpret_state t s' ;; ret x). Proof. intros S R. ginit. gcofix CIH. intros t H0 s s'. rewrite (itree_eta (interpret_state t s)). rewrite (itree_eta (interpret_state t s')). rewrite... | Lemma | examples | [
"From Coq Require Import\n Morphisms.",
"From Paco Require Import paco.",
"From ExtLib Require Import\n Monads.",
"From Paco Require Import paco."
] | examples/ITreePredicatesExample.v | state_independent | |
state_independent_k : forall {S R U} (t:itree (stateE S) R) (H: NoGets t) (k: (S * R) -> itree void1 U) (INV: forall s s' x, k (s, x) ≅ k (s', x)), forall s s', (sx <- interpret_state t s ;; (k sx)) ≅ (sx <- interpret_state t s' ;; (k sx)). Proof. intros S R U. ginit. gcofix CIH. intros t H0 k INV s s'. rewrite (itree_... | Lemma | examples | [
"From Coq Require Import\n Morphisms.",
"From Paco Require Import paco.",
"From ExtLib Require Import\n Monads.",
"From Paco Require Import paco."
] | examples/ITreePredicatesExample.v | state_independent_k | |
state_independent' : forall {S R} (t:itree (stateE S) R) (H: NoGets t), forall s s', ('(s,x) <- interpret_state t s ;; ret x) ≅ ('(s,x) <- interpret_state t s' ;; ret x). Proof. intros S R t H s s'. eapply state_independent_k; eauto. intros. reflexivity. Qed. | Theorem | examples | [
"From Coq Require Import\n Morphisms.",
"From Paco Require Import paco.",
"From ExtLib Require Import\n Monads.",
"From Paco Require Import paco."
] | examples/ITreePredicatesExample.v | state_independent' | |
term : Type := | Var : nat -> term (* DeBruijn indexed *) | App : term -> term -> term | Lam : term -> term . | Inductive | examples | [
"From Coq Require Import Arith.",
"From ExtLib.Structures Require Import\n Monad."
] | examples/LC.v | term | |
headvar : Type := | VVar : nat -> headvar | VApp : headvar -> value -> headvar with value : Type := | VHead : headvar -> value | VLam : term -> value . | Inductive | examples | [
"From Coq Require Import Arith.",
"From ExtLib.Structures Require Import\n Monad."
] | examples/LC.v | headvar | |
to_term (v : value) : term := match v with | VHead hv => hv_to_term hv | VLam t => Lam t end with hv_to_term (hv : headvar) : term := match hv with | VVar n => Var n | VApp hv v => App (hv_to_term hv) (to_term v) end. | Fixpoint | examples | [
"From Coq Require Import Arith.",
"From ExtLib.Structures Require Import\n Monad."
] | examples/LC.v | to_term | |
shift (n m : nat) (s : term) := match s with | Var p => if p <? m then Var (n + p) else Var p | App t1 t2 => App (shift n m t1) (shift n m t2) | Lam t => Lam (shift n (S m) t) end. | Fixpoint | examples | [
"From Coq Require Import Arith.",
"From ExtLib.Structures Require Import\n Monad."
] | examples/LC.v | shift | |
subst (n : nat) (s t : term) := match t with | Var m => if m <? n then Var m else if m =? n then shift n O s else Var (pred m) | App t1 t2 => App (subst n s t1) (subst n s t2) | Lam t => Lam (subst (S n) s t) end. (* big-step call-by-value *) | Fixpoint | examples | [
"From Coq Require Import Arith.",
"From ExtLib.Structures Require Import\n Monad."
] | examples/LC.v | subst | |
big_step : term -> itree void1 value := rec (fun t => match t with | Var n => ret (VHead (VVar n)) | App t1 t2 => t2' <- trigger (Call t2);; t1' <- trigger (Call t1);; match t1' with | VHead hv => ret (VHead (VApp hv t2')) | VLam t1'' => trigger (Call (subst O (to_term t2') t1'')) end | Lam t => ret (VLam t) end). | Definition | examples | [
"From Coq Require Import Arith.",
"From ExtLib.Structures Require Import\n Monad."
] | examples/LC.v | big_step | |
printE : Type -> Type := Print : string -> printE unit. (* A thread that loops, printing [s] forever. *) | Variant | examples | [
"From Coq Require Import\n String."
] | examples/MultiThreadedPrinting.v | printE | |
thread {E} `{printE -< E} (s:string) : itree E unit := ITree.forever (trigger (Print s)). (* Run three threads. *) | Definition | examples | [
"From Coq Require Import\n String."
] | examples/MultiThreadedPrinting.v | thread | |
main_thread : itree (spawnE printE +' printE) unit := spawn (thread "Thread 1") ;; spawn (thread "Thread 2") ;; spawn (thread "Thread 3"). | Definition | examples | [
"From Coq Require Import\n String."
] | examples/MultiThreadedPrinting.v | main_thread | |
scheduled_thread : itree printE unit := run_spawn main_thread. | Definition | examples | [
"From Coq Require Import\n String."
] | examples/MultiThreadedPrinting.v | scheduled_thread | |
com : Type := | loop : com -> com (* Nondeterministically, continue or stop. *) | choose : com -> com -> com | skip : com | seq : com -> com -> com . Declare Scope com_scope. Infix ";;" := seq (at level 61, right associativity) : com_scope. Delimit Scope com_scope with com. Open Scope com_scope. | Inductive | examples | [
"From Coq Require Import\n Relations.",
"From Paco Require Import paco."
] | examples/Nimp.v | com | |
one_loop : com := loop skip. | Example | examples | [
"From Coq Require Import\n Relations.",
"From Paco Require Import paco."
] | examples/Nimp.v | one_loop | |
two_loops : com := loop (loop skip). | Example | examples | [
"From Coq Require Import\n Relations.",
"From Paco Require Import paco."
] | examples/Nimp.v | two_loops | |
loop_choose : com := loop (choose skip skip). | Example | examples | [
"From Coq Require Import\n Relations.",
"From Paco Require Import paco."
] | examples/Nimp.v | loop_choose | |
choose_loop : com := choose (loop skip) skip. (* Unlabeled small-step *) | Example | examples | [
"From Coq Require Import\n Relations.",
"From Paco Require Import paco."
] | examples/Nimp.v | choose_loop | |
step : relation com := | step_loop_stop c : loop c --> skip | step_loop_go c : loop c --> (c ;; loop c) | step_choose_l c1 c2 : choose c1 c2 --> c1 | step_choose_r c1 c2 : choose c1 c2 --> c2 | step_seq_go c1 c1' c2 : c1 --> c2 -> (c1 ;; c2) --> (c1' ;; c2) | step_seq_next c2 : (skip ;; c2) --> c2 where "x --> y" := (s... | Inductive | examples | [
"From Coq Require Import\n Relations.",
"From Paco Require Import paco."
] | examples/Nimp.v | step | |
infinite_steps (c : com) : Type := | more c' : step c c' -> infinite_steps c' -> infinite_steps c. | CoInductive | examples | [
"From Coq Require Import\n Relations.",
"From Paco Require Import paco."
] | examples/Nimp.v | infinite_steps | |
infinite_simple_loop : infinite_steps one_loop. Proof. cofix self. eapply more. { eapply step_loop_go. } eapply more. { eapply step_seq_next. } apply self. Qed. | Lemma | examples | [
"From Coq Require Import\n Relations.",
"From Paco Require Import paco."
] | examples/Nimp.v | infinite_simple_loop | |
label := tau | bit (b : bool). | Variant | examples | [
"From Coq Require Import\n Relations.",
"From Paco Require Import paco."
] | examples/Nimp.v | label | |
step : label -> relation com := | step_loop_stop c : loop c ! true --> skip | step_loop_go c : loop c ! false --> (c ;; loop c) | step_choose_l c1 c2 : choose c1 c2 ! true --> c1 | step_choose_r c1 c2 : choose c1 c2 ! false --> c2 | step_seq_go b c1 c1' c2 : c1 ? b --> c2 -> (c1 ;; c2) ? b --> (c1' ;; c2) | step_seq_ne... | Inductive | examples | [
"From Coq Require Import\n Relations.",
"From Paco Require Import paco."
] | examples/Nimp.v | step | |
infinite_steps (c : com) : Type := | more b c' : step b c c' -> infinite_steps c' -> infinite_steps c. | CoInductive | examples | [
"From Coq Require Import\n Relations.",
"From Paco Require Import paco."
] | examples/Nimp.v | infinite_steps | |
infinite_simple_loop : infinite_steps one_loop. Proof. cofix self. eapply more. { eapply step_loop_go. } eapply more. { eapply step_seq_next. } apply self. Qed. | Lemma | examples | [
"From Coq Require Import\n Relations.",
"From Paco Require Import paco."
] | examples/Nimp.v | infinite_simple_loop | |
nd : Type -> Prop := | Or : nd bool. | Variant | examples | [
"From Coq Require Import\n Relations.",
"From Paco Require Import paco."
] | examples/Nimp.v | nd | |
or {R : Type} (t1 t2 : itree nd R) : itree nd R := Vis Or (fun b : bool => if b then t1 else t2). (* Flip a coin *) | Definition | examples | [
"From Coq Require Import\n Relations.",
"From Paco Require Import paco."
] | examples/Nimp.v | or | |
choice {E} `{nd -< E} : itree E bool := trigger Or. | Definition | examples | [
"From Coq Require Import\n Relations.",
"From Paco Require Import paco."
] | examples/Nimp.v | choice | |
eval_def : com -> itree (callE _ _ +' nd) unit := (fun (c : com) => match c with | loop c => (b <- choice;; if b : bool then Ret tt else (trigger (Call c);; trigger (Call (loop c))))%itree | choose c1 c2 => (b <- choice;; if b : bool then trigger (Call c1) else trigger (Call c2))%itree | (t1 ;; t2)%com => (trigger (Cal... | Definition | examples | [
"From Coq Require Import\n Relations.",
"From Paco Require Import paco."
] | examples/Nimp.v | eval_def | |
eval : com -> itree nd unit := rec eval_def. (* [itree] semantics of [one_loop]. *) | Definition | examples | [
"From Coq Require Import\n Relations.",
"From Paco Require Import paco."
] | examples/Nimp.v | eval | |
one_loop_tree : itree nd unit := rec (fun _ : unit => (* note: [or] is not allowed under [mfix]. *) b <- choice;; if b : bool then Ret tt else trigger (Call tt))%itree tt. Import Coq.Classes.Morphisms. | Definition | examples | [
"From Coq Require Import\n Relations.",
"From Paco Require Import paco."
] | examples/Nimp.v | one_loop_tree | |
eval_skip : rec eval_def skip ≈ Ret tt. Proof. rewrite rec_as_interp. cbn. rewrite interp_ret. reflexivity. Qed. (* SAZ: the [~] notation for eutt wasn't working here. *) | Lemma | examples | [
"From Coq Require Import\n Relations.",
"From Paco Require Import paco."
] | examples/Nimp.v | eval_skip | |
eval_one_loop : eval one_loop ≈ one_loop_tree. Proof. einit. ecofix CIH. edrop. setoid_rewrite rec_as_interp. setoid_rewrite interp_bind. setoid_rewrite interp_vis. setoid_rewrite tau_eutt. setoid_rewrite interp_ret. setoid_rewrite bind_bind. setoid_rewrite bind_ret_l. setoid_rewrite bind_vis. evis. intros. setoid_rewr... | Lemma | examples | [
"From Coq Require Import\n Relations.",
"From Paco Require Import paco."
] | examples/Nimp.v | eval_one_loop | |
inputE : Type -> Prop := | Input : inputE nat. (* Effectful programs *) | Variant | examples | [
"From ITree Require Import\n ITree ITreeFacts."
] | examples/ReadmeExample.v | inputE | |
echo : itree inputE nat := x <- trigger Input ;; Ret x. (* Effect handlers *) | Definition | examples | [
"From ITree Require Import\n ITree ITreeFacts."
] | examples/ReadmeExample.v | echo | |
handler {E} (n : nat) : inputE ~> itree E := fun _ e => match e with | Input => Ret n end. (* Interpreters *) | Definition | examples | [
"From ITree Require Import\n ITree ITreeFacts."
] | examples/ReadmeExample.v | handler | |
echoed (n : nat) : itree void1 nat := interp (handler n) echo. (* Equational reasoning *) | Definition | examples | [
"From ITree Require Import\n ITree ITreeFacts."
] | examples/ReadmeExample.v | echoed | |
echoed_id : forall n, echoed n ≈ Ret n. Proof. intros n. (* echoed n *) unfold echoed, echo. (* ≈ interp (handler n) (x <- trigger Input ;; Ret x) *) rewrite interp_bind. (* ≈ x <- interp (handler n) Input ;; interp (handler n) (Ret x) *) rewrite interp_trigger. (* ≈ x <- handler n _ Input ;; interp (handler n) (Ret x)... | Theorem | examples | [
"From ITree Require Import\n ITree ITreeFacts."
] | examples/ReadmeExample.v | echoed_id | |
typ := | Base | Arr (s:typ) (t:typ). Variable V : typ -> Type. (* PHOAS variables *) | Inductive | examples | [] | examples/STLC.v | typ | |
tm : typ -> Type := | Lit (n:nat) : tm Base | Var : forall (t:typ), V t -> tm t | App : forall t1 t2 (m1 : tm (Arr t1 t2)) (m2 : tm t1), tm t2 | Lam : forall t1 t2 (body : V t1 -> tm t2), tm (Arr t1 t2) | Opr : forall (m1 : tm Base) (m2 : tm Base), tm Base . | Inductive | examples | [] | examples/STLC.v | tm | |
open_tm (G : list typ) (u:typ) : Type := match G with | [] => tm u | t::ts => V t -> (open_tm ts u) end. | Fixpoint | examples | [] | examples/STLC.v | open_tm | |
Term (G : list typ) (u:typ) := forall (V : typ -> Type), open_tm V G u. Arguments Lit {V}. Arguments Var {V t}. Arguments App {V t1 t2}. Arguments Lam {V t1 t2}. Arguments Opr {V}. | Definition | examples | [] | examples/STLC.v | Term | |
denote_typ E (t:typ) : Type := match t with | Base => nat | Arr s t => (denote_typ E s) -> itree E (denote_typ E t) end. | Fixpoint | examples | [] | examples/STLC.v | denote_typ | |
denotation_tm_typ E (V:typ -> Type) (G : list typ) (u:typ) := match G with | [] => itree E (V u) | t::ts => (V t) -> denotation_tm_typ E V ts u end. | Fixpoint | examples | [] | examples/STLC.v | denotation_tm_typ | |
denote_closed_term {E} {u:typ} (m : tm (denote_typ E) u) : itree E (denote_typ E u) := match m with | Lit n => Ret n | Var x => Ret x | App m1 m2 => f <- (denote_closed_term m1) ;; x <- (denote_closed_term m2) ;; ans <- f x ;; ret ans | Lam body => ret (fun x => denote_closed_term (body x)) | Opr m1 m2 => x <- (denote_... | Fixpoint | examples | [] | examples/STLC.v | denote_closed_term | |
Fixpoint denote_rec (V:typ -> Type) E (base : forall u (m : tm V u), itree E (V u)) (G: list typ) (u:typ) (m : open_tm V G u) : denotation_tm_typ E V G u := match G with | [] => base u _ | t::ts => fun (x : V t) => denote_rec V E base ts u _ end. | Program | examples | [] | examples/STLC.v | Fixpoint | |
Obligation . simpl in m. exact m. Defined. | Next | examples | [] | examples/STLC.v | Obligation | |
Obligation . unfold Term in m. simpl in m. apply m in x. exact x. Defined. | Next | examples | [] | examples/STLC.v | Obligation | |
Definition denote E (G : list typ) (u:typ) (m : Term G u) : denotation_tm_typ E (denote_typ E) G u := denote_rec (denote_typ E) E (@denote_closed_term E) G u _. | Program | examples | [] | examples/STLC.v | Definition | |
Obligation . unfold Term in m. specialize (m (denote_typ E)). exact m. Defined. | Next | examples | [] | examples/STLC.v | Obligation | |
id_tm : Term [] (Arr Base Base) := fun V => Lam (fun x => Var x). | Definition | examples | [] | examples/STLC.v | id_tm | |
example : Term [] Base := fun V => App (id_tm V) (Lit 3). | Definition | examples | [] | examples/STLC.v | example | |
example_equiv E : (denote E [] Base example) ≈ Ret 3. Proof. cbn. repeat rewrite bind_ret_l. reflexivity. Qed. | Lemma | examples | [] | examples/STLC.v | example_equiv | |
twice : Term [] (Arr (Arr Base Base) (Arr Base Base)) := fun V => Lam (fun f => Lam (fun x => App (Var f) (App (Var f) (Var x)))). | Definition | examples | [] | examples/STLC.v | twice | |
example2 : Term [] Base := fun V => App (App (twice V) (id_tm V)) (Lit 3). | Definition | examples | [] | examples/STLC.v | example2 | |
big_example_equiv E : (denote E [] Base example2) ≈ Ret 3. Proof. cbn. repeat rewrite bind_ret_l. reflexivity. Qed. | Lemma | examples | [] | examples/STLC.v | big_example_equiv | |
add_2_tm : Term [] (Arr Base Base) := fun V => Lam (fun x => (Opr (Var x) (Lit 2))). | Definition | examples | [] | examples/STLC.v | add_2_tm | |
example3 : Term [] Base := fun V => App (App (twice V) (add_2_tm V)) (Lit 3). | Definition | examples | [] | examples/STLC.v | example3 | |
big_example2_equiv E : (denote E [] Base example3) ≈ Ret 7. Proof. cbn. repeat rewrite bind_ret_l. reflexivity. Qed. | Lemma | examples | [] | examples/STLC.v | big_example2_equiv | |
iforest (E: Type -> Type) (X: Type): Type := itree E X -> Prop. (** TODO: There may be a generalization to a kind of monad transformer [PropT M X := M X -> Prop]. *) (** [iforest] are expected to be compatible with the [eutt] relation in the following sense: *) | Definition | extra | [
"From Paco Require Import paco.",
"From ExtLib Require Import\n Structures."
] | extra/IForest.v | iforest | |
eutt_closed := (Proper (eutt eq ==> iff)) (only parsing). #[global] Polymorphic Instance Eq1_iforest {E} : Eq1 (iforest E) := fun a PA PA' => (forall x y, x ≈ y -> (PA x <-> PA' y)) /\ eutt_closed PA /\ eutt_closed PA'. #[global] Instance Functor_iforest {E} : Functor (iforest E) := {| fmap := fun A B f PA b => exists ... | Notation | extra | [
"From Paco Require Import paco.",
"From ExtLib Require Import\n Structures."
] | extra/IForest.v | eutt_closed | |
subtree {E} {A B} (ta : itree E A) (tb : itree E B) : Prop := exists (k : A -> itree E B), tb ≈ bind ta k. (* Definition 5.1 *) | Definition | extra | [
"From Paco Require Import paco.",
"From ExtLib Require Import\n Structures."
] | extra/IForest.v | subtree | |
bind_iforest {E} : forall A B, iforest E A -> (A -> iforest E B) -> iforest E B := fun A B (specA : iforest E A) (K: A -> iforest E B) (tb: itree E B) => exists (ta: itree E A) (k: A -> itree E B), specA ta /\ tb ≈ bind ta k /\ (forall a, Leaf a ta -> K a (k a)). | Definition | extra | [
"From Paco Require Import paco.",
"From ExtLib Require Import\n Structures."
] | extra/IForest.v | bind_iforest |
End of preview. Expand in Data Studio
Coq-InteractionTrees
Structured dataset from Interaction Trees — Representing recursive and impure programs.
2,936 declarations extracted from Coq source files.
Applications
- Training language models on formal proofs
- Fine-tuning theorem provers
- Retrieval-augmented generation for proof assistants
- Learning proof embeddings and representations
Source
- Repository: https://github.com/DeepSpec/InteractionTrees
Schema
| Column | Type | Description |
|---|---|---|
| fact | string | Declaration body |
| type | string | Lemma, Definition, Theorem, etc. |
| library | string | Source module |
| imports | list | Required imports |
| filename | string | Source file path |
| symbolic_name | string | Identifier |
- Downloads last month
- 11