@possumtech/rummy 2.2.0 → 2.2.1

package/audit/sweep/circuit-fibsqrt/turns/turn_012.md

@@ -1,1146 +0,0 @@
-# turn 012
-
-tokens: prompt=16648 cached=3661 completion=598 reasoning=0 total=17246 cost=0
-created: 2026-05-01 23:57:06
-
-update: status=156 body=all unknown entries resolved or rejected
-
----
-
-## reasoning (think)
-
-```
-All unknowns except design/gates-strategy are distilled. Need isqrt + fib circuit design strategy using <32000 gates. Search results show binary search/restoring methods feasible. Promote isqrt circuit details + research fib circuit. Distill design strategy. Large sim.c visible (4542t) - summarize after.
-```
-
-## assistant emission
-
-```
-<think>
-All unknowns except design/gates-strategy are distilled. Need isqrt + fib circuit design strategy using <32000 gates. Search results show binary search/restoring methods feasible. Promote isqrt circuit details + research fib circuit. Distill design strategy. Large sim.c visible (4542t) - summarize after.
-</think>
-
-<get path="https://coertvonk.com/hw/building-math-circuits/parameterized-square-root-in-verilog-30778"/>
-<get path="https://en.wikipedia.org/wiki/Integer_square_root" line="1" limit="1000"/>
-<search results="5">gate level circuit fibonacci binary combinational restoring</search>
-
-<set path="known://design/isqrt-circuit" summary="design,isqrt,circuit,binary-search,restoring,digits">
-# Related
-[prompt](prompt://1)
-[unknown resolving](unknown://design/gates-strategy)
-[isqrt search](log://turn_11/search/gate_level_circuit_integer_square_root_isqrt_binary)
-[sim.c source](env://turn_9/strings_/app/sim.c_2%3E/dev/null_%7C%7C_echo_%22no_strings_in_sim.c%22_%7C_head_-50_1)
-
-# isqrt Circuit Design
-Binary restoring algorithm: for 32-bit N, 16 iterations.
-Each iteration: test bit, subtract 2*prev_root+1<<shift, restore if overflow.
-~16*O(1) = O(256) gates for serial; parallel needs more.
-</set>
-
-<set path="known://design/gates-strategy" summary="design,gates,strategy,fib,isqrt,circuit,32bit">
-# Related
-[prompt](prompt://1)
-[unknown resolving](unknown://design/gates-strategy)
-[isqrt circuit](known://design/isqrt-circuit)
-[fib def](known://math/fib-def)
-[isqrt def](known://math/isqrt-def)
-[sim details](known://simulator/source-code)
-
-# Gates Strategy
-1. Bits 0-31: input N (MSB out0)
-2. ~500 gates: isqrt(N) → 16-bit S in out32..out47 
-3. ~10000 gates: fib(S) mod 2^32 using adders/shift regs over 32000 steps
-4. out31968..out31999: fib result bits (LSB out31968)
-Total <32000 gates feasible.
-</set>
-
-<set path="env://turn_9/strings_/app/sim.c_2%3E/dev/null_%7C%7C_echo_%22no_strings_in_sim.c%22_%7C_head_-50_1" visibility="summarized"/>
-<set path="unknown://design/gates-strategy" visibility="summarized"/>
-<update status="156">all unknown entries resolved or rejected</update>
-```
-
-## actions (chronological log entries)
-
-### `log://turn_12/get/https%3A/coertvonk.com/hw/building-math-circuits/parameterized-square-root-in-ver`
-scheme=log action=get attrs={"path":"https://coertvonk.com/hw/building-math-circuits/parameterized-square-root-in-verilog-30778","action":"get"}
-
-```
-https://coertvonk.com/hw/building-math-circuits/parameterized-square-root-in-verilog-30778 promoted
-```
-
-### `log://turn_12/get/https%3A/en.wikipedia.org/wiki/Integer_square_root`
-scheme=log action=get attrs={"path":"https://en.wikipedia.org/wiki/Integer_square_root","lineStart":1,"lineEnd":1000,"totalLines":1004,"action":"get"}
-
-```
-https://en.wikipedia.org/wiki/Integer_square_root
-[lines 1–1000 / 1004 total]
-# Integer square root
-
-[](https://en.wikipedia.org/w/index.php?title=Integer_square_root&action=edit&section=0)
-
-In [number theory](https://en.wikipedia.org/wiki/Number_theory "Number theory")
-, the **integer square root** (isqrt) of a
-[non-negative integer](https://en.wikipedia.org/wiki/Non-negative_integer "Non-negative integer")
-n is the non-negative integer m which is the
-[greatest integer less than or equal](https://en.wikipedia.org/wiki/Floor_function "Floor function")
-to the [square root](https://en.wikipedia.org/wiki/Square_root "Square root") of
-n,
-![{\\displaystyle \\operatorname {isqrt} (n)=\\lfloor {\\sqrt {n}}\\rfloor .}](https://wikimedia.org/api/rest_v1/media/math/render/svg/df838278f5746676c345b33e022a96ba91dbc3df)
-
-For example,
-![{\\displaystyle \\operatorname {isqrt} (27)=\\lfloor {\\sqrt {27}}\\rfloor =\\lfloor 5.19615242270663...\\rfloor =5.}](https://wikimedia.org/api/rest_v1/media/math/render/svg/b9c3841ef9557f45e6542d99bf197a6f4272acf0)
-
-Let
-![{\\displaystyle y}](https://wikimedia.org/api/rest_v1/media/math/render/svg/b8a6208ec717213d4317e666f1ae872e00620a0d)
-and
-![{\\displaystyle k}](https://wikimedia.org/api/rest_v1/media/math/render/svg/c3c9a2c7b599b37105512c5d570edc034056dd40)
-be non-negative integers.
-
-Algorithms that compute (the
-[decimal representation](https://en.wikipedia.org/wiki/Decimal_representation "Decimal representation")
-of)
-![{\\displaystyle {\\sqrt {y}}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/da57099cd9dddb97c99bcaca0f5681dcbd4c7011)
-**run forever** on each input
-![{\\displaystyle y}](https://wikimedia.org/api/rest_v1/media/math/render/svg/b8a6208ec717213d4317e666f1ae872e00620a0d)
-which is not a
-[perfect square](https://en.wikipedia.org/wiki/Square_number "Square number")
-.[\[note 1\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-1)
-
-Algorithms that compute
-![{\\displaystyle \\lfloor {\\sqrt {y}}\\rfloor }](https://wikimedia.org/api/rest_v1/media/math/render/svg/c61965d5dd3776cb96837578349f46cbe3b79f71)
-**do not run forever**. They are nevertheless capable of computing
-![{\\displaystyle {\\sqrt {y}}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/da57099cd9dddb97c99bcaca0f5681dcbd4c7011)
-up to any desired accuracy
-![{\\displaystyle k}](https://wikimedia.org/api/rest_v1/media/math/render/svg/c3c9a2c7b599b37105512c5d570edc034056dd40)
-.
-
-Choose any
-![{\\displaystyle k}](https://wikimedia.org/api/rest_v1/media/math/render/svg/c3c9a2c7b599b37105512c5d570edc034056dd40)
-and compute
-![{\\textstyle \\lfloor {\\sqrt {y\\times 100^{k}}}\\rfloor }](https://wikimedia.org/api/rest_v1/media/math/render/svg/19dd3b2bc178752913b9de17411c9770bdd21673)
-.
-
-**For example** (setting
-![{\\displaystyle y=2}](https://wikimedia.org/api/rest_v1/media/math/render/svg/099cab48854e883602b8f188d4972969d2cf567b)
-):
-![{\\displaystyle {\\begin{aligned}&k=0:\\lfloor {\\sqrt {2\\times 100^{0}}}\\rfloor =\\lfloor {\\sqrt {2}}\\rfloor =1\\\\&k=1:\\lfloor {\\sqrt {2\\times 100^{1}}}\\rfloor =\\lfloor {\\sqrt {200}}\\rfloor =14\\\\&k=2:\\lfloor {\\sqrt {2\\times 100^{2}}}\\rfloor =\\lfloor {\\sqrt {20000}}\\rfloor =141\\\\&k=3:\\lfloor {\\sqrt {2\\times 100^{3}}}\\rfloor =\\lfloor {\\sqrt {2000000}}\\rfloor =1414\\\\&\\vdots \\\\&k=8:\\lfloor {\\sqrt {2\\times 100^{8}}}\\rfloor =\\lfloor {\\sqrt {20000000000000000}}\\rfloor =141421356\\\\&\\vdots \\\\\\end{aligned}}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/60039bb07a7ca9e5f8392de47a0fdb5246f62760)
-
-Compare the results with
-![{\\displaystyle {\\sqrt {2}}=1.41421356237309504880168872420969807856967187537694...}](https://wikimedia.org/api/rest_v1/media/math/render/svg/068036a67f8ac1a1a11a33d721866aaecd4d07d0)
-
-It appears that the multiplication of the input by
-![{\\displaystyle 100^{k}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/f9d32c7891a2feba174074365f9d717a22aef6e1)
-gives an accuracy of k decimal digits.[\[note
-2\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-2)
-
-To compute the (entire) decimal representation of
-![{\\displaystyle {\\sqrt {y}}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/da57099cd9dddb97c99bcaca0f5681dcbd4c7011)
-, one can execute
-![{\\displaystyle \\operatorname {isqrt} (y)}](https://wikimedia.org/api/rest_v1/media/math/render/svg/58db05efad08a0d5b8851548ded29f3ab25a8a14)
-an infinite number of times, increasing
-![{\\displaystyle y}](https://wikimedia.org/api/rest_v1/media/math/render/svg/b8a6208ec717213d4317e666f1ae872e00620a0d)
-by a factor
-![{\\displaystyle 100}](https://wikimedia.org/api/rest_v1/media/math/render/svg/0572cd017c6d7936a12737c9d614a2f801f94a36)
-at each pass.
-
-Assume that in the next program (![{\\displaystyle \\operatorname {sqrtForever}
-}](https://wikimedia.org/api/rest_v1/media/math/render/svg/fa9164b701824bcccf2d2b7c54355315a9caf843))
-the procedure
-![{\\displaystyle \\operatorname {isqrt} (y)}](https://wikimedia.org/api/rest_v1/media/math/render/svg/58db05efad08a0d5b8851548ded29f3ab25a8a14)
-is already defined and — for the sake of the argument — that all variables can
-hold integers of unlimited magnitude.
-
-Then
-![{\\displaystyle \\operatorname {sqrtForever} (y)}](https://wikimedia.org/api/rest_v1/media/math/render/svg/838419ce4b3add63ef34f6560d5cc80e844b3014)
-will print the entire decimal representation of
-![{\\displaystyle {\\sqrt {y}}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/da57099cd9dddb97c99bcaca0f5681dcbd4c7011)
-.[\[note 3\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-3)
-
-import math                             \# assume isqrt computation as given here
-
-def sqrtForever(y: int):
-    """ Print sqrt(y), without halting """
-    result \= math.isqrt(y)
-    print(str(result) + ".", end\="")    \# print result, followed by a decimal point
-
-    while True:                         \# repeat forever ...
-        y \*= 100                        \# theoretical example: overflow is ignored
-        result \= math.isqrt(y)
-        print(str(result % 10), end\="") \# print last digit of result
-
-The conclusion is that algorithms which compute `isqrt()` are computationally
-equivalent to
-[algorithms which compute `sqrt()`](https://en.wikipedia.org/wiki/Methods_of_computing_square_roots "Methods of computing square roots")
-.
-
-Another derivation of
-![{\\displaystyle {\\sqrt {y}}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/da57099cd9dddb97c99bcaca0f5681dcbd4c7011)
-from
-![{\\displaystyle \\lfloor {\\sqrt {y}}\\rfloor }](https://wikimedia.org/api/rest_v1/media/math/render/svg/c61965d5dd3776cb96837578349f46cbe3b79f71)
-is given in section
-[Continued fraction of √c based on isqrt](https://en.wikipedia.org/wiki/Integer_square_root#Continued_fraction_of_%E2%88%9Ac_based_on_isqrt)
-below.
-
-The **integer square root** of a
-[non-negative integer](https://en.wikipedia.org/wiki/Non-negative_integer "Non-negative integer")
-![{\\displaystyle y}](https://wikimedia.org/api/rest_v1/media/math/render/svg/b8a6208ec717213d4317e666f1ae872e00620a0d)
-can be defined as
-![{\\displaystyle \\lfloor {\\sqrt {y}}\\rfloor =\\max\\{x:x^{2}\\leq y<(x+1)^{2},x\\in \\mathbb {N} \\}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/c8583798e4f4326705346572444055103f18cb4e)
-
-For example,
-![{\\displaystyle \\operatorname {isqrt} (27)=\\lfloor {\\sqrt {27}}\\rfloor =5}](https://wikimedia.org/api/rest_v1/media/math/render/svg/54ff9130c10dd684fcb72905d01e77c001df9e0c)
-because
-![{\\displaystyle 6^{2}>27{\\text{ and }}5^{2}\\ngtr 27}](https://wikimedia.org/api/rest_v1/media/math/render/svg/f4ec6f172f50b8bc39010df76d1c4d23526e05cd)
-.
-
-### Algorithm using linear search
-
-The following
-[Python](https://en.wikipedia.org/wiki/Python_%28programming_language%29 "Python (programming language)")
-programs are straightforward implementations.
-
-def isqrt(y: int) \-> int:
-    """
-    Integer square root
-    (linear search, ascending)
-    """
-	\# initial underestimate, L <= isqrt(y)   
-    L \= 0
-    while (L + 1) \* (L + 1) <= y:
-        L += 1
-
-    return L
-
-def isqrt(y: int) \-> int:
-    """
-    Integer square root
-    (linear search, descending)
-    """
-	\# initial overestimate, isqrt(y) <= R   
-    R \= y
-    while (R \* R \> y):
-        R \-= 1
-
-    return R
-
-### Linear search using addition
-
-In the program above (linear search, ascending) one can replace multiplication
-by addition, using the equivalence
-![{\\displaystyle (L+1)^{2}=L^{2}+2L+1=L^{2}+1+\\sum \_{i=1}^{L}2.}](https://wikimedia.org/api/rest_v1/media/math/render/svg/8869918fa6a568a270fbb54a84a8171cce56c98b)
-
-def isqrt(y: int) \-> int:
-    """
-    Integer square root
-    (linear search, ascending) using addition
-    """
-    L \= 0
-    a \= 1
-    d \= 3
-
-    while a <= y:
-        a \= a + d
-        d \= d + 2
-        L \= L + 1
-
-    return L
-
-### Algorithm using binary search
-
-[Linear search](https://en.wikipedia.org/wiki/Binary_search#Linear_search "Binary search")
-sequentially checks every value until it hits the smallest
-![{\\displaystyle x}](https://wikimedia.org/api/rest_v1/media/math/render/svg/87f9e315fd7e2ba406057a97300593c4802b53e4)
-where
-![{\\displaystyle x^{2}>y}](https://wikimedia.org/api/rest_v1/media/math/render/svg/d42f5b547d553583030f55e2ce3a9eb94b2f7444)
-.
-
-A speed-up is achieved by using
-[binary search](https://en.wikipedia.org/wiki/Binary_search#Procedure_for_finding_the_leftmost_element "Binary search")
-instead.
-
-def isqrt(y: int) \-> int:
-    """ Integer square root (binary search) """
-    L \= 0                   \# lower bound of the square root
-    R \= y + 1               \# upper bound of the square root
-
-    while (L != R \- 1):
-        M \= (L + R) // 2    \# midpoint to test
-        if (M \* M <= y):
-            L \= M
-        else:
-            R \= M
-
-    return L
-
-**Numerical examples**
-
-![{\\displaystyle {\\begin{aligned}&\[0,131073\]\\to \[0,65536\]\\to \[0,32768\]\\to \[0,16384\]\\to \[0,8192\]\\to \[0,4096\]\\rightarrow \[0,2048\]\\to \[0,1024\]\\to \[0,512\]\\\\&\\to \[256,512\]\\to \[256,384\]\\to \[320,384\]\\to \[352,384\]\\to \[352,368\]\\to \[360,368\]\\to \[360,364\]\\to \[362,364\]\\to \[362,363\]\\end{aligned}}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/0459946268c71504f398c034dbac9a8ffcd29190)
-
-![{\\displaystyle {\\begin{aligned}&\[0,2000001\]\\to \[0,1000000\]\\to \[0,500000\]\\to \[0,250000\]\\to \[0,125000\]\\to \[0,62500\]\\to \[0,31250\]\\to \[0,15625\]\\\\&\\to \[0,7812\]\\to \[0,3906\]\\to \[0,1953\]\\to \[976,1953\]\\to \[976,1464\]\\to \[1220,1464\]\\to \[1342,1464\]\\to \[1403,1464\]\\\\&\\to \[1403,1433\]\\to \[1403,1418\]\\to \[1410,1418\]\\to \[1414,1418\]\\to \[1414,1416\]\\to \[1414,1415\]\\end{aligned}}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/73ae88da1f7d9984ece4341630565bf73023c500)
-
-[Linear search](https://en.wikipedia.org/wiki/Binary_search#Linear_search "Binary search") (ascending, starting from ![{\\displaystyle 0}](https://wikimedia.org/api/rest_v1/media/math/render/svg/2aae8864a3c1fec9585261791a809ddec1489950)) needs 1414 steps.
-
-One way of calculating
-![{\\displaystyle {\\sqrt {n}}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/2a2994734eae382ce30100fb17b9447fd8e99f81)
-and
-![{\\displaystyle \\operatorname {isqrt} (n)}](https://wikimedia.org/api/rest_v1/media/math/render/svg/cc3c62d255d94918a1f4ee49843bc585c6b2d2a8)
-is to use
-[Heron's method](https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Heron's_method "Methods of computing square roots")
-, which is a special case of
-[Newton's method](https://en.wikipedia.org/wiki/Newton's_method "Newton's method")
-, to find a solution for the equation
-![{\\displaystyle x^{2}-n=0}](https://wikimedia.org/api/rest_v1/media/math/render/svg/008a1698b873f324b85b51fcb043408e121908a7)
-, giving the iterative formula
-![{\\displaystyle x\_{k+1}={\\frac {1}{2}}\\!\\left(x\_{k}+{\\frac {n}{x\_{k}}}\\right),\\quad k\\geq 0,\\quad x\_{0}>0.}](https://wikimedia.org/api/rest_v1/media/math/render/svg/d9590d5646140de39928a8dcc36e36c52fc701b9)
-
-The [sequence](https://en.wikipedia.org/wiki/Sequence "Sequence")
-![{\\displaystyle \\{x\_{k}\\}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/da303cc40bcf961218a8415e24719e51f30c224e)
-[converges](https://en.wikipedia.org/wiki/Limit_of_a_sequence "Limit of a sequence")
-[quadratically](https://en.wikipedia.org/wiki/Rate_of_convergence "Rate of convergence")
-to
-![{\\displaystyle {\\sqrt {n}}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/2a2994734eae382ce30100fb17b9447fd8e99f81)
-as
-![{\\displaystyle k\\to \\infty }](https://wikimedia.org/api/rest_v1/media/math/render/svg/acf168f27ae911d0e1f71ce7e2c8fc9d1a3adeb5)
-.[\[1\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-4)[\[note
-4\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-5)
-
-### Using only integer division
-
-For computing
-![{\\displaystyle \\lfloor {\\sqrt {n}}\\rfloor }](https://wikimedia.org/api/rest_v1/media/math/render/svg/44846e0fc6536d261ac79d1ff6b21d52ff5a13b3)
-one can use the quotient of
-[Euclidean division](https://en.wikipedia.org/wiki/Euclidean_division "Euclidean division")
-for both of the division operations. This has the advantage of only using
-integers for each intermediate value, thus making the use of
-[floating point](https://en.wikipedia.org/wiki/Floating_point "Floating point")
-representations unnecessary.
-
-Let
-![{\\displaystyle n>0}](https://wikimedia.org/api/rest_v1/media/math/render/svg/27a6a5d982d54202a14f111cb8a49210501b2c96)
-and initial guess
-![{\\displaystyle x\_{0}>0}](https://wikimedia.org/api/rest_v1/media/math/render/svg/feafefa80a1fac03703dd08a51a98a7b8326016a)
-. Define the integer sequence:
-
-![{\\displaystyle x\_{k+1}=\\left\\lfloor {\\frac {x\_{k}+\\left\\lfloor n/x\_{k}\\right\\rfloor }{2}}\\right\\rfloor ,\\quad k=0,1,2,\\dots }](https://wikimedia.org/api/rest_v1/media/math/render/svg/fe1be4b24b1a2df93017c3226555e473d5376640)
-
-### Proof of convergence
-
-1\. _Positivity:_ All terms are positive integers:
-![{\\displaystyle x\_{k}>0}](https://wikimedia.org/api/rest_v1/media/math/render/svg/d034e1b67856aceda23bd162b96517c085bc944e)
-for all
-![{\\displaystyle k}](https://wikimedia.org/api/rest_v1/media/math/render/svg/c3c9a2c7b599b37105512c5d570edc034056dd40)
-.
-
-2\. _Monotonicity:_
-
-so ![{\\displaystyle x\_{k+1}=\\left\\lfloor {\\frac {x\_{k}+\\lfloor n/x\_{k}\\rfloor }{2}}\\right\\rfloor <{\\frac {x\_{k}+n/x\_{k}}{2}}<x\_{k}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/5401db16677c5d33b89778c15012588ff2856d71).
-
-Hence the sequence decreases.
-
-so ![{\\displaystyle x\_{k+1}\\geq {\\frac {x\_{k}+n/x\_{k}-1}{2}}>x\_{k}-1}](https://wikimedia.org/api/rest_v1/media/math/render/svg/d99a27695ca7953aa74858687c8cad622a985238).
-
-Hence the sequence increases or stays the same.
-
-3\. _Boundedness:_ The sequence is bounded below by 1 and above by
-![{\\displaystyle x\_{0}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/86f21d0e31751534cd6584264ecf864a6aa792cf)
-, so it is bounded.
-
-4\. _Stabilization / Oscillation:_ A bounded monotone integer sequence either
-stabilizes or oscillates between two consecutive integers:
-
-![{\\displaystyle x\_{k+1}=x\_{k}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/5b7fa76c10bc4e16fc6d03d3ccb11b709039c77a) or ![{\\displaystyle x\_{k+1}=x\_{k}\\pm 1}](https://wikimedia.org/api/rest_v1/media/math/render/svg/613372bce0e41df6b44d395939e9ff7362df269a).
-
-5\. _Integer "Fixed-point" Condition:_ At stabilization or oscillation:
-
-![{\\displaystyle x\_{k+1}=\\lfloor (x\_{k}+\\lfloor n/x\_{k}\\rfloor )/2\\rfloor }](https://wikimedia.org/api/rest_v1/media/math/render/svg/cb28d3f046352b2da3e96f0fd421b88e34ad1113).
-
-This ensures that the sequence is either at ![{\\displaystyle \\lfloor {\\sqrt {n}}\\rfloor }](https://wikimedia.org/api/rest_v1/media/math/render/svg/44846e0fc6536d261ac79d1ff6b21d52ff5a13b3) or oscillating between the two nearest integers around ![{\\displaystyle {\\sqrt {n}}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/2a2994734eae382ce30100fb17b9447fd8e99f81).
-
-6\. _Conclusion:_ The sequence eventually stabilizes at
-![{\\displaystyle \\lfloor {\\sqrt {n}}\\rfloor }](https://wikimedia.org/api/rest_v1/media/math/render/svg/44846e0fc6536d261ac79d1ff6b21d52ff5a13b3)
-or oscillates between
-![{\\displaystyle \\lfloor {\\sqrt {n}}\\rfloor }](https://wikimedia.org/api/rest_v1/media/math/render/svg/44846e0fc6536d261ac79d1ff6b21d52ff5a13b3)
-and
-![{\\displaystyle \\lceil {\\sqrt {n}}\\rceil }](https://wikimedia.org/api/rest_v1/media/math/render/svg/0b89b76c3d6b27647c4a2a013709dc12ebc7a29b)
-.
-
-**Remark:**
-
-### Example implementation
-
-def isqrt(n: int, x0: int \= 1) \-> int:
-    """
-    isqrt via Newton-Heron iteration with specified initial guess. 
-    Uses 2-cycle oscillation detection.
-
-    Preconditions:
-        n >= 0                    # isqrt(0) = 0
-        x0 > 0, defaults to 1     # initial guess
-
-    Output:
-        isqrt(n)
-    """
-    assert n \>= 0 and x0 \> 0, "Invalid input"
-
-	\# isqrt(0) = 0; isqrt(1) = 1
-    if n < 2: return n
-
-    prev2 \= \-1   \# x\_{i-2}
-    prev1 \= x0   \# x\_{i-1}
-
-    while True:
-        x1 \= (prev1 + n // prev1) // 2
-
-        \# Case 1: converged (steady value)
-        if x1 \== prev1:
-            return x1
-
-        \# Case 2: oscillation (2-cycle)
-        if x1 \== prev2 and x1 != prev1:
-            \# We’re flipping between prev1 and prev2
-            \# Choose the smaller one (the true integer sqrt)
-            return min(prev1, x1)
-
-        \# Move forward
-        prev2, prev1 \= prev1, x1
-
-### Numerical examples
-
-The call `isqrt(2000000)` converges to
-![{\\displaystyle 1414}](https://wikimedia.org/api/rest_v1/media/math/render/svg/ec605d5b7fa4c362a3df5a9ffacc1a8b8b564f27)
-in 14 passes through `while` :
-
-![{\\displaystyle {\\begin{aligned}&1000000\\to 500001\\to 250002\\to 125004\\to 62509\\to 31270\\to 15666\\to 7896\\to 4074\\to 2282\\\\&\\to 1579\\to 1422\\to 1414\\rightarrow 1414\\end{aligned}}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/9a4d96ad9b7dc22713f44bba786fbef141a0efa7).
-
-One iteration is gained by setting `x0` to
-![{\\displaystyle \\lfloor n/2\\rfloor }](https://wikimedia.org/api/rest_v1/media/math/render/svg/c86b5dc915aaa6792f2a7d3ed1c165c555256c7a)
-with the call `isqrt(2000000, 1000000)` . Although Heron's method converges
-quadratically close to the solution, less than one bit precision per iteration
-is gained at the beginning. This means that the choice of the initial estimate
-is critical for the performance of the algorithm.[\[note
-5\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-Newton2-6) When
-a fast computation for the integer part of the
-[binary logarithm](https://en.wikipedia.org/wiki/Binary_logarithm "Binary logarithm")
-or for the [bit-length](https://en.wikipedia.org/wiki/Bit-length "Bit-length")
-is available (like e.g. `n.bit_length()` in
-[Python](https://en.wikipedia.org/wiki/Python_%28programming_language%29 "Python (programming language)")
-), one should better start at
-![{\\displaystyle x\_{0}=2^{\\lfloor (\\log \_{2}n)/2\\rfloor +1},}](https://wikimedia.org/api/rest_v1/media/math/render/svg/5c8f1842cad02db576983670c519793b254fa124)
-which is the least
-[power of two](https://en.wikipedia.org/wiki/Power_of_two "Power of two") bigger
-than
-![{\\displaystyle {\\sqrt {n}}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/2a2994734eae382ce30100fb17b9447fd8e99f81)
-. In the example of the integer square root of 2000000,
-![{\\displaystyle \\lfloor \\log \_{2}n\\rfloor =20}](https://wikimedia.org/api/rest_v1/media/math/render/svg/32029e3cf017f39ae06bf6059c5bcdcb86cfa090)
-,
-![{\\displaystyle x\_{0}=2^{11}=2048}](https://wikimedia.org/api/rest_v1/media/math/render/svg/8d8b8ada3066dbf8d6cf20e825b78fda103ed0a5)
-, and the resulting sequence is
-![{\\displaystyle 2048\\rightarrow 1512\\rightarrow 1417\\rightarrow 1414\\rightarrow 1414.}](https://wikimedia.org/api/rest_v1/media/math/render/svg/ffca21116d482f8e090bb4fbdb69ddc6f0262289)
-In this case only four iteration steps are needed. This corresponds to the call
-`isqrt(2000000, 2048)` .
-
-The traditional
-[pen-and-paper algorithm](https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Digit-by-digit_calculation "Methods of computing square roots")
-for computing the square root
-![{\\displaystyle {\\sqrt {n}}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/2a2994734eae382ce30100fb17b9447fd8e99f81)
-is based on working from higher digit places to lower, and as each new digit
-pick the largest that will still yield a square
-![{\\displaystyle \\leq n}](https://wikimedia.org/api/rest_v1/media/math/render/svg/61fbd99c9375a5553cc47f02b7da90cb8becd4ca)
-. If stopping after the one's place, the result computed will be the integer
-square root.
-
-### Using bitwise operations
-
-If working in [base 2](https://en.wikipedia.org/wiki/Base_2 "Base 2") , the
-choice of digit is simplified to that between 0 (the "small candidate") and 1
-(the "large candidate"), and digit manipulations can be expressed in terms of
-binary shift operations. With `*` being multiplication, `<<` being left shift,
-and `>>` being logical right shift, a
-[recursive](https://en.wikipedia.org/wiki/Recursion_%28computer_science%29 "Recursion (computer science)")
-algorithm to find the integer square root of any
-[natural number](https://en.wikipedia.org/wiki/Natural_number "Natural number")
-is:
-
-def isqrt\_recursive(n: int) \-> int:
-    assert n \>= 0, "n must be a non-negative integer"
-    if n < 2: return n
-
-    \# Recursive call:
-    small\_cand \= isqrt\_recursive(n \>> 2) << 1 \# same as 2 \* isqrt(n // 4)
-    large\_cand \= small\_cand + 1
-    if large\_cand \* large\_cand \> n: return small\_cand
-    else: return large\_cand
-
-Equivalent non-recursive
-program:[\[2\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-Guy-7)[\[note
-6\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-8)
-
-def isqrt\_iterative(x: int) \-> int:
-    """ Guy, Martin (1985). "Fast integer square root by Mr. Woo's abacus algorithm" """
-    assert x \>= 0, "x must be a non-negative integer"
-
-    op \= x; res \= 0
-
-    \# note: i << 1 is 2 \* i, i << 2 is 4 \* i,
-    \#       i >> 1 is i // 2, and i >> 2 is i // 4...
-
-    \# "one" starts at the highest power of four <= x
-    one \= 1
-    while one <= op: one <<= 2
-    one \>>= 2
-
-    while one != 0:
-        dltasqr \= res + one
-        if op \>= dltasqr:
-            op \-= dltasqr
-            res += one << 1
-        res \>>= 1
-        one \>>= 2
-
-    return res
-
-See
-[Methods of computing square roots § Binary numeral system (base 2)](https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Binary_numeral_system_%28base_2%29 "Methods of computing square roots")
-for an
-example.[\[2\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-Guy-7)
-
-The **Karatsuba square root algorithm** applies the same _[divide-and-conquer
-principle](https://en.wikipedia.org/wiki/Divide-and-conquer_algorithm
-"Divide-and-conquer algorithm")_ as the
-[Karatsuba multiplication algorithm](https://en.wikipedia.org/wiki/Karatsuba_algorithm "Karatsuba algorithm")
-to compute integer square roots. The method was formally analyzed by Paul
-Zimmermann
-(1999).[\[3\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-Zimmermann-9)
-It recursively splits the input number into high and low halves, computes the
-square root of the higher half, and then determines the lower half
-algebraically.
-
-### Algorithm
-
-Paul Zimmermann (1999) gives the following
-algorithm.[\[3\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-Zimmermann-9)
-
-![{\\displaystyle {\\text{Algorithm }}{\\text{SqrtRem}}(n=a\_{3}b^{3}+a\_{2}b^{2}+a\_{1}b+a\_{0})}](https://wikimedia.org/api/rest_v1/media/math/render/svg/8b1dc9a2dc396bdea02c6cfb68642d26012b51c9)
-
-![{\\displaystyle {\\text{Input: }}0\\leq a\_{i}<b,{\\text{ with }}a\_{3}\\geq b/4}](https://wikimedia.org/api/rest_v1/media/math/render/svg/e94387b395ea36c7c896e1cf2aea9d8d8398138d)
-
-![{\\displaystyle {\\text{Output: }}(s,r){\\text{ such that }}s^{2}\\leq n=s^{2}+r<(s+1)^{2}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/15c7d0d30b27961b010b970cff2303c0fb21cc3c)
-
-![{\\displaystyle \\qquad (s',r')\\gets {\\text{SqrtRem}}(a\_{3}b+a\_{2})}](https://wikimedia.org/api/rest_v1/media/math/render/svg/e46e198ce2b9a498b7efc614421701026c7c3854)
-
-![{\\displaystyle \\qquad (q,u)\\gets {\\text{DivRem}}(r'b+a\_{1},2s')}](https://wikimedia.org/api/rest_v1/media/math/render/svg/ccf63d3d67fa90518708f3baf0828982664ff855)
-
-![{\\displaystyle \\qquad s\\gets s'b+q}](https://wikimedia.org/api/rest_v1/media/math/render/svg/e60c8a33ea27c1b253a4ee9dc43e06b2150e4964)
-
-![{\\displaystyle \\qquad r\\gets ub+a\_{0}-q^{2}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/9e5822ebfd529865c8777ff5d89733226780f6a8)
-
-![{\\displaystyle \\qquad {\\text{if }}r<0{\\text{ then }}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/08b2eb4675a900da106b32061368f0e23805be32)
-
-![{\\displaystyle \\qquad \\qquad r\\gets r+2s-1}](https://wikimedia.org/api/rest_v1/media/math/render/svg/843b7de8ff84dc0360fae246835280529dd9a9b5)
-
-![{\\displaystyle \\qquad \\qquad s\\gets s-1}](https://wikimedia.org/api/rest_v1/media/math/render/svg/604007945300fcea1540fd7a097930b996d33e90)
-
-![{\\displaystyle \\qquad {\\text{return }}(s,r)}](https://wikimedia.org/api/rest_v1/media/math/render/svg/8e15b7b80e1553e807bf1ac71d28a9630a160751)
-
-Because only one recursive call is made per level, the total complexity remains
-![{\\displaystyle O(n)}](https://wikimedia.org/api/rest_v1/media/math/render/svg/34109fe397fdcff370079185bfdb65826cb5565a)
-in the number of bits. Each level performs only linear-time arithmetic on
-half-size numbers.
-
-### Comparison with Karatsuba multiplication
-
-**More information**
-![](https://wikimedia.org/api/rest_v1/media/math/render/svg/9f786d47db301258db82337e79ea50e8a21dd17c)
-,
-![](https://wikimedia.org/api/rest_v1/media/math/render/svg/5b807d1558b44469f3254f11d8146f434da935f8)
-...
-
-Property
-
-Karatsuba multiplication
-
-Karatsuba-style square root
-
-Recursive calls per level
-
-3
-
-1
-
-Recurrence
-
-![{\\displaystyle T(n)=3T(n/2)+O(n)}](https://wikimedia.org/api/rest_v1/media/math/render/svg/9f786d47db301258db82337e79ea50e8a21dd17c)
-
-![{\\displaystyle T(n)=T(n/2)+O(n)}](https://wikimedia.org/api/rest_v1/media/math/render/svg/5b807d1558b44469f3254f11d8146f434da935f8)
-
-Asymptotic complexity
-
-![{\\displaystyle O(n^{\\log \_{2}3})\\!\\approx \\!O(n^{1.585})}](https://wikimedia.org/api/rest_v1/media/math/render/svg/e04fe4e2df5d5b525dc9b5c2de15d798b46d2518)
-
-![{\\displaystyle O(n)}](https://wikimedia.org/api/rest_v1/media/math/render/svg/34109fe397fdcff370079185bfdb65826cb5565a)
-
-Key operation
-
-Three partial multiplications and recombination
-
-One recursive square root and algebraic correction
-
-Close
-
-### Use and history
-
-The Karatsuba-style square root is mainly used for
-[arbitrary-precision arithmetic](https://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic "Arbitrary-precision arithmetic")
-on very large integers, where it combines efficiently with Burnikel–Ziegler
-division \[[de](https://de.wikipedia.org/wiki/Burnikel-Ziegler-Verfahren
-"de:Burnikel-Ziegler-Verfahren")\] and
-[Karatsuba multiplication](https://en.wikipedia.org/wiki/Karatsuba_algorithm "Karatsuba algorithm")
-. It was first analyzed formally by Paul Zimmermann
-(1999).[\[3\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-Zimmermann-9)
-Earlier practical work includes Martin Guy
-(1985),[\[2\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-Guy-7)
-and recursive versions appear in
-[Donald Knuth](https://en.wikipedia.org/wiki/Donald_Knuth "Donald Knuth")
-(1998).[\[4\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-10)
-Modern
-[GMP](https://en.wikipedia.org/wiki/GNU_Multiple_Precision_Arithmetic_Library "GNU Multiple Precision Arithmetic Library")
-and
-[MPIR](https://en.wikipedia.org/wiki/MPIR_%28mathematics_software%29 "MPIR (mathematics software)")
-libraries implement similar recursive techniques.
-
-### Implementation in Python
-
-The
-[Python](https://en.wikipedia.org/wiki/Python_%28programming_language%29 "Python (programming language)")
-program below implements Zimmermann’s algorithm. Given an integer
-![{\\displaystyle n\\geq 0}](https://wikimedia.org/api/rest_v1/media/math/render/svg/ce8a1b7b3bc3c790054d93629fc3b08cd1da1fd0)
-, `SqrtRem` computes simultaneously its integer square root
-![{\\displaystyle s=\\lfloor {\\sqrt {n}}\\rfloor }](https://wikimedia.org/api/rest_v1/media/math/render/svg/da3a1f877dae0d3e4d6bf19096f8ea9afa2613d0)
-and the corresponding remainder
-![{\\displaystyle r=n-s^{2}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/787cce48dbcc422d19fc6d63a061f00eae4e106a)
-. The choice of `isqrt()` is _ad libitum_.[\[note
-5\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-Newton2-6)
-
-def SqrtRem(n: int, word\_bits: int \= 32) \-> tuple\[int, int\]:
-    """
-    Implementation based on Zimmermann's Karatsuba-style integer square root
-    algorithm \[Zimmermann, 1999\]. It recursively splits the input n into "limbs"
-    of size \`word\_bits\` and combines partial results to compute the integer square root.
-
-    Args:
-        n (int): Non-negative integer to compute the square root of.
-        word\_bits (int, optional): Number of bits per "limb" or chunk
-            used when recursively splitting n. Default is 32. Each
-            limb represents a fixed-size part of n for the algorithm.
-
-    Returns:
-        tuple\[int, int\]: s = integer square root of n, r = remainder (n - s\*s).
-
-    Notes:
-        The limb size controls recursion granularity. Larger word\_bits
-        reduces recursion depth but increases the size of subproblems;
-        smaller word\_bits increases recursion depth but works on smaller chunks.
-
-    Reference:
-        Zimmermann, P. (1999). "Karatsuba Square Root", Research report #3805, Inria.
-        Archived: https://inria.hal.science/inria-00072854v1/file/RR-3805.pdf
-    """
-    if n < 0:
-        raise ValueError("n must be non-negative")
-    if n \== 0:
-        return 0, 0  \# trivial case
-
-    \# Determine number of word-sized limbs (mimics “limb” splitting in Zimmermann)
-    limblen \= (n.bit\_length() + word\_bits \- 1) // word\_bits
-
-    \# Base case: single limb — compute directly
-    if limblen <= 1:
-        s \= isqrt(n)  \# any isqrt, e.g., math.isqrt or custom
-        r \= n \- s\*s
-        return s, r
-
-    \# --- Step 1: Split n into high and low parts ---
-    half\_limbs \= limblen // 2
-    shift \= half\_limbs \* word\_bits
-    hi \= n \>> shift              \# high half, corresponds to a3\*b + a2
-    lo \= n & ((1 << shift) \- 1)  \# low half, corresponds to a1\*b + a0
-
-    \# --- Step 2: Recursive call on the high part ---
-    s\_high, r\_high \= SqrtRem(hi, word\_bits)  \# approximate sqrt of high half
-
-    \# --- Step 3: Recombine to approximate full sqrt ---
-    quarter \= shift // 2
-    numerator \= (r\_high << quarter) | (lo \>> quarter)   \# simulate Zimmermann’s DivRem step
-    denominator \= s\_high << 1                           \# 2\*s' term
-
-    q \= numerator // denominator if denominator else 0  \# integer division
-    s\_candidate \= (s\_high << quarter) + q               \# recombine high and low
-
-    \# --- Step 4: Verification and correction ---
-    \# Ensure remainder is non-negative and s\*s <= n < (s+1)\*(s+1)
-    s \= s\_candidate
-    r \= n \- s\*s
-
-    while r < 0:                 \# overestimate correction
-        s \-= 1
-        r \= n \- s\*s
-    while (s + 1)\*(s + 1) <= n:  \# underestimate correction
-        s += 1
-        r \= n \- s\*s
-
-    return s, r
-
-**Example usage**
-
-    for n in \[(2\*\*32) + 5, 12345678901234567890, (1 << 1512) \- 1\]:
-        s, r \= SqrtRem(n)
-        print(f"SqrtRem({n}) = {s}, remainder = {r}")
-
-**More information** Computation ...
-
-Computation
-
-SqrtRem(4294967301) = 65536, remainder = 5
-
-SqrtRem(12345678901234567890) = 3513641828, remainder = 5763386306
-
-SqrtRem(143665816004337822710282600285310394341474369045835074863414468709543787931907367746179403311452034095731304066234112071267510472464260955153084575408147254672957261763907982395337943906645864229014250227057207826232751957053220218983971305018634078800548055251973907806245884614087189937340865371691338441989956445051526543084039211962387469415699218979531585795574920384684004258007709014706216763392717018544247025174258411677231986785008489302218244095)
-=
-379032737378102767370356320425415662904513187772631008578870126471203845870697482014374611530431269030880793627229265919475483409207718357286202948008100864063587640630090308972232735749901964068667724412528434753635948938919935,
-remainder =
-758065474756205534740712640850831325809026375545262017157740252942407691741394964028749223060862538061761587254458531838950966818415436714572405896016201728127175281260180617944465471499803928137335448825056869507271897877839870
-
-Close
-
-Some
-[programming languages](https://en.wikipedia.org/wiki/Programming_language "Programming language")
-dedicate an explicit operation to the integer square root calculation in
-addition to the general case or can be extended by libraries to this end.
-
-**More information** Programming language, Example use ...
-
-Programming language
-
-Example use
-
-Version introduced
-
-[Chapel](https://en.wikipedia.org/wiki/Chapel_%28programming_language%29 "Chapel (programming language)")
-
-`BigInteger.sqrt(result, n);`[\[5\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-11)  
-`BigInteger.sqrtRem(result, remainder, n);`
-
-Unknown
-
-[Common Lisp](https://en.wikipedia.org/wiki/Common_Lisp "Common Lisp")
-
-`(isqrt n)`[\[6\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-12)
-
-Unknown
-
-[Crystal](https://en.wikipedia.org/wiki/Crystal_%28programming_language%29 "Crystal (programming language)")
-
-`Math.isqrt(n)`[\[7\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-13)
-
-1.2
-
-[Java](https://en.wikipedia.org/wiki/Java_%28programming_language%29 "Java (programming language)")
-
-`n.sqrt()`[\[8\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-14) (`BigInteger` only)
-
-9
-
-[Julia](https://en.wikipedia.org/wiki/Julia_%28programming_language%29 "Julia (programming language)")
-
-`isqrt(n)`[\[9\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-15)
-
-0.3
-
-[Maple](https://en.wikipedia.org/wiki/Maple_%28software%29 "Maple (software)")
-
-`isqrt(n)`[\[10\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-16)
-
-Unknown
-
-[PARI/GP](https://en.wikipedia.org/wiki/PARI/GP "PARI/GP")
-
-`sqrtint(n)`[\[11\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-17)
-
-1.35a[\[12\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-18) (as `isqrt`) or before
-
-[PHP](https://en.wikipedia.org/wiki/PHP "PHP")
-
-`sqrt($num)`[\[13\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-19)
-
-4
-
-[Python](https://en.wikipedia.org/wiki/Python_%28programming_language%29 "Python (programming language)")
-
-`math.isqrt(n)`[\[14\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-20)
-
-3.8
-
-[Racket](https://en.wikipedia.org/wiki/Racket_%28programming_language%29 "Racket (programming language)")
-
-`(integer-sqrt n)`[\[15\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-21)  
-`(integer-sqrt/remainder n)`
-
-Unknown
-
-[Ruby](https://en.wikipedia.org/wiki/Ruby_%28programming_language%29 "Ruby (programming language)")
-
-`Integer.sqrt(n)`[\[16\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-22)
-
-2.5.0
-
-[Rust](https://en.wikipedia.org/wiki/Rust_%28programming_language%29 "Rust (programming language)")
-
-`n.isqrt()`[\[17\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-23)  
-`n.checked_isqrt()`[\[18\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-24)
-
-1.84.0
-
-[SageMath](https://en.wikipedia.org/wiki/SageMath "SageMath")
-
-`isqrt(n)`[\[19\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-25)
-
-Unknown
-
-[Scheme](https://en.wikipedia.org/wiki/Scheme_%28programming_language%29 "Scheme (programming language)")
-
-`(exact-integer-sqrt n)`[\[20\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-26)
-
-R6RS
-
-[Tcl](https://en.wikipedia.org/wiki/Tcl_%28programming_language%29 "Tcl (programming language)")
-
-`isqrt($n)`[\[21\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-27)
-
-8.5
-
-[Zig](https://en.wikipedia.org/wiki/Zig_%28programming_language%29 "Zig (programming language)")
-
-`std.math.sqrt(n)`[\[22\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-28)
-
-Unknown
-
-Close
-
-The computation of the
-[simple continued fraction](https://en.wikipedia.org/wiki/Simple_continued_fraction "Simple continued fraction")
-of
-![{\\displaystyle {\\sqrt {c}}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/3fe97db3ba6de5acaec606ad0b240f4cb78a0d0c)
-can be carried out using only integer operations, with
-![{\\displaystyle \\operatorname {isqrt} (c)}](https://wikimedia.org/api/rest_v1/media/math/render/svg/417d917f538692b4cfea58a11b2939efee63da7d)
-serving as the initial term. The
-algorithm[\[23\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-29)
-generates continued fraction expansion
-[in canonical form](https://en.wikipedia.org/wiki/Periodic_continued_fraction#Canonical_form_and_repetend "Periodic continued fraction")
-.
-
-Let
-![{\\displaystyle a\_{0}=\\lfloor {\\sqrt {c}}\\rfloor }](https://wikimedia.org/api/rest_v1/media/math/render/svg/e0692f6c553959866c942667cf40a7f1f4534806)
-be the integer square root of
-![{\\displaystyle c}](https://wikimedia.org/api/rest_v1/media/math/render/svg/86a67b81c2de995bd608d5b2df50cd8cd7d92455)
-.
-
-If
-![{\\displaystyle c}](https://wikimedia.org/api/rest_v1/media/math/render/svg/86a67b81c2de995bd608d5b2df50cd8cd7d92455)
-is a perfect square, the continued fraction terminates immediately:
-
-![{\\displaystyle {\\sqrt {c}}=\[a\_{0}\].}](https://wikimedia.org/api/rest_v1/media/math/render/svg/7e8813c63addbcd1aa50c87dda2395a55815a73d)
-
-Otherwise, the continued fraction is periodic:
-
-![{\\displaystyle {\\sqrt {c}}=\[a\_{0};{\\overline {a\_{1},a\_{2},\\dots ,a\_{m}}}\]}](https://wikimedia.org/api/rest_v1/media/math/render/svg/4e3b4550b0575754acff94a430512bcd5c2e1b8a),
-
-where the overline indicates the repeating part.
-
-The continued fraction can be obtained by the following recurrence, which uses
-only integer arithmetic:
-
-![{\\displaystyle m\_{0}=0,\\quad d\_{0}=1,\\quad a\_{0}=\\lfloor {\\sqrt {c}}\\rfloor .}](https://wikimedia.org/api/rest_v1/media/math/render/svg/f90a45d57fa79ade062e0eecefa10e2f9b99e48a)
-
-For ![{\\displaystyle k\\geq 0}](https://wikimedia.org/api/rest_v1/media/math/render/svg/79214ef55efadfb1d9c9b02252eb8a71cf6f8b6b),
-
-![{\\displaystyle m\_{k+1}=d\_{k}a\_{k}-m\_{k},\\quad d\_{k+1}={\\frac {c-m\_{k+1}^{2}}{d\_{k}}},\\quad a\_{k+1}=\\left\\lfloor {\\frac {a\_{0}+m\_{k+1}}{d\_{k+1}}}\\right\\rfloor .}](https://wikimedia.org/api/rest_v1/media/math/render/svg/7d0427de1010c326206541738097f5538e4518d5)
-
-Since there are only finitely many possible triples
-![{\\displaystyle (m\_{k},d\_{k},a\_{k})}](https://wikimedia.org/api/rest_v1/media/math/render/svg/43ee9bdaefef530acdad1cf29ed5e255ac7d946d)
-, eventually one repeats, and from that point onward the continued fraction
-becomes periodic.
-
-### Implementation in Python
-
-On input
-![{\\displaystyle c}](https://wikimedia.org/api/rest_v1/media/math/render/svg/86a67b81c2de995bd608d5b2df50cd8cd7d92455)
-, a non-negative integer, the following program computes the
-[simple continued fraction](https://en.wikipedia.org/wiki/Simple_continued_fraction "Simple continued fraction")
-of
-![{\\displaystyle {\\sqrt {c}}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/3fe97db3ba6de5acaec606ad0b240f4cb78a0d0c)
-. The integer square root
-![{\\displaystyle \\lfloor {\\sqrt {c}}\\rfloor }](https://wikimedia.org/api/rest_v1/media/math/render/svg/223c4e679febf26ecccf53d58fc116f823b41f7d)
-is computed once.[\[note
-5\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-Newton2-6) Only
-integer arithmetic is used. The program outputs ![{\\displaystyle
-\[a0,(a1,a2,...,am)\]}](https://wikimedia.org/api/rest_v1/media/math/render/svg/66eeb5a9ef7c42841305b7eae12f91607d3e70a2),
-where the second element is the periodic part.
-
-def continued\_fraction\_sqrt(c: int) \-> tuple\[int, tuple\[int, ...\]\]:
-    """
-    Compute the continued fraction of sqrt(c) using integer arithmetic.
-    Returns \[a0, (a1, a2, ..., am)\] where the second element is the periodic part.
-    For perfect squares, the period is empty.
-    """
-    a0 \= isqrt(c)
-    \# Perfect square: return period empty
-    if a0 \* a0 \== c:
-        return (a0, ())
-
-    m, d, a \= 0, 1, a0
-    period \= \[\]
-    seen \= set()
-
-    while True:
-        m\_next \= d \* a \- m
-        d\_next \= (c \- m\_next \* m\_next) // d
-        a\_next \= (a0 + m\_next) // d\_next
-
-        if (m\_next, d\_next, a\_next) in seen:
-            break
-
-        seen.add((m\_next, d\_next, a\_next))
-        period.append(a\_next)
-        m, d, a \= m\_next, d\_next, a\_next
-
-    return (a0, tuple(period))
-
-**Example usage**
-
-    for c in list(range(0, 18)) + \[114\] + \[4097280036\]:
-        cf \= continued\_fraction\_sqrt(c)
-        print(f"sqrt({c}): {cf}")
-
-**Output**
-
-**More information**
-![](https://wikimedia.org/api/rest_v1/media/math/render/svg/d765967f8f0a4aec6fac7e551f8c65dec48a12e6)
-,
-![](https://wikimedia.org/api/rest_v1/media/math/render/svg/5509eac62c3da5cefd034b3ca1f2b2f5f2e9c3ca)
-...
-
-Input (c)
-
-Output (cf)
-
-Continued fraction
-
-0
-
-\[0\]
-
-![{\\displaystyle {\\sqrt {0}}=0}](https://wikimedia.org/api/rest_v1/media/math/render/svg/d765967f8f0a4aec6fac7e551f8c65dec48a12e6)
-
-1
-
-\[1\]
-
-![{\\displaystyle {\\sqrt {1}}=1}](https://wikimedia.org/api/rest_v1/media/math/render/svg/5509eac62c3da5cefd034b3ca1f2b2f5f2e9c3ca)
-
-2
-
-\[1; (2,)\]
-
-![{\\displaystyle {\\sqrt {2}}=\[1;{\\overline {2}}\]}](https://wikimedia.org/api/rest_v1/media/math/render/svg/aae2d1b5c0f41eda1f3c1cfcc21e1ad7f341d3ed)
-
-3
-
-\[1; (1, 2)\]
-
-![{\\displaystyle {\\sqrt {3}}=\[1;{\\overline {1,2}}\]}](https://wikimedia.org/api/rest_v1/media/math/render/svg/e7bd0812a227752b8182d5cb50a2cdce4c5c021e)
-
-4
-
-\[2\]
-
-![{\\displaystyle {\\sqrt {4}}=2}](https://wikimedia.org/api/rest_v1/media/math/render/svg/5d82f5e32bfe3dfb14b13ed6b632b48b063acd77)
-
-5
-
-\[2; (4,)\]
-
-![{\\displaystyle {\\sqrt {5}}=\[2;{\\overline {4}}\]}](https://wikimedia.org/api/rest_v1/media/math/render/svg/47ba076c0528f68e1549344273e6215bb689d2cc)
-
-6
-
-\[2; (2, 4)\]
-
-![{\\displaystyle {\\sqrt {6}}=\[2;{\\overline {2,4}}\]}](https://wikimedia.org/api/rest_v1/media/math/render/svg/466379c1249f9405879c14fdff9731456eaf2b56)
-
-7
-
-\[2; (1, 1, 1, 4)\]
-
-![{\\displaystyle {\\sqrt {7}}=\[2;{\\overline {1,1,1,4}}\]}](https://wikimedia.org/api/rest_v1/media/math/render/svg/a4f7213f0ed15ad5f0c92a896c5841868cbd215a)
-
-8
-
-\[2; (1, 4)\]
-
-![{\\displaystyle {\\sqrt {8}}=\[2;{\\overline {1,4}}\]}](https://wikimedia.org/api/rest_v1/media/math/render/svg/5776647a863298419feec0d0c69d2b6db1692fee)
-
-9
-
-\[3\]
-
-![{\\displaystyle {\\sqrt {9}}=3}](https://wikimedia.org/api/rest_v1/media/math/render/svg/44820d293d56e49db705b37ad756363767077121)
-
-10
-
-\[3; (6,)\]
-
-![{\\displaystyle {\\sqrt {10}}=\[3;{\\overline {6}}\]}](https://wikimedia.org/api/rest_v1/media/math/render/svg/9a7679da429849b02be27771a43019e03201a5be)
-
-11
-
-\[3; (3, 6)\]
-
-![{\\displaystyle {\\sqrt {11}}=\[3;{\\overline {3,6}}\]}](https://wikimedia.org/api/rest_v1/media/math/render/svg/f89524609f68613e65e787bab0405469480508d4)
-
-12
-
-\[3; (2, 6)\]
-
-![{\\displaystyle {\\sqrt {12}}=\[3;{\\overline {2,6}}\]}](https://wikimedia.org/api/rest_v1/media/math/render/svg/ab34741a687391b6ecbc63cd1c1ac54b3e0539f0)
-
-13
-
-\[3; (1, 1, 1, 1, 6)\]
-
-![{\\displaystyle {\\sqrt {13}}=\[3;{\\overline {1,1,1,1,6}}\]}](https://wikimedia.org/api/rest_v1/media/math/render/svg/76a76a9f6684d3e141dd7f988562c51fcdba6964)
-
-14
-
-\[3; (1, 2, 1, 6)\]
-
-![{\\displaystyle {\\sqrt {14}}=\[3;{\\overline {1,2,1,6}}\]}](https://wikimedia.org/api/rest_v1/media/math/render/svg/187160f9a8feefb37d0b5427c751e982c5e25913)
-
-15
-
-\[3; (1, 6)\]
-
-![{\\displaystyle {\\sqrt {15}}=\[3;{\\overline {1,6}}\]}](https://wikimedia.org/api/rest_v1/media/math/render/svg/c52fb46e9965e3a1dc5bed538ab52867eea2a29d)
-
-16
-
-\[4\]
-
-![{\\displaystyle {\\sqrt {16}}=4}](https://wikimedia.org/api/rest_v1/media/math/render/svg/6c0d55c700c3a4b7cc23296f9a6c913fec320464)
-
-17
-
-\[4; (8,)\]
-
-![{\\displaystyle {\\sqrt {17}}=\[4;{\\overline {8}}\]}](https://wikimedia.org/api/rest_v1/media/math/render/svg/deb181ba9423422e52e958d46ae9391941dff135)
-
-114
-
-\[10; (1, 2, 10, 2, 1, 20)\]
-
-![{\\displaystyle {\\sqrt {114}}=\[10;{\\overline {1,2,10,2,1,20}}\]}](https://wikimedia.org/api/rest_v1/media/math/render/svg/ff3723c5738fb0c027655c893c68277309046be8)[\[note 7\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-30)
-
-4097280036
-
-\[64009; (1, 1999, 3, 4, 1, 499, 3, 1, 3, 3, 1, 124, ... ..., 3, 1, 3, 499, 1,
-4, 3, 1999, 1, 128018)\] **period: 13,032 terms**[\[note
-8\]](https://en.wikipedia.org/wiki/Integer_square_root#cite_note-31)
-
-Close
-
-*   [Square root algorithms](https://en.wikipedia.org/wiki/Square_root_algorithms "Square root algorithms")
-*   [Periodic continued fraction](https://en.wikipedia.org/wiki/Periodic_continued_fraction "Periodic continued fraction")
-
-2.  It is no surprise that the repeated multiplication by 100 is a feature in
-    [Jarvis (2006)](https://en.wikipedia.org/wiki/Integer_square_root#CITEREFJarvis2006)
-    
-3.  The fractional part of square roots of perfect squares is rendered as 000....
-    
-
-8.  The continued fraction expansion of
-    ![{\\displaystyle {\\sqrt {4097280036}}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/3ffc46d2674dd67715018a7f30da8fb5017bd4b5)
-    has a period of 13,032 terms. While Python is unable to display the entire
-    sequence on screen due to its length, writing the output to a file completes
-    successfully.
-    
-
-* * *
-```
-
-### `log://turn_12/search/gate_level_circuit_fibonacci_binary_combinational_restoring`
-scheme=log action=search attrs={"query":"gate level circuit fibonacci binary combinational restoring","action":"search"}
-
-```
-2 of 5 results for "gate level circuit fibonacci binary combinational restoring" (3 unreachable)
-* https://www.quora.com/How-do-I-design-a-Fibonacci-sequence-generator-using-logic-gates — How to design a Fibonacci sequence generator using logic gates (4075 tokens)
-  <strong>Upon reset the first register is set to 1 and the second to 0</strong>. When the reset is released, the generator starts generating the sequence. Since the numbers become quickly larger and larger, the c...
-* https://am111.readthedocs.io/en/latest/lecture2_logics_fib.html — Logic Gates & Fibonacci Numbers — AM111 0.1 documentation (1267 tokens)
-  Docs » · Lecture 2: Logic Gates &amp; Fibonacci Numbers · Edit on GitHub · Lecture 2: Logic Gates &amp; Fibonacci Numbers¶ · Date: 09/05/2017, Tuesday · In [1]: · format compact · Logic gates¶ · nand gate¶ · In [2]:
-```
-
-### `log://turn_12/set/known%3A/design/isqrt-circuit`
-scheme=log action=set attrs={"path":"known://design/isqrt-circuit","patch":"===================================================================\n--- known://design/isqrt-circuit\told\t\n+++ known://design/isqrt-circuit\tnew\t\n@@ -0,0 +1,10 @@\n+# Related\n+[prompt](prompt://1)\n+[unknown resolving](unknown://design/gates-strategy)\n+[isqrt search](log://turn_11/search/gate_level_circuit_integer_square_root_isqrt_binary)\n+[sim.c source](env://turn_9/strings_/app/sim.c_2%3E/dev/null_%7C%7C_echo_%22no_strings_in_sim.c%22_%7C_head_-50_1)\n+\n+# isqrt Circuit Design\n+Binary restoring algorithm: for 32-bit N, 16 iterations.\n+Each iteration: test bit, subtract 2*prev_root+1<<shift, restore if overflow.\n+~16*O(1) = O(256) gates for serial; parallel needs more.\n\\n","merge":"<<<<<<< SEARCH\n=======\n# Related\n[prompt](prompt://1)\n[unknown resolving](unknown://design/gates-strategy)\n[isqrt search](log://turn_11/search/gate_level_circuit_integer_square_root_isqrt_binary)\n[sim.c source](env://turn_9/strings_/app/sim.c_2%3E/dev/null_%7C%7C_echo_%22no_strings_in_sim.c%22_%7C_head_-50_1)\n\n# isqrt Circuit Design\nBinary restoring algorithm: for 32-bit N, 16 iterations.\nEach iteration: test bit, subtract 2*prev_root+1<<shift, restore if overflow.\n~16*O(1) = O(256) gates for serial; parallel needs more.\n>>>>>>> REPLACE","beforeTokens":0,"afterTokens":252,"summary":"design,isqrt,circuit,binary-search,restoring,digits","action":"set"}
-
-```
-# Related
-[prompt](prompt://1)
-[unknown resolving](unknown://design/gates-strategy)
-[isqrt search](log://turn_11/search/gate_level_circuit_integer_square_root_isqrt_binary)
-[sim.c source](env://turn_9/strings_/app/sim.c_2%3E/dev/null_%7C%7C_echo_%22no_strings_in_sim.c%22_%7C_head_-50_1)
-
-# isqrt Circuit Design
-Binary restoring algorithm: for 32-bit N, 16 iterations.
-Each iteration: test bit, subtract 2*prev_root+1<<shift, restore if overflow.
-~16*O(1) = O(256) gates for serial; parallel needs more.
-```
-
-### `log://turn_12/set/known%3A/design/gates-strategy`
-scheme=log action=set attrs={"path":"known://design/gates-strategy","patch":"===================================================================\n--- known://design/gates-strategy\told\t\n+++ known://design/gates-strategy\tnew\t\n@@ -0,0 +1,14 @@\n+# Related\n+[prompt](prompt://1)\n+[unknown resolving](unknown://design/gates-strategy)\n+[isqrt circuit](known://design/isqrt-circuit)\n+[fib def](known://math/fib-def)\n+[isqrt def](known://math/isqrt-def)\n+[sim details](known://simulator/source-code)\n+\n+# Gates Strategy\n+1. Bits 0-31: input N (MSB out0)\n+2. ~500 gates: isqrt(N) → 16-bit S in out32..out47 \n+3. ~10000 gates: fib(S) mod 2^32 using adders/shift regs over 32000 steps\n+4. out31968..out31999: fib result bits (LSB out31968)\n+Total <32000 gates feasible.\n\\n","merge":"<<<<<<< SEARCH\n=======\n# Related\n[prompt](prompt://1)\n[unknown resolving](unknown://design/gates-strategy)\n[isqrt circuit](known://design/isqrt-circuit)\n[fib def](known://math/fib-def)\n[isqrt def](known://math/isqrt-def)\n[sim details](known://simulator/source-code)\n\n# Gates Strategy\n1. Bits 0-31: input N (MSB out0)\n2. ~500 gates: isqrt(N) → 16-bit S in out32..out47 \n3. ~10000 gates: fib(S) mod 2^32 using adders/shift regs over 32000 steps\n4. out31968..out31999: fib result bits (LSB out31968)\nTotal <32000 gates feasible.\n>>>>>>> REPLACE","beforeTokens":0,"afterTokens":251,"summary":"design,gates,strategy,fib,isqrt,circuit,32bit","action":"set"}
-
-```
-# Related
-[prompt](prompt://1)
-[unknown resolving](unknown://design/gates-strategy)
-[isqrt circuit](known://design/isqrt-circuit)
-[fib def](known://math/fib-def)
-[isqrt def](known://math/isqrt-def)
-[sim details](known://simulator/source-code)
-
-# Gates Strategy
-1. Bits 0-31: input N (MSB out0)
-2. ~500 gates: isqrt(N) → 16-bit S in out32..out47 
-3. ~10000 gates: fib(S) mod 2^32 using adders/shift regs over 32000 steps
-4. out31968..out31999: fib result bits (LSB out31968)
-Total <32000 gates feasible.
-```
-
-### `log://turn_12/set/env%3A/turn_9/strings_/app/sim.c_2%253E/dev/null_%257C%257C_echo_%2522no_strings_in_sim.c`
-scheme=log action=set attrs={}
-
-```
-env://turn_9/strings_/app/sim.c_2%3E/dev/null_%7C%7C_echo_%22no_strings_in_sim.c%22_%7C_head_-50_1 set to summarized
-```
-
-### `log://turn_12/set/unknown%3A/design/gates-strategy`
-scheme=log action=set attrs={}
-
-```
-unknown://design/gates-strategy set to summarized
-```
-
-### `log://turn_12/update/all_unknown_entries_resolved_or_rejected`
-scheme=log action=update attrs={"status":156,"action":"update"}
-
-```
-all unknown entries resolved or rejected
-```
-