Here's a new attempt after my last one got wrecked by you guys. I'm curious what you think

Here's a new attempt after my last one got wrecked by you guys. I'm curious what you think.

Statement

S1. P ≠ NP.

Proof

P1. Let there be natural non-zero inputs n and k such that the complexity of the input is the sum of the bit lengths of n and k.

P2. Let there be irrational a such that a[b] must be calculated before a[b + 1]. For example, if a is 0.01011110…, 0.010[1]1110… must be calculated before 0.0101[1]110…. Note that not all irrationals require such calculation.

P3. For each natural c such that 0 ≤ c ≤ 2 ^ n, let natural chunk[c] be bits a[k × c + 1] to a[k × c + k + 1].

P4. Let the problem be as follows: does d and e exist such that d ≠ e and chunk[d] = chunk[e]? Note that, as n and k change, the solution to the problem can change between YES and NO, so no general solution exists.

P5. P2 and P3 imply that solving the problem requires ≥ O(2 ^ n) time. This is because chunk[c] must be calculated before chunk[c + 1] and there are O(2 ^ n) chunks to check for equality.

P6. A solution to the problem can be verified in O(k) time by a comparison between chunk[d] and chunk[e] returning YES.

P7. P5 and P6 imply S1, because the problem requires ≥ O(2 ^ n) time to find a solution but O(k) time to verify a solution.

0x51B4908DdCD986A41e2f8522BB5B68E563A358De

I think the chunking should be a[k × c + 1] to a[k × c + k], actually. My math is terrible, to be honest.

weren't you supposed to be "done" after your last shitpost

How do you verify in polynomial time if you cannot compute the chunk without computing all previous chunks, and there are exponentially many chunks?

Yeah, but this one just came to mind and I had to have someone look at it.

That might be the error. I was under the impression that once you have the chunks in hand, you don't ever need to regenerate them. Now that i think about it, proving the chunk is part of the irrational might be where I fucked up.

How does it verify if it needs the previous bits to compute? Also, why does your proof not relativize, since there are oracles for which [math]P^A = NP^A[/math] and also oracles for which [math]P^A \neq NP^A[/math]

I think I'm in error, see:

So the proof is flawed. You guys can let this thread die while I rethink things.

All of your proofs will be flawed you arrogant piece of shit.

That's a great attitude to have in STEM.

Not even OP btw.

I've tried to improve it a little:

Statement

S1. P ≠ NP.

Proof

P1. Let there be natural non-zero inputs n and k such that the complexity of the input is the sum of the bit lengths of binary n and k.

P2. Let π be 3.1415… in binary such that π[b] is bit b of π.

P3. For each natural c such that 0 ≤ c ≤ 2 ^ n, let natural chunk[c] be bits π[k × c + 1] to π[k × c + k].

P4. Let the problem be as follows: does d and e exist such that d ≠ e and chunk[d] = chunk[e]? Note that, as inputs n and k change, the solution to the problem can change between YES and NO, so no general solution exists.

P5. P2 and P3 imply that solving the problem requires ≥ O(2 ^ n) time, because there are O(2 ^ n) chunks to check for equality. Note that, because the chunks are not naturally ordered, a process of elimination isn't possible to reduce the time complexity to < O(2 ^ n) time.

P6. A solution to the problem can be verified in O(k) time by an equality check between chunk[d] and chunk[e] returning YES. These chunks can be calculated with the BBP formula.

P7. P5 and P6 imply S1, because the problem requires ≥ O(2 ^ n) time to find a solution but O(k) time to verify a solution.

0x51B4908DdCD986A41e2f8522BB5B68E563A358De

It actually is, “you and OP” are completely brain-dead

Anyone could do this retardation op is doing wow look at my “proof” it proves nothing, people shit on me, and then I pretend like - because I was corrected - that legitimizes my endeavor and I’m doing real math and then I shitpost again with their corrections in mind and then again and the shitposting never stops and eventually some day in the future after 100,000 shitposts I will finally have my proof because some anons shit on me over and over

That’s a great method for proving things, you should make a wiki page for it

What's so bad about never giving up and continuously improving your arguments? Also, please look at the new version!

instead of trying to solve the universe in a 6 line proof with the help of other anonymous shitposters, maybe read a book or something

Post this on stack exchange or physicforums or give this to your professor and see what happens

>P ≠ NP ``proof`''
>anime poster

>let P be greater than 0
>assume N =/= P
>I leave the steps as an exercise to the reader

Wow I fucking solved it guys. Check my proof. That was fucking easy.

There is no argument. There is just you who hasn't learned complexity theory well enough to make any argument. Just stop and go study, if it's your interest. This kind of attention-whoring isn't a very good way, if you want somebody to help you learn stuff and pay any attention.
>please look at the new version!
No.

BBP takes O(N log N) time to compute the Nth digit, which is exponential in n, the number of digits needed to index the positions.

The BBP formula has a time complexity of O(n × log(n) × M(log(n))), where M(m) is the complexity of integer multiplication. Integer multiplication can be done in O(n ^ 2) using schoolbook long multiplication, making the BBP formula polynomial.

You are presuming an asymptotically fast algorithm for integer multiplication, which isn't required.

>let p == np
guys i think i'm on to something here!

>this anime poster again
at least this is better than iq circle jerks
i can read some discussion

Can you please look at the revisions and give feedback? Thanks.

I don't have many anime girl pictures... I need to download more. Anyway, here is the proof with all the feedback so far put into it:

**Statement**

S1. P ≠ NP.

**Axioms**

A1. Given integer list x such that x is not naturally ordered, an element of x can't be selected by value in < O(|x|) time without first naturally ordering x, which requires ≥ O(|x|) time. Note that an element of x can still be selected by index in O(1) time.

**Proof**

P1. Let there be natural non-zero inputs n and k such that the complexity of the input is the sum of the bit lengths of binary n and k.

P2. Let a[b] be the element at index b of a, if a is a list. Let a[b] be bit at index b of a, if a is an integer.

P3. Let chunk be a list such that, for each natural c such that 0 ≤ c ≤ 2 ^ n, let natural chunk[c] be bits π[k × c + 1] to π[k × c + k].

P4. Let the problem be as follows: does d and e exist such that d ≠ e and chunk[d] = chunk[e]? Note that, as inputs n and k change, the solution to the problem can change between YES and NO, so no general solution exists.

P5. A1 implies the problem requires ≥ O(2 ^ n) time, because chunk is not naturally ordered and O(|chunk|) is O(2 ^ n).

P6. A solution to the problem can be verified in polynomial time by an equality check between chunk[d] and chunk[e] returning YES. These chunks can be calculated with the BBP formula, which can have a polynomial time complexity. More specifically, the BBP formula has a time complexity of O(k × log(k) × M(log(k))), where M(m) is the time complexity of integer multiplication, which can have a time complexity of O(k ^ 2) time using schoolbook long multiplication.

P7. P5 and P6 imply S1, because the problem requires ≥ O(2 ^ n) time to find a solution but polynomial time to verify a solution.

0x51B4908DdCD986A41e2f8522BB5B68E563A358De

>Integer multiplication can be done in O(n ^ 2) using schoolbook long multiplication, making the BBP formula polynomial.
But it is O(n log n M (log n)), not O(n log n M(n))

>A1. Given integer list x such that x is not naturally ordered, an element of x can't be selected by value in < O(|x|) time without first naturally ordering x, which requires ≥ O(|x|) time. Note that an element of x can still be selected by index in O(1) time.
That statement makes no sense at all. Ordering a list takes no time, the list comes in some order: you might not specify one but that doesn't have anything to do with complexity theory. This is why you're being told to learn some theory instead of coming back here over and over again: there is no amount of "tweaking" that will turn your nonsense into a valid proof, you need to learn what you're talking about first.

even better, still polynomial

natural order means ordered with the same order as the naturals

Then this statement:
>an element of x can't be selected by value in < O(|x|) time without first naturally ordering x
is untrue.

what im trying to say is that its not possible to select a rock by weight without iteration unless the rocks are sorted by weight

can you explain? is this not true?

But that isn't what you're saying, you say:
>an element of x can't be selected by value in < O(|x|) time without first naturally ordering x
Which is untrue if natural order means ordered with the same order as the naturals.
Also, if you are using your "axiom" in your proof, then you have only produced a conditional proof dependant on your new axiom. To solve P=NP, you need to show that P=NP, or otherwise, in ZFC, not ZFC + some other assumptions. To turn your proof into a proper proof you'd have to show that your A1 follows from the ZFC axioms.

ill word that better, then. do you really think you can take a list of rocks and select one of a given weight without randomness, iteration, or the list being sorted?

Have you even read Sipser yet like I told you to in the last thread? Bet you haven't.

But you aren't dealing with rocks, you're dealing with lists of integers! This is why you need to learn actual complexity theory, and more maths in general. A1 doesn't imply that the solution takes O(2^n) time because you might not need to evaluate the whole list and order it to answer the question, there could be a clever algorithm that takes d & e and spits out the right answer very quickly, you need to prove that NO POSSIBLE algorithm could do that: there is nothing to say that such an algorithm would rely on looking through the list via brute force. This is why the problem of P=NP is hard in the first place -- you've implicitly assumed the solution must take a particular form, but that mightn't be true.

"A clever algorithm" is not possible. Anything other than iteration requires transitive properties, and no such properties can exist because the order of the elements over any property changes with n and k.

PROVE IT don't just say it

God you're a fucking brainlet, this is the exact same topic we were discussing in one of your threads months ago and apparently you didn't listen. I can see why other anons are mad at you, you don't listen to basic advice

Have you even formally studied proofs at all? You don't just get to say things that seem reasonable, you have to PROVE EVERYTHING YOU SAY

OK. How does this sound? Presuming randomly selecting things isn't allowed:

1. The order of chunk changes as n or k change. This can be proven trivially by changing n or k.

2. A list must be ordered in order to search it in any way. Otherwise, you're basically trying to pick out a person with a green shirt from a line, that's not ordered by shirt color, without iterating over the line.

#1 implies that chunk isn't ordered for some n and some k. #2 implies that #1 implies that an element of chunk can't be selected without iteration.

Look user green shirts are not going to be used in the solution to P vs. NP

You clearly did not read what I said at all and are not even using formal mathematical language, just vague intuitive hand waving

This is pathetic.
You're clearly not even trying anymore and just using this as an excuse for attention because you're so fucking retarded you've become a local spectacle and you like the fact that somebody noticed you for once in your sad anime-ridden life.

I will prove P ≠ NP using a programming language (Swift):
[code]
var P = "P"
var NP = "NP"
if P == NP {
print("P = NP")
} else {
print("P ≠ NP")
}
[/code]
output:
> P ≠ NP

Veeky Forums BTFO by /g/, where's my money?

I was just trying to prove one step with that, not the entire thing. I was trying to prove the step that was contested....

Stop making these threads.

Stop making these posts.

You are not going to solve this problem.

You don't even understand the problem or the fields related to it and you never will.

Verification is not polynomial time. Complexity of BPP also depends on the depth in pi (i.e. 1,000,000th digit is harder to calculate than 1000th), not just on k, and also you seem to be confused about whether the size of the problem is the bitlength of n and k [i.e. log(n) + log(k) ], or n and k.

That's not what the complexity classes P and NP are. That's basically like saying that 0.999... ≠ 1 because 0.999... starts with a 0

>What's so bad about never giving up and continuously improving your arguments?
OP: I'm one of the people who helped you out in a recent thread. Listen to me: your arguments are not improving. They are just flailing around without making a shred of progress, even if doesn't feel that way to you.

The field of complexity theory has an exact idea of what exactly an arguments needs to show to prove that P != NP. You do not understand that specification, and as a consequence you cannot tell whether your proofs are correct at all, much less whether it can be transformed into something correct. Instead, you need the thread to tell you, time and again, exactly why your attempted proofs don't prove what you are after at all.

And it so happens that any naive attempt at proving P != NP, not informed with this understanding, can never match the specification of what makes a correct P != NP proof. Any attempt to prove it without this understanding will inevitably be completely hopelessly off-base, and beyond repair, because they are solving the wrong problem entirely. Which means that until you understand enough of the background theory to be able to judge *by yourself* whether your proofs are correct, you stand zero chance of coming up with a correct proof, or even anything that can be improved into one, or inspire a correct proof. You are just wasting your time.

And more importantly, you are wasting everyone else's time, as well. I know that I, for one, am no longer interested in helping you parasitically feed on those who do understand this material; you can do your own homework. And I imagine that everyone else is approaching this point as well.

>Also, please look at the new version!
No. Come back when you understand the background theory well enough for it to worth it.

n-naaaaniii?????

“Proof by shitpost induction”

Pretty sure this guys a literal maniac. One time I had a manic episode after taking some antidepressants I started seeing patterns everywhere and writing down the patterns to a ridiculous degree. I thought I was going to unlock the secrets of the Universe and I didn't sleep for 3 days straight. Either that or this guy is actually retarded.

Sounds like the acid trip that made me quit. I had all these abstraction and I thought I was seeing things on the level of Einstein, and if I could only just write down these dependency graphs everything in the world would be okay again and nobody would fight

Turns out OP is a retarded cryptocurrency cultist, which is not at all surprising.

lmao, this is the way of the future

imagine of p=np was solved by some weeb repeatedly shitposting for years on end

You have to think of it a different way. The shitposting and responses would have to improve in methodology to reach that conclusion. Right now it is taking basically a random shot repeatedly. That means there is a 1 in how every many possibilities there are in ever landing on the proof.

The current situation is a little bit worse then that because he is merely modifying some that are just completely wrong. One improvement would be to scrap a proof completely and start from scratch for any found mistake.