Datasets:
Tasks:
Text Generation
Modalities:
Text
Formats:
csv
Languages:
English
Size:
1K - 10K
Tags:
neural-theorem-proving
hol-light
cryptographic-verification
tactic-synthesis
benchmark
formal-methods
License:
problem_id stringlengths 17 84 | category stringclasses 5
values | query stringlengths 10 8.6k |
|---|---|---|
common.overlap.NONOVERLAPPING_MODULO_SETWISE | program_state | `!addr1 addr2 len1 len2.
nonoverlapping_modulo n (addr1,len1) (addr2,len2) <=>
DISJOINT (IMAGE (\i. (addr1 + i) MOD n) {i | i < len1})
(IMAGE (\i. (addr2 + i) MOD n) {i | i < len2})` |
common.overlap.CONTAINED_MODULO_SETWISE | program_state | `!addr1 addr2 len1 len2.
contained_modulo n (addr1,len1) (addr2,len2) <=>
(IMAGE (\i. (addr1 + i) MOD n) {i | i < len1}) SUBSET
(IMAGE (\i. (addr2 + i) MOD n) {i | i < len2})` |
common.overlap.NONOVERLAPPING_MODULO_WORDWISE | program_state | `!(addr1:N word) addr2 len1 len2.
nonoverlapping_modulo (2 EXP dimindex(:N))
(val addr1,len1) (val addr2,len2) <=>
DISJOINT (IMAGE (\i. word_add addr1 (word i)) {i | i < len1})
(IMAGE (\i. word_add addr2 (word i)) {i | i < len2})` |
common.overlap.CONTAINED_MODULO_WORDWISE | program_state | `!(addr1:N word) addr2 len1 len2.
contained_modulo (2 EXP dimindex(:N))
(val addr1,len1) (val addr2,len2) <=>
IMAGE (\i. word_add addr1 (word i)) {i | i < len1} SUBSET
IMAGE (\i. word_add addr2 (word i)) {i | i < len2}` |
common.overlap.NONOVERLAPPING_MODULO_TRIVIAL | program_state | `!n addr1 addr2 len1 len2.
len1 = 0 \/ len2 = 0
==> nonoverlapping_modulo n (addr1,len1) (addr2,len2)` |
common.overlap.CONTAINED_MODULO_TRIVIAL | program_state | `!n addr1 addr2 len2.
contained_modulo n (addr1,0) (addr2,len2)` |
common.overlap.CONTAINED_MODULO_EMPTY | program_state | `!n addr1 addr2 len1.
contained_modulo n (addr1,len) (addr2,0) <=> len = 0` |
common.overlap.NONOVERLAPPING_MODULO_REFL | program_state | `!n addr len1 len2.
nonoverlapping_modulo n (addr,len1) (addr,len2) <=> len1 = 0 \/ len2 = 0` |
common.overlap.CONTAINED_MODULO_REFL | program_state | `!n addr len1 len2.
contained_modulo n (addr,len1) (addr,len2) <=>
len1 <= len2 \/ 0 < n /\ n <= len2` |
common.overlap.NONOVERLAPPING_MODULO_SYM | program_state | `!n addr1 len1 addr2 len2.
nonoverlapping_modulo n (addr1,len1) (addr2,len2) <=>
nonoverlapping_modulo n (addr2,len2) (addr1,len1)` |
common.overlap.CONTAINED_MODULO_TRANS | program_state | `!n addr1 len1 addr2 len2 addr3 len3.
contained_modulo n (addr1,len1) (addr2,len2) /\
contained_modulo n (addr2,len2) (addr3,len3)
==> contained_modulo n (addr1,len1) (addr3,len3)` |
common.overlap.NONOVERLAPPING_MODULO_SUBREGIONS | program_state | `!n addr1 len1 addr2 len2 addr1' len1' addr2' len2'.
nonoverlapping_modulo n (addr1,len1) (addr2,len2) /\
contained_modulo n (addr1',len1') (addr1,len1) /\
contained_modulo n (addr2',len2') (addr2,len2)
==> nonoverlapping_modulo n (addr1',len1') (addr2',len2')` |
common.overlap.NONOVERLAPPING_MODULO_LMOD | program_state | `!n addr1 len1 addr2 len2.
nonoverlapping_modulo n (addr1 MOD n,len1) (addr2,len2) <=>
nonoverlapping_modulo n (addr1,len1) (addr2,len2)` |
common.overlap.NONOVERLAPPING_MODULO_RMOD | program_state | `!n addr1 len1 addr2 len2.
nonoverlapping_modulo n (addr1,len1) (addr2 MOD n,len2) <=>
nonoverlapping_modulo n (addr1,len1) (addr2,len2)` |
common.overlap.NONOVERLAPPING_MODULO_MOD2 | program_state | `!n addr1 len1 addr2 len2.
nonoverlapping_modulo n (addr1 MOD n,len1) (addr2 MOD n,len2) <=>
nonoverlapping_modulo n (addr1,len1) (addr2,len2)` |
common.overlap.CONTAINED_MODULO_LMOD | program_state | `!n addr1 len1 addr2 len2.
contained_modulo n (addr1 MOD n,len1) (addr2,len2) <=>
contained_modulo n (addr1,len1) (addr2,len2)` |
common.overlap.CONTAINED_MODULO_RMOD | program_state | `!n addr1 len1 addr2 len2.
contained_modulo n (addr1,len1) (addr2 MOD n,len2) <=>
contained_modulo n (addr1,len1) (addr2,len2)` |
common.overlap.CONTAINED_MODULO_MOD2 | program_state | `!n addr1 len1 addr2 len2.
contained_modulo n (addr1 MOD n,len1) (addr2 MOD n,len2) <=>
contained_modulo n (addr1,len1) (addr2,len2)` |
common.overlap.NONOVERLAPPING_MODULO_LMIN | program_state | `!n addr1 len1 addr2 len2.
nonoverlapping_modulo n (addr1,MIN len1 n) (addr2,len2) <=>
n = 0 \/ nonoverlapping_modulo n (addr1,len1) (addr2,len2)` |
common.overlap.NONOVERLAPPING_MODULO_RMIN | program_state | `!n addr1 len1 addr2 len2.
nonoverlapping_modulo n (addr1,len1) (addr2,MIN len2 n) <=>
n = 0 \/ nonoverlapping_modulo n (addr1,len1) (addr2,len2)` |
common.overlap.NONOVERLAPPING_MODULO_MIN2 | program_state | `!n addr1 len1 addr2 len2.
nonoverlapping_modulo n (addr1,MIN len1 n) (addr2,MIN len2 n) <=>
n = 0 \/ nonoverlapping_modulo n (addr1,len1) (addr2,len2)` |
common.overlap.CONTAINED_MODULO_LMIN | program_state | `!n addr1 len1 addr2 len2.
contained_modulo n (addr1,MIN len1 n) (addr2,len2) <=>
n = 0 \/ contained_modulo n (addr1,len1) (addr2,len2)` |
common.overlap.CONTAINED_MODULO_RMIN | program_state | `!n addr1 len1 addr2 len2.
contained_modulo n (addr1,len1) (addr2,MIN len2 n) <=>
if n = 0 then len1 = 0
else contained_modulo n (addr1,len1) (addr2,len2)` |
common.overlap.CONTAINED_MODULO_MIN2 | program_state | `!n addr1 len1 addr2 len2.
contained_modulo n (addr1,MIN len1 n) (addr2,MIN len2 n) <=>
n = 0 \/ contained_modulo n (addr1,len1) (addr2,len2)` |
common.overlap.NONOVERLAPPING_MODULO_OFFSET_RIGHT | program_state | `!a1 a2 l1 l2 k.
nonoverlapping_modulo n (a1 + k,l1) (a2 + k,l2) <=>
nonoverlapping_modulo n (a1,l1) (a2,l2)` |
common.overlap.NONOVERLAPPING_MODULO_OFFSET_LEFT | program_state | `!a l1 l2 k1 k2.
nonoverlapping_modulo n (a + k1,l1) (a + k2,l2) <=>
nonoverlapping_modulo n (k1,l1) (k2,l2)` |
common.overlap.NONOVERLAPPING_MODULO_MULTIPLE | program_state | `!m n addr1 len1 addr2 len2.
nonoverlapping_modulo n (addr1,len1) (addr2,len2)
==> nonoverlapping_modulo (m * n) (addr1,len1) (addr2,len2)` |
common.overlap.NONOVERLAPPING_MODULO_0 | program_state | `!n addr1 len1 addr2 len2.
nonoverlapping_modulo n (addr1,len1) (addr2,len2)
==> nonoverlapping_modulo 0 (addr1,len1) (addr2,len2)` |
common.overlap.NONOVERLAPPING_MODULO_DIFFERENCE | program_state | `!n addr1 len1 addr2 len2.
nonoverlapping_modulo n (addr1,len1) (addr2,len2) <=>
(len1 = 0 \/ len2 = 0) \/
~(?z:int. --(&len2) < z /\ z < &len1 /\
(&addr2 - &addr1 == z) (mod &n))` |
common.overlap.NONOVERLAPPING_NONMODULAR_DIFFERENCE | program_state | `!addr1 len1 addr2 len2.
nonoverlapping_modulo 0 (addr1,len1) (addr2,len2) <=>
(len1 = 0 \/ len2 = 0) \/
~(-- &len2:int < &addr2 - &addr1 /\ &addr2 - &addr1:int < &len1)` |
common.overlap.NONOVERLAPPING_NONMODULAR_NUM | program_state | `!addr1 addr2 len1 len2.
nonoverlapping_modulo 0 (addr1,len1) (addr2,len2) <=>
(len1 = 0 \/ len2 = 0) \/
(addr1 + len1 <= addr2 \/ addr2 + len2 <= addr1)` |
common.overlap.NONOVERLAPPING_MODULO_OFFSET | program_state | `!n addr1 addr2 len1 len2 d.
nonoverlapping_modulo n (addr1 + d,len1) (addr2 + d,len2) <=>
nonoverlapping_modulo n (addr1,len1) (addr2,len2)` |
common.overlap.NONOVERLAPPING_MODULO_MODULAR | program_state | `!n addr1 addr1' addr2 addr2' len1 len2.
(addr1' == addr1) (mod n) /\ (addr2' == addr2) (mod n)
==> (nonoverlapping_modulo n (addr1',len1) (addr2',len2) <=>
nonoverlapping_modulo n (addr1,len1) (addr2,len2))` |
common.overlap.NONOVERLAPPING_MODULO_DIFFERENCE_ALT | program_state | `!n addr1 len1 addr2 len2.
nonoverlapping_modulo n (addr1,len1) (addr2,len2) <=>
(len1 = 0 \/ len2 = 0) \/
~(?z. &0 <= z /\ z <= (&len1 + &len2) - &2 /\
(&addr2 - &addr1 + &len2 - &1:int == z) (mod &n))` |
common.overlap.NONOVERLAPPING_MODULO_DIFFERENCE_NUM | program_state | `!n addr1 len1 addr2 len2.
nonoverlapping_modulo n (addr1,len1) (addr2,len2) <=>
(len1 = 0 \/ len2 = 0) \/
!d. (&addr2 - &addr1 + &len2 - &1:int == &d) (mod &n)
==> (len1 - 1) + (len2 - 1) < d` |
common.overlap.NONOVERLAPPING_MODULO_DIFFERENCE_NUM_RESTRICTED | program_state | `!n addr1 len1 addr2 len2.
len1 + len2 <= n + 1
==> (nonoverlapping_modulo n (addr1,len1) (addr2,len2) <=>
(len1 = 0 \/ len2 = 0) \/
!d. d < n /\ (&addr2 - &addr1 + &len2 - &1:int == &d) (mod &n)
==> (len1 - 1) + (len2 - 1) < d)` |
common.overlap.CONTAINED_MODULO_IMP_NONTRIVIAL | program_state | `!n a b i j. contained_modulo n (a,i) (b,j) /\ j < n ==> i < n` |
common.overlap.CONTAINED_MODULO_IMP_LE | program_state | `!n a b i j. contained_modulo n (a,i) (b,j) /\ i <= n ==> i <= j` |
common.overlap.CONTAINED_MODULO_IMP_LE_ADD | program_state | `!n a i j k.
contained_modulo n (a + i,j) (a,k) /\
i <= k /\ k < n
==> i + j <= k` |
common.overlap.NONOVERLAPPING_IMP_SMALL_2 | program_state | `!n addr1 len1 addr2 len2.
nonoverlapping_modulo n (addr1,len1) (addr2,len2) /\
0 < n /\ 0 < len1 /\ 0 < len2
==> len1 + len2 <= n` |
common.overlap.NONOVERLAPPING_IMP_SMALL_1 | program_state | `!n addr1 addr2 len.
nonoverlapping_modulo n (addr1,len) (addr2,len) /\
0 < n
==> 2 * len <= n` |
common.overlap.NONOVERLAPPING_IMP_LT | program_state | `!n addr1 len1 addr2 len2.
nonoverlapping_modulo n (addr1,len1) (addr2,len2) /\
0 < n /\ 0 < len1 /\ 0 < len2
==> len1 < n /\ len2 < n` |
common.overlap.NONOVERLAPPING_IMP_LE | program_state | `!n addr1 len1 addr2 len2.
nonoverlapping_modulo n (addr1,len1) (addr2,len2) /\
0 < n /\ 0 < len1 /\ 0 < len2
==> len1 <= n /\ len2 <= n` |
common.overlap.NONOVERLAPPING_IMP_SMALL_RIGHT | program_state | `!n addr1 len1 addr2 len2.
nonoverlapping_modulo n (addr1,len1) (addr2,len2) /\ 0 < n /\ 0 < len1
==> len2 <= n` |
common.overlap.NONOVERLAPPING_IMP_SMALL_LEFT | program_state | `!n addr1 len1 addr2 len2.
nonoverlapping_modulo n (addr1,len1) (addr2,len2) /\ 0 < n /\ 0 < len2
==> len1 <= n` |
common.overlap.NONOVERLAPPING_IMP_SMALL_RIGHT_ALT | program_state | `!n addr1 len1 addr2 len2.
nonoverlapping_modulo n (addr1,len1) (addr2,len2) /\
0 < n /\ 0 < len1 /\ len1 <= n
==> len1 + len2 <= n` |
common.overlap.NONOVERLAPPING_IMP_SMALL_LEFT_ALT | program_state | `!n addr1 len1 addr2 len2.
nonoverlapping_modulo n (addr1,len1) (addr2,len2) /\
0 < n /\ 0 < len2 /\ len2 <= n
==> len1 + len2 <= n` |
common.overlap.NONOVERLAPPING_MODULO_SIMPLE | program_state | `!n a1 a2 l1 l2.
a1 + l1 <= a2 /\ a2 + l2 <= a1 + n \/
a2 + l2 <= a1 /\ a1 + l1 <= a2 + n
==> nonoverlapping_modulo n (a1,l1) (a2,l2)` |
common.overlap.NONOVERLAPPING_MODULO_OFFSET_SIMPLE_RIGHT | program_state | `!n a k l1 l2.
l1 <= k /\ k + l2 <= n ==> nonoverlapping_modulo n (a,l1) (a+k,l2)` |
common.overlap.NONOVERLAPPING_MODULO_OFFSET_SIMPLE_LEFT | program_state | `!n a k l1 l2.
l2 <= k /\ k + l1 <= n ==> nonoverlapping_modulo n (a+k,l1) (a,l2)` |
common.overlap.NONOVERLAPPING_MODULO_OFFSET_SIMPLE_BOTH | program_state | `!n a k m l1 l2.
k + l1 <= m /\ m + l2 <= k + n \/
m + l2 <= k /\ k + l1 <= m + n
==> nonoverlapping_modulo n (a+k,l1) (a+m,l2)` |
common.overlap.CONTAINED_MODULO_SIMPLE | program_state | `!n a1 a2 l1 l2.
a2 <= a1 /\ a1 + l1 <= a2 + l2
==> contained_modulo n (a1,l1) (a2,l2)` |
common.overlap.CONTAINED_MODULO_OFFSET_SIMPLE | program_state | `!n a k l1 l2.
k + l1 <= l2 ==> contained_modulo n (a+k,l1) (a,l2)` |
common.overlap.NONOVERLAPPING | program_state | `!(base1:N word) base2 len1 len2.
nonoverlapping (base1,len1) (base2,len2) <=>
~(?i j. i < len1 /\ j < len2 /\
word_add base1 (word i) = word_add base2 (word j))` |
common.overlap.CONTAINED | program_state | `!(base1:N word) base2 len1 len2.
contained (base1,len1) (base2,len2) <=>
!i. i < len1
==> ?j. j < len2 /\
word_add base1 (word i) = word_add base2 (word j)` |
common.overlap.NONOVERLAPPING_MODULO | program_state | `!base1 base2 len1 len2.
nonoverlapping_modulo (2 EXP dimindex(:N)) (base1,len1) (base2,len2) <=>
nonoverlapping(word base1:N word,len1) (word base2:N word,len2)` |
common.overlap.CONTAINED_MODULO | program_state | `!base1 base2 len1 len2.
contained_modulo (2 EXP dimindex(:N)) (base1,len1) (base2,len2) <=>
contained(word base1:N word,len1) (word base2:N word,len2)` |
common.overlap.NONOVERLAPPING_SYM | program_state | `!(base1:N word) base2 len1 len2.
nonoverlapping (base1,len1) (base2,len2) <=>
nonoverlapping (base2,len2) (base1,len1)` |
common.overlap.CONTAINED_TRIVIAL | program_state | `!(base1:N word) base2 len2. contained (base1,0) (base2,len2)` |
common.overlap.NONOVERLAPPING_TRIVIAL | program_state | `!(base1:N word) base2 len1 len2.
len1 = 0 \/ len2 = 0
==> nonoverlapping (base1,len1) (base2,len2)` |
common.overlap.NONOVERLAPPING_SUBREGIONS | program_state | `!(base1:N word) len1 base2 len2 base1' len1' base2' len2'.
nonoverlapping (base1,len1) (base2,len2) /\
contained (base1',len1') (base1,len1) /\
contained (base2',len2') (base2,len2)
==> nonoverlapping (base1',len1') (base2',len2')` |
common.overlap.NONOVERLAPPING_QFREE | program_state | `!(base1:N word) base2 len1 len2.
nonoverlapping (base1,len1) (base2,len2) <=>
0 < len1 /\ 0 < len2
==> len2 <= val(word_sub base1 base2) /\
val(word_sub base1 base2) + len1 <= 2 EXP dimindex(:N)` |
common.overlap.NONOVERLAPPING_QFREE' | program_state | `!(base1:N word) base2 len1 len2.
nonoverlapping (base1,len1) (base2,len2) <=>
0 < len1 /\ 0 < len2
==> len2 <= val(word_sub base1 base2) /\
len1 <= val(word_sub base2 base1)` |
common.overlap.CONTAINED_QFREE | program_state | `!(base1:N word) base2 len1 len2.
contained (base1,len1) (base2,len2) <=>
0 < len1 /\ len2 < 2 EXP dimindex(:N)
==> val(word_sub base1 base2) + len1 <= len2` |
common.overlap.NONOVERLAPPING_SIMPLE_LEFT | program_state | `!(base:N word) off1 off2 len1 len2.
(0 < len1 /\ 0 < len2
==> &len2 <= off1 - off2 /\ (off1 - off2) + &len1 <= &2 pow dimindex(:N))
==> nonoverlapping (word_add base (iword off1),len1)
(word_add base (iword off2),len2)` |
common.overlap.NONOVERLAPPING_SIMPLE.0 | program_state | `!pos1 len1 pos2 len2.
pos1 + len1 <= 2 EXP 64 /\ pos2 + len2 <= 2 EXP 64
==> (nonoverlapping_modulo (2 EXP 64) (pos1,len1) (pos2,len2) <=>
len1 = 0 \/ len2 = 0 \/
pos1 + len1 <= pos2 \/ pos2 + len2 <= pos1)` |
common.overlap.NONOVERLAPPING_SIMPLE.1 | program_state | `!(base:N word) off1 off2 len1 len2.
(0 < len1 /\ 0 < len2
==> &len2 <= off1 - off2 /\
(off1 - off2) + &len1 <= &2 pow dimindex(:N) \/
&len1 <= off2 - off1 /\
(off2 - off1) + &len2 <= &2 pow dimindex(:N))
==> nonoverlapping (word_add base (iword off1),len1)
... |
common.overlap.CONTAINED_SIMPLE | program_state | `!(base:N word) off1 off2 len1 len2.
(0 < len1 ==> &0 <= off1 - off2 /\ (off1 - off2) + &len1 <= &len2)
==> contained (word_add base (iword off1),len1)
(word_add base (iword off2),len2)` |
common.overlap.NONOVERLAPPING_CLAUSES | program_state | `(nonoverlapping (word n1:int64,l1) (a2,l2) <=>
nonoverlapping_modulo (2 EXP 64) (n1,l1) (val a2,l2)) /\
(nonoverlapping (a1:int64,l1) (word n2:int64,l2) <=>
nonoverlapping_modulo (2 EXP 64) (val a1,l1) (n2,l2)) /\
(nonoverlapping (a1:int64,l1) (a2,l2) <=>
nonoverlapping_modulo (2 EXP 64) ... |
common.for_hollight.FORALL_FUN_PAIR_THM | generic | `!P. (!f:A#B->C. P f) <=> (!g. P(\a. g (FST a) (SND a)))` |
common.for_hollight.obind_eq_some | generic | `!ao f b. (ao >>= f) = SOME (b:B) <=> ?a:A. ao = SOME a /\ f a = SOME b` |
common.for_hollight.ODD_DOUBLE | generic | `!n. ~ODD (2 * n)` |
common.for_hollight.EXP_2_NE_0 | generic | `~(2 EXP n = 0)` |
common.for_hollight.ONE_LE_EXP_2 | generic | `forall y. 1 <= 2 EXP y` |
common.for_hollight.MOD_DIV_EQ_0 | generic | `~(n = 0) ==> (m MOD n) DIV n = 0` |
common.for_hollight.BIT0_0 | generic | `BIT0 0 = 0` |
common.for_hollight.BIT1_0 | generic | `BIT1 0 = 1` |
common.for_hollight.exists_list_split | generic | `!l n. n <= LENGTH (l:A list) ==> ?l1 l2. l = APPEND l1 l2 /\ LENGTH l1 = n` |
common.for_hollight.FROM_BITLIST_CLAUSES | generic | `from_bitlist [] = 0 /\
(!t. from_bitlist (CONS T t) = BIT1 (from_bitlist t)) /\
(!t. from_bitlist (CONS F t) = BIT0 (from_bitlist t))` |
common.words2.LENGTH_BYTELIST_OF_NUM | generic | `!k n. LENGTH(bytelist_of_num k n) = k` |
common.words2.LENGTH_BYTELIST_OF_INT | generic | `!k n. LENGTH(bytelist_of_int k n) = k` |
common.words2.NUM_OF_BYTELIST_BOUND | generic | `!l. num_of_bytelist l < 256 EXP (LENGTH l)` |
common.words2.BYTELIST_OF_NUM_OF_BYTELIST | generic | `!l. bytelist_of_num (LENGTH l) (num_of_bytelist l) = l` |
common.words2.NUM_OF_BYTELIST_OF_NUM_0 | generic | `!k. num_of_bytelist(bytelist_of_num k 0) = 0` |
common.words2.NUM_OF_BYTELIST_OF_NUM | generic | `!k n. num_of_bytelist(bytelist_of_num k n) = n MOD (256 EXP k)` |
common.words2.BYTELIST_OF_NUM_MOD | generic | `!k n. bytelist_of_num k (n MOD (256 EXP k)) = bytelist_of_num k n` |
common.words2.NUM_OF_BYTELIST_OF_NUM_EQ | generic | `!k n. n < 256 EXP k ==> num_of_bytelist(bytelist_of_num k n) = n` |
common.words2.BYTELIST_OF_INT_OF_NUM | generic | `bytelist_of_int k (&n) = bytelist_of_num k n` |
common.words2.NUMBIT_VAL | bit_vector | `numbit i (val (e:N word)) = bit i e` |
common.words2.num_shift_add_0 | generic | `num_shift_add a b 0 = b` |
common.words2.num_shift_add_SUC | generic | `num_shift_add (BIT0 a) b (SUC n) = BIT0 (num_shift_add a b n) /\
num_shift_add (BIT1 a) b (SUC n) = BIT1 (num_shift_add a b n)` |
common.words2.num_shift_add_lt | generic | `!a b n i. b < 2 EXP i ==> num_shift_add a b n < 2 EXP (i + n)` |
common.words2.num_shift_add_mod | generic | `num_shift_add a (b MOD 2 EXP i) n = num_shift_add a b n MOD 2 EXP (i + n)` |
common.words2.read_byte_val | program_state | `read_byte [] = NONE /\ !a l. read_byte (CONS a l) = SOME (a, l)` |
common.words2.read_word_n_eq_some | generic | `read_word_n n l = SOME (a, l') <=>
?l1. l = APPEND l1 l' /\ LENGTH l1 = n /\ a = num_of_bytelist l1` |
common.words2.read_word_eq_some | bit_vector | `read_word n l = SOME (a, l') <=>
?l1. l = APPEND l1 l' /\ LENGTH l1 = n /\ a = word (num_of_bytelist l1)` |
common.misc.LIST_OF_SEQ_CLAUSES | generic | `(!(f:num->A). list_of_seq f 0 = []) /\
(!(f:num->A). list_of_seq f 1 = [f 0]) /\
(!(f:num->A). list_of_seq f 2 = [f 0; f 1]) /\
(!(f:num->A). list_of_seq f 3 = [f 0; f 1; f 2]) /\
(!(f:num->A). list_of_seq f 4 = [f 0; f 1; f 2; f 3])` |
common.misc.SUB_LIST_CLAUSES | generic | `SUB_LIST (m,0) (l:A list) = [] /\
SUB_LIST (m,n) [] = [] /\
SUB_LIST (SUC m,n) (CONS h t) = SUB_LIST (m,n) t /\
SUB_LIST (0,SUC n) (CONS h t) = CONS h (SUB_LIST (0,n) t)` |
common.misc.SUB_LIST_LENGTH | generic | `!l. SUB_LIST(0,LENGTH l) l = l` |
common.misc.SUB_LIST_SPLIT | generic | `!l m n p. SUB_LIST(p,m+n) l = APPEND (SUB_LIST(p,m) l) (SUB_LIST(p+m,n) l)` |
End of preview. Expand in Data Studio
s2n-bignum-bench
A benchmark of 2,301 HOL Light proof obligations distilled from AWS s2n-bignum, a formally verified library of hand-tuned big-integer assembly routines for AArch64 (ARM) and x86-64. Each task asks an LLM (Solver) to synthesize a HOL Light tactic that discharges a goal arising inside an industrial proof development for ARM or x86 machine code, or supporting Lemmas.
Paper: s2n-bignum-bench: A practical benchmark for evaluating low-level code reasoning of LLMs, NeurIPS 2026 Datasets & Benchmarks Track (under review).
Code, evaluator, and full benchmark (with setup.ml contexts):
github.com/kings-crown/s2n-bignum-bench
Dataset summary
Most neural-theorem-proving benchmarks emphasize Olympiad mathematics (miniF2F, PutnamBench) or repository-scale Lean developments (LeanDojo, miniCTX, VeriSoftBench). s2n-bignum-bench fills a gap by targeting HOL Light tactic synthesis for industrial low-level cryptographic assembly, with shipped object-code artifacts, large shared proof contexts, and trusted ARM/x86 ISA semantics
The corpus is partitioned into five categories:
| Category | Tasks | Share |
|---|---|---|
generic |
564 | 24.5% |
program_state |
555 | 24.1% |
bit_vector |
318 | 13.8% |
functional_correctness_arm |
439 | 19.1% |
functional_correctness_x86 |
425 | 18.5% |
862 tasks are Hoare-style *_CORRECT theorems over decoded ARM/x86
machine code; the remaining 1,439 are supporting lemmas
(bit-vector identities, program-state predicates, generic algebraic
facts).
This Hugging Face dataset exposes the queries only (one record per benchmark task). Each record has four fields:
| Field | Type | Description |
|---|---|---|
split |
string | Only "train" |
problem_id |
string | Identifier of the form {arch}.{filename}.{thm}[.{N}] |
category |
string | One of the five categories above |
query |
string | HOL Light goal term to be discharged |
For the full benchmarking setup refer to the GitHub repository: s2n-bignum-bench
The benchmark is distributed under CC-BY-4.0 to align with standard dataset-licensing practice; the underlying AWS s2n-bignum source from which queries are derived is Apache-2.0, with upstream attribution preserved in the NOTICE file. Downstream consumers integrating into code projects should treat the queries as CC-BY-4.0 content and follow Apache-2.0 attribution for any redistributed setup.ml fragments.
Attribution: When using the dataset, please consider citing both the s2n-bignum-bench paper and the upstream s2n-bignum project.
- Downloads last month
- 24