index 40df3b8..d44f824 100644 (file)
@@ -1,3 +1,15 @@
+<!--
+I would like to propose one pedegogical suggestion (due to Ken), which
+a "Let" construction to GSV's logic, i.e., "Let of var * term *
+clause", whose interpretation adds a peg, assigns var to it, sets the
+value to the value computed by term, and evaluates the clause with the
+new peg in place.  This can be added easily, especially since you have
+supplied a procedure that handles the main essence of the
+construction.  Once the Let is in place, adding the existential is
+purely dealing with nondeterminism.
+-->
+
*      How shall we handle \[[&exist;x]]? As we said, GS&V really tell us how to interpret \[[&exist;xPx]], but for our purposes, what they say about this can be broken naturally into two pieces, such that we represent the update of our starting set `u` with \[[&exist;xPx]] as:

<pre><code>u >>= \[[&exist;x]] >>= \[[Px]]
*      How shall we handle \[[&exist;x]]? As we said, GS&V really tell us how to interpret \[[&exist;xPx]], but for our purposes, what they say about this can be broken naturally into two pieces, such that we represent the update of our starting set `u` with \[[&exist;xPx]] as:

<pre><code>u >>= \[[&exist;x]] >>= \[[Px]]
@@ -17,8 +29,8 @@

<pre><code>u updated with \[[&exist;x]] &equiv;
let extend one_dpm (d : entity) =

<pre><code>u updated with \[[&exist;x]] &equiv;
let extend one_dpm (d : entity) =
-                       bind_dpm one_dpm (new_peg_and_assign 'x' d)
-               in bind_set u (fun one_dpm -> List.map (fun d -> extend one_dpm d) domain)
+                       dpm_bind one_dpm (new_peg_and_assign 'x' d)
+               in set_bind u (fun one_dpm -> List.map (fun d -> extend one_dpm d) domain)
</code></pre>

where `new_peg_and_assign` is the operation we defined in [hint 3](/hints/assignment_7_hint_3):
</code></pre>

where `new_peg_and_assign` is the operation we defined in [hint 3](/hints/assignment_7_hint_3):

or, being explicit about which "bind" operation we're representing here with `>>=`, that is:

or, being explicit about which "bind" operation we're representing here with `>>=`, that is:

-       <pre><code>bind_set (bind_set u \[[&exist;x]]) \[[Px]]
+       <pre><code>set_bind (set_bind u \[[&exist;x]]) \[[Px]]
</code></pre>

</code></pre>

-*      Let's compare this to what \[[&exist;xPx]] would look like on a non-dynamic semantics, for example, where we use a simple reader monad to implement variable binding. Reminding ourselves, we'd be working in a framework like this. (Here we implement environments or assignments as functions from variables to entities, instead of as lists of pairs of variables and entities. An assignment `r` here is what `fun c -> List.assoc c r` would have been in [week6](
+*      Let's compare this to what \[[&exist;xPx]] would look like on a non-dynamic semantics, for example, where we use a simple Reader monad to implement variable binding. Reminding ourselves, we'd be working in a framework like this. (Here we implement environments or assignments as functions from variables to entities, instead of as lists of pairs of variables and entities. An assignment `r` here is what `fun c -> List.assoc c r` would have been in [week7](

type assignment = char -> entity;;
type 'a reader = assignment -> 'a;;

type assignment = char -> entity;;
type 'a reader = assignment -> 'a;;

-               let unit_reader (value : 'a) : 'a reader = fun r -> value;;
+               let reader_unit (value : 'a) : 'a reader = fun r -> value;;

fun r ->
let a = u r
in let u' = f a
fun r ->
let a = u r
in let u' = f a
@@ -77,7 +89,7 @@
fun r ->
fun r ->

The meaning of \[[Qx]] would then be:

The meaning of \[[Qx]] would then be:

@@ -86,7 +98,7 @@
\[[Qx]] &equiv; \[[Q]] \[[x]] &equiv;
fun r ->
let obj = getx r
\[[Qx]] &equiv; \[[Q]] \[[x]] &equiv;
fun r ->
let obj = getx r
</code></pre>

Recall also how we defined \[[lambda x]], or as [we called it before](/reader_monad_for_variable_binding), \\[[who(x)]]:
</code></pre>

Recall also how we defined \[[lambda x]], or as [we called it before](/reader_monad_for_variable_binding), \\[[who(x)]]:

fun (lifted_predicate : lifted_unary) ->
fun r -> exists (fun (obj : entity) ->

fun (lifted_predicate : lifted_unary) ->
fun r -> exists (fun (obj : entity) ->

That would be the meaning of \[[&exist;]], which we'd use like this:

That would be the meaning of \[[&exist;]], which we'd use like this:

in clause r'
in let lifted_exists =
fun lifted_predicate ->
in clause r'
in let lifted_exists =
fun lifted_predicate ->
-                               fun r -> exists (fun obj -> lifted_predicate (unit_reader obj) r)
+                               fun r -> exists (fun obj -> lifted_predicate (reader_unit obj) r)

which we can simplify to:

which we can simplify to:
in clause r'
in let lifted_exists =
fun lifted_predicate ->
in clause r'
in let lifted_exists =
fun lifted_predicate ->
-                               fun r -> exists (fun obj -> lifted_predicate (unit_reader obj) r)
+                               fun r -> exists (fun obj -> lifted_predicate (reader_unit obj) r)

in let r' = fun var -> if var = 'x' then new_value else r var
in let r' = fun var -> if var = 'x' then new_value else r var
-                       in fun r -> exists (fun obj -> shifted' (unit_reader obj) r)
+                       in fun r -> exists (fun obj -> shifted' (reader_unit obj) r)