|
2 | 2 | "cells": [ |
3 | 3 | { |
4 | 4 | "cell_type": "code", |
5 | | - "execution_count": 44, |
| 5 | + "execution_count": 1, |
6 | 6 | "metadata": { |
7 | 7 | "collapsed": false |
8 | 8 | }, |
|
16 | 16 | " Vec({0, 1, 2, 3, 4},{0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 3.0})]" |
17 | 17 | ] |
18 | 18 | }, |
19 | | - "execution_count": 44, |
| 19 | + "execution_count": 1, |
20 | 20 | "metadata": {}, |
21 | 21 | "output_type": "execute_result" |
22 | 22 | } |
|
70 | 70 | }, |
71 | 71 | { |
72 | 72 | "cell_type": "code", |
73 | | - "execution_count": 10, |
| 73 | + "execution_count": null, |
74 | 74 | "metadata": { |
75 | 75 | "collapsed": false |
76 | 76 | }, |
77 | | - "outputs": [ |
78 | | - { |
79 | | - "name": "stdout", |
80 | | - "output_type": "stream", |
81 | | - "text": [ |
82 | | - "\n", |
83 | | - " A B C D\n", |
84 | | - " ---------\n", |
85 | | - " 1 | 1 1 0 0\n", |
86 | | - " 2 | 1 0 1 0\n", |
87 | | - " 3 | 0 1 1 1\n", |
88 | | - " 4 | 1 0 0 0\n", |
89 | | - "\n", |
90 | | - "\n", |
91 | | - " A B C D\n", |
92 | | - " -----------------\n", |
93 | | - " 0 | one one 0 0\n", |
94 | | - " 1 | 0 one one 0\n", |
95 | | - " 2 | 0 0 0 one\n", |
96 | | - " 3 | 0 0 one one\n", |
97 | | - "\n" |
98 | | - ] |
99 | | - } |
100 | | - ], |
| 77 | + "outputs": [], |
101 | 78 | "source": [ |
102 | | - "from cracking_rand import *\n", |
103 | | - "import random\n", |
104 | | - "prng = random.Random()\n", |
105 | | - "n = 64\n", |
106 | | - "data = [prng.getrandbits(32) for k in range(n)]\n", |
107 | | - "seed = prng.getstate()[1][:n]\n", |
108 | | - "\n", |
109 | | - "Bd = (set([1,2,3,4]), set(['A','B','C','D']))\n", |
110 | | - "Bf = {k:1 for k in {(1,'A'),(1,'B'),(2,'A'),(2,'C'),(3,'B'),(3,'C'),(3,'D'),(4,'A')}}\n", |
111 | | - "B=Mat(Bd, Bf)\n", |
112 | | - "\n", |
113 | | - "print(B)\n", |
114 | | - "print(transformation(B)*B)\n" |
| 79 | + "# from cracking_rand import *\n", |
| 80 | + "# import random\n", |
| 81 | + "# prng = random.Random()\n", |
| 82 | + "# n = 64\n", |
| 83 | + "# data = [prng.getrandbits(32) for k in range(n)]\n", |
| 84 | + "# seed = prng.getstate()[1][:n]\n", |
| 85 | + "\n", |
| 86 | + "# Bd = (set([1,2,3,4]), set(['A','B','C','D']))\n", |
| 87 | + "# Bf = {k:1 for k in {(1,'A'),(1,'B'),(2,'A'),(2,'C'),(3,'B'),(3,'C'),(3,'D'),(4,'A')}}\n", |
| 88 | + "# B=Mat(Bd, Bf)\n", |
| 89 | + "\n", |
| 90 | + "# print(B)\n", |
| 91 | + "# print(transformation(B)*B)\n" |
115 | 92 | ] |
116 | 93 | }, |
117 | 94 | { |
118 | 95 | "cell_type": "code", |
119 | | - "execution_count": 11, |
| 96 | + "execution_count": 2, |
120 | 97 | "metadata": { |
121 | 98 | "collapsed": false |
122 | 99 | }, |
|
145 | 122 | }, |
146 | 123 | { |
147 | 124 | "cell_type": "code", |
148 | | - "execution_count": 12, |
| 125 | + "execution_count": 3, |
149 | 126 | "metadata": { |
150 | 127 | "collapsed": false |
151 | 128 | }, |
|
159 | 136 | }, |
160 | 137 | { |
161 | 138 | "cell_type": "code", |
162 | | - "execution_count": 19, |
| 139 | + "execution_count": 11, |
163 | 140 | "metadata": { |
164 | 141 | "collapsed": false |
165 | 142 | }, |
|
169 | 146 | "output_type": "stream", |
170 | 147 | "text": [ |
171 | 148 | "\n", |
172 | | - " 0 1 2 3\n", |
173 | | - " ---------------\n", |
174 | | - " 0 | 0 0 one one\n", |
175 | | - " 1 | one 0 0 0\n", |
| 149 | + " 0 1 2 3\n", |
| 150 | + " -----------------\n", |
| 151 | + " 0 | 0 0 one one\n", |
| 152 | + " 1 | one one 0 0\n", |
176 | 153 | "\n", |
177 | 154 | "0\n", |
178 | 155 | "1\n", |
|
187 | 164 | "\n", |
188 | 165 | "import random\n", |
189 | 166 | "def randGF2() :\n", |
190 | | - " random.seed(a=None, version=2)\n", |
| 167 | + " #random.seed(a=None, version=2)\n", |
191 | 168 | " return random.randint(0,1)*one\n", |
192 | 169 | "\n", |
193 | 170 | "# Task 7.7.1\n", |
|
196 | 173 | " u_list = [randGF2() for i in range(6)]\n", |
197 | 174 | " u_vec = list2vec(u_list)\n", |
198 | 175 | " while (a0*u_vec) != s or (b0 * u_vec) != t:\n", |
| 176 | + " random.seed(a=None, version=2)\n", |
199 | 177 | " u_list = [randGF2() for i in range(6)]\n", |
200 | 178 | " u_vec = list2vec(u_list)\n", |
201 | 179 | " return u_vec\n", |
|
239 | 217 | " if independence.is_independent([a1,b1,a2,b2,a3,b3]) & independence.is_independent([a2,b2,a3,b3,a4,b4]) & \\\n", |
240 | 218 | " independence.is_independent([a1,b1,a2,b2,a4,b4]):\n", |
241 | 219 | " flag_independent = True\n", |
242 | | - " \n", |
243 | | - " \n", |
244 | | - "\n", |
245 | | - "#print(iter)\n", |
| 220 | + " \n", |
| 221 | + "# print(iter)\n", |
246 | 222 | "# print(a1) \n", |
247 | 223 | "# print(b1) \n", |
248 | 224 | "# print(a2) \n", |
|
253 | 229 | "# print(b4) \n", |
254 | 230 | "# print(independence.is_independent([a1,b1,a2,b2,a4,b4]))\n", |
255 | 231 | "\n", |
256 | | - " \n", |
257 | | - " \n", |
258 | | - "\n", |
259 | 232 | "# Task 7.7.6\n", |
260 | 233 | "\n", |
261 | | - "list_bits = str2bits('R')\n", |
| 234 | + "list_bits = str2bits('Z')\n", |
262 | 235 | "\n", |
263 | 236 | "mat_2_into_n = bits2mat(list_bits,2)\n", |
264 | 237 | "\n", |
|
275 | 248 | }, |
276 | 249 | { |
277 | 250 | "cell_type": "code", |
278 | | - "execution_count": 95, |
| 251 | + "execution_count": 12, |
279 | 252 | "metadata": { |
280 | 253 | "collapsed": false |
281 | 254 | }, |
|
284 | 257 | "name": "stdout", |
285 | 258 | "output_type": "stream", |
286 | 259 | "text": [ |
287 | | - "z\n" |
| 260 | + "Z\n", |
| 261 | + "\n", |
| 262 | + " 0 1 2 3\n", |
| 263 | + " -----------------\n", |
| 264 | + " 0 | 0 0 one one\n", |
| 265 | + " 1 | one one 0 0\n", |
| 266 | + "\n", |
| 267 | + "True\n", |
| 268 | + "\n", |
| 269 | + " 0 1 2 3 4 5\n", |
| 270 | + "--------------------\n", |
| 271 | + " one one 0 0 one one\n", |
| 272 | + "\n", |
| 273 | + " 0 1 2 3\n", |
| 274 | + " -----------------\n", |
| 275 | + " 0 | one 0 0 0\n", |
| 276 | + " 1 | 0 0 one 0\n", |
| 277 | + " 2 | 0 one one 0\n", |
| 278 | + " 3 | one one one one\n", |
| 279 | + " 4 | 0 0 0 one\n", |
| 280 | + " 5 | 0 one one 0\n", |
| 281 | + "\n", |
| 282 | + "\n", |
| 283 | + " 0 1 2 3 4 5\n", |
| 284 | + "------------------\n", |
| 285 | + " 0 0 one one 0 one\n" |
288 | 286 | ] |
289 | 287 | } |
290 | 288 | ], |
|
334 | 332 | "\n", |
335 | 333 | "D = {i for i in range(6) }\n", |
336 | 334 | "\n", |
337 | | - "b0 = Vec(D,{0:TA1_a1[0],1:TA1_b1[0],2:TA2_a2[0],3:TA2_b2[0],4:TA3_a3[0],5:TA3_b3[0]})\n", |
338 | | - "b1 = Vec(D,{0:TA1_a1[1],1:TA1_b1[1],2:TA2_a2[1],3:TA2_b2[1],4:TA3_a3[1],5:TA3_b3[1]})\n", |
339 | | - "b2 = Vec(D,{0:TA1_a1[2],1:TA1_b1[2],2:TA2_a2[2],3:TA2_b2[2],4:TA3_a3[2],5:TA3_b3[2]})\n", |
340 | | - "b3 = Vec(D,{0:TA1_a1[3],1:TA1_b1[3],2:TA2_a2[3],3:TA2_b2[3],4:TA3_a3[3],5:TA3_b3[3]})\n", |
| 335 | + "sol0 = Vec(D,{0:TA1_a1[0],1:TA1_b1[0],2:TA2_a2[0],3:TA2_b2[0],4:TA3_a3[0],5:TA3_b3[0]})\n", |
| 336 | + "sol1 = Vec(D,{0:TA1_a1[1],1:TA1_b1[1],2:TA2_a2[1],3:TA2_b2[1],4:TA3_a3[1],5:TA3_b3[1]})\n", |
| 337 | + "sol2 = Vec(D,{0:TA1_a1[2],1:TA1_b1[2],2:TA2_a2[2],3:TA2_b2[2],4:TA3_a3[2],5:TA3_b3[2]})\n", |
| 338 | + "sol3 = Vec(D,{0:TA1_a1[3],1:TA1_b1[3],2:TA2_a2[3],3:TA2_b2[3],4:TA3_a3[3],5:TA3_b3[3]})\n", |
341 | 339 | "\n", |
342 | 340 | "# solver.solve(A_matrix,b0)\n", |
343 | 341 | "\n", |
344 | 342 | "#print(b1)\n", |
345 | 343 | "#print(share_matrix_dict)\n", |
346 | | - "u0=solver.solve(A_matrix,b0)\n", |
347 | | - "u1=solver.solve(A_matrix,b1)\n", |
348 | | - "u2=solver.solve(A_matrix,b2)\n", |
349 | | - "u3=solver.solve(A_matrix,b3)\n", |
| 344 | + "u0=solver.solve(A_matrix,sol0)\n", |
| 345 | + "u1=solver.solve(A_matrix,sol1)\n", |
| 346 | + "u2=solver.solve(A_matrix,sol2)\n", |
| 347 | + "u3=solver.solve(A_matrix,sol3)\n", |
350 | 348 | "#print(u_dict_vec)\n", |
351 | 349 | "rev_col_dict = {}\n", |
352 | 350 | "\n", |
|
355 | 353 | "rev_col_dict[2] = list2vec([a0*u2,b0*u2])\n", |
356 | 354 | "rev_col_dict[3] = list2vec([a0*u3,b0*u3])\n", |
357 | 355 | "\n", |
358 | | - "print(bits2str(mat2bits(coldict2mat(rev_col_dict))))\n" |
| 356 | + "print(bits2str(mat2bits(coldict2mat(rev_col_dict))))\n", |
| 357 | + "\n", |
| 358 | + "print(((coldict2mat(rev_col_dict))))\n", |
| 359 | + "\n", |
| 360 | + "\n", |
| 361 | + "# testing independence\n", |
| 362 | + "\n", |
| 363 | + "\n", |
| 364 | + "print(independence.is_independent([a1,b1,a2,b2,a3,b3]))\n", |
| 365 | + "print(b1)\n", |
| 366 | + "\n", |
| 367 | + "print(u_mat)\n", |
| 368 | + "print(u1)\n", |
| 369 | + "\n" |
359 | 370 | ] |
360 | 371 | }, |
361 | 372 | { |
|
366 | 377 | }, |
367 | 378 | "outputs": [], |
368 | 379 | "source": [ |
| 380 | + "import os\n", |
| 381 | + "#print(os.urandom(2))\n", |
369 | 382 | "\n", |
370 | 383 | "# testing independence\n", |
371 | 384 | "\n", |
| 385 | + "print(independence.is_independent([a1,b1,a2,b2,a3,b3]))\n", |
| 386 | + "print(independence.is_independent([list2vec(v) for v in [[2,4,0],[8,16,4],[0,0,7]]]))\n", |
372 | 387 | "\n", |
373 | | - "independence.is_independent([list2vec(v) for v in [[2,4,0],[8,16,4],[0,0,7]]])\n", |
374 | | - "\n", |
375 | | - "independence.is_independent([list2vec(v) for v in [[2,4,0],[8,16,4]]])\n", |
| 388 | + "print(independence.is_independent([list2vec(v) for v in [[2,4,0],[8,16,4]]]))\n", |
376 | 389 | "\n" |
377 | 390 | ] |
378 | 391 | } |
|
0 commit comments