Ladner’s theorem in TOC

Ladner’s theorem in TOC :
As you presumably know, regardless of whether  P = NP is a significant perplexing issue in field of Computer Science. In computational complexity, those problems which belongs to NP- problems but can’t belong to P or  NP-complete are known as NP-intermediate problems.

Taking into account NP-complete issues, it is normal to keep thinking about whether we have a division among P and NP-complete, to be specific whether  P or NP comprises of just NP-complete issues,  on the off chance that P  ≠ NP. 

Even if you think of P  ≠ NP , it is enticing to believe that NP  =  P ∪ NP-complete – that each issue in NP can either be tackled in polynomial time or is sufficiently expressive to encode SAT. All this issues was solved by Ladner , his theorem proves that intermediate complexity exist. 

NP-intermediate Problems :
A language L ∈ NP is NP-intermediate if and only if L∉ P and L∉ NP-complete.

Ladner’s Theorem : 
If P ≠ NP then there is a language L which is NP intermediate language.
In other words if P ≠ NP is true, then NP Intermediate is not empty, it means NP contains problems which are neither in P nor NP-complete.

Proof : 
By using diagonalization, 

let us assume a special function H : N –> N such that :

• O(m³) time required to process H(m) from m.
• H(m) –> ∞ with m if  SAT_H ∉ P.
• H(m) ≤ C (C= constant) if SAT_H ∈ P .
• Now,  Let SAT_H = {Ψ₀ 1 ^{m^ H(m)} : Ψ ∈ SAT and |Ψ| = m}

Taking P ≠ NP into account,  H is characterized so that  SAT_H  is NP-intermediate .

1. Let SAT_H ∈ P. Then H(m) ≤ C.
This suggests a poly-time algorithm for SAT as follows :

• first input ϕ , and get the value of m = |ϕ|.
• Now generate a string ϕ 0 1 ^{m^ H(m)} from calculated H(m).
• Verify if  string ϕ 0 1 ^{m^ H(m)}  ∈ SAT_H.

Result – Hence it should be SAT_H ∉ P , because of P ≠ NP.

2. Let SAT_H ∈ NP-complete. This implies  H(m)–>∞ with m.
This suggests a poly-time algorithm for SAT as follows :

• SAT ≤_p SAT_H   and ϕ–> Ψ 0 1^k 
• first input ϕ with m = |Ψ| , and get the value of f(ϕ) = Ψ 0 1^k.
• Verify if k = m ^H(m) by processing H(m).
• This suggest , n ^c = |f(ϕ)| ≥ k ≥ m^2c .

Hence, √n ≥ m Also ϕ ∈ SAT if  Ψ ∈ SAT.
Only O(log log n) recursive steps needed.

Result – Hence SAT_H ∉  NP-complete, as P ≠ NP. 

Construction of H : 
Now for H construction , we notice that the value of H(m) govern
membership on SAT_H of strings, Here length of SAT_H of string ≥ m. 

• Hence we will define H(m) whose length is < m , according to string in SAT_H .
• Now for construction, we know that H(m) is the smallest k < log (log m) such that M_k  chooses participation of all length up to  log m strings x in SAT_H inside k. |x| ^k  time_.    If not then we can say  H(m) = log (log m). 
• Now H(m) ≤ C if and only if SAT_H ∈ P is true.

There is a poly-time M that chooses  enrollment of each x ∈ SAT_H inside c. |x| ^c  time.  Here M can be addressed by vastly many strings,  there’s α ≥ c such that M = M*α chooses participation of each x ∈ SAT_H inside α.|x| ^α  time.
Hence H(m) ≤ α for all m which satisfy α < log (log m). 

• If SAT_H ∈ P then H(m) ≤ C (for infinitely many m).
   H(m) = k for infinitely many m when  k ≤ C this condition true. 

make any x ∈ {0,1}* now find largest M such that |x| ≤ log m and H(m) = k. Here x is decided by M_k in k. |x| ^k time.
SAT_H is determined by M_k which is poly-time machine. 

Properties of H : 
Properties of H are as follows :

• O(m3) time required to process H(m) from m.
• H(m) –> ∞ with m if  SAT_H ∉ P.
• H(m) ≤ C (C= constant) if SAT_H ∈ P .

Limits of diagonalization :
Diagonalization is a technique used to separate sets . Here we want to separate two sets NP and P for NP intermediate set. Kozen theorem shows that strong diagonalization does not relativize.

 While the P versus NP question is still yet unsettled, we have refined our attention on the subject. Despite the fact that there is solid proof against diagonalization’s capacity to isolate P and NP, we have shown that it this doesn’t matter to our thought of solid diagonalization. Besides, solid diagonalization is the best way to isolate these P and NP, as Kozen illustrated in his theorem.

Examples of NP-intermediate problem :

• Computing the discrete logarithm.
• Graph isomorphism problem.
•  Factoring the discrete logarithm.
• Approximation of shortest vector in a lattice.
• Minimum Circuit Size Problem.