Comments for Mathematics and Computation

Comment on How to make the “impossible” functionals run even faster by Andrej Bauer

Andrej Bauer — Mon, 30 Jan 2012 07:14:48 +0000

You’re not toally off the mark, though. It is relevant to ask whether $\epsilon$ is extensional. Of course, if $\epsilon$ always finds the first witness in the lexicographic (or some other) order, then it is extensional. And, as you observe, given any $\epsilon$ we can always construct an extensioonal one. But still Martin’s $\epsilon$ is extensional (because it is total and written in PCF), while mine is not (try applying it to XOR written in different orders).

Comment on How to make the “impossible” functionals run even faster by Ralph Loader

Ralph Loader — Sun, 29 Jan 2012 07:27:17 +0000

Too much coffee this morning!

Once you have a search functional you can define the uniform modulus of continuity and then compute finite graphs of members of Cantor->Bool & do any sort of minimisation you like.

So I was talking bollocks.

Comment on How to make the “impossible” functionals run even faster by Ralph Loader

Ralph Loader — Sun, 29 Jan 2012 01:14:03 +0000

In the pure functional case, the epsilon one gets is not just any epsilon – it is a minimization function.

To be precise, for the examples I’ve seen, there is a “search order” on Int (not necessarily the usual order, not necessarily well-founded). The order on Int then induces a lexicographical partial-order on (Int->Bool) (which is only a total order if the search-order is well-founded).

The search functionals (Cantor->Bool)->Cantor then I believe return the minimum (not just a minimal!) element for which the predicate holds (or the max. element if the predicate is empty). [That is true if all the examples I've seen written down, one can twist them so they do not, e.g., remapping Cantor->Cantor by flipping odd-numbered bits.]

And one can make the search functional parametrised by the search-order Int->Int->Bool, giving a parametrised minimisation operator (Int->Int->Bool) -> ((Int->Bool) -> Bool) -> Int->Bool.

Question: do all PCF-definable search functionals (Cantor->Bool)->Cantor minimise w.r.t. some [not PCF-definable] partial-order on Cantor? (I guess one should ask for the order to be on the extensional quotient of the total objects.)

It is not obvious to me whether or not one can do minimisation using the kind of “memoisation” techniques that speed up search in the non-functional case.

Question: in your favourite non-fully-abstract model of PCF, do there exist parametrised minimisation operators of the type above? [Conjecture - none will not exist in the stable model, but will exist in the continuous model.]

Comment on Seemingly impossible functional programs by Andrej Bauer

Andrej Bauer — Sat, 28 Jan 2012 07:14:55 +0000

@Martin: my talk about faster functionals using effects is on line.

Comment on Seemingly impossible functional programs by Ralph Loader

Ralph Loader — Sat, 28 Jan 2012 01:28:47 +0000

It turns out that you can give a sensible, negative, answer to my question. find can be parametrized with a monad pretty easily e.g., [conflating Bit and Bool to save typing].

module MFind where
import Control.Monad.State

findM :: Ord i => Monad m => ((i -> m Bool) -> m Bool) -> (i -> m Bool)
findM p n = do { x <- q (findM q) ; return (not x) }  where
   q a = p (\i -> if i == n then return False else
                 if i < n then findM p i else a i)

-- Make a dummy call to (c x), where x increments by 1 each time we're called.
-- Then return (c 5).
fifthWithDummy :: (Integer -> State Integer Bool) -> State Integer Bool
fifthWithDummy c = do
  x <- get
  put (x + 1)
  b <- c x
  if b then c 5 else c 5

-- Now compare
--   findM ($ 5) 0
-- with
--   runState (findM (fifthWithDummy) 0) 0

never returns.