fact stringlengths 9 1.52k | type stringclasses 12
values | library stringclasses 3
values | imports listlengths 2 11 | filename stringclasses 54
values | symbolic_name stringlengths 1 44 | docstring stringclasses 420
values |
|---|---|---|---|---|---|---|
bvn_unsigned (b : bvn) := bv_unsigned (b.(bvn_val)). | Definition | stdpp_bitvector | [
"Stdlib.ZifyNat",
"stdpp.numbers",
"stdpp.countable",
"stdpp.finite",
"stdpp.options"
] | stdpp_bitvector/definitions.v | bvn_unsigned | null |
bvn_eq (b1 b2 : bvn) :
b1 = b2 ↔ b1.(bvn_n) = b2.(bvn_n) ∧ bvn_unsigned b1 = bvn_unsigned b2. | Lemma | stdpp_bitvector | [
"Stdlib.ZifyNat",
"stdpp.numbers",
"stdpp.countable",
"stdpp.finite",
"stdpp.options"
] | stdpp_bitvector/definitions.v | bvn_eq | null |
bvn_to_bv (n : N) (b : bvn) : option (bv n) :=
match decide (b.(bvn_n) = n) with
| left eq => Some (eq_rect (bvn_n b) (λ n0 : N, bv n0) (bvn_val b) n eq)
| right _ => None
end. | Definition | stdpp_bitvector | [
"Stdlib.ZifyNat",
"stdpp.numbers",
"stdpp.countable",
"stdpp.finite",
"stdpp.options"
] | stdpp_bitvector/definitions.v | bvn_to_bv | null |
bv_extract_concat_later m n1 n2 s l (b1 : bv n1) (b2 : bv n2):
(n2 ≤ s)%N →
(m = n1 + n2)%N →
bv_extract s l (bv_concat m b1 b2) = bv_extract (s - n2) l b1. | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_extract_concat_later | * General lemmas |
bv_extract_concat_here m n1 n2 s (b1 : bv n1) (b2 : bv n2):
s = 0%N →
(m = n1 + n2)%N →
bv_extract s n2 (bv_concat m b1 b2) = b2. | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_extract_concat_here | null |
BvUnfold (n : N) (signed : bool) (wrapped : bool) (b : bv n) (z : Z) := {
bv_unfold_proof : ((if signed then bv_signed else bv_unsigned) b) =
(if wrapped then bv_suwrap signed n z else z);
}. | Class | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | BvUnfold | null |
BV_UNFOLD_BLOCK {A} (x : A) : A := x. | Definition | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | BV_UNFOLD_BLOCK | [BV_UNFOLD_BLOCK] is a marker that this occurrence of [bv_signed]
or [bv_unsigned] has already been simplified. |
bv_unfold_end s w n b :
BvUnfold n s w b ((if s then BV_UNFOLD_BLOCK bv_signed else BV_UNFOLD_BLOCK bv_unsigned) b). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_end | null |
bv_unfold_BV s w n z Hwf :
BvUnfold n s w (@BV _ z Hwf) (if w then z else if s then bv_swrap n z else z). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_BV | null |
bv_unfold_bv_0 s w n :
BvUnfold n s w (bv_0 n) 0. | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_bv_0 | null |
bv_unfold_Z_to_bv s w n z :
BvUnfold n s w (Z_to_bv _ z) (if w then z else bv_suwrap s n z). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_Z_to_bv | null |
bv_unfold_succ s w n b z :
BvUnfold n s true b z →
BvUnfold n s w (bv_succ b) (if w then Z.succ z else bv_suwrap s n (Z.succ z)). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_succ | null |
bv_unfold_pred s w n b z :
BvUnfold n s true b z →
BvUnfold n s w (bv_pred b) (if w then Z.pred z else bv_suwrap s n (Z.pred z)). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_pred | null |
bv_unfold_add s w n b1 b2 z1 z2 :
BvUnfold n s true b1 z1 →
BvUnfold n s true b2 z2 →
BvUnfold n s w (bv_add b1 b2) (if w then z1 + z2 else bv_suwrap s n (z1 + z2)). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_add | null |
bv_unfold_sub s w n b1 b2 z1 z2 :
BvUnfold n s true b1 z1 →
BvUnfold n s true b2 z2 →
BvUnfold n s w (bv_sub b1 b2) (if w then z1 - z2 else bv_suwrap s n (z1 - z2)). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_sub | null |
bv_unfold_opp s w n b z :
BvUnfold n s true b z →
BvUnfold n s w (bv_opp b) (if w then - z else bv_suwrap s n (- z)). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_opp | null |
bv_unfold_mul s w n b1 b2 z1 z2 :
BvUnfold n s true b1 z1 →
BvUnfold n s true b2 z2 →
BvUnfold n s w (bv_mul b1 b2) (if w then z1 * z2 else bv_suwrap s n (z1 * z2)). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_mul | null |
bv_unfold_divu s w n b1 b2 z1 z2 :
BvUnfold n false false b1 z1 →
BvUnfold n false false b2 z2 →
BvUnfold n s w (bv_divu b1 b2) (if w then z1 `div` z2 else if s then bv_swrap n (z1 `div` z2) else z1 `div` z2). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_divu | null |
bv_unfold_modu s w n b1 b2 z1 z2 :
BvUnfold n false false b1 z1 →
BvUnfold n false false b2 z2 →
BvUnfold n s w (bv_modu b1 b2) (if w then z1 `mod` z2 else if s then bv_swrap n (z1 `mod` z2) else z1 `mod` z2). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_modu | null |
bv_unfold_divs s w n b1 b2 z1 z2 :
BvUnfold n true false b1 z1 →
BvUnfold n true false b2 z2 →
BvUnfold n s w (bv_divs b1 b2) (if w then z1 `div` z2 else bv_suwrap s n (z1 `div` z2)). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_divs | null |
bv_unfold_quots s w n b1 b2 z1 z2 :
BvUnfold n true false b1 z1 →
BvUnfold n true false b2 z2 →
BvUnfold n s w (bv_quots b1 b2) (if w then z1 `quot` z2 else bv_suwrap s n (z1 `quot` z2)). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_quots | null |
bv_unfold_mods s w n b1 b2 z1 z2 :
BvUnfold n true false b1 z1 →
BvUnfold n true false b2 z2 →
BvUnfold n s w (bv_mods b1 b2) (if w then z1 `mod` z2 else bv_suwrap s n (z1 `mod` z2)). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_mods | null |
bv_unfold_rems s w n b1 b2 z1 z2 :
BvUnfold n true false b1 z1 →
BvUnfold n true false b2 z2 →
BvUnfold n s w (bv_rems b1 b2) (if w then z1 `rem` z2 else bv_suwrap s n (z1 `rem` z2)). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_rems | null |
bv_unfold_shiftl s w n b1 b2 z1 z2 :
BvUnfold n false false b1 z1 →
BvUnfold n false false b2 z2 →
BvUnfold n s w (bv_shiftl b1 b2) (if w then z1 ≪ z2 else bv_suwrap s n (z1 ≪ z2)). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_shiftl | null |
bv_unfold_shiftr s w n b1 b2 z1 z2 :
BvUnfold n false false b1 z1 →
BvUnfold n false false b2 z2 →
BvUnfold n s w (bv_shiftr b1 b2) (if w then z1 ≫ z2 else if s then bv_swrap n (z1 ≫ z2) else (z1 ≫ z2)). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_shiftr | null |
bv_unfold_ashiftr s w n b1 b2 z1 z2 :
BvUnfold n true false b1 z1 →
BvUnfold n false false b2 z2 →
BvUnfold n s w (bv_ashiftr b1 b2) (if w then z1 ≫ z2 else bv_suwrap s n (z1 ≫ z2)). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_ashiftr | null |
bv_unfold_or s w n b1 b2 z1 z2 :
BvUnfold n false false b1 z1 →
BvUnfold n false false b2 z2 →
BvUnfold n s w (bv_or b1 b2) (if w then Z.lor z1 z2 else if s then bv_swrap n (Z.lor z1 z2) else Z.lor z1 z2). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_or | null |
bv_unfold_and s w n b1 b2 z1 z2 :
BvUnfold n false false b1 z1 →
BvUnfold n false false b2 z2 →
BvUnfold n s w (bv_and b1 b2) (if w then Z.land z1 z2 else if s then bv_swrap n (Z.land z1 z2) else Z.land z1 z2). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_and | null |
bv_unfold_xor s w n b1 b2 z1 z2 :
BvUnfold n false false b1 z1 →
BvUnfold n false false b2 z2 →
BvUnfold n s w (bv_xor b1 b2) (if w then Z.lxor z1 z2 else if s then bv_swrap n (Z.lxor z1 z2) else Z.lxor z1 z2). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_xor | null |
bv_unfold_not s w n b z :
BvUnfold n false false b z →
BvUnfold n s w (bv_not b) (if w then Z.lnot z else bv_suwrap s n (Z.lnot z)). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_not | null |
bv_unfold_zero_extend s w n n' b z `{!TCFastDone (n' <=? n = true)%N} :
BvUnfold n' false false b z →
BvUnfold n s w (bv_zero_extend n b) (if w then z else if s then bv_swrap n z else z). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_zero_extend | null |
bv_unfold_sign_extend s w n n' b z `{!TCFastDone (n' <=? n = true)%N} :
BvUnfold n' true false b z →
BvUnfold n s w (bv_sign_extend n b) (if w then z else if s then z else bv_wrap n z). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_sign_extend | null |
bv_unfold_extract s w n n' n1 b z :
BvUnfold n' false false b z →
BvUnfold n s w (bv_extract n1 n b) (if w then z ≫ Z.of_N n1 else bv_suwrap s n (z ≫ Z.of_N n1)). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_extract | null |
bv_unfold_concat s w n n1 n2 b1 b2 z1 z2 `{!TCFastDone (n = n1 + n2)%N} :
BvUnfold n1 false false b1 z1 →
BvUnfold n2 false false b2 z2 →
BvUnfold n s w (bv_concat n b1 b2) (if w then Z.lor (z1 ≪ Z.of_N n2) z2 else if s then bv_swrap n (Z.lor (z1 ≪ Z.of_N n2) z2) else Z.lor (z1 ≪ Z.of_N n2) z2). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_concat | null |
bv_unfold_add_Z s w n b1 z1 z2 :
BvUnfold n s true b1 z1 →
BvUnfold n s w (bv_add_Z b1 z2) (if w then z1 + z2 else bv_suwrap s n (z1 + z2)). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_add_Z | null |
bv_unfold_sub_Z s w n b1 z1 z2 :
BvUnfold n s true b1 z1 →
BvUnfold n s w (bv_sub_Z b1 z2) (if w then z1 - z2 else bv_suwrap s n (z1 - z2)). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_sub_Z | null |
bv_unfold_mul_Z s w n b1 z1 z2 :
BvUnfold n s true b1 z1 →
BvUnfold n s w (bv_mul_Z b1 z2) (if w then z1 * z2 else bv_suwrap s n (z1 * z2)). | Lemma | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | bv_unfold_mul_Z | null |
BvSolve (P : Prop) : Prop := bv_solve_proof : P. | Class | stdpp_bitvector | [
"stdpp.bitvector.definitions",
"stdpp.options"
] | stdpp_bitvector/tactics.v | BvSolve | null |
Nat_eqb_eq n1 n2 :
(n1 =? n2)%nat = bool_decide (n1 = n2). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | Nat_eqb_eq | * Helper lemmas to upstream |
Z_eqb_eq n1 n2 :
(n1 =? n2)%Z = bool_decide (n1 = n2). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | Z_eqb_eq | null |
Z_testbit_pos_testbit p n :
(0 ≤ n)%Z →
Z.testbit (Z.pos p) n = Pos.testbit p (Z.to_N n). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | Z_testbit_pos_testbit | null |
negb_forallb {A} (ls : list A) f :
negb (forallb f ls) = existsb (negb ∘ f) ls. | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | negb_forallb | null |
Z_bits_inj'' a b :
a = b → (∀ n : Z, 0 ≤ n → Z.testbit a n = Z.testbit b n). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | Z_bits_inj | null |
tac_tactic_in_hyp (P1 P2 : Prop) :
P1 → (P1 → P2) → P2. | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | tac_tactic_in_hyp | null |
pos_to_bit_ranges_aux (p : positive) : (nat * nat) * list (nat * nat) :=
match p with
| xH => ((0, 1)%nat, [])
| xO p' =>
let x := pos_to_bit_ranges_aux p' in
((S x.1.1, x.1.2), prod_map S id <$> x.2)
| xI p' =>
let x := pos_to_bit_ranges_aux p' in
if (x.1.1 =? 0)%nat then
((0%na... | Fixpoint | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | pos_to_bit_ranges_aux | ** bitranges |
pos_to_bit_ranges (p : positive) : list (nat * nat) :=
let x := pos_to_bit_ranges_aux p in x.1::x.2. | Definition | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | pos_to_bit_ranges | 0b10101 [(0, 1); (2, 1); (4, 1)] |
pos_to_bit_ranges_spec p rs :
pos_to_bit_ranges p = rs →
(∀ n, Pos.testbit p n ↔ ∃ r, r ∈ rs ∧ (N.of_nat r.1 ≤ n ∧ n < N.of_nat r.1 + N.of_nat r.2)%N). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | pos_to_bit_ranges_spec | null |
Z_to_bit_ranges (z : Z) : list (nat * nat) :=
match z with
| Z0 => []
| Z.pos p => pos_to_bit_ranges p
| Z.neg p => []
end. | Definition | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | Z_to_bit_ranges | null |
Z_to_bit_ranges_spec z n rs :
(0 ≤ n)%Z →
(0 ≤ z)%Z →
Z_to_bit_ranges z = rs →
Z.testbit z n ↔ Exists (λ r, Z.of_nat r.1 ≤ n ∧ n < Z.of_nat r.1 + Z.of_nat r.2) rs. | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | Z_to_bit_ranges_spec | null |
IsPowerOfTwo (z n : Z) := {
is_power_of_two_proof : z = 2 ^ n;
}. | Class | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | IsPowerOfTwo | ** [IsPowerOfTwo] |
is_power_of_two_pow2 n :
IsPowerOfTwo (2 ^ n) n. | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | is_power_of_two_pow2 | null |
is_power_of_two_const n p :
(∀ x, [(n, 1%nat)] = x → prod_map Z.of_nat id <$> Z_to_bit_ranges (Z.pos p) = x) →
IsPowerOfTwo (Z.pos p) n. | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | is_power_of_two_const | null |
BitblastBounded (z n : Z) := {
bitblast_bounded_proof : 0 ≤ z < 2 ^ n;
}. | Class | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | BitblastBounded | ** [BitblastBounded] |
Bitblast (z n : Z) (b : bool) := {
bitblast_proof : Z.testbit z n = b;
}. | Class | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | Bitblast | ** [Bitblast] |
BITBLAST_TESTBIT := Z.testbit. | Definition | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | BITBLAST_TESTBIT | null |
bitblast_id z n :
Bitblast z n (bool_decide (0 ≤ n) && BITBLAST_TESTBIT z n). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_id | null |
bitblast_id_bounded z z' n :
BitblastBounded z z' →
Bitblast z n (bool_decide (0 ≤ n < z') && BITBLAST_TESTBIT z n). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_id_bounded | null |
bitblast_0 n :
Bitblast 0 n false. | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_0 | null |
bitblast_pos p n rs b :
(∀ x, rs = x → (λ p, (Z.of_nat p.1, Z.of_nat p.1 + Z.of_nat p.2)) <$> Z_to_bit_ranges (Z.pos p) = x) →
existsb (λ '(r1, r2), bool_decide (r1 ≤ n ∧ n < r2)) rs = b →
Bitblast (Z.pos p) n b. | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_pos | null |
bitblast_neg p n rs b :
(∀ x, rs = x → (λ p, (Z.of_nat p.1, Z.of_nat p.1 + Z.of_nat p.2)) <$> Z_to_bit_ranges (Z.pred (Z.pos p)) = x) →
forallb (λ '(r1, r2), bool_decide (n < r1 ∨ r2 ≤ n)) rs = b →
Bitblast (Z.neg p) n (bool_decide (0 ≤ n) && b). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_neg | null |
bitblast_land z1 z2 n b1 b2 :
Bitblast z1 n b1 →
Bitblast z2 n b2 →
Bitblast (Z.land z1 z2) n (b1 && b2). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_land | null |
bitblast_lor z1 z2 n b1 b2 :
Bitblast z1 n b1 →
Bitblast z2 n b2 →
Bitblast (Z.lor z1 z2) n (b1 || b2). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_lor | null |
bitblast_lxor z1 z2 n b1 b2 :
Bitblast z1 n b1 →
Bitblast z2 n b2 →
Bitblast (Z.lxor z1 z2) n (xorb b1 b2). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_lxor | null |
bitblast_shiftr z1 z2 n b1 :
Bitblast z1 (n + z2) b1 →
Bitblast (z1 ≫ z2) n (bool_decide (0 ≤ n) && b1). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_shiftr | null |
bitblast_shiftl z1 z2 n b1 :
Bitblast z1 (n - z2) b1 →
Bitblast (z1 ≪ z2) n (bool_decide (0 ≤ n) && b1). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_shiftl | null |
bitblast_lnot z1 n b1 :
Bitblast z1 n b1 →
Bitblast (Z.lnot z1) n (bool_decide (0 ≤ n) && negb b1). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_lnot | null |
bitblast_ldiff z1 z2 n b1 b2 :
Bitblast z1 n b1 →
Bitblast z2 n b2 →
Bitblast (Z.ldiff z1 z2) n (b1 && negb b2). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_ldiff | null |
bitblast_ones z1 n :
Bitblast (Z.ones z1) n (bool_decide (0 ≤ n < z1) || bool_decide (z1 < 0 ∧ 0 ≤ n)). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_ones | null |
bitblast_pow2 n n' :
Bitblast (2 ^ n') n (bool_decide (n = n' ∧ 0 ≤ n)). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_pow2 | null |
bitblast_setbit z1 n b1 n' :
Bitblast (Z.lor z1 (2 ^ n')) n b1 →
Bitblast (Z.setbit z1 n') n b1. | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_setbit | null |
bitblast_mod z1 z2 z2' n b1 :
IsPowerOfTwo z2 z2' →
Bitblast z1 n b1 →
Bitblast (z1 `mod` z2) n ((bool_decide (z2' < 0 ∧ 0 ≤ n) || bool_decide (n < z2')) && b1). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_mod | null |
bitblast_add_0 z1 z2 b1 b2 :
Bitblast z1 0 b1 →
Bitblast z2 0 b2 →
Bitblast (z1 + z2) 0 (xorb b1 b2). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_add_0 | ** [Bitblast] |
bitblast_add_1 z1 z2 b10 b11 b20 b21 :
Bitblast z1 0 b10 →
Bitblast z2 0 b20 →
Bitblast z1 1 b11 →
Bitblast z2 1 b21 →
Bitblast (z1 + z2) 1 (xorb (xorb b11 b21) (b10 && b20)). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_add_1 | null |
bitblast_clearbit z n b m :
Bitblast z n b →
Bitblast (Z.clearbit z m) n (bool_decide (n ≠ m) && b). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_clearbit | null |
bitblast_bool_to_Z b n:
Bitblast (bool_to_Z b) n (bool_decide (n = 0) && b). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_bool_to_Z | null |
bitblast_bv_wrap z1 n n1 b1:
Bitblast z1 n b1 →
Bitblast (bv_wrap n1 z1) n (bool_decide (n < Z.of_N n1) && b1). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_bv_wrap | Instances for [bv] |
bitblast_bounded_bv_unsigned n (b : bv n):
BitblastBounded (bv_unsigned b) (Z.of_N n). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_bounded_bv_unsigned | null |
bitblast_bv_swrap z1 n n1 b1 b2 :
Bitblast z1 n b1 →
Bitblast z1 (Z.of_N n1-1) b2 →
Bitblast (bv_swrap n1 z1) n (if bool_decide (n < Z.of_N n1-1) then b1 else b2). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | bitblast_bv_swrap | null |
BITBLAST_BOOL_DECIDE := @bool_decide. | Definition | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | BITBLAST_BOOL_DECIDE | ** Helper definitions and lemmas for the tactics |
tac_bitblast_bool_decide_true G (P : Prop) `{!Decision P} :
P →
G true →
G (bool_decide P). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | tac_bitblast_bool_decide_true | null |
tac_bitblast_bool_decide_false G (P : Prop) `{!Decision P} :
¬ P →
G false →
G (bool_decide P). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | tac_bitblast_bool_decide_false | null |
tac_bitblast_bool_decide_split G (P : Prop) `{!Decision P} :
(P → G true) →
(¬ P → G false) →
G (bool_decide P). | Lemma | stdpp_unstable | [
"Stdlib.ssreflect",
"Stdlib.btauto.Btauto",
"stdpp.bitvector.definitions",
"stdpp.tactics",
"stdpp.numbers",
"stdpp.list",
"stdpp.options"
] | stdpp_unstable/bitblast.v | tac_bitblast_bool_decide_split | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.