proof

I was thinking about the fact that we can prove a program has bugs. We can test it to assess that it is more or less bug resistant. But is there a way (even theoretically) to prove that a program has no bug ? For simple programs, such as a "Hello World", I guess we should be able to do it. But what about larger programs ? There are nowadays many different formalisms that can be used to prove programs correct (e.g., formalizations in proof assistants, dependently typed programming languages, separation logic, ...). As noted by others, there is no automatic way to prove any given program correct

Multithread algorithms are notably hard to design/debug/prove. Dekker's algorithm is a prime example of how hard it can be to design a correct synchronized algorithm. Tanenbaum's Modern operating systems is filled with examples in its IPC section. Does anyone have a good reference (books, articles) for this? Thanks! It is impossible to prove anything without building upon guarentees, so the first thing you want to do is to get familiar with the memory model of your target platform; Java and x86 both have solid and standardized memory models - I'm not so sure about CLR, but if all else fails,

I failed at reading RWH; and not one to quit, I ordered Haskell: The Craft of Functional Programming . Now I'm curious about these functional proofs on page 146. Specifically I'm trying to prove 8.5.1 sum (reverse xs) = sum xs . I can do some of the induction proof but then I get stuck.. HYP: sum ( reverse xs ) = sum xs BASE: sum ( reverse [] ) = sum [] Left = sum ( [] ) (reverse.1) = 0 (sum.1) Right = 0 (sum.1) INDUCTION: sum ( reverse (x:xs) ) = sum (x:xs) Left = sum ( reverse xs ++ [x] ) (reverse.2) Right = sum (x:xs) = x + sum xs (sum.2) So now I'm just trying ot prove that Left sum (

A graph can have many different Minimum Spanning Trees (MSTs), but can different MSTs have different sets of edge weights? For example, if an MST uses edge weights {2,3,4,5}, must every other MST have edge weights {2,3,4,5}, or can some other MST use a different collection of weights? What gave me the idea is property that a graph has no unique MST only if its edge weights are different. The sets must have the same weight. Here's a simple proof: suppose they don't. Let's let T1 and T2 be MSTs for some graph G with different multisets of edge weights. Sort those edges into ascending order of

I am unsure how to formally prove the Big O Rule of Sums, i.e.: f1(n) + f2(n) is O(max(g1(n)),g2(n)) So far, I have supposed the following in my effort: Let there be two constants c1 and c2 such that c2 > c1 . By Big O definition: f1(n) <= c1g1(n) and f2(n) <= c2g2(n) How should I proceed? Is it reasonable to introduce numerical substitutions for the variables at this step to prove the relationship? Not knowing g or f , that is the only way I can think to approach. Let gmax = max(g1, g2), and gmin = min(g1, g2). gmin is O(gmax). Now, using the definition: gmin(n) <= c*gmax(n) for n > some k