What is the efficiency of this algorithm which decides the answer to the Boolean satisfiability problem? I have just written a short javascript program which, given any boolean expression with $N$ variables, completes in N "ticks" of the clock and which makes the decision.  I will explain this algorithm, make some remarks, and post the code so that its clear exactly what I am doing.


*

*make 2 objects that holds an array, initialize one to [true], the other to [false]

*each timestep, self-replicate the most recently made objects twice each, and append true, false to the array

*after N timesteps, every possible set of values for the boolean variables will be in memory

*if the object detects it has the correct length to do the check, then check it and update a global variable

*after you check every case in a single timestep (click of the js engine) because I used self-replicating objects, terminate the program


I have been working very hard on some really exciting new programming approaches using "computer virus techniques" to write normal non-malicious programs.  From a practical point of view, this algorithm takes N clicks, which means it takes N steps to check all $2^N$ cases, where each step is what I call a "click" of the javascript engine.  It's like a timestep in the theory of Turing Machines.
For my practical concerns, I can now check in n-clicks of the js engine the answer to any decision problem of this type.


*

*What is the efficiency of this algorithm if not equal to the number of ticks of the javascript engine?  I claim the efficiency of $O(N)$, is this wrong?


To run the code you can copy/paste it into a text file and save it with a .html extension and open that file in your browser.  Just type any javascript boolean expression with an arbitrary number of variables. For example you can type b1 && b2 || b3 into the input field and click evaluate and check the console log, name all your variables b + number.
<!DOCTYPE html>
<html>
<head>
    <title>Boolean satisfiability problem</title>
    <style type="text/css">
        input { width: 100%; padding: 4px; font-size: 16px; }
    </style>
</head>
<body>
    <p>Type a Boolean expression in javascript using variables b1, b2, b3, ... </p>
    <input id="expression" type="text" name="expression" />
    <button id="evaluate">Evaluate</button>

    <script type="text/javascript">
        document.getElementById('evaluate').onclick = function() {
            var isSatisfiable = false,
                numChecked = 0,
                val = document.getElementById('expression').value,
                match = val.match(/b[0-9]*/g);

            if ( !match.length ) {
                console.log('no match!');
                return;
            }

            var totalCases = Math.pow(2, match.length);

            function BioObject(value) {
                if ( value.length === match.length ) {
                    var params = {};
                    match.forEach(function(item, idx) {
                        params[item] = value[idx];
                    });

                    with (params) {
                        if ( eval(val) ) {
                            isSatisfiable = true
                        }

                        if ( ++numChecked >= totalCases ) {
                            if ( isSatisfiable ) {
                                console.log('is satisfiabile');
                            } else {
                                console.log('cannot be satisfied');
                            }
                        }
                    }
                } else {
                    setTimeout(function() {
                            var t = value.slice(),
                                f = value.slice();

                            t.push(true)
                            f.push(false)

                            new BioObject(t)
                            new BioObject(f)
                    }, 1)
                }
            }

            new BioObject([true]);
            new BioObject([false]);
        }
    </script>
</body>
</html>
```

 A: 
What is the efficiency of this algorithm if not equal to the number of ticks of the javascript engine? I claim the efficiency of 
  $O(N)$, is this wrong?

To claim a time efficiency, you (formally) have to specify a computational model. Most people don't because of some vague sense (formalized partially in some things like the Church Turing thesis), all "reasonable" computational models are equivalent (up to polynomial factors) in time complexity.
Your model appears to be inequivalent. The statement:

each timestep, self-replicate the most recently made objects twice each, and append true, false to the array

Implies that in $N$ time steps you could create $2^N$ objects. This would mean that the space complexity of your algorithm is not upper bounded by the time complexity, which is generally the case (for example, in the RAM or Turing Machine model).
It seems like the quantity $O(N)$ in your model would be a better match for the depth of some circuit, but I'm unaware if even this perspective is interesting.
I suspect simulating your computational model with a Turing machine would require $\Omega(2^N)$ time. If you could show this isn't the case it would be interesting, but otherwise you've found a way to rewrite the brute force solution to SAT in a computational model which violates the Church Turing thesis. This can be fine in certain cases (quantum computation is thought to violate the Church turing thesis), but that's because we think that (single) other case could potentially be executed in "polynomial time" in a real life system. Without a demonstration that you can solve hard instances of SAT quickly (which you should be able to do if you have a linear time algorithm), most would find your algorithm unconvincing.
If you wish to "experimentally test" your algorithm, you could generate hard instances of SAT, and see if it preforms well on them.
It's fairly well known that SAT can be fairly easy "on average" (I believe SAT solvers can do better than $O(1.2^n)$ for fairly natural distributions), but is hard in the worst case, especially on problem instances generated from reducing "hard problems" to SAT.
This paper discusses generating hard SAT instances via reducing factoring to SAT.
If you implement this (or find a program implementing it), and demonstrate you can factor large numbers efficiently, it would go a LONG ways towards justifying that you have a breakthrough.
