Composite Superpositions

        $wanted = any("Mr","Ms").any(@names);
        if ($name eq $wanted) { print "Reward!"; } 

        $okay = all(\&check1,\&check2);
        die unless $okay->();

        my $large =
                all(    BigNum->new($centillion),
                        BigNum->new($googol),
                        BigNum->new($SkewesNum)
                );
        @huge =  grep {$_ > $large} @nums;

More interestingly, since the individual states of a superposition are scalar values and a superposition is itself a scalar value, a superposition may have states that are themselves superpositions:

        $ideal = any( all("tall", "rich", "handsome"),
                      all("rich", "old"),
                      all("smart","Australian","rich")
                    );

Operations involving such a composite superposition operate recursively and in parallel on each its states individually and then recompose the result. For example:

        while (@features = get_description)
                {
                if (any(@features) eq $ideal)
                                {
                        print "True love";
                }
        }

The "any(@features) eq $ideal" equality is true if the input characteristics collectively match any of the three superimposed conjunctive superpositions. That is, if the characteristics collectively equate to each of "tall" and "rich" and "handsome", or to both "rich" and "old", or to all three of "smart" and "Australian" and "rich".

Eigenstates

In programming terms this is the set of values @ev for a given superposition $s such that "any(@ev) == $s" or "any(@ev) eq $s".

This list is provided by the "eigenstates" operator, which may be called on any superposition:

        print "The factor was: ",
              eigenstates($factor);

        print "Don't use any of:",
              eigenstates($badpasswds);

Boolean evaluation of superpositions

The drawback of applying arithmetic metasemantics to logical operations is that it causes useful information to be lost. Specifically, which states were responsible for the success of the comparison. For example, it is possible to determine if any number in the array @newnums is less than all those in the array @oldnums with:

        if (any(@newnums) < @all(oldnums))
                {
          print "New minimum detected";
        }

But this is almost certainly unsatisfactory, because it does not reveal which element(s) of @newnum caused the condition to be true.

It is, however, possible to define a different meta-semantics for logical operations between superpositions; one that preserves the intuitive logic of comparisons but also gives limited access to the states that cause those comparisons to succeed.

The key is to deviate from the arithmetic view of superpositional comparison (namely, that a compared superposition yields a superposition of compared state combinations). Instead, the various comparison operators are redefined so that they form a superposition of those eigenstates of the left operand that cause the operation to be true. In other words, the old meta-semantics superimposed the result of each parallel comparison, whilst the new meta-semantics superimposes the left operands of each parallel comparison that succeeds.

For example, under the original semantics, the comparisons:

        all(7,8,9) <= any(5,6,7)        #A
        all(5,6,7) <= any(7,8,9)        #B
        any(6,7,8) <= all(7,8,9)        #C

would yield:

        all(0,0,1,0,0,0,0,0,0)          #A (false)
        all(1,1,1,1,1,1,1,1,1)          #B (true)
        any(1,1,1,1,1,1,0,1,1)          #C (true)

Under the new semantics they would yield:

        all(7)                          #A (false)
        all(5,6,7)                      #B (true)
        any(6,7)                        #C (true)

The success of the comparison (the truth of the result) is no longer determined by the values of the resulting states, but by the number of states in the resulting superposition.

The Quantum::Superpositions module treats logical operations and boolean conversions in exactly this way. Under these meta-semantics, it is possible to check a comparison and also determine which eigenstates of the left operand were responsible for its success:

        $newmins = any(@newnums) < all(@oldnums);

        if ($newmins)
                {
                print "New minima found:", eigenstates($newmins);
        }

Thus, these semantics provide a mechanism to conduct parallel searches for minima and maxima :

        sub min { eigenstates( any(@_) <= all(@_) ) }

        sub max { eigenstates( any(@_) >= all(@_) ) }

These definitions are also quite intuitive, almost declarative: the minimum is any value that is less-than-or-equal-to all of the other values; the maximum is any value that is greater-than-or-equal to all of them.

String evaluation of superpositions

If there is only one eigenstate, the stringification of that state is the string representation. This eliminates the need to explicitly apply the "eigenstates" operator when only a single resultant state is possible. For example:

        print "lexicographically first: ",
              any(@words) le all(@words);

In all other cases, superpositions are stringified in the format: "all(eigenstates)" or "any(eigenstates)".

Numerical evaluation of superpositions

Again, if the superposition has a single eigenstate, the conversion is just the standard conversion for that value. For instance, to output the value in an array element with the smallest index in the set of indices @i:

        print "The smallest element is: ",
              $array[any(@i)<=all(@i)];

If the superposition has no eigenstates, there is no numerical value to which it could collapse, so the result is "undef".

If a disjunctive superposition has more than one eigenstate, that superposition could collapse to any of those values. And it is convenient to allow it to do exactly that -- collapse (pseudo-)randomly to one of its eigenstates. Indeed, doing so provides a useful notation for random selection from a list:

        print "And the winner is...",
              $entrant[any(0..$#entrant)];

Superpositions as subroutine arguments

        $n1 = any(1,4,9);
        $r1 = sqrt($n1);

        $n2 = all(1,4,9);
        $r2 = pow($n2,3);

        $r3 = pow($n1,$r1);

then $r1 contains the disjunctive superposition "any(1,2,3)", $r2 contains the conjunctive superposition "all(1,64,729)", and <$r3 > contains the conjunctive superposition "any(1,4,9,16,64,81,729)".

Because the built-in "sqrt" and "pow" functions don't know about superpositions, the module provides a mechanism for informing them that their arguments may be superimposed.

If the call to "use Quantum::Superpositions" is given an argument list, that list specifies which functions should be rewritten to handle superpositions. Unary functions and subroutine can be "quantized" like so:

        sub incr    { $_[0]+1 }
        sub numeric { $_[0]+0 eq $_[0] }

        use Quantum::Superpositions
                UNARY         => ["CORE::int", "main::incr"],
                UNARY_LOGICAL => ["main::numeric"];

For binary functions and subroutines use:

        sub max  { $_[0] < $_[1] ? $_[1] : $_[0] }

        sub same { my $failed; $IG{__WARN__}=sub{$failed=1};
                   return $_[0] eq $_[1] || $_[0]==$_[1] && !$failed;
                 }

        use Quantum::Superpositions
                BINARY         => ['main::max', 'CORE::index'],
                BINARY_LOGICAL => ['main::same'];

Primality testing

        sub is_prime
                {
          my ($n) = @_;
          return $n % all(2..sqrt($n)+1) != 0 
        }

The subroutine takes a single argument ($n) and computes (in parallel) its modulus with respect to every integer between 2 and "sqrt($n)". This produces a conjunctive superposition of moduli, which is then compared with zero. That comparison will only be true if all the moduli are not zero, which is precisely the requirement for an integer to be prime.

Because "is_prime" takes a single scalar argument, it can also be passed a superposition. For example, here is a constant-time filter for detecting whether a number is part of a pair of twin primes:

        sub has_twin
                {
                my ($n) = @_;
                return is_prime($n) && is_prime($n+any(+2,-2);
        }

Set membership and intersection

        $v == any(@elems)

Note that this is equivalent to the definition of an eigenstate. That equivalence can be used to compute set intersections. Given two disjunctive superpositions, "$s1=any(@elems1)" and "$s2=any(@elems2)", representing two sets, the values that constitute the intersection of those sets must be eigenstates of both <$s1> and $s2. Hence:

        @intersection = eigenstates(all($s1, $s2));

This result can be extended to extract the common elements from an arbitrary number of arrays in parallel:

        @common = eigenstates( all(     any(@list1),
                                        any(@list2),
                                        any(@list3),
                                        any(@list4),
                                  )
                     );

Factoring

        sub factors
                {
          my ($n) = @_;
          my $q = $n / any(2..$n-1);
          return eigenstates(floor($q)==$q);
        }

Query processing

        use Quantum::Superpositions BINARY => ["CORE::index"];

        $found = index(any(@db), $target) >= 0;

To determine which of the database strings contain the target:

        sub contains_str
                {
                        return $dbstr if (index($dbstr, $target) >= 0;
        }

        $found = contains_str(any(@db), $target);
        @matches = eigenstates $found;

It is also possible to superimpose the target string, rather than the database, so as to search a single string for any of a set of targets:

        sub contains_targ
                {
                if (index($dbstr, $target) >= 0)
                                {
                        return $target;
                }
        }

        $found = contains_targ($string, any(@targets)); 
        @matches = eigenstates $found;

or in every target simultaneously:

        $found = contains_targ($string, all(@targets));
        @matches = eigenstates $found;