This web page contains an archive of e-mail concerning issues about time and causality and their relationship to an ontology of processes. The starting point for this discussion was a question about methods for representing processes in logic. One suggestion was to use the Process Specification Language (PSL), but John Sowa raised a doubt about whether the PSL assumption of absolute time was sufficiently general to represent distributed processes. As an alternative, Sowa suggested Petri nets, which he used as a basis for representing processes in the book Knowledge Representation. Following is the list of e-mail notes:
In June 2000, a web site was set up to archive the e-mail messages for the IEEE discussions about a standard upper ontology. See that site for messages after that date.
Date: Tue, 23 May 2000 15:31:35 -0400 (EDT)
From: "John F. Sowa" <sowa@west.poly.edu>
Subject: Representing processes in PSL
Following is a note that I sent to the CG list in response to some discussion about using the PSL axioms and definitions for representing processes. As much as I like precise axioms and definitions expressed in logic, I must admit that I cannot recommend PSL because of some fundamental flaws in their ontology. I'm circulating this note to the ontology mailing list because I think that point should be discussed more widely. John Sowa ----------------------------------------------------------------------- For a general theory of processes and their representation in any version of logic, I would recommend Chapter 4 of my book _Knowledge Representation_. For a brief summary of the ontology of processes used in that book, see http://www.bestweb.net/~sowa/ontology/process.htm On that web page, I also summarize the ontology of processes used by Erik Sandewall in his book, _Features and Fluents_ (Clarendon Press, Oxford, 1994). In my book, I use Petri nets as the basic notation for representing discrete processes and show how to translate Petri nets to and from logic represented in either predicate calculus or CGs. I would strongly recommend the study of Petri nets as the starting point for anyone who is planning to represent discrete processes of any kind and use them as a basis for specifications, simulations, reasoning, etc. It's not necessary to use Petri nets in the final representation, but they are probably the best tool for teaching people how to think correctly about interacting discrete processes. Interacting continuous processes are, as they say, a whole 'nuther ball game, which quickly leads to chaos (both literally and figuratively). I would also like to comment on the suggestion for using the Process Specification Language (PSL): http://www.nist.gov/psl/ The fundamental reason why I don't recommend PSL is that it assumes the speed of light is infinite. The limitations of PSL begin with the first two axioms: 1. Axiom 1. The before relation only holds between timepoints. 2. Axiom 2. The before relation is a total ordering. The basic problem with Axiom 1 is that a timepoint is a fiction that can never be measured or represented precisely. The basic problem with Axiom 2 is that it is false in the real world and false in any application that has interacting processes occurring at different places. In the real world, we have to deal with the finite speed of light, which makes it impossible to conceive of a timepoint that is simultaneously defined at any two places that are separated by any reasonable distance. The notion of reasonable depends on your application. If your clocks are ticking at nanosecond intervals, you can't expect any two processes that are a foot apart to be synchronized. If your processes include multiple computers interacting via TCP/IP, you have to deal with the fact that most of the computers in the world have clocks that some user set from his or her wristwatch. You can go down the list of PSL axioms and definitions and find similar problems with almost all of them; e.g., Definition 1. One activity-occurrence is the successor of another if and only if the first activity-occurrence is earlier and there does not exist any other activity-occurrence between them. The successor relation is one that a revised and improved version of PSL should use as a starting primitive. Then earlier and later can be defined in terms of successor. The notion of time should not be introduced until after the more fundamental notion of a clock has been defined. Time can then be defined as the count of ticks by some clock, and no two clocks can be assumed to tell the same time unless they have been explicitly synchronized, which in itself is a nontrivial task. I'm sorry to be so negative about PSL, because the developers are smart people who did a lot of things right. I especially approve of their using logic and rigorous definitions all the way through. But using logic doesn't help if the underlying ontology is wrong. The PSL documentation says that the designers applied PSL to various examples and scenarios. That is certainly a useful test, but they forgot that the speed of light is a fundamental constant. That fact might not have been relevant to their examples, but it is fundamental to everything that deals with messages, ranging from circuit design to the Internet and even the Global Positioning System. I would never travel in an airplane or even a high-speed train that had been designed with PSL. John Sowa
Date: Tue, 23 May 2000 16:21:33 -0400
From: Michael Gruninger <mudcat@eil.utoronto.ca>
Subject: Re: Representing processes in PSL
Let the fireworks begin ... John F. Sowa wrote: > I would strongly recommend the study of Petri nets as the starting > point for anyone who is planning to represent discrete processes > of any kind and use them as a basis for specifications, simulations, > reasoning, etc. It's not necessary to use Petri nets in the final > representation, but they are probably the best tool for teaching > people how to think correctly about interacting discrete processes. > Interacting continuous processes are, as they say, a whole 'nuther ball > game, which quickly leads to chaos (both literally and figuratively). Of course there are many alternatives for choosing a formalism to represent processes. All have advantages and disadvantages, but one of the primary objectives is to axiomatize these different approaches within the same language (e.g. KIF) and then compare how the models of these axiomatizations are related to each other and to different intuitions that people have about processes. Perhaps you could supply explicit axiomatizations of the approaches that you mention so that we can have a rational objective discussion based on theories and models. > I would also like to comment on the suggestion for using the > Process Specification Language (PSL): > > http://www.nist.gov/psl/ PSL is organized modularly as a partially ordered set of extensions of PSL-Core (which contains the two axioms that you refer to). The idea is that not everyone needs to share all extensions, but that minimally, people will share PSL-Core. The axiomatization of PSL-Core is finished; we have proven that this theory is consistent, and we have a complete characterization of the models of this theory. The new version of the next set of extensions will be completed in June; these will also include proofs of consistency and characterizations of models (see methodological note at the bottom of this message). > The fundamental reason why I don't recommend PSL is that it assumes > the speed of light is infinite. The limitations of PSL begin with > the first two axioms: > > 1. Axiom 1. The before relation only holds between timepoints. > > 2. Axiom 2. The before relation is a total ordering. > > The basic problem with Axiom 1 is that a timepoint is a fiction that > can never be measured or represented precisely. The basic problem > with Axiom 2 is that it is false in the real world and false in any > application that has interacting processes occurring at different places. I'm not sure I see the point of these objections. Such an axiomatization of time is quite common; for example, see Hayes' theories of time. In particular, Pat discusses the relationships between ontologies of time that use points vs intervals. How is the total ordering of timepoints false in the real world? The Julian date 12345678 is before the Julian date 12345679, which is before Julian date 12345680; all of these timepoints are comparable to each other. This has nothing to do with interacting processes. Two processes can be concurrent (they occur at the same time) or they might not occur at the same time. > In the real world, we have to deal with the finite speed of light, which > makes it impossible to conceive of a timepoint that is simultaneously > defined at any two places that are separated by any reasonable distance. Whether I'm on Mars and you're on Venus, there is still a timepoint (say Julian date 12345678) and I can perform an activity at the same time as you. Of course, how our two activities interact with each other is a different matter, which would need to be covered by some extension of PSL-Core. > The notion of reasonable depends on your application. If your clocks > are ticking at nanosecond intervals, you can't expect any two processes > that are a foot apart to be synchronized. If your processes include > multiple computers interacting via TCP/IP, you have to deal with the > fact that most of the computers in the world have clocks that some user > set from his or her wristwatch. Again, synchronized processes are not explicitly axiomatized within PSL-Core; these must be covered by some extension. > You can go down the list of PSL axioms and definitions and find similar > problems with almost all of them; e.g., > > Definition 1. One activity-occurrence is the successor of another > if and only if the first activity-occurrence is earlier and there > does not exist any other activity-occurrence between them. Perhaps this discussion could start over again a little more constructively, and begin with some of the intuitions that you have about processes, and then examine how these intuitions are not addressed by PSL. Your intuitions about the before relation are an example. I would also like to point out some of the underlying methodology used in the axiomatization of PSL. It serves as a useful framework for discussion and evaluation of theories. I will send this out in a separate message to keep the discussions distinct. Michael GruningerDate: Tue, 23 May 2000 20:12:13 -0700 (PDT)
My initial reaction to John's criticisms of PSL is that there is a vanishingly small likelihood that it will ever matter. On the other hand, he suggests interesting real world applications for which real problems might exist. How to know? Perhaps the real issue is to be clear about what the implications of the assumptions are, and to ascertain under what conditions they matter. This may be a perfect example of why there will never be a single global ontology that suits all. For PSL may be fine for an enormous range of applications, in which case it is 'right' for those apps. For other apps, other assumptions will be needed. One might ask: could one 'fix' PSL in such a way that it would satisfy John's objections and also be suitable for the intended purposes of PSL? Or would there be something traded off? What might that be? Any PSL developers out there care to comment? Mike
Date: Tue, 23 May 2000 23:32:33 -0500
From: Chris Menzel <cmenzel@philebus.tamu.edu>
Subject: Re: Representing processes in PSL
Hi John. You wrote: > The fundamental reason why I don't recommend PSL is that it assumes > the speed of light is infinite. The limitations of PSL begin with > the first two axioms: > > 1. Axiom 1. The before relation only holds between timepoints. > > 2. Axiom 2. The before relation is a total ordering. > > The basic problem with Axiom 1 is that a timepoint is a fiction that > can never be measured or represented precisely. The basic problem > with Axiom 2 is that it is false in the real world and false in any > application that has interacting processes occurring at different > places. > > In the real world, we have to deal with the finite speed of light, which > makes it impossible to conceive of a timepoint that is simultaneously > defined at any two places that are separated by any reasonable distance. I think perhaps your comments do force a few issues that PSL has not made particularly clear. One of the central motivations behind PSL has been to provide a general process representation to support reuse and translation among process-oriented applications like workflow and simulation. The bulk of these applications are designed for discrete manufacturing processes typically involving medium-sized slow-moving dry goods, and they presuppose a rather simple view of time, one in which subtleties -- critical, of course, in some contexts -- like the finite speed of light simply do not come into play. The PSL ontology of time is, quite purposely, a somewhat simple, commonsense one. Timepoints may indeed be ontological fictions when we don our philosophers' caps and ask what time is REALLY, but they are a central part of a commonsense ontology of time. They are, most prominently, the denotations of timestamps and context-sensitive names like "noon", and we reason about them with great facility. Axioms 1 and 2 capture two elements of our talk about them. For applications that require precision within nanoseconds, where relativistic effects become relevant, PSL is probably not your ontology. Fine! Use another. Your comments seem to suggest that there is One True Temporal Ontology for all process-oriented applications. But perhaps we should rather follow Carnap and let a hundred flowers bloom, and pick the appropriate ontology for the application and context at hand. Regarding your counterexample about processes occurring at different places, I'm not sure I get it. Perhaps you could be more specific. > If your processes include multiple computers interacting via TCP/IP, > you have to deal with the fact that most of the computers in the world > have clocks that some user set from his or her wristwatch. And if I have processes involving them where timing and sequencing is important, I'd damn well better have them synchronized (as much as possible) via xntpd or the like. > You can go down the list of PSL axioms and definitions and find > similar problems with almost all of them; e.g., > > Definition 1. One activity-occurrence is the successor of another > if and only if the first activity-occurrence is earlier and there > does not exist any other activity-occurrence between them. > > The successor relation is one that a revised and improved version of > PSL should use as a starting primitive. Proposals welcome. > Then earlier and later can be defined in terms of successor. The > notion of time should not be introduced until after the more > fundamental notion of a clock has been defined. Time can then be > defined as the count of ticks by some clock, and no two clocks can be > assumed to tell the same time unless they have been explicitly > synchronized, which in itself is a nontrivial task. Interesting points, but you seem to be running together conceptual issues with practical issues. It may be nontrivial to synchronize relevant clocks, but the very fact that we have to do so when timing is relevant attests to the fact that before and after seem conceptually prior. > I'm sorry to be so negative about PSL, because the developers are > smart people who did a lot of things right. The PSLers think you're pretty smart too, John! ;-) > I especially approve of their using logic and rigorous definitions all > the way through. But using logic doesn't help if the underlying > ontology is wrong. Au contraire, it helps you to see precisely where the ontology goes wrong, if it does, and invites equally clear alternatives. Be that as it may, let a hundred flowers bloom, John -- PSL ought to do the same and give your stuff a closer look in this regard as well. > The PSL documentation says that the designers applied PSL to various > examples and scenarios. That is certainly a useful test, but they > forgot that the speed of light is a fundamental constant. Nope, they are, as you note, a smart crew who know a lot of physics, and the fact never escaped them. It simply was not relevant to the types of manufacturing scenarios they were dealing with. > That fact might not have been relevant to their examples, ... And isn't that precisely the point? > ...but it is fundamental to everything that deals with messages, > ranging from circuit design to the Internet and even the Global > Positioning System. I am skeptical that the situation is as dire as you suggest, but your critique here should not be taken lightly. One can well imagine, for example, more sophisticated modifications of the axioms that take the existing axioms to restricted to contexts where relativistic effects are negligible. Or something like that. In any case, I'm sure PSL will take the issues you raise to heart. Regards, -chris Christopher Menzel # web: philebus.tamu.edu/~cmenzel Philosophy, Texas A&M University # net: chris.menzel@tamu.edu College Station, TX 77843-4237 # vox: (409) 845-8764
Date: Wed, 24 May 2000 22:43:57 -0400 (EDT)
From: "John F. Sowa" <sowa@west.poly.edu>
Subject: PSL
Dear Mike G., Mike U., Chris M., et al., I realize that a lot of work has gone into the PSL design, and I believe that most of it can be salvaged. My major complaint is with the core, which should not have any simplifying assumptions built into it. Although PSL may have been intended for manufacturing applications, if it proves successful (as I hope that some revised version of PSL may become), it will be used much more widely, and it may be built into applications for which the simplifying assumptions are invalid. And please note that I did not give any examples of things traveling at high speed. All those examples depend on events at a distance, which may be as short as one foot. As an example of the kinds of problems that might arise, there was a story about a professor of fluid mechanics who "proved" that nothing could move through air at a speed faster than sound. It turned out that he started with some simplified equations that assumed all speeds were much less than the speed of sound. As another example, some friends of mine were writing programs for processing email. And naturally, they used the UTC time stamps for sorting them. But they discovered many inconsistencies where people were responding to messages that hadn't yet been written. The clocks on different computers in the same building might vary by several minutes. Axiom 2, which may be true for slow-moving objects whose time is measured according to some standard atomic clock, is unreliable for any practical application, including manufacturing. The axiomatization for processes that I would recommend is the one that is used for Petri nets. It is much simpler and far more primitive than the PSL core. Furthermore, it already supports concurrent processes, synchronization, and consistent, realistic rules for message passing among processes at any distance whatever or traveling at any speed whatever. There has been 35 years of experience in axiomatizing, implementing, and applying Petri nets. See Chapter 4 of my KR book for a survey; if you want more, go to Google and type "Petri net". Another axiomatization that I would recommend is Erik Sandewall's in his book _Features and Fluents_. For a brief summary of his distinctions, see the summary on my web site: http://www.bestweb.net/~sowa/ontology/process.htm The product of Sandewall's distinctions leads to 2304 categories of processes, of which 1152 are continuous and the other 1152 can be represented or simulated by Petri nets. Bottom line: I do not recommend that you throw away all of PSL. Instead, I recommend that you replace the PSL core axioms with a simpler set of axioms that define the same process model as Petri nets. In terms of those axioms, you can define the notion of a clock, and from that, the notion of time. This would also allow the axioms to support the very realistic case in which different clocks are not synchronized. As a result, the current PSL core would be available as a special case, but the core axioms would also support more general models, including the discrete subset of Sandewall's ontology or my ontology, and a whole lot more. Following are some comments on your comments. John Sowa _________________________________________________________________________ From Mike Gruninger, >PSL is organized modularly as a partially ordered set of extensions >of PSL-Core (which contains the two axioms that you refer to). The idea >is that not everyone needs to share all extensions, but that minimally, >people will share PSL-Core. I agree with these assumptions. My primary objection is that the PSL core is too specialized. It does not support most of Sandewall's 1152 categories of discrete processes, but a simpler core based on a Petri net model for processes would support them. >The axiomatization of PSL-Core is finished; we have proven that this >theory is consistent, and we have a complete characterization of the >models of this theory. That's fine. But there is a great depth of experience in using and formalizing Petri nets. They are simpler and more general than the PSL core, they support synchronization and other features that haven't yet been included in PSL, and they can be used to define the current PSL core as a special case. >I'm not sure I see the point of these objections. Such an axiomatization >of time is quite common; for example, see Hayes' theories of time. >In particular, Pat discusses the relationships between ontologies of >time that use points vs intervals. I prefer intervals because they are physically more realistic. But Petri nets can be used to define either version of time. My major objection is to the assumption that the "before" relation is totally ordered. At best, it should be partially ordered. >How is the total ordering of timepoints false in the real world? >The Julian date 12345678 is before the Julian date 12345679... For a single point p in space, you can define a total ordering of time at that point. But for a point q at a distance d from p, the ordering is undefined for timepoints separated by any interval less than d/c, where c is the speed of light. For computer design, those intervals become significant even for communications between the CPU and RAM. And those intervals are humanly perceptible for telephone conversations that are relayed by a geosynchronous satelite. (That is why telephone companies are still laying undersea cables.) >Of course, how our two activities interact with each other is a >different matter, which would need to be covered by some extension >of PSL-Core.... >Again, synchronized processes are not explicitly axiomatized within >PSL-Core; these must be covered by some extension. Yes, that is why I recommend the Petri net model of processes. It is simpler than the current PSL core, and it already supports all the primitives needed for synchronization, locking, and other interactions. From Mike Uschold, >Perhaps the real issue is to be clear about what the implications of >the assumptions are, and to ascertain under what conditions they matter. >This may be a perfect example of why there will never be a single global >ontology that suits all. For PSL may be fine for an enormous range of >applications, in which case it is 'right' for those apps. For other apps, >other assumptions will be needed. I agree. >One might ask: could one 'fix' PSL in such a way that it would satisfy >John's objections and also be suitable for the intended purposes of PSL? >Or would there be something traded off? What might that be? The simplest fix would be to "jack up" the current PSL core by defining it on top of a simpler ontology, such as the Petri net model. Then all the applications and tools that use the current PSL core could be used as is, but future applications could be built on a model that supports synchronization, inaccurate clocks, message passing across significant distances, etc. From Chris Menzel, >The bulk of these applications are designed for discrete manufacturing >processes typically involving medium-sized slow-moving dry goods, and >they presuppose a rather simple view of time... Yes, but if PSL proves to be successful, then people will want to use the tools and techniques for other applications. Even manufacturing, for example, uses computers with e-mail messages sent around the world. >The PSL ontology of time is, quite purposely, a somewhat simple, >commonsense one. Timepoints may indeed be ontological fictions when we >don our philosophers' caps and ask what time is REALLY, but they are >a central part of a commonsense ontology of time. They are, most >prominently, the denotations of timestamps and context-sensitive names >like "noon", and we reason about them with great facility. Commonsense varies widely from one culture to another and changes with every technological advance. The Western concept of time didn't become commonsense until the invention of pendulum-driven clocks. Even more recently, I still remember the first e-mail message I received from Australia that was sent from the "future". And note my example above about the unreliability of time stamps. >For applications that require precision within nanoseconds, where >relativistic effects become relevant, PSL is probably not your ontology. >Fine! Use another. My objections are not based on the fact that the PSL core is too simple, but that it's too complex. As I suggested above and show in my book, you can have a much simpler ontology that does not take time as primitive. >Your comments seem to suggest that there is One True Temporal Ontology >for all process-oriented applications. But perhaps we should rather >follow Carnap and let a hundred flowers bloom, and pick the appropriate >ontology for the application and context at hand. Carnap is a good example. He showed how to define several different notations and axiomatizations for the same application, but then he showed how they could be translated from one to another. The current PSL axioms cannot be translated, salva veritate, to a more general ontology. But a simpler core could be. >And if I have processes involving them where timing and sequencing is >important, I'd damn well better have them synchronized (as much as >possible) via xntpd or the like. That's why I like Petri nets -- they're simpler, and they already allow you to define any synchronization primitives currently in use or any that are likely to be invented in the near future. >Proposals welcome. I would be happy to work with the PSL gang to review proposals or to develop new ones. But as the old saying goes, I'm not free, but I'm reasonable. >.... but you seem to be running together conceptual issues >with practical issues. It may be nontrivial to synchronize relevant >clocks, but the very fact that we have to do so when timing is relevant >attests to the fact that before and after seem conceptually prior. As you know, C. S. Peirce is my favorite philosopher, and the cornerstone of his philosophy is that pragmatic tests are the only reliable way to clarify conceptual issues. And if you look at Einstein's writings about relativity, his methodology was to use Gedanken experiments that took into account the behavior of clocks and the problems of synchronizing them. I agree that before and after are conceptually prior; in fact, they are more primitive than any definition of time. What I object to is taking absolute time as primitive and ignoring the serious practical problems of measuring any version of time. >>.... But using logic doesn't help if the underlying ontology is wrong. >Au contraire, it helps you to see precisely where the ontology goes >wrong, if it does, and invites equally clear alternatives. I agree. In fact, I wouldn't have noticed the problems with PSL if it hadn't been so clearly axiomatized. >I am skeptical that the situation is as dire as you suggest, but your >critique here should not be taken lightly. One can well imagine, for >example, more sophisticated modifications of the axioms that take the >existing axioms to restricted to contexts where relativistic effects >are negligible. Or something like that. That's why I'm recommending a *less sophisticated* ontology. Somewhere in my stack of papers, I have a report by Carl Adam Petri in which he makes the point that Petri nets support a process model that can accommodate relativity and distributed networks without making any assumptions about absolute time or synchronized clocks. John
Date: Thu, 25 May 2000 13:25:00 -0700
From: graham wideman <graham@wideman-one.com>
Subject: Re: PSL
John: I've been following your process ontology discussions with interest, and had a couple of comments. The Relativity/Speed-of-light Thing: It seems that when you state the PSL deficit as a speed-of-light issue, you get responses like: >>where relativistic effects become relevant [...] >>Fine! Use another. But to me it seems that the critical feature is more general than the speed of light, rather the speed of *information propagation* in any scenario where it's customary to not make it explicit but where it actually turns out to matter... and the resulting window of parallel events at each location that's not yet known at the others. If communication is by horse, then the relevant speed is 10-20 mph. Your surprise at "email from the future" is an example caused by propagation far slower than c (though it also involved unsynchronized clocks as well). Speed-of-light *does* matter at human scales As an electrical engineer I'm all too familiar with near-c propagation issues, but generally think of c as not relevant to "everyday" problems. Your telephone example is one place where the problem shows up, partially solvable by shorter communication paths. An initially surprising example I encountered a couple of years ago involved telesurgery: Apparently even info propagation at theoretical maximum causes an unacceptable lag between surgeon's manipulation of controls, and the force and visual feedback that results... even for surgery across the US. I had to do some quick napkin calculations to verify that the scenario really is fundamentally limited by c! Graham --------------------------------------------------- Graham Wideman Resources for programmable diagramming at: http://www.diagramantics.com http://www.wideman-one.com
Date: Thu, 25 May 2000 22:41:53 -0400 (EDT)
From: "John F. Sowa" <sowa@west.poly.edu>
Subject: Re: PSL
Graham, You're right that the fundamental problem is message propagation time. Another example: the concept of time zones never became popular until "high-speed" train travel was introduced in the 19th century. That is one reason why I like Petri nets -- the firing rules for transitions do not depend on a clock, and they automatically accommodate message delays. If you want a clock, you can define one as a Petri net and let it interact with the rest of the net by generating messages. Another reason is that they are so incredibly simple: just a bipartite graph (places and transitions) with tokens on the nodes and a simple firing rule that waits as long as necessary for messages to arrive. And the clincher is that they can model an enormous range of other mechanisms in computer science: finite-state machines, flow charts, PERT charts, token-passing in AI systems, neural networks, Judea Pearl's causal nets, linear logic, and even the Linda operators that are implemented in the Java-based Jini. Petri nets have also been used to define the actions of verbs in natural language processing: the result of linking together the Petri nets for each verb in a story is an executable model of the story. (Of course, you do need to add some additional housekeeping details if you actually want to execute it.) Furthermore, there are lots of tools that simulate Petri nets, display them in action, and compile them into executable code. They have been implemented in running models with thousands of nodes and compiled into C. For more info, type the phrase "Petri net" into your favorite search engine (I prefer Google). And last, but not least, you can draw them with boxes and circles -- they not only look like CGs, but they *are* CGs. John
Date: Fri, 26 May 2000 10:32:22 +0200
From: "Christopher A. Welty" <welty@ladseb.pd.cnr.it>
Subject: Re: Representing processes in PSL
John F. Sowa wrote: >The fundamental reason why I don't recommend PSL is that it assumes >the speed of light is infinite. The limitations of PSL begin with >the first two axioms: > > 1. Axiom 1. The before relation only holds between timepoints. > > 2. Axiom 2. The before relation is a total ordering. > >The basic problem with Axiom 1 is that a timepoint is a fiction that >can never be measured or represented precisely. The basic problem >with Axiom 2 is that it is false in the real world and false in any >application that has interacting processes occurring at different places. I've looked over these arguments. I've found that John Sowa often makes very interesting points and then muddies the water by adding things like "that's why Conceptual Graphs are better". The discussion of Petri Nets is quite irrelevant, you might as well argue about implementing it in Java vs. C++. If Sowa's problems stem from these simple facts above, then clearly using or not using Petri Nets makes no difference. If you choose to represent the speed of light as infinite in a Petri Net, I don't see that you have a solution to the problems raised. I believe the discussion would be far more productive if it stayed at the level of ontological issues. I think Sowa raises two interesting questions that I'm at the moment unsure how to resolve: 1) what goes *wrong* with the infinite speed-of-light assumption. Seems to me we all agree that infinite speed of light is intuitive, but what are the problems this assumption creates - especially for engineered systems. Regardless of whether the assumption is changed in PSL, knowing the limitations up-front is an important part of good design. 2) is a timepoint a fiction, and what problems does this assumption cause. Notice that "axiom 2" (before is a total ordering) has absolutely no problems. The basic "problem" with axiom 2 is axiom 1. The reason axiom 2 doesn't *seem* to hold in the real world is because we don't think of it as holding strictly between timepoints. In the framework of PSL it is perfectly consistent, and I can easily imagine consistent ways of interpreting it for real-world usage. THe other point raised by Sowa that I found poignant was the reference to Sandewall's work. I have not read any of this stuff in depth at all, but surface scans of it look pretty impressive. He seems to have a very well thought-out framework which has been rigorously analyzed. -Chris Christopher A. Welty Professore Visitatore LADSEB-CNR welty@ladseb.pd.cnr.it Corso Stati Uniti, 4 Voice: +39 049 8295783 I-35127 Padova Fax: +39 049 8295763 Italy http://www.cs.vassar.edu/faculty/welty/
Date: Fri, 26 May 2000 13:08:02 -0400
From: Michael Gruninger <mudcat@eil.utoronto.ca>
Subject: Re: Representing processes in PSL
Christopher A. Welty wrote: > I believe the discussion would be far more productive if it stayed at > the level of ontological issues. I agree with this wholeheartedly. Rather than refer to Petri nets themselves, one should refer to the underlying ontology for Petri nets. Of course, PSL should be able to faithfully capture the concepts in such an ontology. > I think Sowa raises two interesting > questions that I'm at the moment unsure how to resolve: > > 1) what goes *wrong* with the infinite speed-of-light assumption. > Seems to me we all agree that infinite speed of light is intuitive, > but what are the problems this assumption creates - especially for > engineered systems. Regardless of whether the assumption is changed > in PSL, knowing the limitations up-front is an important part of good > design. I'm still not sure how to respond to this. Clearly, PSL-Core alone does not address the problems with the propagation of effects, but there is also nothing that prevents a consistent extension of PSL-Core from capturing these intuitions. > 2) is a timepoint a fiction, and what problems does this assumption cause. > > Notice that "axiom 2" (before is a total ordering) has absolutely no > problems. The basic "problem" with axiom 2 is axiom 1. The reason > axiom 2 doesn't *seem* to hold in the real world is because we don't > think of it as holding strictly between timepoints. In the framework > of PSL it is perfectly consistent, and I can easily imagine > consistent ways of interpreting it for real-world usage. Be careful here about the distinction between activities, activity occurrences, and timepoints -- these are all distinct entities. Activities occur at timepoints, so that each activity occurrences have a beginof and an endof timepoint associated with it. This in no way precludes one from defining other ordering relations over activity occurrences, such as partially ordered sets of occurrences. In fact, within extensions of PSL, we currently include three additional ordering relations over activity occurrences. What axiom 2 of PSL-Core says is that the before relation only takes timepoints as arguments. Other ordering relations may take only activity occurrences as arguments. Of course, because of the relationship between activity occurrences and timepoints, any of these other ordering relations will place constraints on the timepoints at which the activity occurs. > The other point raised by Sowa that I found poignant was the > reference to Sandewal's work. I have not read any of this stuff in > depth at all, but surface scans of it look pretty impressive. He > seems to have a very well thought-out framework which has been > rigorously analyzed. I'm quite aware of Sandewall's work; I picked up his book almost the day it arrived in the bookstore. I think that it does provide a nice framework for identifying the relationships among various ontological commitments regarding processes, and the development of PSL should also address the issues he raises. PSL has never been conceived to be the True Process Ontology. Rather, we want to provide an explicitly axiomatized ontology together with a complete characterization of the models of this axiomatization. Hopefully, a formal framework like this can bring all process-related endeavours together so that everyone can share what they have done. Then people can compare their different approaches in a rigorous objective manner, rather than clashing over subjective intuitions. michael
Date: Sat, 27 May 2000 22:34:04 -0400 (EDT)
From: "John F. Sowa" <sowa@west.poly.edu>
Subject: Process ontology based on causality instead of time
In recent notes, Chris Welty and Mike Gruninger asked me to be more
specific (and formal) about the ontology that I propose as an alternative
to the PSL core. For this note, I won't give the detailed axioms because
Petri nets have been formalized many times, usually in highly abstract
terms. Instead, I'll translate the abstract P-net ontology into terms
that can be compared to the PSL ontology.
Informally, you can think of a Petri net as a generalization of a finite
state machine, in which states are called "places", but with the option
of allowing any transition to have any number of input states and any
number of output states. If the number is restricted to 1, you have a
conventional FSM. A general P-net may also have multiple "tokens" in
any state, each of which corresponds to a message that is waiting
to be processed.
Following are the basic primitives in the PSL and PN ontologies:
PSL ontology: Activity types, Activity occurrences, Objects, Time points.
PN ontology: State types, Event types, Messages, Causal links,
Presence of messages in states, Occurrences of Events.
Comparison: A PSL activity type corresponds to a PN sequence of
state types and event types. The PSL before relation
between time points is replaced by causal links, which
take causality as a primitive rather than time. It is
possible to define time in terms of causality, but not
conversely: post hoc does not imply propter hoc.
Following are the basic rules that determine how events occur. Each
of these statements can be (and has been) translated to formal axioms:
1. Associated with each state in a P-net is a proposition p, which
describes that state. The presence of a message in a state
corresponds to one instance of p being true.
Example: A state might represent people waiting at a bus stop.
Each message (P-net token) in that state represents a fact that
one person is waiting there. The total number of messages in that
state corresponds to the number of people waiting for a bus.
2. Each transition in a P-net represents an event type. Each input
link to a transition represents a causal link from one state, whose
proposition represents a necessary condition for the occurrence
of the corresponding event type. The conjunction of all the input
conditions is sufficient for the occurrence of an event of that type.
Example: A P-net transition with two input states might represent
one person getting on a bus. Input state #1 could represent the
presence of a bus, and input state #2 could represent the presence
of a person waiting for a bus. A general P-net could allow any
number of busses in state #1 and any number of people in #2.
3. The firing of a transition is represented by erasing one message
from each of its input states and placing one message in each
of its output states. Each output link represents one effect
that becomes true as the result of the corresponding event.
Example: The transition for a person getting on a bus, which has
two input links, would also have two output links. When the event
occurs (i.e. the transition "fires"), a message for one bus and
a message for one person is erased from the inputs. One output
link would go back to the same input state that represents the bus
(indicating that the bus does not disappear when a person gets on).
The other output link would go to a state whose condition represents
one person on the bus. The net result of the "get on bus" event is
to decrease the number of messages in the "person waiting" state
by one and to increase the number of messages in the "person on bus"
state by one.
That's all there is. These three rules (or their translation to logic)
determine a process model of alternating states and events connected
by causal links. All events depend only on their local input states,
and they only affect their local output states. States and events that
are not directly connected by causal links have no immediate effects
on one another, and they may happen independently of one another.
There is also no built-in notion of time, either local or global.
If you want to define time, you can define a clock with just one
transition and two states. The transition represents one "tick" of
a clock, one state is used to keep the transition cycling forever,
and the other state measures time by the number of messages that
accumulate (similar to my input mailbox). Any number of clocks can be
added to a P-net, but they are not synchronized unless explicit causal
links are added from one to another.
Formally, the version of P-nets I summarize above is isomorphic to
the most widely used and implemented version of linear logic. The
quickest way to axiomatize this ontology is to copy pp. 12-14 and
the prerequisite definitions from Anne Troelstra's book (_Lectures
on Linear Logic_, CSLI, 1992) and do a global change of "sequent"
to "event type".
Following are some comments on the comments by Chris and Mike.
John Sowa
-------------------------------------------------------------------------
Chris Welty wrote,
>I've looked over these arguments. I've found that John Sowa often
>makes very interesting points and then muddies the water by adding
>things like "that's why Conceptual Graphs are better".
I'm sorry that I mentioned anything about CGs, because I don't want
to confuse the issues with talk about notation. I have been trying to
address fundamental semantic issues that can be represented equally
well in Petri nets, linear logic, or many other notations.
>The discussion of Petri Nets is quite irrelevant, you might as well
>argue about implementing it in Java vs. C++. If Sowa's problems stem
>from these simple facts above, then clearly using or not using Petri
>Nets makes no difference. If you choose to represent the speed of
>light as infinite in a Petri Net, I don't see that you have a
>solution to the problems raised.
No, that misses the point I was trying to make. The basic issue is
that causality is more primitive than time. I was not recommending
Petri nets as a notation (although I have found them to be an excellent
pedagogical tool for teaching students how to think about processes)
but as a system for modeling processes that doesn't require time as
a primitive. You don't represent time at all in a Petri net (unless
you choose to define a clock, but that choice is optional).
>I believe the discussion would be far more productive if it stayed at
>the level of ontological issues. I think Sowa raises two interesting
>questions that I'm at the moment unsure how to resolve:
Yes, and the fundamental point that I am trying to make is that
causality is conceptually and ontologically prior to time.
>Notice that "axiom 2" (before is a total ordering) has absolutely no
>problems. The basic "problem" with axiom 2 is axiom 1. The reason
>axiom 2 doesn't *seem* to hold in the real world is because we don't
>think of it as holding strictly between timepoints.
No. Time cannot be represented as a total ordering except at a single
fixed point in space. As I said in my earlier notes, for any two points
p1 and p2 separated by a distance d, it is meaningless to say whether
the time t1 at p1 is before or after t2 at p2 when the interval |t1 - t2|
is less than d/c.
In fact, causality depends on the speed of information propagation,
which may often be much slower than the speed of light. For practical
purposes, if the speed is v (say 20 mph if your messages are relayed
by pony express), then for any points separated by distance d, events
at those points cannot have any causal effect on one another in any
time interval less than d/v. If you're trying to solve a crime,
for example, the limit on causal effects helps limit your search.
>The other point raised by Sowa that I found poignant was the
>reference to Sandewall's work. I have not read any of this stuff in
>depth at all, but surface scans of it look pretty impressive. He
>seems to have a very well thought-out framework which has been
>rigorously analyzed.
I agree that Sandewall's work is valuable, and all 1152 of his
categories of discrete processes can be represented by Petri nets.
But the total ordering imposed by PSL Axiom 2 is unnecessary for any
of those categories. Sandewall's methods of reasoning depend primarily
on causality, not on time differences. In fact, if you base reasoning
on absolute time rather than causal links, it becomes less efficient,
because you increase the number of spurious events to consider.
Mike Gruninger wrote,
>Rather than refer to Petri nets themselves, one should
>refer to the underlying ontology for Petri nets.
I agree wholeheartedly.
>Of course, PSL should
>be able to faithfully capture the concepts in such an ontology.
Unfortunately, it can't. Petri nets make no assumption about time,
they are by design relativistically invariant, and they don't
presuppose any kind of synchronized clocks or global time. Furthermore,
the causal links in the PN ontology imply a partial ordering, but a
simple before and after relation does not imply cause.
>I'm still not sure how to respond to this. Clearly, PSL-Core alone does
>not address the problems with the propagation of effects, but there
>is also nothing that prevents a consistent extension of PSL-Core from
>capturing these intuitions.
The basic problem, as I said before, is that PSL-core is based on the
wrong primitives. By taking causal links as primitive, the PN ontology
automatically accounts for the propagation of effects, and it can be
used to define time for the PSL axioms as a special case.
>Be careful here about the distinction between activities, activity
>occurrences, and timepoints -- these are all distinct entities.
>Activities occur at timepoints, so that each activity occurrence has
>a beginof and an endof timepoint associated with it.
The distinction between an event type and an event occurrence is clearly
defined in the PN ontology. Begining and ending points occur when the
messages are received or generated (and the causal effects are taken
into account).
>This in no way precludes one from defining other ordering relations over
>activity occurrences, such as partially ordered sets of occurrences.
>In fact, within extensions of PSL, we currently include three additional
>ordering relations over activity occurrences.
You can define time in terms of causality, but you can't define the
partial ordering imposed by cause and effect in terms of time.
>PSL has never been conceived to be the True Process Ontology. Rather,
>we want to provide an explicitly axiomatized ontology together with
>a complete characterization of the models of this axiomatization.
That's fine. And I don't regard the PN ontology as the One True Ontology.
Both PN and PSL are discrete approximations to the more fundamental
continuous ontology. My basic claim is that the PSL-core can be defined
as a special case of the PN ontology by throwing away causal information.
The converse is not possible.
>Hopefully, a formal framework like this can bring all process-related
>endeavours together so that everyone can share what they have done. Then
>people can compare their different approaches in a rigorous objective
>manner, rather than clashing over subjective intuitions.
I agree.
Date: Mon, 29 May 2000 16:17:49 +0200
From: Chris Partridge <Chris_Partridge@csi.com>
Subject: RE: Representing processes in PSL
Michael Gruninger wrote:
"PSL has never been conceived to be the True Process Ontology. Rather, we
want to provide an explicitly axiomatized ontology together with a
complete characterization of the models of this axiomatization. Hopefully,
a formal framework like this can bring all process-related endeavours
together so that everyone can share what they have done. Then people can
compare their different approaches in a rigorous objective manner ..."
Wouldn't part of what needs to be compared be the different fundamental
ontological commitments - and the results of making those ontological
commitments?
So the issue of whether as John Sowa says "causality is conceptually and
ontologically prior to time" would need to come into this. This does apply
to "medium-sized slow-moving dry goods" as the following example shows.
Consider the process of getting undressed. We could say:
(1) You should take your trousers off before taking off your underwear,
Or
(2) You should make sure the end-timepoint of your taking-your-trousers-off
activity is before the start-timepoint of the
taking-off-your-underwear-activity.
(On the face of it, this example seems biased against PSL - but that is not
my intention)
These seem to have different ontological commitments (the second sentence
seems to be committed to timepoints, whereas the first does not) and I
suspect, interpreted in the right way, imply different ontologies. Sentence
(2) seems to suggest that time is substantial rather than relational (which
is one interpretation of John Sowa's point). One can see the nature of the
difference between the two by considering a time travel experiment where you
take off your trousers then travel back in time and take off your underwear.
In this case the first sentence is true, the second false.
There are a number of fundamental ontological issues here. Is time (or
space-time) ontologically dependent upon causality (as John suggests)? This
is related to, but not the same as, is time (or space-time) substantial? If
it is substantial, as some people believe, then John Sowa's claim that
"causality is conceptually and ontologically prior to time" is incorrect. It
would then better be expressed as that "causality is more relevant to
processes than time".
Unfortunately I suspect that many of these fundamental ontological
commitments are not as easy to resolve empirically as the relativeness of
space and time. For example, I seem to recall that whether space-time is
absolute or relative is an open empirical issue.
But I am reasonably sure that making clear when a formal specification of an
ontology is making a commitment - and what the results of making it are - is
at the very least, helpful. Particularly if you are trying to merge
ontologies - or create a top ontology.
Michael Gruninger wrote:
"This in no way precludes one from defining other ordering relations over
activity occurrences, such as partially ordered sets of occurrences. In fact,
within extensions of PSL, we currently include three additional ordering
relations over activity occurrences."
Though this seems to be a good thing to do, I'm not sure that this is the
point. This could be read as implying that the logical characterisation is
neutral with regard to fundamental ontological commitments. That adding some
stuff somehow includes fundamentally different ontological commitments in
the same ontology. It seems to me that the PSL characterisation has a
natural interpretation with regard to some ontological commitments. In
general, it would be sad if logical characterisations could not somehow
capture fundamental ontological commitments.
It may be a moot point how far you need to go into fundamental ontological
commitments when trying to get a working 'process ontology'. However I
think it is less of a moot point when you are trying to get together a top
ontology. I am reasonably sure that trying to merge lower level ontologies
with fundamentally different ontological commitments - especially when these
are not clearly understood - will need more work than merging ones with the
same commitments.
In the quote from Michael Gruninger at the beginning he suggests that
"a formal framework like this can bring all process-related endeavours
together so that everyone can share what they have done. Then people can
compare their different approaches in a rigorous objective manner ...".
I have no quarrel with this but I suspect that maybe more is required.
If we look at John Sowa's formal specification of P-nets in his latest
email, to compare it with PSL he adds an explanation of the fundamental
ontological commitments as well. I suspect that if we make the fundamental
ontological commitments clearer for each formalised ontology, this would
make comparing them easier and make using them to build a unified top
ontology easier.
Chris
Chris Partridge
LADSEB-CNR partridge@ladseb.pd.cnr.it
Corso Stati Uniti, 4 Voice: +39 049 829 5715
I-35127 Padova Fax: +39 049 829 5763
Italy
Date: Tue, 30 May 2000 09:28:08 -0400
From: Michael Gruninger <mudcat@eil.utoronto.ca>
Subject: Re: Process ontology based on causality instead of time
John F. Sowa wrote: > Following are the basic primitives in the PSL and PN ontologies: > > PSL ontology: Activity types, Activity occurrences, Objects, Time points. > > PN ontology: State types, Event types, Messages, Causal links, > Presence of messages in states, Occurrences of Events. > > Comparison: A PSL activity type corresponds to a PN sequence of > state types and event types. The PSL before relation > between time points is replaced by causal links, which > take causality as a primitive rather than time. It is > possible to define time in terms of causality, but not > conversely: post hoc does not imply propter hoc. Ahh, I'm beginning to see where your misconceptions are... your comparison statement is incorrect. The PSL before relation is NOT equivalent to causality. (I cannot stress this enough). PSL-Core does NOT axiomatize causality and it does NOT axiomatize states. However, there are extensions of PSL-Core that axiomatize both of these concepts. The PSL project made the decision to put time in the core, and causality in an extension. Of course, it could have made the converse decision, and put causality in the Core and time in an extension; one does not have any inherent primacy over the other. It simply was the case that the model theory for the former decision is a little easier than the latter, and that we were looking for a realtively weak theory that we could use in an extendible manner. However, the main point is that, in the end, both concepts are part of PSL (i.e. Core + extensions). > No, that misses the point I was trying to make. The basic issue is > that causality is more primitive than time. I don't believe this. Both time and causality have equal footing ontologically. Neither is more primitive than the other. > Yes, and the fundamental point that I am trying to make is that > causality is conceptually and ontologically prior to time. Again, this is a needless distinction to obsess about. This sounds like you are still searching for the One True Ontology. > No. Time cannot be represented as a total ordering except at a single > fixed point in space. As I said in my earlier notes, for any two points > p1 and p2 separated by a distance d, it is meaningless to say whether > the time t1 at p1 is before or after t2 at p2 when the interval |t1 - t2| > is less than d/c. This still doesn't make any sense for me... > >Of course, PSL should > >be able to faithfully capture the concepts in such an ontology. > > Unfortunately, it can't. Again, please do not confuse PSL-Core with the rest of PSL. Of course, PSL-Core alone does not capture causality and state, and it was never designed to do so. This is the purpose of the extensions, and together they can capture the ontology of Petri nets. > Petri nets make no assumption about time, > they are by design relativistically invariant, and they don't > presuppose any kind of synchronized clocks or global time. Furthermore, > the causal links in the PN ontology imply a partial ordering, but a > simple before and after relation does not imply cause. I must strenuously disagree with this. Time and causality are two separate ideas. One is not definable in terms of the other. Of course, there is a strong relationship between the two, and any axiomatization must be able to capture this. > The basic problem, as I said before, is that PSL-core is based on the > wrong primitives. By taking causal links as primitive, the PN ontology > automatically accounts for the propagation of effects, and it can be > used to define time for the PSL axioms as a special case. No. Time is not defined using causality. Why be so obsessed with finding the Ultimate Primitives? This is a philosophical deadend. Look at this as an exercise in mathematical logic. We are building axiomatic theories that axiomatize different classes of structures. The structures of PSL-Core include a timeline and a set of activities and activity occurrences. Other extensions of PSL-Core include ordering relations over activity occurrences, and these relations can be used to capture intuitions about causality. This does not mean that PSL-Core has some kind of primacy; it is merely a weak, extendable theory that serves as a reference point in building a lattice of axiomatic theories to capture intuitions about processes. - michael
Date: Tue, 30 May 2000 16:31:55 +0200
From: "Christopher A. Welty" <welty@ladseb.pd.cnr.it>
Subject: Re: Process ontology based on causality instead of time
> Comparison: A PSL activity type corresponds to a PN sequence of
> state types and event types. The PSL before relation
> between time points is replaced by causal links, which
> take causality as a primitive rather than time. It is
> possible to define time in terms of causality, but not
> conversely: post hoc does not imply propter hoc.
Having timepoints in PSL does not prevent you from defining causality.
It does not prevent you from defining processes and states.
As long as I have axiomatized things properly, there is no need to
have a specific timepoint, just relationships between existentially
quantified terms. I can talk about "the time-point where process P1
started" without giving it a time-stamp. I can say it occurred
before "the time-point where process P2 started". You can say
anything you want about it.
>the fundamental point that I am trying to make is that
>causality is conceptually and ontologically prior to time.
Interesting, but based on what? What evidence do you have that
causality is "conceptually and ontologically prior to time" Note
that in your own language you use temporal ("prior") not causal terms.
>Time cannot be represented as a total ordering except at a single
>fixed point in space. As I said in my earlier notes, for any two points
>p1 and p2 separated by a distance d, it is meaningless to say whether
>the time t1 at p1 is before or after t2 at p2 when the interval |t1 - t2|
>is less than d/c.
Even if we accept this revisionist (as opposed to descriptive) point,
then for any two points ON PLANET EARTH it is only meaningless (again
by your definition) if |t1-t2| < .07 seconds. And this is with a
conservative estimate on the maximum distance between two points on
Earth.
This seems like a pretty weak argument to change the PSL ontology,
though a useful thing to know about it.
>I agree that Sandewall's work is valuable, and all 1152 of his
>categories of discrete processes can be represented by Petri nets.
>But the total ordering imposed by PSL Axiom 2 is unnecessary for any
>of those categories. Sandewall's methods of reasoning depend primarily
>on causality, not on time differences. In fact, if you base reasoning
>on absolute time rather than causal links, it becomes less efficient,
>because you increase the number of spurious events to consider.
Regardless of efficiency, as I mention above, nothing about
timepoints in general prevent you from defining causal relationships.
>You can define time in terms of causality, but you can't define the
>partial ordering imposed by cause and effect in terms of time.
If starts(p1,t1) AND starts(p2,t2) AND causes(p1,p2)
THEN not(before(t2,t1))
This is a partial ordering of the starting points of P1 and P2.
-Chris
Date: Tue, 30 May 2000 11:09:53 -0700 (PDT)
From: mfu@redwood.rt.cs.boeing.com (Michael Uschold)
Subject: Time, Causality and Demand-Pull
The following kind of simple disagreement without further illumination
seems likely to dead end very soon.
JOHN: causality is conceptually and ontologically prior to time.
MICHAEL: this is a needless distinction to obsess about. This sounds like you
are still searching for the One True Ontology.
Chris Welty asks John:
"What evidence do you have that
causality is "conceptually and ontologically prior to time" Note
that in your own language you use temporal ("prior") not causal terms."
This point may never be resolved. I also suspect that pursuing it may not
contribute much to the particular question at hand: should PSL be
changed. Although, it may be interesting, and highly relevant from a
philosophical perspective.
I advocate a demand-pull approach where practical examples that arise in
everyday needs for representing processes cause the demand for changing axioms
to be ontologically 'correct'. Rather than supply-push, imposing ontological
tidiness before it is needed.
The challenge for John, I submit, is to find compelling examples of processes
that everyone agrees PSL should be able to handle, but it cannot. Thence, to
trace the problem back to its original roots, perhaps leading us to a
time/causality discussion -- in which case, Michael's claim that "this is a
needless distinction" would be proved wrong. Chris Partridge's example about
trousers is perhaps an interesting one.
Lacking such an example, it is too easy to simply nod politely to John and
ignore him -- albeit noting that his points are interesting and perhaps of
great philosophical import (assuming he's right) -- but not relevant to PSL
concerns.
A very good point was made by someone, about what I'm calling ontological
tidiness being much more relevant to a the task of building
'one-true-upper-ontology' than it is to PSL. This seems right to me.
Mike
Date: Tue, 30 May 2000 15:15:27 -0400
From: Michael Gruninger <mudcat@eil.utoronto.ca>
Subject: Re: Time, Causality and Demand-Pull
I would just like to clarify my position -- 1. Both causality and time need to be axiomatized within any process ontology 2. The question of which notion is prior is not as important as correctly and completely axiomatizing the intuitions about causality and time. By intuitions I mean concrete empirical scenarios that we can use to potentially falsify the proposed axiomatic theories. 3. It is neither right nor wrong to say "Timepoints are totally ordered". Every software application that the PSL group looked at satisfies this requirement. John has examples that he believes violate this requirement. If two people disagree about the ordering constraints over timepoints, it simply means that they cannot share sentences that refer to timepoints. I would also like to offer another example from mathematics, namely the axiomatization of geometry. David Hilbert provided an axiomatization in 1905, and Alfred Tarski provided a very different one in 1958. Hilbert's basic ontology consists of point, line and plane, and the inclusion relations among these. In Tarski's theory, everything is a point, so that line and plane are not primitive notions; he also uses a ternary relation for betweenness, and another relation for congruence. Neither theory is right or wrong; there is no One True Geometry. They are simply different axiomatizations. The important thing is that once they are both axiomatized, we can begin to characterize their relationships in precise, formal ways. - michael
Date: Tue, 30 May 2000 18:43:35 -0500
From: Chris Menzel <cmenzel@philebus.tamu.edu>
Subject: Linear logic formalization
> I wonder if someone who has access to Anne Troelstra's book could copy > the axioms and post them to this list? Adam, A useful formalization of linear logic in a Gentzen-style system of inference rules can be found in "Linear Logic and Computation: A Survey" by Andre Scedrov. This paper is available on the web at: ftp://ftp.cis.upenn.edu/pub/papers/scedrov/mdorf93.dvi.Z Regards, -chris
Date: Wed, 31 May 2000 17:27:15 +0200
From: Chris Partridge <Chris_Partridge@csi.com>
Subject: RE: Time, Causality and Demand-Pull
Mike,
I think it may be useful to clarify the point that is, I think, at the
heart of the issue that John Sowa is raising (John maybe you can tell me
whether I am right?). It seems to be overlooked - at least as far as I
can tell - in some of the responses.
My problem is that I, like John, was a little surprised when I first looked
at PSL to see how it started with timepoints.
The point is that it seems to me - at first blush - odd (for a number of
reasons outlined below) to introduce timepoints at the heart of a process
ontology. And I would be really interested in understanding why PSL chose
this route - particularly if there is some deep reason. I find it difficult
to believe it is just "a little easier" as you says below.
Mike Gruninger wrote:
The PSL project made the decision to put time in the core, and causality in
an extension. Of course, it could have made the converse decision, and
put causality in the Core and time in an extension; one does not have any
inherent primacy over the other. It simply was the case that the model
theory for the former decision is a little easier than the latter, and
that we were looking for a relatively weak theory that we could use in an
extendible manner. However, the main point is that, in the end, both concepts
are part of PSL (i.e. Core + extensions).
I do not see the point as in any way 'damaging' to PSL. If there should
turn out to be a need for a change - something I am *not* claiming - it
may well be that this can be done with a little work. So what we might
have here, just maybe, is a potential for improvement at little cost.
I also suspect the point is not about different axiomatisations of the same
'meaning' - such as your example of Hilbert, Tarski and geometry - this
seems to me to show that the choice of primitives and axioms is in some ways
ontologically irrelevant. The point is more about whether the different
axiomitisations give a different 'meaning' - whatever meaning is.
Let me explain why this approach seems odd to me.
Firstly it does not seem to me to reflect folk understanding of processes -
though as always folk understanding is not a reliable guide.
People do not think of one activity having a timepoint at its end, which is
before the start timepoint of the following activity. Consider (again)
the getting dressed process: we say:
(1) You put your socks on before your shoes
Not
(2) Your putting-your-socks-on activity has to have an end timepoint
before the start timepoint of the putting-your-shoes-on activity.
People normally think of activities being before or after one another - not
their timepoints. Imagine if we said (2) to some poor child. They could
reasonably ask where to find these timepoints, what they were, etc. It
would be interesting to see what you PSL people thought they were - immaterial
entities, slices of space-time, or just a way of talking about processes.
Secondly my experience of process modelling in business software development
is quite different from yours in KR.
Mike Gruninger wrote:
"I'm not sure I see the point of these objections. Such an axiomatization of
time is quite common; for example, see Hayes' theories of time. In particular,
Pat discusses the relationships between ontologies of time that use points vs intervals."
As far as I can remember (probably not very far) the business software
development process modelling methodologies assumed that the 'before'
ordering was over activities rather than timepoints. Note this is not
strictly a material cause relation (as some of the mails seem to assume) -
for example putting on my socks does not 'cause' putting on my shoes.
Thirdly, from an ontological point of view I wonder why there is a need
to introduce such a tricky kind of entity as timepoints at such an early
stage. Much of the work needed to be done by these, outside ordering
activities, can be done in other ways - e.g. by having a clock as a
process. I have been told that this is exactly how many distributed
business systems are designed to and actually work - because of the
risks of taking a simplistic view that relies on clocks providing the
same 'timepoints' in different systems. Why take on a risk when you do
not need to?
John Sowa's point about relativity is pertinent here - as historically
Liebnitz the original advocacy of relativity argued that space and time
were based upon relations between objects rather than entities in
themselves.
I do not know for sure whether one can axiomatise processes without
introducing timepoints - though on the face of it this seems likely and
intuitively more comfortable. Maybe it can be argued that Sandewall's
work has proved it can. If it can then I think it makes sense to ask
whether the two positions are effectively the same one or one is better
than the other. If it can be proved that such an axiomatisation is
impossible then this is an interesting, non-obvious fact.
Hopefully it is a little clearer now why some people may want to know what
benefits PSL saw in choosing the strategy it did.
I would also like to make an ancillary point about what Michael Uschold
wrote: "I advocate a demand-pull approach where practical examples that
arise in everyday needs for representing processes cause the demand for
changing axioms to be ontologically 'correct'. Rather than supply-push,
imposing ontological tidiness before it is needed."
If the ontological point (third point above) does lead to interesting
questions than can I suggest it offers a counter-example to Mike Uschold's
suggestion. Can I suggest a different model where ontological intuitions are
harnessed to help improve quality - though the final court deciding on
changing axioms could, probably even must, demand proof of practical
examples. It seems a pity to waste this resource.
Finally I suspect that the value of using ontological analysis will become
much clearer when we try and build a top ontology - then the practical value
of it will become obvious.
Chris
Date: Wed, 31 May 2000 13:11:47 -0400
From: Michael Gruninger <mudcat@eil.utoronto.ca>
Subject: Re: Time, Causality and Demand-Pull
Chris Partridge wrote: > The point is that it seems to me - at first blush - odd (for a number of > reasons outlined below) to introduce timepoints at the heart of a process > ontology. And I would be really interested in understanding why PSL chose > this route - particularly if there is some deep reason. I find it difficult > to believe it is just "a little easier" as you says below. First of all, we wanted to use the Core to specify the basic ontological commitments. We started with activities and activity occurrences. One way in which these differ is that activity occurrences are temporally extended entities, while activities are intuitively at the "type" level. This notion of temporal extent is the first intuition that led to the introducti on of timepoints. The second intuition was that objects can be created and destroyed by activity occurrences, and people will want to identify the timepoints at which the objects exist and are available for various activities. For these two reasons, timepoints became one of the ontological commitments. (There may be other reasons for this; perhaps someone else from PSL or PIF might like to comment here). An overall design decision for PSL-Core was to make it as weak as possible, so that PSL could support partial sharing among different process applications. The only constraint imposed on timepoints is that they are a totally ordered set (whence the before relation over timepoints). There are two functions (beginof,endof) that map activity occurrences and object s to timepoints. There is a relation occurrence-of that specifies the relationship between activities and activity-occurrences, and a participates-in relation between objects and activity occurrences. Again, this is a very weak theory. Ordering relations over activities or activity occurrences were not included in PSL-Core because there are several possible relations that could be used here. We therefo re decided to be agnostic about these relations in PSL-Core and introduce them in further extensions instead. I would also like to point out that a similar commitment was made in the ARPI project SPAR (Shared Planning and Activity Representation). > I also suspect the point is not about different axiomatisations of the same > 'meaning' - such as your example of Hilbert, Tarski and geometry - this > seems to me to show that the choice of primitives and axioms is in some ways > ontologically irrelevant. The point is more about whether the different > axiomitisations give a different 'meaning' - whatever meaning is. Part of the discussion seems to have referred to which concepts are in some sense "more primitive" than others. I understood John as claiming that causality is more primitive than time. Although this may be the case in his ontology, it is not necessarily true in every ontology. I used the example of geometry as an example since the two theories have different sets of primitives (as is the case with our discussion about processes). The choice of primitives is not ontologically irrelevant; however, it is a design CHOICE, not a design requirement for an ontology. Tarski made a design choice to make points the only primitive, but this is not a requirement for any ontology of geometry. > People normally think of activities being before or after one another - not > their timepoints. > Imagine if we said (2) to some poor child. They could reasonably ask where > to find these timepoints, what they were, etc. It would be interesting to > see what you PSL people thought they were - immaterial entities, slices of > space-time, or just a way of talking about processes. A distinction must be made between activities and activity occurrences. Activities in PSL are not explicitly associated with timepoints; rather, each activity occurrence is associated with two timepoints -- the beginof the occurrence and the endof the occurrence. Your getting-dressed process example is the specification of the activity. The ordering relation in (1) is not the "before" relation of PSL, since in your example you are using an ordering relation over activities. Of course, there is a strong relationship between the two, since implicitly you are saying that for every occurrence of the getting-dressed activity, the endof the occurrence of the puton-sock subactivity must be before the beginof the occurrence of the puton-shoe subactivity. Furthermore, before is NOT a relation over these activity occurrences; it is a relation over the timepoints that are the beginof and endof the occurrences. As a side note, there are process descriptions that cannot be defined using ordering relations over activities alone, but which must explicitly refer to an ordering relation over activity occurrences. In particular, there may a process which has multiple occurrences of the same subactivity, and an ordering relation over activities alone is unable to disambiguate among them. > As far as I can remember (probably not very far) the business software > development process modelling methodologies assumed that the 'before' > ordering was over activities rather than timepoints. Note this is not > strictly a material cause relation (as some of the mails seem to assume) - > for example putting on my socks does not 'cause' putting on my shoes. We realize that orderings over activities are important for a process ontology. But you seem to be saying that your intuitions about the symbol "before" is restricted to activities, whereas PSL uses the symbol "before" to refer to timepoints, so therefore there is a conflict between your intuitions and PSL. But remember that the words we use to name predicates are only around for human benefit; from a logical point of view, they are ultimately irrelevant. What is of central importance is the set of axioms that we use to restrict the interpretation of the symbol. > > Thirdly, from an ontological point of view I wonder why there is a need to > introduce such a tricky kind of entity as timepoints at such an early stage. > Much of the work needed to be done by these, outside ordering activities, > can be done in other ways - e.g. by having a clock as a process. I have been > told that this is exactly how many distributed business systems are designed > to and actually work - because of the risks of taking a simplistic view that > relies on clocks providing the same 'timepoints' in different systems. Why > take on a risk when you do not need to? We never considered timepoints as being "tricky". The only constraints we place on them is that they are a totally ordered set of objects that are associated with activity occurrences and objects. Simply asserting the existence of timepoints does not mean that PSL-Core is committing in any particular approach to the subtleties of clocks or metrics for a quantitative approach to time; these are handled by extensions to the Core. The reason that these decisions are put into extensions is that people may have different theories of clocks which are mutually inconsistent with each other, even though they are consistent extensions of the Core. Another example is that PSL-Core does not make a commitment on whether time is dense or discrete; some process applications assume the former, others assume the latter. In this case, there are two different extensions of the Core that axiomatize each ot these commitments. Personally, I believe it is easier to axiomatize time as a linearly ordered set and then impose additional restrictions as needed (very much in the spirit of Pat Hayes' catalog) rather than simulate time as a clock (but this is just my opinion). > John Sowa's point about relativity is pertinent here - as historically > Liebnitz the original advocacy of relativity argued that space and time were > based upon relations between objects rather than entities in themselves. I'm afraid I still don't understand this point about relativity... > Finally I suspect that the value of using ontological analysis will become > much clearer when we try and build a top ontology - then the practical value > of it will become obvious. As Mike Uschold mentioned, there may in fact be a different methodology followed by people building a top ontology vs people building common merged ontologies (e.g. PSL). For one thing, the idea of using a weak core ontology in conjunction with a lattice of extensions seems to be different from the taxonomy of a top ontology. It seems to be a bigger issue for top ontology people to minimize the number of primitive concepts, even if it takes a lot of machinery to do so (e.g. simulating time as a clock). In the common merged ontology approach, there is no a priori bias for the set of primitive concepts, so long as everything is axiomatized. - michael
Date: Wed, 31 May 2000 22:55:28 -0400 (EDT)
From: "John F. Sowa" <sowa@west.poly.edu>
Subject: Summarizing the arguments so far
To clarify the theoretical and practical differences between our
positions, I'll start by summarizing some points of agreement and
disagreement. I assume that we all agree on the following two points:
1. The current PSL core is based on time as a primitive rather
than causality.
2. Causality cannot be defined in terms of time, but axioms and
definitions for some version of causality could be added as
an extension to the PSL core.
Following are some questions that seem to be in dispute:
1. Whether PSL Axiom 2, which assumes an absolute, totally ordered time,
is physically true.
2. Whether an absolute, totally ordered time is a reasonable
approximation for most, if not all manufacturing applications.
3. Whether time can be defined in terms of causality.
4. Whether a definition of causality can be added to the PSL-core
in terms of which it is possible to define the PN ontology.
5. Whether the PSL-core can be defined in terms of the PN ontology.
In the previous notes to this list, I have answered no to #1 and #4,
yes to #3 and #5, and maybe to #2, but only with serious qualifications.
In the following discussion, I sharpen some of my previous claims and
present a more detailed justification for them.
Claim 1: An absolute, totally ordered time is physically impossible.
Newton's assumption of absolute space and time is inconsistent with
Maxwell's equations of electromagnetism. To reconcile the theories
of mechanics and electromagnetism, Einstein developed the theory of
relativity, which assumes a 4-dimensional space-time continuum that
gives equal status to all inertial coordinate systems. The following
implication of relativity contradicts PSL Axiom 2:
For any two points p1 and p2 separated by a spatial distance d,
it is possible to find three inertial coordinate systems with the
following properties:
1. An event at p1 is observed to occur simultaneously with an event at p2.
2. The event at p1 is observed to occur before the event at p2.
3. The event at p1 is observed to occur after the event at p2.
This fact implies that clocks stationary with respect to each of the
three coordinate systems would give a different ordering of events.
The time interval d/c, where c is the speed of light, determines
an _event horizon_. No consistent ordering of events at p1 and p2
can be defined when the time differences are smaller than d/c.
Therefore, the most that can be assumed is a partial ordering of time:
beyond a distance d, the ordering defined by the before relation is
undefined for time intervals less than d/c. It is not only impossible
to measure such time differences, it is impossible to give any globally
consistent meaning to them.
Claim 2: PSL Axiom 2 may be assumed to be approximately true, but only
if all clocks are synchronized, the maximum distance involved is d,
the speed of message passing is v, and time differences less than d/v
are neglible for any application of PSL.
Einstein's arguments for the physical limit d/c can be used to define
an _epistemological limit_ of d/v, where v is speed of information
propagation. As Graham Wideman pointed out in his e-mail of May 25,
"If communication is by horse, then the relevant speed is 10-20 mph."
The epistemological limit is critical in many applications that depend
on scheduling events that must share resources, such as a railroad
crossing or an airport runway. When an air traffic controller is
monitoring multiple events on a radar screen while talking with multiple
pilots on the radio, information propagation may take many seconds.
During that time, events that may be ordered from God's point of view
may be epistemologically unordered from a pilots' point of view.
Graham's example of telesurgery is significant: "info propagation
at theoretical maximum causes an unacceptable lag between a surgeon's
manipulation of controls and the force and visual feedback that results,
even for surgery across the US." Similarly, a remote-controled technique
that works fine in Seattle could break down when the operator is on the
ground and the assembly is done on the International Space Station.
PSL could become more dangerous if it proves to be successful.
It might then be used in applications for which the limitations
of Axiom 2 are no longer acceptable.
Claim 3: All methods for measuring time depend on causality.
Therefore, time can be formally defined in terms of an _ideal clock_,
which is based on a suitable theory of causality.
Every technique, instrument, or clock for measuring time is based
on the assumption that some physical process "causes" repeated
occurrences of an easily observable event type that is assumed to
be regular. Historically, those event types have been the rising
of the sun, the phases of the moon, dropping water, sifting sand,
swinging pendulums, or vibrating tuning forks, crystals, and atoms.
Since Newton, theoretical physics has assumed a quantity called time,
which may be represented by a variable (or _fluent_) t. No theory of
physics explicitly defines time by itself. Instead, the equations of
physics implicitly relate time to other quantities, such as space, mass,
electrical charge, Planck's constant, or the gravitational constant.
For a formal theory, there are two options: (1) postulate time as
an undefined primitive, which may be related implicitly to other
undefined primitives; or (2) give an explicit definition of time in
terms of the other primitives. PSL has adopted option #1. I have
recommended option #2, in which events with causal links are assumed
as undefined primitives, and time is defined as a count of repeatable,
regular event types in an ideal clock.
Claim 4: Although a definition of causality can be added as an extension
to the PSL-core, every such extension would inherit Axiom 2. Therefore,
no definition of the concepts of the PN ontology in terms of an extension
to PSL-core could be isomorphic to the proposed version of PN ontology,
which allows a partial ordering of time.
A partial ordering defined by message passing, as in Petri nets,
is by its nature relativistically invariant, since no message can
travel faster than the speed of light. Furthermore, Petri nets and
the PN ontology also accommodate the stricter epistemological limits
that result from slower means, such as TCP/IP or even a horse.
Since the PSL Axiom 2 violates the relativistic limitations,
and every extension to PSL-core must include all the core axioms,
every extension to PSL-core must also violate those limitations.
Therefore, no theory defined on top of PSL-core can be isomorphic
to a relativistically invariant theory, such as Petri nets or
the PN ontology.
My complaint about PSL-core is not that it's too weak, but that
it's too strong. I believe that Axiom 2 should be replaced by
the weaker and more realistic assumption of a partial ordering.
Claim 5: The axioms and definitions of the PSL-core can be defined
in terms of the PN ontology, but only with certain restrictions that
are necessary to enforce relativistic invariance.
Given the PN ontology that I proposed in the e-mail of May 27, I would
add the assumption that there exists an event type called a _tick_,
which recurs at regularly spaced intervals. Actually, the tick defines
what it means to be regular. In his experiments with falling bodies,
Galileo defined his heartbeat as the tick. By today's standards, such
a definition would make the atomic clock in Colorado grossly inaccurate.
In principle, however, any repeatable event type could be assumed as
the standard for what it means to be "regular."
With that assumption, one could construct a Petri net that would serve
as a model for the PSL core axioms and definitions. The ideal clock
could be defined by a Petri net with one place and one transition that
would cycle forever. One more place would be added that would receive
a message at each tick. The count of ticks would be defined as the
absolute, totally ordered time stamp.
To accommodate the PSL assumption of a beginOf and endOf time for any
actvity occurrence, additional links could be added to the Petri net
to broadcast the standard time stamp to every transition at every tick.
Before any transition (event type) could fire, it would have to check
whether the current time is at least one tick greater than the time of
the previous firing. That constraint would ensure that no transition
could fire more than once during a single tick of the clock (although
it would allow different transitions to fire during the same tick).
To accommodate the PSL assumption that a new time point might be
inserted between any two time points, we could add the option of
unplugging and "upgrading" the ticker of the ideal clock with a faster
ticker that would generate two ticks for every tick of the old clock.
Note that this construction requires every transition in the Petri net
to wait until it receives a message that at least one tick of the ideal
clock has passed. That restriction enforces a kind of synchronization
that is not required in a normal Petri net. If the physical distances
between transitions are large, the synchronization requirement may slow
down the processes in order to accommodate the limitations of the speed
of light. (By the way, circuit designers realize that asynchronous
circuits can be faster than synchronized ones, largely because they
are less constrained by the speed of light. Petri nets are a good way
to model such designs.)
By a construction of this sort, it would be possible to define a
model of the PN ontology that would also be a model of the current
PSL axioms. Since the PSL axioms are not relativistically invariant,
but Petri nets are, there may be some models of the PSL axioms that
cannot be modeled by this method. However, I conjecture that those
models are the physically unrealistic ones that should be excluded.
Verifying that conjecture would require a bit more work.
Following are a some brief comments on previous notes.
John
--------------------------------------------------------------------
Michael Gruninger wrote,
>Why be so obsessed with finding the Ultimate Primitives? This is a
>philosophical deadend. Look at this as an exercise in mathematical logic.
I'm looking at PSL as a practical tool for representing applications,
and as I showed above, Axiom 2 of total ordering is inconsistent with
modern physics. It may be acceptable for some applications, but not
for applications in which information propagation time is significant.
>.... This does not mean that PSL-Core has some kind of primacy; it is
>merely a weak, extendable theory that serves as a reference point in
>building a lattice of axiomatic theories to capture intuitions about
>processes.
My primary complaint is that Axiom 2 excludes all relativistically
invariant theories from the lattice. I'm asking for the weaker axiom
of partial ordering, which is physically more realistic and compatible
with other ontologies, such as PN. I'm not looking for One True Ontology.
All I'm saying is that the core axioms of PSL should not *exclude* all
ontologies that are consistent with modern physics. The problem is that
PSL-core is already too strong, and any extension would be even stronger.
Chris Welty wrote,
>Regardless of efficiency, as I mention above, nothing about
>timepoints in general prevent you from defining causal relationships.
I agree. If the PSL Axiom 2 were replaced by a partial ordering, then
it would be possible to add the axioms and definitions of the PN ontology
to form a theory that includes both.
>Thirdly, from an ontological point of view I wonder why there is a need
>to introduce such a tricky kind of entity as timepoints at such an early
>stage. Much of the work needed to be done by these, outside ordering
>activities, can be done in other ways - e.g. by having a clock as a
>process. I have been told that this is exactly how many distributed
>business systems are designed to and actually work - because of the
>risks of taking a simplistic view that relies on clocks providing the
>same 'timepoints' in different systems. Why take on a risk when you do
>not need to?
I agree. All the work on Petri nets makes a clear distinction between
event types and event instances. I feel quite happy about quantifying
over event instances; they can also be put in a partial ordering or even
a total ordering. The only advantage that a time point might have over
an event instance is that the symbols that identify the time points can
be used to sort them. But as I said, I'd prefer a partial ordering anyway.
In any case, I'm less concerned about removing time from PSL-core
than about replacing "total" with "partial" in Axiom 2.
Last Modified: