Computational Complexity Theory - Science topic

The pumping lemma is a valuable theoretical tool for understanding the limitations of finite automata and regular languages. It is not used for solving computational problems directly but is important for proving non-regularity and understanding the boundaries of regular languages.

The question of whether P equals NP in polynomial time is one of the most famous unsolved problems in computational complexity theory. In this context, P refers to the set of problems that can be solved in polynomial time on a deterministic Turing machine, while NP refers to the set of problems for which a solution can be verified in polynomial time once it is given.

If P were to equal NP, it would imply that problems for which solutions can be verified quickly could also be solved quickly. This would have profound implications across various fields, including cryptography, optimization, artificial intelligence, and many other areas of computer science.

For example, in cryptography, the security of many encryption algorithms relies on the assumption that certain problems are hard to solve (NP-hard problems). If P were to equal NP, it could potentially mean that these problems are not as hard to solve as previously believed, leading to significant vulnerabilities in cryptographic systems.

Similarly, in optimization, many real-world problems involve finding the best solution among a vast number of possible options. If P were to equal NP, it would revolutionize optimization algorithms, potentially enabling the efficient solution of complex optimization problems that are currently considered computationally intractable.

Despite decades of research and numerous attempts to solve the P vs. NP problem, no definitive answer has been found yet. The resolution of this question would not only have far-reaching implications for computer science but also impact our understanding of the inherent complexity of computational problems and the limits of efficient computation.

π=3.1415926535897932384626433832795…⇒π≃3.14,

while 22/7=3.1428571428571428571428571428571…=3.(142857) ̅ …⇒22/7≃3.14≃π

looks like the answer has been deleted?

Hi,

If it still persists, just add a new line character around the line of SOL in topol.top file. Sometimes, gmx behaves in a weird manner during reading SOL.

HTH.

The question about avoidance of intersection of trajectories in state space has different meaning for infinitesimal numbers and for bounded rationals. Thus while in the first case distnaces among trajectories are infinitesimely small. This however, implies that energy/matter/information involved in the aviodance of any intersection is ill-defined and since the infinitesimal numbers involve infinite energy/matter/information for their execution, it turns out that notion of distance becomes compromised. On the other hand, a bounded dense transitive set of trajectories provides a bounded well-defined distance between trajecories, even though they intersect. The tricky point is that this bounded set has no dynamical center because of the perpetual motion with bounded velocity, although it has a geometric one according to Weierstrass theorem.

Hi? You might want to have a look at one of my publications - 10.1016/j.envsoft.2020.104800

I recently conducted a similar study where I applied three different sensitivity analysis methods to fire simulations and compared their results!

Cheers!

Dear Tim Heiszwolf

In DFT, since all the so-called Kohn-Sham (KS) integrals are performed over functionals of charge density , the size of the computations scales up as O(N^3). Here, N represents the system size which can be the number of atoms, electrons or basis functions. In practice, the exact value of N depends on the method used for solving the KS integrations. For example, if the so-called all-electron method is used, N would be the number atomic-orbital basis sets used to construct the wave functions within the unit cell. On the other hand, for pseudo-potential methods (in which the contribution of core electrons is neglected), the number of valence electrons of each atom within the unit cell is relevant for N.

Dear Frank Vega

I read your notes, but I got nothing! You described some open problems. Complexity theory is useful in the presence of an algorithm to tackle the problem.

First, you need to show a concrete theory and then build your algorithm with a suitable complexity time to support your proofs.

We have nothing to do with complexity in the absence of the theory.

Best regards

DEA is generally applied to assess the relative performance a set of decision making units (DMUs) that consume inputs to produce outputs under a similar production technology. This may be valid whenever the systems under consideration fit within such a structure. In graph related problems such as scheduling, routing, etc., the objectives are completely different. Although there is a flow of material over the network, which may suggest that a node can be assimilated to a DMU, here, we are more concerned with finding an optimal route that satisfies constraints that may be as complex as the practical problem under study. In large scale problems, one may think of DEA for building clusters of nodes so that to reduce the problem size and, hence, related computational cost. I think that this aspect is worth to be investigated.

I agree handcrafting components is going to be critical in the future. I think creating hybrid networks with both hand crafted as well as learner components is going to be the next step. Since neural nets are too rigid post training this to truly instill some dynamic component hand crafting would be the most ideal way.

If you are really interested in the properties of algorithms, perhaps you should consult the bible of algorithms: The Art of Computer Programming by Donald Knuth. It's all there! ;-)

This is not my field of research but I chanced on some useful resources on computational aspects in statistical processing as well as on approximate signal processing. All the best in your project.

Many nonconvex MINLPs can be solved easily nowadays with spatial branch-and-bound solvers.  For a recent review of optimization solvers that can solve this class of problems, see Kılınç, M. and N. V. Sahinidis, State-of-the-art in mixed-integer nonlinear programming, in T. Terlaky, M. Anjos and S. Ahmed (eds.), Advances and Trends in Optimization with Engineering Applications, MOS-SIAM Book Series on Optimization, SIAM, Philadelphia, 2017, pp. 273-292.

For freely available tools through the NEOS server, see https://neos-server.org/neos/solvers/index.html#minco

For some recent comparisons of MINLP solvers, see http://plato.asu.edu/ftp/minlp.html

Thanks for your attention to my questions. As a follow-up message, I report that I now have the answer to my earlier questions. It is not surprising that there are optimization problems that are neither in APX nor strongly NP-hard. In fact, there is no close connection between the separation boundary of strongly/weakly NP-hardness and that of approximability/in-approximability. For those who would like to have more details, please get in touch via individual communications.

Yes Sir, that is the trivial way of doing this.  Thanks

You might find this very interesting! I think it might be close to what you have been asking for. http://www.wolframscience.com/prizes/tm23/solved.html

You can find the proof here: http://www.wolframscience.com/prizes/tm23/TM23Proof.pdf

thanks for your usefull help

That depends on what "more" means. :-) If "more" is a constant (finite) number then it means that you solve a finite number of NP-complete problems - which is still NP-complete.

Yes! my question was regarding the "exponential" with respect to the number of variables. (The question "arose" when I was trying a problem reduction from QBF. )

I understood that the question was irrelevant in any sense as the number of disjunctive clauses in the  CNF  depends on the atomics. I was about to delete the question and then saw your answer. Thank you for considering my question and taking time to answer it.

Complexity increases as source data integrity and linearity becomes compromised or more complex in itself, thereby changing the "fit". It also increases with increased definition of actionable content within the data.

It appears to me that, in the paper you cited, Chaitin uses the phrase "irreducibly complex" as a synonym for "algorithmically random." This is quite different from computational complexity such as NP-completeness.  Algorithmically random is defined in terms of Kolmogorov complexity.  The prefix-free Kolmogorov complexity,  K(s) of a binary string, s, is defined to be the length of the shortest program that outputs s.   Prefix-free means that no program is a prefix of another program. We assume a fixed optimal computer. Changing optimal computers changes the Kolmogorov complexities of strings, but the change is bounded by a single constant for all strings.   Results in Kolmogorov complexity are usually stated "up to an additive constant"  just as results in analysis of algorithms are usually stated "up to a mupltiplicative constant"  (big O notation).  An infinite binary sequence, x, is algorithmically random if there is a constant b such that for all n, K(x[n]) >= n - b, where x[n] is the initial segment of x consisting of the first n bits of x. This means that the initial segments of x cannot be described using short programs. The programs must be almost as long as the strings themselves. (The programs can be shorter only by the additive constant b.)  Algorithmically random sequences cannot be computable.  A computable sequence x can be described by a program of finite length, so an initial segment x[n] can be described by the finite program plus a description of n, which can described using less than 2log(n)+O(1) bits.  This implies x is not algorithmically random.  However, although algorithmically random implies not computable, the converse implication doesn't hold.  For instance, if x=x0, x1, x2, ... is algorithmically random, x0, 0, x1, 0, x2, 0, ... is not computable, but is not algorithmically random since an initial segment of length n only contains n/2 bits of information.   Algorithmically random sequences are upredicatable in the sense that no program can predit the bits of the sequence with better than 50% accuracy.

In classical literature, I didn't know another kind of one-way functions.

In my view particle swarm and genetic algorithms are simply elaborate ways to explore some of the solution space (i.e. a fraction of the feasible region). There is very little theory guiding this search -- which is fine if you have absolutely no idea about how to tackle your underlying problem. But most of us, once we explore a problem, begin to gain some appreciation for the multivariate space which contains the solutions. Much better then, as hinted in the other answers, is to formulate easier-to-solve special cases, relaxations, etc. In other words exploit / explore the structure of the problem. That would also seem to lead to a better chance of having a publishable result -- e.g. as a result of finding a new facet defining inequality for example (basically chopping off more infeasible solutions). Good luck and let us know what you decide as a strategy!

In addition, consider searching from

both sides. When two opposing vertices

from different starting points meet,

you can stop. For example, you can

start from one side with positive

counting 1,2,3,4... from the other

side with -1,-2,-3,-4... When an edge

appears with a positive and negative

node on either side, you can construct

the path by stepping back in descending

and ascending order.

You can also use 2 marks instead

of a single positive/negative.

Regards,

Joachim

Dear colleagues,

First, I must correct a mistake in my previous comment. Where it is written

“For each other component C, check if there is a vertex u of C such that there is an arc vu in G with v ∉ V(C), and such that your property holds for the component C taking u as root. If it holds for some u, it means that there is a DAG which contains all arcs of T ∩ E(C) and that all vertices of C are reachable from u. But it also means that there is a path from r to u.”

It should actually be read:

“For each other component C, let S(C) be the set of all vertices u of C such that there is an arc vu in G with v ∉ V(C), and let C' be the graph obtained by creating temporarily a supersource s_C with an arc to every vertex u of S(C). Then, check if your property holds for C' taking s_C as root. If it holds, it means that there is a DAG which contains all arcs of T ∩ E(C) and that all vertices of C are reachable from some vertex u of S(C). But it also means that all vertices of C are reachable from r, since there is a path from r to each vertex of S(C).”

The change above is necessary since there could be a case wherein all vertices of C are reachable from r, but still not reachable from a single vertex of S(C).

Let me clarify how you could check your property for C' taking s_C as root, given that C is strongly connected. Surely the arcs of T ∩ E(C) induce a DAG D, otherwise G would not have passed in the prechecking. If there is a path in C from some u in S(C) to some source x of D (a source of D is a vertex with indegree 0 in D) which passes by a vertex y ≠ x of D reachable from x in D, then this path cannot exist in the DAG we are willing to construct, for it would create a cycle. So, all you have to do is to check, for every source x of D, if there is a path in C' from s_C to x which does not pass by any non-source vertex y of D reachable from x in D. It is pretty easy to see that this can be done in quadratic total time: one could, for each source x of D, temporarily delete all vertices y reachable from x in D, and then run a DFS from s_C to check if x is still reachable from s_C in C' even after the deletion. Notice that, as C is strongly connected, only the sources of D need to be tested. Please do not forget to restore the deleted vertices after the DFS for each source x of D. I would not be surprised if the total time for all sources could also be linear, but I would need some further thinking to make up with something.

Marcelo, surely v is in an already verified component, since the components are taken following a topological sorting of the SCC-DAG of G.

Again, best regards.

My first  thought: if two polytrees are isomorphic then their underlying trees must be isomorphic: this surely cuts the problem space down immensely.  I suspect that the methods which show that the isomorphism problem for trees is in P can be modified to work for polytrees too: something along the lines of 

a) find the center(s) of the underlying trees

b) consider the subtrees meeting at the center: either there are few of them, in which case divide and conquer again, or there are many, in which case the trees in question are small.

I don't immediately see how to implement this, but the fact that trees are in P strongly suggests to me that polytrees should be too.

Of course, you could just wait a little while and see if Babai and others manage to tighten his proof  that GI is almost in P to get it actually in P!

Thank you Dimiter, I see Rough Relations go back to Pawlak and there are several references in J. Stepaniuk Rough Relations and Logics:

 I have been working on a version of rough graphs where you start with a graph and impose a kind of "equivalence relation on a graph" and I thought there must be similar things out there. My equivalence relations on graphs are relations in the sense of

Stell, J. G.(2015) Symmetric Heyting Relation Algebras with Applications to Hypergraphs. Journal of Logical and Algebraic Methods in Programming, vol 84 pp440-455.

where the relations are reflexive and transitive (in a straightforward way) but there is a weak kind of symmetry defined using the left converse operation in the above paper.

So I was especially looking for work which adopted the strategy that you get a "rough x" by finding a notion of "equivalence relation on an x" (or partition etc) and then get a way to approximate a "sub x" in terms of the "equivalence classes" which will themselves form an x and not merely a set. For x=hypergraph I think we can do all this.

Mathematica claims to have the largest set of statistical tests.  I looked through Kolmogorov relatives and found nothing but data.  However, at the bottom of Mathematica pages related functions are suggested.  Here's a method that works with vectors: https://reference.wolfram.com/language/ref/SpearmanRankTest.html .  I suggest just looking through their functions as if it were a textbook.

.

by the way, the Stream Summary data structure is not so complicated ; in order to understand it, you just have to remember the following facts

therefore it makes sense

... which is the basic structure of the Stream Summary

.

I do not know the answer but this is what i thought.

If you can build a deterministic algorithm to solve this problem in polynomial time then it belongs to Class P. If not, you can try to prove  that this problem is in NP-Complete.

(summarizing some theory)

1° Prove that this problem is in NP.

a) Define a structure to represent a solution from this problem.

b) Build a non deterministic turing machine (random algorithm) to generate a solution.

c) Build a deterministic algorithm to verify if the generated solution satisfies the problem.

2° Prove that this problem is NP-Complete

build a polynomial tranformation from [math] pi^* \in NP-C[/math] to your problem.

try to transform from SAT or TSP to this problem.

Also I guest this is a combinatorial problem, and looks like the Linear Ordering Problem (LOP).

I hope this helps in some way and find an anwer to your question.

I am not sure what your question is. But, a decimal number might be the column shifting of an identity matrix  in the representation of a QC-LDPC parity matrix. For example,  9 means a cyclic shifting right  of the columns of an identity matrix by 9.

Even if you normalize them, the scaling will appear because of the non-uniformity of the grid. If you have 'N+1' points, you will get 'N+1' eigenvalues out of which 2/3rd of them will agree with the analytical solution and the remaining 1/3rd will scale as N^2 for a Laplacian.

I was able to work it out. Thanks for sharing though.

Anthony, there are other posts that I've made where it is determined that the sequence is a de Bruijn sequence.  What is most important about my work is the speed with which such a sequence can be generated; for 100 million digit de Bruijn sequence, my software produces same in less than 30 minutes.  Also, while random is not computable, it is also true that random is biased from maximal disorder.  Thanks for the reply.

Oh, and concerning your question in the title: a weighted automaton is very much like a standard finite automaton. The only additional feature is that every transition has a weight (from the chosen semiring). The weight of a string is obtained by multiplying the weights of all the transitions that he automaton uses while reading this string. If the automaton is non-deterministic there can be several possible computations (with possibly different weights) for the same input word. In this case, the resulting weights are summed up. This is how the two semiring operations sum and product are used. 

For example: give every transition weight one. Then the weight of the word is the number of different accepting computations.

Thank you very much. I wanted just to enrich the discussion about. For now, we are preparing a large-scale test collection from hadith books to be announced on www.jarir.tn.

I know - I think there are too many papers that contribute only heuristic solution methods, with no quality guarantees. We DO want to find an optimal solution, and almost all heuristics provide a feasible solution with NO guarantee of being any good.

The basic technique to establish that an optimization problem is "difficult" in the language of complexity theory, is to show that you can convert (in polynomial time and space) a problem (problem P, say) that you already know is "difficult" to your problem, problem Q. We call it a "polynomial reduction", because we (1) state both problems P and Q in a common language, and (2) we show that any instance of the known difficult problem P can be converted in polynomial time AND space to our problem Q. We have therefore shown that among all problems in the class Q there exist difficult ones, and we are done. 

The perhaps first really good book that illustrates these conversions is by Garey and Johnson. Chapter one is here: http://udel.edu/~heinz/classes/2014/4-667/materials/readings/Garey%20and%20Johnson/Chapter%20One.pdf

Wikipedia's page on complexity -http://en.wikipedia.org/wiki/Computational_complexity_theory#Reduction - is not bad.

Your question makes me think about mathematical morphology (the mathematical framework is based on lattices, but it is applied on grids, graphs). Connectivity is important, there are some notions as watersheds, it ls related with segmentation (more preciselly it is a tool for some segmentation technics) and so on... I give you the wikipedia link but there exists of course many academic sources (http://en.wikipedia.org/wiki/Mathematical_morphology).

Thank you for your kind reply.

I see that there is a reduction proof on the CSTheory StackExchange website already. But if it is a reference that you need, here it is:

Fricke, G. H., Hedetniemi, S. T., Jacobs, D. P.,

Independence and irredundance in k-regular graphs.

Ars Combin. 49 (1998), 271–279.

Summary from MathSciNet: "We show that for each fixed k≥3, the INDEPENDENT SET problem is NP-complete for the class of k-regular graphs. Several other decision problems, including IRREDUNDANT SET, are also NP-complete for each class of k-regular graphs, for k≥6.''

Now, if the summary is correct, the authors prove that the decision version of the independent set problem is NP-complete for the class of k-regular graphs. Therefore, the optimization problem of finding the maximal independent set is np-hard for the same class. And of course, the minumum vertex cover is the complement of the max independent set. Hope this helps.

Charles, no, it is done for momentum meausurement, I have given the formulas, of course, one needs the cofiguration of the measurement device as well as the full wave function for this too, and, again, this is not speculation but the prescription, the necessary consequence of the dBB equations, and this is well-known since Bohm's paper. Because this extension from position measurement to all other quantum measurements was the main new result of Bohm's paper in comparison with de Broglies original theory. 

Only repetition of already rejected arguments, so it seems time to finish this discussion. Its already clear that you have no counterarguments against the points I have made, but are unwilling to accept anything.  Bye. 

You can look at some of my papers on how the reduced model work.

Thank you all for your help, but I think Dr. Breuer is right. My question was not clear enough! Please accept my apology.

Let me explain it, I am trying to solve a  linear equation Ax = B.

As Matrix A is not a square matrix, I use x= (A^TA)^-1A^TB

Different experiments result different matrix A and B. matrix A is always accurate but, Matrix B is obtained from some practical experiments therefore, is not accurate.

I know the accuracy of the answer is dependent  on the condition number of matrix (A^TA), and I am using "Cond()" command in Matlab to calculate it. and then I want to use this number to find the most accurate answer.

Now I want to Know what is the computational complexity of  doing this procedure.How many operations is used to calculate it? (matrix A is M by 2 and matrix B is M by 1).

I hope this is clear enough.

Thanks in advance.

There is an obvious reduction form 3DM to the problem of finding a maximum heterochromatic matching in an ede-colored graph (represent the third gender in each triplet by colors).

Therefore, the problem of finding a maximum heterochromatic matching in an ede-colored graph is NP-complete.

Moreover, 3DM is NP-complete even when no two triplets intersect in more than one element. When we start from instances with this property, the reduction mentioned above yields only properly edge-colored graphs. Therefore, the same problem remains NP-complete for properly edge colored bipartite graphs.

Assessing NP-completeness in the case of strong edge-colorings is more technical but  appears now to be downhill.

Drawing a trees hierarchically on a grid (with other aesthetics) as narrow as possible is NP-complete. See: http://link.springer.com/article/10.1007/BF00289576

For instance, a polynomial reduction from SUDOKU into SAT is a function for computing in polynomial time a propositional formula from an incomplete grid of Sudoku such that the Sudoku grid is solvable iff the propositional formula is satisfiable.

"Reduction" is a metaphore because SUDOKU is then seen as a "sub-problem" of SAT. SAT is more general.

Thus, as SAT is NP, SUDOKU is also in NP.

Now, as SAT is also NP-hard, if you can build a polynomial reduction from SAT into, let say, COLORING, then it means that SAT is a "sub-problem" of COLORING. Thus, if SAT is already hard, COLORING has no choice to be harder than SAT. That is COLORING is NP-hard.

Nice question. The first 30 coeffients are presented at attachment. Since they are extremely complicated, I present only their numeric values. After a while they seem to decrease without a known pattern. I hope it will help.

Here are some useful references:

1 Hoang Tuy. Convexity and Monotonicity in Global Optimization. Advances in Convex Analysis and Global Optimization.

Nonconvex Optimization and Its Applications Volume 54, 2001, pp 569-594

2. The following chapters 6. Algorithms for Constructing Optimal on Volume Ellipsoids and Semidefinite Programming. 7. The Role of Ellipsoid Method for Complexity Analysis of Combinatorial Problems. 8. Semidefinite Programming Bounds for Extremal Graph Problems.in the book N.Z Shor. Nondifferentiable Optimization and Polynomial Problems.Nonconvex Optimization and Its Applications, Vol. 24, 1998, XVII, 396 p.

See, e.g. http://www.springer.com/mathematics/book/978-0-7923-4997-6

Yes. For complexity as r tends to infinity, the value of int (r) also tends to infinity and fract (r) is less than 1.So complexity depends on int(r).

I wouldn't say "why is PSPACE required". If you choose not to study it, that's entirely up to you; one wants to stand on the shoulder of giants when doing research. Theoreticians have figured out that problems sitting in PSPACE have certain properties. For example, problems in P and NP all are in PSPACE. It is of interest to those working on intractable problems that may be exhaustive in nature (may have an EXP like behaviour). Since we know EXPSPACE is not in PSPACE, showing it in PSPACE is very useful. Keep in mind that PSPACE means that there exists an algorithm for which the problem (its decision variant) can solved in a polynomial space with respect to the input size.

I think Timur's answer is also helpful.

I'm not quite following. What you are saying in both cases is a reduction (at least to me), just rephrased. Let me expand on this:

In Theoretical Computer Science, we use this idea all the time. It is usually to illustrate the difficulty of solving one problem in relation to another; and provides a clear way to develop an algorithm.

Keep in mind what I saw below are assumed that the results are proven to be true as a premise:

1) What exactly do you mean by "simpler form"? Give a concrete example. Are you meaning something like taking a graph, using some intuition and making some kind of bipartite graph to say something about the original graph? I'd think something like this could technically be skewed as a reduction as well since you just made a new instance that just coincidentally may solve the same problem. Reductions can even occur within the same set of problem instances.

2) The solution set may not be the same between P1 and P2 because the instances are not really the same. Assuming you are talking about a reduction in the scope of something like an optimization problem, you would need to show how you take one instance of a problem and transform it into another one. Typically a reduction is taking an instance I of P1, creating an instance I' using I for problem P2, solving P2, then giving how to get the solution for I from the solution of I' (or their correspondence). In decision problems it is pretty straightforward (as all of them are 'yes'/'no' answers).

To me, it just sounds like a bit of different language. I've seen people call reductions other things like transformations. There are special kinds of reductions though, like a Karp reduction, or Turing reduction. At their heart is taking an instance, making a new instance from it, solving that new instance, and showing what it means for the original by proving a correspondence.

I guess you should start reading a different book. Catch a hold of Introduction to Algorithms by CLRS (search on google).

Apart from this, you can classify any algorithm according to two ways -

1. Ease of coding (complexity of coding NOT execution)

2. Complexity (efficiency) [1]

The most basic algorithms such as Bubble sort, Insertion sort or Selection sort are inefficient in nature (of the order of O(n^2) ) but very easy to code. Other algorithms such as Merge sort, Quick sort and heap sort can provide an efficient performance (of the order of O( n log n) ) in average or worst cases. However, they are trickier to code.

A little more efficient algorithms are Counting sort and Radix sort which provide O(n) performance for a trade off with memory space and several constraints. However, they are also not trivial to code.

Apart from these, other sorting techniques like Tim sort, Shell sort etc., are very less used because of difficulty in coding and almost same performance as the other sorting techniques [2].

[1] : http://bigocheatsheet.com

[2] : http://en.wikipedia.org/wiki/Sorting_algorithm

Expand the standard reduction from 3-SAT to SUBSET SUM adding an extra 1bit column 2^c (in a way that 2^c doesn't interfere with the other bits); set to 1 the bit of that column for all the M addends of the subset sum; add M new dummy addends with only that 2^c bit set; and set as target sum the original target sum T plus M2^c. For what regards the number of addends pick K=M. In this way you can pick an arbitrary number of addends of the original subset sum problem and use the dummy addends to reach exactly K addends (and the K2^c part of the modified target sum T+K2^c).

I hope that it is not a homework question ....

Thank you for your answer to my question from ResearchGate. Please read the last version of my article (SAT13.pdf posted on ResearchGate on my profile).

You assume that we update the x_i assignments every time we find a consistent active chain of dual variables. That is a false assumption.

We work with a solution path (which I also call the active chain of dual variables) through the 3 - CNF clauses, and this active chain of dual variables is formed of 2-CNF clauses, only one for each 3 -CNF clause. At any stage of the algorithm, this chain can have length N (the number of 3-CNF clauses) or less than N, this chain will grow in length, or decrease, depending on whether Test2CNF tells us that the current active chain of dual variables is consistent or not. I emphasize that we do not seek the solution in terms of the original variables unless we have all the 3-CNF clauses solved. That is the whole point, each state of the active chain of dual variables represents a whole class of x_i assignments. That is why in a space of 2^n objects, we can find a certain object (the solution) in polynomial time with sufficiently high probability. My algorithm, if anything, is not simplistic, but it requires attention (and I do agree that it needs more work).

What is your metric for "fast". Time complexity or experimental results? That may help researchers answer your question.

thanks Bolivar

but i want some code implementations, to compare with my method which i guess O(n^2)

In complexity theory, we consider a variety of notions of reduction. However, completeness is only meaningful if you use a class of reductions from a potentially smaller class. Every non-trivial problem in PSPACE is complete for PSPACE under PSPACE reductions: the reduction simply solves the problem in question and produces an instance with the same value. On the other hand, it makes sense to talk about problems complete for EXP under PSPACE reductions, although I do not know of any such problems that are not also known to be complete under P reductions.

Also check this out ftp://ftp.cs.vu.nl/pub/dick/PTAPG_2nd_Edition/CompleteList.pdf

example : 1. If G is a cycle of any finite length L then we have delete one vertex to have metric dimension d-1. If G is a complete graph on N vertices then we have delete one vertex to have metric dimension d-1.

Dear Marzio, I am not so sure what you are after: Devices that can simulate a Turing machine with only a polynomial time slowdown look very much like TMs. So, I do not think they are "weird". But, there are devices like "programmed grammars with leftmost-3 derivation mode and unconditional transfer" that allow to represent any recursively enumerable language, but one can also show that there is no Turing machine that transforms such a device into an equivalent TM. That always looke quite weird to me at last ... (OK, I have worked with these devices (together with Frank Stehpan), which always adds to the fun...)

Is this a sufficiently weird thought to your question?

Henning

Hi Palakiti, I am sorry that I am not familiar with exact algorithms. Do heuristics (e.g., the NEH heuristic for PFSP) or metaheuristics (e.g. GA) fit your definition of "polynomial approx. algorithm"?

As far as I know, the solver (cplex) is the same in both suites. The main difference, to me, are the modelling tools around the solver in these suites. GAMS uses an AMPL-like modeling language and cplex is one the the solvers it can use. OPL studio or concert technology (IBM ILOG) use cplex (linear/integer/mixed interger programming) or cp (constraints programming). Both cplex and cp belong to IBM. I think the choice should mostly depend on how familiar you are with one of those suites.