Comments on: Conquering divide http://bit-player.org/2007/conquering-divide An amateur's outlook on computation and mathematics. Fri, 29 Aug 2008 07:39:54 +0000 http://wordpress.org/?v=1.5.2 Comment on Conquering divide by: Barry Cipra http://bit-player.org/2007/conquering-divide#comment-1520 Tue, 16 Oct 2007 16:49:27 +0000 http://bit-player.org/2007/conquering-divide#comment-1520 "...this is the first nontrivial algorithm most of us encounter in life, and it’s a really weird one." Speaking of weird algorithms, does anyone else (in the appropriate, geriatric age bracket) recall learning a long-hand algorithm for taking square roots? I remember doing so back in the early 1960s. The mechanics looked a lot like long division, except you had to guess successive digits of the divisor along with the quotient (which of course are supposed to be equal). As in long division, the algorithm could keep churning out decimal digits. Is computing the (integer part of the) square root also in Logspace? “…this is the first nontrivial algorithm most of us encounter in life, and it’s a really weird one.”

Speaking of weird algorithms, does anyone else (in the appropriate, geriatric age bracket) recall learning a long-hand algorithm for taking square roots? I remember doing so back in the early 1960s. The mechanics looked a lot like long division, except you had to guess successive digits of the divisor along with the quotient (which of course are supposed to be equal). As in long division, the algorithm could keep churning out decimal digits.

Is computing the (integer part of the) square root also in Logspace?

]]> Comment on Conquering divide by: brian http://bit-player.org/2007/conquering-divide#comment-1519 Tue, 16 Oct 2007 16:06:30 +0000 http://bit-player.org/2007/conquering-divide#comment-1519 Toby: IANAM either, and perhaps that's why I don't understand your question. I assert there's an asymmetry: A standard "times table" supplies a product for every combination of multiplier and multiplicand in a certain range, but the same table does not provide (by a simple lookup) the quotient for every combination of divisor and dividend. No? Toby: IANAM either, and perhaps that’s why I don’t understand your question. I assert there’s an asymmetry: A standard “times table” supplies a product for every combination of multiplier and multiplicand in a certain range, but the same table does not provide (by a simple lookup) the quotient for every combination of divisor and dividend. No?

]]> Comment on Conquering divide by: Toby http://bit-player.org/2007/conquering-divide#comment-1518 Mon, 15 Oct 2007 21:54:35 +0000 http://bit-player.org/2007/conquering-divide#comment-1518 IANAM, but: "No such searching (or guessing) step is needed with multiplication." Is it not the case that both algorithms benefit *equally* from a lookup table - specifically the so-called "times tables" that we learned by rote as children? Or are you suggesting (absent a table) that children do the sub-multiplies by repeated addition? :-) IANAM, but:

“No such searching (or guessing) step is needed with multiplication.”

Is it not the case that both algorithms benefit *equally* from a lookup table - specifically the so-called “times tables” that we learned by rote as children? Or are you suggesting (absent a table) that children do the sub-multiplies by repeated addition? :-)

]]> Comment on Conquering divide by: Barry Cipra http://bit-player.org/2007/conquering-divide#comment-1516 Sat, 13 Oct 2007 13:43:20 +0000 http://bit-player.org/2007/conquering-divide#comment-1516 Ryan, thanks for the clarification. Ryan, thanks for the clarification.

]]> Comment on Conquering divide by: Carlos http://bit-player.org/2007/conquering-divide#comment-1515 Fri, 12 Oct 2007 20:06:38 +0000 http://bit-player.org/2007/conquering-divide#comment-1515 I never had a problem with the long division algorithm once I understood it exactly as the algorithm in Barry Cipra's comment above: add a bunch of zeros to the divisor and the quotient and start subtracting away. When you can't any longer, shift right and repeat. (I also like the connection with CRC algorithms, GF(2) and XOR gates. CRC hardware is in the end really perform long division, if I remember things right) I never had a problem with the long division algorithm once I understood it exactly as the algorithm in Barry Cipra’s comment above: add a bunch of zeros to the divisor and the quotient and start subtracting away. When you can’t any longer, shift right and repeat.

(I also like the connection with CRC algorithms, GF(2) and XOR gates. CRC hardware is in the end really perform long division, if I remember things right)

]]> Comment on Conquering divide by: Jonathan Katz http://bit-player.org/2007/conquering-divide#comment-1514 Fri, 12 Oct 2007 15:48:38 +0000 http://bit-player.org/2007/conquering-divide#comment-1514 Yes, a logspace algorithm uses space that is logarithmic in its input length, which in this case is the number of digits n. Yes, a logspace algorithm uses space that is logarithmic in its input length, which in this case is the number of digits n.

]]> Comment on Conquering divide by: ryan williams http://bit-player.org/2007/conquering-divide#comment-1513 Fri, 12 Oct 2007 15:40:18 +0000 http://bit-player.org/2007/conquering-divide#comment-1513 A logspace algorithm would use "memory proportional to the logarithm of the number of digits in the input". (We assume the input is on a read-only storage and the final output is written on a write-only storage, so those digits are not counted as part of the working memory.) For an example, if you want to compute the digit that occurs the most often in a given input number (to break ties, let's say you want the smallest digit with this property), this can be done in logspace by keeping 10 binary counters (one for each digit) and incrementing the appropriate counter as you read the input from left to right. Each counter requires O(log n) bits to store, where n is the number of digits. A logspace algorithm would use “memory proportional to the logarithm of the number of digits in the input”. (We assume the input is on a read-only storage and the final output is written on a write-only storage, so those digits are not counted as part of the working memory.)

For an example, if you want to compute the digit that occurs the most often in a given input number (to break ties, let’s say you want the smallest digit with this property), this can be done in logspace by keeping 10 binary counters (one for each digit) and incrementing the appropriate counter as you read the input from left to right. Each counter requires O(log n) bits to store, where n is the number of digits.

]]> Comment on Conquering divide by: Barry Cipra http://bit-player.org/2007/conquering-divide#comment-1512 Fri, 12 Oct 2007 03:25:49 +0000 http://bit-player.org/2007/conquering-divide#comment-1512 It seems to me what's lacking is a clear definition of "logspace." I was going by Brian's parenthetical description, "memory proportional to the number of digits in the input." The algorithm I outlined certainly fits that bill. It seems to me what’s lacking is a clear definition of “logspace.” I was going by Brian’s parenthetical description, “memory proportional to the number of digits in the input.” The algorithm I outlined certainly fits that bill.

]]> Comment on Conquering divide by: ryan williams http://bit-player.org/2007/conquering-divide#comment-1511 Thu, 11 Oct 2007 22:05:57 +0000 http://bit-player.org/2007/conquering-divide#comment-1511 Whoops-- ignore the "exponential time" statement in my post, I conflated your algorithm with Brian's-- your algorithm DOES run in polynomial time, but it also uses polynomial space as well. Whoops– ignore the “exponential time” statement in my post, I conflated your algorithm with Brian’s– your algorithm DOES run in polynomial time, but it also uses polynomial space as well.

]]> Comment on Conquering divide by: ryan williams http://bit-player.org/2007/conquering-divide#comment-1510 Thu, 11 Oct 2007 20:56:50 +0000 http://bit-player.org/2007/conquering-divide#comment-1510 Barry: Your algorithm runs in polynomial space and exponential time, not logspace and polynomial time. The input to the division problem is two n-bit integers. In the worst case, the integers you keep around in your algorithm (especially at the beginning of its execution) have at least Omega(n) bits-- not O(log n) bits. Barry: Your algorithm runs in polynomial space and exponential time, not logspace and polynomial time. The input to the division problem is two n-bit integers. In the worst case, the integers you keep around in your algorithm (especially at the beginning of its execution) have at least Omega(n) bits– not O(log n) bits.

]]> Comment on Conquering divide by: Mitch http://bit-player.org/2007/conquering-divide#comment-1508 Thu, 11 Oct 2007 18:16:46 +0000 http://bit-player.org/2007/conquering-divide#comment-1508 Re: the 'real'-world symmetry of multiplication/division vs the asymmetry in numbers...real life is like the continuous reals, where multiplication and division -are- symmetric. But in discrete integers, all pairs of numbers multiply to give a single integer, but not so with division. Re: the ‘real’-world symmetry of multiplication/division vs the asymmetry in numbers…real life is like the continuous reals, where multiplication and division -are- symmetric. But in discrete integers, all pairs of numbers multiply to give a single integer, but not so with division.

]]> Comment on Conquering divide by: Suresh http://bit-player.org/2007/conquering-divide#comment-1507 Thu, 11 Oct 2007 17:48:55 +0000 http://bit-player.org/2007/conquering-divide#comment-1507 I think the point of Allender's article is that we want to find the "natural" complexity of division. In the absence of true lower bounds, the next best thing is to find the complexity class that division is "complete" for, which basically means that division is an example of the hardest problem in this class. His paper describes the final nailing of this, with the result that division is complete for a circuit class called TC^0 with a uniformity condition (see the <a href="http://qwiki.caltech.edu/wiki/Complexity_Zoo#tc0" rel="nofollow">complexity zoo entry on TC^0</a> for more information) I think the point of Allender’s article is that we want to find the “natural” complexity of division. In the absence of true lower bounds, the next best thing is to find the complexity class that division is “complete” for, which basically means that division is an example of the hardest problem in this class. His paper describes the final nailing of this, with the result that division is complete for a circuit class called TC^0 with a uniformity condition (see the complexity zoo entry on TC^0 for more information)

]]> Comment on Conquering divide by: brian http://bit-player.org/2007/conquering-divide#comment-1506 Thu, 11 Oct 2007 16:25:45 +0000 http://bit-player.org/2007/conquering-divide#comment-1506 Barry: I'm sure you're not missing anything. As noted above, division is indeed in P (the polynomial-time complexity class) and in L (the logspace complexity class). What am *I* missing? Barry: I’m sure you’re not missing anything. As noted above, division is indeed in P (the polynomial-time complexity class) and in L (the logspace complexity class). What am *I* missing?

]]> Comment on Conquering divide by: Barry Cipra http://bit-player.org/2007/conquering-divide#comment-1505 Thu, 11 Oct 2007 15:53:55 +0000 http://bit-player.org/2007/conquering-divide#comment-1505 I must be missing something in the definitions, because it seems to me there's a fairly simple logspace algorithm for division. Here's my proposal. First, multiply the divisor by 10 -- i.e., put zeros at its end -- as long as the result stays less than (or equal to) the dividend. Then subtract, increment the appropriate digit of the quotient by 1, and repeat. Each step is clearly polynomial (the "hardest" part is the subtraction), and the number of repetitions is clearly no more than 9 times the number of digits in the dividend (the worst case occurs when you divide 9999...99 by 1), so everything overall is polynomial. What makes it logspace -- if I understand what logspace means (which is probably the sticking point) -- is that after you've done the subtraction, you can forget the original number. For example, dividing 29 into 40321 (your example) proceeds as follows, with each step written in a separate line: 40321-29000=11321, Q=(1000) 11321-2900=8421, Q=(1100) 8421-2900=5521, Q=(1200) 5521-2900=2621, Q=(1300) 2621-290=2331, Q=(1310) 2331-290=2041, Q=(1320) 2041-290=1751, Q=(1330) 1751-290=1461, Q=(1340) 1461-290=1171, Q=(1350) 1171-290=881, Q=(1360) 881-290=591, Q=(1370) 591-290=301, Q=(1380) 301-290=11, Q=(1390), R=11 The logspaciousness resides in the fact that once you've completed a step, you can erase everything in the step above it -- think of it as alternating between two blackboards. So what am I missing? I must be missing something in the definitions, because it seems to me there’s a fairly simple logspace algorithm for division. Here’s my proposal. First, multiply the divisor by 10 — i.e., put zeros at its end — as long as the result stays less than (or equal to) the dividend. Then subtract, increment the appropriate digit of the quotient by 1, and repeat. Each step is clearly polynomial (the “hardest” part is the subtraction), and the number of repetitions is clearly no more than 9 times the number of digits in the dividend (the worst case occurs when you divide 9999…99 by 1), so everything overall is polynomial. What makes it logspace — if I understand what logspace means (which is probably the sticking point) — is that after you’ve done the subtraction, you can forget the original number.

For example, dividing 29 into 40321 (your example) proceeds as follows, with each step written in a separate line:

40321-29000=11321, Q=(1000)
11321-2900=8421, Q=(1100)
8421-2900=5521, Q=(1200)
5521-2900=2621, Q=(1300)
2621-290=2331, Q=(1310)
2331-290=2041, Q=(1320)
2041-290=1751, Q=(1330)
1751-290=1461, Q=(1340)
1461-290=1171, Q=(1350)
1171-290=881, Q=(1360)
881-290=591, Q=(1370)
591-290=301, Q=(1380)
301-290=11, Q=(1390), R=11

The logspaciousness resides in the fact that once you’ve completed a step, you can erase everything in the step above it — think of it as alternating between two blackboards.

So what am I missing?

]]> Comment on Conquering divide by: Jonathan Katz http://bit-player.org/2007/conquering-divide#comment-1504 Thu, 11 Oct 2007 11:44:27 +0000 http://bit-player.org/2007/conquering-divide#comment-1504 This post leads me to wonder...how is division done on real computers? (I.e., how is division handled by a C compiler or, better yet, how is division handled by, e.g., the 80x86 instruction set?) This post leads me to wonder…how is division done on real computers? (I.e., how is division handled by a C compiler or, better yet, how is division handled by, e.g., the 80×86 instruction set?)

]]>