Slashdot

Has anyone out there heard about this new practice police are using to catch criminals? It's called the DNA dragnet.

Here's the short form. Over the last few years, there have been several cases where police request that large numbers of people, sometimes approaching a thousand, give their DNA to rule themselves out as suspects in a case. Those who refuse to submit to the procedure are treated as suspects.

Now, I'm not quite sure how I feel about this--I only found out about it last night while watching 60 Minutes. I am sure, though, how I feel about police using this to solve crimes without having to get permission from a court or a specifically scoped law controlling the practice. Last time I checked, to become a suspect in a criminal case police had to have probable cause--anything short of that is harrassment. You can't even be pulled over for a traffic violation unless the cop has met this burden; how can you become a suspect in a rape or murder investigation simply because you were anonymously caught in a DNA dragnet and refused to cooperate?

Apparently, England has no such qualms. They have taken to routinely using this technique when they run out of other leads to follow. Germany has run DNA dragnets including thousands of people. We in America need to address this to express how we feel about this practice to our representatives and authority figures before it becomes standard practice.

I am not saying that I think it should never be used...though this is very possibly the conclusion I will come to on the matter after careful thought. I've long been conflicted about privacy issues involving identification of individuals. For instance, my state, California, now requires you to give a thumbprint in order to get a driver's license. Is this a problem? I'm not sure...privacy advocates argue that requiring such a thing is the action of a police state that considers its citizens as criminals before they do anything wrong. Somehow, though, this argument has never resonated with me.

To understand my viewpoint, ask yourself: what is the purpose of issuing IDs in the first place? The point, dear reader, is to identify you. I imagine the driver's license originally existed merely to identify you as a licensed driver, but I think that we all know that this is no longer the case; driver's licenses are now used for that purpose and as a state ID, same as the one you're entitled to if you're not a licensed driver but want a form of legal identification. So it seems to me that in order for a privacy advocate's argument against fingerprinting to be self-consistent, they ought to be advocating the abolition of IDs altogether. I've yet to meet anyone that can propose a reasonable means of doing away with IDs altogether. So the same argument privacy advocates make about fingerprints could be applied equally well to the head shot present on every photo ID, the address...the concept of the ID itself.

All this means that even most privacy advocates accept that some form of identification is necessary. So we find ourselves on a sliding scale from no IDs at all at one extreme to a global ID that uses every bit of technology available to disambiguate you from the entire global population (fingerprints of all ten fingers, DNA information, 3D model of your face and body, etc). If we agree that the need exists for the state to identify citizens, what degree of identification is necessary and reasonable?

One of the more nuanced arguments I've heard intelligently draws the line at DNA evidence. This argument is based on the notion that citizens should be willing to give enough information that authorities can reasonably identify them while limiting the exposure for abuse as much as possible. Some undoubtedly feel that a photo and an address are already too much, but I think most reasonable people would recognize that the true jump in exposure to such abuse doesn't occur on this sliding scale until we get to DNA. The potential to abuse DNA is much more serious than, say, fingerprints. Your DNA could be given to a health insurance company that discovers you are predisposed to a certain illness and cancels your insurance as a result. (Is it only a matter of time regardless before insurance companies require a DNA sample before they'll insure anyone? I think that once DNA becomes cheap to process, this will probably come to pass at some point anyway. Perhaps this issue of the DNA dragnet is simply prompting a conversation that we need to have anyway.)

Another factor in this discussion of identification is the level of granularity. Should we move to a national ID card, or leave it at the state level? Personally, I'm not against the national ID card because I think the benefits outweigh the risks. Besides, consistency requires that, if you are against a national ID card, you are also against interstate cooperation. Have you ever gotten a speeding ticket out of state only to have it show up on your driving record in your home state? Of course no one likes to get nailed with a ticket, but I think you'll agree it would be unreasonable to expect that each state will operate completely independently in this regard. I mean, what if a loved one of yours gets kidnapped and taken out of state? Would you advocate that the state authorities follow the trail to the state border, and then simply throw up their hands and head back to the office? Of course not...in that case, you'd be all for interstate cooperation and information sharing. States spend millions of dollars every year sharing databases...we might as well save all these tax dollars and just go national. There's something that rings false about a position that in principle agrees with the need for collecting and sharing data, but finds some degree of comfort when states are unable to exploit this capability due to technological difficulties.

National IDs are more in line with our shared consciousness anyway--when travelling abroad, if someone asks me where I'm from, I start by saying "America," not "San Francisco" or "California." (Contrast this to natives of India, who will often specify their home state within the country...in my experience, Indians typically do not share a strong national identity.) Besides being cheaper, a national ID would perhaps allow us to get better control over the illegal immigration situation (which is why national IDs will never happen--both parties lack the political will to deal with the appalling state of our immigration situation).

Anyway, as I intimated at the top of this essay, I'm pretty well undecided on how exactly to approach the issue of DNA dragnets. Do you have any thoughts to contribute that might help me form an opinion on this?

Did that title get your attention? Sorry to disappoint, but this essay isn't about that. :p phfffbbt

Originally, this was to be part of Big-O Notation , but I suspect several people reading this will already be quite familiar with Big-O notation and won't need the primer, so I've split this off.

Order-of-magnitude analysis can be used in two different ways, the way I described in Big-O Notation , a computer science-y, abstract kind of way, and the way I alluded to in Indirect Thinking , a practical kind of way, used to arrive at an actual concrete value. This essay addresses the latter.

For reasons explained in previous essays, it is often useful to gauge the order of a number. In its simplest form, this can be done directly on a number, such as 1040. What is the order of 1040? If you think back to algebra, you'll remember that the order of a polynomial is simply the highest power of the independent variable. For instance, the order of

f(x) = x^3 + 2*x^2 - 4

is 3 because that's the highest exponent of x, found in the x^3 term. You might also remember that regular, everyday, run-of-the-mill numbers such as 1040 have a "polynomial expanded form in their base." Put simply, that means we can write 1040, a base-10 number, as a polynomial (note the "independent variable" in this expansion is the base--10--and the coefficients of those terms, which are bolded, form the digits of the number itself):

1040 = 1*10^3 + 0*10^2 + 4*10^1 + 0*10^0,

or more simply, we can write the expansion as a function of its base b=10 and we drop the zero terms:

f(b) = 1040 = b^3 + 4*b,

So, the order of 1040, therefore, is 3.

This information about 1040, or any other number, is useful mainly for the purpose of comparison. If we find ourselves in a situation where we must compare two numbers of vastly different scales, order-of-magnitude comparison brings such comparisons down into the realm of numbers we can grasp directly. For instance, we might wonder how many Earths could fit inside the surface of the sun, approximately? Is it a thousand? Maybe ten thousand? (That seems like too many, doesn't it?) This is a question that has undoubtedly been answered before, but it would probably take more research than we're willing to do to answer such a frivolous question just for the sake of interest. That is, if we try to find the result of this calculation written up somewhere. On the other hand, it's very easy to find out the radius of the Sun and Earth, and with a little order-of-magnitude calculatin', we can quickly find out the answer for ourselves.

So, I type sun into the Wikipedia and find out that the radius of the Sun is about 110 times that of the Earth [source]. (Note that I need not concern myself with the long, messy number that represents the actual radius...another nice thing that often occurs when doing order-of-magnitude calculations.) I happen to know that the volume of a sphere is 4/3 the cube of its radius (if you didn't know this, this information is also readily available). So if we let rE be the radius of the Earth, we can quickly figure the volume of the Earth, vE, compared to the volume of a sphere with a radius 110 times that size (the volume of the Sun, vS):

vE = 4/3*rE^3
vS = 4/3*(110*rE)^3 = 4/3*110^3*rE^3

Since we're only concerned with order-of-magnitude here, I can simply drop all terms that are of a smaller order than I want to deal with. I can even turn the 110 into 100, the justification being that 100 is very close and happens to fall exactly on an order-of-magnitude boundary for base-10:

vE = rE^3
vS = 100^3*rE^3

If we divide these two quantities, we get our answer:

vS/vE = 100^3*rE^3/rE^3 = 100^3 = (10^2)^3 = 10^6

In other words, the volume of the sun is about 6 orders-of-magnitude larger than the volume of the earth--we should be able to fit about one million Earth-sized planets inside the Sun's volume. (If you do the actual calculations, you'll see that the real answer is roughly 1,331,000--this assumes that each Earth-sized planet is ground up and dumped into a bin the volume of the Sun. It would be less if we were to consider packing hard, Earth-sized spheres into a Sun-shaped and Sun-sized volume because spheres do not pack the space as tightly as Earths that made their way through a cosmic coffee grinder.) Wow--how reasonable it seemed before to say that 10,000 Earths probably couldn't fit into the Sun, hm? As it turns out, that many Earths would only fill up about 1% of the Sun's volume, and it wasn't difficult at all, using order-of-magnitude, to see how far off we'd been.

So, that was an interesting diversion, but now we get to the real point. We accept that using order-of-magnitude brings us a powerful new tool--it allows us to compare numbers of vastly disparate sizes. This works because the numbers involved in order-of-magnitude calcuations are powers of 10, which are so small and managable. The difference between a thousand and a million becomes simply 3. Even if we consider the vast theoretical extremes of our universe, the numbers remain very manageable. The "fundamental unit" of distance (roughly speaking, the smallest distance that can theoretically occur) is about 10^-35 meters. The diameter of the known universe since the Big Bang has expanded to roughly 100 billion light years, or about 10^27 meters. That means our universe contains, when speaking about matters of physical distance, only about 60 (give or take) orders of magnitude total. Only 60.

Think about that for a moment. This means that, no matter what size an object we happen to be discussing, that object's relationship with the smallest theoretical measureable distance can be represented using a number between 0 and 60. Or, alternatively, we can compare the size of any object at all to the size of the known universe using a number between 0 and 60. This brings such mind boggling differences into the realm of what our minds can manage.

So much so, in fact, that it lead me to think that our minds would probably have no trouble at all dealing with numbers that are even slightly larger than from 0 to 60. The 60 orders of magnitude present in our universe is only true if we assume we're working in base-10. But why work in base-10? Clearly, if we used a smaller base than 10, we might gain some fine structure without costing us any manageability. What if we went to the smallest integral base available, base-2, instead? Then what would we find? Would the orders get so large that we would find ourselves outside the realm of the manageable? Well, let's see.

10 is about 2^3.33. This is not exact, but it's convenient to think of it as a nice round fraction, so I'll use 2^(10/3). If I remember my basic numbers correctly, we can convert powers of ten to powers of two simply by multiplying the exponent of ten, then, by 10/3. Let's see if I'm right. We'll figure out, for various powers of ten, what the corresponding powers of two are:

10 = 2^(10/3)
10^2 = (2^(10/3))^2 = 2^(20/3)
10^6 = 2^(6*10/3) = 2^20

These equations aren't exactly true, but they're all pretty close (10^6=1,000,000 and 2^20=1,048,576, not exactly the same, but close enough for our purposes). That means our range expanded from 0 to 60, using base-10, by a factor of 10/3 to 0 to 200. This is definitely still manageable! And, it provides a much finer scale for us to work with. For instance, in base-10, the following numbers are all of the second order of magnitude: 110, 130, 480, 780. All of these numbers fall into different base-2 orders, though...respectively: 6, 7, 8, and 9. Even with this finer level of granularity, we're guaranteed that at the extremes the numbers will still always be restricted to the realm of the manageable.

You might agree that there's benefits to comparing orders in base-2, but argue that it's not practical because people have no reference point for working in this base, whereas base-10 comes naturally to most people...you just count the digits. I would reply, though, that with the tiniest bit of effort, anyone can think in base-2. Because of computers, everyone already knows several benchmarks along the progression of the base-2 system. No one buys 100MB or 200MB of RAM, we buy 128MB (2^7), 256MB (2^8), or 1GB (which is 2^0 gigabytes, 2^10 megabytes, or 2^20 bytes). Furthermore, the two bases tend to align remarkably well every three orders; 1000 is roughly 2^10, 1 million is about 2^20, 1 billion is about 2^30, and so on.

It's not as far-fetched or abstruse as one might think, and it makes order-of-magnitude comparison that much more useful.

In Indirect Thinking , I used an order-of-magnitude check as an example of an indirect way to verify a calculation. Is 24*29 equal to 14,984,334? Most people won't have to do the multiplication to know that the suggested result is way too large...they have performed an order-of-magnitude check to make this determination.

In computer science, we are taught to think in terms of order-of-magnitude when judging the performance of algorithms. The result of that analysis is often recorded using what is called Big-O notation, in which the total amount of time the algorithm takes to run is related to some independent variable of the problem. For instance, you have a list of names (a telephone book, for example) and you want to know whether the name Gummercinda Lipschitz is in that list. How long does it take your algorithm?

Well, there are a number of algorithms that can be applied here. The simplest and most straightforward is to simply go through the list from beginning to end, comparing each name as you go. The variable in this problem is the number of elements that happen to be in the list--note that this value is independent of the algorithm itself...the algorithm will execute over any sized list. Of course, the longer the list, the longer it takes.

When doing an order-of-magnitude anaylsis, we say the time T for this algorithm to run will be directly proportional to the number of elements n in the list: T=a*n, where a is some scaling factor. The actual value of this scaling factor depends on all sorts of things: what kind of computer is running the algorithm, how many other processes are running simultaneously, how much memory is available to the algorithm, etc, etc. This is a very convenient way of mathematically representing our analysis because it binds together all of these unknowns into this one little variable a so we can focus simply on the interaction between the number of elements and the performance of the algorithm. Certainly, all of that other stuff is important in terms of actually running the algorithm and getting an actual time...still, there is value in understanding this particular fundamental relationship contained in the other two variables.

So, using Big-O notation, instead of the above formula we obscure the proportionality constant altogether...this focuses the mind on the relationship that's under study: O(n)=n, we would write. For the sake of comparison, let's consider an algorithm that tells us whether the first character of an input string is a capital letter or not (it simply returns true or false). If n, in this case, is the number of characters in the input string, we can clearly see that the algorithm need only concern itself with considering the first character alone. Hence, no matter how long the input string, the algorithm will run in the same amount of time, as it will simply ignore whatever comes after the first character. Represented in Big-O notation, this would be: O(n)=1. Expanded into standard mathematical notation, we would write T=a*1, or simply T=a...all of these represent the same relationship. This algorithm is said to run in "constant time" with respect to the length of the input string because, for a particular machine with some fixed amount of memory, other processes running, etc, it will always return a result in the same constant amount of time regardless of the length of that input string.

In actuality, there is one more notational contraction applied in Big-O notation...the formula on the right hand side is usually represented directly in the O() function instead of explicitly listing the independent variable there--it is understood that n is the independent variable by convention. So O(n)=n and O(n)=1 become simply O(n) and O(1), respectively. Also, it is also sometimes unnecessary to roll all scaling factors into the unseen proportionality constant. For instance, if my name search algorithm was designed only to tell me if the name was present in the first third of the list, it would not be wrong to represent this algorithm's "order" by writing O(n/3). This 1/3 factor represents a fundamental part of the problem under consideration because it's related directly to the interaction between the performance of the algorithm and the independent variable, so it's not wrong to include it. On the other hand, for most purposes that Big-O analyses are done, this factor would be of little consequence so it would be excluded anyway.

In the previous example of the name list, we might be able to provide a different algorithm based on additional knowledge we have. For example, let's say the list of names accessible to our algorithm has certain features; it is always sorted alphabetically and we can always find out before we begin the search how many total elements it contains. In this case, we can use the divide-and-conquer technique. We skip to the middle of the list and see if Gummercinda's name is in the first or last half, then we recursively repeat this process on the half that might contain the name until we get to the position it would alphabetically occupy. This way of doing things does not vary directly with the number of elements in the list; rather, it varies directly with the logarithm of that number. (This is because each time I double the size of the list, only one more iteration is required for my algorithm.) This equates to O(log n).

So, what is the point of all this? Big-O is actually a very good way of distilling order-of-magnitude calculations into a reductionist form...everything but that which is absolutely necessary is rolled into an unseen constant. So, the basic character of two algorithms can be compared simply by comparing the graphs of their Big-O expressions. Even more complex information can be teased from these...for instance, if I have two algorithms that solve a particular problem, one associated with O(n^10) and the other O(2^n), I can tell right away that the former will, for large n, be more performant. But I might be working with a situation where n will never exceed a hundred, and I might wish to know for what n the second algorithm will begin to run slower than the first. With a bit of calculating, it's easy to see that the second overtakes the first in terms of running time around n=60.

This points up that any one of the quick calculating methods introduced in the previous essay Indirect Thinking can be developed further. It's true that the more developed version may not be as quick to check off-the-cuff, but it can yield a perspective and information about the problem that might otherwise lay undiscovered altogether.

Before reading this, you might want to read Part I of what has apparently become a series.

This new approach to developing applications brings unprecendented customizability. So much so, in fact, that it's hard to handle on all of it, and it even calls into question whether two different installations of the same application can really be called the "same" application beyond some point. I've been thinking on this since I posted that last thought, and I think I may have something.

What if applications were multi-user like operating systems are multi-user? In other words, what if you had to log in to an application before you could use it? This may sound like a horrible inconvenience, but stick with me...you'll see where I'm going with this shortly.

I download a word processor, the core of which is actually just a framework for word processing plug-ins. This framework sports a standard plug-in that connects up with a web service, hosted by the application developer, and logs in using my account on that web site (yes, I can optionally register an account with the site to download the word processor). Once this app is installed, I browse the list of available plug-ins and customize to my heart's content. Each time I install a plug-in, the web service module updates my on-line account to reflect the current customization, including all plug-ins installed and configuration information.

I go to my friend's house and get on his computer. He has installed the same word processor and customized it to his liking. But when I start up the app, it prompts me for a login and password, which I provide. It downloads all of my plug-ins and configuration. Some of these are necessary for me to start using the application for the first time on my buddy's computer, so for those I have to wait. Once it's done installing those and updating the configurations, though, it lets me start using the application. Meanwhile, in the background, it keeps downloading and installing the rest of my plug-ins, and my configured functionality starts magically appearing as I use the application.

Ah, but every problem solved spawns a new set of problems. You're thinking, Wait a minute...I already have enough trouble keeping track of all the accounts I already have to maintain for sites like /., my online bank access, the Wall Street Journal...now I have to create logins and passwords for each and every application I use? I feel your pain. As someone who tries to go by the handle sever everywhere I go, I've recently been stung several times by the new requirement at several sites that handles be at least 6 characters long. Also, for some reason, some sites will not accept special characters in passwords such as |, &, or $. So this means that I have to have at least 2 logins (the login I naively used to intially create accounts, and the one I had to invent with more than 5 characters) and two passwords (one secure one with lots of special characters, one less secure one with none), making a total of four combinations. Oh, and let's not forget the login I use for accounts that are jointly accessible to both me and my fiancee (that login has 6 chars, but I still need two passwords...argh). I can tell you, I usually have to login using the guess'n'check method if I haven't used an account for a little while.

Technology to the rescue! The last few times I've installed Linux, I've noticed that most distributions now come with an application called keyring. It's a fairly simple idea--it's a little database that associates all of your username and password combinations with the appropriate site. It even performs the login for you automatically, I believe, when it senses you're being prompted for a login (cookies be damned--this is much better). Of course, it keeps all of this information securely, encrypting every bit of data that passes through it. I'll bet it even prefers HTTPS connections or uses a web service to perform the login if they're available.

What if we were to marry this keyring application with the above idea of an application login model? It works like this...you go to the website of your favorite keyring application and create an account. You download the keyring application and install it, and then from then on, whenever you add a account to it, it updates the information remotely for you. Voila! Now, even at your friend's house, you have access to your keyring (assuming he has that keyring application installed). You only must remember that one username and password to get access to everything on the Internet associated with you. Suddenly, having to log in to every application doesn't seem like such a burden--it's done automatically for you.

Here's several more possibilities, some food for thought. (1) Could a standard be developed for such keyring applications? This way, you'd be free to install whatever keyring app you like and they'd all share your encrypted information, meaning that when your friend visits you or you visit your friend, regardless of what keyring app he uses, you can still log in by providing the username/password and the URL for the database of your preferred keyring app. (2) Could such an idea be incorporated into OS logins? This way, you wouldn't log in to your friend's computer directly either--the login prompt would provide an option whereby you could login using your keyring account, whereupon it would look up the login credentials you chose for your friend's computer, just like any other website. (3) Could such a keyring application automatically create accounts for you? Let's say you find a new discussion board on the web that requires you to create an account before you can start posting. It would be nice if you could simply go to your keyring app, type in the URL of the site asking you to create an account, and it would do it automatically. It could even use a nonsense handle and password--who cares? You'd never need to know it anyway to access the site...let the keyring app do the work whenever you need to log in!

So, let's run through a quick example of how this might work. You download and install your favorite keyring application. You decide to install some applications: Firefox, a word processor, and a file server. As you download each one, your keyring app automatically creates an account, encrypts, and stores your credentials. You configure each app (including the keyring app) with the plug-ins you prefer and customize them according to your wishes. You create an account for yourself in your file server so you can access your own machine from remote locations, and you add the credentials and URL to your keyring app. You remember to add your login credentials for your own computer because your OS integrates access to your keyring--so now, you log in even to your own home computer using the keyring option. You also add your login credentials for the home computers of your friends.

Then you head over to your friend's house. You sit down at his machine and log in using your single keyring username/password and the URL of that keyring applications database. It fetches your login information for your friend's computer and logs you in. You open the word processor and your keyring provides your credentials, at which point it downloads and configures itself to your liking. You decide to save your document on your home computer. You map a network drive (I know, I know, Windows-speak) to your home machine, at which time your keyring logs you into your file server at home. You save the document to that network drive.

There is no reason this idea can't be applied across the board, to everything from logging in to the OS to using a file browser, web browser, command shell...whatever. The OS could even configure itself with applications. For instance, you use Firefox at home, as soon as you log in to your friend's computer it downloads and installs Firefox for you. This idea could even be applied to licensed software...say you have your very own license for IDEA IntelliJ. As long as keyring has all of your login credentials, there's no reason you shouldn't be able to install that and run it from your friend's machine as well.

So what are the flaws with this idea? I don't see any that are insurmountable, though the most important I've come up with are still worth mentioning.

This could use up a lot of space. Let's say you've created accounts for your 20 closest friends, and each one has their own set of plug-ins for Firefox, a word processor, a calculator program, etc. That's a lot of plug-ins that are floating around on your machine, only a subset of which get used at any one time. If one of these friends only visits you once a year, do you really want that person's 100MB of Firefox plug-ins taking up space? I would address this one by saying one of two things: (1) hard drives are cheap and getting cheaper, so yes, you could simply spare the room and (2) an application-independent plug-in manager could be invented that tracks all the plug-ins on your system and removes rarely used ones...if needed, they'll simply get downloaded again at the appropriate time. An app-independent plug-in manager is also cool because it could automatically download updated versions of plug-ins as they are released. Your applications are all in continuous upgrade mode all the time without you doing anything.

What about speed? Wouldn't downloading all these things add up to a lot of bandwidth? Yes, it would...but, only the first time you logged in to a particular machine. After that, assuming the plug-ins don't get deleted, they're there waiting for you. Besides, bandwidth is soon going to be a lot cheaper, with home connections now getting pushed up into the 3mbps range. Soon, we'll fly past that.

What about security? If I were a savvy programmer, I could create a Firefox plug-in, for example, that does malicious things or gives me backdoor access to the file system of the machine on which it resides. Normally, such a plug-in would be found out because there'd be lots of eyes on it, but let's say I don't put it out for general use...it's only available to me. So when I log in to my friend's machine, this plug-in gets installed by the keyring app and boom, now I've got back-door access to his machine any time I want it. This one I'm not sure how to solve, so discussion is welcome.

The more I think about it, the more I believe it; as applications evolve, we'll need applications that know how to behave as they're configured and this application-level login model might be just the thing.

The unexamined life is not worth living. --Socrates, Apology, 38

I found myself recently wondering if a question exists that can be answered without directly addressing the question, but instead by considering the nature of the question itself. To give an example of what I mean by "directly addressing" a question, consider the following scenario.

I ask you: is 56*19 = 1040? To directly approach the answer to this question, you could do a number of things. You could calculate 56*19 and compare the result to 1040 to see if they are the same. You could do something algebraically equivalent as well, such as dividing 1040 by 56 to see if the result is 19. My use of the word direct in describing this approach has to do with the fact that these approaches depend upon executing exactly the operations (or the algebraic equivalent) present in the problem statement.

This is how we humans are taught to solve problems (at least, how this human was taught). This approach solves the problem, but not in a way that relies on creativity or intuition...it instead requires the solver to apply elementary knowledge in a simple and straightforward manner to find the answer. The solution is found through an application of knowledge and could more or less be carried out by someone that isn't necessarily intelligent but, rather, has memorized a sequence of steps without any real insight into the problem. Even so, using this approach tends to give people a feeling of satisfaction because it answers more than what the question explicitly asks (which could be addressed with a simple yes or no) and goes a step further in answering the unasked question: What is 56*19?

Humans have the habit of assuming the presence of these implicit questions. If you ask this question of your friends and relatives, I'm fairly confident that a good number of them will not simply respond with a simple yes or no, exactly enough to answer the question. Instead, they're likely to reply with a number.

So we've covered how to answer this question using a direct approach. What would be an indirect approach? Well, here's one example. I might notice that, whenever one multiplies two numbers together, the last digit of the product is always the same as the last digit of the product of the last two digits of the arguments. That was a mouthful, so if you don't feel like parsing it, fear not and read on. The rightmost digits of 56 and 19 are 6 and 9, respectively. The product of these two digits is 54, the rightmost digit of which is 4. So without actually multiplying 56 and 19 together, I can say with certainty that the final digit of the product will be 4. In the problem statement, the suggested product is 1040, which does not have a final digit of 4, and therefore cannot be the correct product.

This approach, while a bit more convoluted, is a bit more appealing to me because it seeks to provide an easy means of answering not just this particular question, but an entire class of similar questions. Furthermore, it requires a minimal amount of information from the problem statement while still providing the answer.

Consider, for instance, a slightly different problem. I ask you: is 734...211 (a 1000-digit number, of which I am only telling you the first and last three digits) times 349...214 (another 1000-digit number) equal to 936...001 (a 2000-digit number)? Using the direct approach of multiplying and comparing your result, you might conclude that this question is unanswerable because you can't carry out the multiplication; you don't even know what the actual numbers are.

Using the indirect approach, however, one can immediately see that not only is the answer to the question obtainable, but easily so! Even grade schoolers can do the required calculation in their heads. On the other hand, using the direct approach, even if I acquiesced and provided you all of the digits of the three numbers, finding the answer would require quite a long bit of calculating.

There is one little hang-up with the indirect approach, though. Perhaps you noticed it already...the class of problems that this approach applies to must be carefully considered. For instance, one might think this approach can be used to quickly answer any such question, such as: Is 21*21 = 421? You might be tempted, based upon the indirect approach, to say yes, it appears so. But do the calculation, and you'll discover that it is not so, it's merely that the actual product (441) happens to have the same final digit as the suggested, but incorrect, product. So this indirect approach is only useful in answering this question when it contradicts the suggested product, but outside the class of problems that fall into this cateogory, this approach has little to contribute.

Note I say it has little to contribute, but not nothing. If we assume that incorrect suggested products sport a last digit that is evenly distributed over all ten of the possible values, then the suggested approach will answer the question 9 times out of 10 (when the final digit of the suggested product does not match the actual product's final digit). That means when the problem doesn't belong to this method's problem space, while we cannot say the proposed product is correct, we can say we have a slightly higher degree of confidence that it is correct than before we applied this method. This alone is negligible, but consider if we had a long list of different methods such as this one to apply to the problem. If all of them failed to show the suggested product is incorrect, and there were enough of them, we might be able to have a very high degree of confidence that the proposed product is correct. It is still not a sure thing, depending on the completeness of the methods we've assembled in combination, but it's better than nothing and in some cases still far less work than the direct approach.

So we might conclude from this that using several indirect approaches in concert can be a very effective way to deal with a seemingly intractable problem. For the sake of example, let's consider a second indirect approach to the same kind of problem: is 22*47 = 1,048,224 true? Can a 2-digit number multiplied with a 2-digit number result in a 7-digit product? If you study this a bit, you can conclude that any m-digit number multiplied by any n-digit number will result in a product not larger than an (m+n)-digit number. (This is also known as checking by "order-of-magnitude.") Since the proposed product above is not 4 digits long, it cannot be correct. So here is a case where the first indirect method could not be applied, but the second one works. These two approaches, taken together, effectively expands the problem space that we can answer conclusively. If the problem at hand involved two 1000-digit numbers, one could develop quite a long checklist of these techniques and still find that the total amount of work involved in performing each and every check is still far less work than the direct approach.

This is all well and good for mathematics, but can this kind of indirect reasoning be applied to knotty "real life" questions, such as those that might arise in a discipline such as philosophy? I'm glad you asked, because this is exactly the thought I found myself considering a few days ago. And, I think I've found an example question that is related to the quote at the top of this essay.

The philosophical question is: is it useful to examine one's own beliefs? To directly answer this question, one might choose a particular position ("yes, examination of one's own beliefs is useful") and then set out to support this position. Then, one might choose the opposite position ("no, self-examination is futile and a waste of valuable time") and set about supporting that viewpoint. Once one is satisfied that both positions are bolstered to the best of one's abilities, one could compare the two arguments and see which one is more complete, more self-consistent, etc, and ultimately buy into one or the other. (It is worth pointing out, however, that addressing such questions in this way have been known to occupy great minds for years and even lifetimes without being resolved to the person's satisfaction.)

Now, let us consider the indirect approach to such a question. For the sake of this argument, let's assume that there exists support in favor of not examining one's beliefs, and this support trumps that of the opposing position. (That is not to say such support actually exists--only that we are assuming it as a basis to move forward along the indirect path.) If such an argument exists against self-examination and we were to discover it, we would without a doubt consider this newfound knowledge useful--why else would we put in the time and effort to uncover such a conclusion if the result of that work was not interesting to us?

But, if we were to achieve this state of affairs, we would immediately find ourselves in a quandary. The argument we have discovered is itself an example of the self-examination of one's beliefs yielding a result we find useful! It seems that the mere act of finding a good argument for this position disproves such an argument.

Now, let's consider our original assumption, which is: the argument against self-examination is better than the argument for it. All of the reasoning above is based upon this assumption, but what if this assumption is incorrect? If this assumption is wrong, then it means the opposite is true--that the argument for self-examination is better. So, even if our original assumption is invalid, we arrive at the same conclusion. Any way we cut it, the only logical stance is that self-examination of one's beliefs is useful, which is the answer to our question. We were able to arrive at this conclusion without even attempting to answer the question directly...instead, simply by considering the nature of the question itself, we were able to arrive at the correct answer.

Such methods of indirect reasoning are the hallmark of great thinking in many fields. Mathematics even sports formal methods of reasoning based upon indirect thinking...to name a couple: reductio ad absurdum and mathematical induction. Both have at their cores indirect thinking. ("Reductio ad absurdum" literally means "reduce to absurdity"...it is a method of answering a mathematical question by taking a position and showing that it irrevocably leads to impossibilities. Mathematical induction proves that a thing is generally true by proving that, if that thing is true in a single case, then it also must be true in each successive case. All that remains once this is done is to show any single example.)

What I have termed indirect thinking in this essay is, I think, an essential attribute of all truly deep understanding. It is an example of the synergy that can arise in the mind when that mind not only knows how to find an answer through brute force means, but also intimately understands the nature of the question and the essence of what allows the brute force method to work.