FPGA

[Monty J. Harder]

On 8/12/07, Jared <jared at hatwhite.com> wrote:


"industry." So, yes, there is an industry, and one of its
> internal debates is whether to use the word "trinary" or "ternary,"
> with the latter being more technically accurate, but the former
> being more popular.


I think 'trinary' works well to stress that it's an alternative to binary.
But if you use ternary, you won't have trits, you'll have teits, or terits,
or terts, or something.

>
> True. You do have a point here. Let me more precise then, what we're
> discussing is the case where data is available, but in encrypted form
> without a key. In such cases, a key will soon be unnecessary....


I don't think so.  There are keys that are sufficiently long that no
brute-force attack is practical, because the size of the keyspace is on the
order of the number of atoms in the planet.

>     The only way to prevent such pattern-based analysis from cracking
> >     open any binarily-encrypted clump of data, or even a packet stream,
> >     is to generate TRULY RANDOM keys, which can only be created ... you
> >     guessed it ... within a ternary pattern-based algorithm. You already


Bullshit.  There's nothing about a ternary algorithm that enhances
generation of randomness.  An algorithm either has random INPUTS or it
doesn't.  Given the same inputs, any algorithm always produces the same
answer.  If it doesn't, it's no good as an algorithm.


Use polyvalent logic, the third option, that a statement is
> "true under certain conditions" and "false under other conditions,"
> and therefore its truth value is UNKNOWN, YET KNOWABLE. Now _this_
> is the way to look at what is before you. If you continue to look
> at it with binary eyes, you will continue to see a pile of BS.
> I'm okay with that.


Why not use a  quaternary  system of False/True/Unknown Yet
Knowable/UnKnowable?

Instead of leaping from one extreme to the other, it opens up smoothly
> into an infinite recursion, like fractals do. For example, something
> which is VIRTUALLY TRUE, being very close to completely true, is in
> this middle area. Likewise so is something VIRTUALLY FALSE, and so
> is the WHOLE RANGE BETWEEN. To binary eyes, it looks like a single


Ah.  We need to sex it up then, and have False/Virtually False/Virtually
True/True/UYK/UK.

empty area, neither true nor false and therefore useless. In truth
> it is actually a spectrum: a window into infinity which has much
> more smooth transitions than binary.


Six not enough?  How about a tuple:  The first value range from 0 meaning
known false to 100 for known true, and the second (again ranging from 0 to
100 describes the level of confidence, where 0 means totally unknown, and
100 is absolutely certain)?   When the second value hits 100, only 0 and 100
would be normal valid values for the first.  The special value (50,100)
might mean 'Unknowable', because the 100 says that you know (as much as you
can know).  Other (x,100) values would be available for things I haven't
thought of yet.  There's nothing magic about 100 though.  It could be 0..15
for each value, neatly fitting the tuple into a byte.  Nor do the two values
have to use the same range of values.


It is _this_ incremental ability that makes ternary logic much closer
> to analog -- and strangely, quaternary logic is worse, not better.


Bullshit.  3 is one closer to infinity than 2.  It is perfectly suited to
the unique case of representing binary values plus an extra value for "I
don't know", but imperfectly suited for representing 3 values plus IDK,
where quaternary is better.

It doesn't even work all that well for your 'current in a wire' example.  A
wire can have current flowing in either direction at a certain voltage, no
current, or alternating current with a certain frequency and voltage
amplitude.   The latter can have more complex waveforms suggesting multiple
frequencies and amplitudes.  And noise.

Hell, that right there would be a great generator for randomness.  Subtract
your ideal sine wave from the actual waveform of the AC coming into the
machine and use the least-significant bits/trits/quits of it.  I wonder what
it takes to build a chip for that and tie it to the inside of the power
supply where it's not easily tampered with.  I'd need something else for
this laptop though.  A USB cable that runs over to the AC side of the brick,
where the waveform monitoring chip would do its work, and a daemon to take
the randomness produced by that chip and accumulate it in a file for later
use when I'm on battery power.


> Yes, these examples are good. Note, however, all of these are
> reliant upon an interface with the analog, or "real" world. What
> I am talking about is generating such randomness entirely
> within the digital world, or at least so elegantly that there
> is no need for a geiger counter, keyboard, or mouse movements.


The computer exists in reality.  The way to get randomness out of
electronics is to specifically design them to NOT do error correction and
detection.  There's no reason why a chip can't be made to accumulate
randomness and dispense N bits of it at a time when requested.  It's just a
matter of whether there's enough demand for it.  Not a damn thing to do with
the base you count in.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://kclug.org/pipermail/kclug/attachments/20070813/46ca5d14/attachment-0001.htm