Theoretical Computer Science - Science topic

Fabricio Kolberg Idle question: do you know what and how to change.

Christopher A. Wisnik

1. **Define the Scope and Objectives**:

- Clearly define the objectives of your literature review. For example, you may want to focus on understanding the current state of research in using augmented learning and learning-augmented algorithms to enhance surgical performance and guidance.

- Determine the key aspects you want to cover, such as the specific applications of these techniques in the context of performance-guided surgery, the methodologies employed, the reported outcomes and benefits, as well as any challenges or limitations.

2. **Search and Gather Relevant Literature**:

- Identify relevant databases and search engines, such as PubMed, IEEE Xplore, ACM Digital Library, and Google Scholar, to search for peer-reviewed journal articles, conference proceedings, and other relevant publications.

- Use a combination of keywords, such as "augmented learning", "learning-augmented algorithms", "performance-guided surgery", "surgical guidance", "surgical decision support", etc., to conduct your searches.

- Ensure you include both recent and seminal publications in your search to capture the latest advancements as well as the foundations of the field.

3. **Review and Critically Analyze the Literature**:

- Carefully read and analyze the selected publications, focusing on the key aspects identified in the scope and objectives.

- Identify the main themes, methodologies, findings, and contributions reported in the literature.

- Assess the quality, validity, and reliability of the studies, and identify any gaps, inconsistencies, or areas that require further investigation.

4. **Synthesize the Findings**:

- Organize the literature review in a logical and coherent manner, potentially using a thematic or chronological approach.

- Synthesize the key insights, trends, and conclusions drawn from the literature, highlighting the potential applications, benefits, and limitations of using augmented learning and learning-augmented algorithms in performance-guided surgery.

5. **Identify Future Research Directions**:

- Based on your analysis of the literature, identify areas that require further research, such as specific surgical procedures or applications that could benefit from these techniques, methodological improvements, or the integration of these approaches with other emerging technologies.

- Provide recommendations for future research that could contribute to the advancement of this field and address the identified gaps.

6. **Structure and Write the Literature Review**:

- Organize your literature review into a well-structured document, including an introduction, background, review of the literature, synthesis of findings, and a conclusion.

- Use appropriate headings, subheadings, and transitions to ensure the flow and readability of your review.

- Properly cite the references using a consistent citation style, such as APA or IEEE.

Good luck; partial credit AI

Well, "deep learning" search generates

About 357,000,000 results (0.27 seconds).

On the other side,

"big data" search generates

About 373,000,000 results (0.26 seconds)

which is slightly bigger figure than the former one.

So, people are interested in many current hot topics.

I found an error in my proof.

Tong Guo Theoretical deep learning is primarily focused on understanding the fundamental principles, limitations, and mathematical underpinnings of deep neural networks. It aims to address several key problems:

In summary, theoretical deep learning aims to provide a deeper understanding of the principles underlying deep neural networks, enabling researchers and practitioners to build more effective, interpretable, and robust AI systems. It serves as the theoretical foundation for the practical advances and applications of deep learning in various domains.

For me some basic knowledge of formal systems is essential for undergraduate CS students, as this is a necessary part of the scientific education.

If not, you might still learn a lot about software construction, but you wouldn't know nor understand its bedrock.

Hi Joseph C Lee

I agree with you that it depends on the editor and reviewer. However, could it be better to display this factor (in average or estimated value) on the journal's website. So that authors can get a rough estimate for article.

Dear Majid Zohrehbandian,

I suggest you see the links on the topic.

https://www.geeksforgeeks.org/vertex-cover-problem-set-1-introduction-approximate-algorithm-2/

Best regards

The answer is P=NP

If P is the permutation matrix corresponding to a permutation π of the vertex set of a graph G, and A is the adjacency matrix of the graph, then π is an automorphism of G iff PAPᵗ = A (where Pᵗ = P⁻¹ is the transpose and hence inverse of the permutation matrix P).

That is, π ∈ Aut(G) iff PA = AP: the permutation matrix commutes with the adjacency matrix.

This is probably what you have in mind.

But this has some other implications as well.

If x is any eigenvector A corresponding to an eigenvalue λ, then:

APx = PAx ⇒

A(Px) = λ(Px) [since Ax = λx]

which means that Px (which, note, is non-zero) is also an eigenvector of A for the same eigenvalue. Thus, any permutation, when it acts on vectors via the permutation matrix, must permute eigenvectors in each respective eigenspace amongst themselves.

The converse is true too. Suppose the permutation matrix P maps each eigenvector x to another eigenvector corresponding to the same eigenvalue. Then P represents an automorphism of G. To see this, write A as

A = QΛQᵗ = QΛQᵗ

where Λ is the diagonalisation of A [assuming G is an undirected graph and hence A is real and symmetric], and Q is the orthogonal diagonalising matrix whose column are (independent) eigenvectors of A corresponding to the respective eigenvalues along the diagonal of Λ. Then

PAPᵗ = (PQ)Λ(PQ)ᵗ.

But PQ is also a matrix whose columns are eigenvectors of A corresponding to the respective eigenvalues along the diagonal of Λ. Since P and Q are orthogonal, so is PQ [so (PQ)ᵗ = (PQ)⁻¹]. Thus, the RHS of the above equation is A, and we have

PAPᵗ = A

which shows that P represents an automorphism of G.

The relevant aspect of "playing better chess" is that chess is a model of a conversation, a give and take. It is unsetlling that people have difficulty accepting it, it is not a good performance on a conversation. A human who finds it "normal" that computers can pass as a colleague, frequently, and not wonder about the intelligence of that colleague ... or smile? The Turing test has also become an intelligence test, and humans are using bots to beat humans, easily. This is another reason, in ethics, to depreciate this tool and look deeper.

That Polyani theorized some matters in error does not invalidate all of his effort.

In addition, we now know that free market economies, if they ever exist, are not wholly self-adjusting with respect to externalities, since free market economies are not closed systems in reality. That does not imply a single-authority system, so perhaps Polyani should not be labelled as binary thinking in this case.

It strikes me that Polyani must certainly have meant truth in a fashion not corresponding to the Ed Gerck notion of truth being accessible to an AI.

I don't believe that successful chess-playing programs qualify as AI, although they do provide demonstration that intelligence is not required to play chess successfully. I don't know about the more-recent demonstration of GO mastery, but I suspect that it does not require an AI either. I conceded the achievement of successful heuristic approaches and the computing power available to apply them beyond the capacities of human opponents.

I love playing computer adventure games of the highly-animated, cinematic form. My favorites are termed third-person shooters because one can observe and operate a character without being trapped behind the character's eyes. I am currently working through "Shadow of the Tomb Raider," a great demonstration of the genre. That the operation of non-player characters and other entities that appear to exhibit agency is sometimes claimed to be evidence of AI is not much evidence for that claim, whatever its appeal in popular culture.

In the case of Euclidean graphs you can use the Euclidean distance between nodes. You can also use random weights. Depending on the application you can use appropriate weights...

Use Structural Equation Modeling (SEM).

Hi Jesujoba,

AFAIK, this should be accomplished based on previous knowledge (a.k.a background) such as ranking the content using certain aspect; otherwise, there is no meaning or logic behind such process.

HTH.

Samer Sarsam, PhD.

Dear Fatemeh,

Maybe I am getting too late into this discussion. What I would do is to solve the following problem P:

minimize (1,1,...,1)' e

(Y-Zx) > -e

-(Y-Zx) > -e

a <= x_i <= b for each vector variable component

and programming myself a simple branch and bound algorithm:

1. Solve P

2. check whether some variable x_i has a value that is different from a or b.

3. (branching) Say you find that x_t is a < x_t < b. Then solve the following two problems:

P1

minimize (1,1,...,1)' e

(Y-Zx) > -e

-(Y-Zx) > -e

x_t = a

P2

minimize (1,1,...,1)' e

(Y-Zx) > -e

-(Y-Zx) > -e

x_t = b

4. Perform step 3 on the solutions of all problems you have.

5. (bounding) . Stop branching if:

- the solution of a problem is infeasible

- all variables in the solution have values either a or b ("integer" solution)

- the solution of the problem still contains variables with values different to a or b, but the objective is worse than a previously found "integer" solution.

I know it is brut force, but it will keep the structure of your problem and will guarantee what you want. And, it is very easy to program.

Hope it helps.

Vlad

Thanks. Yes, I use the Church/Turing hypothesis/definition of computable (with any Turing-complete language, though programs for UTM are most traditional). OK, I see why I need the Axiom of Choice. I don't think I need the powerset axiom - that's just a convenient shortcut. And yes, it's not a constructive proof.

Unconstrained Quadratic Integer Programming is strongly NP-hard even when the objective function is convex. The proof is by reduction from the Closest Vector Problem.

Apparently, Norbert Blum is convinced of a negative solution to the question. See "A Solution of the P versus NP Problem" up on arXiv.

Maximize the entropy, the information gain

for every question.

Regards,

Joachim

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

anyone knows?

It is good paper about the complexity of frequent itemset mining.

I have been unable to find any use of the term earlier than Simons 1987. It's worth noting that he used a hyphen: mereo-topology. But certainly it was being used unhyphenated by the mid-90s.

Selection of a journal invariably depends upon the quality, length etc. h of the paper. One can go to the journal site to check the topics covered by that journal. But this is now a ocean. So, the titles can be analysed before searching.

If we need a SCOPUS indexed journal may or may not have impact factor then there are several Inderscience journals.

If we need impact factor journals then i agree with Prof.Peters that journals like Information sciences, Approximate reasoning, Fuzzy sets and Systems, IJUFKS are quite good.

Also, there are several special editions of different journals on the specific topic of rough sets, granular computing or knowledge discovery etc. to which papers can be communicated.

FO = first order, LFP = least fix point; for the logic LO + LFP and how it defines reachability, see the book Descriptive Complexity by Immerman:

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.

tanks alot

You can find the connected components, then count those.  As others have pointed out, you want to build on DFS or BFS.  You can find the algorithm for this in the following paper (while if you understand DFS or BFS, it's not complicated):

Hopcroft, J.; Tarjan, R. (1973). "Efficient algorithms for graph manipulation". Communications of the ACM 16 (6): 372–378

Pierre, I agree that nonmon reasoning can be confusing, but not only for naive users.  Experts never take any kind of reasoning at face value.  They always ask follow-on questions:  What were the assumptions?  Where did the data come from?  How did you derive that answer from those assumptions and that data?

One advantage of FOL theorem provers is the ability to generate an explanation:  Show every step of the proof -- every axiom or data point and every inference.  With controlled NLs, each step can be translated to the same CNL that the user knows.

For nonomon reasoning, belief revision has the same advantage as FOL.  Each revision step can be translated to the CNL.  The final proof is a purely classical FOL proof that can be explained by the above method.

For complex proofs, the amount of detail can be overwhelming, but the expert needs that kind of detail.  Intelligent users who don't have much knowledge of FOL can learn FOL by studying the explanations.  Anyone who is both naive and lazy will always be confused.

Hi John,

Subject to your case scenario and system dynamics the embedded Petri Net System may  be relevant.

Best regards 

I got the answer for it sir... Thank you so much... In the paper I referred they mentioned single valued attribute as nuclear attribute,,, 

I'm not sure whether you're asking about the time cost, or cost in gates, transistors, power?  And do you mean at the bit-level, or instruction-level?  And do you mean "as implemented in conventional processors", or do you want theoretical limits, given particular trade-offs?

For instance, 1-bit addition is simple enough (xor), but extending to multiple bits means propagating carry.  This introduces trade-offs: you could simply pipeline your add so a 32b operation takes ~32 pipe stages.  Or you can cram the propagation within a single cycle (meaning your 1-bit full-adder has to operate in < 1/32 cycle).  Or you can dedicate more transistors to propagate the carry faster.

So in this sense, you can't assign a very simple cost (in time, power, transistors) to even addition, since different tradeoffs lead to different costs.  And even simple addition has a cost which grows at least linearly with bit-width (but maybe faster).  The same sort of analysis applies to functions like mul and div, though obviously they are usually have much steeper cost.  (And bitwise operations are always cheaper than add.)

I am reading your article to understand your above response. I will reply you later.

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.

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.

Ah yes, I forgot earlier. Dimitri Bertsekas has made available his network flows book for free. It has god stuff on single-commodity network flows - dual methods in particular. Here is a link to download the book from: 

Again - good luck!

Wikipedia has an acceptable overview of static program analysis at

which may give you the English magic words to clarify your question.  There is also an Urdu Wikipedia at

Different statistical distribution base :-)

although it should ideally be "research driven", there are alternatives...for example, if you have large data sets.that can be "mined" for the content they have hidden within them (e.g., by using cluster analysis or other data mining techniques)...obviously, it's not that simple, but they are both places to begin your search...good luck... 

Dear Dahi Abd Zakaria Abd El Moiz,

please have a look at the discussion "How to evaluate the quality of metaheuristic algorithms without any benchmarks?" on the link https://www.researchgate.net/post/How_to_evaluate_the_quality_of_metaheuristic_algorithms_without_any_benchmarks

and in particular on the link  http://www.fedulov.ge  as an application.

What's wrong with Atkin's Simplicial Complex?

On the other hand you need all paths to be disjoint - they may share nodes but not links. You may need to use the graph search to enumerate paths, in order to see if there is even a feasible solution. Is there a particular application? There are several such approaches in telecommunication, one being found through this link:

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.

Transistors can be made out of graphene for fast amplification, but for

computing machinery switches with nonlinear characteristics are needed.

Therefore ways are being investigated to induce band gaps.

Regards,

Joachim

I'd say it depends on what you are designing. If you look at it from a process perspective, the whole software development process is like a funnel, from vague requirements over a (hopefully) not so vague design to a concrete implementation.

While this is usually fine for systems where there is no "right" or "wrong" solution (the look and feel of a web shop, for example), other systems are much more restrictive. You don't want to be vague about alarm and shutdown criteria in the control software of a nuclear power plant or in aircraft control.

So I think using formal methods will be worthwile in only some scenarios, while in others semi-formal notation (such as UML) will suffice.

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

I am grateful to colleagues for a set of answers diversely on this matter, especially, for the answer that the size of "heights" of a wave is proportional to a square of its length.

It depends how you define "real industrial". Since verification is still very costly, the applications are rather limited to domains as military or air/space transportation.

E.g.. the IMHO most famous and largest project is the seL4 kernel. The was writen in Haskell and proved with Isabell/HOL (and refinded in C). It was used by OK Labs, what was later bought by General Dynamics, world's fifth-largest defence compancy (according WIkipedia).

There are smaller projects in industrial companies. E.g., Daimler Benz once used the OPAL language to develop a proven compiler for ECUs, but I am not aware that the compiler is actual used in non-prototype development (most ECU development is outsourced anyway).

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

From your explanation u-statistics should work, but if you don't have judgments for all n(n-1)/2 pairs you may have a bias.

I Think you can find hints in René Thom (catastroph theory and forms growth), Ilya Prigogine (auto-organisation, dissipative structures) and Classical theory of entropy.

Colin,

the emphasis is on fuzzy and associative computation.

@Afaq Ahmad: thank you for the link... My question was more historical than technical... I was interested in knowing who first came up with a description of the algorithm in a textbook or a book... I found somewhere that somebody referred to Bellman, but Bellman does not give an explicit description of the algorithm after a first quick glance (but I didn't try yet to link his differential equation notation to the one's we conventionally see in textbooks such as the one you linked)...

Has the algorithm become somewhat folklore? Most of us can remember that Quick Sort was first published by Hoare. Some of us were told that Merge Sort was a Von Neumann trick... We sometimes link binary systems to p-adic systems, at least in the Western canon...

To be honest, I wouldn't even be surprised if the algorithm could be traced back to Ancient Japan, China or India... due to its "abacus" nature...

@Peter: Did you check the references that I gave? They contain the actual beta-reduction steps for \Theta, and show how Y is different. I don't see a problem there.

Thank you very much for your answer. So, it is interesting to add the sampling rate in the entropy to calculate the modification in the system.

A further question is about the mathematical equation so i can combine the experimental results with the entropy in general. When i access to read about entropy, based always on probability we are computing a graph but i couldn t find a metric that helps to combine the results with the entropy to assess the attractors of the chaotic phenomene that i am trying to measure. Please do you have any idea about that?

Ulrich, I had something like this in mind when I was formulating my question. It's the proof that GO is PSPACE hard. QBF formulas are coded into a Geography game which is then converted to a GO position. Maybe Turing computation, or some weaker form of computation can be similary coded.

"Can you give a Wang tile program for calculating the function f ?"

I think that a "real world example" would require *A LOT* of work :-). However another approach, slightly different from the one suggested by Philon Nguyen, is 1) build an Universal Turing Machine with Wang Tiles, 2) build the equivalent TM program, 3) feed the Wang Tiles UTM with it

I have worked on feature weighting (FW) as a continuous search space problem. Feature weighting involves assigning weights to the features of the data sets before performing machine learning tasks (like classification). As it is reported by many authors, FW improves the performance of classification algorithms. When the weights are limited to 0/1, the task will be Feature selection (FS) instead of feature weighting. (Feature selection is a discrete search space problem). For more information you can study this article:

Basic Concepts: Graphs and digraphs, incidence and adjacency matrices, isomorphism, the automorphism group; Trees: Equivalent definitions of trees and forests, Cayley's formula, the Matrix-Tree theorem, minimum spanning trees; Connectivity: Cut vertices, cut edges, bonds, the cycle space and the bond space, blocks, Menger's theorem; Paths and Cycles: Euler tours, Hamilton paths and cycles, theorems of Dirac, Ore, Bondy and Chvatal, girth, circumference, the Chinese Postman Problem, the Traveling Salesman problem, diameter and maximum degree, shortest paths; Matchings: Berge's Theorem, perfect matchings, Hall's theorem, Tutte's theorem, Konig's theorem, Petersen's theorem, algorithms for matching and weighted matching (in both bipartitie and general graphs), factors of graphs (decompositions of the complete graph), Tutte's f-factor theorem; Extremal problems: Independent sets and covering numbers, Turan's theorem, Ramsey theorems; Colorings: Brooks theorem, the greedy algorithm, the Welsh-Powell bound, critical graphs, chromatic polynomials, girth and chromatic number, Vizing's theorem; Graphs on surfaces: Planar graphs, duality, Euler's formula, Kuratowski's theorem, toroidal graphs, 2-cell embeddings, graphs on other surfaces; Directed graphs: Tournaments, directed paths and cycles, connectivity and strongly connected digraphs, branchings; Networks and flows: Flow cuts, max flow min cut theorem, perfect square; Selected topics: Dominating sets, the reconstruction problem, intersection graphs, perfect graphs, random graphs.

@Maximiliano, I am sure that this problem is pretty hard: all us coding theorists are not going to be replaced by computer programs overnight! Then proving it is another matter...

Thanks for the link Pierre-Yves. I'll have a look at it and put my comments on the thread.

There are 2 definitions of an Oracle machine I am aware of:

The decision version returns true or false to any question. In my previous comment, I was referring to the decision version. If my memory is good, Turing's 1937 thesis referred to that version.

But even an oracle that can answer the question with the full answer would not be able to answer the question on a non-recursively enumerable real (at least assuming that we are limited by such a class), as it cannot return the complete enumeration of digits (assuming finite time) and it cannot return a compact representation (assuming the Church-Turing thesis). Now, Oracle machines are effectively not bound by computability as they can solve the Halting problem as a decision problem, but the representation would not be finite and therefore the answer cannot be provided, other than by assuming, as a thought experiment, that the Oracle can return an answer we cannot "understand".

Now my question was more about if there are simpler classes of problems that cannot be solved by an Oracle, without having to refer to the discrete/real duality.

A weaker version of the problem would be: what is the class of problems that cannot be solved by a Gentzen system.

These are the problematics of the Church-Turing thesis I wanted to ask about.

The distinction may be confusing as the literature itself on the subject refers to different sets of hypotheses.

But posited shortly, any numbering (in the sense of Gödel) that can be ordered (Gentzen) has a practical implementation as an Oracle machine (computable). Now, what are the problems that cannot be solved in such a way, that cannot be ordered sufficiently... Perhaps this weaker statement of the question is clearer.

Not an easy question to ask...

A folklore example is swapping the value of two (integer) references without using a local variables. Take a programming language with call-by-reference and the following function:

swap(&int a, &int b) {

a := a - b; // value of a is a0 - b0

b := a + b; // value of b is a0 - b0 + b0 = a0

a := b - a; // value of a is a0 - a0 + b0

}

Assume the value of a is a pointer to the value a0 and b to b0. Then after a call to swap(a, b) the value pointed to by a and b are swapped ... except if a and b both point to the same memory address, in which case they point to the value 0.

This is more an example of the problems related to reasonning about programs in the presence of pointers but I think that it qualifies as an example of tricky algorithm.

In general, the more carefully a computational task is defined, and the better the task is understood, the more difficult it becomes to argue that it is not a Turing process. This idea is reflected in Von Neumann's (perhaps apocryphal) remark that "you tell me what it is that computers cannot do, and I will program a computer to do it." My opinion is that the burden of proof should fall on those who argue that a process is NOT a Turing process, to demonstrate why it is not. No one ever said that a Turing machine is the fastest way to execute an algorithm - parallel/distributed processes are obviously vastly faster - but a I've never seen a convincing demonstration that a process (such as predicting stopping time) cannot be represented in the form of an algorithm that a Turing machine can read - and that such a process nevertheless exists.

JFlap - is a quick draw/simulate tool, LaTeX + Tikz - the best combination to draw beautiful pictures (and they have Automata package too)

I agree with Patrick. 40% correction if errors are random cannot be achieved for that length. If errors are not random, that is a different story, but in that case we need a model for the channel (like a bursty channel), as other people are pointing out.