P versus NP polynomial problem: How can we verify before applying the solution?

 The P versus NP problem asks whether every problem whose solution can be quickly verified by a computer can also be quickly solved by one.
According to an unknown theorem when something is repeated 1000 times an error is bound to exist if there is no check and balance.
In a randomly occurring events, what happens next depends only on the state of affairs of now.  (Markov chains)

 A polynomial is a mathematical expression constructed from variables and coefficients,
The expression 2x + 3y is a polynomial. Specifically, it is a linear polynomial with two variables and both with exponential of 1,  while 2x³ + 3y⁴+3 is an exponential type  with a constant rate of change 

P versus NP polynomial problem says that can we quickly solve a problem and at the same time verify if that is the solution before applying it 

P versus NP problem, verification is fundamentally easier than finding the solution from scratch. Before deploying any algorithmic solution, you can verify it in polynomial time using a mathematical "proof" or "certificate" that confirms if the proposed answer satisfies all the constraints of the problem

Falling Coconut kills more people than sharks attack...... How do we solve the falling Coconut problem?

*P vs NP* is the big computer science question:  If you can check a solution fast, can you also find it fast?

- *P* = problems we can solve quickly [polynomial time] 

- *NP* = problems where we can verify a solution quickly [polynomial time], but finding it might be hard

*How to verify BEFORE you try to solve it*

With P vs NP problems, the key move is: *don’t solve, verify first, If it’s NP, that’s the whole point.

check if your problem is NP-style, we should asked  "If someone handed me a solution, could I check it fast?" 

examples of P versus NP polynomial problem.

- *Traveling Salesman*: "Here’s a route = 400km" → I can add distances fast. That’s verification in P Polynomial and finding the route is the hard part, that is the problem in NP polynomial

- *Sudoku*:    "Here’s a filled grid" → I can check rows/cols fast. Filling it is hard.
in sudoku game  it is all about verification first before application of correct number in the grid.

 The core of the P versus NP question asks if the reverse is also true—whether the ability to easily check a solution means we should be able to easily compute it from scratch .

The complexity of the P versus NP (verification time and solution time)  is analogous to the multifaceted Nigerian state problems, how can we quickly verify the solution to Nigeria problem before applying the solution,  It means that there are genuine, insurmountable barriers to solving certain problems quickly.
The Nigeria state problems can be a Nondeterministic Polynomial Time problem, that is the solution is nondeterministic as each solution can not be quickly verified as each variable components of the country problems have too much of exponential tendency which cannot be quickly resolved at the same time when trying to solve the problem

The Polynomial Time problem is in the falling coconut from a tree can kill, but the verification to the solution is how quickly can we think for a solution  and verify if that is the desirable solution at same time.

P = NP means: "If we can verify a solution quickly, then we can also find the solution quickly"
P ≠ NP means: "Some problems are easy to check but impossibly hard to solve from scratch"

P (Polynomial Time): Problems that a computer can easily and quickly solve. The time it takes to find the answer grows at a manageable rate (a polynomial function) as the puzzle gets bigger. Examples include sorting a list or multiplying numbers. 

Polynomial time describes an algorithm whose execution time grows at a rate proportional to a polynomial function of the input size

NP (Nondeterministic Polynomial Time): Problems where, if you are handed a potential solution, you can easily verify if it is correct in a reasonable amount of time. However, finding that solution from scratch is incredibly difficult and might take longer than the age of the universe using brute force. 

NP-Complete: The absolute hardest problems in NP. If you discover a fast way to solve just one of these problems, you can solve all NP problems quickly, proving that P = NP. A famous example is the Traveling Salesperson Problem, which asks for the shortest possible route to visit a series of cities. 

Verification vs. Finding: For problems in NP, verifying the correctness of a potential solution is fast (polynomial). However, discovering the solution itself often requires algorithms with exponential time complexities, forcing computers to perform brute-force checks of millions of combination.

Non-deterministic algorithms often cannot be executed in polynomial time due to their unpredictable nature. In deterministic algorithms, the execution path remains the same in every execution. In non-deterministic algorithms, the execution path varies between executions and may take different, random paths.

Bottom line is that P vs NP asks: Is finding the solution  as easy as checking the solution ?