From 9ef8c8a5c822f05b63ff23c92980a103efc85967 Mon Sep 17 00:00:00 2001 From: Jim Date: Mon, 13 Apr 2015 20:48:39 -0400 Subject: [PATCH] update Juli8 to v1.6 and post gsv.ml --- code/Juli8-v1.6.tgz | Bin 0 -> 41918 bytes code/gsv.ml | 1001 +++++++++++++++++++++++++++++++++++++++++++++++++++ index.mdwn | 2 +- juli8.mdwn | 2 +- 4 files changed, 1003 insertions(+), 2 deletions(-) create mode 100644 code/Juli8-v1.6.tgz create mode 100644 code/gsv.ml diff --git a/code/Juli8-v1.6.tgz b/code/Juli8-v1.6.tgz new file mode 100644 index 0000000000000000000000000000000000000000..4df3d0915b045a8644c5bd9b56afc7b6eec0467f GIT binary patch literal 41918 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 F0|4rOTzdcj literal 0 HcmV?d00001 diff --git a/code/gsv.ml b/code/gsv.ml new file mode 100644 index 00000000..abd305f6 --- /dev/null +++ b/code/gsv.ml @@ -0,0 +1,1001 @@ +(* GSV monadically 13 April 2015 *) + +type identifier = char +let any_truths (xs : 'a list) : bool = List.exists ident xs +let all_truths (xs : 'a list) : bool = List.for_all ident xs + +module type SEMANTICS = sig + type noun (* this is whatever monadic type the semantics assigns to noun-sized contents *) + type sent (* this is whatever monadic type the semantics assigns to sentence-sized contents *) + val run : sent -> bool + val dynamic : bool + val extensional : bool + + val getx : noun val gety : noun val getz : noun + (* OCaml will parse ~~~ as a prefix operator, but unfortunately won't let you say + `~~~ predicate subject`; you have to say `~~~ (predicate subject)`. *) + val ( ~~~ ) : sent -> sent + (* OCaml will parse these three as infix operators (yay), but makes them all + left-associative (ehh for >>>) and have the same precedence (boo). *) + val ( &&& ) : sent -> sent -> sent + val ( ||| ) : sent -> sent -> sent + val ( >>> ) : sent -> sent -> sent + (* OCaml parses this with same associativity and precedence as the preceding (boo). *) + val (===) : noun -> noun -> sent + val ann : noun val bill : noun val carol : noun val dave : noun val ella : noun val frank : noun + val male : noun -> sent val female : noun -> sent + val left : noun -> sent + val single : noun -> sent + (* Transitive verbs apply to their direct objs first, subjects second. *) + val marriedto : noun -> noun -> sent + val saw : noun -> noun -> sent + val kisses : noun -> noun -> sent + val loves : noun -> noun -> sent (* here construed extensionally *) + (* Quantifiers may be unimplemented. *) + val some : identifier -> sent -> sent + val every : identifier -> sent -> sent + (* Intensional verbs and operators may be unimplemented. *) + val thinks : sent -> noun -> sent + val maybe : sent -> sent +end + +type world = Actual | Other | Another +let modal_domain = [Actual; Other; Another] + +type entity = Ann | Bill | Carol | Dave | Ella | Frank +let domain = [Ann; Bill; Carol; Dave; Ella; Frank] +let string_of_entity = function + | Ann -> "Ann" + | Bill -> "Bill" + | Carol -> "Carol" + | Dave -> "Dave" + | Ella -> "Ella" + | Frank -> "Frank" +let print_entity ent = print_string (string_of_entity ent) + +module Facts(X : Monad.MONAD) = struct +(* Here are the atomic facts: Ann and Bill are married, also Carol and Dave. + Genders and marital statuses are epistemically necessary. + In the actual world (w1), everyone left; people look leftwards (Carol sees Bill and Ann, etc.); Carol and Dave kiss; husbands love only their wives and Frank loves all the women. + In w2, all but Carol left; no one sees anything; all spouses kiss; all men love only Carol and Ella loves the wives. + In w3, only Ann and Bill left; no one sees anything; nobody kisses; Frank loves everyone else. +*) + + let is_male = function Bill | Dave | Frank -> true | _ -> false + let are_married = function (Ann, Bill) | (Bill, Ann) | (Carol, Dave) | (Dave, Carol) -> true | _ -> false + let is_a_wife = function Ann | Carol -> true | _ -> false + + let male xx = X.(map is_male xx) + let female xx = X.(map (not % is_male) xx) + +(* Ella and Frank are single *) + let single xx = X.(map (fun x -> x > Dave) xx) + +(* Actually (in w1), everybody left. In w2, everybody but Carol left. In w3, only Ann and Bill left. *) + let left1 xx = X.(map (fun _ -> true) xx) + let left2 xx = X.(map (fun x -> x <> Carol) xx) + let left3 xx = X.(map (fun x -> x = Ann || x = Bill) xx) + +(* In the sentences, order of application is: TransitiveVerb + Object + Subject. + But we convert to logical order for our operations. *) + +(* Actually, each person saw the people alphabetically before them. In w2 and w3, no one saw anyone. *) + let saw1 yy xx = X.(map2 (fun x y -> x < y) xx yy) + let saw2 yy xx = X.(map2 (fun _ _ -> false) xx yy) + let saw3 = saw2 + +(* Necessarily, Ann and Bill are married to each other; also Carol to Dave. *) + let marriedto yy xx = X.(map2 (curry are_married) xx yy) + +(* Actually, only Carol and Dave kiss. In w2, spouses kiss. In w3, there is no kissing. *) + let kisses1 yy xx = X.(map2 (fun x y -> (x = Carol && y = Dave) || (x = Dave && y = Carol)) xx yy) + let kisses2 yy xx = marriedto xx yy + let kisses3 yy xx = X.(map2 (fun x y -> false) xx yy) + +(* Actually, each husband loves only his wife and Frank also loves the women. + In w2, all the men love Carol and Ella loves the wives. + In w3, Frank loves everyone else. *) + let loves1 yy xx = X.(map2 (fun x y -> (is_male x && are_married(x,y)) || (x = Frank && not (is_male y))) xx yy) + let loves2 yy xx = X.(map2 (fun x y -> (is_male x && y = Carol) || (x = Ella && is_a_wife y)) xx yy) + let loves3 yy xx = X.(map2 (fun x y -> x = Frank && x <> y) xx yy) +end + +module Test(S : SEMANTICS) : sig end = struct + type result = True | False | Fail + let print_result res = match res with True -> print_string "true" | False -> print_string "false" | Fail -> print_string "failure" + + let check name expected expr = + (match (try Some (S.run expr) with Not_found -> None) with + | Some true -> if expected = True then true else begin print_string "Sentence \""; print_string name; print_string "\" failed: got true but expected "; print_result expected; print_newline (); false end + | Some false -> if expected = False then true else begin print_string "Sentence \""; print_string name; print_string "\" failed: got false but expected "; print_result expected; print_newline (); false end + | None -> if expected = Fail then true else begin print_string "Sentence \""; print_string name; print_string "\" failed: got failure but expected "; print_result expected; print_newline (); false end) +(* + with List.Short_list -> begin print_string "Sentence \""; print_string name; print_string "\" failed: got Short_list but expected "; print_result expected; print_newline (); false end + with Failure "Unimplemented" -> begin print_string "Sentence \""; print_string name; print_endline "\" unimplemented."; true end +*) + + let dynamic res = if S.dynamic then res else Fail + + let truth = S.(male bill) + let falsehood = S.(female bill) + let bool_results = + [ check "true" True truth + ; check "false" False falsehood + ; check "true and true" True S.(truth &&& truth) + ; check "true and false" False S.(truth &&& falsehood) + ; check "false and true" False S.(falsehood &&& truth) + ; check "false and false" False S.(falsehood &&& falsehood) + ; check "true or true" True S.(truth ||| truth) + ; check "true or false" True S.(truth ||| falsehood) + ; check "false or true" True S.(falsehood ||| truth) + ; check "false or false" False S.(falsehood ||| falsehood) + ; check "true >>> true" True S.(truth >>> truth) + ; check "true >>> false" False S.(truth >>> falsehood) + ; check "false >>> true" True S.(falsehood >>> truth) + ; check "false >>> false" True S.(falsehood >>> falsehood) + ] + let () = print_newline(); print_int (List.count not bool_results); print_endline " boolean test(s) failed." + + let results = + [ check "1. Bill is male" True S.(male bill) + ; check "2. Bill is female" False S.(female bill) + ; check "3. Bill isn't female" True S.(~~~ (female bill)) + ; check "4. Carol didn't leave" False S.(~~~ (left carol)) + ; S.extensional || check "5. Maybe Carol didn't leave" True S.(maybe (~~~ (left carol))) + ; S.extensional || check "6. Maybe Ann didn't leave" False S.(maybe (~~~ (left ann))) + + ; check "7. Some x. x is male" True S.(some 'x' (male getx)) + ; check "8. Some x. x isn't female" True S.(some 'x' (~~~ (female getx))) + ; check "9. Some x. x left" True S.(some 'x' (left getx)) + ; check "10. Some x. x didn't leave" False S.(some 'x' (~~~ (left getx))) + ; check "11. Every x. x left" True S.(every 'x' (left getx)) + ; check "12. Every x. x is female" False S.(every 'x' (female getx)) + ; check "13. Every x. x isn't male" False S.(every 'x' (~~~ (male getx))) + ; check "14. (Some x. x is male) and Ann is female" True S.(some 'x' (male getx) &&& female ann) + ; check "15. Some x. (x is male and Ann is female)" True S.(some 'x' (male getx &&& female ann)) + + ; check "16. Some x. (x is male and x is female)" False S.(some 'x' (male getx &&& female getx)) + ; check "17. Some x. (x is male) and Some x. x is female" True S.(some 'x' (male getx) &&& some 'x' (female getx)) + + ; check "18. Some x. (x is male and Some y. y is male)" True S.(some 'x' (male getx &&& some 'y' (male gety))) + ; check "19. Some x. (x is male and Some y. y is female)" True S.(some 'x' (male getx &&& some 'y' (female gety))) + ; check "20. Some x. (x is male and Some y. x is male)" True S.(some 'x' (male getx &&& some 'y' (male getx))) + ; check "21. Some x. (x is male and Some y. x is female)" False S.(some 'x' (male getx &&& some 'y' (female getx))) + ; check "22. Some x. (x is male and Some y. x isn't female)" True S.(some 'x' (male getx &&& some 'y' (~~~ (female getx)))) + ; check "23. Some x. (x is male and Some x. x is female)" True S.(some 'x' (male getx &&& some 'x' (female getx))) + + ; check "24. Some x. (x is male) and Some y. (y is female and Bill is male)" True S.(some 'x' (male getx) &&& some 'y' (male gety &&& male bill)) + ; check "25. Some x. (x is male and Some y. (y is female and Bill is male))" True S.(some 'x' (male getx &&& some 'y' (female gety &&& male bill))) + ; check "26. Some x. (x is male and Some y. (y is male and Bill is male))" True S.(some 'x' (male getx &&& some 'y' (male gety &&& male bill))) + ; check "27. Some x. (x is male and Some y. (x is female and Bill is male))" False S.(some 'x' (male getx &&& some 'y' (female getx &&& male bill))) + ; check "28. Some x. (x is male and Some y. (x isn't female and Bill is male))" True S.(some 'x' (male getx &&& some 'y' (~~~ (female getx) &&& male bill))) + ; check "29. Some x. (x is male and Some y. (x is male and Bill is male))" True S.(some 'x' (male getx &&& some 'y' (male getx &&& male bill))) + + ; check "30. Some x. (x is male and Some y. (y is female and x isn't female))" True S.(some 'x' (male getx &&& some 'y' (female gety &&& ~~~ (female getx)))) + ; check "31. Some x. (x is male and Some y. (y is female and x is single))" True S.(some 'x' (male getx &&& some 'y' (female gety &&& single getx))) + ; check "32. Some x. (x is male and Some y. (y is female and x isn't single))" True S.(some 'x' (male getx &&& some 'y' (female gety &&& ~~~ (single getx)))) + ; check "33. Some x. (x is male and Some y. (y is male and x is single))" True S.(some 'x' (male getx &&& some 'y' (male gety &&& single getx))) + ; check "34. Some x. (x is male and Some y. (y is male and x isn't single))" True S.(some 'x' (male getx &&& some 'y' (male gety &&& ~~~ (single getx)))) + + ; check "35. Some x. (x is male and Some y. (x is female and x is single))" False S.(some 'x' (male getx &&& some 'y' (female getx &&& single getx))) + ; check "36. Some x. (x is male and Some y. (x is female and x isn't single))" False S.(some 'x' (male getx &&& some 'y' (female getx &&& ~~~ (single getx)))) + ; check "37. Some x. (x is male and Some y. (x is male and x is single))" True S.(some 'x' (male getx &&& some 'y' (male getx &&& single getx))) + ; check "38. Some x. (x is male and Some y. (x is male and x isn't single))" True S.(some 'x' (male getx &&& some 'y' (male getx &&& ~~~ (single getx)))) + + ; check "39. (Some x. male x) and x left" (dynamic True) S.(some 'x' (male getx) &&& left getx) + ; check "40. (Some x. male x) and female x" (dynamic False) S.(some 'x' (male getx) &&& female getx) + ; check "41. (Some x. male x) and Some y. female x" (dynamic False) S.(some 'x' (male getx) &&& some 'y' (female getx)) + ; check "42. (Some x. male x) and Some y. male x" (dynamic True) S.(some 'x' (male getx) &&& some 'y' (male getx)) + ; check "43. (Some x. male x) and Some y. (female x and male Bill)" (dynamic False) S.(some 'x' (male getx) &&& some 'y' (female getx &&& male bill)) + ; check "44. (Some x. male x) and Some y. (male x and male Bill)" (dynamic True) S.(some 'x' (male getx) &&& some 'y' (male getx &&& male bill)) + ; check "45. (Some x. male x) and Some y. (female y and x isn't single)" (dynamic True) S.(some 'x' (male getx) &&& some 'y' (female gety &&& ~~~ (single getx))) + ; check "46. (Some x. male x) and Some y. (female x and x isn't single)" (dynamic False) S.(some 'x' (male getx) &&& some 'y' (female getx &&& ~~~ (single getx))) + ; check "47. (Some x. male x) and Some y. (male x and x isn't single)" (dynamic True) S.(some 'x' (male getx) &&& some 'y' (male getx &&& ~~~ (single getx))) + + ; check "48. Every x. (male x and (Some y. married y x) -> loves y x)" (dynamic True) S.(every 'x' (male getx &&& some 'y' (marriedto gety getx) >>> loves gety getx)) + ; check "49. Every x. (male x and (Some y. married y x) -> kisses y x)" (dynamic False) S.(every 'x' (male getx &&& some 'y' (marriedto gety getx) >>> kisses gety getx)) + ; check "50. (Some x. (male x and Some y. married y x)) -> loves y x" (dynamic True) S.(some 'x' (male getx &&& some 'y' (marriedto gety getx)) >>> loves gety getx) + ; check "51. (Some x. (male x and Some y. married y x)) -> kisses y x" (dynamic False) S.(some 'x' (male getx &&& some 'y' (marriedto gety getx)) >>> kisses gety getx) + + ; check "52. Every x. (male x and Some y. (female y and (x = frank or married y x)) -> loves y x)" (dynamic True) S.(every 'x' (male getx &&& some 'y' (female gety &&& (getx === frank ||| marriedto gety getx)) >>> loves gety getx)) + ; check "53. Every x. (male x and (x = frank or Some y. married y x) -> loves y x)" (dynamic Fail) S.(every 'x' (male getx &&& (getx === frank ||| some 'y' (marriedto gety getx)) >>> loves gety getx)) + ; check "54. Every x. (male x and (Some y. (x = frank and female y) or Some y. married y x) -> loves y x)" (dynamic Fail) S.(every 'x' (male getx &&& (some 'y' (getx === frank &&& female gety) ||| some 'y' (marriedto gety getx)) >>> loves gety getx)) + ; check "55. Every x. (male x and ((x = frank and Some y. female y) or Some y. married y x) -> loves y x)" (dynamic Fail) S.(every 'x' (male getx &&& ((getx === frank &&& some 'y' (female gety)) ||| some 'y' (marriedto gety getx)) >>> loves gety getx)) + ] + let () = print_newline(); print_int (List.count not results); print_endline " test(s) failed." + +end + + + + + + +module R = Monad.Reader(struct type env = identifier -> entity end) +module S = Monad.State(struct type store = identifier -> entity end) +module S' = Monad.State(struct type store = identifier -> int end) +module R' = Monad.Reader(struct type env = identifier -> int end) + +let env0 = fun _ -> raise Not_found +let lookup (sought : identifier) env = env sought +let lookup_string (sought : identifier) env = try string_of_entity (env sought) with Not_found -> "*" +let print_lookup c env = print_string (lookup_string c env) +let insert (var : identifier) who env = fun sought -> if sought = var then who else env sought + +module Y = Monad.Reader(struct type env = world end) + +module L = Monad.List + +module RY = struct + include R.T(Y) + include Monad.Derive.Reader_dbl(Y)(R.T(Y)) +end +module YR = struct + include Y.T(R) + include Monad.Derive.Reader_dbl(R)(Y.T(R)) +end +module LR = struct + include L.T(R) + include Monad.Derive.Reader(R)(L.T(R)) +end +module LY = struct + include L.T(Y) + include Monad.Derive.Reader(Y)(L.T(Y)) +end +module RL = struct + include R.M(L) + include Monad.Derive.List(L)(R.M(L)) +end +module YL = struct + include Y.M(L) + include Monad.Derive.List(L)(Y.M(L)) +end + +module SY = struct + include S.T(Y) + include Monad.Derive.Reader(Y)(S.T(Y)) +end +module YS = struct + include Y.T(S) + include Monad.Derive.State(S)(Y.T(S)) +end +module LS = struct + include L.T(S) + include Monad.Derive.State(S)(L.T(S)) +end +module LY = struct + include L.T(Y) + include Monad.Derive.Reader(Y)(L.T(Y)) +end +module SL = struct + include S.M(L) + include Monad.Derive.List(L)(S.M(L)) +end +module YL = struct + include Y.M(L) + include Monad.Derive.List(L)(Y.M(L)) +end + +module S'Y = struct + include S'.T(Y) + include Monad.Derive.Reader(Y)(S'.T(Y)) +end +module YS' = struct + include Y.T(S') + include Monad.Derive.State(S')(Y.T(S')) +end +module LS' = struct + include L.T(S') + include Monad.Derive.State(S')(L.T(S')) +end +module S'L = struct + include S'.M(L) + include Monad.Derive.List(L)(S'.M(L)) +end + +module LRY = struct + include L.T(RY) + include Monad.Derive.Reader2(RY)(L.T(RY)) +end +module LYR = struct + include L.T(YR) + include Monad.Derive.Reader2(YR)(L.T(YR)) +end +module RLY = struct + include R.M(LY) + include Monad.Derive.List(LY)(R.M(LY)) + include Monad.Derive.Reader_dbl(LY)(R.M(LY)) +end +module RYL = struct + include R.M(YL) + include Monad.Derive.List(YL)(R.M(YL)) + include Monad.Derive.Reader_dbl(YL)(R.M(YL)) +end +module YLR = struct + include Y.M(LR) + include Monad.Derive.List(LR)(Y.M(LR)) + include Monad.Derive.Reader_dbl(LR)(Y.M(LR)) +end +module YRL = struct + include Y.M(RL) + include Monad.Derive.List(RL)(Y.M(RL)) + include Monad.Derive.Reader_dbl(RL)(Y.M(RL)) +end + +module LSY = struct + include L.T(SY) + include Monad.Derive.Reader(SY)(L.T(SY)) + include Monad.Derive.State(SY)(L.T(SY)) +end +module LYS = struct + include L.T(YS) + include Monad.Derive.Reader(YS)(L.T(YS)) + include Monad.Derive.State(YS)(L.T(YS)) +end +module SLY = struct + include S.M(LY) + include Monad.Derive.List(LY)(S.M(LY)) + include Monad.Derive.Reader(LY)(S.M(LY)) +end +module SYL = struct + include S.M(YL) + include Monad.Derive.List(YL)(S.M(YL)) + include Monad.Derive.Reader(YL)(S.M(YL)) +end +module YLS = struct + include Y.M(LS) + include Monad.Derive.List(LS)(Y.M(LS)) + include Monad.Derive.State(LS)(Y.M(LS)) +end +module YSL = struct + include Y.M(SL) + include Monad.Derive.List(SL)(Y.M(SL)) + include Monad.Derive.State(SL)(Y.M(SL)) +end + +module LS'Y = struct + include L.T(S'Y) + include Monad.Derive.Reader(S'Y)(L.T(S'Y)) + include Monad.Derive.State(S'Y)(L.T(S'Y)) +end +module LYS' = struct + include L.T(YS') + include Monad.Derive.Reader(YS')(L.T(YS')) + include Monad.Derive.State(YS')(L.T(YS')) +end +module S'LY = struct + include S'.M(LY) + include Monad.Derive.List(LY)(S'.M(LY)) + include Monad.Derive.Reader(LY)(S'.M(LY)) +end +module S'YL = struct + include S'.M(YL) + include Monad.Derive.List(YL)(S'.M(YL)) + include Monad.Derive.Reader(YL)(S'.M(YL)) +end +module YLS' = struct + include Y.M(LS') + include Monad.Derive.List(LS')(Y.M(LS')) + include Monad.Derive.State(LS')(Y.M(LS')) +end +module YS'L = struct + include Y.M(S'L) + include Monad.Derive.List(S'L)(Y.M(S'L)) + include Monad.Derive.State(S'L)(Y.M(S'L)) +end + + +module Sem1a = struct + let dynamic = false + let extensional = true + + (* We use monad R, with env = var -> entity. + Types of sentences are env -> bool. *) + module X = R + type noun = entity X.t + type sent = bool X.t + let run (xx : sent) : bool = X.(run xx env0 = true) + let getx = X.(asks (lookup 'x')) + let gety = X.(asks (lookup 'y')) + let getz = X.(asks (lookup 'z')) + let let_ c (xx : noun) (body : sent) = X.(xx >>= fun x -> shift (insert c x) body) + + let (~~~) xx = X.(map not xx) + let (&&&) xx yy = X.(xx >>= fun b' -> if not b' then mid false else yy) + let (|||) xx yy = X.(xx >>= fun b' -> if b' then mid true else yy) + let (>>>) xx yy = X.(xx >>= fun b' -> if not b' then mid true else yy) + + let some c (body : sent) = + let (bbs : bool X.t list) = List.map (fun x -> let_ c X.(mid x) body) domain in + let (bsb : bool list X.t) = X.seq bbs in + let (bb : bool X.t) = X.map (exists ident) bsb in + bb + let every c (body : sent) = + let (bbs : bool X.t list) = List.map (fun x -> let_ c X.(mid x) body) domain in + let (bsb : bool list X.t) = X.seq bbs in + let (bb : bool X.t) = X.map (for_all ident) bsb in + bb + + module F = Facts(X) + let ann = X.(mid Ann) let bill = X.(mid Bill) let carol = X.(mid Carol) let dave = X.(mid Dave) let ella = X.(mid Ella) let frank = X.(mid Frank) + let (===) xx yy = X.(map2 (=) xx yy) + let male = F.male let female = F.female let single = F.single let left = F.left1 + let marriedto = F.marriedto let saw = F.saw1 let kisses = F.kisses1 let loves = F.loves1 + let thinks pp xx = failwith "Unimplemented" + let maybe pp = failwith "Unimplemented" +end (* Sem1a *) + +module Sem1b = struct + let dynamic = false + let extensional = true + + (* We again use monad R, with env = var -> entity. + This variant defines sentence meanings as Kleisli arrows, that is: + type sent = bool -> bool X.t + or equivalently, bool -> (env -> bool). A true sentence takes any bool + input to a boxed version of that input (so truth = mid), and a false + sentence takes any input to mid false. + This more closely parallels the dynamic semantics (though it should not, + just on account of that structural similarity, be itself counted as dynamic). + It also brings the boolean operations closer to monadic primitives. + *) + module X = R + type noun = entity X.t + type sent = bool -> bool X.t + let run (k : sent) : bool = X.(run (k true) env0 = true) + let getx = X.(asks (lookup 'x')) + let gety = X.(asks (lookup 'y')) + let getz = X.(asks (lookup 'z')) + let let_ c (xx : noun) (body : sent) = fun b -> X.(xx >>= fun x -> shift (insert c x) (body b)) + + let (~~~) k = fun b -> X.(if b then map not (k true) else mid false) + let (&&&) k j = X.(k >=> j) + let (|||) k j = ~~~ (~~~ k &&& ~~~ j) + let (>>>) k j = ~~~ k ||| j +(* or + let (|||) xx yy = fun b -> X.(xx b >>= fun b' -> if b' then mid true else yy b) + let (>>>) xx yy = fun b -> X.(xx b >>= fun b' -> if not b' then mid true else yy b) + let (>>>) k j = ~~~ (k &&& ~~~ j) +*) + + let some c (body : sent) = fun b -> + let (bbs : bool X.t list) = List.map (fun x -> let_ c X.(mid x) body b) domain in + let (bsb : bool list X.t) = X.seq bbs in + let (bb : bool X.t) = X.map (exists ident) bsb in + bb + let every c (body : sent) = fun b -> + let (bbs : bool X.t list) = List.map (fun x -> let_ c X.(mid x) body b) domain in + let (bsb : bool list X.t) = X.seq bbs in + let (bb : bool X.t) = X.map (for_all ident) bsb in + bb + + module F = Facts(X) + let to_kleisli xx = fun b -> X.(xx >>= fun b' -> mid (b && b')) + let ann = X.(mid Ann) let bill = X.(mid Bill) let carol = X.(mid Carol) let dave = X.(mid Dave) let ella = X.(mid Ella) let frank = X.(mid Frank) + let (===) xx yy = to_kleisli X.(map2 (=) xx yy) + let male = to_kleisli % F.male let female = to_kleisli % F.female let single = to_kleisli % F.single let left = to_kleisli % F.left1 + let marriedto yy xx = to_kleisli (F.marriedto yy xx) let saw yy xx = to_kleisli (F.saw1 yy xx) let kisses yy xx = to_kleisli (F.kisses1 yy xx) let loves yy xx = to_kleisli (F.loves1 yy xx) + let thinks pp xx = fun b -> failwith "Unimplemented" + let maybe pp = fun b -> failwith "Unimplemented" +end (* Sem1b *) + +module Sem2a = struct + let dynamic = false + let extensional = true + + (* We could use either monad RL or LR, with type env = var -> entity. + Their box type is the same: env -> ['a] + However, the types of SL and LS differ, and the latter is more suitable for the dynamic version. So to keep things maximally parallel, we'll use LR here. + We use the box type in two ways: first, we use a box(entity) to compute whether a matrix + clause is satisfied by a bound pronoun, where entity ranges over the whole domain. + Second, it is convenient and more consonant with later strategies + to re-use the same monad for sentence types (rather than using a simpler monad + that lacks a List component). Here we will let the types of sentences + be box(bool), that is: env -> [bool]. We will understand the sentence to be true + if there are ANY truths in the resulting list. A list of all falses is treated + the same as an empty list. Sem2c, below, eliminates this artifact by changing + the sentence type to box(unit). Then truths (rel to an env) are [();...] and + falsehoods are []. +*) + module X = LR + type noun = entity X.t + type sent = bool X.t + let run (xx : sent) : bool = X.(any_truths (run xx env0)) + (* lift an 'a list to a single 'a X.t *) + let mids (xs : 'a list) : 'a X.t = let rec aux xx = function [] -> xx | x::xs -> aux X.(xx ++ mid x) xs in aux X.mzero xs + let getx = X.(asks (lookup 'x')) + let gety = X.(asks (lookup 'y')) + let getz = X.(asks (lookup 'z')) + let let_ c (xx : noun) (body : sent) = X.(xx >>= fun x -> shift (insert c x) body) + + let (~~~) xx = X.(map not xx) + let (&&&) xx yy = X.(xx >>= fun b' -> if not b' then mid false else yy) + let (|||) xx yy = X.(xx >>= fun b' -> if b' then mid true else yy) + let (>>>) xx yy = X.(xx >>= fun b' -> if not b' then mid true else yy) + + (* On this semantics, `some c body` is a list of the boolean outcomes for body for each assignment to c. + That matches our convention for sentence types, where any truth in the list means the sentence is true. + However, we can't then define `every c body === ~~~ (some c (~~~ body))`, because it's only when the rhs is entirely true that the lhs should be true. + In later semantics, the duality of `some` and `every` will be restored. + *) + let some c (body : sent) = X.(let_ c (mids domain) body) + let every c body = X.(let xx = let_ c (mids domain) body in list_map (fun xs -> if all_truths xs then xs else []) xx) (* could alternatively return [true] instead of xs *) + + module F = Facts(X) + let ann = X.(mid Ann) let bill = X.(mid Bill) let carol = X.(mid Carol) let dave = X.(mid Dave) let ella = X.(mid Ella) let frank = X.(mid Frank) + let (===) xx yy = X.(map2 (=) xx yy) + let male = F.male let female = F.female let single = F.single let left = F.left1 + let marriedto = F.marriedto let saw = F.saw1 let kisses = F.kisses1 let loves = F.loves1 + let thinks pp xx = failwith "Unimplemented" + let maybe pp = failwith "Unimplemented" +end (* Sem2a *) + +(* Sem2b would convert Sem2a into having sentence meanings be Kleisli arrows, as Sem1b did. + Not here implemented. *) + +(* Variant of Sem2a, which uses [();...] vs [] instead of [true;...] vs (list of all false OR []). *) +module Sem2c = struct + let dynamic = false + let extensional = true + + (* We use monad LR as above, with same env = var -> entity and box type = env -> ['a]. + We again use box(entity) to compute whether matrix clauses are satisfied by + bound pronouns; but now we use box(unit) for the types of sentences. + Truths (rel to an env) are [();...] and falsehood is []. + *) + module X = LR + type noun = entity X.t + type sent = unit X.t + let run (xx : sent) : bool = X.(not (List.is_null (run xx env0))) + (* lift an 'a list to a single 'a X.t *) + let mids (xs : 'a list) : 'a X.t = let rec aux xx = function [] -> xx | x::xs -> aux X.(xx ++ mid x) xs in aux X.mzero xs + let getx = X.(asks (lookup 'x')) + let gety = X.(asks (lookup 'y')) + let getz = X.(asks (lookup 'z')) + let let_ c (xx : noun) (body : sent) = X.(xx >>= fun x -> shift (insert c x) body) + let to_unit (x : bool) : unit X.t = X.guard x + + let (~~~) xx = X.(list_map (fun xs -> if is_null xs then [()] else []) xx) + let (&&&) xx yy = X.(xx >> yy) + let (|||) xx yy = X.(xx ++ (* ~~~ xx >> *) yy) + let (>>>) xx yy = X.(~~~ xx ++ yy) +(* or + let (>>>) xx yy = X.(~~~ (xx >> ~~~ yy)) +*) + + let some c (body : sent) = X.(let_ c (mids domain) body) + let every c (body : sent) = ~~~ (some c (~~~ body)) + + module F = Facts(X) + let ann = X.(mid Ann) let bill = X.(mid Bill) let carol = X.(mid Carol) let dave = X.(mid Dave) let ella = X.(mid Ella) let frank = X.(mid Frank) + let (===) xx yy = X.(map2 (=) xx yy >>= to_unit) + let male xx = X.(F.male xx >>= to_unit) + let female xx = X.(F.female xx >>= to_unit) + let single xx = X.(F.single xx >>= to_unit) + let left xx = X.(F.left1 xx >>= to_unit) + let marriedto yy xx = X.(F.marriedto yy xx >>= to_unit) + let saw yy xx = X.(F.saw1 yy xx >>= to_unit) + let kisses yy xx = X.(F.kisses1 yy xx >>= to_unit) + let loves yy xx = X.(F.loves1 yy xx >>= to_unit) + let thinks pp xx = failwith "Unimplemented" + let maybe pp = failwith "Unimplemented" +end (* Sem2c *) + +(* Sem2d would convert Sem2c into having sentence meanings be Kleisli arrows, as Sem1b did. + Not here implemented. *) + +(* Add intensionality to 2a *) +module Sem3a = struct + let dynamic = false + let extensional = false + + (* Using monad LRY, with type env = var -> entity. + Box type is env -> world -> ['a] + Types of sentences are env -> world -> [bool]. *) + module X = LRY + type noun = entity X.t + type sent = bool X.t + let run xx = X.(any_truths (run xx env0 Actual)) + (* lift an 'a list to a single 'a X.t *) + let mids (xs : 'a list) : 'a X.t = let rec aux xx = function [] -> xx | x::xs -> aux X.(xx ++ mid x) xs in aux X.mzero xs + let getx = X.(asks (lookup 'x')) + let gety = X.(asks (lookup 'y')) + let getz = X.(asks (lookup 'z')) + let getw = X.(uask) (* get world from the underlying Y monad *) + (* select an intranstive verb based on the world *) + let select1 f1 f2 f3 xx = X.(getw >>= fun w -> (if w = Actual then f1 else if w = Other then f2 else f3) xx) + (* select a transitive verb based on the world *) + let select2 f1 f2 f3 yy xx = X.(getw >>= fun w -> (if w = Actual then f1 else if w = Other then f2 else f3) yy xx) + let let_ c (xx : noun) (body : sent) = X.(xx >>= fun x -> shift (insert c x) body) + let letw world (body : sent) = X.(ushift (fun _ -> world) body) (* shift the "env" of the underlying Y monad *) + + let (~~~) xx = X.(map not xx) + let (&&&) xx yy = X.(xx >>= fun b' -> if not b' then mid false else yy) + let (|||) xx yy = X.(xx >>= fun b' -> if b' then mid true else yy) + let (>>>) xx yy = X.(xx >>= fun b' -> if not b' then mid true else yy) + + let some c (body : sent) = X.(let_ c (mids domain) body) + let every c (body : sent) = X.(let xx = let_ c (mids domain) body in list_map (fun xs -> if all_truths xs then xs else []) xx) + + module F = Facts(X) + let ann = X.(mid Ann) let bill = X.(mid Bill) let carol = X.(mid Carol) let dave = X.(mid Dave) let ella = X.(mid Ella) let frank = X.(mid Frank) + let (===) xx yy = X.(map2 (=) xx yy) + let male = F.male let female = F.female let single = F.single + let left xx = select1 F.left1 F.left2 F.left3 xx + let saw yy xx = select2 F.saw1 F.saw2 F.saw3 yy xx + let marriedto = F.marriedto + let kisses yy xx = select2 F.kisses1 F.kisses2 F.kisses3 yy xx + let loves yy xx = select2 F.loves1 F.loves2 F.loves3 yy xx + let thinks pp xx = failwith "Unimplemented" + let maybe (body : sent) : sent = + let (yy : R.env -> Y.env -> bool list) = fun e w -> + let body_int = List.map (fun w' -> any_truths (X.run (letw w' body) e w)) modal_domain in + body_int (* can just use body's intension as the result of `maybe body` *) in + Obj.magic yy +end (* Sem3a *) + +(* Sem3b would convert Sem3a into having sentence meanings be Kleisli arrows, as Sem1b did. + Not here implemented. *) + +(* Add intensionality to 2c *) +module Sem3c = struct + let dynamic = false + let extensional = false + + (* Using monad LRY, with type env = var -> entity. + Box type is env -> world -> ['a] + Types of sentences are env -> world -> [unit]. *) + module X = LRY + type noun = entity X.t + type sent = unit X.t + let run xx = X.(not (List.is_null (run xx env0 Actual))) + (* lift an 'a list to a single 'a X.t *) + let mids (xs : 'a list) : 'a X.t = let rec aux xx = function [] -> xx | x::xs -> aux X.(xx ++ mid x) xs in aux X.mzero xs + let getx = X.(asks (lookup 'x')) + let gety = X.(asks (lookup 'y')) + let getz = X.(asks (lookup 'z')) + let getw = X.(uask) (* get world from the underlying Y monad *) + (* select an intranstive verb based on the world *) + let select1 f1 f2 f3 xx = X.(getw >>= fun w -> (if w = Actual then f1 else if w = Other then f2 else f3) xx) + (* select a transitive verb based on the world *) + let select2 f1 f2 f3 yy xx = X.(getw >>= fun w -> (if w = Actual then f1 else if w = Other then f2 else f3) yy xx) + let let_ c (xx : noun) (body : sent) = X.(xx >>= fun x -> shift (insert c x) body) + let letw world (body : sent) = X.(ushift (fun _ -> world) body) (* shift the "env" of the underlying Y monad *) + let to_unit (x : bool) : unit X.t = X.guard x + + let (~~~) xx = X.(list_map (fun xs -> if is_null xs then [()] else []) xx) + let (&&&) xx yy = X.(xx >> yy) + let (|||) xx yy = X.(xx ++ (* ~~~ xx >> *) yy) + let (>>>) xx yy = X.(~~~ xx ++ yy) +(* or + let (>>>) xx yy = X.(~~~ (xx >> ~~~ yy)) +*) + + let some c (body : sent) = X.(let_ c (mids domain) body) + let every c (body : sent) = ~~~ (some c (~~~ body)) + + module F = Facts(X) + let ann = X.(mid Ann) let bill = X.(mid Bill) let carol = X.(mid Carol) let dave = X.(mid Dave) let ella = X.(mid Ella) let frank = X.(mid Frank) + let (===) xx yy = X.(map2 (=) xx yy >>= to_unit) + let male xx = X.(F.male xx >>= to_unit) + let female xx = X.(F.female xx >>= to_unit) + let single xx = X.(F.single xx >>= to_unit) + let left xx = X.(select1 F.left1 F.left2 F.left3 xx >>= to_unit) + let saw yy xx = X.(select2 F.saw1 F.saw2 F.saw3 yy xx >>= to_unit) + let marriedto yy xx = X.(F.marriedto yy xx >>= to_unit) + let kisses yy xx = X.(select2 F.kisses1 F.kisses2 F.kisses3 yy xx >>= to_unit) + let loves yy xx = X.(select2 F.loves1 F.loves2 F.loves3 yy xx >>= to_unit) + let thinks pp xx = failwith "Unimplemented" + let maybe (body : sent) : sent = + let (yy : R.env -> Y.env -> unit list) = fun e w -> + let body_int = List.map (fun w' -> not @@ List.is_null @@ X.run (letw w' body) e w) modal_domain in + if any_truths body_int then [()] else [] in + Obj.magic yy +end (* Sem3c *) + +(* Sem3d would convert Sem3c into having sentence meanings be Kleisli arrows, as Sem1b did. + Not here implemented. *) + + +(* Dynamic version of Sem2c *) +module Sem5c = struct + let dynamic = true + let extensional = true + + (* This needs to use monad SL, with store = var -> entity + and box type = store -> ['a,store] + Sentence meaning is box(unit). + Later strategies with more complex sentence meanings and stores + may be able to use monad LS, with box type store -> ['a],store + *) + module X = SL + type noun = entity X.t + type sent = unit X.t + let run (xx : sent) : bool = X.(not (List.is_null (run xx env0))) + (* lift an 'a list to a single 'a X.t *) + let mids (xs : 'a list) : 'a X.t = let rec aux xx = function [] -> xx | x::xs -> aux X.(xx ++ mid x) xs in aux X.mzero xs + let getx = X.(gets (lookup 'x')) + let gety = X.(gets (lookup 'y')) + let getz = X.(gets (lookup 'z')) + let let_ c (xx : noun) (body : sent) = X.(xx >>= fun x -> modify (insert c x) >> body) + let to_unit (x : bool) : unit X.t = X.guard x +(* + let peek msg () = X.(get >>= fun s -> begin print_string msg; print_string ": x="; print_lookup 'x' s; print_string ", y="; print_lookup 'y' s; print_string ", z="; print_lookup 'z' s; print_newline (); mid () end) +*) + + let (~~~) (xx : sent) : sent = + let yy : S.store -> (unit * S.store) list = fun s -> if List.is_null (X.run xx s) then [(),s] else [] in + Obj.magic yy (* this is an identity function that changes the type of yy to a unit X.t *) + let (&&&) xx yy = X.(xx >> yy) + let (|||) xx yy = ~~~ (~~~ xx &&& ~~~ yy) + let (>>>) xx yy = X.(~~~ (xx >> ~~~ yy)) + +(* + This would propagate effects out of the disjuncts, so that for example after + "Some y. (x = frank and female y) or Some y. married y x" + "y" would be available for anaphor: + let (|||) xx yy = X.(xx ++ (~~~ xx >> yy)) + + This wouldn't propagate effects from antecedent to consequent, so that for example + "(Some y. marriedto y bill) >>> female gety" + has a failed lookup on "y": + let (>>>) xx yy = X.(~~~ xx ++ yy) +*) + + let some c (body : sent) = X.(let_ c (mids domain) body) + let every c (body : sent) = ~~~ (some c (~~~ body)) + + module F = Facts(X) + let ann = X.(mid Ann) let bill = X.(mid Bill) let carol = X.(mid Carol) let dave = X.(mid Dave) let ella = X.(mid Ella) let frank = X.(mid Frank) + let (===) xx yy = X.(map2 (=) xx yy >>= to_unit) + let male xx = X.(F.male xx >>= to_unit) + let female xx = X.(F.female xx >>= to_unit) + let single xx = X.(F.single xx >>= to_unit) + let left xx = X.(F.left1 xx >>= to_unit) + let marriedto yy xx = X.(F.marriedto yy xx >>= to_unit) + let saw yy xx = X.(F.saw1 yy xx >>= to_unit) + let kisses yy xx = X.(F.kisses1 yy xx >>= to_unit) + let loves yy xx = X.(F.loves1 yy xx >>= to_unit) + let thinks pp xx = failwith "Unimplemented" + let maybe pp = failwith "Unimplemented" +end (* Sem5c *) + + +(* Dynamic version of Sem3c / Add intensionality to Sem5c *) +module Sem6c = struct + let dynamic = true + let extensional = false + + (* This needs to use monad SLY, with store = var -> entity + and box type = store -> world -> ['a,store] + Sentence meaning is box(unit). + Later strategies with more complex sentence meanings and stores + may be able to use monad LSY, with box type store -> world -> ['a],store + *) + module X = SLY + type noun = entity X.t + type sent = unit X.t + let run (xx : sent) : bool = X.(not (List.is_null (run xx env0 Actual))) + (* lift an 'a list to a single 'a X.t *) + let mids (xs : 'a list) : 'a X.t = let rec aux xx = function [] -> xx | x::xs -> aux X.(xx ++ mid x) xs in aux X.mzero xs + let getx = X.(gets (lookup 'x')) + let gety = X.(gets (lookup 'y')) + let getz = X.(gets (lookup 'z')) + let getw = X.(ask) (* get world from the underlying Y monad *) + (* select an intranstive verb based on the world *) + let select1 f1 f2 f3 xx = X.(getw >>= fun w -> (if w = Actual then f1 else if w = Other then f2 else f3) xx) + (* select a transitive verb based on the world *) + let select2 f1 f2 f3 yy xx = X.(getw >>= fun w -> (if w = Actual then f1 else if w = Other then f2 else f3) yy xx) + let let_ c (xx : noun) (body : sent) = X.(xx >>= fun x -> modify (insert c x) >> body) + let letw world (body : sent) = X.(shift (fun _ -> world) body) (* shift the "env" of the underlying Y monad *) + let to_unit (x : bool) : unit X.t = X.guard x +(* + let peek msg () = X.(get >>= fun s -> begin print_string msg; print_string ": x="; print_lookup 'x' s; print_string ", y="; print_lookup 'y' s; print_string ", z="; print_lookup 'z' s; print_newline (); mid () end) +*) + + let (~~~) (xx : sent) : sent = + let yy : S.store -> Y.env -> (unit * S.store) list = fun s w -> if List.is_null (X.run xx s w) then [(),s] else [] in + Obj.magic yy (* this is an identity function that changes the type of yy to a unit X.t *) + + let (&&&) xx yy = X.(xx >> yy) + let (|||) xx yy = ~~~ (~~~ xx &&& ~~~ yy) + let (>>>) xx yy = X.(~~~ (xx >> ~~~ yy)) + + let some c (body : sent) = X.(let_ c (mids domain) body) + let every c (body : sent) = ~~~ (some c (~~~ body)) + + module F = Facts(X) + let ann = X.(mid Ann) let bill = X.(mid Bill) let carol = X.(mid Carol) let dave = X.(mid Dave) let ella = X.(mid Ella) let frank = X.(mid Frank) + let (===) xx yy = X.(map2 (=) xx yy >>= to_unit) + let male xx = X.(F.male xx >>= to_unit) + let female xx = X.(F.female xx >>= to_unit) + let single xx = X.(F.single xx >>= to_unit) + let left xx = X.(select1 F.left1 F.left2 F.left3 xx >>= to_unit) + let saw yy xx = X.(select2 F.saw1 F.saw2 F.saw3 yy xx >>= to_unit) + let marriedto yy xx = X.(F.marriedto yy xx >>= to_unit) + let kisses yy xx = X.(select2 F.kisses1 F.kisses2 F.kisses3 yy xx >>= to_unit) + let loves yy xx = X.(select2 F.loves1 F.loves2 F.loves3 yy xx >>= to_unit) + let thinks pp xx = failwith "Unimplemented" + let maybe (body : sent) : sent = + let (yy : S.store -> Y.env -> (unit * S.store) list) = fun s w -> + let body_int = List.map (fun w' -> not @@ List.is_null @@ X.run (letw w' body) s w) modal_domain in + if any_truths body_int then [(),s] else [] in + Obj.magic yy +end (* Sem6c *) + +(* Sem6c seems adequate for the phenomena GSV are examining, and is substantially simpler than their own semantics. Sem6c doesn't have their "pegs" and complex two-stage function from vars to referents. + Next we develop some semantics that are closer to their actual presentation. *) + +(* This develops Sem5c using in part the strategies from Sem1b. *) +module Sem5e = struct + let dynamic = true + let extensional = true + + (* Let a topic be sequence of entities introduced into conversation (GSV's pegs -> entities, with pegs construed as positions in the sequence). + Then let store = var -> int (that is, position in the topic) + Then we can use monad LS', with box type = store -> ['a],store + And sentence meanings are Kleisli arrows: topic -> box(topic). The list component + in the type captures indeterminacy in what objects are being discussed (introduced + by quantifiers). Truths (relative to a initial store and topic) result in + non-empty topic lists; falsehoods in empty ones. + *) + type topic = entity list + let topic0 = [] + module X = LS' + type noun = (topic -> entity) X.t + type sent = topic -> topic X.t + let run (k : sent) : bool = X.(not (List.is_null (fst (run (k topic0) env0)))) + (* lift an 'a list to a single 'a X.t *) + let mids (xs : 'a list) : 'a X.t = let rec aux xx = function [] -> xx | x::xs -> aux X.(xx ++ mid x) xs in aux X.mzero xs + let get_nth n topic = try List.nth topic n with List.Short_list -> failwith ("can't get item "^string_of_int n^" of "^List.string_of_list string_of_entity topic) + let getx : noun = X.(gets (lookup 'x') >>= fun n -> mid (get_nth n)) + let gety : noun = X.(gets (lookup 'y') >>= fun n -> mid (get_nth n)) + let getz : noun = X.(gets (lookup 'z') >>= fun n -> mid (get_nth n)) + let let_ c (n : int) (body : sent) : sent = fun top -> X.(modify (insert c n) >> (body top)) +(* + let lookup_string sought env top = try string_of_entity (List.nth top (env sought)) with Not_found -> "*" | List.Short_list -> "#" + let print_lookup sought env top = print_string (lookup_string sought env top) + let peek msg top = X.(get >>= fun s -> begin print_string msg; print_string ": x="; print_lookup 'x' s top; print_string ", y="; print_lookup 'y' s top; print_string ", z="; print_lookup 'z' s top; print_newline (); mid top end) +*) + + let (~~~) (k : sent) : sent = fun top -> + let yy : S'.store -> topic list * S'.store = fun s -> if List.is_null (fst (X.run (k top) s)) then ([top],s) else ([],s) in + Obj.magic yy (* this is an identity function that changes the type of yy to a topic X.t *) + let (&&&) k j = X.(k >=> j) + let (|||) k j = ~~~ (~~~ k &&& ~~~ j) (* TODO how about (k >>> j) >>> j *) + let (>>>) k j = X.(~~~ (k >=> ~~~ j)) + + let some c (body : sent) : sent = fun top -> + let n = length top in + let aux ent = X.(let_ c n body) (List.snoc top ent) in + let domain' = List.map aux domain in + X.join (mids domain') + + let every c (body : sent) = ~~~ (some c (~~~ body)) + +(* TODO + let some c body = X.(mids domain >>= fun x -> modify (insert c x) body >>= guard >> mid x) + let every c body = X.(let xx = let_ c (mids domain) body in list_map (fun xs -> if all_truths xs then xs else []) xx) +*) + + module F = Facts(X) + let mapply' (ff : noun) (top : topic) : entity X.t = X.(map (fun f -> f top) ff) + let wrap name = X.(mid (const name)) + let wrap1 f xx = fun top -> X.(f (mapply' xx top) >>= fun b -> if b then mid top else mzero) + let wrap2 f xx yy = fun top -> X.(f (mapply' xx top) (mapply' yy top) >>= fun b -> if b then mid top else mzero) + let ann = wrap Ann let bill = wrap Bill let carol = wrap Carol let dave = wrap Dave let ella = wrap Ella let frank = wrap Frank + let (===) (xx : noun) (yy : noun) : sent = wrap2 X.(map2 (=)) xx yy + let male (xx : noun) : sent = wrap1 F.male xx + let female xx = wrap1 F.female xx + let single xx = wrap1 F.single xx + let left xx = wrap1 F.left1 xx + let marriedto yy xx = wrap2 F.marriedto yy xx + let saw yy xx = wrap2 F.saw1 yy xx + let kisses yy xx = wrap2 F.kisses1 yy xx + let loves yy xx = wrap2 F.loves1 yy xx + let thinks pp xx = fun top -> failwith "Unimplemented" + let maybe pp = fun top -> failwith "Unimplemented" +end (* Sem5e *) + +(* Add intensionality to Sem5e *) +module Sem6e = struct + let dynamic = true + let extensional = false + + type topic = entity list + let topic0 = [] + module X = LS'Y + type noun = (topic -> entity) X.t + type sent = topic -> topic X.t + let run (k : sent) : bool = X.(not (List.is_null (fst (run (k topic0) env0 Actual)))) + (* lift an 'a list to a single 'a X.t *) + let mids (xs : 'a list) : 'a X.t = let rec aux xx = function [] -> xx | x::xs -> aux X.(xx ++ mid x) xs in aux X.mzero xs + let get_nth n topic = try List.nth topic n with List.Short_list -> failwith ("can't get item "^string_of_int n^" of "^List.string_of_list string_of_entity topic) + let getx : noun = X.(gets (lookup 'x') >>= fun n -> mid (get_nth n)) + let gety : noun = X.(gets (lookup 'y') >>= fun n -> mid (get_nth n)) + let getz : noun = X.(gets (lookup 'z') >>= fun n -> mid (get_nth n)) + let getw = X.(ask) (* get world from the underlying Y monad *) + (* select an intranstive verb based on the world *) + let select1 f1 f2 f3 xx = X.(getw >>= fun w -> (if w = Actual then f1 else if w = Other then f2 else f3) xx) + (* select a transitive verb based on the world *) + let select2 f1 f2 f3 yy xx = X.(getw >>= fun w -> (if w = Actual then f1 else if w = Other then f2 else f3) yy xx) + let let_ c (n : int) (body : sent) : sent = fun top -> X.(modify (insert c n) >> (body top)) + let letw world (body : sent) : sent = fun top -> X.(shift (fun _ -> world) (body top)) (* shift the "env" of the underlying Y monad *) + + let (~~~) (k : sent) : sent = fun top -> + let yy : S'.store -> Y.env -> topic list * S'.store = fun s w -> if List.is_null (fst (X.run (k top) s w)) then ([top],s) else ([],s) in + Obj.magic yy (* this is an identity function that changes the type of yy to a topic X.t *) + let (&&&) k j = X.(k >=> j) + let (|||) k j = ~~~ (~~~ k &&& ~~~ j) + let (>>>) k j = X.(~~~ (k >=> ~~~ j)) + + let some c (body : sent) : sent = fun top -> + let n = length top in + let aux ent = X.(let_ c n body) (List.snoc top ent) in + let domain' = List.map aux domain in + X.join (mids domain') + + let every c (body : sent) = ~~~ (some c (~~~ body)) + + module F = Facts(X) + let mapply' (ff : noun) (top : topic) : entity X.t = X.(map (fun f -> f top) ff) + let wrap name = X.(mid (const name)) + let wrap1 f xx = fun top -> X.(f (mapply' xx top) >>= fun b -> if b then mid top else mzero) + let wrap2 f xx yy = fun top -> X.(f (mapply' xx top) (mapply' yy top) >>= fun b -> if b then mid top else mzero) + let ann = wrap Ann let bill = wrap Bill let carol = wrap Carol let dave = wrap Dave let ella = wrap Ella let frank = wrap Frank + let (===) (xx : noun) (yy : noun) : sent = wrap2 X.(map2 (=)) xx yy + let male (xx : noun) : sent = wrap1 F.male xx + let female xx = wrap1 F.female xx + let single xx = wrap1 F.single xx + let left xx = wrap1 (select1 F.left1 F.left2 F.left3) xx + let marriedto yy xx = wrap2 F.marriedto yy xx + let saw yy xx = wrap2 (select2 F.saw1 F.saw2 F.saw3) yy xx + let kisses yy xx = wrap2 (select2 F.kisses1 F.kisses2 F.kisses3) yy xx + let loves yy xx = wrap2 (select2 F.loves1 F.loves2 F.loves3) yy xx + let thinks pp xx = failwith "Unimplemented" + let maybe (body : sent) : sent = fun top -> + let (yy : S'.store -> Y.env -> topic list * S'.store) = fun s w -> + let body_int = List.map (fun w' -> not @@ List.is_null @@ fst @@ X.run (letw w' body top) s w) modal_domain in + if any_truths body_int then [top],s else [],s in + Obj.magic yy +end (* Sem6e *) + +module TestAll = struct + print_endline "\nTesting Sem1a";; + module T1a = Test(Sem1a);; + print_endline "\nTesting Sem1b";; + module T1b = Test(Sem1b);; + print_endline "\nTesting Sem2a";; + module T2a = Test(Sem2a);; + print_endline "\nTesting Sem2c";; + module T2c = Test(Sem2c);; + print_endline "\nTesting Sem3a";; + module T3a = Test(Sem3a);; + print_endline "\nTesting Sem3c";; + module T3c = Test(Sem3c);; + print_endline "\nTesting Sem5c";; + module T5c = Test(Sem5c);; + print_endline "\nTesting Sem5e";; + module T5e = Test(Sem5e);; + print_endline "\nTesting Sem6c";; + module T6c = Test(Sem6c);; + print_endline "\nTesting Sem6e";; + module T6e = Test(Sem6e);; + print_newline () +end + +(* + One can't test the broken vase case by comparing the _truth_ of any sentences. + The difference is in whether the sentences have meanings that are "supported by" + the same informtation states. Compare in our model: + (i) Someone kissed me. She might have stayed. + and: + (ii) Someone who might have stayed kissed me. + Recall that in our model Ann leaves in every world, but Carol stays in some (non-actual) + world. If my background information settles that I was kissed by either Ann or Carol, + then I'm in a position to assert (i), since after the first clause it's left open + that the referent be either woman. But it doesn't put me in a position to assert (ii), + since that implies I was kissed by Carol. So far as truth-value goes, + if Carol kissed me both sentences are true, and if Ann did then both sentences are false. +*) + diff --git a/index.mdwn b/index.mdwn index 5e1c25da..00082462 100644 --- a/index.mdwn +++ b/index.mdwn @@ -167,7 +167,7 @@ Practical advice for working with OCaml and/or Haskell (will be posted someday); (**Week 9**) Thursday April 2 -> Updated notes on [[Installing and Using the Juli8 Libraries|/juli8]] on Sun 5 April. Continued to fix some bugs and improve the monad transformers. Latest version posted Tuesday evening, 7 April: [[v1.5|/code/Juli8-v1.5.tgz]]. +> Updated notes on [[Installing and Using the Juli8 Libraries|/juli8]] on Sun 5 April. Continued to fix some bugs and improve the monad transformers. Latest version posted Monday evening, 13 April: [[v1.6|/code/Juli8-v1.6.tgz]]. This version is needed to run the GSV.ml code. -- 2.11.0