Prev: Considering discrete logs
Next: How Can ZFC/PA do much of Math - it Can't Even Prove PAisConsistent (EASY PROOF)
From: Joshua Cranmer on 30 Jun 2010 17:50
On 06/29/2010 11:35 PM, JSH wrote:
> The result I recently posted showing a way to solve discrete
> logarithms is amazing for its compactness but also for what it may
> indicate about the power of knowledge: not knowing how modular
> arithmetic works at a deep level, certain things that may be easy,
> appear hard.

There is nothing here about how long it takes to get to an answer. As
has been commented on several times for your factoring results, the
world is not short of slow ways to solve discrete logarithms; it is
short of a fast way.

> I'll be looking at replies with interest. One of the problems with
> knowledge is when people reject it because, well, because they don't
> like it!!!

Well, I'm not rejecting veracity of your argument, I'm just rejecting
the idea that it is a useful algorithm. I have already given an estimate
of the runtime, which you have implicitly accepted as true by lack of
comment.

> It's a HUGE issue. So far the problem has been intractable.

Intractable means unfeasible for larger inputs. RSA is now dealing with
this in numbers with 1024 or more bits (300+ decimal digits, if you need
the help).

> Human beings seem to love misery. I'm not sure why. But make no
> mistake, the human animal often works very hard to NOT solve its
> problems, preferring often instead to whine about them, but refusing
> to solve them.

Actually, humans seem to have a greater capacity for ingenuity than most
other species. We are now very capable of ending most life on the planet
with the push of a few buttons. We're also very good at solving problems
that don't exist.

--
Beware of bugs in the above code; I have only proved it correct, not
tried it. -- Donald E. Knuth
From: JSH on 30 Jun 2010 22:00
On Jun 30, 12:34 am, Mark Murray <w.h.o...(a)example.com> wrote:
> On 30/06/2010 04:35, JSH wrote:
>
> > Intriguingly enough my research results studying the simple system of:
>
> > f_1 = a_1*k mod N thru f_m = a_m*k mod N
>
> > indicate that integer factorization IS itself the key to modular
> > arithmetic, so what I called surrogate factoring is in retrospect the
> > way modular arithmetic operates.
>
> Why don't you read a little?
>
> http://en.wikipedia.org/wiki/Discrete_Logarithm
> ... then go to the "Comparison with Integer Factorization" section
> and look at the third bullet point.

I had already read it.

> Don't believe that? go to a search engine (any will do)
> and enter "discrete logarithm factorization" (without the quotes)
> to see how well understood this area is.

I've done that search already.


James Harris
From: JSH on 30 Jun 2010 22:06
On Jun 30, 12:48 am, Tim Little <t...(a)little-possums.net> wrote:
> On 2010-06-30, JSH <jst...(a)gmail.com> wrote:
>
> > That result actually may eliminate the value of a large m, with k^m =
> > q mod N, allowing one to easily handle it by simply cancelling out
> > much of m with a simple technique equivalent to having a certain
> > number of the a's equal to k^{-1} mod N.
>
> A practical cryptographic value of m is 65537.  The values for q and N
> must have at least 300 digits each (RSA-1024), but numbers with 1200
> digits (RSA-4096) are in practical use.

Interesting information.

> > It's a HUGE issue.  So far the problem has been intractable.
>
> It has only been intractable for the sizes of numbers given above.
> RSA-512 (154 digits) has been tractable for some time.
>
> If you can't demonstrate real-world ability to find k for arbitrary
> instances where m = 65537 and q and N are 100-digit numbers, your
> method is hopelessly useless, as existing methods already outperform
> it by far.

It's at the basic research stage.

However, even at that stage it actually shows how with m=65537,
factoring a number into only 4 factors can give an answer, as the
algebra simply eliminates 65537-4 factors, by canceling them out.

Does any other method known?

> But how about trying something simpler: m = 65537, and with q and N
> being 10-digit numbers?  In fact, here's a specific example:
>
>   k^65537 = 2328268283 mod 5123819881.
>
> If you can solve that with a program using your method, great!  You've

The problem is simple, if it could handle that size then it could
handle sizes that are militarily significant.

The mathematics already given shows that is true.

So the program able to do that if it fell into foreign hands could
maybe crack US military encryption.

Would you write that program? Say, to prove a point to Usenet
audiences?

With it, I wouldn't have to say a word to any of you, I could simply
sell it for millions to any nation on this planet.

You are idiots.

It's basic research at this stage you fool.

If it were anything more, worms like yourself at the bottom of the
pile in the sewers would not even hear of it.

How freaking stupid can a person be?

You test the limits of idiotic.


James Harris
From: Joshua Cranmer on 30 Jun 2010 22:38
On 06/30/2010 10:06 PM, JSH wrote:
> However, even at that stage it actually shows how with m=65537,
> factoring a number into only 4 factors can give an answer, as the
> algebra simply eliminates 65537-4 factors, by canceling them out.
>
> Does any other method known?

A number on the order of 1000 bits can have a prime factorization of at
most around 1000 non-unitary factors (counting multiplicity). You're
eliminating around 65000 factors which are all 1. Somehow, I don't
consider that terribly impressive.

> The problem is simple, if it could handle that size then it could
> handle sizes that are militarily significant.
>
> The mathematics already given shows that is true.

I haven't seen a proof that the algorithm will give a correct output
(i.e., halt with the correct answer) for all inputs. For the sake of
simplicity, let's assume that it does, and that the number of numbers to
attempt to factor is O(N).

Even if your algorithm works for all inputs, that doesn't still allow
you to claim an affirmative answer. The problem, as has been repeatedly
mentioned, is that you would need to do so more quickly than existing
algorithms. In the best case (namely, all other operations are O(1)),
the runtime of your algorithm is O(N). An algorithm that is O(sqrt(N))
is already known.

As for practical demonstration, preliminary tests seem to show that the
speed of the algorithm is on the order of "not fast." That means that
for practical purposes, your algorithm is useless.

> So the program able to do that if it fell into foreign hands could
> maybe crack US military encryption.
>
> Would you write that program? Say, to prove a point to Usenet
> audiences?

Actually, yes. I have confidence in the fact that your algorithm is
insufficiently efficient to be useful. Even if you applied all possible
optimizations: factoring is slow and appears to be more quickly and
efficiently translated to a discrete log algorithm than used as a step
in a more complicated searching algorithm.

> It's basic research at this stage you fool.

Under optimistic assumptions, the algorithm is Omega(N). Algorithms
already exist that are O(sqrt(N)). Tell me, which would you rather use?

--
Beware of bugs in the above code; I have only proved it correct, not
tried it. -- Donald E. Knuth
From: not Chumley on 30 Jun 2010 22:44

"JSH" <jstevh(a)gmail.com> wrote in message
news:ec9631a0-ba30-447c-8c76-6f1a9a5467f0(a)j17g2000prn.googlegroups.com...
On Jun 30, 12:48 am, Tim Little <t...(a)little-possums.net> wrote:
> On 2010-06-30, JSH <jst...(a)gmail.com> wrote:

<snip>

>You are idiots.
>
>It's basic research at this stage you fool.
>
>If it were anything more, worms like yourself at the bottom of the
>pile in the sewers would not even hear of it.
>
>How freaking stupid can a person be?
>
>You test the limits of idiotic.
>
>
>James Harris

Another Keeper ! !

Love it;

"If it were anything more, worms like yourself at the bottom of the pile in
the sewers would not even hear of it."
Worms dont have ears, so how are they going to "hear about it" ?
Besides they are at the bottom of a pile...?

JSH Basic Research for 12 years + still in the poodle stage
http://www.buamai.com/wp-content/uploads/2009/07/poodles_1442062i.jpg


First  |  Prev  |  Next  |  Last
Pages: 1 2 3 4 5
Prev: Considering discrete logs
Next: How Can ZFC/PA do much of Math - it Can't Even Prove PAisConsistent (EASY PROOF)