@possumtech/rummy 2.0.1 → 2.2.0

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

@@ -0,0 +1,1146 @@
+# 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
+```
+