Contents
This is where I put anything that interests me or comes into my head.
I just recently read about the concept of zero-knowledge proofs. Basically, let's say you have a secret and you want to sell it to somebody, but there is a slight problem: the buyer won't believe you have the secret unless you divulge it, and you don't want to divulge it until you get the money. This could be considered an impasse, unless there is some way to prove, without giving away the secret, that you do, indeed, have a secret to sell. It's been mathematically proven that such proofs are possible.
I was then thinking about applying this concept to passwords over the Internet, but this isn't strictly a zero-knowledge proof. Assume both the server and the client know what the password is, and that a third party may be listening in on their conversation. Basically, when a client logs onto the network, the server sends a question to the client that asks about the password but has an answer that could not be used to recreate the password. Then, the client answers the question. This process is continued until the server can be sure the client really knows what the answer is. The trick is to find a question that would not jeopardize the confidence of the password.
Perhaps a simple method would be to treat the password as a large integer
using some sort of function. Then, the question from the server could be an
integer
that is multiplied to
mod
(this is the answer back to
the server) where
is some other integer that is perhaps coprime to
.
This is probably very easy to crack, but other questioning methods should be
possible and more secure.
In the event that I'd ever need to know in which order to put on my socks and shoes, I came up with a quick check:
Let
. Then,
is
. Evaluating the inverse,
which is
. A quick
verification shows that
which is
. Therefore, socks and shoes need to be
taken off and put on in the opposite order. QED.
I've been trying to think of how to prove this theorem:
The diophantine equation a3 + b3 = c3 cannot be satisfied with natural a, b, and c
I've been told to look at Fermat's method of infinite descent but I'm not quite sure how to use it. Maybe the class on number theory that I'm taking this fall will help. It's interesting that no cube can be expressed as the sum of two others.
Another thing I'm trying to prove is something I discovered while doodling in
World Civ. The image to the left is an example. I found that a closed loop,
under the right circumstances, can be colored using only two colors. In this
case I used white and gray. Here are definitions and the theorem. The
definitions are my own and may conflict with actual established mathematical
language.
I have an idea for how to prove this by using a set of reduction rules to turn the curve into a bunch of circles (look at the image and pretend each gray blob can be broken from each other gray blob. The maximum number of colors that you need for a bunch of separate circles is two, the background, and the color of the circles.)
I've also been thinking of a system for
infinite graphing, as in graphing
the entire coordinate plane to see the function and its behavior everywhere.
To the right is an example of the entire cartesian plane mapped to a sphere.
I'm also making a collection of other theorems that I have proven here.
I'm trying to think of a good algorithm for finding the differences between two versions of text from an initial version and then combining the findings to create a new version that has the same changes. For example (with the differences italicized for legibility):
| Initial: | The ice cream man ran as fast as he can. |
| Version 1: | The ice cream man ran as fast as he could. |
| Version 2: | The garbage man ran as fast as he can. |
| Merge: | The garbage man ran as fast as he could. |
The utility of this algorithm may not be apparent from this example, but imagine a large document edited by a few people and at some point all of the modifications need to be merged. An automated system could be very useful. I've been planning on putting something like this into KyleWiki3 for the event many people edit the same page at the same time.
My current idea for merging the differences between two texts is very simple and just requires the results from the difference algorithm to be applied by a patching algorithm in succession. So far there is no error checking.
The harder part, though, is to actually find the differences in an optimized manner. Currently, my algorithm looks for the longest similarity between the versions, claims it is the same, then recursively does this same algorithm on each piece of text before and after the similarity. The recursion continues until both sides of the similarity are empty, or no more similarities can be found. Something about my implementation at the moment is unacceptable because it takes nearly 10 seconds for a small to medium length page on the KyleWiki3 test site when examining differences at the word boundary level.
I was watching the fireworks on the 4th of July and I was timing how long it took for the sound to reach me. I estimated it was roughly 2.5 seconds. Then, I wondered what the show would be like if it were recorded and synched with the sound track set back 2.5 seconds so the explosion and the sound coincided.