## APPROXIMATELY COUNTING SEMISMOOTH INTEGERS

Apr 24, 2013 - DS] 24 Apr 2013. APPROXIMATELY COUNTING SEMISMOOTH INTEGERS. ERIC BACH AND JONATHAN SORENSON. Abstract. An integer n ...

APPROXIMATELY COUNTING SEMISMOOTH INTEGERS

arXiv:1301.5293v2 [cs.DS] 24 Apr 2013

ERIC BACH AND JONATHAN SORENSON

Abstract. An integer n is (y, z)-semismooth if n = pm where m is an integer with all prime divisors ≤ y and p is 1 or a prime ≤ z. Large quantities of semismooth integers are utilized in modern integer factoring algorithms, such as the number field sieve, that incorporate the so-called large prime variant. Thus, it is useful for factoring practitioners to be able to estimate the value of Ψ(x, y, z), the number of (y, z)-semismooth integers up to x, so that they can better set algorithm parameters and minimize running times, which could be weeks or months on a cluster supercomputer. In this paper, we explore several algorithms to approximate Ψ(x, y, z) using a generalization of Buchstab’s identity with numeric integration.

1. Introduction The security of the public-key cryptosystem RSA [18, 22] is based on the practical difficulty of integer factoring. The fastest current general-purpose integer factoring algorithm is the number field sieve [9, 17], which in its basic form makes use of smooth numbers, integers with only small prime divisors. This has inspired research into algorithms to approximately count smooth numbers [5, 6, 15, 20, 24, 26, 27]. However, most implementations of the number field sieve make use of the so-called large prime variant [9, §6.1.4]. So we want, in fact, to count smooth integers that admit at most one slightly larger prime divisor, or semismooth numbers. (See, for example, the details on the factorization of a 768-bit RSA modulus  where smoothness bounds are discussed near the end of §2.2.) The principal contribution of this paper is twofold: (1) We present data showing that the key to estimating Ψ(x, y, z) accurately is an algorithm to estimate Ψ(x, y) accurately, and (2) We present head-to-head comparisons of five algorithms for estimating Ψ(x, y, z). Previous work was done by Bach and Peralta  and generalized by Zhang and Ekkelkamp [10, 29]; we discuss this below. This paper is organized as follows. We begin with some definitions, and briefly discuss computing exact counts of semismooth integers. We then give our main theoretical result, a generalized Buchstab identity, which together with numerical integration, is the basis of all our algorithms. We then present five different algorithms in some detail, two based on the Dickman ρ function and three based on the saddle point methods of Hildebrand and Tenenbaum , along with empirical results for each algorithm. As one might expect, we discover a tradeoff in algorithm Date: 24 April 2013. 1

2

ERIC BACH AND JONATHAN SORENSON

Table 1. Exact Values of Ψ(x, y, z), x = 240 y 22 24 26 28 210 212 214 216 218 220

z = 210 z = 212 z = 214 z = 216 z = 218 z = 220 58916 170906 503392 1500366 4513650 13597105 6132454 15111450 36766896 88920834 213965871 508848834 323105012 678707129 1326493628 2499496319 4603776946 8298713253 3157707079 6694272918 11837179134 19296840890 30059136386 45290571262 7138986245 21494669620 39400743040 61719198990 89501569374 123782024151 — 30641713551 68600140477 111769092210 160884758713 215725604647 — — 80324574755 145583683889 214469637137 286977146180 — — — 155283653287 241316058768 329068435579 — — — — 248857736183 349745847766 — — — — — 354983289990

choice between speed and accuracy. We follow this up with an elaboration on some numerical details.

2. Definitions Let P (n) denote the largest prime divisor of the positive integer n, with P (1) = 1. An integer n is y-smooth if P (n) ≤ y, and Ψ(x, y) counts the integers n ≤ x that are y-smooth. An integer n is (y, z)-semismooth if we can write n = mp where m is y-smooth and p ≤ z is a prime or 1. Ψ(x, y, z) counts the integers n ≤ x that are (y, z)semismooth. (Generalizations to more than one exceptional prime have been defined by Zhang and Ekkelkamp [10, 29].) Observe that Ψ(x, y, y) = Ψ(x, y), the function Ψ(x, y, x) counts integers whose second-largest prime divisor is bounded by y, and Ψ(x, 1, z) = min{π(x), π(z)}, where π(x) is the number of primes up to x. Our basic unit of work is the floating point operation. Along with the four basic arithmetic operations (+, −, ×, ÷) we include square roots, logarithms, and exponentials, since their complexity is close to that of multiplication (see for example ).

3. Exact Counts Using a prime number sieve, such as the sieve of Eratosthenes, we can completely factor all integers up to x in O(x log log x) arithmetic operations, and thereby compute exact values of Ψ(x, y, z). Of course this is not a practical approach for large x, but it is useful for evaluating the accuracy of approximation algorithms, which is what we do here. So we wrote a program to do this, based on a segmented sieve of Eratosthenes (see  for prime number sieve references), and we ran our program up to x = 1099511627776 = 240 . Our results for this largest value for x appear in Table 1, which took just over 100 CPU hours to compute.

APPROXIMATELY COUNTING SEMISMOOTH INTEGERS

3

Table 2. x · σ(u, v)/Ψ(x, y, z), x = 240 y 22 24 26 28 210 212 214 216 218 220

z = 210 7.0984e-14 0.0042182 0.26627 0.64392 0.75636 — — — — —

z = 212 1.2946e-12 0.007326 0.2956 0.66898 0.80963 0.84863 — — — —

z = 214 2.1963e-11 0.012701 0.32972 0.68836 0.82644 0.87886 0.89495 — — —

z = 216 3.4242e-10 0.021657 0.36872 0.70731 0.83778 0.89096 0.9169 0.92275 — —

z = 218 4.8536e-09 0.035951 0.41167 0.72686 0.84679 0.89979 0.92614 0.93539 0.93769 —

z = 220 6.2227e-08 0.058 0.4585 0.74754 0.85628 0.90729 0.93196 0.9421 0.94722 0.95043

Table 3. E(x, y, z)/Ψ(x, y, z), x = 240 y 22 24 26 28 210 212 214 216 218 220

z = 210 1.6195e-13 0.0063754 0.34328 0.76655 0.87052 — — — — —

z = 212 2.9202e-12 0.010979 0.37895 0.79204 0.91765 0.94459 — — — —

z = 214 4.8929e-11 0.018858 0.42001 0.81087 0.93094 0.96506 0.97446 — — —

z = 216 7.5256e-10 0.031834 0.46628 0.82903 0.93899 0.97334 0.98537 0.98694 — —

z = 218 1.0508e-08 0.052265 0.51656 0.84748 0.94491 0.97836 0.98863 0.99092 0.99154 —

z = 220 1.325e-07 0.0833 0.57018 0.86587 0.95185 0.98148 0.99038 0.99305 0.99516 0.99766

4. A Generalized Buchstab Identity We have the following version of Buchstab’s identity (see for example [28, p. 365]): X (1) Ψ(x, y) = Ψ(x, 2) + Ψ(x/p, p), 2 0 we have    log(u + 1) (3) Ψ(x, y) = xρ(u) 1 + Oǫ , log y uniformly on the set defined by 1 ≤ u ≤ exp((log y)3/5−ǫ ) and y ≥ 2. Here, u := u(x, y) = log x/ log y. Theorem 1. Given 2 ≤ y ≤ z ≤ x, let ǫ > 0, and assume that 1 ≤ log(x/z)/ log y ≤ log x/ log y ≤ exp((log y)3/5−ǫ ). Then   Z z Ψ(x/t, y) dt (1 + o(1)). (4) Ψ(x, y, z) = Ψ(x, y) + log t y For asymptotic notation, we are assuming y is large. Proof. Define f (t) := (x/t)ρ(log(x/t)/ log y). By (3) we have f (p) = Ψ(x/p, y)(1 + o(1)) for all primes y < p ≤ z. f is differentiable and continuous, with f ′ (t) ∼ −f (t)/t (for large y). It is then straightforward to show that e(t)f ′ (t) = o(f (t)/ log t). Also since f is decreasing we can show e(z)f P(z) − e(y)f (y) = o(π(z) − π(y))f (z) + O(|e(y)|f (y)) and then (π(z)−π(y))f (z) ≤ y 0, log 2 . −φ1 ≥ s 2 −1 So α, the solution to φ1 (α, y) + log x = 0, is lower bounded by the solution β to (15)

log 2 = log x. 2β − 1

Solving, we get

log(1 + (log 2)/(log x)) 1 ≥ , log 2 2 log x the last inequality holding whenever x ≥ 2. Next we show the upper bound. Let ζ denote the Riemann zeta function. By examining their Dirichlet series, we can see that −φ1 (s, y) ≤ −ζ ′ /ζ(s). Both sides are decreasing smooth functions of s on (0, ∞). It follows that α is upper bounded by the solution to ζ ′ (s)/ζ(s) = log 2, which is less than 2. More precise information can be found in . In particular,    log log(1 + y) log(1 + y/ log x) 1+O α= log y log y α≥β=

holds uniformly for x ≥ y ≥ 2, with the explicit lower bound α≥

log(1 + y/(5 log x)) . log y

The strength of this is similar to (15) if y is fixed and x → ∞. 6.2. Computing ξ. Here we discuss some numerical methods for solving eξ = 1 + uξ, when u > 1. Let f (x) = x − log(1 + ux). Then f is convex on (0, ∞) with a minimum at x = 1 − 1/u. This gives the lower bound ξ ≥ 1 − 1/u. To get an upper bound, we observe that ex > 1 + x + x2 /2, so ξ is no larger than the positive solution to 1 + ξ + ξ 2 /2 = 1 + uξ, which is 2(u − 1). Using binary search between these bounds, we can get ⌊ξ⌋ plus d bits of its fraction, with O(log u + d) evaluations of f .

10

ERIC BACH AND JONATHAN SORENSON

Starting from the defining equation and taking logarithms, we get ξ = log(uξ + 1). Suzuki [26, Lemma 2.2] proves that this iteration, starting from log u, is linearly convergent to ξ. (Here u > e is fixed.) In practice, we can use the Newton iteration ξ := ξ −

(ξ − log(1 + uξ))(1 + uξ) , 1 + u(ξ − 1)

starting with the upper bound 2(u − 1). By convexity, the iterates decrease toward the root. We tested values of u from 2 to 1000, and for these u, about 5 iterations were enough to get machine accuracy (about 15D). (Note that when x is large, f (x) ∼ x, so even if we start with a large upper bound, the second iterate will be much closer to the root.) Newton iteration does not work well when u is close to 1, for the following reason. Suppose that u = 1 + ǫ. Then, we have ǫ + O(ǫ2 ) < ξ < 2ǫ, making ξ − log(1 + uξ) vanish to first order in ǫ. Thus, when computing this factor, we will lose precision due to cancellation. If special function software is available, ξ can be expressed using the Lambert W function. For example, in the notation of a well known computer algebra system of Canadian origin, ξ = −1/u − LambertW(−1, −e−1/u /u). (The argument −1 indicates which branch should be used.) 6.3. ATM Summation. The purpose of the next two subsections is to justify the remark made earlier that the cost of evaluating the formula HT can be lowered to y 2/3+o(1) . Here, the “o(1)” term includes factors of order log x, so we are implicitly assuming that x is not outrageously large. If f is a function defined on the positive integers, it is multiplicative if f (mn) = f (m)f (n). This is a stronger requirement than is usual in number theory, where m and n need only be coprime. The concept of an additive function is defined similarly; we require f (mn) = f (m) + f (n). We will call f an ATM function (additive times multiplicative) if f = gh, where g is additive and h is multiplicative. P The paper  gave an algorithm that evaluates the prime sum p≤y f (p), with f an ATM function, in y 2/3+o(1) steps. This generalized a previously known result, also explained in , in which f could be multiplicative. We now explain how these summation algorithms can be used to evaluate φ1 and log ζ. The basic idea is to approximate each of these by a “small” number of ATM or multiplicative prime sums. With log ζ in hand, we can exponentiate to get ζ. We first assume s > 0. Let us consider φ1 first. By summing geometric series, we see that X X log p X log p . = −φ1 = ps − 1 pks p≤y

k≥1 p≤y

Note that each inner sum involves an ATM function. We will restrict the outer sum to 1 ≤ k ≤ N , and choose N to make the truncation error, X X log p . pks k≥N +1 p≤y

small.

APPROXIMATELY COUNTING SEMISMOOTH INTEGERS

11

If we interchange the order of summation, allow all p ≥ 2, and sum geometric series, we can express the truncation error as X log p . pN s (ps − 1) p≥2

Using the globally convergent Maclaurin series for ps , we see that 1/(ps − 1) ≤ 1/(s log p). If we plug this in, the log p factors cancel and we get the upper bound   Z ∞ 1X 1 3 1 1 dt ≤ Ns , ≤ + s pN s s 2N s tN s s2 2 p≥2

provided that N s ≥ 2. For us, s ≥ 1/(2 log x), and with this additional assumption we get 6 log x [truncation error] ≤ N s . 2 Thus, to achieve truncation error less than 2−d , we can use N = Θ((log x)(log log x+ d)). Similarly, we can use X X1X 1 . log ζ(s, y) = − log(1 − p−s ) = k pks p≤y

k≥1

p≤y

Now each inner sum involves a multiplicative function. If we use only the inner sums with k ≤ N , a similar analysis shows that choosing N = Θ((log x)(log log x + d)) will keep the truncation error below 2−d . 6.4. Numerical Differentiation. In this subsection, we explain how to evaluate X log2 p · ps φ2 (s, y) = , (ps − 1)2 p≤y

for use in Algorithm HT. There is no obvious way to reduce this to the kind of sums treated in , so we will approximate it by a difference. Using balanced numerical differentiation [8, p. 297], we have h2 φ1 (s + h, y) − φ1 (s − h, y) + ǫ, ǫ= φ4 (η, y) 2h 6 for some η ∈ [s − h, s + h]. Let us determine how much precision will be necessary to deliver d bits of φ2 (s, y) accurately, when we use this formula. After differentiating the sum for φ2 twice, we see that X ps log2 p (p2s + 4ps + 1) log2 p φ4 (s, y) = × . (ps − 1)2 (ps − 1)2 φ2 (s, y) =

p≤y

2

Observing that (t + 4t + 1)/(t − 1)2 is decreasing for t > 1, we get the estimate   h2 h2 log2 y 22s + 4 · 2s + 1 φ2 (s, y). φ4 (s, y) ≤ 6 6 (2s − 1)2

If 0 ≤ s ≤ 2, the factor in parentheses is bounded by 15/s2 . (Numerically, anyway.) So, if we could use exact arithmetic, numerical differentiation would give us [relative error] ≤

5 h2 log2 y ≤ 10h2 log2 x log2 y. 2 s2

12

ERIC BACH AND JONATHAN SORENSON

However, we don’t have exact arithmetic, so we must also analyze the loss of precision due to cancellation. For this, we use an ad hoc theory. When h is small, the number of bits lost, when using the balanced difference formula to compute φ′1 (s), is about φ1 (s + h) − φ1 (s − h) , − log2 φ1 (s) since dividing by h causes no loss of precision. Note that this is a centered version of the usual relative error formula. Since φ1 (s + h) − φ1 (s − h) ∼ 2hφ′1 (s), we must bound the logarithmic derivative of φ1 , or, what is the same thing, relate φ2 = φ′1 to φ1 . In our case, we require a lower bound for φ2 . Then since t/(t − 1) is decreasing on (1, ∞), X log p ps log p φ2 (s, y) = × ps − 1 ps − 1 p≤y

X

p≤y

log p log p ≥ −φ1 (s, y) log 2. (ps − 1)

Therefore, φ1 (s + h, y) − φ1 (s − h, y) ∼ 2hφ2 (s, y) ≥ −φ1 (s, y) · 2h log 2,

as h → 0, Let us now translate these results into practical advice. Suppose our goal is to obtain φ2 to d bits of precision, in the sense√of relative error. By the exact arithmetic formula, we should choose h ≤ 2−d/2 /( 10 log2 x). Then we need to use log2 h−1 + O(1) guard bits in our computation. Put more crudely, unless x is very large, doubling the working precision should be enough, if we select h properly. The following example indicates that the theory above is roughly correct. Suppose we want 10 digits of φ2 , for x = 106 , y = 103 , and s = 1/(2 log x) = 0.03619... . Our recipe allows us to take h = 10−7 . With 17 digit arithmetic, we obtained numerical derivative = summation for φ2

=

127790.77386350000 127790.77386041727

which agree to 11 figures. 7. Conclusion and Future Work In summary, we recommend the estimate HTf (x, y, z) of §5.4 for approximating Ψ(x, y, z). We feel it gives high accuracy while retaining sufficient speed to be very practical. For future work, we hope to generalize our results to 2 or more large primes. We also hope to further examine estimates of the form of (5). 8. Acknowledgments We want to thank the referees, whose comments helped improve this paper. Abstract presented at the AMS-MAA Joint Mathematics Meetings, January 2012, Boston MA, and at the CMS Summer Meeting, June 2013, Halifax Nova Scotia. Supported in part by grants from the Holcomb Awards Committee, NSF (CCF635355), and ARO (W911NF-09-1-0439).

APPROXIMATELY COUNTING SEMISMOOTH INTEGERS

13

References  M. Abramowitz and I. A. Stegun. Handbook of Mathematical Functions. Dover, 1970.  E. Bach. Sums over primes. In A. M. Ernvall-Hyt¨ onen, M. Jutila, J. Karhum¨ aki, and A. Lepist¨ o, editors, Proceedings of Conference on Algorithmic Number Theory 2007, number 46 in Turku Centre for Computer Science, pages 40–44, 2007.  E. Bach and R. Peralta. Asymptotic semismoothness probabilities. Math. Comp., 65(216):1701–1715, 1996.  E. Bach and J. O. Shallit. Algorithmic Number Theory, volume 1. MIT Press, 1996.  D. J. Bernstein. Bounding smooth integers. In J. P. Buhler, editor, Third International Algorithmic Number Theory Symposium, pages 128–130, Portland, Oregon, June 1998. Springer. LNCS 1423.  D. J. Bernstein. Arbitrarily tight bounds on the distribution of smooth integers. In Bennett, Berndt, Boston, Diamond, Hildebrand, and Philipp, editors, Proceedings of the Millennial Conference on Number Theory, volume 1, pages 49–66. A. K. Peters, 2002.  R. P. Brent. Multiple precision zero-finding methods and the complexity of elementary function evaluation. In J. F. Traub, editor, Analytic Computational Complexity, pages 151–176. Academic Press, 1976.  S. D. Conte and C. W. D. Boor. Elementary Numerical Analysis: An Algorithmic Approach. McGraw-Hill Higher Education, 3rd edition, 1980.  R. Crandall and C. Pomerance. Prime Numbers, a Computational Perspective. Springer, 2001.  W. H. Ekkelkamp. The role of semismooth numbers in factoring large numbers. In A.-M. Ernvall-Hyt¨ onen, M. Jutila, J. Karhum¨ aki, and A. Lepist¨ o, editors, Proceedings of Conference on Algorithmic Number Theory 2007, number 46 in TUCS General Publication, pages 40–44. Turku Centre for Computer Science, 2007.  A. Granville. Smooth numbers: computational number theory and beyond. In Algorithmic number theory: lattices, number fields, curves and cryptography, volume 44 of Math. Sci. Res. Inst. Publ., pages 267–323. Cambridge Univ. Press, Cambridge, 2008.  A. Hildebrand. On the number of positive integers ≤ x and free of prime factors > y. Journal of Number Theory, 22:289–307, 1986.  A. Hildebrand and G. Tenenbaum. On integers free of large prime factors. Trans. AMS, 296(1):265–290, 1986.  A. Hildebrand and G. Tenenbaum. Integers without large prime factors. Journal de Th´ eorie des Nombres de Bordeaux, 5:411–484, 1993.  S. Hunter and J. P. Sorenson. Approximating the number of integers free of large prime factors. Mathematics of Computation, 66(220):1729–1741, 1997.  T. Kleinjung, K. Aoki, J. Franke, A. K. Lenstra, E. Thom´ e, P. Gaudry, P. L. Montgomery, D. A. Osvik, H. T. Riele, A. Timofeev, P. Zimmermann, and et al. Factorization of a 768-bit rsa modulus. http://eprint.iacr.org/2010/006.pdf, 2010.  A. K. Lenstra and H. W. L. Jr., editors. The Development of the Number Field Sieve, volume 1554 of Lecture Notes in Mathematics. Springer-Verlag, Berlin and Heidelberg, Germany, 1993.  A. J. Menezes, P. C. van Oorschot, and S. A. Vanstone. Handbook of Applied Cryptography. CRC Press, Boca Raton, 1997.  P. Moree. Nicolaas Govert de Bruijn, the enchanter of friable integers. Indag. Math., 2013. to appear; available from arxiv.org:1212.1579.

14

ERIC BACH AND JONATHAN SORENSON

 S. Parsell and J. P. Sorenson. Fast bounds on the distribution of smooth numbers. In F. Hess, S. Pauli, and M. Pohst, editors, Proceedings of the 7th International Symposium on Algorithmic Number Theory (ANTS-VII), pages 168–181, Berlin, Germany, July 2006. Springer. LNCS 4076, ISBN 3-540-36075-1.  V. Ramaswami. The number of positive integers ≤ x and free of prime divisors xc , and a problem of S. S. Pillai. Duke Mathematics Journal, 16(1):99–109, 1949.  R. Rivest, A. Shamir, and L. Adleman. A method for obtaining digital signatures and publickey cryptosystems. Communications of the ACM, 21(2):120–126, 1978.  L. Schoenfeld. Sharper bounds for the Chebyshev functions θ(x) and ψ(x). II. Mathematics of Computation, 30(134):337–360, 1976.  J. P. Sorenson. A fast algorithm for approximately counting smooth numbers. In W. Bosma, editor, Proceedings of the Fourth International Algorithmic Number Theory Symposium (ANTS IV), pages 539–549, Leiden, The Netherlands, 2000. LNCS 1838.  J. P. Sorenson. The pseudosquares prime sieve. In F. Hess, S. Pauli, and M. Pohst, editors, Proceedings of the 7th International Symposium on Algorithmic Number Theory (ANTSVII), pages 193–207, Berlin, Germany, July 2006. Springer. LNCS 4076, ISBN 3-540-36075-1.  K. Suzuki. An estimate for the number of integers without large prime factors. Mathematics of Computation, 73:1013–1022, 2004. MR 2031422 (2005a:11142).  K. Suzuki. Approximating the number of integers without large prime factors. Mathematics of Computation, 75:1015–1024, 2006.  G. Tenenbaum. Introduction to Analytic and Probabilistic Number Theory, volume 46 of Cambridge Studies in Advanced Mathematics. Cambridge University Press, english edition, 1995.  C. Zhang. An extension of the Dickman function and its application. PhD thesis, Purdue University, 2002. Computer Sciences Department, University of Wisconsin-Madison E-mail address: [email protected] Computer Science and Software Engineering Department, Butler University E-mail address: [email protected]
{"ft_lang_label":"__label__en","ft_lang_prob":0.7895729,"math_prob":0.9852722,"size":20794,"snap":"2020-24-2020-29","text_gpt3_token_len":6846,"char_repetition_ratio":0.10404041,"word_repetition_ratio":0.060899112,"special_character_ratio":0.36928922,"punctuation_ratio":0.18344566,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.99812627,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2020-07-08T14:52:34Z\",\"WARC-Record-ID\":\"<urn:uuid:26b01ca5-3873-4533-a122-ded17ff9e190>\",\"Content-Length\":\"74501\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:bfeed5eb-a8de-4ca1-8eef-53a6b8371e69>\",\"WARC-Concurrent-To\":\"<urn:uuid:6653c7e7-b093-4f8e-acce-00d50103b0fd>\",\"WARC-IP-Address\":\"104.27.163.127\",\"WARC-Target-URI\":\"https://mafiadoc.com/approximately-counting-semismooth-integers_5a36512a1723dd37a71b483e.html\",\"WARC-Payload-Digest\":\"sha1:C344BVDH2UVIC2SPIUMQD3JCVVZHDRJX\",\"WARC-Block-Digest\":\"sha1:CR4OSK3VATDRIEVKRCWH44XDVB37P4DI\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2020/CC-MAIN-2020-29/CC-MAIN-2020-29_segments_1593655897027.14_warc_CC-MAIN-20200708124912-20200708154912-00118.warc.gz\"}"}