mimc（Mimco怎么读）

本篇文章给大家谈谈mimc，以及Mimco怎么读对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、肉有哪些英语单词
• 2、如何用Python编写一个素数环
• 3、抖音mimc女装是什么牌子
• 4、肉类英语

肉有哪些英语单词

在英语学习中，没有语法不能很好地表达，而没有词汇则什么也不能表达。大量词汇认知是培养语言技能的基础，对于初学者来说，词汇量远比结构准确性重要。那么肉有哪些英语单词呢?一起来了解下吧：

【肉有哪些英语单词】

Fresh Grade Legs(通常叫 Back on Leg) 大鸡腿

Fresh Grade Breast 鸡胸肉

Chicken Drumsticks 小鸡腿

Chicken Wings 鸡翅膀

ground pork (Minced Steak) 绞肉

Pigs Liver 猪肝

Pork Hock 猪肘子(煲汤挺好, 还有淮扬菜里的镇江淆肉就用肘子做的,这个俺很熟练)

Pigs feet 猪脚

Pigs Kidney 猪腰

Pigs Hearts 猪心

Pork Steak 没骨头的猪排

Pork Chops 连骨头的猪排

Rolled Porkloin 卷好的腰部瘦肉

Rolled Pork Belly 卷好的腰部瘦肉连带皮

Pork sausage meat 做香肠的绞肉

Smoked Bacon 醺肉

Pork Fillet 小里肌肉

Spare Rib Pork chops 带骨的瘦肉

Spare Rib of Pork 小排骨肉

Pork ribs 肋骨可煮汤食用

Black Pudding 黑香肠

Pork Burgers 汉堡肉

Pork-pieces 一块块的C肉

Pork Dripping 猪油滴

Lard 猪油

Hock 蹄膀

Casserole Pork 中间带骨的腿肉

Joint 有骨的大块肉

Stewing Beef 小块的瘦肉

Steak Kidney 牛肉块加牛腰

Frying steak 可煎食的大片牛排

Mimced Beef 牛绞肉

Rump Steak 大块牛排

Leg Beef 牛键肉

OX-Tail 牛尾

OX-heart 牛心

OX-Tongues 牛舌

Barnsley Chops 带骨的腿肉

Shoulder Chops 肩肉

Porter House Steak 腰上的牛排肉

Chuck Steak 头肩肉筋、 (这个部位的肉有时候油较多,哈哈)

Tenderised Steak 拍打过的牛排

Roll 牛肠

Cowhells 牛筋

Pig bag 猪肚

Homeycome Tripe 蜂窝牛肚

Tripe Pieces 牛肚块

Best thick seam 白牛肚

【肉类的英语单词】

Short Plate/Brisket Navel End /Navel(胸腹肥牛)

Shortribs (带骨牛小排)

Bnls Shortribs (去骨牛小排)

Tenderloin(牛柳)

Shortloin(带骨前腰脊肉)

Super Pastrimi (精修胸腹肥牛)

Striploin(西冷)

Ribs (带骨肋脊肉)

Ribeye/Cube Roll (眼肉)

Chuck Roll (肩胛肉卷 /上脑)

Boneless Chuck Shortribs (肩胛牛小排 )

Top Blade Muscle/ Digital Muscle (板腱 )

Finger Meat (牛肋条)

Omasum(牛百叶)

Scalded Aorta (牛心管 )

Backstraps /Paddywack(板筋)

Tripes(牛肚)

Abomasum

Tripe Pieces (肚片)

Mountain Chains (牛肚梁)

Honeycomb Tripes (金钱肚)

Tongues(牛舌)

Tunic Tissue/ Diaphragm Membrane (横隔筋)

Large Intestine (大肠)

Small Intestine (小肠)

OXlips (牛唇)

OXtails(牛尾)

Flexor Tendon (前蹄筋)

Hind Tendons (后蹄筋)

Chuck BBQ Ribs (肩胛肋排)and etc.

Tip-on Tongues(猪舌)

Pouch Stoamchs(整肚)

Split Stomachs(片肚)

Regular Front Feet(猪手)

Short Cut Front Feet(短切猪手)

Un-washed Whole Hearts(未洗整 猪心)

Snout(猪脸)

Ears Flaps (耳片)

Small Intestine (小肠)

Brisket Bone (胸骨)

Full Neck Bone(颈骨)

Kidney(猪腰)

Back Ribs (背小排)

Japan Soft Bone (日式软骨/小排) and etc.

Tom/Hen Whole Turkey Birds(公 /母整火鸡)

Tom / Hen Wings (公 /母火鸡全翅)

Drumettes (火鸡翅根)

Tom / Hen 2-Joint Wings (公 /母火鸡两节翅

Hearts (火鸡心)

Tom / Hen / Regular Drums(公 /母 /常规火鸡琵琶腿)

Tails (火鸡尾)

Tom / Hen Necks (公 /母火鸡颈)

Livers (火鸡肝)

Tom/Hen Gizzards (公/母火鸡胗)

Tom / Hen Thigh (公 /母火鸡大腿)

Fry(火鸡睾丸)

Ground Turkey(火鸡绞肉)

Breast(火鸡胸肉)

Bone-in Breast (火鸡带骨胸肉)

MDT and etc.

Wing Tips (翅尖)

Wing Middle Joint (翅中)

Whole Wings (整翅)

Drumsticks (琵琶腿)

Paws (凤爪)

Gizzards (鸡胗)

鹅肝 Goose Liver

【常见的肉类英语单词】

场景词汇

beef 牛肉

pork 猪肉

chicken 鸡肉

drumstick 鸡腿

wing 鸡翅

knuckle of pork 猪肘子

steak 牛排

pork chop 猪排

chop 肉排

lamb chop 羊排

leg of lamb 羊腿

fish ball 鱼丸

turkey 火鸡

salami 意大利腊肠

pork roast 烤猪肉

ground beef 牛肉馅

rib 排骨

liver 肝

thigh(鸡)大腿肉

你一定要会说的Top 10场景句

1. How much does this piece of beef cost?

这块牛肉多少钱?

2. You eat the drumstick.

你吃鸡腿。

3. Let's order two plates of chicken wings.

我们订两盘鸡翅吧。

4. Can you help Billie cut his steak?

你能帮比利切他的牛排吗?

5. The mint sauce for the lamb chops is here.

羊排用的薄荷酱在这里。

6. He wanted to try the fish balls.

他想试试鱼丸。

7. Can you make me a turkey sandwich?

你能给我做一个火鸡三明治吗?

8. I need ground beef to make this recipe.

我需要牛肉馅做这个食谱。

9. He wants barbeque ribs.

他想要烤排骨。

10. There's a lot of meat on the thighs.

大腿上有很多肉。

【关于肉的英语单词】

1，meat n. 肉; 食物; 实质;

2，veal n.牛肉; 小牛;

3，sirloin n. 牛里脊肉;

4，chop n. 排骨; 砍，剁; 掌劈; 嘴周围的地方;

5，stew n. 炖煮的菜肴; 烦恼，焦虑;

6，roast n. 烤肉; 户外烧烤野餐;

7，pork n. 猪肉; 〈美俚〉支持政党上台所分到的好处，政治分肥; 〈古〉猪;

8，ham n. 火腿; (旧时的) 小镇，村庄; 大腿后部; 拙劣演员(尤指表演过火者);

9，bacon n. 培根; 腊肉; 熏猪肉; 咸猪肉;

10，chicken n. 鸡; 鸡肉; 胆小鬼; 懦夫;

扩展资料

1，Meat and fish are relatively expensive.肉和鱼相对来说比较贵。

2，If you like steak, have the sirloin. It's tasty as can be.如果你想吃牛排，来块牛腰肉。再好吃不过了。

3，Lionel built a coop so that they could raise chickens and have a supply of fresh eggs.莱昂内尔做了个鸡笼，打算养些鸡，吃上新鲜鸡蛋。

4，Pork is also the most versatile of meats. It can be roasted whole or in pieces在肉类中，猪肉的做法也是最多的，可以整块烤来吃，也可以切片烤来吃。

如何用Python编写一个素数环

此文主要目的，是向大家展示如何才能用python语言，来部署STARK算法。

STARKs（可扩容的透明知识论证）是创建一种证明的技术，这项证明中f(x)=y，其中f可能要花很长的时间来进行计算，但是这个证明可以被很快验证。STARK是“双重扩容”：对于一个需要t步骤的计算，这会花费大约O(t * log(t))步骤才能完成这个证明，这可能是最优的情况，而且这需要通过~O(log2(t))个步骤才能验证，对于中等大小的T值，它比原始计算快得多。STARKs也拥有隐私保护的“零知识证明”的特性，虽然我们将这类使用案例应用到其中，从而完成可验证的延迟功能，不需要这类性质，所以我们不用担心。

首先，先请几项说明：

这个代码还没有完全审核；在实际使用案例中的情况，还不能保证

这部分代码是还没有达到理想状态（是用Python语言写的）

STARKs 的“真实情况” 倾向于使用二进制字段而不是素数域的特定应用程序效率的原因；但是，他们确实也表现出，这里写出的代码是合法并且可用的。

没有一个真实的方法来使用STARK。它是一个非常宽泛的加密和数学架构，同时为不同的应用有不同的设置，以及连续的研究来减少证明者和验证者的复杂性，同时提高可用性。

此文希望大家能够知道，模运算和素数域是如何运行的，

并且和多项式概念，插值和估值进行结合。

现在，让我们一起来了解吧！

MIMC

下面是STARK的功能展示：

def mimc(inp, steps, round_constants): start_time = time.time() for i in range(steps-1): inp = (inp**3 + round_constants[i % len(round_constants)]) % modulus print("MIMC computed in %.4f sec" % (time.time() - start_time)) return inp

我们选择MIMC作为案例，因为它（i）很容易理解，（ii）在真实世界使用的很多。函数功能见下图：

注意：在很多关于MIMC的讨论中，你可以典型地看出使用了XOR，而不是+；这是因为MIMC可以在二进制情况下使用，其中添加是XOR；这里我们会在素数领域进行。

在我们的案例中，常数相对而言会是比较小的列表（例如，64位），这会一直连续地进行周期循环（也就说，在k[64]之后）。MIMC自身可以获得这个特性，因为MIMC可以向后进行计算（从相应的输出获得输入），但是往后计算需要比向前计算多花费100倍的时间（并且没有方向可以同步进行）。所以你可以将往后计算的功能想象成计算不能同步的工作量证明，并且往前方向计算的功能可以作为验证的过程。

x - x(2p-1)/3 是x - x3 的反函数；根据费马小定理，这是真实的，尽管这个定理没有费马大定理出名，但是依然对数学的贡献很大。

我们尝试使用STARK来进行更加有效的验证，而不是让验证者必须在向前方向运行MIMC，在完成向后计算之后，证明者可以在向前方向进行STARK计算，并且验证者可以很简单地验证STARK。我们希望计算STARK可以比MIMC向前和向后之间的运行速度差别要小，所以证明者的时间仍然是有初始的向后计算来主导的。而并不是STARK计算。STARK的认证会相对较快（在python语言算法中，可以是0.05-0.3秒），不论初始的计算时间有多长。

所有的计算会在2256 – 351 * 232 + 1个模内完成；我们使用素数模，因为它是小于2256 最大的素数，其中乘法群包含了232 个子集（也就是说，有这样一个数g，从而在完全232次循环之后，G素数环的连续幂模绕回到1），而且是按照6k+5的形式。首个特性是保证FFT和FRI算法的有效版本，其次是保证MIMC实际上可以向后计算（请见上面提到的x - x(2p-1)/3 使用方法）。

素域操作

我们通过建立方便的等级来进行素域的操作，同时也有多项式的操作。代码如下，收首先是小数位数：

class PrimeField(): def __init__(self, modulus): # Quick primality test assert pow(2, modulus, modulus) == 2 self.modulus = modulus def add(self, x, y): return (x+y) % self.modulus def sub(self, x, y): return (x-y) % self.modulus def mul(self, x, y): return (x*y) % self.modulus

并且使用扩展欧几里得算法，来计算模块逆转（这和在素域中计算1/x相同）：

# Modular inverse using the extended Euclidean algorithm def inv(self, a): if a == 0: return 0 lm, hm = 1, 0 low, high = a % self.modulus, self.modulus while low 1: r = high//low nm, new = hm-lm*r, high-low*r lm, low, hm, high = nm, new, lm, low return lm % self.modulus

上面的算法是相对昂贵的；幸运地是，对于特定的案例，我们需要做很多的模逆计算，有一个数学方法可以让我们来计算很多逆运算，被称为蒙哥马利批量求逆：

使用蒙哥马利批量求逆来计算模逆，其输入为紫色，输出为绿色，乘法门为黑色，红色方块是唯一的模逆。

下面的代码是算法的体现，其中包含一些特别的逻辑。如果我们正在求逆的集合中包含零，那么它会将这些零的逆设置为 0 并继续前进。

def multi_inv(self, values): partials = [1] for i in range(len(values)): partials.append(self.mul(partials[-1], values[i] or 1)) inv = self.inv(partials[-1]) outputs = [0] * len(values) for i in range(len(values), 0, -1): outputs[i-1] = self.mul(partials[i-1], inv) if values[i-1] else 0 inv = self.mul(inv, values[i-1] or 1) return outputs

这部分算法接下来会验证称为非常重要的东西，特别是当我们开始和不同阶的多项式进行计算的时候。

现在我们来看看一些多项式计算。我们把多项式当做一个数据集，其中的i是第i阶（例如，x3 + 2x + 1变成[1, 2, 0, 1]）。下面就是在一个点进行多项式估算的方法：

# Evaluate a polynomial at a point def eval_poly_at(self, p, x): y = 0 power_of_x = 1 for i, p_coeff in enumerate(p): y += power_of_x * p_coeff power_of_x = (power_of_x * x) % self.modulus return y % self.modulus

困难和挑战

f.eval_poly_at([4, 5, 6], 2)的输出是多少？模是31吗？

下面的解释就是答案

.其实也有代码是多项式加法，减法，乘法和除法；这是很长的加减乘除运算。有一个很重要的内容是拉格朗日插值，它将一组 x 和 y 坐标作为输入，并返回通过所有这些点的最小多项式（你可以将其视为多项式求值的逆）：

# Build a polynomial that returns 0 at all specified xs def zpoly(self, xs): root = [1] for x in xs: root.insert(0, 0) for j in range(len(root)-1): root[j] -= root[j+1] * x return [x % self.modulus for x in root] def lagrange_interp(self, xs, ys): # Generate master numerator polynomial, eg. (x - x1) * (x - x2) * ... * (x - xn) root = self.zpoly(xs) # Generate per-value numerator polynomials, eg. for x=x2, # (x - x1) * (x - x3) * ... * (x - xn), by dividing the master # polynomial back by each x coordinate nums = [self.div_polys(root, [-x, 1]) for x in xs] # Generate denominators by evaluating numerator polys at each x denoms = [self.eval_poly_at(nums[i], xs[i]) for i in range(len(xs))] invdenoms = self.multi_inv(denoms) # Generate output polynomial, which is the sum of the per-value numerator # polynomials rescaled to have the right y values b = [0 for y in ys] for i in range(len(xs)): yslice = self.mul(ys[i], invdenoms[i]) for j in range(len(ys)): if nums[i][j] and ys[i]: b[j] += nums[i][j] * yslice return [x % self.modulus for x in b]

相关数学知识请参见此文的M-N部分。需要注意，我们也会有特别的方法lagrange_interp_4和lagrange_interp_2来加速次数小于 2 的拉格朗日插值和次数小于 4 的多项式运算。

快速傅立叶变换

如果你仔细阅读上面的算法，你也许会发现拉格朗日插值和多点求值（即求在N个点处次数小于N的多项式的值）都需要耗费2次时间，例如对于1000个点求拉格朗日插值，需要几百万个步骤，而且100万个点的拉格朗日插值需要万亿个步骤。这是不可接受的低效率，所以我们需要使用更加有效的算法，快速傅立叶变换。

FFT只需要花费O(n * log(n))的时间（也就是说，1000个点的计算需要10,000步，100万个点的计算需要2000步），虽然它的范围更受限制；x坐标必须是单位根部的完全集合，必须满足N = 2k 阶。也就是说，如果有N个点，那么x坐标必须某个P值的连续幂，1, p, p2, p3…，其中pN = 1。这个算法能够用来进行多点计算和插值计算，而且只需要调整一个小参数。

下面就是算法详情（这是个简单的表达方式；更详细内容可以参阅此处代码）

def fft(vals, modulus, root_of_unity): if len(vals) == 1: return vals L = fft(vals[::2], modulus, pow(root_of_unity, 2, modulus)) R = fft(vals[1::2], modulus, pow(root_of_unity, 2, modulus)) o = [0 for i in vals] for i, (x, y) in enumerate(zip(L, R)): y_times_root = y*pow(root_of_unity, i, modulus) o[i] = (x+y_times_root) % modulus o[i+len(L)] = (x-y_times_root) % modulus return o def inv_fft(vals, modulus, root_of_unity): f = PrimeField(modulus) # Inverse FFT invlen = f.inv(len(vals)) return [(x*invlen) % modulus for x in fft(vals, modulus, f.inv(root_of_unity))]

你可以自己通过一些输入来运行代码，并且看看是否能得到想要的结果，当你使用eval_poly_at的时候，给出你期望得到的答案。例如：

fft.fft([3,1,4,1,5,9,2,6], 337, 85, inv=True) [46, 169, 29, 149, 126, 262, 140, 93] f = poly_utils.PrimeField(337) [f.eval_poly_at([46, 169, 29, 149, 126, 262, 140, 93], f.exp(85, i)) for i in range(8)] [3, 1, 4, 1, 5, 9, 2, 6]

傅里叶变换会把[x[0] …. x[n-1]]作为输入，并且它的目标是输出x[0] + x[1] + … + x[n-1]作为首个元素，x[0] + x[1] * 2 + … + x[n-1] * w**(n-1)作为第二个元素，等等；快速傅里叶变换可以通过把数据分为两半，来完成这个，在两边都进行FFT，然后将结果结合在一起。

上图就是信息如何进行FFT运算的解释。请注意FFT是如何进行两次数据复制，并且进行粘合，直到你得到一个元素。

现在，我们把所有部分组合起来，看看整件事情是如何：def mk_mimc_proof(inp, steps, round_constants)，它生成运行 MIMC 函数的执行结果的证明，其中给定的输入为步骤数。首先，是一些 assert 函数：

# Calculate the set of x coordinates xs = get_power_cycle(root_of_unity, modulus) column = [] for i in range(len(xs)//4): x_poly = f.lagrange_interp_4( [xs[i+len(xs)*j//4] for j in range(4)], [values[i+len(values)*j//4] for j in range(4)], ) column.append(f.eval_poly_at(x_poly, special_x))

扩展因子是我们将要拉伸的计算轨迹（执行 MIMC 函数的“中间值”的集合）。

m2 = merkelize(column) # Pseudo-randomly select y indices to sample # (m2[1] is the Merkle root of the column) ys = get_pseudorandom_indices(m2[1], len(column), 40) # Compute the Merkle branches for the values in the polynomial and the column branches = [] for y in ys: branches.append([mk_branch(m2, y)] + [mk_branch(m, y + (len(xs) // 4) * j) for j in range(4)])

我们需要步数乘以扩展因子最多为 2^32，因为当 k 32 时，我们没有 2^k 次的单位根。

computational_trace_polynomial = inv_fft(computational_trace, modulus, subroot) p_evaluations = fft(computational_trace_polynomial, modulus, root_of_unity)

我们首个计算会是得出计算轨迹；也就是说，所有的计算中间值，从输入到输出。

assert steps = 2**32 // extension_factor assert is_a_power_of_2(steps) and is_a_power_of_2(len(round_constants)) assert len(round_constants) steps

然后，我们会从将计算轨迹转换为多项式，在单位根 g （其中，g^steps = 1）的连续幂的轨迹上“放下”连续值，然后我们对更大的集合——即单位根 g2 的连续幂，其中 g2^steps * 8 = 1（注意 g2^8 = g）的多项式求值。

# Generate the computational trace computational_trace = [inp] for i in range(steps-1): computational_trace.append((computational_trace[-1]**3 + round_constants[i % len(round_constants)]) % modulus) output = computational_trace[-1]

黑色： g1 的幂。紫色： g2 的幂。橙色：1。你可以将连续的单位根看作一个按这种方式排列的圆圈。我们沿着 g1的幂“放置”计算轨迹，然后扩展它来计算在中间值处（即 g2 的幂）的相同多项式的值。

我们可以将MIMC的循环常数转换为多项式。因为这些循环常数链是非常通常发生地（在我们的测试中，每64个步骤都会进行），最终证明他们形成了64阶的多项式，而且外面可以很容易计算出它的表达式，以及扩展式：

skips2 = steps // len(round_constants) constants_mini_polynomial = fft(round_constants, modulus, f.exp(subroot, skips2), inv=True) constants_polynomial = [0 if i % skips2 else constants_mini_polynomial[i//skips2] for i in range(steps)] constants_mini_extension = fft(constants_mini_polynomial, modulus, f.exp(root_of_unity, skips2))

假设其中有8192个步骤，并且有64个循环常数。这是我们想要做的：我们正在进行FFT，从而计算循环常数来作为g1128 的功能。然后我们在之间加入很多零，来完成g1本身的功能。因为g1128 大约每64步进行循环，我们知道g1这个功能也会同样。我们只计算这个扩展中的512个步骤，因为我们知道这个扩展会在每512步之后重复。现在，我们按照斐波那契案例中那样，计算C(P(x))，除了这次是计算，需要注意，我们不在计算使用系数形式的多项式；而是根据高次单位根的连续幂来对多项式进行求值。

c_of_p需要满足Q(x) = C(P(x), P(g1*x)，K(x)) = P(g1*x) – P(x)**3 – K(x)；目标是对于任何我们放入计算轨道的x（除了最后一步，因为在最后一步之后，就没有步骤），计算轨迹中的下个数值就和之前的相等，再加上循环常量。与第1部分中的斐波那契示例不同，其中如果某个计算步骤是在k向量，下个就会是k+1向量，我们把低次单位根（ g1 ）的连续幂放下计算轨迹，所以如果某个计算步骤是在x = g1i ，下个步骤就会在g1i+1 = g1i * g1 = x * g1。因此，对于低阶单位根（ g1 ）的每一个幂，我们希望最终会是P(x*g1) = P(x)**3 + K(x)，或者P(x*g1) – P(x)**3 – K(x) = Q(x) = 0。因此，Q(x) 会在低次单位根 g 的所有连续幂上等于零（除了最后一个）。

# Create the composed polynomial such that # C(P(x), P(g1*x), K(x)) = P(g1*x) - P(x)**3 - K(x) c_of_p_evaluations = [(p_evaluations[(i+extension_factor)%precision] - f.exp(p_evaluations[i], 3) - constants_mini_extension[i % len(constants_mini_extension)]) % modulus for i in range(precision)] print('Computed C(P, K) polynomial')

有个代数定理证明，如果Q(x)在所有这些x坐标，都等于零，那么最小多项式的乘积就会在所有这些x坐标等于零：Z(x) = (x – x_1) * (x – x_2) * … * (x – x_n)。通过证明在任何单个的坐标，Q(x)是等于零，我们想要证明这个很难，因为验证这样的证明比运行原始计算需要耗费更长的时间，我们会使用一个间接的方式来证明Q(x)是Z(x)的乘积。并且我们会怎么做呢？通过证明D(x) = Q(x) / Z(x)，并且使用FRI来证明它其实是个多项式，而不是个分数。

我们选择低次单位根和高次单位根的特定排列，因为事实证明，计算Z(x)，而且除以Z(x)也十分简单：Z 的表达式是两项的一部分。

需要注意地是，直接计算Z的分子和分母，然后使用批量模逆的方法将除以Z转换为乘法，随后通过 Z(X) 的逆来逐点乘以 Q(x) 的值。需要注意，对于低次单位根的幂，除了最后一个，都可以得到Z(x) = 0，所以这个计算包含其逆计算就会中断。这是非常不幸的，虽然我们会通过简单地修改随机检查和FRI算法来堵住这个漏洞，所以就算我们计算错误，也没关系。

因为Z(x)可以简洁地表达，我们也可以获得另个好处：验证者对于任何特别的x，可以快速计算Z(x)，而且还不需要任何提前计算。对于证明者来说，我们可以接受证明者必须处理大小等于步数的多项式，但我们不想让验证者做同样的事情，因为我们希望验证过程足够简洁。

# Compute D(x) = Q(x) / Z(x) # Z(x) = (x^steps - 1) / (x - x_atlast_step) z_num_evaluations = [xs[(i * steps) % precision] - 1 for i in range(precision)] z_num_inv = f.multi_inv(z_num_evaluations) z_den_evaluations = [xs[i] - last_step_position for i in range(precision)] d_evaluations = [cp * zd * zni % modulus for cp, zd, zni in zip(c_of_p_evaluations, z_den_evaluations, z_num_inv)] print('Computed D polynomial')

在几个随机点上，进行概念检测D(x) * Z(x) = Q(x)，从而可以验证转账约束，每个计算步骤是之前步骤的有效结果。但是我们也想验证边界约束，其中计算的输入和输出就是证明者所说的那样。只是要求证明者提供P(1), D(1), P(last_step)还有D(last_step)的数值，这些都是很脆弱的；没有证明，那些数值都是在同个多项式。所以，我们使用类似的多项式除法技巧：

# Compute interpolant of ((1, input), (x_atlast_step, output)) interpolant = f.lagrange_interp_2([1, last_step_position], [inp, output]) i_evaluations = [f.eval_poly_at(interpolant, x) for x in xs] zeropoly2 = f.mul_polys([-1, 1], [-last_step_position, 1]) inv_z2_evaluations = f.multi_inv([f.eval_poly_at(quotient, x) for x in xs]) # B = (P - I) / Z2 b_evaluations = [((p - i) * invq) % modulus for p, i, invq in zip(p_evaluations, i_evaluations, inv_z2_evaluations)] print('Computed B polynomial')

那么，我们的论证如下。证明者想要证明P(1) == input和P(last_step) == output。如果我们将I(x)作为插值，那么就是穿越(1, input)和(last_step, output)亮点的线，于是P(x) – I(x)就会在这亮点上等于零。因此，它会证明P(x) – I(x)是P(x) – I(x)的乘积，并且我们通过提高商数来证明这点。

紫色：计算轨迹多项式 (P) 。绿色：插值 (I)（注意插值是如何构造的，其在 x = 1 处等于输入（应该是计算轨迹的第一步），在 x=g^(steps-1) 处等于输出（应该是计算轨迹的最后一步）。红色：P-I。黄色：在x = 1和 x=g^(steps-1)（即 Z2）处等于 0 的最小多项式。粉红色：(P – I) / Z2。

现在，我们来看看将P，D和B的默克尔根部组合在一起。

现在，我们需要证明P，D和B其实都是多项式，并且是最大的正确阶数。但是FRI证明是很大且昂贵的，而且我们不想有三个FRI证明，所以，我们计算 P，D 和 B 的伪随机线性组合，并且基于它来进行FRI证明：

# Compute their Merkle roots mtree = merkelize([pval.to_bytes(32, 'big') + dval.to_bytes(32, 'big') + bval.to_bytes(32, 'big') for pval, dval, bval in zip(p_evaluations, d_evaluations, b_evaluations)]) print('Computed hash root')

除非所有这三个多项式有正确的低阶，不然几乎不可能有随机选择的线性组合，所以这很足够。

我们想要证明D的阶数小于2 * steps，而且P 和 B 的次数小于steps，所以我们其实使用了随机的P, P * xsteps, B, Bsteps 和 D的随机组合，并且可以看出这部分组合是小于2 * steps。

现在，我们来检查下所有的多项式组合。我们先获得很多随机的索引，然后在这些索引上为默克尔树枝提供多项式：

k1 = int.from_bytes(blake(mtree[1] + b'\x01'), 'big') k2 = int.from_bytes(blake(mtree[1] + b'\x02'), 'big') k3 = int.from_bytes(blake(mtree[1] + b'\x03'), 'big') k4 = int.from_bytes(blake(mtree[1] + b'\x04'), 'big') # Compute the linear combination. We don't even bother calculating it # in coefficient form; we just compute the evaluations root_of_unity_to_the_steps = f.exp(root_of_unity, steps) powers = [1] for i in range(1, precision): powers.append(powers[-1] * root_of_unity_to_the_steps % modulus) l_evaluations = [(d_evaluations[i] + p_evaluations[i] * k1 + p_evaluations[i] * k2 * powers[i] + b_evaluations[i] * k3 + b_evaluations[i] * powers[i] * k4) % modulus for i in range(precision)]

get_pseudorandom_indices函数会回复[0…precision-1]范围中的随机索引，而且exclude_multiples_of参数并不会给出特定参数倍数的值。这就保证了，我们不会沿着原始计算轨迹进行采样，否则就会获得错误的答案。

证明是由一组默克尔根、经过抽查的分支以及随机线性组合的低次证明组成：

# Do some spot checks of the Merkle tree at pseudo-random coordinates, excluding # multiples of `extension_factor` branches = [] samples = spot_check_security_factor positions = get_pseudorandom_indices(l_mtree[1], precision, samples, exclude_multiples_of=extension_factor) for pos in positions: branches.append(mk_branch(mtree, pos)) branches.append(mk_branch(mtree, (pos + skips) % precision)) branches.append(mk_branch(l_mtree, pos)) print('Computed %d spot checks' % samples)

整个证明最长的部分是默克尔树分支，还有FRI证明，这是有更多分支来组成的。这是验证者的实质结果：

o = [mtree[1], l_mtree[1], branches, prove_low_degree(l_evaluations, root_of_unity, steps * 2, modulus, exclude_multiples_of=extension_factor)]

在每个位置，证明者需要提供一个默克尔证明，从而让验证者能够检查这个默克尔证明，并且检查C(P(x), P(g1*x), K(x)) = Z(x) * D(x)以及B(x) * Z2(x) + I(x) = P(x)（提醒：对于不在初始计算轨道上的x，Z(x)不会是零，所以C(P(x), P(g1*x), K(x)也不会是零)。验证者也会检查线性组合是正确的，然后调用。

for i, pos in enumerate(positions): x = f.exp(G2, pos) x_to_the_steps = f.exp(x, steps) mbranch1 = verify_branch(m_root, pos, branches[i*3]) mbranch2 = verify_branch(m_root, (pos+skips)%precision, branches[i*3+1]) l_of_x = verify_branch(l_root, pos, branches[i*3 + 2], output_as_int=True) p_of_x = int.from_bytes(mbranch1[:32], 'big') p_of_g1x = int.from_bytes(mbranch2[:32], 'big') d_of_x = int.from_bytes(mbranch1[32:64], 'big') b_of_x = int.from_bytes(mbranch1[64:], 'big') zvalue = f.div(f.exp(x, steps) - 1, x - last_step_position) k_of_x = f.eval_poly_at(constants_mini_polynomial, f.exp(x, skips2)) # Check transition constraints Q(x) = Z(x) * D(x) assert (p_of_g1x - p_of_x ** 3 - k_of_x - zvalue * d_of_x) % modulus == 0 # Check boundary constraints B(x) * Z2(x) + I(x) = P(x) interpolant = f.lagrange_interp_2([1, last_step_position], [inp, output]) zeropoly2 = f.mul_polys([-1, 1], [-last_step_position, 1]) assert (p_of_x - b_of_x * f.eval_poly_at(zeropoly2, x) - f.eval_poly_at(interpolant, x)) % modulus == 0 # Check correctness of the linear combination assert (l_of_x - d_of_x - k1 * p_of_x - k2 * p_of_x * x_to_the_steps - k3 * b_of_x - k4 * b_of_x * x_to_the_steps) % modulus == 0

其实还没有完成成功；证明对跨多项式检查和 FRI 所需的抽查次数的可靠性分析是非常棘手的。但是这些就是所有代码，至少你不用担心进行疯狂的优化。当我运行以上代码的时候，我们会获得STARK证明，会有300-400倍的证明成本例如，一个需要 0.2 秒的 MIMC 计算需要 60 秒来证明）。这就使得4核机器计算MIMC中的 STARK，实际上可以比后向计算 MIMC 更快。也就是说，在python语言，这会相对低效的实现，并且这也会证明运行时间比例会不同。同时，也值得指出，MIMC 的 STARK 证明成本非常低，因为MIMC几乎是完美地可计算，它的数学形式很简单。对于平均计算，会包含更少的清晰计算（例如，检查一个数是大于还是小于另一个），其计算成本可能会更高，会有大约10000-50000倍。

抖音mimc女装是什么牌子

这款服饰非常好的，而且质地也相当的好，做工非常的精细这款服饰的做工非常的精细。

抖音是一款音乐创意短视频社交软件,是一个专注年轻人的15秒音乐短视频社区。用户可以通过这款软件选择歌曲,拍摄15秒的音乐短视频,形成自己的作品。

肉类英语

肉类大全英语

单词在英语中重不重要,不在于单词本身,而在于我们对它的熟知程度，熟悉一些常见食物的英语是很有必要的，肉类是我们日常饮食中必不可少的食物，它可以提供人体所需要的多种维生素和营养物质，下面一起来看一下肉类大全英语。

肉类英语1

猪肉pork

猪排chop

五花肉 streaky pork/marbled beef

肥肉faty meat

瘦肉len meat

前腿fre leg

后腿ind leg

猪蹄pettitoes

脚爪hock foot

蹄筋sinew

软骨gristle

牛肉beef roast

小牛肉veal

碎牛肉ground beef

牛排steak

牛腿肉silverside

牛腰肉sirloin

羊肉mutton

鹿肉venison

羊排lamb chop

羊腿gigot

鸡腿drumstick

鸭翅膀duck wing

腊肉preserved ham

Meat分为三种：beef 牛肉、pork 猪肉 和 lamb 羊肉

beef :

1 roast 烤焙

2 steak 牛排

3 stewing beef 炖煮用牛肉

4 ground beef 绞牛肉

5 beef ribs 牛排骨

6 veal cutlets 牛肉片

7 liver 牛肝

8 tripe 牛肚

pork: 1 ham 火腿

2 pork chops 排骨

3 bacon 腌猪肉

4 sausage 香肠

lamb: 1 lamb shanks 羊腿肉

2 leg of lamb 羊腿

3 lamb chops 羊排

鸡以身体部位分：

大鸡腿

Fresh Grade Legs

鸡胸肉

Fresh Grade Breast

小鸡腿

Chicken Drumsticks

鸡翅膀

Chicken Wings

其它部位及内藏。

猪肉则分：

绞肉

Minced Steak

猪肝

Pigs Liver

猪脚

Pigs feet

猪腰

Pigs Kidney

猪心

Pigs Hearts

猪肚

Pig bag

没骨头的猪排

Pork Steak

连骨头的猪排

Pork Chops

卷好的腰部瘦肉

Rolled Porkloin

卷好的腰部瘦肉连带皮

Rolled Pork Belly

做香肠的绞肉

Pork sausage meat

醺肉

Smoked Bacon

小里肌肉

Pork Fillet

带骨的`瘦肉

Spare Rib Pork chops

小排骨肉

Spare Rib of Pork

肋骨

Pork ribs (ps可煮汤食用)

汉堡肉

Pork Burgers

一块块的廋肉

Pork-pieces

猪油滴

Pork Dripping

猪油

Lard

蹄膀

Hock

中间带骨的腿肉

Casserole Pork

有骨的大块肉

Joint

牛肉则分：

小块的瘦肉

Stewing Beef

牛肉块加牛腰

Steak Kidney

可煎食的大片牛排

Frying steak

牛绞肉

Mimced Beef

大块牛排

Rump Steak

牛键肉

Leg Beef

牛尾

OX-Tail

牛心

OX-heart

牛舌

OX-Tongues

带骨的腿肉

Barnsley Chops

肩肉

Shoulder Chops

腰上的牛排肉

Porter House Steak

头肩肉筋、油较多

Chuck Steak

拍打过的牛排

Tenderised Steak

肉类英语2

牛肉beef

猪肉pork

羊肉 mutton

羔羊肉lamb

鸡肉chicken

鸭肉 duck

鸭胸肉 duck breast

肋骨 rib

排骨 chop

肉馅，肉沫 ground meat

牛排 steak

腱子肉 tendon

五花肉 streaky pork

肘子 pork joint

鲤鱼carp

草鱼 grass carp

鲫鱼 crucian

咸猪肉bacon

瘦肉 lean meat

肥肉speck

肉类英语3

猪肉pork 猪排chop 五花肉 streaky pork/marbled beef

肥肉fatty meat 瘦肉lean meat 前腿fore leg 后腿hind leg

猪蹄pettitoes 脚爪hock foot 蹄筋sinew 软骨gristle

牛肉beef roast 小牛肉veal 碎牛肉ground beef 牛排steak

牛腿肉silverside 牛腰肉sirloin 羊肉mutton 鹿肉venison

羊排lamb chop 羊腿gigot 鸡腿drumstick 鸭翅膀duck wing

腊肉preserved ham 香肠sausage 鱼圆fishball 虾皮dried small shrimps

海蜇jelly fish 蚝oyster 三文鱼/鲑鱼salmon 鲈鱼weever

鳝eel 金枪鱼tuna 带鱼hairtail 海参sea cucumber

明虾prawn 虾仁peeled prawns 龙虾lobster 小龙虾crawfish

扇贝/鲜贝scallop 鲍鱼abalone 海带kelp蛤clam 蛏子razor clam

虾子shrimp’s egg 鱼子roe 凤尾鱼anchovy 鳕鱼cod

鲳鱼pomfret 青鱼herring 鲭mackerel 淡菜moule 旗鱼swordfish

沙丁鱼pilchard/sardine 海螺whelk 海蜇jellyfish 蚌mussel

海扇cockle 比目鱼plaice 海鳗eel 墨鱼cuttlefish

关于mimc和Mimco怎么读的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。