from Crypto.Util.number import * from random impor...

Question

from Crypto.Util.number import *
from random import randint

flag = b"flag{*********}"
s = bytes_to_long(flag)
p = 167264670864949699243357401113153413519395292842449702828997572587750744834109623044157691349874788443790813991233493187794208993416335499200258467667251878377809772494422224799463216535077998226807333354887520008430717730163942897177961332163562331189299169807359374076510657092682573089393224676206465299481
k = 128
d = 2

www=[54205988582886778833457799475098659028926887812765603455747115607215401361621742985106290116194861063767444600441258507426158129383071764259602929436444817489805442555547918972855579813914210680247478024861432102196251008812915761410423068240889240928469255876570421762674154189999999792058567237621394396271,
4343825245377051766505786024070186727131854242224107955057658697141719731502298050775438124008054391043556285558776400249635735928087246121689525142171481609750710988915493632267888553552842244530750198651613701139984013488023194742902848230076510741997604547571596886981566463754331330080252181562481666127]
data = []
for _ in range(d):
t = www[_]
inv = inverse(s+t,p)
h = (inv >> k) << k
data.append((t, h))
print(p)
print(data)
'''
167264670864949699243357401113153413519395292842449702828997572587750744834109623044157691349874788443790813991233493187794208993416335499200258467667251878377809772494422224799463216535077998226807333354887520008430717730163942897177961332163562331189299169807359374076510657092682573089393224676206465299481
[(54205988582886778833457799475098659028926887812765603455747115607215401361621742985106290116194861063767444600441258507426158129383071764259602929436444817489805442555547918972855579813914210680247478024861432102196251008812915761410423068240889240928469255876570421762674154189999999792058567237621394396271,
2546698704243987536016492442967166113447850717026761327623738213470629383370759333483184881495588176808273661168597885481456942923393620297008613216304247190570943812048945341256947796531532546196494257883630230367512634958046836640727905189456714715052293584431397022936421091296508421575965932945498177536),
(4343825245377051766505786024070186727131854242224107955057658697141719731502298050775438124008054391043556285558776400249635735928087246121689525142171481609750710988915493632267888553552842244530750198651613701139984013488023194742902848230076510741997604547571596886981566463754331330080252181562481666127,
2802720220541111900541354867712021493670777147149794113335529387112961462634010734123202153568969265423470761636550474743567712207627701527848956111416129699136305492622854346336413265233450906832479683876769460583246976169424803168278765255846550373688672750611910856303146814284162789519551077992712110080)]
'''
教我这道CTF密码学题目，inverse函数是模逆元吗，告诉我解题的原理

Answer 1

先回答你最关心的点：Crypto.Util.number.inverse(u, v) 就是求模逆元——返回一个整数 u^{-1} (mod v)，满足

u \cdot inverse(u,v)\equiv 1\pmod v

在 PyCryptodome 的文档里它就写的是 “The inverse of u mod v”。 (pycryptodome.readthedocs.io)

题目在“泄露”什么信息？

你代码里（把未知 flag 看成整数 $s$ ）做了：

取大素数 $p$
对两个已知随机数 $t_1,t_2$
计算 $inv_i = (s+t_i)^{-1}\pmod p$
然后只输出 inv_i 的高位：
```
python
h = (inv >> k) << k   # k=128
```
这等价于把 inv 的 低 128 bit 直接抹掉置零，只留下高位。

所以对每个 $i$ 你实际上拿到的是：

inv_i = h_i + r_i,\quad 0\le r_i < 2^{128}

其中：

$h_i$ 是你拿到的（低 128 位为 0 的）值
$r_i$ 是被隐藏的低 128 位（未知，但很小）

为什么 2 组数据就能破？

如果我们知道完整的 $inv_i$ ，那就能直接还原 $s$ ：

s \equiv inv_i^{-1} - t_i \pmod p

但是你只知道 $inv_i$ 的高位，所以单独一条数据不够。

关键是你给了两条：同一个 $s$ ，对应 $(t_1,h_1)$ 、 $(t_2,h_2)$ 。于是：

inv_1^{-1}-t_1 \equiv inv_2^{-1}-t_2 \pmod p

移项得：

inv_2^{-1} - inv_1^{-1} \equiv t_2 - t_1 \pmod p

两边乘上 $inv_1inv_2$ （注意这是在模 $p$ 下合法的，因为 $p$ 是素数、逆元存在）：

inv_1 - inv_2 \equiv (t_2-t_1)\, inv_1\, inv_2 \pmod p

这一步非常核心：把“逆”的关系变成了只含 $inv_1, inv_2$ 的方程。

把未知量换成“已知高位 + 小误差”

写成：

inv_1 = h_1 + x,\quad inv_2 = h_2 + y,\quad 0\le x,y<2^{128}

代入上面的同余式：

(h_1+x) - (h_2+y) \equiv (t_2-t_1)(h_1+x)(h_2+y)\pmod p

展开后可以整理成一个**双线性（bilinear）**同余：

A + Bx + Cy + Dxy \equiv 0 \pmod p

其中 $A,B,C,D$ 都能由 $p,t_1,t_2,h_1,h_2$ 计算出来。

此时未知量只有 $x,y$ ，并且它们都被强约束在 $<2^{128}$ 的小范围内。

为什么要用格（LLL + Babai）？

因为这个同余里有 $xy$ 项，不是普通线性方程。

一个非常实用的“CTF 技巧”是：引入新变量把它线性化：

令

z = xy

则同余变成线性的：

Bx + Cy + Dz \equiv -A \pmod p

现在我们要找的是一个满足上式的 $(x,y,z)$ ，并且有范围约束：

$0\le x < 2^{128}$
$0\le y < 2^{128}$
$0\le z < 2^{256}$

这就是“小解的模线性方程”问题，非常适合用格方法做：

LLL 用于把格基约化，得到“更接近正交、含有短向量”的基。 (en.wikipedia.org)
Babai 最近平面算法（Nearest Plane / Nearest Hyperplane） 用于在 LLL 约化基上近似求解“最近向量问题 CVP”，把目标点投影回格里找到最近的格点。 (cims.nyu.edu)

直观理解：
我们构造一个格，使得格向量形如

(kp + Bx + Cy + Dz,\ x,\ y,\ z)

然后我们希望找到一个格向量，它的第一维刚好等于 $-A \bmod p$ ，同时后三维尽可能小（因为 $x,y,z$ 小）。这正是 CVP 的味道。

解题流程总结

写出： $inv_i=(s+t_i)^{-1}\pmod p,\quad inv_i=h_i+r_i$
利用同一个 $s$ 消去 $s$ ，得到只含 $inv_1,inv_2$ 的同余： $inv_1-inv_2 \equiv (t_2-t_1)inv_1inv_2 \pmod p$
代入 $inv_1=h_1+x,\ inv_2=h_2+y$ ，得到： $A+Bx+Cy+Dxy\equiv0\pmod p$
令 $z=xy$ ，化成线性： $Bx+Cy+Dz\equiv -A\pmod p$
用格（LLL + Babai）求出小解 $(x,y,z)$ ，再验证 $z=xy$ 。
还原完整逆元： $inv_1=h_1+x$
还原消息： $s \equiv inv_1^{-1}-t_1\pmod p$
long_to_bytes(s) 得到 flag。

给你一份可直接跑的 Python 解法（核心思路就是上面）

你这组数据我实际跑出来的 flag 是：

flag{H1de_S1cr1t_IsS0_Ezf01r_y0u}

下面代码包含：

计算 $A,B,C,D$
LLL 约化（我用了一个“纯 Python/分数”的简化 LLL）
Babai 最近平面
还原 flag

你如果用 SageMath，会更短（matrix(ZZ, ...).LLL()），但我先给你“纯 Python 版”思路更清晰。

python
from Crypto.Util.number import inverse, long_to_bytes
from fractions import Fraction

p = 167264670864949699243357401113153413519395292842449702828997572587750744834109623044157691349874788443790813991233493187794208993416335499200258467667251878377809772494422224799463216535077998226807333354887520008430717730163942897177961332163562331189299169807359374076510657092682573089393224676206465299481

t1 = 54205988582886778833457799475098659028926887812765603455747115607215401361621742985106290116194861063767444600441258507426158129383071764259602929436444817489805442555547918972855579813914210680247478024861432102196251008812915761410423068240889240928469255876570421762674154189999999792058567237621394396271
h1 = 2546698704243987536016492442967166113447850717026761327623738213470629383370759333483184881495588176808273661168597885481456942923393620297008613216304247190570943812048945341256947796531532546196494257883630230367512634958046836640727905189456714715052293584431397022936421091296508421575965932945498177536

t2 = 4343825245377051766505786024070186727131854242224107955057658697141719731502298050775438124008054391043556285558776400249635735928087246121689525142171481609750710988915493632267888553552842244530750198651613701139984013488023194742902848230076510741997604547571596886981566463754331330080252181562481666127
h2 = 2802720220541111900541354867712021493670777147149794113335529387112961462634010734123202153568969265423470761636550474743567712207627701527848956111416129699136305492622854346336413265233450906832479683876769460583246976169424803168278765255846550373688672750611910856303146814284162789519551077992712110080

# ---------- 1) 组出 A,B,C,D 使得 A + Bx + Cy + Dxy == 0 (mod p) ----------
delta = (t2 - t1) % p
A = (h1 - h2 - delta*h1*h2) % p
B = (1 - delta*h2) % p
C = (-1 - delta*h1) % p
D = (-delta) % p

# 线性化：Bx + Cy + Dz == -A (mod p), 其中 z = x*y
b = (-A) % p

# ---------- 2) 简化 LLL + Babai（最近平面） ----------
def nearest_int(frac: Fraction) -> int:
    num, den = frac.numerator, frac.denominator
    if num >= 0:
        return (2*num + den) // (2*den)
    else:
        return -((2*(-num) + den) // (2*den))

def gram_schmidt(basis):
    m = len(basis)
    n = len(basis[0])
    b_star = [[Fraction(0) for _ in range(n)] for _ in range(m)]
    mu = [[Fraction(0) for _ in range(m)] for _ in range(m)]
    Bn = [Fraction(0) for _ in range(m)]
    for i in range(m):
        b_star[i] = [Fraction(x) for x in basis[i]]
        for j in range(i):
            dot = sum(Fraction(basis[i][k]) * b_star[j][k] for k in range(n))
            mu[i][j] = dot / Bn[j]
            b_star[i] = [b_star[i][k] - mu[i][j]*b_star[j][k] for k in range(n)]
        Bn[i] = sum(b_star[i][k]*b_star[i][k] for k in range(n))
    return mu, b_star, Bn

def lll_reduce(basis, delta=Fraction(3,4)):
    basis = [list(map(int, row)) for row in basis]
    m = len(basis)
    n = len(basis[0])
    mu, b_star, Bn = gram_schmidt(basis)
    k = 1
    while k < m:
        # size reduction
        for j in range(k-1, -1, -1):
            r = nearest_int(mu[k][j])
            if r != 0:
                basis[k] = [basis[k][i] - r*basis[j][i] for i in range(n)]
                mu, b_star, Bn = gram_schmidt(basis)

        # Lovasz
        if Bn[k] >= (delta - mu[k][k-1]**2) * Bn[k-1]:
            k += 1
        else:
            basis[k], basis[k-1] = basis[k-1], basis[k]
            mu, b_star, Bn = gram_schmidt(basis)
            k = max(k-1, 1)
    return basis

def babai_closest_vector(basis, target):
    mu, b_star, Bn = gram_schmidt(basis)
    t = [Fraction(x) for x in target]
    m = len(basis)
    n = len(basis[0])
    coeffs = [0]*m
    for i in range(m-1, -1, -1):
        dot = sum(t[k]*b_star[i][k] for k in range(n))
        c = dot / Bn[i]
        k_i = nearest_int(c)
        coeffs[i] = k_i
        t = [t[k] - k_i*basis[i][k] for k in range(n)]
    v = [0]*n
    for i in range(m):
        for k in range(n):
            v[k] += coeffs[i]*basis[i][k]
    return v

# 这个格的行向量： (p,0,0,0), (B,1,0,0), (C,0,1,0), (D,0,0,1)
basis = [
    [p,0,0,0],
    [B,1,0,0],
    [C,0,1,0],
    [D,0,0,1],
]
basis_red = lll_reduce(basis)
v = babai_closest_vector(basis_red, [b,0,0,0])

# v 应该是 (b, x, y, z)
assert v[0] == b
x = v[1]
y = v[2]
z = v[3]
assert x*y == z

# ---------- 3) 还原 s ----------
inv1 = h1 + x
s = (inverse(inv1, p) - t1) % p
print(long_to_bytes(s))

你应该记住的“解题原理关键词”

模逆元泄露高位 / 截断泄露（truncated bits）
两条样本把同一个 secret $s$ 连起来
把“逆”的关系消掉，得到双线性同余
引入 $z=xy$ 线性化
LLL 约化 + Babai 最近平面解决“小解的模线性方程” (en.wikipedia.org)

如果你愿意，我也可以把“为什么这一步能线性化、为什么格一定能找回小解”的条件（比如解的大小和模数位数之间的关系）再用更数学一点的方式推导一遍。

Answer 2

你已经走到

Bx+Cy+Dz\equiv b\pmod p\qquad(\text{这里 }b\equiv -A\pmod p)

这一步非常关键：这就是典型的“模线性方程 + 小解”场景。接下来用到的“格方法”本质上是在做：

把“同余式”改写成“带未知倍数 $kp$ 的整数等式”，然后把它编码成一个**格（lattice）**里的点；因为 $x,y,z$ 很小，这个点会是某个格问题（CVP/SVP）里的“短向量/最近点”，用 LLL + Babai 就能找回来。

下面按你现在这一步开始解释。

1) 为什么说它是“小解的模线性方程”问题？

同余式

Bx+Cy+Dz\equiv b\pmod p

等价于存在某个整数 $k$ ，使得

Bx+Cy+Dz = b + kp.

也就是

kp + Bx + Cy + Dz = b.

这一步把“模 $p$ ”消掉了，变成了整数线性关系，只是多了个未知的 $k$ 。

现在你有 4 个未知整数 $(k,x,y,z)$ ，并且你知道一个关键额外信息：

|x|<2^{128},\ |y|<2^{128},\ |z|<2^{256}\quad(\text{小！})

而 $p$ 是 1024-bit（你说的 309 位十进制没错）。

这就是“小解”：在所有满足等式的整数解里，我们要找的是那个 $x,y,z$ 很小的解。

2) 什么是“格（lattice）”？这里怎么构造？

格可以理解成：在 $\mathbb{R}^n$ 里由一些“基向量”做整数线性组合得到的一堆离散点：

L = \left\{\sum_{i} u_i \mathbf{b}_i\ :\ u_i\in\mathbb{Z}\right\}.

二维的直观例子： $(1,0),(0,1)$ 的整数线性组合就是整点网格 $\mathbb{Z}^2$ 。

把你的等式编码成一个 4 维格

考虑 4 个向量（把它们看作“基向量”）：

\mathbf{b}_1=(p,0,0,0)

\mathbf{b}_2=(B,1,0,0)

\mathbf{b}_3=(C,0,1,0)

\mathbf{b}_4=(D,0,0,1)

那么任意整数 $k,x,y,z$ 的组合

k\mathbf{b}_1 + x\mathbf{b}_2 + y\mathbf{b}_3 + z\mathbf{b}_4

就是

(kp + Bx + Cy + Dz,\ x,\ y,\ z).

所以我们定义这个格：

L=\{(kp + Bx + Cy + Dz,\ x,\ y,\ z)\ :\ k,x,y,z\in\mathbb{Z}\}.

现在如果 $(x,y,z)$ 满足 $Bx+Cy+Dz=b+kp$ ，那么对应的格点正好是：

(b,\ x,\ y,\ z)\in L.

也就是说：你的解 $(x,y,z)$ 被编码成了格里的一个点，而且这个点的第 1 个坐标固定是 $b$ ，后 3 个坐标是我们要找的小数。

这就是“格方法”的核心转换。

3) CVP：为什么变成“找最近格点”？

令目标向量（不是格点）为：

\mathbf{t}=(b,0,0,0).

如果我们能在格 $L$ 中找到点 $(b,x,y,z)$ ，那它和 $\mathbf{t}$ 的距离就是

\| (b,x,y,z)-(b,0,0,0)\|=\sqrt{x^2+y^2+z^2},

而这因为 $x,y,z$ 有界（很小），所以这个格点会是一个非常近的候选。

于是问题变成了经典的格问题：

Closest Vector Problem (CVP)：给定一个格 $L$ 和目标点 $\mathbf{t}$ ，找离 $\mathbf{t}$ 最近的格点。(CSE UCSD)

在很多密码题里，这类“同余 + 小解”都会被包装成 CVP（或相关的 SVP 变体），然后用 LLL/Babai 做近似解。(Wikipedia)

4) LLL 是干什么的？

LLL（Lenstra–Lenstra–Lovász）基约化做的事可以一句话概括：

给你一个“很歪、很长”的格基，它把基变得“更短、更接近正交”，让你更容易在格里找短向量/最近点。(Wikipedia)

注意：LLL 不是直接“解方程”，它是一个预处理，把格的几何形状变得好用。

更形象一点：
原来的基可能像两根几乎平行的长杆（很难看出格点分布），LLL 会把它换成两根更短、夹角更大的杆（更像正交坐标），这时“找最近点”的舍入/投影策略才靠谱。(Wikipedia)

5) Babai 最近平面算法是干什么的？

LLL 之后通常配合 Babai’s Nearest Plane (Nearest Hyperplane) 算法来做 CVP 的近似求解：

从最后一维开始，把目标点投影到 Gram-Schmidt 正交化的方向上，然后逐维“取最近整数系数”，得到一个近似最近的格点。(CIMS)

直觉：像在二维格子上找离某点最近的整点：

如果格子是正方形网格，直接对坐标四舍五入就行；
如果格子被“剪切”成平行四边形网格，直接四舍五入会错；
LLL 让网格“更接近正方形”，Babai 就像“在这个更正的坐标系里做四舍五入”。(CIMS)

6) 那我们为什么能从 Babai 得到精确的 $(x,y,z)$ ？

这依赖一个“经验上非常常见、在 CTF 中通常成立”的几何事实：

在你构造的格里，确实存在格点 $(b,x,y,z)$ ；
并且这个解对应的 $(x,y,z)$ 足够小，使得它在目标 $(b,0,0,0)$ 附近“非常突出”；
LLL 让基更好，Babai 的近似就会命中这个突出点。

最后还会做一个验证：你本来就要求 $z=xy$ ，所以即使线性化后得到了某个 $(x,y,z)$ ，也要检查 $z\stackrel{?}=xy$ 。这一步把“可能的伪解”几乎都排掉。

7) 你关于“解的唯一性/概率”的理解对吗？

(a) 你的 p 位数判断对：p 是 309 位十进制，1024 bit

是的，这个 $p$ 的十进制长度是 309 位，对应 bit 长度 1024（你可以用 p.bit_length() 验证）。因此 $p\approx 2^{1024}$ 。

(b) 对原始的 $(x,y)$ 方程：为什么几乎只有一个小解？

原始（带 $xy$ 的）同余你可以看成：在 $N=2^{256}$ 个候选 $(x,y)$ 里找满足条件的。

如果把“对不同 $(x,y)$ 是否满足同余”当成近似随机事件（CTF 里常用的启发式），那么：

每个 $(x,y)$ 成为解的概率约 $\approx 1/p \approx 2^{-1024}$ ；
期望解数 $\approx N/p = 2^{256}/2^{1024}=2^{-768}\approx 10^{-231}$ 。

这意味着：如果 $(A,B,C,D)$ 真的是随机的，在这么小的范围里大概率根本没有解。

但你的题不是“随机出题”，而是“先种下（planted）一个真解”：
题目数据是由真实 secret $s$ 生成的，所以保证至少有一个真解 $(x_0,y_0)$ 。

那么你关心的是“会不会还有第二个小解？”
对“额外解”的启发式估计是：

\Pr(\exists\ \text{第二个小解}) \approx \frac{N-1}{p} \approx 2^{-768},

基本可以认为是 0。

所以结论是：几乎肯定只有一个小解（那个被种下的）。
你用“搜索空间大小 / 模数大小”来估计唯一性，这个方向是对的，只是要注意“本题是种了一个必然存在的解”。

(c) 引入 $z$ 以后，你说的 $2^{512}/10^{309}\approx 0$ 有哪些细节？

你把范围当作：

$x$ 约 $2^{128}$ 种
$y$ 约 $2^{128}$ 种
$z$ 约 $2^{256}$ 种
总共 $2^{512}$ 个三元组

然后拿 $2^{512}/p \approx 2^{-512}\approx 10^{-154}$ 来说“几乎不会撞出两个解”。这个数量级判断同样是在估计唯一性，方向没错。

但要补两个关键点：

线性同余 $Bx+Cy+Dz\equiv b\pmod p$ 在模 $p$ 意义下解非常多
因为它是 3 个变量 1 条线性约束：在 $(\mathbb{Z}/p\mathbb{Z})^3$ 里，它是一张“平面”，有大约 $p^2$ 个模解（比如随便选 $x,y$ ，就能解出唯一的 $z$ ）。
因此“解多不多”不是问题，问题是：在你这个小盒子 $[0,2^{128})\times[0,2^{128})\times[0,2^{256})$ 里，能不能有解、会不会不止一个。
你加 $z$ 并不是“为了让概率更小”，而是为了把 非线性项 $Dxy$ 变成线性项 $Dz$
也就是说，引入 $z$ 的目的主要是“线性化以便用格”，不是主要建立在概率估计上。

然后再用 $z=xy$ 这个验证条件，把线性化带来的伪解排除。

8) 把这一段和你的题完全对应起来（你可以对照理解）

在你这题里，最后确实能用 LLL + Babai 找到唯一的小解，并且满足 $z=xy$ 。我实际算到的那组是：

$x = 204797914155582675798458399559613710204$ （128 bit）
$y = 28624777682690119271227122081061734915$ （125 bit）
$z = xy$

然后 $inv_1 = h_1 + x$ ，再反推出 $s$ 进而得到 flag。

如果你想继续深入一点，我建议你下一步把注意力放在这句话上：

“我们为什么能相信 $(b,x,y,z)$ 会是目标 $(b,0,0,0)$ 的最近格点/足够近的格点？”

这涉及到两件事：

**如何给坐标做缩放（scaling）**让“短”更符合我们的界限（很多题要显式乘上 $2^{128}$ 、 $2^{256}$ 做权重）；
以及 LLL+Babai 在低维时为什么常常能直接命中。

你要是愿意，我可以用一个 2 维小玩具例子（比如 $ax\equiv b\pmod p$ 且 $x$ 很小）画出“格点/最近点”的直觉，再回到你这个 4 维例子，就会非常顺。

from Crypto.Util.number import * from random impor...

Câu hỏi

Suy nghĩ

Trả lời

题目在“泄露”什么信息？

为什么 2 组数据就能破？

把未知量换成“已知高位 + 小误差”

为什么要用格（LLL + Babai）？

解题流程总结

给你一份可直接跑的 Python 解法（核心思路就是上面）

你应该记住的“解题原理关键词”

Câu hỏi

Suy nghĩ

Trả lời

1) 为什么说它是“小解的模线性方程”问题？

2) 什么是“格（lattice）”？这里怎么构造？

把你的等式编码成一个 4 维格

3) CVP：为什么变成“找最近格点”？

4) LLL 是干什么的？

5) Babai 最近平面算法是干什么的？

6) 那我们为什么能从 Babai 得到精确的 $(x,y,z)$ ？

7) 你关于“解的唯一性/概率”的理解对吗？

(a) 你的 p 位数判断对：p 是 309 位十进制，1024 bit

(b) 对原始的 $(x,y)$ 方程：为什么几乎只有一个小解？

(c) 引入 $z$ 以后，你说的 $2^{512}/10^{309}\approx 0$ 有哪些细节？

8) 把这一段和你的题完全对应起来（你可以对照理解）

Chia sẻ Q&A này

Câu hỏi

Suy nghĩ

Trả lời

题目在“泄露”什么信息？

为什么 2 组数据就能破？

把未知量换成“已知高位 + 小误差”

为什么要用格（LLL + Babai）？

解题流程总结

给你一份可直接跑的 Python 解法（核心思路就是上面）

你应该记住的“解题原理关键词”

Câu hỏi

Suy nghĩ

Trả lời

1) 为什么说它是“小解的模线性方程”问题？

2) 什么是“格（lattice）”？这里怎么构造？

把你的等式编码成一个 4 维格

3) CVP：为什么变成“找最近格点”？

4) LLL 是干什么的？

5) Babai 最近平面算法是干什么的？

6) 那我们为什么能从 Babai 得到 精确 的 (x,y,z)(x,y,z)(x,y,z)？

7) 你关于“解的唯一性/概率”的理解对吗？

(a) 你的 p 位数判断对：p 是 309 位十进制，1024 bit

(b) 对原始的 (x,y)(x,y)(x,y) 方程：为什么几乎只有一个小解？

(c) 引入 zzz 以后，你说的 2512/10309≈02^{512}/10^{309}\approx 02512/10309≈0 有哪些细节？

8) 把这一段和你的题完全对应起来（你可以对照理解）

Chia sẻ Q&A này

6) 那我们为什么能从 Babai 得到精确的 $(x,y,z)$ ？

(b) 对原始的 $(x,y)$ 方程：为什么几乎只有一个小解？

(c) 引入 $z$ 以后，你说的 $2^{512}/10^{309}\approx 0$ 有哪些细节？