Hugging Face's logo

Datasets:
kreasof-ai
/
ECA-Zero

Tasks:
Text Generation
Modalities:
Text
Formats:
parquet
Size:
100K - 1M
ArXiv:
Tags:
reasoning
Libraries:
Datasets
Dask
Polars
License:
Dataset card Data Studio Files
xet
Community
1
Dataset Viewer
Auto-converted to Parquet Duplicate
task
stringclasses
3 values
input
stringlengths
81
131
cot
stringlengths
478
6.26k
target
stringlengths
12
62
induction
Task: Induction, Start: 110000101000, End: 111011100101, Steps: 12, Hint: Class 4
Task: Find rule in Class 4. Candidates: [124, 147, 110, 106, 54, 137, 193] Attempt 1: Testing Rule 124 [111->0, 110->1, 101->1, 100->1, 011->1, 010->1, 001->0, 000->0] Sim Step 1: 111000111100 Sim Step 2: 101100100110 Sim Step 3: 111110110111 Sim Step 4: 000011111100 Sim Step 5: 000010000110 Sim Step 6: 000011000111 Sim Step 7: 100011100101 Sim Step 8: 110010110111 Sim Step 9: 011011111100 Sim Step 10: 011110000110 Sim Step 11: 010011000111 Sim Step 12: 111011100101 Verification: Exact Match. Rule Confirmed.
111->0, 110->1, 101->1, 100->1, 011->1, 010->1, 001->0, 000->0
induction
Task: Induction, Start: 00001110001011001010, End: 01111011100000010111, Steps: 14, Hint: Class 4
Task: Find rule in Class 4. Candidates: [193, 137, 54, 147, 106, 124, 110] Attempt 1: Testing Rule 193 [111->1, 110->1, 101->0, 100->0, 011->0, 010->0, 001->0, 000->1] Sim Step 1: 11100110100001000000 Sim Step 2: 01100010001100011110 Sim Step 3: 00101000100101001110 Sim Step 4: 10000010000000000110 Sim Step 5: 00111000111111110010 Sim Step 6: 10011010011111110000 Sim Step 7: 00001000001111110110 Sim Step 8: 11100011100111110010 Sim Step 9: 01101001100011110000 Sim Step 10: 00100000101001110111 Sim Step 11: 00001110000000110011 Sim Step 12: 01100110111110010001 Sim Step 13: 00100010011110000100 Sim Step 14: 10001000001110110001 Verification: Mismatch (Expected 01111011100000010111). Next... Attempt 2: Testing Rule 137 [111->1, 110->0, 101->0, 100->0, 011->1, 010->0, 001->0, 000->1] Sim Step 1: 11101100100010000000 Sim Step 2: 11001000001000111110 Sim Step 3: 10000011100010111100 Sim Step 4: 00111011001000111000 Sim Step 5: 10110010000010110011 Sim Step 6: 00100000111000100011 Sim Step 7: 00001110110010001010 Sim Step 8: 11101100100000100000 Sim Step 9: 11001000001110001110 Sim Step 10: 10000011101100101100 Sim Step 11: 00111011001000001000 Sim Step 12: 10110010000011100011 Sim Step 13: 00100000111011001011 Sim Step 14: 00001110110010000010 Verification: Mismatch (Expected 01111011100000010111). Next... Attempt 3: Testing Rule 54 [111->0, 110->0, 101->1, 100->1, 011->0, 010->1, 001->1, 000->0] Sim Step 1: 00010001011100111111 Sim Step 2: 10111011100011000000 Sim Step 3: 11000100010100100001 Sim Step 4: 00101110111111110010 Sim Step 5: 01110001000000001111 Sim Step 6: 10001011100000010000 Sim Step 7: 11011100010000111001 Sim Step 8: 00100010111001000110 Sim Step 9: 01110111000111101001 Sim Step 10: 10001000101000011111 Sim Step 11: 01011101111100100000 Sim Step 12: 11100010000011110000 Sim Step 13: 00010111000100001001 Sim Step 14: 10111000101110011111 Verification: Mismatch (Expected 01111011100000010111). Next... Attempt 4: Testing Rule 147 [111->1, 110->0, 101->0, 100->1, 011->0, 010->0, 001->1, 000->1] Sim Step 1: 11110101110000110001 Sim Step 2: 11100000101111001110 Sim Step 3: 01011111000110110100 Sim Step 4: 10001110111000000011 Sim Step 5: 01110100010111111101 Sim Step 6: 00100011100011111000 Sim Step 7: 11011101011101110111 Sim Step 8: 10001000001000100011 Sim Step 9: 01110111110111011101 Sim Step 10: 00100011100010001000 Sim Step 11: 11011101011101110111 Sim Step 12: 10001000001000100011 Sim Step 13: 01110111110111011101 Sim Step 14: 00100011100010001000 Verification: Mismatch (Expected 01111011100000010111). Next... Attempt 5: Testing Rule 106 [111->0, 110->1, 101->1, 100->0, 011->1, 010->0, 001->1, 000->0] Sim Step 1: 00011010010111010100 Sim Step 2: 00111100101101101000 Sim Step 3: 01100101011111110000 Sim Step 4: 11101010110000010000 Sim Step 5: 10110101110000100001 Sim Step 6: 11111011010001000011 Sim Step 7: 00001111100010000110 Sim Step 8: 00011000100100001110 Sim Step 9: 00111001001000011010 Sim Step 10: 01101010010000111100 Sim Step 11: 11110100100001100100 Sim Step 12: 10011001000011101001 Sim Step 13: 10111010000110110011 Sim Step 14: 11101100001111110110 Verification: Mismatch (Expected 01111011100000010111). Next... Attempt 6: Testing Rule 124 [111->0, 110->1, 101->1, 100->1, 011->1, 010->1, 001->0, 000->0] Sim Step 1: 00001011001111101111 Sim Step 2: 10001111101000111001 Sim Step 3: 11001000111100101101 Sim Step 4: 01101100100110111111 Sim Step 5: 11111110110111100001 Sim Step 6: 00000011111100110001 Sim Step 7: 10000010000110111001 Sim Step 8: 11000011000111101101 Sim Step 9: 01100011100100111111 Sim Step 10: 11110010110110100001 Sim Step 11: 00011011111111110001 Sim Step 12: 10011110000000011001 Sim Step 13: 11010011000000011101 Sim Step 14: 01111011100000010111 Verification: Exact Match. Rule Confirmed.
111->0, 110->1, 101->1, 100->1, 011->1, 010->1, 001->0, 000->0
deduction
Task: Deduction, Rule: 19 [111->0, 110->0, 101->0, 100->1, 011->0, 010->0, 001->1, 000->1], Steps: 15, Start: 11100011110111
Step 1 Scan: 0:[111]->0 | 1:[111]->0 | 2:[110]->0 | 3:[100]->1 | 4:[000]->1 | 5:[001]->1 | 6:[011]->0 | 7:[111]->0 | 8:[111]->0 | 9:[110]->0 | 10:[101]->0 | 11:[011]->0 | 12:[111]->0 | 13:[111]->0 Step 1 Output: 00011100000000 Step 2 Scan: 0:[000]->1 | 1:[000]->1 | 2:[001]->1 | 3:[011]->0 | 4:[111]->0 | 5:[110]->0 | 6:[100]->1 | 7:[000]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[000]->1 | 12:[000]->1 | 13:[000]->1 Step 2 Output: 11100011111111 Step 3 Scan: 0:[111]->0 | 1:[111]->0 | 2:[110]->0 | 3:[100]->1 | 4:[000]->1 | 5:[001]->1 | 6:[011]->0 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 | 12:[111]->0 | 13:[111]->0 Step 3 Output: 00011100000000 Step 4 Scan: 0:[000]->1 | 1:[000]->1 | 2:[001]->1 | 3:[011]->0 | 4:[111]->0 | 5:[110]->0 | 6:[100]->1 | 7:[000]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[000]->1 | 12:[000]->1 | 13:[000]->1 Step 4 Output: 11100011111111 Step 5 Scan: 0:[111]->0 | 1:[111]->0 | 2:[110]->0 | 3:[100]->1 | 4:[000]->1 | 5:[001]->1 | 6:[011]->0 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 | 12:[111]->0 | 13:[111]->0 Step 5 Output: 00011100000000 Step 6 Scan: 0:[000]->1 | 1:[000]->1 | 2:[001]->1 | 3:[011]->0 | 4:[111]->0 | 5:[110]->0 | 6:[100]->1 | 7:[000]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[000]->1 | 12:[000]->1 | 13:[000]->1 Step 6 Output: 11100011111111 Step 7 Scan: 0:[111]->0 | 1:[111]->0 | 2:[110]->0 | 3:[100]->1 | 4:[000]->1 | 5:[001]->1 | 6:[011]->0 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 | 12:[111]->0 | 13:[111]->0 Step 7 Output: 00011100000000 Step 8 Scan: 0:[000]->1 | 1:[000]->1 | 2:[001]->1 | 3:[011]->0 | 4:[111]->0 | 5:[110]->0 | 6:[100]->1 | 7:[000]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[000]->1 | 12:[000]->1 | 13:[000]->1 Step 8 Output: 11100011111111 Step 9 Scan: 0:[111]->0 | 1:[111]->0 | 2:[110]->0 | 3:[100]->1 | 4:[000]->1 | 5:[001]->1 | 6:[011]->0 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 | 12:[111]->0 | 13:[111]->0 Step 9 Output: 00011100000000 Step 10 Scan: 0:[000]->1 | 1:[000]->1 | 2:[001]->1 | 3:[011]->0 | 4:[111]->0 | 5:[110]->0 | 6:[100]->1 | 7:[000]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[000]->1 | 12:[000]->1 | 13:[000]->1 Step 10 Output: 11100011111111 Step 11 Scan: 0:[111]->0 | 1:[111]->0 | 2:[110]->0 | 3:[100]->1 | 4:[000]->1 | 5:[001]->1 | 6:[011]->0 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 | 12:[111]->0 | 13:[111]->0 Step 11 Output: 00011100000000 Step 12 Scan: 0:[000]->1 | 1:[000]->1 | 2:[001]->1 | 3:[011]->0 | 4:[111]->0 | 5:[110]->0 | 6:[100]->1 | 7:[000]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[000]->1 | 12:[000]->1 | 13:[000]->1 Step 12 Output: 11100011111111 Step 13 Scan: 0:[111]->0 | 1:[111]->0 | 2:[110]->0 | 3:[100]->1 | 4:[000]->1 | 5:[001]->1 | 6:[011]->0 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 | 12:[111]->0 | 13:[111]->0 Step 13 Output: 00011100000000 Step 14 Scan: 0:[000]->1 | 1:[000]->1 | 2:[001]->1 | 3:[011]->0 | 4:[111]->0 | 5:[110]->0 | 6:[100]->1 | 7:[000]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[000]->1 | 12:[000]->1 | 13:[000]->1 Step 14 Output: 11100011111111 Step 15 Scan: 0:[111]->0 | 1:[111]->0 | 2:[110]->0 | 3:[100]->1 | 4:[000]->1 | 5:[001]->1 | 6:[011]->0 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 | 12:[111]->0 | 13:[111]->0 Step 15 Output: 00011100000000
00011100000000
abduction
Task: Abduction, Rule: 105 [111->0, 110->1, 101->1, 100->0, 011->1, 010->0, 001->0, 000->1], Steps: 2, End: 10101001011101011
Goal: Reverse 2 steps by calculating likelihoods of priors. Step -1: Inverting state 10101001011101011 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '011', '101', '110'] Idx 1 requires neighborhood in ['001', '010', '100', '111'] Idx 2 requires neighborhood in ['000', '011', '101', '110'] Idx 3 requires neighborhood in ['001', '010', '100', '111'] Idx 4 requires neighborhood in ['000', '011', '101', '110'] Idx 5 requires neighborhood in ['001', '010', '100', '111'] Idx 6 requires neighborhood in ['001', '010', '100', '111'] Idx 7 requires neighborhood in ['000', '011', '101', '110'] Idx 8 requires neighborhood in ['001', '010', '100', '111'] Idx 9 requires neighborhood in ['000', '011', '101', '110'] Idx 10 requires neighborhood in ['000', '011', '101', '110'] Idx 11 requires neighborhood in ['000', '011', '101', '110'] Idx 12 requires neighborhood in ['001', '010', '100', '111'] Idx 13 requires neighborhood in ['000', '011', '101', '110'] Idx 14 requires neighborhood in ['001', '010', '100', '111'] Idx 15 requires neighborhood in ['000', '011', '101', '110'] Idx 16 requires neighborhood in ['000', '011', '101', '110'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% | 12:50% | 13:50% | 14:50% | 15:50% | 16:50% Greedy Candidate: 11111111111111111 Verification: Mismatch. Correction applied -> 00111001110111000 Step -2: Inverting state 00111001110111000 Calculating Local Priors: Idx 0 requires neighborhood in ['001', '010', '100', '111'] Idx 1 requires neighborhood in ['001', '010', '100', '111'] Idx 2 requires neighborhood in ['000', '011', '101', '110'] Idx 3 requires neighborhood in ['000', '011', '101', '110'] Idx 4 requires neighborhood in ['000', '011', '101', '110'] Idx 5 requires neighborhood in ['001', '010', '100', '111'] Idx 6 requires neighborhood in ['001', '010', '100', '111'] Idx 7 requires neighborhood in ['000', '011', '101', '110'] Idx 8 requires neighborhood in ['000', '011', '101', '110'] Idx 9 requires neighborhood in ['000', '011', '101', '110'] Idx 10 requires neighborhood in ['001', '010', '100', '111'] Idx 11 requires neighborhood in ['000', '011', '101', '110'] Idx 12 requires neighborhood in ['000', '011', '101', '110'] Idx 13 requires neighborhood in ['000', '011', '101', '110'] Idx 14 requires neighborhood in ['001', '010', '100', '111'] Idx 15 requires neighborhood in ['001', '010', '100', '111'] Idx 16 requires neighborhood in ['001', '010', '100', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% | 12:50% | 13:50% | 14:50% | 15:50% | 16:50% Greedy Candidate: 11111111111111111 Verification: Mismatch. Correction applied -> 11101111011101111
11101111011101111
induction
Task: Induction, Start: 000001001100, End: 000000000000, Steps: 11, Hint: Class 1
Task: Find rule in Class 1. Candidates: [168, 128, 40, 0, 136, 8, 32, 160] Attempt 1: Testing Rule 168 [111->1, 110->0, 101->1, 100->0, 011->1, 010->0, 001->0, 000->0] Sim Step 1: 000000001000 Sim Step 2: 000000000000 Sim Step 3: 000000000000 Sim Step 4: 000000000000 Sim Step 5: 000000000000 Sim Step 6: 000000000000 Sim Step 7: 000000000000 Sim Step 8: 000000000000 Sim Step 9: 000000000000 Sim Step 10: 000000000000 Sim Step 11: 000000000000 Verification: Exact Match. Rule Confirmed.
111->1, 110->0, 101->1, 100->0, 011->1, 010->0, 001->0, 000->0
deduction
Task: Deduction, Rule: 54 [111->0, 110->0, 101->1, 100->1, 011->0, 010->1, 001->1, 000->0], Steps: 14, Start: 1010111010110100
Step 1 Scan: 0:[010]->1 | 1:[101]->1 | 2:[010]->1 | 3:[101]->1 | 4:[011]->0 | 5:[111]->0 | 6:[110]->0 | 7:[101]->1 | 8:[010]->1 | 9:[101]->1 | 10:[011]->0 | 11:[110]->0 | 12:[101]->1 | 13:[010]->1 | 14:[100]->1 | 15:[001]->1 Step 1 Output: 1111000111001111 Step 2 Scan: 0:[111]->0 | 1:[111]->0 | 2:[111]->0 | 3:[110]->0 | 4:[100]->1 | 5:[000]->0 | 6:[001]->1 | 7:[011]->0 | 8:[111]->0 | 9:[110]->0 | 10:[100]->1 | 11:[001]->1 | 12:[011]->0 | 13:[111]->0 | 14:[111]->0 | 15:[111]->0 Step 2 Output: 0000101000110000 Step 3 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[001]->1 | 4:[010]->1 | 5:[101]->1 | 6:[010]->1 | 7:[100]->1 | 8:[000]->0 | 9:[001]->1 | 10:[011]->0 | 11:[110]->0 | 12:[100]->1 | 13:[000]->0 | 14:[000]->0 | 15:[000]->0 Step 3 Output: 0001111101001000 Step 4 Scan: 0:[000]->0 | 1:[000]->0 | 2:[001]->1 | 3:[011]->0 | 4:[111]->0 | 5:[111]->0 | 6:[111]->0 | 7:[110]->0 | 8:[101]->1 | 9:[010]->1 | 10:[100]->1 | 11:[001]->1 | 12:[010]->1 | 13:[100]->1 | 14:[000]->0 | 15:[000]->0 Step 4 Output: 0010000011111100 Step 5 Scan: 0:[000]->0 | 1:[001]->1 | 2:[010]->1 | 3:[100]->1 | 4:[000]->0 | 5:[000]->0 | 6:[000]->0 | 7:[001]->1 | 8:[011]->0 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 | 12:[111]->0 | 13:[110]->0 | 14:[100]->1 | 15:[000]->0 Step 5 Output: 0111000100000010 Step 6 Scan: 0:[001]->1 | 1:[011]->0 | 2:[111]->0 | 3:[110]->0 | 4:[100]->1 | 5:[000]->0 | 6:[001]->1 | 7:[010]->1 | 8:[100]->1 | 9:[000]->0 | 10:[000]->0 | 11:[000]->0 | 12:[000]->0 | 13:[001]->1 | 14:[010]->1 | 15:[100]->1 Step 6 Output: 1000101110000111 Step 7 Scan: 0:[110]->0 | 1:[100]->1 | 2:[000]->0 | 3:[001]->1 | 4:[010]->1 | 5:[101]->1 | 6:[011]->0 | 7:[111]->0 | 8:[110]->0 | 9:[100]->1 | 10:[000]->0 | 11:[000]->0 | 12:[001]->1 | 13:[011]->0 | 14:[111]->0 | 15:[111]->0 Step 7 Output: 0101110001001000 Step 8 Scan: 0:[001]->1 | 1:[010]->1 | 2:[101]->1 | 3:[011]->0 | 4:[111]->0 | 5:[110]->0 | 6:[100]->1 | 7:[000]->0 | 8:[001]->1 | 9:[010]->1 | 10:[100]->1 | 11:[001]->1 | 12:[010]->1 | 13:[100]->1 | 14:[000]->0 | 15:[000]->0 Step 8 Output: 1110001011111100 Step 9 Scan: 0:[011]->0 | 1:[111]->0 | 2:[110]->0 | 3:[100]->1 | 4:[000]->0 | 5:[001]->1 | 6:[010]->1 | 7:[101]->1 | 8:[011]->0 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 | 12:[111]->0 | 13:[110]->0 | 14:[100]->1 | 15:[001]->1 Step 9 Output: 0001011100000011 Step 10 Scan: 0:[100]->1 | 1:[000]->0 | 2:[001]->1 | 3:[010]->1 | 4:[101]->1 | 5:[011]->0 | 6:[111]->0 | 7:[110]->0 | 8:[100]->1 | 9:[000]->0 | 10:[000]->0 | 11:[000]->0 | 12:[000]->0 | 13:[001]->1 | 14:[011]->0 | 15:[110]->0 Step 10 Output: 1011100010000100 Step 11 Scan: 0:[010]->1 | 1:[101]->1 | 2:[011]->0 | 3:[111]->0 | 4:[110]->0 | 5:[100]->1 | 6:[000]->0 | 7:[001]->1 | 8:[010]->1 | 9:[100]->1 | 10:[000]->0 | 11:[000]->0 | 12:[001]->1 | 13:[010]->1 | 14:[100]->1 | 15:[001]->1 Step 11 Output: 1100010111001111 Step 12 Scan: 0:[111]->0 | 1:[110]->0 | 2:[100]->1 | 3:[000]->0 | 4:[001]->1 | 5:[010]->1 | 6:[101]->1 | 7:[011]->0 | 8:[111]->0 | 9:[110]->0 | 10:[100]->1 | 11:[001]->1 | 12:[011]->0 | 13:[111]->0 | 14:[111]->0 | 15:[111]->0 Step 12 Output: 0010111000110000 Step 13 Scan: 0:[000]->0 | 1:[001]->1 | 2:[010]->1 | 3:[101]->1 | 4:[011]->0 | 5:[111]->0 | 6:[110]->0 | 7:[100]->1 | 8:[000]->0 | 9:[001]->1 | 10:[011]->0 | 11:[110]->0 | 12:[100]->1 | 13:[000]->0 | 14:[000]->0 | 15:[000]->0 Step 13 Output: 0111000101001000 Step 14 Scan: 0:[001]->1 | 1:[011]->0 | 2:[111]->0 | 3:[110]->0 | 4:[100]->1 | 5:[000]->0 | 6:[001]->1 | 7:[010]->1 | 8:[101]->1 | 9:[010]->1 | 10:[100]->1 | 11:[001]->1 | 12:[010]->1 | 13:[100]->1 | 14:[000]->0 | 15:[000]->0 Step 14 Output: 1000101111111100
1000101111111100
abduction
Task: Abduction, Rule: 150 [111->1, 110->0, 101->0, 100->1, 011->0, 010->1, 001->1, 000->0], Steps: 3, End: 00101101010100
Goal: Reverse 3 steps by calculating likelihoods of priors. Step -1: Inverting state 00101101010100 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '011', '101', '110'] Idx 1 requires neighborhood in ['000', '011', '101', '110'] Idx 2 requires neighborhood in ['001', '010', '100', '111'] Idx 3 requires neighborhood in ['000', '011', '101', '110'] Idx 4 requires neighborhood in ['001', '010', '100', '111'] Idx 5 requires neighborhood in ['001', '010', '100', '111'] Idx 6 requires neighborhood in ['000', '011', '101', '110'] Idx 7 requires neighborhood in ['001', '010', '100', '111'] Idx 8 requires neighborhood in ['000', '011', '101', '110'] Idx 9 requires neighborhood in ['001', '010', '100', '111'] Idx 10 requires neighborhood in ['000', '011', '101', '110'] Idx 11 requires neighborhood in ['001', '010', '100', '111'] Idx 12 requires neighborhood in ['000', '011', '101', '110'] Idx 13 requires neighborhood in ['000', '011', '101', '110'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% | 12:50% | 13:50% Greedy Candidate: 11111111111111 Verification: Mismatch. Correction applied -> 01110011100011 Step -2: Inverting state 01110011100011 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '011', '101', '110'] Idx 1 requires neighborhood in ['001', '010', '100', '111'] Idx 2 requires neighborhood in ['001', '010', '100', '111'] Idx 3 requires neighborhood in ['001', '010', '100', '111'] Idx 4 requires neighborhood in ['000', '011', '101', '110'] Idx 5 requires neighborhood in ['000', '011', '101', '110'] Idx 6 requires neighborhood in ['001', '010', '100', '111'] Idx 7 requires neighborhood in ['001', '010', '100', '111'] Idx 8 requires neighborhood in ['001', '010', '100', '111'] Idx 9 requires neighborhood in ['000', '011', '101', '110'] Idx 10 requires neighborhood in ['000', '011', '101', '110'] Idx 11 requires neighborhood in ['000', '011', '101', '110'] Idx 12 requires neighborhood in ['001', '010', '100', '111'] Idx 13 requires neighborhood in ['001', '010', '100', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% | 12:50% | 13:50% Greedy Candidate: 11111111111111 Verification: Mismatch. Correction applied -> 10010111110111 Step -3: Inverting state 10010111110111 Calculating Local Priors: Idx 0 requires neighborhood in ['001', '010', '100', '111'] Idx 1 requires neighborhood in ['000', '011', '101', '110'] Idx 2 requires neighborhood in ['000', '011', '101', '110'] Idx 3 requires neighborhood in ['001', '010', '100', '111'] Idx 4 requires neighborhood in ['000', '011', '101', '110'] Idx 5 requires neighborhood in ['001', '010', '100', '111'] Idx 6 requires neighborhood in ['001', '010', '100', '111'] Idx 7 requires neighborhood in ['001', '010', '100', '111'] Idx 8 requires neighborhood in ['001', '010', '100', '111'] Idx 9 requires neighborhood in ['001', '010', '100', '111'] Idx 10 requires neighborhood in ['000', '011', '101', '110'] Idx 11 requires neighborhood in ['001', '010', '100', '111'] Idx 12 requires neighborhood in ['001', '010', '100', '111'] Idx 13 requires neighborhood in ['001', '010', '100', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% | 12:50% | 13:50% Greedy Candidate: 11111111111111 Verification: Mismatch. Correction applied -> 00001111111001
00001111111001
abduction
Task: Abduction, Rule: 30 [111->0, 110->0, 101->0, 100->1, 011->1, 010->1, 001->1, 000->0], Steps: 3, End: 11010100111101100
Goal: Reverse 3 steps by calculating likelihoods of priors. Step -1: Inverting state 11010100111101100 Calculating Local Priors: Idx 0 requires neighborhood in ['001', '010', '011', '100'] Idx 1 requires neighborhood in ['001', '010', '011', '100'] Idx 2 requires neighborhood in ['000', '101', '110', '111'] Idx 3 requires neighborhood in ['001', '010', '011', '100'] Idx 4 requires neighborhood in ['000', '101', '110', '111'] Idx 5 requires neighborhood in ['001', '010', '011', '100'] Idx 6 requires neighborhood in ['000', '101', '110', '111'] Idx 7 requires neighborhood in ['000', '101', '110', '111'] Idx 8 requires neighborhood in ['001', '010', '011', '100'] Idx 9 requires neighborhood in ['001', '010', '011', '100'] Idx 10 requires neighborhood in ['001', '010', '011', '100'] Idx 11 requires neighborhood in ['001', '010', '011', '100'] Idx 12 requires neighborhood in ['000', '101', '110', '111'] Idx 13 requires neighborhood in ['001', '010', '011', '100'] Idx 14 requires neighborhood in ['001', '010', '011', '100'] Idx 15 requires neighborhood in ['000', '101', '110', '111'] Idx 16 requires neighborhood in ['000', '101', '110', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:41% | 1:58% | 2:41% | 3:58% | 4:41% | 5:58% | 6:58% | 7:41% | 8:41% | 9:41% | 10:41% | 11:58% | 12:41% | 13:41% | 14:58% | 15:58% | 16:41% Greedy Candidate: 01010110000100110 Verification: Mismatch. Correction applied -> 01010110100101000 Step -2: Inverting state 01010110100101000 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '101', '110', '111'] Idx 1 requires neighborhood in ['001', '010', '011', '100'] Idx 2 requires neighborhood in ['000', '101', '110', '111'] Idx 3 requires neighborhood in ['001', '010', '011', '100'] Idx 4 requires neighborhood in ['000', '101', '110', '111'] Idx 5 requires neighborhood in ['001', '010', '011', '100'] Idx 6 requires neighborhood in ['001', '010', '011', '100'] Idx 7 requires neighborhood in ['000', '101', '110', '111'] Idx 8 requires neighborhood in ['001', '010', '011', '100'] Idx 9 requires neighborhood in ['000', '101', '110', '111'] Idx 10 requires neighborhood in ['000', '101', '110', '111'] Idx 11 requires neighborhood in ['001', '010', '011', '100'] Idx 12 requires neighborhood in ['000', '101', '110', '111'] Idx 13 requires neighborhood in ['001', '010', '011', '100'] Idx 14 requires neighborhood in ['000', '101', '110', '111'] Idx 15 requires neighborhood in ['000', '101', '110', '111'] Idx 16 requires neighborhood in ['000', '101', '110', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:41% | 1:58% | 2:41% | 3:58% | 4:41% | 5:41% | 6:58% | 7:41% | 8:58% | 9:58% | 10:41% | 11:58% | 12:41% | 13:58% | 14:58% | 15:58% | 16:58% Greedy Candidate: 01010010110101111 Verification: Mismatch. Correction applied -> 01100010110101111 Step -3: Inverting state 01100010110101111 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '101', '110', '111'] Idx 1 requires neighborhood in ['001', '010', '011', '100'] Idx 2 requires neighborhood in ['001', '010', '011', '100'] Idx 3 requires neighborhood in ['000', '101', '110', '111'] Idx 4 requires neighborhood in ['000', '101', '110', '111'] Idx 5 requires neighborhood in ['000', '101', '110', '111'] Idx 6 requires neighborhood in ['001', '010', '011', '100'] Idx 7 requires neighborhood in ['000', '101', '110', '111'] Idx 8 requires neighborhood in ['001', '010', '011', '100'] Idx 9 requires neighborhood in ['001', '010', '011', '100'] Idx 10 requires neighborhood in ['000', '101', '110', '111'] Idx 11 requires neighborhood in ['001', '010', '011', '100'] Idx 12 requires neighborhood in ['000', '101', '110', '111'] Idx 13 requires neighborhood in ['001', '010', '011', '100'] Idx 14 requires neighborhood in ['001', '010', '011', '100'] Idx 15 requires neighborhood in ['001', '010', '011', '100'] Idx 16 requires neighborhood in ['001', '010', '011', '100'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:41% | 1:41% | 2:58% | 3:58% | 4:58% | 5:41% | 6:58% | 7:41% | 8:41% | 9:58% | 10:41% | 11:58% | 12:41% | 13:41% | 14:41% | 15:41% | 16:58% Greedy Candidate: 00111010010100001 Verification: Mismatch. Correction applied -> 00111100010110010
00111100010110010
deduction
Task: Deduction, Rule: 90 [111->0, 110->1, 101->0, 100->1, 011->1, 010->0, 001->1, 000->0], Steps: 12, Start: 10010100101010111100
Step 1 Scan: 0:[010]->0 | 1:[100]->1 | 2:[001]->1 | 3:[010]->0 | 4:[101]->0 | 5:[010]->0 | 6:[100]->1 | 7:[001]->1 | 8:[010]->0 | 9:[101]->0 | 10:[010]->0 | 11:[101]->0 | 12:[010]->0 | 13:[101]->0 | 14:[011]->1 | 15:[111]->0 | 16:[111]->0 | 17:[110]->1 | 18:[100]->1 | 19:[001]->1 Step 1 Output: 01100011000000100111 Step 2 Scan: 0:[101]->0 | 1:[011]->1 | 2:[110]->1 | 3:[100]->1 | 4:[000]->0 | 5:[001]->1 | 6:[011]->1 | 7:[110]->1 | 8:[100]->1 | 9:[000]->0 | 10:[000]->0 | 11:[000]->0 | 12:[000]->0 | 13:[001]->1 | 14:[010]->0 | 15:[100]->1 | 16:[001]->1 | 17:[011]->1 | 18:[111]->0 | 19:[110]->1 Step 2 Output: 01110111100001011101 Step 3 Scan: 0:[101]->0 | 1:[011]->1 | 2:[111]->0 | 3:[110]->1 | 4:[101]->0 | 5:[011]->1 | 6:[111]->0 | 7:[111]->0 | 8:[110]->1 | 9:[100]->1 | 10:[000]->0 | 11:[000]->0 | 12:[001]->1 | 13:[010]->0 | 14:[101]->0 | 15:[011]->1 | 16:[111]->0 | 17:[110]->1 | 18:[101]->0 | 19:[010]->0 Step 3 Output: 01010100110010010100 Step 4 Scan: 0:[001]->1 | 1:[010]->0 | 2:[101]->0 | 3:[010]->0 | 4:[101]->0 | 5:[010]->0 | 6:[100]->1 | 7:[001]->1 | 8:[011]->1 | 9:[110]->1 | 10:[100]->1 | 11:[001]->1 | 12:[010]->0 | 13:[100]->1 | 14:[001]->1 | 15:[010]->0 | 16:[101]->0 | 17:[010]->0 | 18:[100]->1 | 19:[000]->0 Step 4 Output: 10000011111101100010 Step 5 Scan: 0:[010]->0 | 1:[100]->1 | 2:[000]->0 | 3:[000]->0 | 4:[000]->0 | 5:[001]->1 | 6:[011]->1 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[110]->1 | 12:[101]->0 | 13:[011]->1 | 14:[110]->1 | 15:[100]->1 | 16:[000]->0 | 17:[001]->1 | 18:[010]->0 | 19:[101]->0 Step 5 Output: 01000110000101110100 Step 6 Scan: 0:[001]->1 | 1:[010]->0 | 2:[100]->1 | 3:[000]->0 | 4:[001]->1 | 5:[011]->1 | 6:[110]->1 | 7:[100]->1 | 8:[000]->0 | 9:[000]->0 | 10:[001]->1 | 11:[010]->0 | 12:[101]->0 | 13:[011]->1 | 14:[111]->0 | 15:[110]->1 | 16:[101]->0 | 17:[010]->0 | 18:[100]->1 | 19:[000]->0 Step 6 Output: 10101111001001010010 Step 7 Scan: 0:[010]->0 | 1:[101]->0 | 2:[010]->0 | 3:[101]->0 | 4:[011]->1 | 5:[111]->0 | 6:[111]->0 | 7:[110]->1 | 8:[100]->1 | 9:[001]->1 | 10:[010]->0 | 11:[100]->1 | 12:[001]->1 | 13:[010]->0 | 14:[101]->0 | 15:[010]->0 | 16:[100]->1 | 17:[001]->1 | 18:[010]->0 | 19:[101]->0 Step 7 Output: 00001001110110001100 Step 8 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[001]->1 | 4:[010]->0 | 5:[100]->1 | 6:[001]->1 | 7:[011]->1 | 8:[111]->0 | 9:[110]->1 | 10:[101]->0 | 11:[011]->1 | 12:[110]->1 | 13:[100]->1 | 14:[000]->0 | 15:[001]->1 | 16:[011]->1 | 17:[110]->1 | 18:[100]->1 | 19:[000]->0 Step 8 Output: 00010111010111011110 Step 9 Scan: 0:[000]->0 | 1:[000]->0 | 2:[001]->1 | 3:[010]->0 | 4:[101]->0 | 5:[011]->1 | 6:[111]->0 | 7:[110]->1 | 8:[101]->0 | 9:[010]->0 | 10:[101]->0 | 11:[011]->1 | 12:[111]->0 | 13:[110]->1 | 14:[101]->0 | 15:[011]->1 | 16:[111]->0 | 17:[111]->0 | 18:[110]->1 | 19:[100]->1 Step 9 Output: 00100101000101010011 Step 10 Scan: 0:[100]->1 | 1:[001]->1 | 2:[010]->0 | 3:[100]->1 | 4:[001]->1 | 5:[010]->0 | 6:[101]->0 | 7:[010]->0 | 8:[100]->1 | 9:[000]->0 | 10:[001]->1 | 11:[010]->0 | 12:[101]->0 | 13:[010]->0 | 14:[101]->0 | 15:[010]->0 | 16:[100]->1 | 17:[001]->1 | 18:[011]->1 | 19:[110]->1 Step 10 Output: 11011000101000001111 Step 11 Scan: 0:[111]->0 | 1:[110]->1 | 2:[101]->0 | 3:[011]->1 | 4:[110]->1 | 5:[100]->1 | 6:[000]->0 | 7:[001]->1 | 8:[010]->0 | 9:[101]->0 | 10:[010]->0 | 11:[100]->1 | 12:[000]->0 | 13:[000]->0 | 14:[000]->0 | 15:[001]->1 | 16:[011]->1 | 17:[111]->0 | 18:[111]->0 | 19:[111]->0 Step 11 Output: 01011101000100011000 Step 12 Scan: 0:[001]->1 | 1:[010]->0 | 2:[101]->0 | 3:[011]->1 | 4:[111]->0 | 5:[110]->1 | 6:[101]->0 | 7:[010]->0 | 8:[100]->1 | 9:[000]->0 | 10:[001]->1 | 11:[010]->0 | 12:[100]->1 | 13:[000]->0 | 14:[001]->1 | 15:[011]->1 | 16:[110]->1 | 17:[100]->1 | 18:[000]->0 | 19:[000]->0 Step 12 Output: 10010100101010111100
10010100101010111100
abduction
Task: Abduction, Rule: 126 [111->0, 110->1, 101->1, 100->1, 011->1, 010->1, 001->1, 000->0], Steps: 2, End: 11000111100000110000
Goal: Reverse 2 steps by calculating likelihoods of priors. Step -1: Inverting state 11000111100000110000 Calculating Local Priors: Idx 0 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 1 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 2 requires neighborhood in ['000', '111'] Idx 3 requires neighborhood in ['000', '111'] Idx 4 requires neighborhood in ['000', '111'] Idx 5 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 6 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 7 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 8 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 9 requires neighborhood in ['000', '111'] Idx 10 requires neighborhood in ['000', '111'] Idx 11 requires neighborhood in ['000', '111'] Idx 12 requires neighborhood in ['000', '111'] Idx 13 requires neighborhood in ['000', '111'] Idx 14 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 15 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 16 requires neighborhood in ['000', '111'] Idx 17 requires neighborhood in ['000', '111'] Idx 18 requires neighborhood in ['000', '111'] Idx 19 requires neighborhood in ['000', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% | 12:50% | 13:50% | 14:50% | 15:50% | 16:50% | 17:50% | 18:50% | 19:50% Greedy Candidate: 11111111111111111111 Verification: Mismatch. Correction applied -> 01111100111111100000 Step -2: Inverting state 01111100111111100000 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '111'] Idx 1 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 2 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 3 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 4 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 5 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 6 requires neighborhood in ['000', '111'] Idx 7 requires neighborhood in ['000', '111'] Idx 8 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 9 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 10 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 11 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 12 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 13 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 14 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 15 requires neighborhood in ['000', '111'] Idx 16 requires neighborhood in ['000', '111'] Idx 17 requires neighborhood in ['000', '111'] Idx 18 requires neighborhood in ['000', '111'] Idx 19 requires neighborhood in ['000', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% | 12:50% | 13:50% | 14:50% | 15:50% | 16:50% | 17:50% | 18:50% | 19:50% Greedy Candidate: 11111111111111111111 Verification: Mismatch. Correction applied -> 11001000010110111111
11001000010110111111
deduction
Task: Deduction, Rule: 19 [111->0, 110->0, 101->0, 100->1, 011->0, 010->0, 001->1, 000->1], Steps: 10, Start: 00100110010011011
Step 1 Scan: 0:[100]->1 | 1:[001]->1 | 2:[010]->0 | 3:[100]->1 | 4:[001]->1 | 5:[011]->0 | 6:[110]->0 | 7:[100]->1 | 8:[001]->1 | 9:[010]->0 | 10:[100]->1 | 11:[001]->1 | 12:[011]->0 | 13:[110]->0 | 14:[101]->0 | 15:[011]->0 | 16:[110]->0 Step 1 Output: 11011001101100000 Step 2 Scan: 0:[011]->0 | 1:[110]->0 | 2:[101]->0 | 3:[011]->0 | 4:[110]->0 | 5:[100]->1 | 6:[001]->1 | 7:[011]->0 | 8:[110]->0 | 9:[101]->0 | 10:[011]->0 | 11:[110]->0 | 12:[100]->1 | 13:[000]->1 | 14:[000]->1 | 15:[000]->1 | 16:[001]->1 Step 2 Output: 00000110000011111 Step 3 Scan: 0:[100]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[001]->1 | 5:[011]->0 | 6:[110]->0 | 7:[100]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[001]->1 | 12:[011]->0 | 13:[111]->0 | 14:[111]->0 | 15:[111]->0 | 16:[110]->0 Step 3 Output: 11111001111100000 Step 4 Scan: 0:[011]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[110]->0 | 5:[100]->1 | 6:[001]->1 | 7:[011]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[110]->0 | 12:[100]->1 | 13:[000]->1 | 14:[000]->1 | 15:[000]->1 | 16:[001]->1 Step 4 Output: 00000110000011111 Step 5 Scan: 0:[100]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[001]->1 | 5:[011]->0 | 6:[110]->0 | 7:[100]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[001]->1 | 12:[011]->0 | 13:[111]->0 | 14:[111]->0 | 15:[111]->0 | 16:[110]->0 Step 5 Output: 11111001111100000 Step 6 Scan: 0:[011]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[110]->0 | 5:[100]->1 | 6:[001]->1 | 7:[011]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[110]->0 | 12:[100]->1 | 13:[000]->1 | 14:[000]->1 | 15:[000]->1 | 16:[001]->1 Step 6 Output: 00000110000011111 Step 7 Scan: 0:[100]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[001]->1 | 5:[011]->0 | 6:[110]->0 | 7:[100]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[001]->1 | 12:[011]->0 | 13:[111]->0 | 14:[111]->0 | 15:[111]->0 | 16:[110]->0 Step 7 Output: 11111001111100000 Step 8 Scan: 0:[011]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[110]->0 | 5:[100]->1 | 6:[001]->1 | 7:[011]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[110]->0 | 12:[100]->1 | 13:[000]->1 | 14:[000]->1 | 15:[000]->1 | 16:[001]->1 Step 8 Output: 00000110000011111 Step 9 Scan: 0:[100]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[001]->1 | 5:[011]->0 | 6:[110]->0 | 7:[100]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[001]->1 | 12:[011]->0 | 13:[111]->0 | 14:[111]->0 | 15:[111]->0 | 16:[110]->0 Step 9 Output: 11111001111100000 Step 10 Scan: 0:[011]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[110]->0 | 5:[100]->1 | 6:[001]->1 | 7:[011]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[110]->0 | 12:[100]->1 | 13:[000]->1 | 14:[000]->1 | 15:[000]->1 | 16:[001]->1 Step 10 Output: 00000110000011111
00000110000011111
deduction
Task: Deduction, Rule: 108 [111->0, 110->1, 101->1, 100->0, 011->1, 010->1, 001->0, 000->0], Steps: 11, Start: 00001001100100100000
Step 1 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[001]->0 | 4:[010]->1 | 5:[100]->0 | 6:[001]->0 | 7:[011]->1 | 8:[110]->1 | 9:[100]->0 | 10:[001]->0 | 11:[010]->1 | 12:[100]->0 | 13:[001]->0 | 14:[010]->1 | 15:[100]->0 | 16:[000]->0 | 17:[000]->0 | 18:[000]->0 | 19:[000]->0 Step 1 Output: 00001001100100100000 Step 2 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[001]->0 | 4:[010]->1 | 5:[100]->0 | 6:[001]->0 | 7:[011]->1 | 8:[110]->1 | 9:[100]->0 | 10:[001]->0 | 11:[010]->1 | 12:[100]->0 | 13:[001]->0 | 14:[010]->1 | 15:[100]->0 | 16:[000]->0 | 17:[000]->0 | 18:[000]->0 | 19:[000]->0 Step 2 Output: 00001001100100100000 Step 3 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[001]->0 | 4:[010]->1 | 5:[100]->0 | 6:[001]->0 | 7:[011]->1 | 8:[110]->1 | 9:[100]->0 | 10:[001]->0 | 11:[010]->1 | 12:[100]->0 | 13:[001]->0 | 14:[010]->1 | 15:[100]->0 | 16:[000]->0 | 17:[000]->0 | 18:[000]->0 | 19:[000]->0 Step 3 Output: 00001001100100100000 Step 4 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[001]->0 | 4:[010]->1 | 5:[100]->0 | 6:[001]->0 | 7:[011]->1 | 8:[110]->1 | 9:[100]->0 | 10:[001]->0 | 11:[010]->1 | 12:[100]->0 | 13:[001]->0 | 14:[010]->1 | 15:[100]->0 | 16:[000]->0 | 17:[000]->0 | 18:[000]->0 | 19:[000]->0 Step 4 Output: 00001001100100100000 Step 5 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[001]->0 | 4:[010]->1 | 5:[100]->0 | 6:[001]->0 | 7:[011]->1 | 8:[110]->1 | 9:[100]->0 | 10:[001]->0 | 11:[010]->1 | 12:[100]->0 | 13:[001]->0 | 14:[010]->1 | 15:[100]->0 | 16:[000]->0 | 17:[000]->0 | 18:[000]->0 | 19:[000]->0 Step 5 Output: 00001001100100100000 Step 6 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[001]->0 | 4:[010]->1 | 5:[100]->0 | 6:[001]->0 | 7:[011]->1 | 8:[110]->1 | 9:[100]->0 | 10:[001]->0 | 11:[010]->1 | 12:[100]->0 | 13:[001]->0 | 14:[010]->1 | 15:[100]->0 | 16:[000]->0 | 17:[000]->0 | 18:[000]->0 | 19:[000]->0 Step 6 Output: 00001001100100100000 Step 7 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[001]->0 | 4:[010]->1 | 5:[100]->0 | 6:[001]->0 | 7:[011]->1 | 8:[110]->1 | 9:[100]->0 | 10:[001]->0 | 11:[010]->1 | 12:[100]->0 | 13:[001]->0 | 14:[010]->1 | 15:[100]->0 | 16:[000]->0 | 17:[000]->0 | 18:[000]->0 | 19:[000]->0 Step 7 Output: 00001001100100100000 Step 8 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[001]->0 | 4:[010]->1 | 5:[100]->0 | 6:[001]->0 | 7:[011]->1 | 8:[110]->1 | 9:[100]->0 | 10:[001]->0 | 11:[010]->1 | 12:[100]->0 | 13:[001]->0 | 14:[010]->1 | 15:[100]->0 | 16:[000]->0 | 17:[000]->0 | 18:[000]->0 | 19:[000]->0 Step 8 Output: 00001001100100100000 Step 9 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[001]->0 | 4:[010]->1 | 5:[100]->0 | 6:[001]->0 | 7:[011]->1 | 8:[110]->1 | 9:[100]->0 | 10:[001]->0 | 11:[010]->1 | 12:[100]->0 | 13:[001]->0 | 14:[010]->1 | 15:[100]->0 | 16:[000]->0 | 17:[000]->0 | 18:[000]->0 | 19:[000]->0 Step 9 Output: 00001001100100100000 Step 10 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[001]->0 | 4:[010]->1 | 5:[100]->0 | 6:[001]->0 | 7:[011]->1 | 8:[110]->1 | 9:[100]->0 | 10:[001]->0 | 11:[010]->1 | 12:[100]->0 | 13:[001]->0 | 14:[010]->1 | 15:[100]->0 | 16:[000]->0 | 17:[000]->0 | 18:[000]->0 | 19:[000]->0 Step 10 Output: 00001001100100100000 Step 11 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[001]->0 | 4:[010]->1 | 5:[100]->0 | 6:[001]->0 | 7:[011]->1 | 8:[110]->1 | 9:[100]->0 | 10:[001]->0 | 11:[010]->1 | 12:[100]->0 | 13:[001]->0 | 14:[010]->1 | 15:[100]->0 | 16:[000]->0 | 17:[000]->0 | 18:[000]->0 | 19:[000]->0 Step 11 Output: 00001001100100100000
00001001100100100000
deduction
Task: Deduction, Rule: 106 [111->0, 110->1, 101->1, 100->0, 011->1, 010->0, 001->1, 000->0], Steps: 12, Start: 110010100011
Step 1 Scan: 0:[111]->0 | 1:[110]->1 | 2:[100]->0 | 3:[001]->1 | 4:[010]->0 | 5:[101]->1 | 6:[010]->0 | 7:[100]->0 | 8:[000]->0 | 9:[001]->1 | 10:[011]->1 | 11:[111]->0 Step 1 Output: 010101000110 Step 2 Scan: 0:[001]->1 | 1:[010]->0 | 2:[101]->1 | 3:[010]->0 | 4:[101]->1 | 5:[010]->0 | 6:[100]->0 | 7:[000]->0 | 8:[001]->1 | 9:[011]->1 | 10:[110]->1 | 11:[100]->0 Step 2 Output: 101010001110 Step 3 Scan: 0:[010]->0 | 1:[101]->1 | 2:[010]->0 | 3:[101]->1 | 4:[010]->0 | 5:[100]->0 | 6:[000]->0 | 7:[001]->1 | 8:[011]->1 | 9:[111]->0 | 10:[110]->1 | 11:[101]->1 Step 3 Output: 010100011011 Step 4 Scan: 0:[101]->1 | 1:[010]->0 | 2:[101]->1 | 3:[010]->0 | 4:[100]->0 | 5:[000]->0 | 6:[001]->1 | 7:[011]->1 | 8:[110]->1 | 9:[101]->1 | 10:[011]->1 | 11:[110]->1 Step 4 Output: 101000111111 Step 5 Scan: 0:[110]->1 | 1:[101]->1 | 2:[010]->0 | 3:[100]->0 | 4:[000]->0 | 5:[001]->1 | 6:[011]->1 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 Step 5 Output: 110001100000 Step 6 Scan: 0:[011]->1 | 1:[110]->1 | 2:[100]->0 | 3:[000]->0 | 4:[001]->1 | 5:[011]->1 | 6:[110]->1 | 7:[100]->0 | 8:[000]->0 | 9:[000]->0 | 10:[000]->0 | 11:[001]->1 Step 6 Output: 110011100001 Step 7 Scan: 0:[111]->0 | 1:[110]->1 | 2:[100]->0 | 3:[001]->1 | 4:[011]->1 | 5:[111]->0 | 6:[110]->1 | 7:[100]->0 | 8:[000]->0 | 9:[000]->0 | 10:[001]->1 | 11:[011]->1 Step 7 Output: 010110100011 Step 8 Scan: 0:[101]->1 | 1:[010]->0 | 2:[101]->1 | 3:[011]->1 | 4:[110]->1 | 5:[101]->1 | 6:[010]->0 | 7:[100]->0 | 8:[000]->0 | 9:[001]->1 | 10:[011]->1 | 11:[110]->1 Step 8 Output: 101111000111 Step 9 Scan: 0:[110]->1 | 1:[101]->1 | 2:[011]->1 | 3:[111]->0 | 4:[111]->0 | 5:[110]->1 | 6:[100]->0 | 7:[000]->0 | 8:[001]->1 | 9:[011]->1 | 10:[111]->0 | 11:[111]->0 Step 9 Output: 111001001100 Step 10 Scan: 0:[011]->1 | 1:[111]->0 | 2:[110]->1 | 3:[100]->0 | 4:[001]->1 | 5:[010]->0 | 6:[100]->0 | 7:[001]->1 | 8:[011]->1 | 9:[110]->1 | 10:[100]->0 | 11:[001]->1 Step 10 Output: 101010011101 Step 11 Scan: 0:[110]->1 | 1:[101]->1 | 2:[010]->0 | 3:[101]->1 | 4:[010]->0 | 5:[100]->0 | 6:[001]->1 | 7:[011]->1 | 8:[111]->0 | 9:[110]->1 | 10:[101]->1 | 11:[011]->1 Step 11 Output: 110100110111 Step 12 Scan: 0:[111]->0 | 1:[110]->1 | 2:[101]->1 | 3:[010]->0 | 4:[100]->0 | 5:[001]->1 | 6:[011]->1 | 7:[110]->1 | 8:[101]->1 | 9:[011]->1 | 10:[111]->0 | 11:[111]->0 Step 12 Output: 011001111100
011001111100
abduction
Task: Abduction, Rule: 60 [111->0, 110->0, 101->1, 100->1, 011->1, 010->1, 001->0, 000->0], Steps: 1, End: 110111000001
Goal: Reverse 1 steps by calculating likelihoods of priors. Step -1: Inverting state 110111000001 Calculating Local Priors: Idx 0 requires neighborhood in ['010', '011', '100', '101'] Idx 1 requires neighborhood in ['010', '011', '100', '101'] Idx 2 requires neighborhood in ['000', '001', '110', '111'] Idx 3 requires neighborhood in ['010', '011', '100', '101'] Idx 4 requires neighborhood in ['010', '011', '100', '101'] Idx 5 requires neighborhood in ['010', '011', '100', '101'] Idx 6 requires neighborhood in ['000', '001', '110', '111'] Idx 7 requires neighborhood in ['000', '001', '110', '111'] Idx 8 requires neighborhood in ['000', '001', '110', '111'] Idx 9 requires neighborhood in ['000', '001', '110', '111'] Idx 10 requires neighborhood in ['000', '001', '110', '111'] Idx 11 requires neighborhood in ['010', '011', '100', '101'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% Greedy Candidate: 111111111111 Verification: Mismatch. Correction applied -> 011010000001
011010000001
deduction
Task: Deduction, Rule: 90 [111->0, 110->1, 101->0, 100->1, 011->1, 010->0, 001->1, 000->0], Steps: 12, Start: 1000110110010
Step 1 Scan: 0:[010]->0 | 1:[100]->1 | 2:[000]->0 | 3:[001]->1 | 4:[011]->1 | 5:[110]->1 | 6:[101]->0 | 7:[011]->1 | 8:[110]->1 | 9:[100]->1 | 10:[001]->1 | 11:[010]->0 | 12:[101]->0 Step 1 Output: 0101110111100 Step 2 Scan: 0:[001]->1 | 1:[010]->0 | 2:[101]->0 | 3:[011]->1 | 4:[111]->0 | 5:[110]->1 | 6:[101]->0 | 7:[011]->1 | 8:[111]->0 | 9:[111]->0 | 10:[110]->1 | 11:[100]->1 | 12:[000]->0 Step 2 Output: 1001010100110 Step 3 Scan: 0:[010]->0 | 1:[100]->1 | 2:[001]->1 | 3:[010]->0 | 4:[101]->0 | 5:[010]->0 | 6:[101]->0 | 7:[010]->0 | 8:[100]->1 | 9:[001]->1 | 10:[011]->1 | 11:[110]->1 | 12:[101]->0 Step 3 Output: 0110000011110 Step 4 Scan: 0:[001]->1 | 1:[011]->1 | 2:[110]->1 | 3:[100]->1 | 4:[000]->0 | 5:[000]->0 | 6:[000]->0 | 7:[001]->1 | 8:[011]->1 | 9:[111]->0 | 10:[111]->0 | 11:[110]->1 | 12:[100]->1 Step 4 Output: 1111000110011 Step 5 Scan: 0:[111]->0 | 1:[111]->0 | 2:[111]->0 | 3:[110]->1 | 4:[100]->1 | 5:[000]->0 | 6:[001]->1 | 7:[011]->1 | 8:[110]->1 | 9:[100]->1 | 10:[001]->1 | 11:[011]->1 | 12:[111]->0 Step 5 Output: 0001101111110 Step 6 Scan: 0:[000]->0 | 1:[000]->0 | 2:[001]->1 | 3:[011]->1 | 4:[110]->1 | 5:[101]->0 | 6:[011]->1 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[110]->1 | 12:[100]->1 Step 6 Output: 0011101000011 Step 7 Scan: 0:[100]->1 | 1:[001]->1 | 2:[011]->1 | 3:[111]->0 | 4:[110]->1 | 5:[101]->0 | 6:[010]->0 | 7:[100]->1 | 8:[000]->0 | 9:[000]->0 | 10:[001]->1 | 11:[011]->1 | 12:[110]->1 Step 7 Output: 1110100100111 Step 8 Scan: 0:[111]->0 | 1:[111]->0 | 2:[110]->1 | 3:[101]->0 | 4:[010]->0 | 5:[100]->1 | 6:[001]->1 | 7:[010]->0 | 8:[100]->1 | 9:[001]->1 | 10:[011]->1 | 11:[111]->0 | 12:[111]->0 Step 8 Output: 0010011011100 Step 9 Scan: 0:[000]->0 | 1:[001]->1 | 2:[010]->0 | 3:[100]->1 | 4:[001]->1 | 5:[011]->1 | 6:[110]->1 | 7:[101]->0 | 8:[011]->1 | 9:[111]->0 | 10:[110]->1 | 11:[100]->1 | 12:[000]->0 Step 9 Output: 0101111010110 Step 10 Scan: 0:[001]->1 | 1:[010]->0 | 2:[101]->0 | 3:[011]->1 | 4:[111]->0 | 5:[111]->0 | 6:[110]->1 | 7:[101]->0 | 8:[010]->0 | 9:[101]->0 | 10:[011]->1 | 11:[110]->1 | 12:[100]->1 Step 10 Output: 1001001000111 Step 11 Scan: 0:[110]->1 | 1:[100]->1 | 2:[001]->1 | 3:[010]->0 | 4:[100]->1 | 5:[001]->1 | 6:[010]->0 | 7:[100]->1 | 8:[000]->0 | 9:[001]->1 | 10:[011]->1 | 11:[111]->0 | 12:[111]->0 Step 11 Output: 1110110101100 Step 12 Scan: 0:[011]->1 | 1:[111]->0 | 2:[110]->1 | 3:[101]->0 | 4:[011]->1 | 5:[110]->1 | 6:[101]->0 | 7:[010]->0 | 8:[101]->0 | 9:[011]->1 | 10:[110]->1 | 11:[100]->1 | 12:[001]->1 Step 12 Output: 1010110001111
1010110001111
abduction
Task: Abduction, Rule: 110 [111->0, 110->1, 101->1, 100->0, 011->1, 010->1, 001->1, 000->0], Steps: 2, End: 11111110111000011
Goal: Reverse 2 steps by calculating likelihoods of priors. Step -1: Inverting state 11111110111000011 Calculating Local Priors: Idx 0 requires neighborhood in ['001', '010', '011', '101', '110'] Idx 1 requires neighborhood in ['001', '010', '011', '101', '110'] Idx 2 requires neighborhood in ['001', '010', '011', '101', '110'] Idx 3 requires neighborhood in ['001', '010', '011', '101', '110'] Idx 4 requires neighborhood in ['001', '010', '011', '101', '110'] Idx 5 requires neighborhood in ['001', '010', '011', '101', '110'] Idx 6 requires neighborhood in ['001', '010', '011', '101', '110'] Idx 7 requires neighborhood in ['000', '100', '111'] Idx 8 requires neighborhood in ['001', '010', '011', '101', '110'] Idx 9 requires neighborhood in ['001', '010', '011', '101', '110'] Idx 10 requires neighborhood in ['001', '010', '011', '101', '110'] Idx 11 requires neighborhood in ['000', '100', '111'] Idx 12 requires neighborhood in ['000', '100', '111'] Idx 13 requires neighborhood in ['000', '100', '111'] Idx 14 requires neighborhood in ['000', '100', '111'] Idx 15 requires neighborhood in ['001', '010', '011', '101', '110'] Idx 16 requires neighborhood in ['001', '010', '011', '101', '110'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:53% | 1:53% | 2:53% | 3:53% | 4:53% | 5:53% | 6:61% | 7:46% | 8:46% | 9:53% | 10:61% | 11:54% | 12:44% | 13:44% | 14:36% | 15:46% | 16:53% Greedy Candidate: 11111110011100001 Verification: Mismatch. Correction applied -> 10110110011000001 Step -2: Inverting state 10110110011000001 Calculating Local Priors: Idx 0 requires neighborhood in ['001', '010', '011', '101', '110'] Idx 1 requires neighborhood in ['000', '100', '111'] Idx 2 requires neighborhood in ['001', '010', '011', '101', '110'] Idx 3 requires neighborhood in ['001', '010', '011', '101', '110'] Idx 4 requires neighborhood in ['000', '100', '111'] Idx 5 requires neighborhood in ['001', '010', '011', '101', '110'] Idx 6 requires neighborhood in ['001', '010', '011', '101', '110'] Idx 7 requires neighborhood in ['000', '100', '111'] Idx 8 requires neighborhood in ['000', '100', '111'] Idx 9 requires neighborhood in ['001', '010', '011', '101', '110'] Idx 10 requires neighborhood in ['001', '010', '011', '101', '110'] Idx 11 requires neighborhood in ['000', '100', '111'] Idx 12 requires neighborhood in ['000', '100', '111'] Idx 13 requires neighborhood in ['000', '100', '111'] Idx 14 requires neighborhood in ['000', '100', '111'] Idx 15 requires neighborhood in ['000', '100', '111'] Idx 16 requires neighborhood in ['001', '010', '011', '101', '110'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:61% | 1:46% | 2:46% | 3:61% | 4:46% | 5:46% | 6:61% | 7:54% | 8:36% | 9:46% | 10:61% | 11:54% | 12:44% | 13:44% | 14:44% | 15:36% | 16:46% Greedy Candidate: 10010011001100000 Verification: Mismatch. Correction applied -> 10010010001000000
10010010001000000
deduction
Task: Deduction, Rule: 193 [111->1, 110->1, 101->0, 100->0, 011->0, 010->0, 001->0, 000->1], Steps: 12, Start: 111000010100
Step 1 Scan: 0:[011]->0 | 1:[111]->1 | 2:[110]->1 | 3:[100]->0 | 4:[000]->1 | 5:[000]->1 | 6:[001]->0 | 7:[010]->0 | 8:[101]->0 | 9:[010]->0 | 10:[100]->0 | 11:[001]->0 Step 1 Output: 011011000000 Step 2 Scan: 0:[001]->0 | 1:[011]->0 | 2:[110]->1 | 3:[101]->0 | 4:[011]->0 | 5:[110]->1 | 6:[100]->0 | 7:[000]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[000]->1 Step 2 Output: 001001011111 Step 3 Scan: 0:[100]->0 | 1:[001]->0 | 2:[010]->0 | 3:[100]->0 | 4:[001]->0 | 5:[010]->0 | 6:[101]->0 | 7:[011]->0 | 8:[111]->1 | 9:[111]->1 | 10:[111]->1 | 11:[110]->1 Step 3 Output: 000000001111 Step 4 Scan: 0:[100]->0 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[000]->1 | 5:[000]->1 | 6:[000]->1 | 7:[001]->0 | 8:[011]->0 | 9:[111]->1 | 10:[111]->1 | 11:[110]->1 Step 4 Output: 011111100111 Step 5 Scan: 0:[101]->0 | 1:[011]->0 | 2:[111]->1 | 3:[111]->1 | 4:[111]->1 | 5:[111]->1 | 6:[110]->1 | 7:[100]->0 | 8:[001]->0 | 9:[011]->0 | 10:[111]->1 | 11:[110]->1 Step 5 Output: 001111100011 Step 6 Scan: 0:[100]->0 | 1:[001]->0 | 2:[011]->0 | 3:[111]->1 | 4:[111]->1 | 5:[111]->1 | 6:[110]->1 | 7:[100]->0 | 8:[000]->1 | 9:[001]->0 | 10:[011]->0 | 11:[110]->1 Step 6 Output: 000111101001 Step 7 Scan: 0:[100]->0 | 1:[000]->1 | 2:[001]->0 | 3:[011]->0 | 4:[111]->1 | 5:[111]->1 | 6:[110]->1 | 7:[101]->0 | 8:[010]->0 | 9:[100]->0 | 10:[001]->0 | 11:[010]->0 Step 7 Output: 010011100000 Step 8 Scan: 0:[001]->0 | 1:[010]->0 | 2:[100]->0 | 3:[001]->0 | 4:[011]->0 | 5:[111]->1 | 6:[110]->1 | 7:[100]->0 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[000]->1 Step 8 Output: 000001101111 Step 9 Scan: 0:[100]->0 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[001]->0 | 5:[011]->0 | 6:[110]->1 | 7:[101]->0 | 8:[011]->0 | 9:[111]->1 | 10:[111]->1 | 11:[110]->1 Step 9 Output: 011100100111 Step 10 Scan: 0:[101]->0 | 1:[011]->0 | 2:[111]->1 | 3:[110]->1 | 4:[100]->0 | 5:[001]->0 | 6:[010]->0 | 7:[100]->0 | 8:[001]->0 | 9:[011]->0 | 10:[111]->1 | 11:[110]->1 Step 10 Output: 001100000011 Step 11 Scan: 0:[100]->0 | 1:[001]->0 | 2:[011]->0 | 3:[110]->1 | 4:[100]->0 | 5:[000]->1 | 6:[000]->1 | 7:[000]->1 | 8:[000]->1 | 9:[001]->0 | 10:[011]->0 | 11:[110]->1 Step 11 Output: 000101111001 Step 12 Scan: 0:[100]->0 | 1:[000]->1 | 2:[001]->0 | 3:[010]->0 | 4:[101]->0 | 5:[011]->0 | 6:[111]->1 | 7:[111]->1 | 8:[110]->1 | 9:[100]->0 | 10:[001]->0 | 11:[010]->0 Step 12 Output: 010000111000
010000111000
abduction
Task: Abduction, Rule: 106 [111->0, 110->1, 101->1, 100->0, 011->1, 010->0, 001->1, 000->0], Steps: 3, End: 110111011000
Goal: Reverse 3 steps by calculating likelihoods of priors. Step -1: Inverting state 110111011000 Calculating Local Priors: Idx 0 requires neighborhood in ['001', '011', '101', '110'] Idx 1 requires neighborhood in ['001', '011', '101', '110'] Idx 2 requires neighborhood in ['000', '010', '100', '111'] Idx 3 requires neighborhood in ['001', '011', '101', '110'] Idx 4 requires neighborhood in ['001', '011', '101', '110'] Idx 5 requires neighborhood in ['001', '011', '101', '110'] Idx 6 requires neighborhood in ['000', '010', '100', '111'] Idx 7 requires neighborhood in ['001', '011', '101', '110'] Idx 8 requires neighborhood in ['001', '011', '101', '110'] Idx 9 requires neighborhood in ['000', '010', '100', '111'] Idx 10 requires neighborhood in ['000', '010', '100', '111'] Idx 11 requires neighborhood in ['000', '010', '100', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:41% | 1:58% | 2:58% | 3:41% | 4:58% | 5:58% | 6:58% | 7:41% | 8:58% | 9:58% | 10:41% | 11:41% Greedy Candidate: 011011101100 Verification: Mismatch. Correction applied -> 101011001111 Step -2: Inverting state 101011001111 Calculating Local Priors: Idx 0 requires neighborhood in ['001', '011', '101', '110'] Idx 1 requires neighborhood in ['000', '010', '100', '111'] Idx 2 requires neighborhood in ['001', '011', '101', '110'] Idx 3 requires neighborhood in ['000', '010', '100', '111'] Idx 4 requires neighborhood in ['001', '011', '101', '110'] Idx 5 requires neighborhood in ['001', '011', '101', '110'] Idx 6 requires neighborhood in ['000', '010', '100', '111'] Idx 7 requires neighborhood in ['000', '010', '100', '111'] Idx 8 requires neighborhood in ['001', '011', '101', '110'] Idx 9 requires neighborhood in ['001', '011', '101', '110'] Idx 10 requires neighborhood in ['001', '011', '101', '110'] Idx 11 requires neighborhood in ['001', '011', '101', '110'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:58% | 1:58% | 2:41% | 3:58% | 4:41% | 5:58% | 6:58% | 7:41% | 8:41% | 9:58% | 10:58% | 11:58% Greedy Candidate: 110101100111 Verification: Mismatch. Correction applied -> 010101111011 Step -3: Inverting state 010101111011 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '010', '100', '111'] Idx 1 requires neighborhood in ['001', '011', '101', '110'] Idx 2 requires neighborhood in ['000', '010', '100', '111'] Idx 3 requires neighborhood in ['001', '011', '101', '110'] Idx 4 requires neighborhood in ['000', '010', '100', '111'] Idx 5 requires neighborhood in ['001', '011', '101', '110'] Idx 6 requires neighborhood in ['001', '011', '101', '110'] Idx 7 requires neighborhood in ['001', '011', '101', '110'] Idx 8 requires neighborhood in ['001', '011', '101', '110'] Idx 9 requires neighborhood in ['000', '010', '100', '111'] Idx 10 requires neighborhood in ['001', '011', '101', '110'] Idx 11 requires neighborhood in ['001', '011', '101', '110'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:58% | 1:41% | 2:58% | 3:41% | 4:58% | 5:41% | 6:58% | 7:58% | 8:58% | 9:58% | 10:41% | 11:58% Greedy Candidate: 101010111101 Verification: Mismatch. Correction applied -> 110010110101
110010110101
abduction
Task: Abduction, Rule: 105 [111->0, 110->1, 101->1, 100->0, 011->1, 010->0, 001->0, 000->1], Steps: 1, End: 001000100010
Goal: Reverse 1 steps by calculating likelihoods of priors. Step -1: Inverting state 001000100010 Calculating Local Priors: Idx 0 requires neighborhood in ['001', '010', '100', '111'] Idx 1 requires neighborhood in ['001', '010', '100', '111'] Idx 2 requires neighborhood in ['000', '011', '101', '110'] Idx 3 requires neighborhood in ['001', '010', '100', '111'] Idx 4 requires neighborhood in ['001', '010', '100', '111'] Idx 5 requires neighborhood in ['001', '010', '100', '111'] Idx 6 requires neighborhood in ['000', '011', '101', '110'] Idx 7 requires neighborhood in ['001', '010', '100', '111'] Idx 8 requires neighborhood in ['001', '010', '100', '111'] Idx 9 requires neighborhood in ['001', '010', '100', '111'] Idx 10 requires neighborhood in ['000', '011', '101', '110'] Idx 11 requires neighborhood in ['001', '010', '100', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% Greedy Candidate: 111111111111 Verification: Mismatch. Correction applied -> 001111100101
001111100101
induction
Task: Induction, Start: 000000001111101, End: 111111101000001, Steps: 13, Hint: Class 2
Task: Find rule in Class 2. Candidates: [108, 50, 1, 19, 29, 37, 23, 178] Attempt 1: Testing Rule 108 [111->0, 110->1, 101->1, 100->0, 011->1, 010->1, 001->0, 000->0] Sim Step 1: 000000001000111 Sim Step 2: 000000001000101 Sim Step 3: 000000001000111 Sim Step 4: 000000001000101 Sim Step 5: 000000001000111 Sim Step 6: 000000001000101 Sim Step 7: 000000001000111 Sim Step 8: 000000001000101 Sim Step 9: 000000001000111 Sim Step 10: 000000001000101 Sim Step 11: 000000001000111 Sim Step 12: 000000001000101 Sim Step 13: 000000001000111 Verification: Mismatch (Expected 111111101000001). Next... Attempt 2: Testing Rule 50 [111->0, 110->0, 101->1, 100->1, 011->0, 010->0, 001->1, 000->0] Sim Step 1: 100000010000010 Sim Step 2: 010000101000101 Sim Step 3: 101001010101010 Sim Step 4: 010110101010101 Sim Step 5: 101001010101010 Sim Step 6: 010110101010101 Sim Step 7: 101001010101010 Sim Step 8: 010110101010101 Sim Step 9: 101001010101010 Sim Step 10: 010110101010101 Sim Step 11: 101001010101010 Sim Step 12: 010110101010101 Sim Step 13: 101001010101010 Verification: Mismatch (Expected 111111101000001). Next... Attempt 3: Testing Rule 1 [111->0, 110->0, 101->0, 100->0, 011->0, 010->0, 001->0, 000->1] Sim Step 1: 011111100000000 Sim Step 2: 000000001111111 Sim Step 3: 011111100000000 Sim Step 4: 000000001111111 Sim Step 5: 011111100000000 Sim Step 6: 000000001111111 Sim Step 7: 011111100000000 Sim Step 8: 000000001111111 Sim Step 9: 011111100000000 Sim Step 10: 000000001111111 Sim Step 11: 011111100000000 Sim Step 12: 000000001111111 Sim Step 13: 011111100000000 Verification: Mismatch (Expected 111111101000001). Next... Attempt 4: Testing Rule 19 [111->0, 110->0, 101->0, 100->1, 011->0, 010->0, 001->1, 000->1] Sim Step 1: 111111110000000 Sim Step 2: 000000001111111 Sim Step 3: 111111110000000 Sim Step 4: 000000001111111 Sim Step 5: 111111110000000 Sim Step 6: 000000001111111 Sim Step 7: 111111110000000 Sim Step 8: 000000001111111 Sim Step 9: 111111110000000 Sim Step 10: 000000001111111 Sim Step 11: 111111110000000 Sim Step 12: 000000001111111 Sim Step 13: 111111110000000 Verification: Mismatch (Expected 111111101000001). Next... Attempt 5: Testing Rule 29 [111->0, 110->0, 101->0, 100->1, 011->1, 010->1, 001->0, 000->1] Sim Step 1: 111111101000001 Sim Step 2: 000000001111101 Sim Step 3: 111111101000001 Sim Step 4: 000000001111101 Sim Step 5: 111111101000001 Sim Step 6: 000000001111101 Sim Step 7: 111111101000001 Sim Step 8: 000000001111101 Sim Step 9: 111111101000001 Sim Step 10: 000000001111101 Sim Step 11: 111111101000001 Sim Step 12: 000000001111101 Sim Step 13: 111111101000001 Verification: Exact Match. Rule Confirmed.
111->0, 110->0, 101->0, 100->1, 011->1, 010->1, 001->0, 000->1
abduction
Task: Abduction, Rule: 126 [111->0, 110->1, 101->1, 100->1, 011->1, 010->1, 001->1, 000->0], Steps: 2, End: 000011111100
Goal: Reverse 2 steps by calculating likelihoods of priors. Step -1: Inverting state 000011111100 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '111'] Idx 1 requires neighborhood in ['000', '111'] Idx 2 requires neighborhood in ['000', '111'] Idx 3 requires neighborhood in ['000', '111'] Idx 4 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 5 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 6 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 7 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 8 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 9 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 10 requires neighborhood in ['000', '111'] Idx 11 requires neighborhood in ['000', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% Greedy Candidate: 111111111111 Verification: Mismatch. Correction applied -> 111110110111 Step -2: Inverting state 111110110111 Calculating Local Priors: Idx 0 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 1 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 2 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 3 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 4 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 5 requires neighborhood in ['000', '111'] Idx 6 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 7 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 8 requires neighborhood in ['000', '111'] Idx 9 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 10 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Idx 11 requires neighborhood in ['001', '010', '011', '100', '101', '110'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% Greedy Candidate: 111111111111 Verification: Mismatch. Correction applied -> 010011100010
010011100010
induction
Task: Induction, Start: 10101001000100101, End: 00101101110110101, Steps: 13, Hint: Class 2
Task: Find rule in Class 2. Candidates: [1, 50, 37, 23, 178, 108, 29, 19] Attempt 1: Testing Rule 1 [111->0, 110->0, 101->0, 100->0, 011->0, 010->0, 001->0, 000->1] Sim Step 1: 00000000010000000 Sim Step 2: 11111111000111111 Sim Step 3: 00000000010000000 Sim Step 4: 11111111000111111 Sim Step 5: 00000000010000000 Sim Step 6: 11111111000111111 Sim Step 7: 00000000010000000 Sim Step 8: 11111111000111111 Sim Step 9: 00000000010000000 Sim Step 10: 11111111000111111 Sim Step 11: 00000000010000000 Sim Step 12: 11111111000111111 Sim Step 13: 00000000010000000 Verification: Mismatch (Expected 00101101110110101). Next... Attempt 2: Testing Rule 50 [111->0, 110->0, 101->1, 100->1, 011->0, 010->0, 001->1, 000->0] Sim Step 1: 01010110101011010 Sim Step 2: 10101001010100101 Sim Step 3: 01010110101011010 Sim Step 4: 10101001010100101 Sim Step 5: 01010110101011010 Sim Step 6: 10101001010100101 Sim Step 7: 01010110101011010 Sim Step 8: 10101001010100101 Sim Step 9: 01010110101011010 Sim Step 10: 10101001010100101 Sim Step 11: 01010110101011010 Sim Step 12: 10101001010100101 Sim Step 13: 01010110101011010 Verification: Mismatch (Expected 00101101110110101). Next... Attempt 3: Testing Rule 37 [111->0, 110->0, 101->1, 100->0, 011->0, 010->1, 001->0, 000->1] Sim Step 1: 01111001010100110 Sim Step 2: 00000001111100000 Sim Step 3: 11111100000001111 Sim Step 4: 00000001111100000 Sim Step 5: 11111100000001111 Sim Step 6: 00000001111100000 Sim Step 7: 11111100000001111 Sim Step 8: 00000001111100000 Sim Step 9: 11111100000001111 Sim Step 10: 00000001111100000 Sim Step 11: 11111100000001111 Sim Step 12: 00000001111100000 Sim Step 13: 11111100000001111 Verification: Mismatch (Expected 00101101110110101). Next... Attempt 4: Testing Rule 23 [111->0, 110->0, 101->0, 100->1, 011->0, 010->1, 001->1, 000->1] Sim Step 1: 00101111111111100 Sim Step 2: 11100000000000011 Sim Step 3: 00011111111111100 Sim Step 4: 11100000000000011 Sim Step 5: 00011111111111100 Sim Step 6: 11100000000000011 Sim Step 7: 00011111111111100 Sim Step 8: 11100000000000011 Sim Step 9: 00011111111111100 Sim Step 10: 11100000000000011 Sim Step 11: 00011111111111100 Sim Step 12: 11100000000000011 Sim Step 13: 00011111111111100 Verification: Mismatch (Expected 00101101110110101). Next... Attempt 5: Testing Rule 178 [111->1, 110->0, 101->1, 100->1, 011->0, 010->0, 001->1, 000->0] Sim Step 1: 01010110101011010 Sim Step 2: 10101001010100101 Sim Step 3: 01010110101011010 Sim Step 4: 10101001010100101 Sim Step 5: 01010110101011010 Sim Step 6: 10101001010100101 Sim Step 7: 01010110101011010 Sim Step 8: 10101001010100101 Sim Step 9: 01010110101011010 Sim Step 10: 10101001010100101 Sim Step 11: 01010110101011010 Sim Step 12: 10101001010100101 Sim Step 13: 01010110101011010 Verification: Mismatch (Expected 00101101110110101). Next... Attempt 6: Testing Rule 108 [111->0, 110->1, 101->1, 100->0, 011->1, 010->1, 001->0, 000->0] Sim Step 1: 11111001000100111 Sim Step 2: 00001001000100100 Sim Step 3: 00001001000100100 Sim Step 4: 00001001000100100 Sim Step 5: 00001001000100100 Sim Step 6: 00001001000100100 Sim Step 7: 00001001000100100 Sim Step 8: 00001001000100100 Sim Step 9: 00001001000100100 Sim Step 10: 00001001000100100 Sim Step 11: 00001001000100100 Sim Step 12: 00001001000100100 Sim Step 13: 00001001000100100 Verification: Mismatch (Expected 00101101110110101). Next... Attempt 7: Testing Rule 29 [111->0, 110->0, 101->0, 100->1, 011->1, 010->1, 001->0, 000->1] Sim Step 1: 00101101110110101 Sim Step 2: 10101001000100101 Sim Step 3: 00101101110110101 Sim Step 4: 10101001000100101 Sim Step 5: 00101101110110101 Sim Step 6: 10101001000100101 Sim Step 7: 00101101110110101 Sim Step 8: 10101001000100101 Sim Step 9: 00101101110110101 Sim Step 10: 10101001000100101 Sim Step 11: 00101101110110101 Sim Step 12: 10101001000100101 Sim Step 13: 00101101110110101 Verification: Exact Match. Rule Confirmed.
111->0, 110->0, 101->0, 100->1, 011->1, 010->1, 001->0, 000->1
deduction
Task: Deduction, Rule: 23 [111->0, 110->0, 101->0, 100->1, 011->0, 010->1, 001->1, 000->1], Steps: 13, Start: 0111001111100100011
Step 1 Scan: 0:[101]->0 | 1:[011]->0 | 2:[111]->0 | 3:[110]->0 | 4:[100]->1 | 5:[001]->1 | 6:[011]->0 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[110]->0 | 11:[100]->1 | 12:[001]->1 | 13:[010]->1 | 14:[100]->1 | 15:[000]->1 | 16:[001]->1 | 17:[011]->0 | 18:[110]->0 Step 1 Output: 0000110000011111100 Step 2 Scan: 0:[000]->1 | 1:[000]->1 | 2:[000]->1 | 3:[001]->1 | 4:[011]->0 | 5:[110]->0 | 6:[100]->1 | 7:[000]->1 | 8:[000]->1 | 9:[000]->1 | 10:[001]->1 | 11:[011]->0 | 12:[111]->0 | 13:[111]->0 | 14:[111]->0 | 15:[111]->0 | 16:[110]->0 | 17:[100]->1 | 18:[000]->1 Step 2 Output: 1111001111100000011 Step 3 Scan: 0:[111]->0 | 1:[111]->0 | 2:[111]->0 | 3:[110]->0 | 4:[100]->1 | 5:[001]->1 | 6:[011]->0 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[110]->0 | 11:[100]->1 | 12:[000]->1 | 13:[000]->1 | 14:[000]->1 | 15:[000]->1 | 16:[001]->1 | 17:[011]->0 | 18:[111]->0 Step 3 Output: 0000110000011111100 Step 4 Scan: 0:[000]->1 | 1:[000]->1 | 2:[000]->1 | 3:[001]->1 | 4:[011]->0 | 5:[110]->0 | 6:[100]->1 | 7:[000]->1 | 8:[000]->1 | 9:[000]->1 | 10:[001]->1 | 11:[011]->0 | 12:[111]->0 | 13:[111]->0 | 14:[111]->0 | 15:[111]->0 | 16:[110]->0 | 17:[100]->1 | 18:[000]->1 Step 4 Output: 1111001111100000011 Step 5 Scan: 0:[111]->0 | 1:[111]->0 | 2:[111]->0 | 3:[110]->0 | 4:[100]->1 | 5:[001]->1 | 6:[011]->0 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[110]->0 | 11:[100]->1 | 12:[000]->1 | 13:[000]->1 | 14:[000]->1 | 15:[000]->1 | 16:[001]->1 | 17:[011]->0 | 18:[111]->0 Step 5 Output: 0000110000011111100 Step 6 Scan: 0:[000]->1 | 1:[000]->1 | 2:[000]->1 | 3:[001]->1 | 4:[011]->0 | 5:[110]->0 | 6:[100]->1 | 7:[000]->1 | 8:[000]->1 | 9:[000]->1 | 10:[001]->1 | 11:[011]->0 | 12:[111]->0 | 13:[111]->0 | 14:[111]->0 | 15:[111]->0 | 16:[110]->0 | 17:[100]->1 | 18:[000]->1 Step 6 Output: 1111001111100000011 Step 7 Scan: 0:[111]->0 | 1:[111]->0 | 2:[111]->0 | 3:[110]->0 | 4:[100]->1 | 5:[001]->1 | 6:[011]->0 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[110]->0 | 11:[100]->1 | 12:[000]->1 | 13:[000]->1 | 14:[000]->1 | 15:[000]->1 | 16:[001]->1 | 17:[011]->0 | 18:[111]->0 Step 7 Output: 0000110000011111100 Step 8 Scan: 0:[000]->1 | 1:[000]->1 | 2:[000]->1 | 3:[001]->1 | 4:[011]->0 | 5:[110]->0 | 6:[100]->1 | 7:[000]->1 | 8:[000]->1 | 9:[000]->1 | 10:[001]->1 | 11:[011]->0 | 12:[111]->0 | 13:[111]->0 | 14:[111]->0 | 15:[111]->0 | 16:[110]->0 | 17:[100]->1 | 18:[000]->1 Step 8 Output: 1111001111100000011 Step 9 Scan: 0:[111]->0 | 1:[111]->0 | 2:[111]->0 | 3:[110]->0 | 4:[100]->1 | 5:[001]->1 | 6:[011]->0 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[110]->0 | 11:[100]->1 | 12:[000]->1 | 13:[000]->1 | 14:[000]->1 | 15:[000]->1 | 16:[001]->1 | 17:[011]->0 | 18:[111]->0 Step 9 Output: 0000110000011111100 Step 10 Scan: 0:[000]->1 | 1:[000]->1 | 2:[000]->1 | 3:[001]->1 | 4:[011]->0 | 5:[110]->0 | 6:[100]->1 | 7:[000]->1 | 8:[000]->1 | 9:[000]->1 | 10:[001]->1 | 11:[011]->0 | 12:[111]->0 | 13:[111]->0 | 14:[111]->0 | 15:[111]->0 | 16:[110]->0 | 17:[100]->1 | 18:[000]->1 Step 10 Output: 1111001111100000011 Step 11 Scan: 0:[111]->0 | 1:[111]->0 | 2:[111]->0 | 3:[110]->0 | 4:[100]->1 | 5:[001]->1 | 6:[011]->0 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[110]->0 | 11:[100]->1 | 12:[000]->1 | 13:[000]->1 | 14:[000]->1 | 15:[000]->1 | 16:[001]->1 | 17:[011]->0 | 18:[111]->0 Step 11 Output: 0000110000011111100 Step 12 Scan: 0:[000]->1 | 1:[000]->1 | 2:[000]->1 | 3:[001]->1 | 4:[011]->0 | 5:[110]->0 | 6:[100]->1 | 7:[000]->1 | 8:[000]->1 | 9:[000]->1 | 10:[001]->1 | 11:[011]->0 | 12:[111]->0 | 13:[111]->0 | 14:[111]->0 | 15:[111]->0 | 16:[110]->0 | 17:[100]->1 | 18:[000]->1 Step 12 Output: 1111001111100000011 Step 13 Scan: 0:[111]->0 | 1:[111]->0 | 2:[111]->0 | 3:[110]->0 | 4:[100]->1 | 5:[001]->1 | 6:[011]->0 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[110]->0 | 11:[100]->1 | 12:[000]->1 | 13:[000]->1 | 14:[000]->1 | 15:[000]->1 | 16:[001]->1 | 17:[011]->0 | 18:[111]->0 Step 13 Output: 0000110000011111100
0000110000011111100
abduction
Task: Abduction, Rule: 60 [111->0, 110->0, 101->1, 100->1, 011->1, 010->1, 001->0, 000->0], Steps: 2, End: 1010101001111011011
Goal: Reverse 2 steps by calculating likelihoods of priors. Step -1: Inverting state 1010101001111011011 Calculating Local Priors: Idx 0 requires neighborhood in ['010', '011', '100', '101'] Idx 1 requires neighborhood in ['000', '001', '110', '111'] Idx 2 requires neighborhood in ['010', '011', '100', '101'] Idx 3 requires neighborhood in ['000', '001', '110', '111'] Idx 4 requires neighborhood in ['010', '011', '100', '101'] Idx 5 requires neighborhood in ['000', '001', '110', '111'] Idx 6 requires neighborhood in ['010', '011', '100', '101'] Idx 7 requires neighborhood in ['000', '001', '110', '111'] Idx 8 requires neighborhood in ['000', '001', '110', '111'] Idx 9 requires neighborhood in ['010', '011', '100', '101'] Idx 10 requires neighborhood in ['010', '011', '100', '101'] Idx 11 requires neighborhood in ['010', '011', '100', '101'] Idx 12 requires neighborhood in ['010', '011', '100', '101'] Idx 13 requires neighborhood in ['000', '001', '110', '111'] Idx 14 requires neighborhood in ['010', '011', '100', '101'] Idx 15 requires neighborhood in ['010', '011', '100', '101'] Idx 16 requires neighborhood in ['000', '001', '110', '111'] Idx 17 requires neighborhood in ['010', '011', '100', '101'] Idx 18 requires neighborhood in ['010', '011', '100', '101'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% | 12:50% | 13:50% | 14:50% | 15:50% | 16:50% | 17:50% | 18:50% Greedy Candidate: 1111111111111111111 Verification: Mismatch. Correction applied -> 1100110001010010010 Step -2: Inverting state 1100110001010010010 Calculating Local Priors: Idx 0 requires neighborhood in ['010', '011', '100', '101'] Idx 1 requires neighborhood in ['010', '011', '100', '101'] Idx 2 requires neighborhood in ['000', '001', '110', '111'] Idx 3 requires neighborhood in ['000', '001', '110', '111'] Idx 4 requires neighborhood in ['010', '011', '100', '101'] Idx 5 requires neighborhood in ['010', '011', '100', '101'] Idx 6 requires neighborhood in ['000', '001', '110', '111'] Idx 7 requires neighborhood in ['000', '001', '110', '111'] Idx 8 requires neighborhood in ['000', '001', '110', '111'] Idx 9 requires neighborhood in ['010', '011', '100', '101'] Idx 10 requires neighborhood in ['000', '001', '110', '111'] Idx 11 requires neighborhood in ['010', '011', '100', '101'] Idx 12 requires neighborhood in ['000', '001', '110', '111'] Idx 13 requires neighborhood in ['000', '001', '110', '111'] Idx 14 requires neighborhood in ['010', '011', '100', '101'] Idx 15 requires neighborhood in ['000', '001', '110', '111'] Idx 16 requires neighborhood in ['000', '001', '110', '111'] Idx 17 requires neighborhood in ['010', '011', '100', '101'] Idx 18 requires neighborhood in ['000', '001', '110', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% | 12:50% | 13:50% | 14:50% | 15:50% | 16:50% | 17:50% | 18:50% Greedy Candidate: 1111111111111111111 Verification: Mismatch. Correction applied -> 1000100001100011100
1000100001100011100
deduction
Task: Deduction, Rule: 19 [111->0, 110->0, 101->0, 100->1, 011->0, 010->0, 001->1, 000->1], Steps: 15, Start: 0000100101111
Step 1 Scan: 0:[100]->1 | 1:[000]->1 | 2:[000]->1 | 3:[001]->1 | 4:[010]->0 | 5:[100]->1 | 6:[001]->1 | 7:[010]->0 | 8:[101]->0 | 9:[011]->0 | 10:[111]->0 | 11:[111]->0 | 12:[110]->0 Step 1 Output: 1111011000000 Step 2 Scan: 0:[011]->0 | 1:[111]->0 | 2:[111]->0 | 3:[110]->0 | 4:[101]->0 | 5:[011]->0 | 6:[110]->0 | 7:[100]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[000]->1 | 12:[001]->1 Step 2 Output: 0000000111111 Step 3 Scan: 0:[100]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[000]->1 | 5:[000]->1 | 6:[001]->1 | 7:[011]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 | 12:[110]->0 Step 3 Output: 1111111000000 Step 4 Scan: 0:[011]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[111]->0 | 5:[111]->0 | 6:[110]->0 | 7:[100]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[000]->1 | 12:[001]->1 Step 4 Output: 0000000111111 Step 5 Scan: 0:[100]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[000]->1 | 5:[000]->1 | 6:[001]->1 | 7:[011]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 | 12:[110]->0 Step 5 Output: 1111111000000 Step 6 Scan: 0:[011]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[111]->0 | 5:[111]->0 | 6:[110]->0 | 7:[100]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[000]->1 | 12:[001]->1 Step 6 Output: 0000000111111 Step 7 Scan: 0:[100]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[000]->1 | 5:[000]->1 | 6:[001]->1 | 7:[011]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 | 12:[110]->0 Step 7 Output: 1111111000000 Step 8 Scan: 0:[011]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[111]->0 | 5:[111]->0 | 6:[110]->0 | 7:[100]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[000]->1 | 12:[001]->1 Step 8 Output: 0000000111111 Step 9 Scan: 0:[100]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[000]->1 | 5:[000]->1 | 6:[001]->1 | 7:[011]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 | 12:[110]->0 Step 9 Output: 1111111000000 Step 10 Scan: 0:[011]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[111]->0 | 5:[111]->0 | 6:[110]->0 | 7:[100]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[000]->1 | 12:[001]->1 Step 10 Output: 0000000111111 Step 11 Scan: 0:[100]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[000]->1 | 5:[000]->1 | 6:[001]->1 | 7:[011]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 | 12:[110]->0 Step 11 Output: 1111111000000 Step 12 Scan: 0:[011]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[111]->0 | 5:[111]->0 | 6:[110]->0 | 7:[100]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[000]->1 | 12:[001]->1 Step 12 Output: 0000000111111 Step 13 Scan: 0:[100]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[000]->1 | 5:[000]->1 | 6:[001]->1 | 7:[011]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 | 12:[110]->0 Step 13 Output: 1111111000000 Step 14 Scan: 0:[011]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[111]->0 | 5:[111]->0 | 6:[110]->0 | 7:[100]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[000]->1 | 12:[001]->1 Step 14 Output: 0000000111111 Step 15 Scan: 0:[100]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[000]->1 | 5:[000]->1 | 6:[001]->1 | 7:[011]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 | 12:[110]->0 Step 15 Output: 1111111000000
1111111000000
deduction
Task: Deduction, Rule: 50 [111->0, 110->0, 101->1, 100->1, 011->0, 010->0, 001->1, 000->0], Steps: 11, Start: 0000000100101001
Step 1 Scan: 0:[100]->1 | 1:[000]->0 | 2:[000]->0 | 3:[000]->0 | 4:[000]->0 | 5:[000]->0 | 6:[001]->1 | 7:[010]->0 | 8:[100]->1 | 9:[001]->1 | 10:[010]->0 | 11:[101]->1 | 12:[010]->0 | 13:[100]->1 | 14:[001]->1 | 15:[010]->0 Step 1 Output: 1000001011010110 Step 2 Scan: 0:[010]->0 | 1:[100]->1 | 2:[000]->0 | 3:[000]->0 | 4:[000]->0 | 5:[001]->1 | 6:[010]->0 | 7:[101]->1 | 8:[011]->0 | 9:[110]->0 | 10:[101]->1 | 11:[010]->0 | 12:[101]->1 | 13:[011]->0 | 14:[110]->0 | 15:[101]->1 Step 2 Output: 0100010100101001 Step 3 Scan: 0:[101]->1 | 1:[010]->0 | 2:[100]->1 | 3:[000]->0 | 4:[001]->1 | 5:[010]->0 | 6:[101]->1 | 7:[010]->0 | 8:[100]->1 | 9:[001]->1 | 10:[010]->0 | 11:[101]->1 | 12:[010]->0 | 13:[100]->1 | 14:[001]->1 | 15:[010]->0 Step 3 Output: 1010101011010110 Step 4 Scan: 0:[010]->0 | 1:[101]->1 | 2:[010]->0 | 3:[101]->1 | 4:[010]->0 | 5:[101]->1 | 6:[010]->0 | 7:[101]->1 | 8:[011]->0 | 9:[110]->0 | 10:[101]->1 | 11:[010]->0 | 12:[101]->1 | 13:[011]->0 | 14:[110]->0 | 15:[101]->1 Step 4 Output: 0101010100101001 Step 5 Scan: 0:[101]->1 | 1:[010]->0 | 2:[101]->1 | 3:[010]->0 | 4:[101]->1 | 5:[010]->0 | 6:[101]->1 | 7:[010]->0 | 8:[100]->1 | 9:[001]->1 | 10:[010]->0 | 11:[101]->1 | 12:[010]->0 | 13:[100]->1 | 14:[001]->1 | 15:[010]->0 Step 5 Output: 1010101011010110 Step 6 Scan: 0:[010]->0 | 1:[101]->1 | 2:[010]->0 | 3:[101]->1 | 4:[010]->0 | 5:[101]->1 | 6:[010]->0 | 7:[101]->1 | 8:[011]->0 | 9:[110]->0 | 10:[101]->1 | 11:[010]->0 | 12:[101]->1 | 13:[011]->0 | 14:[110]->0 | 15:[101]->1 Step 6 Output: 0101010100101001 Step 7 Scan: 0:[101]->1 | 1:[010]->0 | 2:[101]->1 | 3:[010]->0 | 4:[101]->1 | 5:[010]->0 | 6:[101]->1 | 7:[010]->0 | 8:[100]->1 | 9:[001]->1 | 10:[010]->0 | 11:[101]->1 | 12:[010]->0 | 13:[100]->1 | 14:[001]->1 | 15:[010]->0 Step 7 Output: 1010101011010110 Step 8 Scan: 0:[010]->0 | 1:[101]->1 | 2:[010]->0 | 3:[101]->1 | 4:[010]->0 | 5:[101]->1 | 6:[010]->0 | 7:[101]->1 | 8:[011]->0 | 9:[110]->0 | 10:[101]->1 | 11:[010]->0 | 12:[101]->1 | 13:[011]->0 | 14:[110]->0 | 15:[101]->1 Step 8 Output: 0101010100101001 Step 9 Scan: 0:[101]->1 | 1:[010]->0 | 2:[101]->1 | 3:[010]->0 | 4:[101]->1 | 5:[010]->0 | 6:[101]->1 | 7:[010]->0 | 8:[100]->1 | 9:[001]->1 | 10:[010]->0 | 11:[101]->1 | 12:[010]->0 | 13:[100]->1 | 14:[001]->1 | 15:[010]->0 Step 9 Output: 1010101011010110 Step 10 Scan: 0:[010]->0 | 1:[101]->1 | 2:[010]->0 | 3:[101]->1 | 4:[010]->0 | 5:[101]->1 | 6:[010]->0 | 7:[101]->1 | 8:[011]->0 | 9:[110]->0 | 10:[101]->1 | 11:[010]->0 | 12:[101]->1 | 13:[011]->0 | 14:[110]->0 | 15:[101]->1 Step 10 Output: 0101010100101001 Step 11 Scan: 0:[101]->1 | 1:[010]->0 | 2:[101]->1 | 3:[010]->0 | 4:[101]->1 | 5:[010]->0 | 6:[101]->1 | 7:[010]->0 | 8:[100]->1 | 9:[001]->1 | 10:[010]->0 | 11:[101]->1 | 12:[010]->0 | 13:[100]->1 | 14:[001]->1 | 15:[010]->0 Step 11 Output: 1010101011010110
1010101011010110
deduction
Task: Deduction, Rule: 147 [111->1, 110->0, 101->0, 100->1, 011->0, 010->0, 001->1, 000->1], Steps: 10, Start: 11010101010111011
Step 1 Scan: 0:[111]->1 | 1:[110]->0 | 2:[101]->0 | 3:[010]->0 | 4:[101]->0 | 5:[010]->0 | 6:[101]->0 | 7:[010]->0 | 8:[101]->0 | 9:[010]->0 | 10:[101]->0 | 11:[011]->0 | 12:[111]->1 | 13:[110]->0 | 14:[101]->0 | 15:[011]->0 | 16:[111]->1 Step 1 Output: 10000000000010001 Step 2 Scan: 0:[110]->0 | 1:[100]->1 | 2:[000]->1 | 3:[000]->1 | 4:[000]->1 | 5:[000]->1 | 6:[000]->1 | 7:[000]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[001]->1 | 12:[010]->0 | 13:[100]->1 | 14:[000]->1 | 15:[001]->1 | 16:[011]->0 Step 2 Output: 01111111111101110 Step 3 Scan: 0:[001]->1 | 1:[011]->0 | 2:[111]->1 | 3:[111]->1 | 4:[111]->1 | 5:[111]->1 | 6:[111]->1 | 7:[111]->1 | 8:[111]->1 | 9:[111]->1 | 10:[111]->1 | 11:[110]->0 | 12:[101]->0 | 13:[011]->0 | 14:[111]->1 | 15:[110]->0 | 16:[100]->1 Step 3 Output: 10111111111000101 Step 4 Scan: 0:[110]->0 | 1:[101]->0 | 2:[011]->0 | 3:[111]->1 | 4:[111]->1 | 5:[111]->1 | 6:[111]->1 | 7:[111]->1 | 8:[111]->1 | 9:[111]->1 | 10:[110]->0 | 11:[100]->1 | 12:[000]->1 | 13:[001]->1 | 14:[010]->0 | 15:[101]->0 | 16:[011]->0 Step 4 Output: 00011111110111000 Step 5 Scan: 0:[000]->1 | 1:[000]->1 | 2:[001]->1 | 3:[011]->0 | 4:[111]->1 | 5:[111]->1 | 6:[111]->1 | 7:[111]->1 | 8:[111]->1 | 9:[110]->0 | 10:[101]->0 | 11:[011]->0 | 12:[111]->1 | 13:[110]->0 | 14:[100]->1 | 15:[000]->1 | 16:[000]->1 Step 5 Output: 11101111100010111 Step 6 Scan: 0:[111]->1 | 1:[111]->1 | 2:[110]->0 | 3:[101]->0 | 4:[011]->0 | 5:[111]->1 | 6:[111]->1 | 7:[111]->1 | 8:[110]->0 | 9:[100]->1 | 10:[000]->1 | 11:[001]->1 | 12:[010]->0 | 13:[101]->0 | 14:[011]->0 | 15:[111]->1 | 16:[111]->1 Step 6 Output: 11000111011100011 Step 7 Scan: 0:[111]->1 | 1:[110]->0 | 2:[100]->1 | 3:[000]->1 | 4:[001]->1 | 5:[011]->0 | 6:[111]->1 | 7:[110]->0 | 8:[101]->0 | 9:[011]->0 | 10:[111]->1 | 11:[110]->0 | 12:[100]->1 | 13:[000]->1 | 14:[001]->1 | 15:[011]->0 | 16:[111]->1 Step 7 Output: 10111010001011101 Step 8 Scan: 0:[110]->0 | 1:[101]->0 | 2:[011]->0 | 3:[111]->1 | 4:[110]->0 | 5:[101]->0 | 6:[010]->0 | 7:[100]->1 | 8:[000]->1 | 9:[001]->1 | 10:[010]->0 | 11:[101]->0 | 12:[011]->0 | 13:[111]->1 | 14:[110]->0 | 15:[101]->0 | 16:[011]->0 Step 8 Output: 00010001110001000 Step 9 Scan: 0:[000]->1 | 1:[000]->1 | 2:[001]->1 | 3:[010]->0 | 4:[100]->1 | 5:[000]->1 | 6:[001]->1 | 7:[011]->0 | 8:[111]->1 | 9:[110]->0 | 10:[100]->1 | 11:[000]->1 | 12:[001]->1 | 13:[010]->0 | 14:[100]->1 | 15:[000]->1 | 16:[000]->1 Step 9 Output: 11101110101110111 Step 10 Scan: 0:[111]->1 | 1:[111]->1 | 2:[110]->0 | 3:[101]->0 | 4:[011]->0 | 5:[111]->1 | 6:[110]->0 | 7:[101]->0 | 8:[010]->0 | 9:[101]->0 | 10:[011]->0 | 11:[111]->1 | 12:[110]->0 | 13:[101]->0 | 14:[011]->0 | 15:[111]->1 | 16:[111]->1 Step 10 Output: 11000100000100011
11000100000100011
induction
Task: Induction, Start: 00101011100101011110, End: 01010101011010101101, Steps: 13, Hint: Class 2
Task: Find rule in Class 2. Candidates: [50, 29, 1, 108, 19, 178, 23, 37] Attempt 1: Testing Rule 50 [111->0, 110->0, 101->1, 100->1, 011->0, 010->0, 001->1, 000->0] Sim Step 1: 01010100011010100001 Sim Step 2: 10101010100101010010 Sim Step 3: 01010101011010101101 Sim Step 4: 10101010100101010010 Sim Step 5: 01010101011010101101 Sim Step 6: 10101010100101010010 Sim Step 7: 01010101011010101101 Sim Step 8: 10101010100101010010 Sim Step 9: 01010101011010101101 Sim Step 10: 10101010100101010010 Sim Step 11: 01010101011010101101 Sim Step 12: 10101010100101010010 Sim Step 13: 01010101011010101101 Verification: Exact Match. Rule Confirmed.
111->0, 110->0, 101->1, 100->1, 011->0, 010->0, 001->1, 000->0
deduction
Task: Deduction, Rule: 90 [111->0, 110->1, 101->0, 100->1, 011->1, 010->0, 001->1, 000->0], Steps: 15, Start: 011110111001000
Step 1 Scan: 0:[001]->1 | 1:[011]->1 | 2:[111]->0 | 3:[111]->0 | 4:[110]->1 | 5:[101]->0 | 6:[011]->1 | 7:[111]->0 | 8:[110]->1 | 9:[100]->1 | 10:[001]->1 | 11:[010]->0 | 12:[100]->1 | 13:[000]->0 | 14:[000]->0 Step 1 Output: 110010101110100 Step 2 Scan: 0:[011]->1 | 1:[110]->1 | 2:[100]->1 | 3:[001]->1 | 4:[010]->0 | 5:[101]->0 | 6:[010]->0 | 7:[101]->0 | 8:[011]->1 | 9:[111]->0 | 10:[110]->1 | 11:[101]->0 | 12:[010]->0 | 13:[100]->1 | 14:[001]->1 Step 2 Output: 111100001010011 Step 3 Scan: 0:[111]->0 | 1:[111]->0 | 2:[111]->0 | 3:[110]->1 | 4:[100]->1 | 5:[000]->0 | 6:[000]->0 | 7:[001]->1 | 8:[010]->0 | 9:[101]->0 | 10:[010]->0 | 11:[100]->1 | 12:[001]->1 | 13:[011]->1 | 14:[111]->0 Step 3 Output: 000110010001110 Step 4 Scan: 0:[000]->0 | 1:[000]->0 | 2:[001]->1 | 3:[011]->1 | 4:[110]->1 | 5:[100]->1 | 6:[001]->1 | 7:[010]->0 | 8:[100]->1 | 9:[000]->0 | 10:[001]->1 | 11:[011]->1 | 12:[111]->0 | 13:[110]->1 | 14:[100]->1 Step 4 Output: 001111101011011 Step 5 Scan: 0:[100]->1 | 1:[001]->1 | 2:[011]->1 | 3:[111]->0 | 4:[111]->0 | 5:[111]->0 | 6:[110]->1 | 7:[101]->0 | 8:[010]->0 | 9:[101]->0 | 10:[011]->1 | 11:[110]->1 | 12:[101]->0 | 13:[011]->1 | 14:[110]->1 Step 5 Output: 111000100011011 Step 6 Scan: 0:[111]->0 | 1:[111]->0 | 2:[110]->1 | 3:[100]->1 | 4:[000]->0 | 5:[001]->1 | 6:[010]->0 | 7:[100]->1 | 8:[000]->0 | 9:[001]->1 | 10:[011]->1 | 11:[110]->1 | 12:[101]->0 | 13:[011]->1 | 14:[111]->0 Step 6 Output: 001101010111010 Step 7 Scan: 0:[000]->0 | 1:[001]->1 | 2:[011]->1 | 3:[110]->1 | 4:[101]->0 | 5:[010]->0 | 6:[101]->0 | 7:[010]->0 | 8:[101]->0 | 9:[011]->1 | 10:[111]->0 | 11:[110]->1 | 12:[101]->0 | 13:[010]->0 | 14:[100]->1 Step 7 Output: 011100000101001 Step 8 Scan: 0:[101]->0 | 1:[011]->1 | 2:[111]->0 | 3:[110]->1 | 4:[100]->1 | 5:[000]->0 | 6:[000]->0 | 7:[000]->0 | 8:[001]->1 | 9:[010]->0 | 10:[101]->0 | 11:[010]->0 | 12:[100]->1 | 13:[001]->1 | 14:[010]->0 Step 8 Output: 010110001000110 Step 9 Scan: 0:[001]->1 | 1:[010]->0 | 2:[101]->0 | 3:[011]->1 | 4:[110]->1 | 5:[100]->1 | 6:[000]->0 | 7:[001]->1 | 8:[010]->0 | 9:[100]->1 | 10:[000]->0 | 11:[001]->1 | 12:[011]->1 | 13:[110]->1 | 14:[100]->1 Step 9 Output: 100111010101111 Step 10 Scan: 0:[110]->1 | 1:[100]->1 | 2:[001]->1 | 3:[011]->1 | 4:[111]->0 | 5:[110]->1 | 6:[101]->0 | 7:[010]->0 | 8:[101]->0 | 9:[010]->0 | 10:[101]->0 | 11:[011]->1 | 12:[111]->0 | 13:[111]->0 | 14:[111]->0 Step 10 Output: 111101000001000 Step 11 Scan: 0:[011]->1 | 1:[111]->0 | 2:[111]->0 | 3:[110]->1 | 4:[101]->0 | 5:[010]->0 | 6:[100]->1 | 7:[000]->0 | 8:[000]->0 | 9:[000]->0 | 10:[001]->1 | 11:[010]->0 | 12:[100]->1 | 13:[000]->0 | 14:[001]->1 Step 11 Output: 100100100010101 Step 12 Scan: 0:[110]->1 | 1:[100]->1 | 2:[001]->1 | 3:[010]->0 | 4:[100]->1 | 5:[001]->1 | 6:[010]->0 | 7:[100]->1 | 8:[000]->0 | 9:[001]->1 | 10:[010]->0 | 11:[101]->0 | 12:[010]->0 | 13:[101]->0 | 14:[011]->1 Step 12 Output: 111011010100001 Step 13 Scan: 0:[111]->0 | 1:[111]->0 | 2:[110]->1 | 3:[101]->0 | 4:[011]->1 | 5:[110]->1 | 6:[101]->0 | 7:[010]->0 | 8:[101]->0 | 9:[010]->0 | 10:[100]->1 | 11:[000]->0 | 12:[000]->0 | 13:[001]->1 | 14:[011]->1 Step 13 Output: 001011000010011 Step 14 Scan: 0:[100]->1 | 1:[001]->1 | 2:[010]->0 | 3:[101]->0 | 4:[011]->1 | 5:[110]->1 | 6:[100]->1 | 7:[000]->0 | 8:[000]->0 | 9:[001]->1 | 10:[010]->0 | 11:[100]->1 | 12:[001]->1 | 13:[011]->1 | 14:[110]->1 Step 14 Output: 110011100101111 Step 15 Scan: 0:[111]->0 | 1:[110]->1 | 2:[100]->1 | 3:[001]->1 | 4:[011]->1 | 5:[111]->0 | 6:[110]->1 | 7:[100]->1 | 8:[001]->1 | 9:[010]->0 | 10:[101]->0 | 11:[011]->1 | 12:[111]->0 | 13:[111]->0 | 14:[111]->0 Step 15 Output: 011110111001000
011110111001000
abduction
Task: Abduction, Rule: 30 [111->0, 110->0, 101->0, 100->1, 011->1, 010->1, 001->1, 000->0], Steps: 2, End: 0101010110000100010
Goal: Reverse 2 steps by calculating likelihoods of priors. Step -1: Inverting state 0101010110000100010 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '101', '110', '111'] Idx 1 requires neighborhood in ['001', '010', '011', '100'] Idx 2 requires neighborhood in ['000', '101', '110', '111'] Idx 3 requires neighborhood in ['001', '010', '011', '100'] Idx 4 requires neighborhood in ['000', '101', '110', '111'] Idx 5 requires neighborhood in ['001', '010', '011', '100'] Idx 6 requires neighborhood in ['000', '101', '110', '111'] Idx 7 requires neighborhood in ['001', '010', '011', '100'] Idx 8 requires neighborhood in ['001', '010', '011', '100'] Idx 9 requires neighborhood in ['000', '101', '110', '111'] Idx 10 requires neighborhood in ['000', '101', '110', '111'] Idx 11 requires neighborhood in ['000', '101', '110', '111'] Idx 12 requires neighborhood in ['000', '101', '110', '111'] Idx 13 requires neighborhood in ['001', '010', '011', '100'] Idx 14 requires neighborhood in ['000', '101', '110', '111'] Idx 15 requires neighborhood in ['000', '101', '110', '111'] Idx 16 requires neighborhood in ['000', '101', '110', '111'] Idx 17 requires neighborhood in ['001', '010', '011', '100'] Idx 18 requires neighborhood in ['000', '101', '110', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:41% | 1:58% | 2:41% | 3:58% | 4:41% | 5:58% | 6:41% | 7:41% | 8:58% | 9:58% | 10:58% | 11:58% | 12:41% | 13:58% | 14:58% | 15:58% | 16:41% | 17:58% | 18:58% Greedy Candidate: 0101010011110111011 Verification: Mismatch. Correction applied -> 0101100011110111011 Step -2: Inverting state 0101100011110111011 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '101', '110', '111'] Idx 1 requires neighborhood in ['001', '010', '011', '100'] Idx 2 requires neighborhood in ['000', '101', '110', '111'] Idx 3 requires neighborhood in ['001', '010', '011', '100'] Idx 4 requires neighborhood in ['001', '010', '011', '100'] Idx 5 requires neighborhood in ['000', '101', '110', '111'] Idx 6 requires neighborhood in ['000', '101', '110', '111'] Idx 7 requires neighborhood in ['000', '101', '110', '111'] Idx 8 requires neighborhood in ['001', '010', '011', '100'] Idx 9 requires neighborhood in ['001', '010', '011', '100'] Idx 10 requires neighborhood in ['001', '010', '011', '100'] Idx 11 requires neighborhood in ['001', '010', '011', '100'] Idx 12 requires neighborhood in ['000', '101', '110', '111'] Idx 13 requires neighborhood in ['001', '010', '011', '100'] Idx 14 requires neighborhood in ['001', '010', '011', '100'] Idx 15 requires neighborhood in ['001', '010', '011', '100'] Idx 16 requires neighborhood in ['000', '101', '110', '111'] Idx 17 requires neighborhood in ['001', '010', '011', '100'] Idx 18 requires neighborhood in ['001', '010', '011', '100'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:41% | 1:58% | 2:41% | 3:41% | 4:58% | 5:58% | 6:58% | 7:41% | 8:41% | 9:41% | 10:41% | 11:58% | 12:41% | 13:41% | 14:41% | 15:58% | 16:41% | 17:41% | 18:58% Greedy Candidate: 0100111000010001001 Verification: Mismatch. Correction applied -> 1000111100100010001
1000111100100010001
deduction
Task: Deduction, Rule: 126 [111->0, 110->1, 101->1, 100->1, 011->1, 010->1, 001->1, 000->0], Steps: 11, Start: 0011100110100001
Step 1 Scan: 0:[100]->1 | 1:[001]->1 | 2:[011]->1 | 3:[111]->0 | 4:[110]->1 | 5:[100]->1 | 6:[001]->1 | 7:[011]->1 | 8:[110]->1 | 9:[101]->1 | 10:[010]->1 | 11:[100]->1 | 12:[000]->0 | 13:[000]->0 | 14:[001]->1 | 15:[010]->1 Step 1 Output: 1110111111110011 Step 2 Scan: 0:[111]->0 | 1:[111]->0 | 2:[110]->1 | 3:[101]->1 | 4:[011]->1 | 5:[111]->0 | 6:[111]->0 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[110]->1 | 12:[100]->1 | 13:[001]->1 | 14:[011]->1 | 15:[111]->0 Step 2 Output: 0011100000011110 Step 3 Scan: 0:[000]->0 | 1:[001]->1 | 2:[011]->1 | 3:[111]->0 | 4:[110]->1 | 5:[100]->1 | 6:[000]->0 | 7:[000]->0 | 8:[000]->0 | 9:[000]->0 | 10:[001]->1 | 11:[011]->1 | 12:[111]->0 | 13:[111]->0 | 14:[110]->1 | 15:[100]->1 Step 3 Output: 0110110000110011 Step 4 Scan: 0:[101]->1 | 1:[011]->1 | 2:[110]->1 | 3:[101]->1 | 4:[011]->1 | 5:[110]->1 | 6:[100]->1 | 7:[000]->0 | 8:[000]->0 | 9:[001]->1 | 10:[011]->1 | 11:[110]->1 | 12:[100]->1 | 13:[001]->1 | 14:[011]->1 | 15:[110]->1 Step 4 Output: 1111111001111111 Step 5 Scan: 0:[111]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[111]->0 | 5:[111]->0 | 6:[110]->1 | 7:[100]->1 | 8:[001]->1 | 9:[011]->1 | 10:[111]->0 | 11:[111]->0 | 12:[111]->0 | 13:[111]->0 | 14:[111]->0 | 15:[111]->0 Step 5 Output: 0000001111000000 Step 6 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[000]->0 | 4:[000]->0 | 5:[001]->1 | 6:[011]->1 | 7:[111]->0 | 8:[111]->0 | 9:[110]->1 | 10:[100]->1 | 11:[000]->0 | 12:[000]->0 | 13:[000]->0 | 14:[000]->0 | 15:[000]->0 Step 6 Output: 0000011001100000 Step 7 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[000]->0 | 4:[001]->1 | 5:[011]->1 | 6:[110]->1 | 7:[100]->1 | 8:[001]->1 | 9:[011]->1 | 10:[110]->1 | 11:[100]->1 | 12:[000]->0 | 13:[000]->0 | 14:[000]->0 | 15:[000]->0 Step 7 Output: 0000111111110000 Step 8 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[001]->1 | 4:[011]->1 | 5:[111]->0 | 6:[111]->0 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[110]->1 | 12:[100]->1 | 13:[000]->0 | 14:[000]->0 | 15:[000]->0 Step 8 Output: 0001100000011000 Step 9 Scan: 0:[000]->0 | 1:[000]->0 | 2:[001]->1 | 3:[011]->1 | 4:[110]->1 | 5:[100]->1 | 6:[000]->0 | 7:[000]->0 | 8:[000]->0 | 9:[000]->0 | 10:[001]->1 | 11:[011]->1 | 12:[110]->1 | 13:[100]->1 | 14:[000]->0 | 15:[000]->0 Step 9 Output: 0011110000111100 Step 10 Scan: 0:[000]->0 | 1:[001]->1 | 2:[011]->1 | 3:[111]->0 | 4:[111]->0 | 5:[110]->1 | 6:[100]->1 | 7:[000]->0 | 8:[000]->0 | 9:[001]->1 | 10:[011]->1 | 11:[111]->0 | 12:[111]->0 | 13:[110]->1 | 14:[100]->1 | 15:[000]->0 Step 10 Output: 0110011001100110 Step 11 Scan: 0:[001]->1 | 1:[011]->1 | 2:[110]->1 | 3:[100]->1 | 4:[001]->1 | 5:[011]->1 | 6:[110]->1 | 7:[100]->1 | 8:[001]->1 | 9:[011]->1 | 10:[110]->1 | 11:[100]->1 | 12:[001]->1 | 13:[011]->1 | 14:[110]->1 | 15:[100]->1 Step 11 Output: 1111111111111111
1111111111111111
induction
Task: Induction, Start: 010010000111, End: 111111110111, Steps: 13, Hint: Class 3
Task: Find rule in Class 3. Candidates: [150, 105, 45, 30, 126, 60, 90] Attempt 1: Testing Rule 150 [111->1, 110->0, 101->0, 100->1, 011->0, 010->1, 001->1, 000->0] Sim Step 1: 011111001010 Sim Step 2: 101110111011 Sim Step 3: 000100010001 Sim Step 4: 101110111011 Sim Step 5: 000100010001 Sim Step 6: 101110111011 Sim Step 7: 000100010001 Sim Step 8: 101110111011 Sim Step 9: 000100010001 Sim Step 10: 101110111011 Sim Step 11: 000100010001 Sim Step 12: 101110111011 Sim Step 13: 000100010001 Verification: Mismatch (Expected 111111110111). Next... Attempt 2: Testing Rule 105 [111->0, 110->1, 101->1, 100->0, 011->1, 010->0, 001->0, 000->1] Sim Step 1: 100000110101 Sim Step 2: 101110111011 Sim Step 3: 111011101110 Sim Step 4: 101110111011 Sim Step 5: 111011101110 Sim Step 6: 101110111011 Sim Step 7: 111011101110 Sim Step 8: 101110111011 Sim Step 9: 111011101110 Sim Step 10: 101110111011 Sim Step 11: 111011101110 Sim Step 12: 101110111011 Sim Step 13: 111011101110 Verification: Mismatch (Expected 111111110111). Next... Attempt 3: Testing Rule 45 [111->0, 110->0, 101->1, 100->0, 011->1, 010->1, 001->0, 000->1] Sim Step 1: 110010110100 Sim Step 2: 100011101100 Sim Step 3: 101010011000 Sim Step 4: 111110010010 Sim Step 5: 100000010011 Sim Step 6: 001111010010 Sim Step 7: 101000110010 Sim Step 8: 111010100011 Sim Step 9: 000111101010 Sim Step 10: 110100011110 Sim Step 11: 101101010001 Sim Step 12: 011011110101 Sim Step 13: 110110001111 Verification: Mismatch (Expected 111111110111). Next... Attempt 4: Testing Rule 30 [111->0, 110->0, 101->0, 100->1, 011->1, 010->1, 001->1, 000->0] Sim Step 1: 011111001100 Sim Step 2: 110000111010 Sim Step 3: 101001100010 Sim Step 4: 101111010110 Sim Step 5: 101000010100 Sim Step 6: 101100110111 Sim Step 7: 001011100100 Sim Step 8: 011010011110 Sim Step 9: 110011110001 Sim Step 10: 001110001011 Sim Step 11: 111001011010 Sim Step 12: 100111010010 Sim Step 13: 111100011110 Verification: Mismatch (Expected 111111110111). Next... Attempt 5: Testing Rule 126 [111->0, 110->1, 101->1, 100->1, 011->1, 010->1, 001->1, 000->0] Sim Step 1: 111111001101 Sim Step 2: 000001111111 Sim Step 3: 100011000001 Sim Step 4: 110111100011 Sim Step 5: 011100110110 Sim Step 6: 110111111111 Sim Step 7: 011100000000 Sim Step 8: 110110000000 Sim Step 9: 111111000001 Sim Step 10: 000001100011 Sim Step 11: 100011110111 Sim Step 12: 110110011100 Sim Step 13: 111111110111 Verification: Exact Match. Rule Confirmed.
111->0, 110->1, 101->1, 100->1, 011->1, 010->1, 001->1, 000->0
deduction
Task: Deduction, Rule: 106 [111->0, 110->1, 101->1, 100->0, 011->1, 010->0, 001->1, 000->0], Steps: 12, Start: 0001111111001
Step 1 Scan: 0:[100]->0 | 1:[000]->0 | 2:[001]->1 | 3:[011]->1 | 4:[111]->0 | 5:[111]->0 | 6:[111]->0 | 7:[111]->0 | 8:[111]->0 | 9:[110]->1 | 10:[100]->0 | 11:[001]->1 | 12:[010]->0 Step 1 Output: 0011000001010 Step 2 Scan: 0:[000]->0 | 1:[001]->1 | 2:[011]->1 | 3:[110]->1 | 4:[100]->0 | 5:[000]->0 | 6:[000]->0 | 7:[000]->0 | 8:[001]->1 | 9:[010]->0 | 10:[101]->1 | 11:[010]->0 | 12:[100]->0 Step 2 Output: 0111000010100 Step 3 Scan: 0:[001]->1 | 1:[011]->1 | 2:[111]->0 | 3:[110]->1 | 4:[100]->0 | 5:[000]->0 | 6:[000]->0 | 7:[001]->1 | 8:[010]->0 | 9:[101]->1 | 10:[010]->0 | 11:[100]->0 | 12:[000]->0 Step 3 Output: 1101000101000 Step 4 Scan: 0:[011]->1 | 1:[110]->1 | 2:[101]->1 | 3:[010]->0 | 4:[100]->0 | 5:[000]->0 | 6:[001]->1 | 7:[010]->0 | 8:[101]->1 | 9:[010]->0 | 10:[100]->0 | 11:[000]->0 | 12:[001]->1 Step 4 Output: 1110001010001 Step 5 Scan: 0:[111]->0 | 1:[111]->0 | 2:[110]->1 | 3:[100]->0 | 4:[000]->0 | 5:[001]->1 | 6:[010]->0 | 7:[101]->1 | 8:[010]->0 | 9:[100]->0 | 10:[000]->0 | 11:[001]->1 | 12:[011]->1 Step 5 Output: 0010010100011 Step 6 Scan: 0:[100]->0 | 1:[001]->1 | 2:[010]->0 | 3:[100]->0 | 4:[001]->1 | 5:[010]->0 | 6:[101]->1 | 7:[010]->0 | 8:[100]->0 | 9:[000]->0 | 10:[001]->1 | 11:[011]->1 | 12:[110]->1 Step 6 Output: 0100101000111 Step 7 Scan: 0:[101]->1 | 1:[010]->0 | 2:[100]->0 | 3:[001]->1 | 4:[010]->0 | 5:[101]->1 | 6:[010]->0 | 7:[100]->0 | 8:[000]->0 | 9:[001]->1 | 10:[011]->1 | 11:[111]->0 | 12:[110]->1 Step 7 Output: 1001010001101 Step 8 Scan: 0:[110]->1 | 1:[100]->0 | 2:[001]->1 | 3:[010]->0 | 4:[101]->1 | 5:[010]->0 | 6:[100]->0 | 7:[000]->0 | 8:[001]->1 | 9:[011]->1 | 10:[110]->1 | 11:[101]->1 | 12:[011]->1 Step 8 Output: 1010100011111 Step 9 Scan: 0:[110]->1 | 1:[101]->1 | 2:[010]->0 | 3:[101]->1 | 4:[010]->0 | 5:[100]->0 | 6:[000]->0 | 7:[001]->1 | 8:[011]->1 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 | 12:[111]->0 Step 9 Output: 1101000110000 Step 10 Scan: 0:[011]->1 | 1:[110]->1 | 2:[101]->1 | 3:[010]->0 | 4:[100]->0 | 5:[000]->0 | 6:[001]->1 | 7:[011]->1 | 8:[110]->1 | 9:[100]->0 | 10:[000]->0 | 11:[000]->0 | 12:[001]->1 Step 10 Output: 1110001110001 Step 11 Scan: 0:[111]->0 | 1:[111]->0 | 2:[110]->1 | 3:[100]->0 | 4:[000]->0 | 5:[001]->1 | 6:[011]->1 | 7:[111]->0 | 8:[110]->1 | 9:[100]->0 | 10:[000]->0 | 11:[001]->1 | 12:[011]->1 Step 11 Output: 0010011010011 Step 12 Scan: 0:[100]->0 | 1:[001]->1 | 2:[010]->0 | 3:[100]->0 | 4:[001]->1 | 5:[011]->1 | 6:[110]->1 | 7:[101]->1 | 8:[010]->0 | 9:[100]->0 | 10:[001]->1 | 11:[011]->1 | 12:[110]->1 Step 12 Output: 0100111100111
0100111100111
abduction
Task: Abduction, Rule: 150 [111->1, 110->0, 101->0, 100->1, 011->0, 010->1, 001->1, 000->0], Steps: 3, End: 000111010010010101
Goal: Reverse 3 steps by calculating likelihoods of priors. Step -1: Inverting state 000111010010010101 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '011', '101', '110'] Idx 1 requires neighborhood in ['000', '011', '101', '110'] Idx 2 requires neighborhood in ['000', '011', '101', '110'] Idx 3 requires neighborhood in ['001', '010', '100', '111'] Idx 4 requires neighborhood in ['001', '010', '100', '111'] Idx 5 requires neighborhood in ['001', '010', '100', '111'] Idx 6 requires neighborhood in ['000', '011', '101', '110'] Idx 7 requires neighborhood in ['001', '010', '100', '111'] Idx 8 requires neighborhood in ['000', '011', '101', '110'] Idx 9 requires neighborhood in ['000', '011', '101', '110'] Idx 10 requires neighborhood in ['001', '010', '100', '111'] Idx 11 requires neighborhood in ['000', '011', '101', '110'] Idx 12 requires neighborhood in ['000', '011', '101', '110'] Idx 13 requires neighborhood in ['001', '010', '100', '111'] Idx 14 requires neighborhood in ['000', '011', '101', '110'] Idx 15 requires neighborhood in ['001', '010', '100', '111'] Idx 16 requires neighborhood in ['000', '011', '101', '110'] Idx 17 requires neighborhood in ['001', '010', '100', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% | 12:50% | 13:50% | 14:50% | 15:50% | 16:50% | 17:50% Greedy Candidate: 111111111111111111 Verification: Mismatch. Correction applied -> 000010001100001110 Step -2: Inverting state 000010001100001110 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '011', '101', '110'] Idx 1 requires neighborhood in ['000', '011', '101', '110'] Idx 2 requires neighborhood in ['000', '011', '101', '110'] Idx 3 requires neighborhood in ['000', '011', '101', '110'] Idx 4 requires neighborhood in ['001', '010', '100', '111'] Idx 5 requires neighborhood in ['000', '011', '101', '110'] Idx 6 requires neighborhood in ['000', '011', '101', '110'] Idx 7 requires neighborhood in ['000', '011', '101', '110'] Idx 8 requires neighborhood in ['001', '010', '100', '111'] Idx 9 requires neighborhood in ['001', '010', '100', '111'] Idx 10 requires neighborhood in ['000', '011', '101', '110'] Idx 11 requires neighborhood in ['000', '011', '101', '110'] Idx 12 requires neighborhood in ['000', '011', '101', '110'] Idx 13 requires neighborhood in ['000', '011', '101', '110'] Idx 14 requires neighborhood in ['001', '010', '100', '111'] Idx 15 requires neighborhood in ['001', '010', '100', '111'] Idx 16 requires neighborhood in ['001', '010', '100', '111'] Idx 17 requires neighborhood in ['000', '011', '101', '110'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% | 12:50% | 13:50% | 14:50% | 15:50% | 16:50% | 17:50% Greedy Candidate: 111111111111111111 Verification: Mismatch. Correction applied -> 011010110011011111 Step -3: Inverting state 011010110011011111 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '011', '101', '110'] Idx 1 requires neighborhood in ['001', '010', '100', '111'] Idx 2 requires neighborhood in ['001', '010', '100', '111'] Idx 3 requires neighborhood in ['000', '011', '101', '110'] Idx 4 requires neighborhood in ['001', '010', '100', '111'] Idx 5 requires neighborhood in ['000', '011', '101', '110'] Idx 6 requires neighborhood in ['001', '010', '100', '111'] Idx 7 requires neighborhood in ['001', '010', '100', '111'] Idx 8 requires neighborhood in ['000', '011', '101', '110'] Idx 9 requires neighborhood in ['000', '011', '101', '110'] Idx 10 requires neighborhood in ['001', '010', '100', '111'] Idx 11 requires neighborhood in ['001', '010', '100', '111'] Idx 12 requires neighborhood in ['000', '011', '101', '110'] Idx 13 requires neighborhood in ['001', '010', '100', '111'] Idx 14 requires neighborhood in ['001', '010', '100', '111'] Idx 15 requires neighborhood in ['001', '010', '100', '111'] Idx 16 requires neighborhood in ['001', '010', '100', '111'] Idx 17 requires neighborhood in ['001', '010', '100', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% | 12:50% | 13:50% | 14:50% | 15:50% | 16:50% | 17:50% Greedy Candidate: 111111111111111111 Verification: Mismatch. Correction applied -> 001010100001010010
001010100001010010
deduction
Task: Deduction, Rule: 37 [111->0, 110->0, 101->1, 100->0, 011->0, 010->1, 001->0, 000->1], Steps: 14, Start: 10100001110111011
Step 1 Scan: 0:[110]->0 | 1:[101]->1 | 2:[010]->1 | 3:[100]->0 | 4:[000]->1 | 5:[000]->1 | 6:[001]->0 | 7:[011]->0 | 8:[111]->0 | 9:[110]->0 | 10:[101]->1 | 11:[011]->0 | 12:[111]->0 | 13:[110]->0 | 14:[101]->1 | 15:[011]->0 | 16:[111]->0 Step 1 Output: 01101100001000100 Step 2 Scan: 0:[001]->0 | 1:[011]->0 | 2:[110]->0 | 3:[101]->1 | 4:[011]->0 | 5:[110]->0 | 6:[100]->0 | 7:[000]->1 | 8:[000]->1 | 9:[001]->0 | 10:[010]->1 | 11:[100]->0 | 12:[000]->1 | 13:[001]->0 | 14:[010]->1 | 15:[100]->0 | 16:[000]->1 Step 2 Output: 00010001101010101 Step 3 Scan: 0:[100]->0 | 1:[000]->1 | 2:[001]->0 | 3:[010]->1 | 4:[100]->0 | 5:[000]->1 | 6:[001]->0 | 7:[011]->0 | 8:[110]->0 | 9:[101]->1 | 10:[010]->1 | 11:[101]->1 | 12:[010]->1 | 13:[101]->1 | 14:[010]->1 | 15:[101]->1 | 16:[010]->1 Step 3 Output: 01010100011111111 Step 4 Scan: 0:[101]->1 | 1:[010]->1 | 2:[101]->1 | 3:[010]->1 | 4:[101]->1 | 5:[010]->1 | 6:[100]->0 | 7:[000]->1 | 8:[001]->0 | 9:[011]->0 | 10:[111]->0 | 11:[111]->0 | 12:[111]->0 | 13:[111]->0 | 14:[111]->0 | 15:[111]->0 | 16:[110]->0 Step 4 Output: 11111101000000000 Step 5 Scan: 0:[011]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[111]->0 | 5:[110]->0 | 6:[101]->1 | 7:[010]->1 | 8:[100]->0 | 9:[000]->1 | 10:[000]->1 | 11:[000]->1 | 12:[000]->1 | 13:[000]->1 | 14:[000]->1 | 15:[000]->1 | 16:[001]->0 Step 5 Output: 00000011011111110 Step 6 Scan: 0:[000]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[000]->1 | 5:[001]->0 | 6:[011]->0 | 7:[110]->0 | 8:[101]->1 | 9:[011]->0 | 10:[111]->0 | 11:[111]->0 | 12:[111]->0 | 13:[111]->0 | 14:[111]->0 | 15:[110]->0 | 16:[100]->0 Step 6 Output: 11111000100000000 Step 7 Scan: 0:[011]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[110]->0 | 5:[100]->0 | 6:[000]->1 | 7:[001]->0 | 8:[010]->1 | 9:[100]->0 | 10:[000]->1 | 11:[000]->1 | 12:[000]->1 | 13:[000]->1 | 14:[000]->1 | 15:[000]->1 | 16:[001]->0 Step 7 Output: 00000010101111110 Step 8 Scan: 0:[000]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[000]->1 | 5:[001]->0 | 6:[010]->1 | 7:[101]->1 | 8:[010]->1 | 9:[101]->1 | 10:[011]->0 | 11:[111]->0 | 12:[111]->0 | 13:[111]->0 | 14:[111]->0 | 15:[110]->0 | 16:[100]->0 Step 8 Output: 11111011110000000 Step 9 Scan: 0:[011]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[110]->0 | 5:[101]->1 | 6:[011]->0 | 7:[111]->0 | 8:[111]->0 | 9:[110]->0 | 10:[100]->0 | 11:[000]->1 | 12:[000]->1 | 13:[000]->1 | 14:[000]->1 | 15:[000]->1 | 16:[001]->0 Step 9 Output: 00000100000111110 Step 10 Scan: 0:[000]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[001]->0 | 5:[010]->1 | 6:[100]->0 | 7:[000]->1 | 8:[000]->1 | 9:[000]->1 | 10:[001]->0 | 11:[011]->0 | 12:[111]->0 | 13:[111]->0 | 14:[111]->0 | 15:[110]->0 | 16:[100]->0 Step 10 Output: 11110101110000000 Step 11 Scan: 0:[011]->0 | 1:[111]->0 | 2:[111]->0 | 3:[110]->0 | 4:[101]->1 | 5:[010]->1 | 6:[101]->1 | 7:[011]->0 | 8:[111]->0 | 9:[110]->0 | 10:[100]->0 | 11:[000]->1 | 12:[000]->1 | 13:[000]->1 | 14:[000]->1 | 15:[000]->1 | 16:[001]->0 Step 11 Output: 00001110000111110 Step 12 Scan: 0:[000]->1 | 1:[000]->1 | 2:[000]->1 | 3:[001]->0 | 4:[011]->0 | 5:[111]->0 | 6:[110]->0 | 7:[100]->0 | 8:[000]->1 | 9:[000]->1 | 10:[001]->0 | 11:[011]->0 | 12:[111]->0 | 13:[111]->0 | 14:[111]->0 | 15:[110]->0 | 16:[100]->0 Step 12 Output: 11100000110000000 Step 13 Scan: 0:[011]->0 | 1:[111]->0 | 2:[110]->0 | 3:[100]->0 | 4:[000]->1 | 5:[000]->1 | 6:[000]->1 | 7:[001]->0 | 8:[011]->0 | 9:[110]->0 | 10:[100]->0 | 11:[000]->1 | 12:[000]->1 | 13:[000]->1 | 14:[000]->1 | 15:[000]->1 | 16:[001]->0 Step 13 Output: 00001110000111110 Step 14 Scan: 0:[000]->1 | 1:[000]->1 | 2:[000]->1 | 3:[001]->0 | 4:[011]->0 | 5:[111]->0 | 6:[110]->0 | 7:[100]->0 | 8:[000]->1 | 9:[000]->1 | 10:[001]->0 | 11:[011]->0 | 12:[111]->0 | 13:[111]->0 | 14:[111]->0 | 15:[110]->0 | 16:[100]->0 Step 14 Output: 11100000110000000
11100000110000000
deduction
Task: Deduction, Rule: 147 [111->1, 110->0, 101->0, 100->1, 011->0, 010->0, 001->1, 000->1], Steps: 10, Start: 10001011001100110
Step 1 Scan: 0:[010]->0 | 1:[100]->1 | 2:[000]->1 | 3:[001]->1 | 4:[010]->0 | 5:[101]->0 | 6:[011]->0 | 7:[110]->0 | 8:[100]->1 | 9:[001]->1 | 10:[011]->0 | 11:[110]->0 | 12:[100]->1 | 13:[001]->1 | 14:[011]->0 | 15:[110]->0 | 16:[101]->0 Step 1 Output: 01110000110011000 Step 2 Scan: 0:[001]->1 | 1:[011]->0 | 2:[111]->1 | 3:[110]->0 | 4:[100]->1 | 5:[000]->1 | 6:[000]->1 | 7:[001]->1 | 8:[011]->0 | 9:[110]->0 | 10:[100]->1 | 11:[001]->1 | 12:[011]->0 | 13:[110]->0 | 14:[100]->1 | 15:[000]->1 | 16:[000]->1 Step 2 Output: 10101111001100111 Step 3 Scan: 0:[110]->0 | 1:[101]->0 | 2:[010]->0 | 3:[101]->0 | 4:[011]->0 | 5:[111]->1 | 6:[111]->1 | 7:[110]->0 | 8:[100]->1 | 9:[001]->1 | 10:[011]->0 | 11:[110]->0 | 12:[100]->1 | 13:[001]->1 | 14:[011]->0 | 15:[111]->1 | 16:[111]->1 Step 3 Output: 00000110110011011 Step 4 Scan: 0:[100]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[001]->1 | 5:[011]->0 | 6:[110]->0 | 7:[101]->0 | 8:[011]->0 | 9:[110]->0 | 10:[100]->1 | 11:[001]->1 | 12:[011]->0 | 13:[110]->0 | 14:[101]->0 | 15:[011]->0 | 16:[110]->0 Step 4 Output: 11111000001100000 Step 5 Scan: 0:[011]->0 | 1:[111]->1 | 2:[111]->1 | 3:[111]->1 | 4:[110]->0 | 5:[100]->1 | 6:[000]->1 | 7:[000]->1 | 8:[000]->1 | 9:[001]->1 | 10:[011]->0 | 11:[110]->0 | 12:[100]->1 | 13:[000]->1 | 14:[000]->1 | 15:[000]->1 | 16:[001]->1 Step 5 Output: 01110111110011111 Step 6 Scan: 0:[101]->0 | 1:[011]->0 | 2:[111]->1 | 3:[110]->0 | 4:[101]->0 | 5:[011]->0 | 6:[111]->1 | 7:[111]->1 | 8:[111]->1 | 9:[110]->0 | 10:[100]->1 | 11:[001]->1 | 12:[011]->0 | 13:[111]->1 | 14:[111]->1 | 15:[111]->1 | 16:[110]->0 Step 6 Output: 00100011101101110 Step 7 Scan: 0:[000]->1 | 1:[001]->1 | 2:[010]->0 | 3:[100]->1 | 4:[000]->1 | 5:[001]->1 | 6:[011]->0 | 7:[111]->1 | 8:[110]->0 | 9:[101]->0 | 10:[011]->0 | 11:[110]->0 | 12:[101]->0 | 13:[011]->0 | 14:[111]->1 | 15:[110]->0 | 16:[100]->1 Step 7 Output: 11011101000000101 Step 8 Scan: 0:[111]->1 | 1:[110]->0 | 2:[101]->0 | 3:[011]->0 | 4:[111]->1 | 5:[110]->0 | 6:[101]->0 | 7:[010]->0 | 8:[100]->1 | 9:[000]->1 | 10:[000]->1 | 11:[000]->1 | 12:[000]->1 | 13:[001]->1 | 14:[010]->0 | 15:[101]->0 | 16:[011]->0 Step 8 Output: 10001000111111000 Step 9 Scan: 0:[010]->0 | 1:[100]->1 | 2:[000]->1 | 3:[001]->1 | 4:[010]->0 | 5:[100]->1 | 6:[000]->1 | 7:[001]->1 | 8:[011]->0 | 9:[111]->1 | 10:[111]->1 | 11:[111]->1 | 12:[111]->1 | 13:[110]->0 | 14:[100]->1 | 15:[000]->1 | 16:[001]->1 Step 9 Output: 01110111011110111 Step 10 Scan: 0:[101]->0 | 1:[011]->0 | 2:[111]->1 | 3:[110]->0 | 4:[101]->0 | 5:[011]->0 | 6:[111]->1 | 7:[110]->0 | 8:[101]->0 | 9:[011]->0 | 10:[111]->1 | 11:[111]->1 | 12:[110]->0 | 13:[101]->0 | 14:[011]->0 | 15:[111]->1 | 16:[110]->0 Step 10 Output: 00100010001100010
00100010001100010
abduction
Task: Abduction, Rule: 106 [111->0, 110->1, 101->1, 100->0, 011->1, 010->0, 001->1, 000->0], Steps: 3, End: 010100011110111110
Goal: Reverse 3 steps by calculating likelihoods of priors. Step -1: Inverting state 010100011110111110 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '010', '100', '111'] Idx 1 requires neighborhood in ['001', '011', '101', '110'] Idx 2 requires neighborhood in ['000', '010', '100', '111'] Idx 3 requires neighborhood in ['001', '011', '101', '110'] Idx 4 requires neighborhood in ['000', '010', '100', '111'] Idx 5 requires neighborhood in ['000', '010', '100', '111'] Idx 6 requires neighborhood in ['000', '010', '100', '111'] Idx 7 requires neighborhood in ['001', '011', '101', '110'] Idx 8 requires neighborhood in ['001', '011', '101', '110'] Idx 9 requires neighborhood in ['001', '011', '101', '110'] Idx 10 requires neighborhood in ['001', '011', '101', '110'] Idx 11 requires neighborhood in ['000', '010', '100', '111'] Idx 12 requires neighborhood in ['001', '011', '101', '110'] Idx 13 requires neighborhood in ['001', '011', '101', '110'] Idx 14 requires neighborhood in ['001', '011', '101', '110'] Idx 15 requires neighborhood in ['001', '011', '101', '110'] Idx 16 requires neighborhood in ['001', '011', '101', '110'] Idx 17 requires neighborhood in ['000', '010', '100', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:41% | 1:41% | 2:58% | 3:41% | 4:58% | 5:41% | 6:41% | 7:41% | 8:58% | 9:58% | 10:58% | 11:58% | 12:41% | 13:58% | 14:58% | 15:58% | 16:58% | 17:58% Greedy Candidate: 001010001111011111 Verification: Mismatch. Correction applied -> 110010001101011011 Step -2: Inverting state 110010001101011011 Calculating Local Priors: Idx 0 requires neighborhood in ['001', '011', '101', '110'] Idx 1 requires neighborhood in ['001', '011', '101', '110'] Idx 2 requires neighborhood in ['000', '010', '100', '111'] Idx 3 requires neighborhood in ['000', '010', '100', '111'] Idx 4 requires neighborhood in ['001', '011', '101', '110'] Idx 5 requires neighborhood in ['000', '010', '100', '111'] Idx 6 requires neighborhood in ['000', '010', '100', '111'] Idx 7 requires neighborhood in ['000', '010', '100', '111'] Idx 8 requires neighborhood in ['001', '011', '101', '110'] Idx 9 requires neighborhood in ['001', '011', '101', '110'] Idx 10 requires neighborhood in ['000', '010', '100', '111'] Idx 11 requires neighborhood in ['001', '011', '101', '110'] Idx 12 requires neighborhood in ['000', '010', '100', '111'] Idx 13 requires neighborhood in ['001', '011', '101', '110'] Idx 14 requires neighborhood in ['001', '011', '101', '110'] Idx 15 requires neighborhood in ['000', '010', '100', '111'] Idx 16 requires neighborhood in ['001', '011', '101', '110'] Idx 17 requires neighborhood in ['001', '011', '101', '110'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:58% | 1:58% | 2:58% | 3:41% | 4:41% | 5:58% | 6:41% | 7:41% | 8:41% | 9:58% | 10:58% | 11:41% | 12:58% | 13:41% | 14:58% | 15:58% | 16:41% | 17:58% Greedy Candidate: 111001000110101101 Verification: Mismatch. Correction applied -> 110001000111001110 Step -3: Inverting state 110001000111001110 Calculating Local Priors: Idx 0 requires neighborhood in ['001', '011', '101', '110'] Idx 1 requires neighborhood in ['001', '011', '101', '110'] Idx 2 requires neighborhood in ['000', '010', '100', '111'] Idx 3 requires neighborhood in ['000', '010', '100', '111'] Idx 4 requires neighborhood in ['000', '010', '100', '111'] Idx 5 requires neighborhood in ['001', '011', '101', '110'] Idx 6 requires neighborhood in ['000', '010', '100', '111'] Idx 7 requires neighborhood in ['000', '010', '100', '111'] Idx 8 requires neighborhood in ['000', '010', '100', '111'] Idx 9 requires neighborhood in ['001', '011', '101', '110'] Idx 10 requires neighborhood in ['001', '011', '101', '110'] Idx 11 requires neighborhood in ['001', '011', '101', '110'] Idx 12 requires neighborhood in ['000', '010', '100', '111'] Idx 13 requires neighborhood in ['000', '010', '100', '111'] Idx 14 requires neighborhood in ['001', '011', '101', '110'] Idx 15 requires neighborhood in ['001', '011', '101', '110'] Idx 16 requires neighborhood in ['001', '011', '101', '110'] Idx 17 requires neighborhood in ['000', '010', '100', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:41% | 1:58% | 2:58% | 3:41% | 4:41% | 5:41% | 6:58% | 7:41% | 8:41% | 9:41% | 10:58% | 11:58% | 12:58% | 13:41% | 14:41% | 15:58% | 16:58% | 17:58% Greedy Candidate: 011000100011100111 Verification: Mismatch. Correction applied -> 011111000011000110
011111000011000110
induction
Task: Induction, Start: 01100011101000, End: 00111111110000, Steps: 15, Hint: Class 3
Task: Find rule in Class 3. Candidates: [105, 150, 60, 90, 30, 126, 45] Attempt 1: Testing Rule 105 [111->0, 110->1, 101->1, 100->0, 011->1, 010->0, 001->0, 000->1] Sim Step 1: 01101010110011 Sim Step 2: 11110101110011 Sim Step 3: 00011011010010 Sim Step 4: 11011111100000 Sim Step 5: 11110000101110 Sim Step 6: 10010110011011 Sim Step 7: 10001110011110 Sim Step 8: 00101010010011 Sim Step 9: 00010100000011 Sim Step 10: 01001001111011 Sim Step 11: 10000001001111 Sim Step 12: 10111100001000 Sim Step 13: 01100101100010 Sim Step 14: 01100011101000 Sim Step 15: 01101010110011 Verification: Mismatch (Expected 00111111110000). Next... Attempt 2: Testing Rule 150 [111->1, 110->0, 101->0, 100->1, 011->0, 010->1, 001->1, 000->0] Sim Step 1: 10010101001100 Sim Step 2: 11110101110011 Sim Step 3: 11100100101101 Sim Step 4: 11011111100000 Sim Step 5: 00001111010001 Sim Step 6: 10010110011011 Sim Step 7: 01110001100001 Sim Step 8: 00101010010011 Sim Step 9: 11101011111100 Sim Step 10: 01001001111011 Sim Step 11: 01111110110000 Sim Step 12: 10111100001000 Sim Step 13: 10011010011101 Sim Step 14: 01100011101000 Sim Step 15: 10010101001100 Verification: Mismatch (Expected 00111111110000). Next... Attempt 3: Testing Rule 60 [111->0, 110->0, 101->1, 100->1, 011->1, 010->1, 001->0, 000->0] Sim Step 1: 01010010011100 Sim Step 2: 01111011010010 Sim Step 3: 01000110111011 Sim Step 4: 11100101100110 Sim Step 5: 10010111010101 Sim Step 6: 01011100111111 Sim Step 7: 11110010100000 Sim Step 8: 10001011110000 Sim Step 9: 11001110001000 Sim Step 10: 10101001001100 Sim Step 11: 11111101101010 Sim Step 12: 10000011011111 Sim Step 13: 01000010110000 Sim Step 14: 01100011101000 Sim Step 15: 01010010011100 Verification: Mismatch (Expected 00111111110000). Next... Attempt 4: Testing Rule 90 [111->0, 110->1, 101->0, 100->1, 011->1, 010->0, 001->1, 000->0] Sim Step 1: 11110110100100 Sim Step 2: 10010110011011 Sim Step 3: 11100111111010 Sim Step 4: 10111100001000 Sim Step 5: 00100110010101 Sim Step 6: 11011111100000 Sim Step 7: 11010000110001 Sim Step 8: 01001001111011 Sim Step 9: 00110111001011 Sim Step 10: 11110101110011 Sim Step 11: 00010001011110 Sim Step 12: 00101010010011 Sim Step 13: 11000001101111 Sim Step 14: 01100011101000 Sim Step 15: 11110110100100 Verification: Mismatch (Expected 00111111110000). Next... Attempt 5: Testing Rule 30 [111->0, 110->0, 101->0, 100->1, 011->1, 010->1, 001->1, 000->0] Sim Step 1: 11010110001100 Sim Step 2: 10010101011011 Sim Step 3: 01110101010010 Sim Step 4: 11000101011111 Sim Step 5: 00101101010000 Sim Step 6: 01101001011000 Sim Step 7: 11001111010100 Sim Step 8: 10111000010111 Sim Step 9: 00100100110100 Sim Step 10: 01111111100110 Sim Step 11: 11000000011101 Sim Step 12: 00100000110001 Sim Step 13: 11110001101011 Sim Step 14: 00001011001010 Sim Step 15: 00011010111011 Verification: Mismatch (Expected 00111111110000). Next... Attempt 6: Testing Rule 126 [111->0, 110->1, 101->1, 100->1, 011->1, 010->1, 001->1, 000->0] Sim Step 1: 11110110111100 Sim Step 2: 10011111100111 Sim Step 3: 11110000111100 Sim Step 4: 10011001100111 Sim Step 5: 11111111111100 Sim Step 6: 10000000000111 Sim Step 7: 11000000001100 Sim Step 8: 11100000011111 Sim Step 9: 00110000110000 Sim Step 10: 01111001111000 Sim Step 11: 11001111001100 Sim Step 12: 11111001111111 Sim Step 13: 00001111000000 Sim Step 14: 00011001100000 Sim Step 15: 00111111110000 Verification: Exact Match. Rule Confirmed.
111->0, 110->1, 101->1, 100->1, 011->1, 010->1, 001->1, 000->0
induction
Task: Induction, Start: 00101111100100111, End: 00010111011111110, Steps: 12, Hint: Class 4
Task: Find rule in Class 4. Candidates: [137, 54, 193, 110, 124, 147, 106] Attempt 1: Testing Rule 137 [111->1, 110->0, 101->0, 100->0, 011->1, 010->0, 001->0, 000->1] Sim Step 1: 00001111000000110 Sim Step 2: 11101110011110100 Sim Step 3: 11001100011100000 Sim Step 4: 10001001011001110 Sim Step 5: 00100000010001100 Sim Step 6: 10001111000101001 Sim Step 7: 00101110010000001 Sim Step 8: 00001100000111100 Sim Step 9: 11101001110111001 Sim Step 10: 11000001100110001 Sim Step 11: 10011101000100101 Sim Step 12: 00011000010000001 Verification: Mismatch (Expected 00010111011111110). Next... Attempt 2: Testing Rule 54 [111->0, 110->0, 101->1, 100->1, 011->0, 010->1, 001->1, 000->0] Sim Step 1: 11110000011111000 Sim Step 2: 00001000100000101 Sim Step 3: 10011101110001111 Sim Step 4: 01100010001010000 Sim Step 5: 10010111011111000 Sim Step 6: 11111000100000101 Sim Step 7: 00000101110001110 Sim Step 8: 00001110001010001 Sim Step 9: 10010001011111011 Sim Step 10: 01111011100000100 Sim Step 11: 10000100010001110 Sim Step 12: 11001110111010001 Verification: Mismatch (Expected 00010111011111110). Next... Attempt 3: Testing Rule 193 [111->1, 110->1, 101->0, 100->0, 011->0, 010->0, 001->0, 000->1] Sim Step 1: 00000111100000011 Sim Step 2: 01110011101111001 Sim Step 3: 00110001100111000 Sim Step 4: 10010100100011011 Sim Step 5: 10000000001001001 Sim Step 6: 10111111100000000 Sim Step 7: 00011111101111110 Sim Step 8: 11001111100111110 Sim Step 9: 01000111100011110 Sim Step 10: 00010011101001110 Sim Step 11: 11000001100000110 Sim Step 12: 01011100101110010 Verification: Mismatch (Expected 00010111011111110). Next... Attempt 4: Testing Rule 110 [111->0, 110->1, 101->1, 100->0, 011->1, 010->1, 001->1, 000->0] Sim Step 1: 01111000101101101 Sim Step 2: 11001001111111111 Sim Step 3: 01011011000000000 Sim Step 4: 11111111000000000 Sim Step 5: 10000001000000001 Sim Step 6: 10000011000000011 Sim Step 7: 10000111000000110 Sim Step 8: 10001101000001111 Sim Step 9: 10011111000011000 Sim Step 10: 10110001000111001 Sim Step 11: 11110011001101011 Sim Step 12: 00010111011111110 Verification: Exact Match. Rule Confirmed.
111->0, 110->1, 101->1, 100->0, 011->1, 010->1, 001->1, 000->0
deduction
Task: Deduction, Rule: 105 [111->0, 110->1, 101->1, 100->0, 011->1, 010->0, 001->0, 000->1], Steps: 12, Start: 001000000010101
Step 1 Scan: 0:[100]->0 | 1:[001]->0 | 2:[010]->0 | 3:[100]->0 | 4:[000]->1 | 5:[000]->1 | 6:[000]->1 | 7:[000]->1 | 8:[000]->1 | 9:[001]->0 | 10:[010]->0 | 11:[101]->1 | 12:[010]->0 | 13:[101]->1 | 14:[010]->0 Step 1 Output: 000011111001010 Step 2 Scan: 0:[000]->1 | 1:[000]->1 | 2:[000]->1 | 3:[001]->0 | 4:[011]->1 | 5:[111]->0 | 6:[111]->0 | 7:[111]->0 | 8:[110]->1 | 9:[100]->0 | 10:[001]->0 | 11:[010]->0 | 12:[101]->1 | 13:[010]->0 | 14:[100]->0 Step 2 Output: 111010001000100 Step 3 Scan: 0:[011]->1 | 1:[111]->0 | 2:[110]->1 | 3:[101]->1 | 4:[010]->0 | 5:[100]->0 | 6:[000]->1 | 7:[001]->0 | 8:[010]->0 | 9:[100]->0 | 10:[000]->1 | 11:[001]->0 | 12:[010]->0 | 13:[100]->0 | 14:[001]->0 Step 3 Output: 101100100010000 Step 4 Scan: 0:[010]->0 | 1:[101]->1 | 2:[011]->1 | 3:[110]->1 | 4:[100]->0 | 5:[001]->0 | 6:[010]->0 | 7:[100]->0 | 8:[000]->1 | 9:[001]->0 | 10:[010]->0 | 11:[100]->0 | 12:[000]->1 | 13:[000]->1 | 14:[001]->0 Step 4 Output: 011100001000110 Step 5 Scan: 0:[001]->0 | 1:[011]->1 | 2:[111]->0 | 3:[110]->1 | 4:[100]->0 | 5:[000]->1 | 6:[000]->1 | 7:[001]->0 | 8:[010]->0 | 9:[100]->0 | 10:[000]->1 | 11:[001]->0 | 12:[011]->1 | 13:[110]->1 | 14:[100]->0 Step 5 Output: 010101100010110 Step 6 Scan: 0:[001]->0 | 1:[010]->0 | 2:[101]->1 | 3:[010]->0 | 4:[101]->1 | 5:[011]->1 | 6:[110]->1 | 7:[100]->0 | 8:[000]->1 | 9:[001]->0 | 10:[010]->0 | 11:[101]->1 | 12:[011]->1 | 13:[110]->1 | 14:[100]->0 Step 6 Output: 001011101001110 Step 7 Scan: 0:[000]->1 | 1:[001]->0 | 2:[010]->0 | 3:[101]->1 | 4:[011]->1 | 5:[111]->0 | 6:[110]->1 | 7:[101]->1 | 8:[010]->0 | 9:[100]->0 | 10:[001]->0 | 11:[011]->1 | 12:[111]->0 | 13:[110]->1 | 14:[100]->0 Step 7 Output: 100110110001010 Step 8 Scan: 0:[010]->0 | 1:[100]->0 | 2:[001]->0 | 3:[011]->1 | 4:[110]->1 | 5:[101]->1 | 6:[011]->1 | 7:[110]->1 | 8:[100]->0 | 9:[000]->1 | 10:[001]->0 | 11:[010]->0 | 12:[101]->1 | 13:[010]->0 | 14:[101]->1 Step 8 Output: 000111110100101 Step 9 Scan: 0:[100]->0 | 1:[000]->1 | 2:[001]->0 | 3:[011]->1 | 4:[111]->0 | 5:[111]->0 | 6:[111]->0 | 7:[110]->1 | 8:[101]->1 | 9:[010]->0 | 10:[100]->0 | 11:[001]->0 | 12:[010]->0 | 13:[101]->1 | 14:[010]->0 Step 9 Output: 010100011000010 Step 10 Scan: 0:[001]->0 | 1:[010]->0 | 2:[101]->1 | 3:[010]->0 | 4:[100]->0 | 5:[000]->1 | 6:[001]->0 | 7:[011]->1 | 8:[110]->1 | 9:[100]->0 | 10:[000]->1 | 11:[000]->1 | 12:[001]->0 | 13:[010]->0 | 14:[100]->0 Step 10 Output: 001001011011000 Step 11 Scan: 0:[000]->1 | 1:[001]->0 | 2:[010]->0 | 3:[100]->0 | 4:[001]->0 | 5:[010]->0 | 6:[101]->1 | 7:[011]->1 | 8:[110]->1 | 9:[101]->1 | 10:[011]->1 | 11:[110]->1 | 12:[100]->0 | 13:[000]->1 | 14:[000]->1 Step 11 Output: 100000111111011 Step 12 Scan: 0:[110]->1 | 1:[100]->0 | 2:[000]->1 | 3:[000]->1 | 4:[000]->1 | 5:[001]->0 | 6:[011]->1 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[110]->1 | 12:[101]->1 | 13:[011]->1 | 14:[111]->0 Step 12 Output: 101110100001110
101110100001110
induction
Task: Induction, Start: 101001111011, End: 000001110001, Steps: 11, Hint: Class 4
Task: Find rule in Class 4. Candidates: [54, 110, 147, 124, 137, 106, 193] Attempt 1: Testing Rule 54 [111->0, 110->0, 101->1, 100->1, 011->0, 010->1, 001->1, 000->0] Sim Step 1: 011110000100 Sim Step 2: 100001001110 Sim Step 3: 110011110001 Sim Step 4: 001100001010 Sim Step 5: 010010011111 Sim Step 6: 111111100000 Sim Step 7: 000000010001 Sim Step 8: 100000111011 Sim Step 9: 010001000100 Sim Step 10: 111011101110 Sim Step 11: 000100010001 Verification: Mismatch (Expected 000001110001). Next... Attempt 2: Testing Rule 110 [111->0, 110->1, 101->1, 100->0, 011->1, 010->1, 001->1, 000->0] Sim Step 1: 111011001110 Sim Step 2: 101111011011 Sim Step 3: 111001111110 Sim Step 4: 101011000011 Sim Step 5: 111111000110 Sim Step 6: 100001001111 Sim Step 7: 100011011000 Sim Step 8: 100111111001 Sim Step 9: 101100001011 Sim Step 10: 111100011110 Sim Step 11: 100100110011 Verification: Mismatch (Expected 000001110001). Next... Attempt 3: Testing Rule 147 [111->1, 110->0, 101->0, 100->1, 011->0, 010->0, 001->1, 000->1] Sim Step 1: 000110110001 Sim Step 2: 111000001110 Sim Step 3: 010111110100 Sim Step 4: 100011100011 Sim Step 5: 011101011101 Sim Step 6: 001000001000 Sim Step 7: 110111110111 Sim Step 8: 100011100011 Sim Step 9: 011101011101 Sim Step 10: 001000001000 Sim Step 11: 110111110111 Verification: Mismatch (Expected 000001110001). Next... Attempt 4: Testing Rule 124 [111->0, 110->1, 101->1, 100->1, 011->1, 010->1, 001->0, 000->0] Sim Step 1: 111101001110 Sim Step 2: 100111101011 Sim Step 3: 110100111110 Sim Step 4: 111110100011 Sim Step 5: 000011110010 Sim Step 6: 000010011011 Sim Step 7: 100011011111 Sim Step 8: 110011110000 Sim Step 9: 111010011000 Sim Step 10: 101111011100 Sim Step 11: 111001110110 Verification: Mismatch (Expected 000001110001). Next... Attempt 5: Testing Rule 137 [111->1, 110->0, 101->0, 100->0, 011->1, 010->0, 001->0, 000->1] Sim Step 1: 000001110011 Sim Step 2: 011101100010 Sim Step 3: 011001001000 Sim Step 4: 010000000011 Sim Step 5: 000111111010 Sim Step 6: 110111110000 Sim Step 7: 100111100110 Sim Step 8: 000111000100 Sim Step 9: 110110010001 Sim Step 10: 100100000101 Sim Step 11: 000001110001 Verification: Exact Match. Rule Confirmed.
111->1, 110->0, 101->0, 100->0, 011->1, 010->0, 001->0, 000->1
induction
Task: Induction, Start: 001000110011, End: 111111001100, Steps: 13, Hint: Class 2
Task: Find rule in Class 2. Candidates: [37, 23, 19, 1, 108, 29, 178, 50] Attempt 1: Testing Rule 37 [111->0, 110->0, 101->1, 100->0, 011->0, 010->1, 001->0, 000->1] Sim Step 1: 001010000000 Sim Step 2: 101110111111 Sim Step 3: 010001000000 Sim Step 4: 010101011111 Sim Step 5: 111111100000 Sim Step 6: 000000001110 Sim Step 7: 111111100000 Sim Step 8: 000000001110 Sim Step 9: 111111100000 Sim Step 10: 000000001110 Sim Step 11: 111111100000 Sim Step 12: 000000001110 Sim Step 13: 111111100000 Verification: Mismatch (Expected 111111001100). Next... Attempt 2: Testing Rule 23 [111->0, 110->0, 101->0, 100->1, 011->0, 010->1, 001->1, 000->1] Sim Step 1: 111111001100 Sim Step 2: 000000110011 Sim Step 3: 111111001100 Sim Step 4: 000000110011 Sim Step 5: 111111001100 Sim Step 6: 000000110011 Sim Step 7: 111111001100 Sim Step 8: 000000110011 Sim Step 9: 111111001100 Sim Step 10: 000000110011 Sim Step 11: 111111001100 Sim Step 12: 000000110011 Sim Step 13: 111111001100 Verification: Exact Match. Rule Confirmed.
111->0, 110->0, 101->0, 100->1, 011->0, 010->1, 001->1, 000->1
abduction
Task: Abduction, Rule: 37 [111->0, 110->0, 101->1, 100->0, 011->0, 010->1, 001->0, 000->1], Steps: 2, End: 011101000000011
Goal: Reverse 2 steps by calculating likelihoods of priors. Step -1: Inverting state 011101000000011 Calculating Local Priors: Idx 0 requires neighborhood in ['001', '011', '100', '110', '111'] Idx 1 requires neighborhood in ['000', '010', '101'] Idx 2 requires neighborhood in ['000', '010', '101'] Idx 3 requires neighborhood in ['000', '010', '101'] Idx 4 requires neighborhood in ['001', '011', '100', '110', '111'] Idx 5 requires neighborhood in ['000', '010', '101'] Idx 6 requires neighborhood in ['001', '011', '100', '110', '111'] Idx 7 requires neighborhood in ['001', '011', '100', '110', '111'] Idx 8 requires neighborhood in ['001', '011', '100', '110', '111'] Idx 9 requires neighborhood in ['001', '011', '100', '110', '111'] Idx 10 requires neighborhood in ['001', '011', '100', '110', '111'] Idx 11 requires neighborhood in ['001', '011', '100', '110', '111'] Idx 12 requires neighborhood in ['001', '011', '100', '110', '111'] Idx 13 requires neighborhood in ['000', '010', '101'] Idx 14 requires neighborhood in ['000', '010', '101'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:45% | 1:45% | 2:33% | 3:45% | 4:45% | 5:53% | 6:53% | 7:60% | 8:60% | 9:60% | 10:60% | 11:60% | 12:53% | 13:45% | 14:45% Greedy Candidate: 000001111111100 Verification: Mismatch. Correction applied -> 010100011111000 Step -2: Inverting state 010100011111000 Calculating Local Priors: Idx 0 requires neighborhood in ['001', '011', '100', '110', '111'] Idx 1 requires neighborhood in ['000', '010', '101'] Idx 2 requires neighborhood in ['001', '011', '100', '110', '111'] Idx 3 requires neighborhood in ['000', '010', '101'] Idx 4 requires neighborhood in ['001', '011', '100', '110', '111'] Idx 5 requires neighborhood in ['001', '011', '100', '110', '111'] Idx 6 requires neighborhood in ['001', '011', '100', '110', '111'] Idx 7 requires neighborhood in ['000', '010', '101'] Idx 8 requires neighborhood in ['000', '010', '101'] Idx 9 requires neighborhood in ['000', '010', '101'] Idx 10 requires neighborhood in ['000', '010', '101'] Idx 11 requires neighborhood in ['000', '010', '101'] Idx 12 requires neighborhood in ['001', '011', '100', '110', '111'] Idx 13 requires neighborhood in ['001', '011', '100', '110', '111'] Idx 14 requires neighborhood in ['001', '011', '100', '110', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:53% | 1:53% | 2:45% | 3:53% | 4:53% | 5:60% | 6:53% | 7:45% | 8:33% | 9:33% | 10:33% | 11:45% | 12:53% | 13:60% | 14:60% Greedy Candidate: 110111100000111 Verification: Mismatch. Correction applied -> 010001101010110
010001101010110
deduction
Task: Deduction, Rule: 23 [111->0, 110->0, 101->0, 100->1, 011->0, 010->1, 001->1, 000->1], Steps: 13, Start: 01110111100110011
Step 1 Scan: 0:[101]->0 | 1:[011]->0 | 2:[111]->0 | 3:[110]->0 | 4:[101]->0 | 5:[011]->0 | 6:[111]->0 | 7:[111]->0 | 8:[110]->0 | 9:[100]->1 | 10:[001]->1 | 11:[011]->0 | 12:[110]->0 | 13:[100]->1 | 14:[001]->1 | 15:[011]->0 | 16:[110]->0 Step 1 Output: 00000000011001100 Step 2 Scan: 0:[000]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[000]->1 | 5:[000]->1 | 6:[000]->1 | 7:[000]->1 | 8:[001]->1 | 9:[011]->0 | 10:[110]->0 | 11:[100]->1 | 12:[001]->1 | 13:[011]->0 | 14:[110]->0 | 15:[100]->1 | 16:[000]->1 Step 2 Output: 11111111100110011 Step 3 Scan: 0:[111]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[111]->0 | 5:[111]->0 | 6:[111]->0 | 7:[111]->0 | 8:[110]->0 | 9:[100]->1 | 10:[001]->1 | 11:[011]->0 | 12:[110]->0 | 13:[100]->1 | 14:[001]->1 | 15:[011]->0 | 16:[111]->0 Step 3 Output: 00000000011001100 Step 4 Scan: 0:[000]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[000]->1 | 5:[000]->1 | 6:[000]->1 | 7:[000]->1 | 8:[001]->1 | 9:[011]->0 | 10:[110]->0 | 11:[100]->1 | 12:[001]->1 | 13:[011]->0 | 14:[110]->0 | 15:[100]->1 | 16:[000]->1 Step 4 Output: 11111111100110011 Step 5 Scan: 0:[111]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[111]->0 | 5:[111]->0 | 6:[111]->0 | 7:[111]->0 | 8:[110]->0 | 9:[100]->1 | 10:[001]->1 | 11:[011]->0 | 12:[110]->0 | 13:[100]->1 | 14:[001]->1 | 15:[011]->0 | 16:[111]->0 Step 5 Output: 00000000011001100 Step 6 Scan: 0:[000]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[000]->1 | 5:[000]->1 | 6:[000]->1 | 7:[000]->1 | 8:[001]->1 | 9:[011]->0 | 10:[110]->0 | 11:[100]->1 | 12:[001]->1 | 13:[011]->0 | 14:[110]->0 | 15:[100]->1 | 16:[000]->1 Step 6 Output: 11111111100110011 Step 7 Scan: 0:[111]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[111]->0 | 5:[111]->0 | 6:[111]->0 | 7:[111]->0 | 8:[110]->0 | 9:[100]->1 | 10:[001]->1 | 11:[011]->0 | 12:[110]->0 | 13:[100]->1 | 14:[001]->1 | 15:[011]->0 | 16:[111]->0 Step 7 Output: 00000000011001100 Step 8 Scan: 0:[000]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[000]->1 | 5:[000]->1 | 6:[000]->1 | 7:[000]->1 | 8:[001]->1 | 9:[011]->0 | 10:[110]->0 | 11:[100]->1 | 12:[001]->1 | 13:[011]->0 | 14:[110]->0 | 15:[100]->1 | 16:[000]->1 Step 8 Output: 11111111100110011 Step 9 Scan: 0:[111]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[111]->0 | 5:[111]->0 | 6:[111]->0 | 7:[111]->0 | 8:[110]->0 | 9:[100]->1 | 10:[001]->1 | 11:[011]->0 | 12:[110]->0 | 13:[100]->1 | 14:[001]->1 | 15:[011]->0 | 16:[111]->0 Step 9 Output: 00000000011001100 Step 10 Scan: 0:[000]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[000]->1 | 5:[000]->1 | 6:[000]->1 | 7:[000]->1 | 8:[001]->1 | 9:[011]->0 | 10:[110]->0 | 11:[100]->1 | 12:[001]->1 | 13:[011]->0 | 14:[110]->0 | 15:[100]->1 | 16:[000]->1 Step 10 Output: 11111111100110011 Step 11 Scan: 0:[111]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[111]->0 | 5:[111]->0 | 6:[111]->0 | 7:[111]->0 | 8:[110]->0 | 9:[100]->1 | 10:[001]->1 | 11:[011]->0 | 12:[110]->0 | 13:[100]->1 | 14:[001]->1 | 15:[011]->0 | 16:[111]->0 Step 11 Output: 00000000011001100 Step 12 Scan: 0:[000]->1 | 1:[000]->1 | 2:[000]->1 | 3:[000]->1 | 4:[000]->1 | 5:[000]->1 | 6:[000]->1 | 7:[000]->1 | 8:[001]->1 | 9:[011]->0 | 10:[110]->0 | 11:[100]->1 | 12:[001]->1 | 13:[011]->0 | 14:[110]->0 | 15:[100]->1 | 16:[000]->1 Step 12 Output: 11111111100110011 Step 13 Scan: 0:[111]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[111]->0 | 5:[111]->0 | 6:[111]->0 | 7:[111]->0 | 8:[110]->0 | 9:[100]->1 | 10:[001]->1 | 11:[011]->0 | 12:[110]->0 | 13:[100]->1 | 14:[001]->1 | 15:[011]->0 | 16:[111]->0 Step 13 Output: 00000000011001100
00000000011001100
abduction
Task: Abduction, Rule: 168 [111->1, 110->0, 101->1, 100->0, 011->1, 010->0, 001->0, 000->0], Steps: 2, End: 0000001101010
Goal: Reverse 2 steps by calculating likelihoods of priors. Step -1: Inverting state 0000001101010 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '001', '010', '100', '110'] Idx 1 requires neighborhood in ['000', '001', '010', '100', '110'] Idx 2 requires neighborhood in ['000', '001', '010', '100', '110'] Idx 3 requires neighborhood in ['000', '001', '010', '100', '110'] Idx 4 requires neighborhood in ['000', '001', '010', '100', '110'] Idx 5 requires neighborhood in ['000', '001', '010', '100', '110'] Idx 6 requires neighborhood in ['011', '101', '111'] Idx 7 requires neighborhood in ['011', '101', '111'] Idx 8 requires neighborhood in ['000', '001', '010', '100', '110'] Idx 9 requires neighborhood in ['011', '101', '111'] Idx 10 requires neighborhood in ['000', '001', '010', '100', '110'] Idx 11 requires neighborhood in ['011', '101', '111'] Idx 12 requires neighborhood in ['000', '001', '010', '100', '110'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:33% | 1:33% | 2:33% | 3:33% | 4:33% | 5:38% | 6:45% | 7:63% | 8:63% | 9:38% | 10:63% | 11:38% | 12:53% Greedy Candidate: 0000000110101 Verification: Mismatch. Correction applied -> 0000001110101 Step -2: Inverting state 0000001110101 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '001', '010', '100', '110'] Idx 1 requires neighborhood in ['000', '001', '010', '100', '110'] Idx 2 requires neighborhood in ['000', '001', '010', '100', '110'] Idx 3 requires neighborhood in ['000', '001', '010', '100', '110'] Idx 4 requires neighborhood in ['000', '001', '010', '100', '110'] Idx 5 requires neighborhood in ['000', '001', '010', '100', '110'] Idx 6 requires neighborhood in ['011', '101', '111'] Idx 7 requires neighborhood in ['011', '101', '111'] Idx 8 requires neighborhood in ['011', '101', '111'] Idx 9 requires neighborhood in ['000', '001', '010', '100', '110'] Idx 10 requires neighborhood in ['011', '101', '111'] Idx 11 requires neighborhood in ['000', '001', '010', '100', '110'] Idx 12 requires neighborhood in ['011', '101', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:53% | 1:33% | 2:33% | 3:33% | 4:33% | 5:38% | 6:45% | 7:77% | 8:63% | 9:63% | 10:38% | 11:63% | 12:38% Greedy Candidate: 1000000111010 Verification: Mismatch. Correction applied -> 1000010111010
1000010111010
deduction
Task: Deduction, Rule: 54 [111->0, 110->0, 101->1, 100->1, 011->0, 010->1, 001->1, 000->0], Steps: 14, Start: 110100010110010001
Step 1 Scan: 0:[111]->0 | 1:[110]->0 | 2:[101]->1 | 3:[010]->1 | 4:[100]->1 | 5:[000]->0 | 6:[001]->1 | 7:[010]->1 | 8:[101]->1 | 9:[011]->0 | 10:[110]->0 | 11:[100]->1 | 12:[001]->1 | 13:[010]->1 | 14:[100]->1 | 15:[000]->0 | 16:[001]->1 | 17:[011]->0 Step 1 Output: 001110111001111010 Step 2 Scan: 0:[000]->0 | 1:[001]->1 | 2:[011]->0 | 3:[111]->0 | 4:[110]->0 | 5:[101]->1 | 6:[011]->0 | 7:[111]->0 | 8:[110]->0 | 9:[100]->1 | 10:[001]->1 | 11:[011]->0 | 12:[111]->0 | 13:[111]->0 | 14:[110]->0 | 15:[101]->1 | 16:[010]->1 | 17:[100]->1 Step 2 Output: 010001000110000111 Step 3 Scan: 0:[101]->1 | 1:[010]->1 | 2:[100]->1 | 3:[000]->0 | 4:[001]->1 | 5:[010]->1 | 6:[100]->1 | 7:[000]->0 | 8:[001]->1 | 9:[011]->0 | 10:[110]->0 | 11:[100]->1 | 12:[000]->0 | 13:[000]->0 | 14:[001]->1 | 15:[011]->0 | 16:[111]->0 | 17:[110]->0 Step 3 Output: 111011101001001000 Step 4 Scan: 0:[011]->0 | 1:[111]->0 | 2:[110]->0 | 3:[101]->1 | 4:[011]->0 | 5:[111]->0 | 6:[110]->0 | 7:[101]->1 | 8:[010]->1 | 9:[100]->1 | 10:[001]->1 | 11:[010]->1 | 12:[100]->1 | 13:[001]->1 | 14:[010]->1 | 15:[100]->1 | 16:[000]->0 | 17:[001]->1 Step 4 Output: 000100011111111101 Step 5 Scan: 0:[100]->1 | 1:[000]->0 | 2:[001]->1 | 3:[010]->1 | 4:[100]->1 | 5:[000]->0 | 6:[001]->1 | 7:[011]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 | 12:[111]->0 | 13:[111]->0 | 14:[111]->0 | 15:[110]->0 | 16:[101]->1 | 17:[010]->1 Step 5 Output: 101110100000000011 Step 6 Scan: 0:[110]->0 | 1:[101]->1 | 2:[011]->0 | 3:[111]->0 | 4:[110]->0 | 5:[101]->1 | 6:[010]->1 | 7:[100]->1 | 8:[000]->0 | 9:[000]->0 | 10:[000]->0 | 11:[000]->0 | 12:[000]->0 | 13:[000]->0 | 14:[000]->0 | 15:[001]->1 | 16:[011]->0 | 17:[111]->0 Step 6 Output: 010001110000000100 Step 7 Scan: 0:[001]->1 | 1:[010]->1 | 2:[100]->1 | 3:[000]->0 | 4:[001]->1 | 5:[011]->0 | 6:[111]->0 | 7:[110]->0 | 8:[100]->1 | 9:[000]->0 | 10:[000]->0 | 11:[000]->0 | 12:[000]->0 | 13:[000]->0 | 14:[001]->1 | 15:[010]->1 | 16:[100]->1 | 17:[000]->0 Step 7 Output: 111010001000001110 Step 8 Scan: 0:[011]->0 | 1:[111]->0 | 2:[110]->0 | 3:[101]->1 | 4:[010]->1 | 5:[100]->1 | 6:[000]->0 | 7:[001]->1 | 8:[010]->1 | 9:[100]->1 | 10:[000]->0 | 11:[000]->0 | 12:[000]->0 | 13:[001]->1 | 14:[011]->0 | 15:[111]->0 | 16:[110]->0 | 17:[101]->1 Step 8 Output: 000111011100010001 Step 9 Scan: 0:[100]->1 | 1:[000]->0 | 2:[001]->1 | 3:[011]->0 | 4:[111]->0 | 5:[110]->0 | 6:[101]->1 | 7:[011]->0 | 8:[111]->0 | 9:[110]->0 | 10:[100]->1 | 11:[000]->0 | 12:[001]->1 | 13:[010]->1 | 14:[100]->1 | 15:[000]->0 | 16:[001]->1 | 17:[010]->1 Step 9 Output: 101000100010111011 Step 10 Scan: 0:[110]->0 | 1:[101]->1 | 2:[010]->1 | 3:[100]->1 | 4:[000]->0 | 5:[001]->1 | 6:[010]->1 | 7:[100]->1 | 8:[000]->0 | 9:[001]->1 | 10:[010]->1 | 11:[101]->1 | 12:[011]->0 | 13:[111]->0 | 14:[110]->0 | 15:[101]->1 | 16:[011]->0 | 17:[111]->0 Step 10 Output: 011101110111000100 Step 11 Scan: 0:[001]->1 | 1:[011]->0 | 2:[111]->0 | 3:[110]->0 | 4:[101]->1 | 5:[011]->0 | 6:[111]->0 | 7:[110]->0 | 8:[101]->1 | 9:[011]->0 | 10:[111]->0 | 11:[110]->0 | 12:[100]->1 | 13:[000]->0 | 14:[001]->1 | 15:[010]->1 | 16:[100]->1 | 17:[000]->0 Step 11 Output: 100010001000101110 Step 12 Scan: 0:[010]->1 | 1:[100]->1 | 2:[000]->0 | 3:[001]->1 | 4:[010]->1 | 5:[100]->1 | 6:[000]->0 | 7:[001]->1 | 8:[010]->1 | 9:[100]->1 | 10:[000]->0 | 11:[001]->1 | 12:[010]->1 | 13:[101]->1 | 14:[011]->0 | 15:[111]->0 | 16:[110]->0 | 17:[101]->1 Step 12 Output: 110111011101110001 Step 13 Scan: 0:[111]->0 | 1:[110]->0 | 2:[101]->1 | 3:[011]->0 | 4:[111]->0 | 5:[110]->0 | 6:[101]->1 | 7:[011]->0 | 8:[111]->0 | 9:[110]->0 | 10:[101]->1 | 11:[011]->0 | 12:[111]->0 | 13:[110]->0 | 14:[100]->1 | 15:[000]->0 | 16:[001]->1 | 17:[011]->0 Step 13 Output: 001000100010001010 Step 14 Scan: 0:[000]->0 | 1:[001]->1 | 2:[010]->1 | 3:[100]->1 | 4:[000]->0 | 5:[001]->1 | 6:[010]->1 | 7:[100]->1 | 8:[000]->0 | 9:[001]->1 | 10:[010]->1 | 11:[100]->1 | 12:[000]->0 | 13:[001]->1 | 14:[010]->1 | 15:[101]->1 | 16:[010]->1 | 17:[100]->1 Step 14 Output: 011101110111011111
011101110111011111
deduction
Task: Deduction, Rule: 124 [111->0, 110->1, 101->1, 100->1, 011->1, 010->1, 001->0, 000->0], Steps: 10, Start: 000000110101
Step 1 Scan: 0:[100]->1 | 1:[000]->0 | 2:[000]->0 | 3:[000]->0 | 4:[000]->0 | 5:[001]->0 | 6:[011]->1 | 7:[110]->1 | 8:[101]->1 | 9:[010]->1 | 10:[101]->1 | 11:[010]->1 Step 1 Output: 100000111111 Step 2 Scan: 0:[110]->1 | 1:[100]->1 | 2:[000]->0 | 3:[000]->0 | 4:[000]->0 | 5:[001]->0 | 6:[011]->1 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 Step 2 Output: 110000100000 Step 3 Scan: 0:[011]->1 | 1:[110]->1 | 2:[100]->1 | 3:[000]->0 | 4:[000]->0 | 5:[001]->0 | 6:[010]->1 | 7:[100]->1 | 8:[000]->0 | 9:[000]->0 | 10:[000]->0 | 11:[001]->0 Step 3 Output: 111000110000 Step 4 Scan: 0:[011]->1 | 1:[111]->0 | 2:[110]->1 | 3:[100]->1 | 4:[000]->0 | 5:[001]->0 | 6:[011]->1 | 7:[110]->1 | 8:[100]->1 | 9:[000]->0 | 10:[000]->0 | 11:[001]->0 Step 4 Output: 101100111000 Step 5 Scan: 0:[010]->1 | 1:[101]->1 | 2:[011]->1 | 3:[110]->1 | 4:[100]->1 | 5:[001]->0 | 6:[011]->1 | 7:[111]->0 | 8:[110]->1 | 9:[100]->1 | 10:[000]->0 | 11:[001]->0 Step 5 Output: 111110101100 Step 6 Scan: 0:[011]->1 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[110]->1 | 5:[101]->1 | 6:[010]->1 | 7:[101]->1 | 8:[011]->1 | 9:[110]->1 | 10:[100]->1 | 11:[001]->0 Step 6 Output: 100011111110 Step 7 Scan: 0:[010]->1 | 1:[100]->1 | 2:[000]->0 | 3:[001]->0 | 4:[011]->1 | 5:[111]->0 | 6:[111]->0 | 7:[111]->0 | 8:[111]->0 | 9:[111]->0 | 10:[110]->1 | 11:[101]->1 Step 7 Output: 110010000011 Step 8 Scan: 0:[111]->0 | 1:[110]->1 | 2:[100]->1 | 3:[001]->0 | 4:[010]->1 | 5:[100]->1 | 6:[000]->0 | 7:[000]->0 | 8:[000]->0 | 9:[001]->0 | 10:[011]->1 | 11:[111]->0 Step 8 Output: 011011000010 Step 9 Scan: 0:[001]->0 | 1:[011]->1 | 2:[110]->1 | 3:[101]->1 | 4:[011]->1 | 5:[110]->1 | 6:[100]->1 | 7:[000]->0 | 8:[000]->0 | 9:[001]->0 | 10:[010]->1 | 11:[100]->1 Step 9 Output: 011111100011 Step 10 Scan: 0:[101]->1 | 1:[011]->1 | 2:[111]->0 | 3:[111]->0 | 4:[111]->0 | 5:[111]->0 | 6:[110]->1 | 7:[100]->1 | 8:[000]->0 | 9:[001]->0 | 10:[011]->1 | 11:[110]->1 Step 10 Output: 110000110011
110000110011
induction
Task: Induction, Start: 00101001100100, End: 00000000000000, Steps: 14, Hint: Class 1
Task: Find rule in Class 1. Candidates: [160, 0, 8, 32, 128, 40, 136, 168] Attempt 1: Testing Rule 160 [111->1, 110->0, 101->1, 100->0, 011->0, 010->0, 001->0, 000->0] Sim Step 1: 00010000000000 Sim Step 2: 00000000000000 Sim Step 3: 00000000000000 Sim Step 4: 00000000000000 Sim Step 5: 00000000000000 Sim Step 6: 00000000000000 Sim Step 7: 00000000000000 Sim Step 8: 00000000000000 Sim Step 9: 00000000000000 Sim Step 10: 00000000000000 Sim Step 11: 00000000000000 Sim Step 12: 00000000000000 Sim Step 13: 00000000000000 Sim Step 14: 00000000000000 Verification: Exact Match. Rule Confirmed.
111->1, 110->0, 101->1, 100->0, 011->0, 010->0, 001->0, 000->0
induction
Task: Induction, Start: 0011110000001100011, End: 0000000000000000000, Steps: 10, Hint: Class 1
Task: Find rule in Class 1. Candidates: [128, 168, 0, 32, 136, 8, 40, 160] Attempt 1: Testing Rule 128 [111->1, 110->0, 101->0, 100->0, 011->0, 010->0, 001->0, 000->0] Sim Step 1: 0001100000000000000 Sim Step 2: 0000000000000000000 Sim Step 3: 0000000000000000000 Sim Step 4: 0000000000000000000 Sim Step 5: 0000000000000000000 Sim Step 6: 0000000000000000000 Sim Step 7: 0000000000000000000 Sim Step 8: 0000000000000000000 Sim Step 9: 0000000000000000000 Sim Step 10: 0000000000000000000 Verification: Exact Match. Rule Confirmed.
111->1, 110->0, 101->0, 100->0, 011->0, 010->0, 001->0, 000->0
deduction
Task: Deduction, Rule: 54 [111->0, 110->0, 101->1, 100->1, 011->0, 010->1, 001->1, 000->0], Steps: 15, Start: 10110111000100000010
Step 1 Scan: 0:[010]->1 | 1:[101]->1 | 2:[011]->0 | 3:[110]->0 | 4:[101]->1 | 5:[011]->0 | 6:[111]->0 | 7:[110]->0 | 8:[100]->1 | 9:[000]->0 | 10:[001]->1 | 11:[010]->1 | 12:[100]->1 | 13:[000]->0 | 14:[000]->0 | 15:[000]->0 | 16:[000]->0 | 17:[001]->1 | 18:[010]->1 | 19:[101]->1 Step 1 Output: 11001000101110000111 Step 2 Scan: 0:[111]->0 | 1:[110]->0 | 2:[100]->1 | 3:[001]->1 | 4:[010]->1 | 5:[100]->1 | 6:[000]->0 | 7:[001]->1 | 8:[010]->1 | 9:[101]->1 | 10:[011]->0 | 11:[111]->0 | 12:[110]->0 | 13:[100]->1 | 14:[000]->0 | 15:[000]->0 | 16:[001]->1 | 17:[011]->0 | 18:[111]->0 | 19:[111]->0 Step 2 Output: 00111101110001001000 Step 3 Scan: 0:[000]->0 | 1:[001]->1 | 2:[011]->0 | 3:[111]->0 | 4:[111]->0 | 5:[110]->0 | 6:[101]->1 | 7:[011]->0 | 8:[111]->0 | 9:[110]->0 | 10:[100]->1 | 11:[000]->0 | 12:[001]->1 | 13:[010]->1 | 14:[100]->1 | 15:[001]->1 | 16:[010]->1 | 17:[100]->1 | 18:[000]->0 | 19:[000]->0 Step 3 Output: 01000010001011111100 Step 4 Scan: 0:[001]->1 | 1:[010]->1 | 2:[100]->1 | 3:[000]->0 | 4:[000]->0 | 5:[001]->1 | 6:[010]->1 | 7:[100]->1 | 8:[000]->0 | 9:[001]->1 | 10:[010]->1 | 11:[101]->1 | 12:[011]->0 | 13:[111]->0 | 14:[111]->0 | 15:[111]->0 | 16:[111]->0 | 17:[110]->0 | 18:[100]->1 | 19:[000]->0 Step 4 Output: 11100111011100000010 Step 5 Scan: 0:[011]->0 | 1:[111]->0 | 2:[110]->0 | 3:[100]->1 | 4:[001]->1 | 5:[011]->0 | 6:[111]->0 | 7:[110]->0 | 8:[101]->1 | 9:[011]->0 | 10:[111]->0 | 11:[110]->0 | 12:[100]->1 | 13:[000]->0 | 14:[000]->0 | 15:[000]->0 | 16:[000]->0 | 17:[001]->1 | 18:[010]->1 | 19:[101]->1 Step 5 Output: 00011000100010000111 Step 6 Scan: 0:[100]->1 | 1:[000]->0 | 2:[001]->1 | 3:[011]->0 | 4:[110]->0 | 5:[100]->1 | 6:[000]->0 | 7:[001]->1 | 8:[010]->1 | 9:[100]->1 | 10:[000]->0 | 11:[001]->1 | 12:[010]->1 | 13:[100]->1 | 14:[000]->0 | 15:[000]->0 | 16:[001]->1 | 17:[011]->0 | 18:[111]->0 | 19:[110]->0 Step 6 Output: 10100101110111001000 Step 7 Scan: 0:[010]->1 | 1:[101]->1 | 2:[010]->1 | 3:[100]->1 | 4:[001]->1 | 5:[010]->1 | 6:[101]->1 | 7:[011]->0 | 8:[111]->0 | 9:[110]->0 | 10:[101]->1 | 11:[011]->0 | 12:[111]->0 | 13:[110]->0 | 14:[100]->1 | 15:[001]->1 | 16:[010]->1 | 17:[100]->1 | 18:[000]->0 | 19:[001]->1 Step 7 Output: 11111110001000111101 Step 8 Scan: 0:[111]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[111]->0 | 5:[111]->0 | 6:[110]->0 | 7:[100]->1 | 8:[000]->0 | 9:[001]->1 | 10:[010]->1 | 11:[100]->1 | 12:[000]->0 | 13:[001]->1 | 14:[011]->0 | 15:[111]->0 | 16:[111]->0 | 17:[110]->0 | 18:[101]->1 | 19:[011]->0 Step 8 Output: 00000001011101000010 Step 9 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[000]->0 | 4:[000]->0 | 5:[000]->0 | 6:[001]->1 | 7:[010]->1 | 8:[101]->1 | 9:[011]->0 | 10:[111]->0 | 11:[110]->0 | 12:[101]->1 | 13:[010]->1 | 14:[100]->1 | 15:[000]->0 | 16:[000]->0 | 17:[001]->1 | 18:[010]->1 | 19:[100]->1 Step 9 Output: 00000011100011100111 Step 10 Scan: 0:[100]->1 | 1:[000]->0 | 2:[000]->0 | 3:[000]->0 | 4:[000]->0 | 5:[001]->1 | 6:[011]->0 | 7:[111]->0 | 8:[110]->0 | 9:[100]->1 | 10:[000]->0 | 11:[001]->1 | 12:[011]->0 | 13:[111]->0 | 14:[110]->0 | 15:[100]->1 | 16:[001]->1 | 17:[011]->0 | 18:[111]->0 | 19:[110]->0 Step 10 Output: 10000100010100011000 Step 11 Scan: 0:[010]->1 | 1:[100]->1 | 2:[000]->0 | 3:[000]->0 | 4:[001]->1 | 5:[010]->1 | 6:[100]->1 | 7:[000]->0 | 8:[001]->1 | 9:[010]->1 | 10:[101]->1 | 11:[010]->1 | 12:[100]->1 | 13:[000]->0 | 14:[001]->1 | 15:[011]->0 | 16:[110]->0 | 17:[100]->1 | 18:[000]->0 | 19:[001]->1 Step 11 Output: 11001110111110100101 Step 12 Scan: 0:[111]->0 | 1:[110]->0 | 2:[100]->1 | 3:[001]->1 | 4:[011]->0 | 5:[111]->0 | 6:[110]->0 | 7:[101]->1 | 8:[011]->0 | 9:[111]->0 | 10:[111]->0 | 11:[111]->0 | 12:[110]->0 | 13:[101]->1 | 14:[010]->1 | 15:[100]->1 | 16:[001]->1 | 17:[010]->1 | 18:[101]->1 | 19:[011]->0 Step 12 Output: 00110001000001111110 Step 13 Scan: 0:[000]->0 | 1:[001]->1 | 2:[011]->0 | 3:[110]->0 | 4:[100]->1 | 5:[000]->0 | 6:[001]->1 | 7:[010]->1 | 8:[100]->1 | 9:[000]->0 | 10:[000]->0 | 11:[000]->0 | 12:[001]->1 | 13:[011]->0 | 14:[111]->0 | 15:[111]->0 | 16:[111]->0 | 17:[111]->0 | 18:[110]->0 | 19:[100]->1 Step 13 Output: 01001011100010000001 Step 14 Scan: 0:[101]->1 | 1:[010]->1 | 2:[100]->1 | 3:[001]->1 | 4:[010]->1 | 5:[101]->1 | 6:[011]->0 | 7:[111]->0 | 8:[110]->0 | 9:[100]->1 | 10:[000]->0 | 11:[001]->1 | 12:[010]->1 | 13:[100]->1 | 14:[000]->0 | 15:[000]->0 | 16:[000]->0 | 17:[000]->0 | 18:[001]->1 | 19:[010]->1 Step 14 Output: 11111100010111000011 Step 15 Scan: 0:[111]->0 | 1:[111]->0 | 2:[111]->0 | 3:[111]->0 | 4:[111]->0 | 5:[110]->0 | 6:[100]->1 | 7:[000]->0 | 8:[001]->1 | 9:[010]->1 | 10:[101]->1 | 11:[011]->0 | 12:[111]->0 | 13:[110]->0 | 14:[100]->1 | 15:[000]->0 | 16:[000]->0 | 17:[001]->1 | 18:[011]->0 | 19:[111]->0 Step 15 Output: 00000010111000100100
00000010111000100100
induction
Task: Induction, Start: 0100001100000111, End: 0001100001110000, Steps: 13, Hint: Class 2
Task: Find rule in Class 2. Candidates: [50, 23, 108, 178, 19, 1, 29, 37] Attempt 1: Testing Rule 50 [111->0, 110->0, 101->1, 100->1, 011->0, 010->0, 001->1, 000->0] Sim Step 1: 1010010010001000 Sim Step 2: 0101101101010101 Sim Step 3: 1010010010101010 Sim Step 4: 0101101101010101 Sim Step 5: 1010010010101010 Sim Step 6: 0101101101010101 Sim Step 7: 1010010010101010 Sim Step 8: 0101101101010101 Sim Step 9: 1010010010101010 Sim Step 10: 0101101101010101 Sim Step 11: 1010010010101010 Sim Step 12: 0101101101010101 Sim Step 13: 1010010010101010 Verification: Mismatch (Expected 0001100001110000). Next... Attempt 2: Testing Rule 23 [111->0, 110->0, 101->0, 100->1, 011->0, 010->1, 001->1, 000->1] Sim Step 1: 0111110011111000 Sim Step 2: 1000001100000111 Sim Step 3: 0111110011111000 Sim Step 4: 1000001100000111 Sim Step 5: 0111110011111000 Sim Step 6: 1000001100000111 Sim Step 7: 0111110011111000 Sim Step 8: 1000001100000111 Sim Step 9: 0111110011111000 Sim Step 10: 1000001100000111 Sim Step 11: 0111110011111000 Sim Step 12: 1000001100000111 Sim Step 13: 0111110011111000 Verification: Mismatch (Expected 0001100001110000). Next... Attempt 3: Testing Rule 108 [111->0, 110->1, 101->1, 100->0, 011->1, 010->1, 001->0, 000->0] Sim Step 1: 1100001100000101 Sim Step 2: 0100001100000111 Sim Step 3: 1100001100000101 Sim Step 4: 0100001100000111 Sim Step 5: 1100001100000101 Sim Step 6: 0100001100000111 Sim Step 7: 1100001100000101 Sim Step 8: 0100001100000111 Sim Step 9: 1100001100000101 Sim Step 10: 0100001100000111 Sim Step 11: 1100001100000101 Sim Step 12: 0100001100000111 Sim Step 13: 1100001100000101 Verification: Mismatch (Expected 0001100001110000). Next... Attempt 4: Testing Rule 178 [111->1, 110->0, 101->1, 100->1, 011->0, 010->0, 001->1, 000->0] Sim Step 1: 1010010010001010 Sim Step 2: 0101101101010101 Sim Step 3: 1010010010101010 Sim Step 4: 0101101101010101 Sim Step 5: 1010010010101010 Sim Step 6: 0101101101010101 Sim Step 7: 1010010010101010 Sim Step 8: 0101101101010101 Sim Step 9: 1010010010101010 Sim Step 10: 0101101101010101 Sim Step 11: 1010010010101010 Sim Step 12: 0101101101010101 Sim Step 13: 1010010010101010 Verification: Mismatch (Expected 0001100001110000). Next... Attempt 5: Testing Rule 19 [111->0, 110->0, 101->0, 100->1, 011->0, 010->0, 001->1, 000->1] Sim Step 1: 0011110011111000 Sim Step 2: 1100001100000111 Sim Step 3: 0011110011111000 Sim Step 4: 1100001100000111 Sim Step 5: 0011110011111000 Sim Step 6: 1100001100000111 Sim Step 7: 0011110011111000 Sim Step 8: 1100001100000111 Sim Step 9: 0011110011111000 Sim Step 10: 1100001100000111 Sim Step 11: 0011110011111000 Sim Step 12: 1100001100000111 Sim Step 13: 0011110011111000 Verification: Mismatch (Expected 0001100001110000). Next... Attempt 6: Testing Rule 1 [111->0, 110->0, 101->0, 100->0, 011->0, 010->0, 001->0, 000->1] Sim Step 1: 0001100001110000 Sim Step 2: 1100001100000111 Sim Step 3: 0001100001110000 Sim Step 4: 1100001100000111 Sim Step 5: 0001100001110000 Sim Step 6: 1100001100000111 Sim Step 7: 0001100001110000 Sim Step 8: 1100001100000111 Sim Step 9: 0001100001110000 Sim Step 10: 1100001100000111 Sim Step 11: 0001100001110000 Sim Step 12: 1100001100000111 Sim Step 13: 0001100001110000 Verification: Exact Match. Rule Confirmed.
111->0, 110->0, 101->0, 100->0, 011->0, 010->0, 001->0, 000->1
abduction
Task: Abduction, Rule: 90 [111->0, 110->1, 101->0, 100->1, 011->1, 010->0, 001->1, 000->0], Steps: 3, End: 100011110111
Goal: Reverse 3 steps by calculating likelihoods of priors. Step -1: Inverting state 100011110111 Calculating Local Priors: Idx 0 requires neighborhood in ['001', '011', '100', '110'] Idx 1 requires neighborhood in ['000', '010', '101', '111'] Idx 2 requires neighborhood in ['000', '010', '101', '111'] Idx 3 requires neighborhood in ['000', '010', '101', '111'] Idx 4 requires neighborhood in ['001', '011', '100', '110'] Idx 5 requires neighborhood in ['001', '011', '100', '110'] Idx 6 requires neighborhood in ['001', '011', '100', '110'] Idx 7 requires neighborhood in ['001', '011', '100', '110'] Idx 8 requires neighborhood in ['000', '010', '101', '111'] Idx 9 requires neighborhood in ['001', '011', '100', '110'] Idx 10 requires neighborhood in ['001', '011', '100', '110'] Idx 11 requires neighborhood in ['001', '011', '100', '110'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% Greedy Candidate: 111111111111 Verification: Mismatch. Correction applied -> 010100110110 Step -2: Inverting state 010100110110 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '010', '101', '111'] Idx 1 requires neighborhood in ['001', '011', '100', '110'] Idx 2 requires neighborhood in ['000', '010', '101', '111'] Idx 3 requires neighborhood in ['001', '011', '100', '110'] Idx 4 requires neighborhood in ['000', '010', '101', '111'] Idx 5 requires neighborhood in ['000', '010', '101', '111'] Idx 6 requires neighborhood in ['001', '011', '100', '110'] Idx 7 requires neighborhood in ['001', '011', '100', '110'] Idx 8 requires neighborhood in ['000', '010', '101', '111'] Idx 9 requires neighborhood in ['001', '011', '100', '110'] Idx 10 requires neighborhood in ['001', '011', '100', '110'] Idx 11 requires neighborhood in ['000', '010', '101', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% Greedy Candidate: 111111111111 Verification: Mismatch. Correction applied -> 001000011100 Step -3: Inverting state 001000011100 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '010', '101', '111'] Idx 1 requires neighborhood in ['000', '010', '101', '111'] Idx 2 requires neighborhood in ['001', '011', '100', '110'] Idx 3 requires neighborhood in ['000', '010', '101', '111'] Idx 4 requires neighborhood in ['000', '010', '101', '111'] Idx 5 requires neighborhood in ['000', '010', '101', '111'] Idx 6 requires neighborhood in ['000', '010', '101', '111'] Idx 7 requires neighborhood in ['001', '011', '100', '110'] Idx 8 requires neighborhood in ['001', '011', '100', '110'] Idx 9 requires neighborhood in ['001', '011', '100', '110'] Idx 10 requires neighborhood in ['000', '010', '101', '111'] Idx 11 requires neighborhood in ['000', '010', '101', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% Greedy Candidate: 111111111111 Verification: Mismatch. Correction applied -> 010000001101
010000001101
abduction
Task: Abduction, Rule: 147 [111->1, 110->0, 101->0, 100->1, 011->0, 010->0, 001->1, 000->1], Steps: 1, End: 100111110000110111
Goal: Reverse 1 steps by calculating likelihoods of priors. Step -1: Inverting state 100111110000110111 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '001', '100', '111'] Idx 1 requires neighborhood in ['010', '011', '101', '110'] Idx 2 requires neighborhood in ['010', '011', '101', '110'] Idx 3 requires neighborhood in ['000', '001', '100', '111'] Idx 4 requires neighborhood in ['000', '001', '100', '111'] Idx 5 requires neighborhood in ['000', '001', '100', '111'] Idx 6 requires neighborhood in ['000', '001', '100', '111'] Idx 7 requires neighborhood in ['000', '001', '100', '111'] Idx 8 requires neighborhood in ['010', '011', '101', '110'] Idx 9 requires neighborhood in ['010', '011', '101', '110'] Idx 10 requires neighborhood in ['010', '011', '101', '110'] Idx 11 requires neighborhood in ['010', '011', '101', '110'] Idx 12 requires neighborhood in ['000', '001', '100', '111'] Idx 13 requires neighborhood in ['000', '001', '100', '111'] Idx 14 requires neighborhood in ['010', '011', '101', '110'] Idx 15 requires neighborhood in ['000', '001', '100', '111'] Idx 16 requires neighborhood in ['000', '001', '100', '111'] Idx 17 requires neighborhood in ['000', '001', '100', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:41% | 1:58% | 2:58% | 3:41% | 4:41% | 5:41% | 6:41% | 7:41% | 8:58% | 9:58% | 10:58% | 11:58% | 12:41% | 13:41% | 14:58% | 15:41% | 16:41% | 17:41% Greedy Candidate: 011000001111001000 Verification: Mismatch. Correction applied -> 011000001101001000
011000001101001000
abduction
Task: Abduction, Rule: 40 [111->0, 110->0, 101->1, 100->0, 011->1, 010->0, 001->0, 000->0], Steps: 3, End: 10000000110000000000
Goal: Reverse 3 steps by calculating likelihoods of priors. Step -1: Inverting state 10000000110000000000 Calculating Local Priors: Idx 0 requires neighborhood in ['011', '101'] Idx 1 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 2 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 3 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 4 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 5 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 6 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 7 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 8 requires neighborhood in ['011', '101'] Idx 9 requires neighborhood in ['011', '101'] Idx 10 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 11 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 12 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 13 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 14 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 15 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 16 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 17 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 18 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 19 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:42% | 1:57% | 2:44% | 3:44% | 4:44% | 5:44% | 6:44% | 7:42% | 8:40% | 9:60% | 10:57% | 11:44% | 12:44% | 13:44% | 14:44% | 15:44% | 16:44% | 17:44% | 18:44% | 19:42% Greedy Candidate: 01000000011000000000 Verification: Mismatch. Correction applied -> 11000001011000000000 Step -2: Inverting state 11000001011000000000 Calculating Local Priors: Idx 0 requires neighborhood in ['011', '101'] Idx 1 requires neighborhood in ['011', '101'] Idx 2 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 3 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 4 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 5 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 6 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 7 requires neighborhood in ['011', '101'] Idx 8 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 9 requires neighborhood in ['011', '101'] Idx 10 requires neighborhood in ['011', '101'] Idx 11 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 12 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 13 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 14 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 15 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 16 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 17 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 18 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 19 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:40% | 1:60% | 2:57% | 3:44% | 4:44% | 5:44% | 6:42% | 7:42% | 8:60% | 9:40% | 10:60% | 11:57% | 12:44% | 13:44% | 14:44% | 15:44% | 16:44% | 17:44% | 18:44% | 19:42% Greedy Candidate: 01100000101100000000 Verification: Mismatch. Correction applied -> 01100001101100001001 Step -3: Inverting state 01100001101100001001 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 1 requires neighborhood in ['011', '101'] Idx 2 requires neighborhood in ['011', '101'] Idx 3 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 4 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 5 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 6 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 7 requires neighborhood in ['011', '101'] Idx 8 requires neighborhood in ['011', '101'] Idx 9 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 10 requires neighborhood in ['011', '101'] Idx 11 requires neighborhood in ['011', '101'] Idx 12 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 13 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 14 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 15 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 16 requires neighborhood in ['011', '101'] Idx 17 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 18 requires neighborhood in ['000', '001', '010', '100', '110', '111'] Idx 19 requires neighborhood in ['011', '101'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:60% | 1:40% | 2:60% | 3:57% | 4:44% | 5:44% | 6:42% | 7:40% | 8:60% | 9:60% | 10:40% | 11:60% | 12:57% | 13:44% | 14:44% | 15:42% | 16:42% | 17:57% | 18:42% | 19:42% Greedy Candidate: 10110000110110000100 Verification: Mismatch. Correction applied -> 10111110110111001110
10111110110111001110
abduction
Task: Abduction, Rule: 106 [111->0, 110->1, 101->1, 100->0, 011->1, 010->0, 001->1, 000->0], Steps: 2, End: 1100101010011
Goal: Reverse 2 steps by calculating likelihoods of priors. Step -1: Inverting state 1100101010011 Calculating Local Priors: Idx 0 requires neighborhood in ['001', '011', '101', '110'] Idx 1 requires neighborhood in ['001', '011', '101', '110'] Idx 2 requires neighborhood in ['000', '010', '100', '111'] Idx 3 requires neighborhood in ['000', '010', '100', '111'] Idx 4 requires neighborhood in ['001', '011', '101', '110'] Idx 5 requires neighborhood in ['000', '010', '100', '111'] Idx 6 requires neighborhood in ['001', '011', '101', '110'] Idx 7 requires neighborhood in ['000', '010', '100', '111'] Idx 8 requires neighborhood in ['001', '011', '101', '110'] Idx 9 requires neighborhood in ['000', '010', '100', '111'] Idx 10 requires neighborhood in ['000', '010', '100', '111'] Idx 11 requires neighborhood in ['001', '011', '101', '110'] Idx 12 requires neighborhood in ['001', '011', '101', '110'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:58% | 1:58% | 2:58% | 3:41% | 4:41% | 5:58% | 6:41% | 7:58% | 8:41% | 9:58% | 10:41% | 11:41% | 12:58% Greedy Candidate: 1110010101001 Verification: Mismatch. Correction applied -> 1010010101001 Step -2: Inverting state 1010010101001 Calculating Local Priors: Idx 0 requires neighborhood in ['001', '011', '101', '110'] Idx 1 requires neighborhood in ['000', '010', '100', '111'] Idx 2 requires neighborhood in ['001', '011', '101', '110'] Idx 3 requires neighborhood in ['000', '010', '100', '111'] Idx 4 requires neighborhood in ['000', '010', '100', '111'] Idx 5 requires neighborhood in ['001', '011', '101', '110'] Idx 6 requires neighborhood in ['000', '010', '100', '111'] Idx 7 requires neighborhood in ['001', '011', '101', '110'] Idx 8 requires neighborhood in ['000', '010', '100', '111'] Idx 9 requires neighborhood in ['001', '011', '101', '110'] Idx 10 requires neighborhood in ['000', '010', '100', '111'] Idx 11 requires neighborhood in ['000', '010', '100', '111'] Idx 12 requires neighborhood in ['001', '011', '101', '110'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:58% | 1:58% | 2:41% | 3:58% | 4:41% | 5:41% | 6:58% | 7:41% | 8:58% | 9:41% | 10:58% | 11:41% | 12:41% Greedy Candidate: 1101001010100 Verification: Mismatch. Correction applied -> 1110001010100
1110001010100
deduction
Task: Deduction, Rule: 150 [111->1, 110->0, 101->0, 100->1, 011->0, 010->1, 001->1, 000->0], Steps: 11, Start: 101011000111111100
Step 1 Scan: 0:[010]->1 | 1:[101]->0 | 2:[010]->1 | 3:[101]->0 | 4:[011]->0 | 5:[110]->0 | 6:[100]->1 | 7:[000]->0 | 8:[001]->1 | 9:[011]->0 | 10:[111]->1 | 11:[111]->1 | 12:[111]->1 | 13:[111]->1 | 14:[111]->1 | 15:[110]->0 | 16:[100]->1 | 17:[001]->1 Step 1 Output: 101000101011111011 Step 2 Scan: 0:[110]->0 | 1:[101]->0 | 2:[010]->1 | 3:[100]->1 | 4:[000]->0 | 5:[001]->1 | 6:[010]->1 | 7:[101]->0 | 8:[010]->1 | 9:[101]->0 | 10:[011]->0 | 11:[111]->1 | 12:[111]->1 | 13:[111]->1 | 14:[110]->0 | 15:[101]->0 | 16:[011]->0 | 17:[111]->1 Step 2 Output: 001101101001110001 Step 3 Scan: 0:[100]->1 | 1:[001]->1 | 2:[011]->0 | 3:[110]->0 | 4:[101]->0 | 5:[011]->0 | 6:[110]->0 | 7:[101]->0 | 8:[010]->1 | 9:[100]->1 | 10:[001]->1 | 11:[011]->0 | 12:[111]->1 | 13:[110]->0 | 14:[100]->1 | 15:[000]->0 | 16:[001]->1 | 17:[010]->1 Step 3 Output: 110000001110101011 Step 4 Scan: 0:[111]->1 | 1:[110]->0 | 2:[100]->1 | 3:[000]->0 | 4:[000]->0 | 5:[000]->0 | 6:[000]->0 | 7:[001]->1 | 8:[011]->0 | 9:[111]->1 | 10:[110]->0 | 11:[101]->0 | 12:[010]->1 | 13:[101]->0 | 14:[010]->1 | 15:[101]->0 | 16:[011]->0 | 17:[111]->1 Step 4 Output: 101000010100101001 Step 5 Scan: 0:[110]->0 | 1:[101]->0 | 2:[010]->1 | 3:[100]->1 | 4:[000]->0 | 5:[000]->0 | 6:[001]->1 | 7:[010]->1 | 8:[101]->0 | 9:[010]->1 | 10:[100]->1 | 11:[001]->1 | 12:[010]->1 | 13:[101]->0 | 14:[010]->1 | 15:[100]->1 | 16:[001]->1 | 17:[011]->0 Step 5 Output: 001100110111101110 Step 6 Scan: 0:[000]->0 | 1:[001]->1 | 2:[011]->0 | 3:[110]->0 | 4:[100]->1 | 5:[001]->1 | 6:[011]->0 | 7:[110]->0 | 8:[101]->0 | 9:[011]->0 | 10:[111]->1 | 11:[111]->1 | 12:[110]->0 | 13:[101]->0 | 14:[011]->0 | 15:[111]->1 | 16:[110]->0 | 17:[100]->1 Step 6 Output: 010011000011000101 Step 7 Scan: 0:[101]->0 | 1:[010]->1 | 2:[100]->1 | 3:[001]->1 | 4:[011]->0 | 5:[110]->0 | 6:[100]->1 | 7:[000]->0 | 8:[000]->0 | 9:[001]->1 | 10:[011]->0 | 11:[110]->0 | 12:[100]->1 | 13:[000]->0 | 14:[001]->1 | 15:[010]->1 | 16:[101]->0 | 17:[010]->1 Step 7 Output: 011100100100101101 Step 8 Scan: 0:[101]->0 | 1:[011]->0 | 2:[111]->1 | 3:[110]->0 | 4:[100]->1 | 5:[001]->1 | 6:[010]->1 | 7:[100]->1 | 8:[001]->1 | 9:[010]->1 | 10:[100]->1 | 11:[001]->1 | 12:[010]->1 | 13:[101]->0 | 14:[011]->0 | 15:[110]->0 | 16:[101]->0 | 17:[010]->1 Step 8 Output: 001011111111100001 Step 9 Scan: 0:[100]->1 | 1:[001]->1 | 2:[010]->1 | 3:[101]->0 | 4:[011]->0 | 5:[111]->1 | 6:[111]->1 | 7:[111]->1 | 8:[111]->1 | 9:[111]->1 | 10:[111]->1 | 11:[111]->1 | 12:[110]->0 | 13:[100]->1 | 14:[000]->0 | 15:[000]->0 | 16:[001]->1 | 17:[010]->1 Step 9 Output: 111001111111010011 Step 10 Scan: 0:[111]->1 | 1:[111]->1 | 2:[110]->0 | 3:[100]->1 | 4:[001]->1 | 5:[011]->0 | 6:[111]->1 | 7:[111]->1 | 8:[111]->1 | 9:[111]->1 | 10:[111]->1 | 11:[110]->0 | 12:[101]->0 | 13:[010]->1 | 14:[100]->1 | 15:[001]->1 | 16:[011]->0 | 17:[111]->1 Step 10 Output: 110110111110011101 Step 11 Scan: 0:[111]->1 | 1:[110]->0 | 2:[101]->0 | 3:[011]->0 | 4:[110]->0 | 5:[101]->0 | 6:[011]->0 | 7:[111]->1 | 8:[111]->1 | 9:[111]->1 | 10:[110]->0 | 11:[100]->1 | 12:[001]->1 | 13:[011]->0 | 14:[111]->1 | 15:[110]->0 | 16:[101]->0 | 17:[011]->0 Step 11 Output: 100000011101101000
100000011101101000
abduction
Task: Abduction, Rule: 90 [111->0, 110->1, 101->0, 100->1, 011->1, 010->0, 001->1, 000->0], Steps: 1, End: 001000111000111111
Goal: Reverse 1 steps by calculating likelihoods of priors. Step -1: Inverting state 001000111000111111 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '010', '101', '111'] Idx 1 requires neighborhood in ['000', '010', '101', '111'] Idx 2 requires neighborhood in ['001', '011', '100', '110'] Idx 3 requires neighborhood in ['000', '010', '101', '111'] Idx 4 requires neighborhood in ['000', '010', '101', '111'] Idx 5 requires neighborhood in ['000', '010', '101', '111'] Idx 6 requires neighborhood in ['001', '011', '100', '110'] Idx 7 requires neighborhood in ['001', '011', '100', '110'] Idx 8 requires neighborhood in ['001', '011', '100', '110'] Idx 9 requires neighborhood in ['000', '010', '101', '111'] Idx 10 requires neighborhood in ['000', '010', '101', '111'] Idx 11 requires neighborhood in ['000', '010', '101', '111'] Idx 12 requires neighborhood in ['001', '011', '100', '110'] Idx 13 requires neighborhood in ['001', '011', '100', '110'] Idx 14 requires neighborhood in ['001', '011', '100', '110'] Idx 15 requires neighborhood in ['001', '011', '100', '110'] Idx 16 requires neighborhood in ['001', '011', '100', '110'] Idx 17 requires neighborhood in ['001', '011', '100', '110'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% | 12:50% | 13:50% | 14:50% | 15:50% | 16:50% | 17:50% Greedy Candidate: 111111111111111111 Verification: Mismatch. Correction applied -> 101111100101001100
101111100101001100
abduction
Task: Abduction, Rule: 108 [111->0, 110->1, 101->1, 100->0, 011->1, 010->1, 001->0, 000->0], Steps: 1, End: 00111011111101
Goal: Reverse 1 steps by calculating likelihoods of priors. Step -1: Inverting state 00111011111101 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '001', '100', '111'] Idx 1 requires neighborhood in ['000', '001', '100', '111'] Idx 2 requires neighborhood in ['010', '011', '101', '110'] Idx 3 requires neighborhood in ['010', '011', '101', '110'] Idx 4 requires neighborhood in ['010', '011', '101', '110'] Idx 5 requires neighborhood in ['000', '001', '100', '111'] Idx 6 requires neighborhood in ['010', '011', '101', '110'] Idx 7 requires neighborhood in ['010', '011', '101', '110'] Idx 8 requires neighborhood in ['010', '011', '101', '110'] Idx 9 requires neighborhood in ['010', '011', '101', '110'] Idx 10 requires neighborhood in ['010', '011', '101', '110'] Idx 11 requires neighborhood in ['010', '011', '101', '110'] Idx 12 requires neighborhood in ['000', '001', '100', '111'] Idx 13 requires neighborhood in ['010', '011', '101', '110'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:41% | 1:41% | 2:58% | 3:58% | 4:58% | 5:41% | 6:58% | 7:58% | 8:58% | 9:58% | 10:58% | 11:58% | 12:41% | 13:58% Greedy Candidate: 00111011111101 Verification: Mismatch. Correction applied -> 00101110110111
00101110110111
abduction
Task: Abduction, Rule: 60 [111->0, 110->0, 101->1, 100->1, 011->1, 010->1, 001->0, 000->0], Steps: 3, End: 0001100010010000
Goal: Reverse 3 steps by calculating likelihoods of priors. Step -1: Inverting state 0001100010010000 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '001', '110', '111'] Idx 1 requires neighborhood in ['000', '001', '110', '111'] Idx 2 requires neighborhood in ['000', '001', '110', '111'] Idx 3 requires neighborhood in ['010', '011', '100', '101'] Idx 4 requires neighborhood in ['010', '011', '100', '101'] Idx 5 requires neighborhood in ['000', '001', '110', '111'] Idx 6 requires neighborhood in ['000', '001', '110', '111'] Idx 7 requires neighborhood in ['000', '001', '110', '111'] Idx 8 requires neighborhood in ['010', '011', '100', '101'] Idx 9 requires neighborhood in ['000', '001', '110', '111'] Idx 10 requires neighborhood in ['000', '001', '110', '111'] Idx 11 requires neighborhood in ['010', '011', '100', '101'] Idx 12 requires neighborhood in ['000', '001', '110', '111'] Idx 13 requires neighborhood in ['000', '001', '110', '111'] Idx 14 requires neighborhood in ['000', '001', '110', '111'] Idx 15 requires neighborhood in ['000', '001', '110', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% | 12:50% | 13:50% | 14:50% | 15:50% Greedy Candidate: 1111111111111111 Verification: Mismatch. Correction applied -> 0001000011100000 Step -2: Inverting state 0001000011100000 Calculating Local Priors: Idx 0 requires neighborhood in ['000', '001', '110', '111'] Idx 1 requires neighborhood in ['000', '001', '110', '111'] Idx 2 requires neighborhood in ['000', '001', '110', '111'] Idx 3 requires neighborhood in ['010', '011', '100', '101'] Idx 4 requires neighborhood in ['000', '001', '110', '111'] Idx 5 requires neighborhood in ['000', '001', '110', '111'] Idx 6 requires neighborhood in ['000', '001', '110', '111'] Idx 7 requires neighborhood in ['000', '001', '110', '111'] Idx 8 requires neighborhood in ['010', '011', '100', '101'] Idx 9 requires neighborhood in ['010', '011', '100', '101'] Idx 10 requires neighborhood in ['010', '011', '100', '101'] Idx 11 requires neighborhood in ['000', '001', '110', '111'] Idx 12 requires neighborhood in ['000', '001', '110', '111'] Idx 13 requires neighborhood in ['000', '001', '110', '111'] Idx 14 requires neighborhood in ['000', '001', '110', '111'] Idx 15 requires neighborhood in ['000', '001', '110', '111'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% | 12:50% | 13:50% | 14:50% | 15:50% Greedy Candidate: 1111111111111111 Verification: Mismatch. Correction applied -> 1110000010111111 Step -3: Inverting state 1110000010111111 Calculating Local Priors: Idx 0 requires neighborhood in ['010', '011', '100', '101'] Idx 1 requires neighborhood in ['010', '011', '100', '101'] Idx 2 requires neighborhood in ['010', '011', '100', '101'] Idx 3 requires neighborhood in ['000', '001', '110', '111'] Idx 4 requires neighborhood in ['000', '001', '110', '111'] Idx 5 requires neighborhood in ['000', '001', '110', '111'] Idx 6 requires neighborhood in ['000', '001', '110', '111'] Idx 7 requires neighborhood in ['000', '001', '110', '111'] Idx 8 requires neighborhood in ['010', '011', '100', '101'] Idx 9 requires neighborhood in ['000', '001', '110', '111'] Idx 10 requires neighborhood in ['010', '011', '100', '101'] Idx 11 requires neighborhood in ['010', '011', '100', '101'] Idx 12 requires neighborhood in ['010', '011', '100', '101'] Idx 13 requires neighborhood in ['010', '011', '100', '101'] Idx 14 requires neighborhood in ['010', '011', '100', '101'] Idx 15 requires neighborhood in ['010', '011', '100', '101'] Aggregating Probabilities & Sampling Greedy Candidate: Likelihood(1): 0:50% | 1:50% | 2:50% | 3:50% | 4:50% | 5:50% | 6:50% | 7:50% | 8:50% | 9:50% | 10:50% | 11:50% | 12:50% | 13:50% | 14:50% | 15:50% Greedy Candidate: 1111111111111111 Verification: Mismatch. Correction applied -> 1011111100101010
1011111100101010
deduction
Task: Deduction, Rule: 137 [111->1, 110->0, 101->0, 100->0, 011->1, 010->0, 001->0, 000->1], Steps: 15, Start: 10101101110011
Step 1 Scan: 0:[110]->0 | 1:[101]->0 | 2:[010]->0 | 3:[101]->0 | 4:[011]->1 | 5:[110]->0 | 6:[101]->0 | 7:[011]->1 | 8:[111]->1 | 9:[110]->0 | 10:[100]->0 | 11:[001]->0 | 12:[011]->1 | 13:[111]->1 Step 1 Output: 00001001100011 Step 2 Scan: 0:[100]->0 | 1:[000]->1 | 2:[000]->1 | 3:[001]->0 | 4:[010]->0 | 5:[100]->0 | 6:[001]->0 | 7:[011]->1 | 8:[110]->0 | 9:[100]->0 | 10:[000]->1 | 11:[001]->0 | 12:[011]->1 | 13:[110]->0 Step 2 Output: 01100001001010 Step 3 Scan: 0:[001]->0 | 1:[011]->1 | 2:[110]->0 | 3:[100]->0 | 4:[000]->1 | 5:[000]->1 | 6:[001]->0 | 7:[010]->0 | 8:[100]->0 | 9:[001]->0 | 10:[010]->0 | 11:[101]->0 | 12:[010]->0 | 13:[100]->0 Step 3 Output: 01001100000000 Step 4 Scan: 0:[001]->0 | 1:[010]->0 | 2:[100]->0 | 3:[001]->0 | 4:[011]->1 | 5:[110]->0 | 6:[100]->0 | 7:[000]->1 | 8:[000]->1 | 9:[000]->1 | 10:[000]->1 | 11:[000]->1 | 12:[000]->1 | 13:[000]->1 Step 4 Output: 00001001111111 Step 5 Scan: 0:[100]->0 | 1:[000]->1 | 2:[000]->1 | 3:[001]->0 | 4:[010]->0 | 5:[100]->0 | 6:[001]->0 | 7:[011]->1 | 8:[111]->1 | 9:[111]->1 | 10:[111]->1 | 11:[111]->1 | 12:[111]->1 | 13:[110]->0 Step 5 Output: 01100001111110 Step 6 Scan: 0:[001]->0 | 1:[011]->1 | 2:[110]->0 | 3:[100]->0 | 4:[000]->1 | 5:[000]->1 | 6:[001]->0 | 7:[011]->1 | 8:[111]->1 | 9:[111]->1 | 10:[111]->1 | 11:[111]->1 | 12:[110]->0 | 13:[100]->0 Step 6 Output: 01001101111100 Step 7 Scan: 0:[001]->0 | 1:[010]->0 | 2:[100]->0 | 3:[001]->0 | 4:[011]->1 | 5:[110]->0 | 6:[101]->0 | 7:[011]->1 | 8:[111]->1 | 9:[111]->1 | 10:[111]->1 | 11:[110]->0 | 12:[100]->0 | 13:[000]->1 Step 7 Output: 00001001111001 Step 8 Scan: 0:[100]->0 | 1:[000]->1 | 2:[000]->1 | 3:[001]->0 | 4:[010]->0 | 5:[100]->0 | 6:[001]->0 | 7:[011]->1 | 8:[111]->1 | 9:[111]->1 | 10:[110]->0 | 11:[100]->0 | 12:[001]->0 | 13:[010]->0 Step 8 Output: 01100001110000 Step 9 Scan: 0:[001]->0 | 1:[011]->1 | 2:[110]->0 | 3:[100]->0 | 4:[000]->1 | 5:[000]->1 | 6:[001]->0 | 7:[011]->1 | 8:[111]->1 | 9:[110]->0 | 10:[100]->0 | 11:[000]->1 | 12:[000]->1 | 13:[000]->1 Step 9 Output: 01001101100111 Step 10 Scan: 0:[101]->0 | 1:[010]->0 | 2:[100]->0 | 3:[001]->0 | 4:[011]->1 | 5:[110]->0 | 6:[101]->0 | 7:[011]->1 | 8:[110]->0 | 9:[100]->0 | 10:[001]->0 | 11:[011]->1 | 12:[111]->1 | 13:[110]->0 Step 10 Output: 00001001000110 Step 11 Scan: 0:[000]->1 | 1:[000]->1 | 2:[000]->1 | 3:[001]->0 | 4:[010]->0 | 5:[100]->0 | 6:[001]->0 | 7:[010]->0 | 8:[100]->0 | 9:[000]->1 | 10:[001]->0 | 11:[011]->1 | 12:[110]->0 | 13:[100]->0 Step 11 Output: 11100000010100 Step 12 Scan: 0:[011]->1 | 1:[111]->1 | 2:[110]->0 | 3:[100]->0 | 4:[000]->1 | 5:[000]->1 | 6:[000]->1 | 7:[000]->1 | 8:[001]->0 | 9:[010]->0 | 10:[101]->0 | 11:[010]->0 | 12:[100]->0 | 13:[001]->0 Step 12 Output: 11001111000000 Step 13 Scan: 0:[011]->1 | 1:[110]->0 | 2:[100]->0 | 3:[001]->0 | 4:[011]->1 | 5:[111]->1 | 6:[111]->1 | 7:[110]->0 | 8:[100]->0 | 9:[000]->1 | 10:[000]->1 | 11:[000]->1 | 12:[000]->1 | 13:[001]->0 Step 13 Output: 10001110011110 Step 14 Scan: 0:[010]->0 | 1:[100]->0 | 2:[000]->1 | 3:[001]->0 | 4:[011]->1 | 5:[111]->1 | 6:[110]->0 | 7:[100]->0 | 8:[001]->0 | 9:[011]->1 | 10:[111]->1 | 11:[111]->1 | 12:[110]->0 | 13:[101]->0 Step 14 Output: 00101100011100 Step 15 Scan: 0:[000]->1 | 1:[001]->0 | 2:[010]->0 | 3:[101]->0 | 4:[011]->1 | 5:[110]->0 | 6:[100]->0 | 7:[000]->1 | 8:[001]->0 | 9:[011]->1 | 10:[111]->1 | 11:[110]->0 | 12:[100]->0 | 13:[000]->1 Step 15 Output: 10001001011001
10001001011001
induction
Task: Induction, Start: 00001001100101100010, End: 10100000001010001110, Steps: 15, Hint: Class 3
Task: Find rule in Class 3. Candidates: [126, 90, 30, 105, 45, 150, 60] Attempt 1: Testing Rule 126 [111->0, 110->1, 101->1, 100->1, 011->1, 010->1, 001->1, 000->0] Sim Step 1: 00011111111111110111 Sim Step 2: 10110000000000011101 Sim Step 3: 11111000000000110111 Sim Step 4: 00001100000001111100 Sim Step 5: 00011110000011000110 Sim Step 6: 00110011000111101111 Sim Step 7: 11111111101100111001 Sim Step 8: 00000000111111101111 Sim Step 9: 10000001100000111001 Sim Step 10: 11000011110001101111 Sim Step 11: 01100110011011111000 Sim Step 12: 11111111111110001100 Sim Step 13: 10000000000011011111 Sim Step 14: 11000000000111110000 Sim Step 15: 11100000001100011001 Verification: Mismatch (Expected 10100000001010001110). Next... Attempt 2: Testing Rule 90 [111->0, 110->1, 101->0, 100->1, 011->1, 010->0, 001->1, 000->0] Sim Step 1: 00010111111001110101 Sim Step 2: 10100100001111010000 Sim Step 3: 00011010011001001001 Sim Step 4: 10111001111110110110 Sim Step 5: 00101111000010110110 Sim Step 6: 01001001100100110111 Sim Step 7: 00110111111011110101 Sim Step 8: 11110100001010010000 Sim Step 9: 10010010010001101001 Sim Step 10: 11101101101011100111 Sim Step 11: 00101101100010111100 Sim Step 12: 01001101110100100110 Sim Step 13: 10111101010011011111 Sim Step 14: 10100100001111010000 Sim Step 15: 00011010011001001001 Verification: Mismatch (Expected 10100000001010001110). Next... Attempt 3: Testing Rule 30 [111->0, 110->0, 101->0, 100->1, 011->1, 010->1, 001->1, 000->0] Sim Step 1: 00011111011101010111 Sim Step 2: 10110000010001010100 Sim Step 3: 10101000111011010111 Sim Step 4: 00101101100010010100 Sim Step 5: 01101001010111110110 Sim Step 6: 11001111010100000101 Sim Step 7: 00111000010110001101 Sim Step 8: 11100100110101011001 Sim Step 9: 00011111100101010111 Sim Step 10: 10110000011101010100 Sim Step 11: 10101000110001010111 Sim Step 12: 00101101101011010100 Sim Step 13: 01101001001010010110 Sim Step 14: 11001111111011110101 Sim Step 15: 00111000000010000101 Verification: Mismatch (Expected 10100000001010001110). Next... Attempt 4: Testing Rule 105 [111->0, 110->1, 101->1, 100->0, 011->1, 010->0, 001->0, 000->1] Sim Step 1: 11100001100011101000 Sim Step 2: 10101101101010110010 Sim Step 3: 01011111110101110001 Sim Step 4: 10110000011011010100 Sim Step 5: 01110111011111101000 Sim Step 6: 01011101110000110011 Sim Step 7: 10110111010110110011 Sim Step 8: 11111101101111110010 Sim Step 9: 10000111111000010001 Sim Step 10: 10110100001011000101 Sim Step 11: 11111001100111010011 Sim Step 12: 00001001100101100010 Sim Step 13: 11100001100011101000 Sim Step 14: 10101101101010110010 Sim Step 15: 01011111110101110001 Verification: Mismatch (Expected 10100000001010001110). Next... Attempt 5: Testing Rule 45 [111->0, 110->0, 101->1, 100->0, 011->1, 010->1, 001->0, 000->1] Sim Step 1: 11101001000111001010 Sim Step 2: 10011001010100001111 Sim Step 3: 00010001111101101000 Sim Step 4: 11010101000011011011 Sim Step 5: 00111111011010110110 Sim Step 6: 10100000110111101100 Sim Step 7: 11101110101100011000 Sim Step 8: 10011001111001010010 Sim Step 9: 10010001000001110011 Sim Step 10: 00010101011101000010 Sim Step 11: 11011111110011011010 Sim Step 12: 10110000000010110111 Sim Step 13: 01100111111011101100 Sim Step 14: 01000100000110011001 Sim Step 15: 11010101110100010001 Verification: Mismatch (Expected 10100000001010001110). Next... Attempt 6: Testing Rule 150 [111->1, 110->0, 101->0, 100->1, 011->0, 010->1, 001->1, 000->0] Sim Step 1: 00011110011100010111 Sim Step 2: 10101101101010110010 Sim Step 3: 10100000001010001110 Sim Step 4: 10110000011011010100 Sim Step 5: 10001000100000010111 Sim Step 6: 01011101110000110011 Sim Step 7: 01001000101001001100 Sim Step 8: 11111101101111110010 Sim Step 9: 01111000000111101110 Sim Step 10: 10110100001011000101 Sim Step 11: 00000110011000101100 Sim Step 12: 00001001100101100010 Sim Step 13: 00011110011100010111 Sim Step 14: 10101101101010110010 Sim Step 15: 10100000001010001110 Verification: Exact Match. Rule Confirmed.
111->1, 110->0, 101->0, 100->1, 011->0, 010->1, 001->1, 000->0
deduction
Task: Deduction, Rule: 128 [111->1, 110->0, 101->0, 100->0, 011->0, 010->0, 001->0, 000->0], Steps: 11, Start: 001011111000111001
Step 1 Scan: 0:[100]->0 | 1:[001]->0 | 2:[010]->0 | 3:[101]->0 | 4:[011]->0 | 5:[111]->1 | 6:[111]->1 | 7:[111]->1 | 8:[110]->0 | 9:[100]->0 | 10:[000]->0 | 11:[001]->0 | 12:[011]->0 | 13:[111]->1 | 14:[110]->0 | 15:[100]->0 | 16:[001]->0 | 17:[010]->0 Step 1 Output: 000001110000010000 Step 2 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[000]->0 | 4:[001]->0 | 5:[011]->0 | 6:[111]->1 | 7:[110]->0 | 8:[100]->0 | 9:[000]->0 | 10:[000]->0 | 11:[000]->0 | 12:[001]->0 | 13:[010]->0 | 14:[100]->0 | 15:[000]->0 | 16:[000]->0 | 17:[000]->0 Step 2 Output: 000000100000000000 Step 3 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[000]->0 | 4:[000]->0 | 5:[001]->0 | 6:[010]->0 | 7:[100]->0 | 8:[000]->0 | 9:[000]->0 | 10:[000]->0 | 11:[000]->0 | 12:[000]->0 | 13:[000]->0 | 14:[000]->0 | 15:[000]->0 | 16:[000]->0 | 17:[000]->0 Step 3 Output: 000000000000000000 Step 4 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[000]->0 | 4:[000]->0 | 5:[000]->0 | 6:[000]->0 | 7:[000]->0 | 8:[000]->0 | 9:[000]->0 | 10:[000]->0 | 11:[000]->0 | 12:[000]->0 | 13:[000]->0 | 14:[000]->0 | 15:[000]->0 | 16:[000]->0 | 17:[000]->0 Step 4 Output: 000000000000000000 Step 5 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[000]->0 | 4:[000]->0 | 5:[000]->0 | 6:[000]->0 | 7:[000]->0 | 8:[000]->0 | 9:[000]->0 | 10:[000]->0 | 11:[000]->0 | 12:[000]->0 | 13:[000]->0 | 14:[000]->0 | 15:[000]->0 | 16:[000]->0 | 17:[000]->0 Step 5 Output: 000000000000000000 Step 6 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[000]->0 | 4:[000]->0 | 5:[000]->0 | 6:[000]->0 | 7:[000]->0 | 8:[000]->0 | 9:[000]->0 | 10:[000]->0 | 11:[000]->0 | 12:[000]->0 | 13:[000]->0 | 14:[000]->0 | 15:[000]->0 | 16:[000]->0 | 17:[000]->0 Step 6 Output: 000000000000000000 Step 7 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[000]->0 | 4:[000]->0 | 5:[000]->0 | 6:[000]->0 | 7:[000]->0 | 8:[000]->0 | 9:[000]->0 | 10:[000]->0 | 11:[000]->0 | 12:[000]->0 | 13:[000]->0 | 14:[000]->0 | 15:[000]->0 | 16:[000]->0 | 17:[000]->0 Step 7 Output: 000000000000000000 Step 8 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[000]->0 | 4:[000]->0 | 5:[000]->0 | 6:[000]->0 | 7:[000]->0 | 8:[000]->0 | 9:[000]->0 | 10:[000]->0 | 11:[000]->0 | 12:[000]->0 | 13:[000]->0 | 14:[000]->0 | 15:[000]->0 | 16:[000]->0 | 17:[000]->0 Step 8 Output: 000000000000000000 Step 9 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[000]->0 | 4:[000]->0 | 5:[000]->0 | 6:[000]->0 | 7:[000]->0 | 8:[000]->0 | 9:[000]->0 | 10:[000]->0 | 11:[000]->0 | 12:[000]->0 | 13:[000]->0 | 14:[000]->0 | 15:[000]->0 | 16:[000]->0 | 17:[000]->0 Step 9 Output: 000000000000000000 Step 10 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[000]->0 | 4:[000]->0 | 5:[000]->0 | 6:[000]->0 | 7:[000]->0 | 8:[000]->0 | 9:[000]->0 | 10:[000]->0 | 11:[000]->0 | 12:[000]->0 | 13:[000]->0 | 14:[000]->0 | 15:[000]->0 | 16:[000]->0 | 17:[000]->0 Step 10 Output: 000000000000000000 Step 11 Scan: 0:[000]->0 | 1:[000]->0 | 2:[000]->0 | 3:[000]->0 | 4:[000]->0 | 5:[000]->0 | 6:[000]->0 | 7:[000]->0 | 8:[000]->0 | 9:[000]->0 | 10:[000]->0 | 11:[000]->0 | 12:[000]->0 | 13:[000]->0 | 14:[000]->0 | 15:[000]->0 | 16:[000]->0 | 17:[000]->0 Step 11 Output: 000000000000000000
000000000000000000
induction
Task: Induction, Start: 0000100111011001111, End: 1001010111010101100, Steps: 14, Hint: Class 3
Task: Find rule in Class 3. Candidates: [126, 150, 90, 45, 30, 105, 60] Attempt 1: Testing Rule 126 [111->0, 110->1, 101->1, 100->1, 011->1, 010->1, 001->1, 000->0] Sim Step 1: 1001111101111111001 Sim Step 2: 1111000111000001111 Sim Step 3: 0001101101100011000 Sim Step 4: 0011111111110111100 Sim Step 5: 0110000000011100110 Sim Step 6: 1111000000110111111 Sim Step 7: 0001100001111100000 Sim Step 8: 0011110011000110000 Sim Step 9: 0110011111101111000 Sim Step 10: 1111110000111001100 Sim Step 11: 1000011001101111111 Sim Step 12: 1100111111111000000 Sim Step 13: 1111100000001100001 Sim Step 14: 0000110000011110011 Verification: Mismatch (Expected 1001010111010101100). Next... Attempt 2: Testing Rule 150 [111->1, 110->0, 101->0, 100->1, 011->0, 010->1, 001->1, 000->0] Sim Step 1: 1001111010000110110 Sim Step 2: 1110110011001000000 Sim Step 3: 0100001100111100001 Sim Step 4: 0110010011011010011 Sim Step 5: 0001111100000011100 Sim Step 6: 0010111010000101010 Sim Step 7: 0110010011001101011 Sim Step 8: 0001111100110001000 Sim Step 9: 0010111011001011100 Sim Step 10: 0110010000111001010 Sim Step 11: 1001111001010111011 Sim Step 12: 0110110111010010001 Sim Step 13: 0000000010011111011 Sim Step 14: 1000000111101110000 Verification: Mismatch (Expected 1001010111010101100). Next... Attempt 3: Testing Rule 90 [111->0, 110->1, 101->0, 100->1, 011->1, 010->0, 001->1, 000->0] Sim Step 1: 1001011101011111001 Sim Step 2: 1110010100010001111 Sim Step 3: 0011100010101011000 Sim Step 4: 0110110100000011100 Sim Step 5: 1110110010000110110 Sim Step 6: 1010111101001110110 Sim Step 7: 0000100100111010110 Sim Step 8: 0001011011101000111 Sim Step 9: 1010011010100101101 Sim Step 10: 1001111000011001101 Sim Step 11: 1111001100111111101 Sim Step 12: 0001111111100000101 Sim Step 13: 1011000000110001000 Sim Step 14: 0011100001111010101 Verification: Mismatch (Expected 1001010111010101100). Next... Attempt 4: Testing Rule 45 [111->0, 110->0, 101->1, 100->0, 011->1, 010->1, 001->0, 000->1] Sim Step 1: 0110100100110001000 Sim Step 2: 0101100100100101011 Sim Step 3: 1111000100100111110 Sim Step 4: 1000010100100100001 Sim Step 5: 0011011100100101101 Sim Step 6: 0010110000100111011 Sim Step 7: 0011100110100100110 Sim Step 8: 1010000101100100100 Sim Step 9: 1110110111000100100 Sim Step 10: 1001101100010100100 Sim Step 11: 1001011001011100100 Sim Step 12: 1001110001110000100 Sim Step 13: 1001000101000110100 Sim Step 14: 1001010111010101100 Verification: Exact Match. Rule Confirmed.
111->0, 110->0, 101->1, 100->0, 011->1, 010->1, 001->0, 000->1
End of preview. Expand in Data Studio

ECA-Zero: Elementary Cellular Automata Reasoning Dataset

A "CIFAR-for-Reasoning" dataset designed to test sequence models on Deduction, Induction, and Abduction tasks with strict Chain-of-Thought supervision.

This dataset implements the paradigm proposed in "Absolute Zero: Reinforced Self-play Reasoning with Zero Data" (Zhao et al., 2025), but adapted for the deterministic environment of Elementary Cellular Automata (Rule 0-255). It isolates algorithmic reasoning capabilities without the noise of natural language or programming syntax.

Dataset Structure

The dataset contains 333,333 training examples and 3,333 test examples. The test set is strictly disjoint (no overlap of Rule/Start-State/Steps) from the training set.

Split Rows Description
Train 333,333 Mixed Deduction, Induction, Abduction
Test 3,333 Unseen configurations for zero-shot evaluation

Columns

  • task: The reasoning mode (deduction, induction, abduction).
  • input: The prompt provided to the model.
  • cot: The "Chain of Thought" reasoning trace.
  • target: The final answer.

Task Types & Trace Logic

Unlike standard synthetic datasets, ECA-Zero generates CoT traces that mimic specific algorithmic search strategies.

1. Deduction (Forward Simulation)

  • Goal: Given a Rule and Start State, predict the state after N steps.
  • Trace Strategy: Explicit Convolution. The trace logs the local window scanning for every bit transition (e.g., Idx 5: [001]->1).
  • Why: Forces the model to learn the local lookup-table application rather than memorizing global state transitions.

2. Induction (Rule Discovery)

  • Goal: Given Start/End states and a hint (Wolfram Class), identify the Rule.
  • Trace Strategy: Stochastic Search. The trace logs an agent proposing hypothesis rules, simulating them fully, and verifying against the target.
  • Logic: Includes failures and retries. If a distractor rule accidentally produces the correct output, the label is dynamically updated to reflect the found rule (Dynamic Labeling).

3. Abduction (Reverse Engineering)

  • Goal: Given an End State and Rule, find a valid Start State.
  • Trace Strategy: Likelihood of Priors (Backpropagation).
    • The trace calculates the local priors for every index (e.g., Idx 0 requires neighborhood in ['001', '100']).
    • It computes greedy likelihoods based on neighbor constraints.
    • It samples a candidate and performs forward verification.
  • Why: Teaches the model to solve Inverse Problems via constraint satisfaction rather than brute force.

Usage 

from datasets import load_dataset

dataset = load_dataset("kreasof-ai/ECA-Zero-Reasoning")

# Example Row
print(dataset['train'][0])

Wolfram Complexity Classes

The dataset is stratified across Wolfram classes to ensure diversity:

  • Class 1 (10%): Converges to uniformity (e.g., Rule 0).
  • Class 2 (20%): Periodic/Repetitive (e.g., Rule 108).
  • Class 3 (35%): Chaotic/Aperiodic (e.g., Rule 30).
  • Class 4 (35%): Complex Computation (e.g., Rule 110).

Citation

Inspired by:

@article{zhao2025absolute,
  title={Absolute Zero: Reinforced Self-play Reasoning with Zero Data},
  author={Zhao, Andrew and Wu, Yiran and Yue, Yang and others},
  journal={arXiv preprint arXiv:2505.03335},
  year={2025}
}
Downloads last month
122
Size of downloaded dataset files:
215 MB
Size of the auto-converted Parquet files:
215 MB
Number of rows:
336,666

Models trained or fine-tuned on kreasof-ai/ECA-Zero

Browse 12 models trained on this dataset

Paper for kreasof-ai/ECA-Zero