# 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
^{3}) 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}= {Ψ_{0 }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.

ake 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.

Learn CS Theory concepts for SDE interviews with the **CS Theory Course** at a student-friendly price and become industry ready.