File size: 2,049 Bytes
e1b6c2e
 
 
c3aa1bb
e1b6c2e
 
 
 
 
cdfe084
e1b6c2e
c3aa1bb
 
 
e1b6c2e
cdfe084
 
 
 
 
 
 
 
c3aa1bb
e1b6c2e
c3aa1bb
 
e1b6c2e
c3aa1bb
 
e1b6c2e
 
 
 
 
c3aa1bb
 
 
e1b6c2e
 
cdfe084
 
 
 
 
 
 
 
 
 
c3aa1bb
e1b6c2e
c3aa1bb
 
e1b6c2e
 
cdfe084
c3aa1bb
cdfe084
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
from __future__ import annotations

import json
import struct
from pathlib import Path

from modchallenge.interface.base_model import ModularMultiplicationModel


class DlpTableBaseline(ModularMultiplicationModel):
    def load(self, model_dir: str) -> None:
        model_path = Path(model_dir)
        with (model_path / "weights.json").open("r", encoding="utf-8") as file:
            metadata = json.load(file)

        self._prime_to_table = {}
        for item in metadata["tables"]:
            prime = int(item["prime"])
            self._prime_to_table[str(prime)] = (
                prime,
                int(item["log_offset"]),
                int(item["exp_offset"]),
            )
        self._table_bytes = (model_path / "weights.bin").read_bytes()

    def preprocess_a(self, a: str) -> int:
        return self._encode_supported_residue(a)

    def preprocess_b(self, b: str) -> int:
        return self._encode_supported_residue(b)

    def preprocess_p(self, p: str) -> str:
        normalized = p.strip().lstrip("0")
        return normalized or "0"

    def predict_digits(self, a_enc: int, b_enc: int, p_enc: str) -> list[int]:
        table = self._prime_to_table.get(p_enc)
        if table is None:
            return [0]

        prime, log_offset, exp_offset = table
        a_residue = a_enc % prime
        b_residue = b_enc % prime
        if a_residue == 0 or b_residue == 0:
            return [0]

        log_a = self._read_u16(log_offset + a_residue)
        log_b = self._read_u16(log_offset + b_residue)
        answer_log = (log_a + log_b) % (prime - 1)
        answer = self._read_u16(exp_offset + answer_log)
        return [int(answer)]

    def _encode_supported_residue(self, value: str) -> int:
        residue = 0
        for char in value.strip():
            if "0" <= char <= "9":
                residue = residue * 10 + ord(char) - ord("0")
        return residue

    def _read_u16(self, entry_offset: int) -> int:
        return struct.unpack_from("<H", self._table_bytes, entry_offset * 2)[0]