problem_id stringlengths 17 84 | category stringclasses 5
values | query stringlengths 10 8.6k |
|---|---|---|
common.misc.NSUM_CLAUSES_IMAGE | generic | `!f k. nsum {i | i < SUC k} f = f 0 + nsum {i | i < k} (f o SUC)` |
common.misc.WORD_CONDENSE | bit_vector | `!x y:N word. word_condense x y = word(num_condense (val x) (val y))` |
common.misc.NUM_CONDENSE_BINARY | generic | `num_condense (NUMERAL(BIT0 n)) (NUMERAL(BIT1 m)) =
2 * num_condense (NUMERAL n) (NUMERAL m) /\
num_condense (NUMERAL(BIT1 n)) (NUMERAL(BIT1 m)) =
2 * num_condense (NUMERAL n) (NUMERAL m) + 1 /\
num_condense (NUMERAL(BIT0 n)) (NUMERAL(BIT0 m)) =
num_condense (NUMERAL n) (NUMERAL m) /\
num_condense (NU... |
common.misc.WORD_ADD_ASSOC_CONSTS | bit_vector | `!(x:(N)word) n m.
(word_add (word_add x (word n)) (word m)) = (word_add x (word (n+m)))` |
common.misc.WORD_OR_ADD_DISJ | bit_vector | `! (x:(64)word) (y:(64)word).
word_or (word_shl x 32) (word_and y (word 4294967295)) =
word_add (word_shl x 32) (word_and y (word 4294967295))` |
common.misc.WORD_OF_BITS_32BITMASK | bit_vector | `word 4294967295 = word_of_bits {i | i < 32}` |
common.misc.WORD_MUL_EQ | bit_vector | `!(x:(64)word) (y:(64)word). word_mul x y = word ((val x * val y) MOD 2 EXP 64)` |
common.misc.WORD64_NE_ADD | bit_vector | `!x y. 0 < y /\ y < 2 EXP 64 ==> ~((word x:int64) = word (x+y))` |
common.misc.WORD64_NE_ADD2 | bit_vector | `!x y y2. y < y2 /\ y2 < 2 EXP 64 ==> ~((word (x+y):int64) = word (x+y2))` |
common.misc.WORD_SUBWORD_MUL | bit_vector | `!x y:N word.
dimindex(:M) = len /\ len <= dimindex(:N)
==> word_subword (word_mul x y) (0,len):M word =
word_mul (word_subword x (0,len))
(word_subword y (0,len))` |
common.misc.GT_REFL | generic | `!(x:num). ~(x > x)` |
common.misc.ADD_MOD_MOD_REFL | generic | `!a b m.
(a + b MOD m) MOD m = (a + b) MOD m /\
(a MOD m + b) MOD m = (a + b) MOD m` |
common.misc.ADD_DIV_MOD_SIMP_LEMMA | generic | `!x y m.
~(m = 0) ==> (x MOD m + y) DIV m + x DIV m = (x + y) DIV m` |
common.misc.LT_MULT_ADD_MULT | generic | `!(a:num) (b:num) (c:num) (m:num).
0 < m /\ a < m /\ b < m /\ c <= m ==> c * a + b < m * m` |
common.misc.LT_ADD_MULT_MULT | generic | `!(a:num) (b:num) (c:num) (m:num).
0 < m /\ a < m /\ b < m /\ c <= m ==> b + c * a < m * m` |
common.misc.ADD_DIV_MOD_SIMP2_LEMMA | generic | `!(x:num) (y:num) (m:num).
~(m = 0) ==> x DIV m + (y + x MOD m) DIV m = (x + y) DIV m` |
common.misc.LE_MULT_ADD | generic | `!(x:num) (x2:num) (y:num). x < x2 ==> x * y + y <= x2 * y` |
common.misc.ADD_SUB_SWAP | generic | `!(x:num) (y:num) (z:num). y >= z /\ x >= z ==> x + (y - z) = y + (x - z)` |
common.misc.ADD_SUB_SWAP2 | generic | `!(x:num) (y:num) (z:num). y >= z /\ z >= x ==> x + (y - z) = y - (z - x)` |
common.misc.LE_SUB_RCANCEL | generic | `forall (x:num) (y:num) (z:num).
x <= y /\ y <= z ==> y - x <= z - x` |
common.misc.SUB_MOD_EQ_0 | generic | `!(x:num) (y:num).
~(x = 0) ==> ((x - y) MOD x = 0 <=> (x <= y \/ y = 0))` |
common.misc.DIVIDES_MOD2 | generic | `!(n:num) (m:num) (k:num).
n divides k ==> (n divides m <=> n divides (m MOD k))` |
common.misc.BITVAL_LE_DIV | bit_vector | `!(x:num) (m:num). x < 2 * m ==> bitval (m <= x) = x DIV m` |
common.misc.BITVAL_LE_MOD_MOD_DIV | bit_vector | `!(x1:num) (x2:num) (m:num). ~(m=0) ==>
bitval (m <= (x1 MOD m + x2 MOD m)) = (x1 MOD m + x2 MOD m) DIV m /\
(x1 DIV m < m ==> bitval (m <= (x1 DIV m + x2 MOD m)) = (x1 DIV m + x2 MOD m) DIV m) /\
(x2 DIV m < m ==> bitval (m <= (x1 MOD m + x2 DIV m)) = (x1 MOD m + x2 DIV m) DIV m)` |
common.misc.VAL_MUL_DIV_MOD_SIMP | bit_vector | `!(x:int64) (y:int64).
((val x * val y) DIV 2 EXP 64) MOD 2 EXP 64 = (val x * val y) DIV 2 EXP 64 /\
(val x * val y) MOD 2 EXP 128 = val x * val y` |
common.misc.MOD_ADD_MOD_RIGHT | generic | `!(a:num) (b:num) (c:num). a MOD d = b MOD d ==> (c + a) MOD d = (c + b) MOD d` |
common.misc.DIV_2_EXP_63 | generic | `!(x:num). x DIV 2 EXP 63 = (2 * x) DIV 2 EXP 64` |
common.misc.LT_SUB_LT | generic | `!(a:num) (b:num). 0 < b /\ b < a ==> a - b < a` |
common.misc.MULT_ADD_DIV_LT | generic | `!(a:num) (b:num) (c:num) (m:num).
1 < m /\ a < m /\ b < m /\ c <= m ==> (a * b + c) DIV m < m` |
common.misc.ENUMERATEL_ADD1 | generic | `forall n f:num->A list. ENUMERATEL (n + 1) f = APPEND (f n) (ENUMERATEL n f)` |
common.misc.ENUMERATEL_APPEND_ZERO | generic | `forall f:num->A list l.
APPEND (ENUMERATEL 0 f) l = l /\
APPEND l (ENUMERATEL 0 f) = l` |
common.misc.ALL_IMP2 | generic | `forall (l:(A)list).
(forall x. P x ==> Q x) ==> ALL P l ==> ALL Q l` |
common.misc.ALL_F | generic | `forall (l:(A)list) h. ALL (\x. false) (CONS h l) <=> F` |
common.misc.EX_SUBSET_LIST | generic | `forall (l:(A)list) P l2.
EX P l /\ ALL (\x. MEM x l2) l ==> EX P l2` |
common.misc.GEN_EX_SUBSET_LIST | generic | `
forall (P:A->bool) Q (l:(A)list) l2.
(forall a b. P a /\ Q a b ==> P b) ==>
EX (\x. P x) l /\ ALL (\x. EX (\y. Q x y) l2) l ==> EX (\x. P x) l2` |
common.components.COMPONENT_INJ | generic | `!rw rw'. component rw = component rw' <=> rw = rw'` |
common.components.FORALL_COMPONENT | generic | `(!c:(S,V)component. P c) <=> !r w. P(component(r,w))` |
common.components.EXISTS_COMPONENT | generic | `(?c:(S,V)component. P c) <=> ?r w. P(component(r,w))` |
common.components.read | program_state | `!(r:S->V) w. read(component(r,w)) = r` |
common.components.write | program_state | `!(r:S->V) w. write(component(r,w)) = w` |
common.components.COMPONENT_EQ | program_state | `!c1 c2. c1 = c2 <=> read c1 = read c2 /\ write c1 = write c2` |
common.components.READ_ENTIRETY | program_state | `read entirety = I /\ (!s. read entirety s = s)` |
common.components.WRITE_ENTIRETY | program_state | `(!y. write entirety y = \s. y) /\ (!s y. write entirety y s = y)` |
common.components.READ_WRITE_ENTIRETY | program_state | `!y s. read entirety (write entirety y s) = y` |
common.components.COMPONENT_COMPOSE_ASSOC | program_state | `!sc1 sc2 sc3. sc1 :> (sc2 :> sc3) = (sc1 :> sc2) :> sc3` |
common.components.READ_COMPONENT_COMPOSE | program_state | `!sc1 sc2 s. read (sc1 :> sc2) s = read sc2 (read sc1 s)` |
common.components.WRITE_COMPONENT_COMPOSE | program_state | `!sc1 sc2 s x. write (sc1 :> sc2) x s =
write sc1 (write sc2 x (read sc1 s)) s` |
common.components.COMPOSE_ENTIRETY | program_state | `(!c. c :> entirety = c) /\ (!c. entirety :> c = c)` |
common.components.READ_WRITE_COMPONENT_COMPOSE | program_state | `!sc1 sc2.
(!y s. read sc1 (write sc1 y s) = y) /\
(!y s. read sc2 (write sc2 y s) = y)
==> !y s. read (sc1 :> sc2) (write (sc1 :> sc2) y s) = y` |
common.components.READ_WRITE_COMPONENT_COMPOSE_GEN2 | program_state | `!f sc1 sc2.
(!y s. read sc1 (write sc1 y s) = y) /\
(!y s. read sc2 (write sc2 y s) = f y)
==> !y s. read (sc1 :> sc2) (write (sc1 :> sc2) y s) = f y` |
common.components.READ_WRITE_COMPONENT_COMPOSE_CONDITIONAL | program_state | `!sc1 sc2.
(!y s. read sc1 (write sc1 y s) = y) /\
(!y s. read sc2 (write sc2 y (read sc1 s)) = y)
==> !y s. read (sc1 :> sc2) (write (sc1 :> sc2) y s) = y` |
common.components.READ_WRITE_ORTHOGONAL_COMPOSE_L | program_state | `!c1 c2 f.
(!y s. read c1 (write c1 y s) = y) /\
(!y s. read c2 (write c2 y s) = f y)
==> !y s. read (c1 :> c2) (write (c1 :> c2) y s) = f y` |
common.components.WEAK_READ_OVER_WRITE | program_state | `!c:(S,A)component.
weak_read_over_write c <=>
!y s s'. read c (write c y s) = read c (write c y s')` |
common.components.READ_OVER_WRITE_COMPOSE | program_state | `!(c:(A,B)component) (d:(B,C)component).
read_over_write c /\ read_over_write d
==> read_over_write(c :> d)` |
common.components.WRITE_OVER_READ_COMPOSE | program_state | `!(c:(A,B)component) (d:(B,C)component).
write_over_read c /\ write_over_read d
==> write_over_read(c :> d)` |
common.components.WRITE_OVER_WRITE_COMPOSE | program_state | `!(c:(A,B)component) (d:(B,C)component).
read_over_write c /\
write_over_write c /\ write_over_write d
==> write_over_write(c :> d)` |
common.components.WEAK_READ_OVER_WRITE_COMPOSE | program_state | `!(c:(A,B)component) (d:(B,C)component).
read_over_write c /\ weak_read_over_write d
==> weak_read_over_write(c :> d)` |
common.components.VALID_COMPONENT_UNWAP | program_state | `!c:(S,A)component.
valid_component c <=>
read_over_write c /\ write_over_write c` |
common.components.VALID_COMPONENT_COMPOSE | program_state | `!c1 c2. valid_component c1 /\ valid_component c2
==> valid_component(c1 :> c2)` |
common.components.READ_WRITE_VALID_COMPONENT | program_state | `!c y s. valid_component c ==> read c (write c (y:V) (s:S)) = y` |
common.components.VALID_COMPONENT_ENTIRETY | generic | `valid_component entirety` |
common.components.WEAKLY_VALID_COMPONENT_UNWAP | program_state | `!c:(S,A)component.
weakly_valid_component c <=>
weak_read_over_write c /\ write_over_write c` |
common.components.WEAKLY_VALID_COMPONENT | program_state | `!c. weakly_valid_component c <=>
(!y s s'. read c (write c y s) = read c (write c y s')) /\
(!y z s. write c z (write c y s) = write c z s)` |
common.components.VALID_IMP_WEAKLY_VALID_COMPONENT | bit_vector | `!c:(S,V)component. valid_component c ==> weakly_valid_component c` |
common.components.WEAKLY_VALID_COMPONENT_COMPOSE | program_state | `!c d. valid_component c /\
weakly_valid_component d
==> weakly_valid_component (c :> d)` |
common.components.WEAKLY_VALID_COMPONENT_ENTIRETY | generic | `weakly_valid_component entirety` |
common.components.WRITE_o_WRITE | program_state | `!c:(S,V)component x y. weakly_valid_component c ==>
write c x o write c y = write c x` |
common.components.STRONGLY_VALID_COMPONENT_UNWAP | program_state | `!c:(S,A)component.
strongly_valid_component c <=>
read_over_write c /\
write_over_read c /\
write_over_write c` |
common.components.STRONGLY_VALID_IMP_VALID_COMPONENT | bit_vector | `!c:(S,V)component. strongly_valid_component c ==> valid_component c` |
common.components.STRONGLY_VALID_COMPONENT_COMPOSE | program_state | `!c1 c2. strongly_valid_component c1 /\ strongly_valid_component c2
==> strongly_valid_component(c1 :> c2)` |
common.components.STRONGLY_VALID_COMPONENT_ENTIRETY | generic | `strongly_valid_component entirety` |
common.components.EXTENSIONALLY_VALID_COMPONENT_UNWAP | program_state | `!c:(S,A)component.
extensionally_valid_component c <=>
weak_read_over_write c /\
write_over_read c /\
write_over_write c` |
common.components.EXTENSIONALLY_VALID_COMPONENT | program_state | `!c. extensionally_valid_component c <=>
(!y s s'. read c (write c y s) = read c (write c y s')) /\
(!s. write c (read c s) s = s) /\
(!y z s. write c z (write c y s) = write c z s)` |
common.components.STRONGLY_VALID_IMP_EXTENSIONALLY_VALID_COMPONENT | generic | `!c:(S,V)component.
strongly_valid_component c ==> extensionally_valid_component c` |
common.components.EXTENSIONALLY_VALID_IMP_WEAKLY_VALID_COMPONENT | generic | `!c:(S,V)component.
extensionally_valid_component c ==> weakly_valid_component c` |
common.components.EXTENSIONALLY_VALID_COMPONENT_ENTIRETY | generic | `extensionally_valid_component entirety` |
common.components.EXTENSIONALLY_VALID_COMPONENT_COMPOSE | program_state | `!c d. strongly_valid_component c /\ extensionally_valid_component d
==> extensionally_valid_component(c :> d)` |
common.components.ORTHOGONAL_COMPONENTS_SYM | generic | `!sc1 sc2. orthogonal_components sc1 sc2 <=> orthogonal_components sc2 sc1` |
common.components.ORTHOGONAL_COMPONENTS_COMPOSE_LEFT | program_state | `!sc1 sc2 sc sc'.
orthogonal_components sc1 sc2
==> orthogonal_components (sc1 :> sc) (sc2 :> sc')` |
common.components.ORTHOGONAL_COMPONENTS_COMPOSE_RIGHT_GEN | program_state | `!sc0 sc sc'.
read_over_write sc0 /\ write_over_write sc0 /\
orthogonal_components sc sc'
==> orthogonal_components (sc0 :> sc) (sc0 :> sc')` |
common.components.ORTHOGONAL_COMPONENTS_COMPOSE_RIGHT | program_state | `!sc0 sc sc'.
valid_component sc0 /\ orthogonal_components sc sc'
==> orthogonal_components (sc0 :> sc) (sc0 :> sc')` |
common.components.ORTHOGONAL_COMPONENTS_SUB_LEFT | program_state | `!sc1 sc2 sc.
orthogonal_components sc1 sc2
==> orthogonal_components (sc1 :> sc) sc2` |
common.components.ORTHOGONAL_COMPONENTS_SUB_RIGHT | program_state | `!sc1 sc2 sc.
orthogonal_components sc1 sc2
==> orthogonal_components sc1 (sc2 :> sc)` |
common.components.ORTHOGONAL_SPECIAL_COMPONENTS | program_state | `!c1 c2. write_over_read c1 /\ write_over_read c2 /\
weak_read_over_write c1 /\ weak_read_over_write c2
==> (orthogonal_components c1 c2 <=>
!y z s. write c1 y (write c2 z s) = write c2 z (write c1 y s))` |
common.components.ORTHOGONAL_COMPONENTS | program_state | `!c1 c2.
strongly_valid_component c1 /\ strongly_valid_component c2
==> (orthogonal_components c1 c2 <=>
!y z s. write c1 y (write c2 z s) = write c2 z (write c1 y s))` |
common.components.ORTHOGONAL_WEAK_COMPONENTS | program_state | `!c1 c2.
extensionally_valid_component c1 /\ extensionally_valid_component c2
==> (orthogonal_components c1 c2 <=>
!y z s. write c1 y (write c2 z s) = write c2 z (write c1 y s))` |
common.components.READ_WRITE_ORTHOGONAL_COMPONENTS | program_state | `!c d x s. orthogonal_components c d ==> read c (write d x s) = read c s` |
common.components.WRITE_SYM | program_state | `!c:(S,V)component d:(S,V)component f g. orthogonal_components c d ==>
write c x o write d y = write d y o write c x` |
common.components.READ_WRITE_EVALUATE | program_state | `(!f:A->B. read (evaluate f) s = f s) /\
(!(f:A->B) y. write (evaluate f) y s = s)` |
common.components.READ_RVALUE | generic | `read(rvalue (c:V)) (s:S) = c` |
common.components.WRITE_RVALUE | program_state | `write (rvalue c) y s = s` |
common.components.READ_WRITE_RVALUE | program_state | `(read (rvalue c) = \s. c) /\ (write(rvalue c) = \y s. s)` |
common.components.COMPONENT_COMPOSE_RVALUE | program_state | `!y (c:(A,B)component).
rvalue y :> c = rvalue(read c y)` |
common.components.COMPONENT_LCOMPOSE_RVALUE | program_state | `!(y:V) (c:(A,B)component). extensionally_valid_component c ==>
c :> rvalue y = rvalue y` |
common.components.ORTHOGONAL_COMPONENTS_RVALUE | program_state | `(!(c:(S,A)component) y. orthogonal_components c (rvalue y)) /\
(!(c:(S,A)component) y. orthogonal_components (rvalue y) c) /\
(!(c:(S,A)component) y (d:(A,B)component).
orthogonal_components c (rvalue y :> d)) /\
(!(c:(S,A)component) y (d:(A,B)component).
orthogonal_components (rvalue y :> d) ... |
common.components.READ_WRITE_THROUGH | program_state | `!f g s. read (through(f,g)) (write (through(f,g)) y s) = f(g y)` |
common.components.READ_WRITE_ASWORD | program_state | `!y s. read asword (write asword y s) = y` |
common.components.WRITE_ASWORD_MOD | program_state | `!y:(N)word s n.
2 EXP dimindex(:N) = n ==> (write asword y s) MOD n = write asword y s` |
common.components.READ_WRITE_ASNUMBER | program_state | `!y s:(N)word. read asnumber (write asnumber y s) =
y MOD (2 EXP (dimindex(:N)))` |
common.components.EXTENSIONALLY_VALID_COMPONENT_ASNUMBER | generic | `extensionally_valid_component asnumber` |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.