fact stringlengths 8 1.54k | type stringclasses 19
values | library stringclasses 8
values | imports listlengths 1 10 | filename stringclasses 98
values | symbolic_name stringlengths 1 42 | docstring stringclasses 1
value |
|---|---|---|---|---|---|---|
incr_tallybs x :=
if bs isn't b :: bs then [:: (x, 1)] else
if x == b.1 then (x, b.2.+1) :: bs else b :: incr_tally bs x. | Fixpoint | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | incr_tally | |
tallys := foldl incr_tally [::] s. | Definition | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | tally | |
wf_tally:=
[qualify a bs : seq (T * nat) | uniq (unzip1 bs) && (0 \notin unzip2 bs)]. | Definition | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | wf_tally | |
tally_seqbs := flatten [seq nseq b.2 b.1 | b <- bs].
Local Notation tseq := tally_seq. | Definition | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | tally_seq | |
size_tally_seqbs : size (tally_seq bs) = sumn (unzip2 bs).
Proof.
by rewrite size_flatten /shape -map_comp; under eq_map do rewrite /= size_nseq.
Qed. | Lemma | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | size_tally_seq | |
tally_seqK: {in wf_tally, cancel tally_seq tally}.
Proof.
move=> bs /andP[]; elim: bs => [|[x [|n]] bs IHbs] //= /andP[bs'x Ubs] bs'0.
rewrite inE /tseq /tally /= -[n.+1]addn1 in bs'0 *.
elim: n 1 => /= [|n IHn] m; last by rewrite eqxx IHn addnS.
rewrite -{}[in RHS]IHbs {Ubs bs'0}// /tally /tally_seq add0n.
elim: bs bs... | Lemma | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | tally_seqK | |
incr_tallyPx : {homo incr_tally^~ x : bs / bs \in wf_tally}.
Proof.
move=> bs /andP[]; rewrite unfold_in.
elim: bs => [|[y [|n]] bs IHbs] //= /andP[bs'y Ubs] /[1!inE] /= bs'0.
have [<- | y'x] /= := eqVneq y; first by rewrite bs'y Ubs.
rewrite -andbA {}IHbs {Ubs bs'0}// andbT.
elim: bs bs'y => [|b bs IHbs] /=; rewrite i... | Lemma | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | incr_tallyP | |
tallyPs : tally s \is a wf_tally.
Proof.
rewrite /tally; set bs := [::]; have: bs \in wf_tally by [].
by elim: s bs => //= x s IHs bs /(incr_tallyP x)/IHs.
Qed. | Lemma | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | tallyP | |
tallyKs : perm_eq (tally_seq (tally s)) s.
Proof.
rewrite -[s in perm_eq _ s]cats0 -[nil]/(tseq [::]) /tally.
elim: s [::] => //= x s IHs bs; rewrite {IHs}(permPl (IHs _)).
rewrite perm_sym -cat1s perm_catCA {s}perm_cat2l.
elim: bs => //= b bs IHbs; case: eqP => [-> | _] //=.
by rewrite -cat1s perm_catCA perm_cat2l.
Qe... | Lemma | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | tallyK | |
tallyEls : perm_eq (unzip1 (tally s)) (undup s).
Proof.
have /andP[Ubs bs'0] := tallyP s; set bs := tally s in Ubs bs'0 *.
rewrite uniq_perm ?undup_uniq {Ubs}// => x.
rewrite mem_undup -(perm_mem (tallyK s)) -/bs.
elim: bs => [|[y [|m]] bs IHbs] //= in bs'0 *.
by rewrite inE IHbs // mem_cat mem_nseq.
Qed. | Lemma | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | tallyEl | |
tallyEs : perm_eq (tally s) [seq (x, count_mem x s) | x <- undup s].
Proof.
have /andP[Ubs _] := tallyP s; pose b := [fun s x => (x, count_mem x (tseq s))].
suffices /permPl->: perm_eq (tally s) (map (b (tally s)) (unzip1 (tally s))).
congr perm_eq: (perm_map (b (tally s)) (tallyEl s)).
by under eq_map do rewrite /... | Lemma | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | tallyE | |
perm_tallys1 s2 : perm_eq s1 s2 -> perm_eq (tally s1) (tally s2).
Proof.
move=> eq_s12; apply: (@perm_trans _ [seq (x, count_mem x s2) | x <- undup s1]).
by congr perm_eq: (tallyE s1); under eq_map do rewrite (permP eq_s12).
by rewrite (permPr (tallyE s2)); apply/perm_map/perm_undup/(perm_mem eq_s12).
Qed. | Lemma | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | perm_tally | |
perm_tally_seqbs1 bs2 :
perm_eq bs1 bs2 -> perm_eq (tally_seq bs1) (tally_seq bs2).
Proof. by move=> Ebs12; rewrite perm_flatten ?perm_map. Qed.
Local Notation perm_tseq := perm_tally_seq. | Lemma | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | perm_tally_seq | |
perm_count_undups :
perm_eq (flatten [seq nseq (count_mem x s) x | x <- undup s]) s.
Proof.
by rewrite -(permPr (tallyK s)) (permPr (perm_tseq (tallyE s))) /tseq -map_comp.
Qed.
Local Fixpoint cons_perms_ perms_rec (s : seq T) bs bs2 acc :=
if bs isn't b :: bs1 then acc else
if b isn't (x, m.+1) then cons_perms_ ... | Lemma | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | perm_count_undup | |
permutationss := perms_rec (size s) [::] (tally s) [::].
Let permsP s : exists n bs,
[/\ permutations s = perms_rec n [::] bs [::],
size (tseq bs) == n, perm_eq (tseq bs) s & uniq (unzip1 bs)].
Proof.
have /andP[Ubs _] := tallyP s; exists (size s), (tally s).
by rewrite (perm_size (tallyK s)) tallyK.
Qed.
Loc... | Definition | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | permutations | |
mem_permutationss t : (t \in permutations s) = perm_eq t s.
Proof.
have{s} [n [bs [-> Dn /permPr<- _]]] := permsP s.
elim: n => [|n IHn] /= in t bs Dn *.
by rewrite inE (nilP Dn); apply/eqP/perm_nilP.
rewrite -[bs in tseq bs]cats0 in Dn *; have x0 : T by case: (tseq _) Dn.
rewrite -[RHS](@andb_idl (last x0 t \in tseq... | Lemma | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | mem_permutations | |
permutations_uniqs : uniq (permutations s).
Proof.
have{s} [n [bs [-> Dn _ Ubs]]] := permsP s.
elim: n => //= n IHn in bs Dn Ubs *; rewrite -[bs]cats0 /unzip1 in Dn Ubs.
elim: bs [::] => [|[x [|m]] bs IHbs] //= bs2 in Dn Ubs *.
by case/andP: Ubs => _ /IHbs->.
rewrite /= cons_permsE cat_uniq has_sym andbCA andbC.
rewr... | Lemma | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | permutations_uniq | |
perms:= permutations. | Notation | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | perms | |
permutationsEs :
0 < size s ->
perm_eq (perms s) [seq x :: t | x <- undup s, t <- perms (rem x s)].
Proof.
move=> nt_s; apply/uniq_perm=> [||t]; first exact: permutations_uniq.
apply/allpairs_uniq_dep=> [|x _|]; rewrite ?undup_uniq ?permutations_uniq //.
by case=> [_ _] [x t] _ _ [-> ->].
rewrite mem_permuta... | Lemma | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | permutationsE | |
permutationsErotx s (le_x := fun t => iota 0 (index x t + 1)) :
perm_eq (perms (x :: s)) [seq rot i (x :: t) | t <- perms s, i <- le_x t].
Proof.
have take'x t i: i <= index x t -> i <= size t /\ x \notin take i t.
move=> le_i_x; have le_i_t: i <= size t := leq_trans le_i_x (index_size x t).
case: (nthP x) => // ... | Lemma | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | permutationsErot | |
size_permutationss : uniq s -> size (permutations s) = (size s)`!.
Proof.
move Dn: (size s) => n Us; elim: n s => [[]|n IHn s] //= in Dn Us *.
rewrite (perm_size (permutationsE _)) ?Dn // undup_id // factS -Dn.
rewrite -(size_iota 0 n`!) -(size_allpairs (fun=>id)) !size_allpairs_dep.
by apply/congr1/eq_in_map=> x sx; r... | Lemma | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | size_permutations | |
permutations_all_uniqs : uniq s -> all uniq (permutations s).
Proof.
by move=> Us; apply/allP=> t; rewrite mem_permutations => /perm_uniq->.
Qed. | Lemma | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | permutations_all_uniq | |
perm_permutationss t :
perm_eq s t -> perm_eq (permutations s) (permutations t).
Proof.
move=> Est; apply/uniq_perm; try exact: permutations_uniq.
by move=> u; rewrite !mem_permutations (permPr Est).
Qed. | Lemma | boot | [
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat"
] | boot/seq.v | perm_permutations | |
change_typety ty' (x : ty) (strategy : ty = ty') : ty' :=
ecast ty ty strategy x. | Definition | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | change_type | |
simplrefl:= (ltac: (simpl; reflexivity)) (only parsing). | Notation | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | simplrefl | |
cbvrefl:= (ltac: (cbv; reflexivity)) (only parsing). | Notation | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | cbvrefl | |
vmrefl:= (ltac: (vm_compute; reflexivity)) (only parsing). | Notation | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | vmrefl | |
of_uint_acc(d:Decimal.uint) (acc:positive) :=
match d with
| Decimal.Nil => acc
| Decimal.D0 l => of_uint_acc l (mul ten acc)
| Decimal.D1 l => of_uint_acc l (add 1 (mul ten acc))
| Decimal.D2 l => of_uint_acc l (add 1~0 (mul ten acc))
| Decimal.D3 l => of_uint_acc l (add 1~1 (mul ten acc))
| Decimal.D4 l... | Fixpoint | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | of_uint_acc | |
of_uint(d:Decimal.uint) : N :=
match d with
| Decimal.Nil => N0
| Decimal.D0 l => of_uint l
| Decimal.D1 l => Npos (of_uint_acc l 1)
| Decimal.D2 l => Npos (of_uint_acc l 1~0)
| Decimal.D3 l => Npos (of_uint_acc l 1~1)
| Decimal.D4 l => Npos (of_uint_acc l 1~0~0)
| Decimal.D5 l => Npos (of_uint_acc l 1~... | Fixpoint | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | of_uint | |
of_hex_uint_acc(d:Hexadecimal.uint) (acc:positive) :=
match d with
| Hexadecimal.Nil => acc
| Hexadecimal.D0 l => of_hex_uint_acc l (mul sixteen acc)
| Hexadecimal.D1 l => of_hex_uint_acc l (add 1 (mul sixteen acc))
| Hexadecimal.D2 l => of_hex_uint_acc l (add 1~0 (mul sixteen acc))
| Hexadecimal.D3 l => of... | Fixpoint | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | of_hex_uint_acc | |
of_hex_uint(d:Hexadecimal.uint) : N :=
match d with
| Hexadecimal.Nil => N0
| Hexadecimal.D0 l => of_hex_uint l
| Hexadecimal.D1 l => Npos (of_hex_uint_acc l 1)
| Hexadecimal.D2 l => Npos (of_hex_uint_acc l 1~0)
| Hexadecimal.D3 l => Npos (of_hex_uint_acc l 1~1)
| Hexadecimal.D4 l => Npos (of_hex_uint_acc... | Fixpoint | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | of_hex_uint | |
of_int(d:Decimal.int) : option positive :=
match d with
| Decimal.Pos d =>
match of_uint d with
| N0 => None
| Npos p => Some p
end
| Decimal.Neg _ => None
end. | Definition | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | of_int | |
of_hex_int(d:Hexadecimal.int) : option positive :=
match d with
| Hexadecimal.Pos d =>
match of_hex_uint d with
| N0 => None
| Npos p => Some p
end
| Hexadecimal.Neg _ => None
end. | Definition | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | of_hex_int | |
of_num_int(d:Number.int) : option positive :=
match d with
| Number.IntDecimal d => of_int d
| Number.IntHexadecimal d => of_hex_int d
end. | Definition | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | of_num_int | |
to_little_uintp :=
match p with
| xH => Decimal.D1 Decimal.Nil
| xI p => Decimal.Little.succ_double (to_little_uint p)
| xO p => Decimal.Little.double (to_little_uint p)
end. | Fixpoint | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | to_little_uint | |
to_uintp := Decimal.rev (to_little_uint p). | Definition | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | to_uint | |
to_num_uintp := Number.UIntDecimal (to_uint p). | Definition | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | to_num_uint | |
Nsuccn :=
match n with
| N0 => Npos xH
| Npos p => Npos (Pos.succ p)
end. | Definition | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | Nsucc | |
nat_of_succ_binb : nat_of_bin (Nsucc b) = 1 + nat_of_bin b :> nat.
Proof. by case: b => [//|p /=]; rewrite nat_of_succ_pos. Qed. | Lemma | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | nat_of_succ_bin | |
eqb_eqp q : Pos.eqb p q = true <-> p=q.
Proof.
by elim: p q => [p IHp|p IHp|] [q|q|] //=; split=> [/IHp->//|]; case=> /IHp.
Qed. | Theorem | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | eqb_eq | |
Definition_ := hasDecEq.Build positive
(fun _ _ => equivP idP (Pos.eqb_eq _ _)). | HB.instance | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | Definition | |
syntax:= Leaf of positive | Op of syntax & syntax. | Inductive | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | syntax | |
serial:= (fix loop (acc : seq positive) (s : syntax) :=
match s with
| Leaf n => n :: acc
| Op s s' => (loop^~ s (loop^~ s' acc))
end) [::]. | Coercion | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | serial | |
serial_Ops1 s2 : Op s1 s2 = s1 ++ s2 :> seq _.
Proof.
rewrite /serial; set loop := (X in X [::]); rewrite -/loop.
elim: s1 (loop [::] s2) => [n|s11 IHs1 s12 IHs2] //= l.
by rewrite IHs1 [in RHS]IHs1 IHs2 catA.
Qed. | Lemma | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | serial_Op | |
Leaf_of_natn := Leaf (Pos.sub (pos_of_nat n n) xH). | Definition | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | Leaf_of_nat | |
Leaf: positive >-> syntax. | Coercion | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | Leaf | |
Leaf_of_nat: nat >-> syntax. | Coercion | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | Leaf_of_nat | |
pattern(s : syntax) := ((fix loop n s :=
match s with
| Leaf 1%positive => (Leaf n, Pos.succ n)
| Leaf m => Pos.iter (fun oi => (Op oi.1 (Leaf oi.2), Pos.succ oi.2))
(Leaf n, Pos.succ n) (Pos.sub m xH)
| Op s s' => let: (p, n') := loop n s in
let: (p', n'') := loop n' s' in... | Definition | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | pattern | |
env:= Empty | ENode of T & env & env. | Inductive | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | env | |
pos:= fix loop (e : env) p {struct e} :=
match e, p with
| ENode t _ _, 1%positive => t
| ENode t e _, (p~0)%positive => loop e p
| ENode t _ e, (p~1)%positive => loop e p
| _, _ => idx
end. | Definition | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | pos | |
set_pos(f : T -> T) := fix loop e p {struct p} :=
match e, p with
| ENode t e e', 1%positive => ENode (f t) e e'
| ENode t e e', (p~0)%positive => ENode t (loop e p) e'
| ENode t e e', (p~1)%positive => ENode t e (loop e' p)
| Empty, 1%positive => ENode (f idx) Empty Empty
| Empty, (p~0)%positive => ENode idx (l... | Definition | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | set_pos | |
pos_set_pos(f : T -> T) e (p p' : positive) :
pos (set_pos f e p) p' = if p == p' then f (pos e p) else pos e p'.
Proof. by elim: p e p' => [p IHp|p IHp|] [|???] [?|?|]//=; rewrite IHp. Qed. | Lemma | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | pos_set_pos | |
unzipz (e : env) : env := match z with
| [::] => e
| (x, inl e') :: z' => unzip z' (ENode x e' e)
| (x, inr e') :: z' => unzip z' (ENode x e e')
end. | Fixpoint | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | unzip | |
set_pos_trec(f : T -> T) := fix loop z e p {struct p} :=
match e, p with
| ENode t e e', 1%positive => unzip z (ENode (f t) e e')
| ENode t e e', (p~0)%positive => loop ((t, inr e') :: z) e p
| ENode t e e', (p~1)%positive => loop ((t, inl e) :: z) e' p
| Empty, 1%positive => unzip z (ENode (f idx) Empty Empty)
... | Definition | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | set_pos_trec | |
set_pos_trecEf z e p : set_pos_trec f z e p = unzip z (set_pos f e p).
Proof. by elim: p e z => [p IHp|p IHp|] [|???] [|[??]?] //=; rewrite ?IHp. Qed. | Lemma | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | set_pos_trecE | |
eval(e : env) := fix loop (s : syntax) :=
match s with
| Leaf n => pos e n
| Op s s' => op (loop s) (loop s')
end. | Definition | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | eval | |
content:= (fix loop (acc : env N) s :=
match s with
| Leaf n => set_pos_trec N0 Pos.Nsucc [::] acc n
| Op s s' => loop (loop acc s') s
end) Empty. | Definition | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | content | |
count_memEx (t : syntax) :
count_mem x t = nat_of_bin (pos N0 (content t) x).
Proof.
rewrite /content; set loop := (X in X Empty); rewrite -/loop.
rewrite -[LHS]addn0.
have <- : nat_of_bin (pos N0 Empty x) = 0 :> nat by elim: x.
elim: t Empty => [n|s IHs s' IHs'] e //=; last first.
by rewrite serial_Op count_cat -a... | Lemma | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | count_memE | |
cforallN T : env N -> (env T -> Type) -> Type := env_rect (@^~ Empty)
(fun _ e IHe e' IHe' R => forall x, IHe (fun xe => IHe' (R \o ENode x xe))). | Definition | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | cforall | |
cforallPN T R : (forall e : env T, R e) -> forall (e : env N), cforall e R.
Proof.
move=> Re e; elim: e R Re => [|? e /= IHe e' IHe' ?? x] //=.
by apply: IHe => ?; apply: IHe' => /=.
Qed. | Lemma | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | cforallP | |
proof(p s : syntax) : content p = content s ->
forall env, eval idx op env p = eval idx op env s.
Proof.
suff evalE env t : eval idx op env t = \big[op/idx]_(i <- t) (pos idx env i).
move=> cps e; rewrite !evalE; apply: perm_big.
by apply/allP => x _ /=; rewrite !count_memE cps.
elim: t => //= [n|t -> t' ->]; las... | Lemma | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | proof | |
directp s ps := cforallP (@proof p s ps) (content p). | Definition | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | direct | |
AC_check_pattern:=
(ltac: (match goal with
|- AC.content ?pat = AC.content ?ord =>
let pat' := fresh "pat" in let pat' := eval compute in pat in
tryif unify pat' ord then
fail 1 "AC: equality between" pat
"and" ord "is trivial, cannot progress"
else tryif vm_compute;... | Notation | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | AC_check_pattern | |
opACoflaw p s :=
((fun T idx op assoc lid rid comm => (change_type (@AC.direct T idx
(Monoid.ComLaw.Pack
(Monoid.ComLaw.Class
(SemiGroup.isLaw.Axioms_ op assoc)
(Monoid.isMonoidLaw.Axioms_ idx op lid rid)
(SemiGroup.isCommutativeLaw.Axioms_ op comm)))
p%AC s%AC AC_check_pattern) c... | Notation | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | opACof | |
opACop p s := (opACof op (AC.pattern p%AC) s%AC) (only parsing). | Notation | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | opAC | |
opAClop s := (opAC op (AC.Leaf_of_nat (size (AC.serial s%AC))) s%AC)
(only parsing). | Notation | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | opACl | |
AC_strategy:=
(ltac: (cbv -[Monoid.ComLaw.sort Monoid.Law.sort]; reflexivity))
(only parsing). | Notation | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | AC_strategy | |
ACofp s := (change_type
(@AC.direct _ _ _ p%AC s%AC AC_check_pattern) AC_strategy)
(only parsing). | Notation | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | ACof | |
ACp s := (ACof (AC.pattern p%AC) s%AC) (only parsing). | Notation | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | AC | |
ACls := (AC (AC.Leaf_of_nat (size (AC.serial s%AC))) s%AC)
(only parsing). | Notation | boot | [
"From HB Require Import structures",
"From Corelib Require Import PosDef",
"From mathcomp Require Import ssreflect ssrbool ssrfun ssrnat eqtype seq bigop"
] | boot/ssrAC.v | ACl | |
homo_mono1[aT rT : Type] [f : aT -> rT] [g : rT -> aT]
[aP : pred aT] [rP : pred rT] :
cancel g f ->
{homo f : x / aP x >-> rP x} ->
{homo g : x / rP x >-> aP x} -> {mono g : x / rP x >-> aP x}.
Proof. by move=> gK fP gP x; apply/idP/idP => [/fP|/gP//]; rewrite gK. Qed. | Lemma | boot | [
"From mathcomp Require Import ssreflect ssrfun",
"From Corelib Require Export ssrbool"
] | boot/ssrbool.v | homo_mono1 | |
if_andb1 b2 T (x y : T) :
(if b1 && b2 then x else y) = (if b1 then if b2 then x else y else y).
Proof. by case: b1 b2 => [] []. Qed. | Lemma | boot | [
"From mathcomp Require Import ssreflect ssrfun",
"From Corelib Require Export ssrbool"
] | boot/ssrbool.v | if_and | |
if_orb1 b2 T (x y : T) :
(if b1 || b2 then x else y) = (if b1 then x else if b2 then x else y).
Proof. by case: b1 b2 => [] []. Qed. | Lemma | boot | [
"From mathcomp Require Import ssreflect ssrfun",
"From Corelib Require Export ssrbool"
] | boot/ssrbool.v | if_or | |
if_implybb1 b2 T (x y : T) :
(if b1 ==> b2 then x else y) = (if b1 then if b2 then x else y else x).
Proof. by case: b1 b2 => [] []. Qed. | Lemma | boot | [
"From mathcomp Require Import ssreflect ssrfun",
"From Corelib Require Export ssrbool"
] | boot/ssrbool.v | if_implyb | |
if_implybCb1 b2 T (x y : T) :
(if b1 ==> b2 then x else y) = (if b2 then x else if b1 then y else x).
Proof. by case: b1 b2 => [] []. Qed. | Lemma | boot | [
"From mathcomp Require Import ssreflect ssrfun",
"From Corelib Require Export ssrbool"
] | boot/ssrbool.v | if_implybC | |
if_addb1 b2 T (x y : T) :
(if b1 (+) b2 then x else y) = (if b1 then if b2 then y else x else if b2 then x else y).
Proof. by case: b1 b2 => [] []. Qed. | Lemma | boot | [
"From mathcomp Require Import ssreflect ssrfun",
"From Corelib Require Export ssrbool"
] | boot/ssrbool.v | if_add | |
relpre_trans{T' T : Type} {leT : rel T} {f : T' -> T} :
transitive leT -> transitive (relpre f leT).
Proof. by move=> + y x z; apply. Qed. | Lemma | boot | [
"From mathcomp Require Import ssreflect ssrfun",
"From Corelib Require Export ssrbool"
] | boot/ssrbool.v | relpre_trans | |
nosimplt := (nosimpl t). | Notation | boot | [
"From Corelib Require Export ssreflect"
] | boot/ssreflect.v | nosimpl | |
hide{T} t : T := t. | Definition | boot | [
"From Corelib Require Export ssreflect"
] | boot/ssreflect.v | hide | |
hideT:= (@hide (hide _)) (only parsing). | Notation | boot | [
"From Corelib Require Export ssreflect"
] | boot/ssreflect.v | hideT | |
injective2(rT aT1 aT2 : Type) (f : aT1 -> aT2 -> rT) :=
forall (x1 x2 : aT1) (y1 y2 : aT2), f x1 y1 = f x2 y2 -> (x1 = x2) * (y1 = y2).
Arguments injective2 [rT aT1 aT2] f. | Definition | boot | [
"From mathcomp Require Import ssreflect",
"From Corelib Require Export ssrfun",
"From mathcomp Require Export ssrnotations"
] | boot/ssrfun.v | injective2 | |
inj_omap{aT rT : Type} (f : aT -> rT) :
injective f -> injective (omap f).
Proof. by move=> injf [?|] [?|] //= [/injf->]. Qed. | Lemma | boot | [
"From mathcomp Require Import ssreflect",
"From Corelib Require Export ssrfun",
"From mathcomp Require Export ssrnotations"
] | boot/ssrfun.v | inj_omap | |
omap_id{T : Type} (x : option T) : omap id x = x.
Proof. by case: x. Qed. | Lemma | boot | [
"From mathcomp Require Import ssreflect",
"From Corelib Require Export ssrfun",
"From mathcomp Require Export ssrnotations"
] | boot/ssrfun.v | omap_id | |
eq_omap{aT rT : Type} (f g : aT -> rT) : f =1 g -> omap f =1 omap g.
Proof. by move=> Ef [?|] //=; rewrite Ef. Qed. | Lemma | boot | [
"From mathcomp Require Import ssreflect",
"From Corelib Require Export ssrfun",
"From mathcomp Require Export ssrnotations"
] | boot/ssrfun.v | eq_omap | |
omapK{aT rT : Type} (f : aT -> rT) (g : rT -> aT) :
cancel f g -> cancel (omap f) (omap g).
Proof. by move=> fK [?|] //=; rewrite fK. Qed. | Lemma | boot | [
"From mathcomp Require Import ssreflect",
"From Corelib Require Export ssrfun",
"From mathcomp Require Export ssrnotations"
] | boot/ssrfun.v | omapK | |
idempotent_op(S : Type) (op : S -> S -> S) := forall x, op x x = x.
#[deprecated(since="mathcomp 2.3.0", note="use `idempotent_op` instead")] | Definition | boot | [
"From mathcomp Require Import ssreflect",
"From Corelib Require Export ssrfun",
"From mathcomp Require Export ssrnotations"
] | boot/ssrfun.v | idempotent_op | |
idempotent:= idempotent_op (only parsing). | Notation | boot | [
"From mathcomp Require Import ssreflect",
"From Corelib Require Export ssrfun",
"From mathcomp Require Export ssrnotations"
] | boot/ssrfun.v | idempotent | |
idempotent_fun(U : Type) (f : U -> U) := f \o f =1 f. | Definition | boot | [
"From mathcomp Require Import ssreflect",
"From Corelib Require Export ssrfun",
"From mathcomp Require Export ssrnotations"
] | boot/ssrfun.v | idempotent_fun | |
inr_inj{A B} : injective (@inr A B). Proof. by move=> ? ? []. Qed. | Lemma | boot | [
"From mathcomp Require Import ssreflect",
"From Corelib Require Export ssrfun",
"From mathcomp Require Export ssrnotations"
] | boot/ssrfun.v | inr_inj | |
inl_inj{A B} : injective (@inl A B). Proof. by move=> ? ? []. Qed. | Lemma | boot | [
"From mathcomp Require Import ssreflect",
"From Corelib Require Export ssrfun",
"From mathcomp Require Export ssrnotations"
] | boot/ssrfun.v | inl_inj | |
taggedK{I : Type} (T_ : I -> Type) (s : {i : I & T_ i}) :
Tagged T_ (tagged s) = s.
Proof. by case: s. Qed. | Lemma | boot | [
"From mathcomp Require Import ssreflect",
"From Corelib Require Export ssrfun",
"From mathcomp Require Export ssrnotations"
] | boot/ssrfun.v | taggedK | |
swap_pair{T1 T2 : Type} (x : T1 * T2) := (x.2, x.1). | Definition | boot | [
"From mathcomp Require Import ssreflect",
"From Corelib Require Export ssrfun",
"From mathcomp Require Export ssrnotations"
] | boot/ssrfun.v | swap_pair | |
swap_pairK{T1 T2 : Type} : @cancel _ (T1 * T2) swap_pair swap_pair.
Proof. by case. Qed. | Lemma | boot | [
"From mathcomp Require Import ssreflect",
"From Corelib Require Export ssrfun",
"From mathcomp Require Export ssrnotations"
] | boot/ssrfun.v | swap_pairK | |
succn:= Datatypes.S. | Notation | boot | [
"From Corelib Require Import PosDef",
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype"
] | boot/ssrnat.v | succn | |
predn:= Peano.pred. | Notation | boot | [
"From Corelib Require Import PosDef",
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype"
] | boot/ssrnat.v | predn | |
succnK: cancel succn predn. Proof. by []. Qed. | Lemma | boot | [
"From Corelib Require Import PosDef",
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype"
] | boot/ssrnat.v | succnK | |
succn_inj: injective succn. Proof. by move=> n m []. Qed. | Lemma | boot | [
"From Corelib Require Import PosDef",
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype"
] | boot/ssrnat.v | succn_inj | |
eqnm n {struct m} :=
match m, n with
| 0, 0 => true
| m'.+1, n'.+1 => eqn m' n'
| _, _ => false
end. | Fixpoint | boot | [
"From Corelib Require Import PosDef",
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype"
] | boot/ssrnat.v | eqn | |
eqnP: Equality.axiom eqn.
Proof.
move=> n m; apply: (iffP idP) => [|<-]; last by elim n.
by elim: n m => [|n IHn] [|m] //= /IHn->.
Qed.
HB.instance Definition _ := hasDecEq.Build nat eqnP.
Arguments eqn !m !n.
Arguments eqnP {x y}. | Lemma | boot | [
"From Corelib Require Import PosDef",
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype"
] | boot/ssrnat.v | eqnP | |
eqnE: eqn = eq_op. Proof. by []. Qed. | Lemma | boot | [
"From Corelib Require Import PosDef",
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype"
] | boot/ssrnat.v | eqnE |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.