Paths and Traversals

Introduction to Paths and Path Systems

See Introduction to Paths and Traversals, a summary of how and why the path system was developed as it was. Note that trajectories (of motions), paths (pre-existing paths) and traversals (of paths) need to be handled separately.

The English word "path" is ambiguous: it can mean a trajectory ("the path of a moving object") or it could mean a path that exists in the world (a road, footpath, pipeline, air-lane, etc.). The trajectories of moving things may or may not follow paths. A section called "Trajectories of Moving Things" is toward the end of this vocabulary file.

Kinds Of Paths

"Path" here means an existing or designated path (real or abstract), not #$Trajectory or #$Traversal.

#$Path-Generic   generic paths

A collection of things that are paths or can be considered paths. Each #$Path-Generic is either a a non-self-crossing path (see #$Path-Simple) or a cycle (see #$Path-Cyclic). A #$Path-Generic may be spatio-temporally abstract (e.g. links in Graph Theory; see #$Multigraph), spatially-located but intangible (e.g. a #$LatitudeLine might be used as a path in some system; see #$Path-Spatial and its specializations), or fully concrete (such as a road, railroad, sea-lane, cowpath, pipe, blood vessel, fiber, or wire; see #$Path-Customary and #$PathArtifact). #$Path-Generic includes anything that is used as a path in some #$PathSystem (q.v.). If a #$Path-Generic is a #$Path-Customary, then it might or might not have a specified #$PathSystem in which it is a path; if the #$Path-Generic is not a #$Path-Customary, then it can only be a path in some given #$PathSystem. For example, an orange is not a customary path, but it can be a path for ants in a specified ant path system. For any #$Path-Generic, there can be a #$Traversal (q.v.) of something moving along the entirety of that path (and a single #$Traversal can cross itself, double back along itself, or go back and forth along some part of a #$Path-Generic any number of times.) Note that #$Path-Generic is _not_ a subcollection of #$Individual, because there is nothing in principle to prevent a mathematical set or a collection from being used as a path in some path system. For similar reasons, few if any (non-empty) collections or sets can definitively be considered disjoint with #$Path-Generic.
guid: c110820b-9c29-11b1-9dad-c379636f7270
direct instance of: #$Collection
direct specialization of: #$Thing  
direct generalization of: #$Path-Spatial #$Path-Cyclic #$SimpleSegmentOfPath #$Path-Simple

An instance of #$Collection, and a specialization of #$Path-Generic. Each instance of #$Path-Simple is a path with two distinct ends that do not overlap each other (in the case of spatial paths, the two ends are spatially disjoint). Since no instance of #$Path-Simple has ends that join at one point, #$Path-Simple is disjoint with #$Path-Cyclic. Although instances of #$Path-Simple have distinct ends, some instances may have more than two things that are its end-points . For example, a path between Austin and Pittsburgh can also be a path between Texas and Pennsylvania. Notable specializations of #$Path-Simple include #$Pipe-GenericConduit, #$Nerve, and #$Stream.
guid: bd588e69-9c29-11b1-9dad-c379636f7270
direct instance of: #$Collection
direct specialization of: #$Path-Generic  
direct generalization of: #$Highway #$GeneralizedTransfer #$Portal #$CordlikeObject #$EdgeOnObject-Generic #$FlowPath

The collection of all cyclic paths, i.e. paths that form cycles, circles, loops or circuits. An instance of #$Path-Cyclic is a #$Path-Generic that can be described as a cycle, i.e., a thing like a #$Path-Simple except that the ends of the path join at one point. A #$Path-Cyclic cannot cross itself (as in a figure-eight) nor double back along itself. More formally, let PATH1 and PATH2 be two #$Path-Simples. Suppose that each end-point of PATH1 is an end point of PATH2 and vice versa, and for each X, X is a point on both PATH1 and PATH2 only if X is an end point of both paths. Then PATH1 and PATH2 together form a #$Path-Cyclic. We allow 'loops'; a loop is a cycle with only one point on it, looping from the point right back to itself. Each loop of a path system is a special instance of #$Path-Cyclic. For differences between a cycle and a loop in the same #$PathSystem, see #$loopInSystem and #$cycleInSystem.
guid: bfa3129f-9c29-11b1-9dad-c379636f7270
direct instance of: #$Collection
direct specialization of: #$Path-Generic  

A specialization of both #$Path-Generic and #$SpatialThing-Localized. Each instance of #$Path-Spatial is a path that has spatial extent, and that joins spatially located things. So instances of #$Path-Spatial include roads, corridors, wires, blood vessels, and nerves; however, purely abstract paths, such as those in kinship diagrams and mathematics, are _not_ instances of #$Path-Spatial. Instances of #$Path-Spatial may be pre-existing paths in a #$CustomarySystemOfLinks (q.v.) or they may be paths in some specially specified #$PathSystem (q.v.) consisting of spatial paths.
guid: c095e890-9c29-11b1-9dad-c379636f7270
direct instance of: #$FirstOrderCollection
direct specialization of: #$SomethingExisting  #$Path-Generic  #$SpatialThing-Localized  
direct generalization of: #$Portal #$SolidSurfacePathThroughAir #$Path-Customary #$EdgeOnObject

A specialization of #$Path-Spatial. Each instance of #$Path-Customary is a spatial path which was either designed as a path by some intelligent agent, or which has a significant known function as a path for movement. Examples include roads, railroads, sea-lanes, cowpaths, boardwalks, tubes, channels, blood vessels, fibers, wires, and communication links. An instance of #$Path-Customary may be either an instance of #$Path-Simple (in which case it would be a path with two distinct ends, not forming a cycle) or an instance of #$Path-Cyclic.
guid: bee87cc9-9c29-11b1-9dad-c379636f7270
direct instance of: #$ExistingObjectType
direct specialization of: #$Path-Spatial  
direct generalization of: #$CordlikeObject #$FlowPath #$PathArtifact

A specialization of both #$ConstructionArtifact and #$Path-Customary. Each instance of #$PathArtifact is a spatial path made by humans or animals. Instances of #$PathArtifact include #$ErieCanal, #$WellandShipCanal, #$ChampsElysee, #$WallStreet, and #$Highway101CA. Note that each of these artifacts is a single, particular path; to refer to a whole system of #$PathArtifacts, use #$PathArtifactSystem.
guid: bd588ea2-9c29-11b1-9dad-c379636f7270
direct instance of: #$ExistingObjectType
direct specialization of: #$ConstructionArtifact  #$Path-Customary  
direct generalization of: #$PathForWheeledVehicles

For specific examples, see below. Some predicates and functions assume that a particular #$PathSystem is specified, and take the #$PathSystem as an argument (their names end in "InSystem"). Others don't assume this.

Physical Transport Path Types

These are not #$Trajectories of motions as listed above, but are pre-existing paths that a motion may (or may not) follow.

#$WaterSurfacePath   water routes    **COMMENT NOT REVIEWED**    **GAFs NOT REVIEWED**

The collection of pre-designated or customary #$Path-Spatials that lie along water surfaces. A moving object following (or blocking) this path is supported by the water, but is neither fully immersed in the water nor completely in the air. This collection includes sea-lanes, channels, pre-designated ship routes, safe-passage mine-free paths, etc. They may or may not be marked with #$Buoys. Certain bodies of water like #$Canals are generally #$WaterSurfacePaths or have #$WaterSurfacePaths on them. For the pure #$Trajectory of the motion of any object on a water surface, use #$WaterSurfaceTrajectory.
guid: c0fd5053-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathType #$ExistingObjectType
direct specialization of: #$Water  #$Path-Customary  #$Path-Simple  

The collection of all designated or customary #$Path-Spatials that go entirely through water (underwater). This would include designated undersea lanes for submarines, or corridors of fish migrations, etc. An object following such a path is immersed in, and supported by, the water. Thus it excludes a #$SolidSurfacePathThroughWater, and a #$WaterSurfacePath. For arbitrary trajectories of motions through water, use #$TrajectoryThroughWater.
guid: bd58cb07-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathType
direct specialization of: #$Path-Spatial  

A designated or pre-defined #$Path-Spatial all of which passes through air (mid-air). This includes air lanes, designated air navigation routes, etc. An object following this #$Path-Generic is immersed in, and supported by, if anything, the air. Thus it excludes a #$SolidSurfacePathThroughAir, a #$PathThroughAirHangingFromSolid, and a #$WaterSurfacePath. For general trajectories of moving objects through air, use #$TrajectoryThroughAir.
guid: bd58cac5-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathType
direct specialization of: #$Path-Spatial  

The collection of all existing or designated #$Path-Spatials through solid material. Designated paths for drilling and machining are examples, as are the paths of tunnel digging and animal burrowings. Boring into wood and burrowing through the earth are locomotions which may follow paths of this type. For the pure #$Trajectory of a motion through a solid (not a designated or pre-existing path), use #$TrajectoryThroughSolid.
guid: c0fd62b2-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathType
direct specialization of: #$Path-Spatial  

The collection of all existing or designated #$Path-Spatials that pass through air along a solid surface. An object following such a path is immersed in the air but supported by the solid surface of the path. To refer to a pure trajectory of the motion, regardless of whether there is any pre-existing or pre-designated #$Path-Spatial, see #$SolidSurfaceTrajectoryThroughAir.
guid: bd58ca42-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathType
direct specialization of: #$PartiallyTangible  #$Path-Spatial  
direct generalization of: #$PathForWheeledVehicles

The collection of all existing or designated #$Path-Spatials through #$Water that are situated along solid surfaces. An object following such a path is immersed in the water but supported by the solid surface. For the pure #$Trajectory of any #$objectMoving through water along a solid surface, use #$SolidSurfaceTrajectoryThroughWater.
guid: bd58ca83-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathType
direct specialization of: #$Path-Spatial  

A collection of paths; a subset of #$PathThroughSolid. Each element of #$AirPathThroughSolid is a region of open space extending from at least one portal on the surface of a solid, into the interior. The portal may be open to surrounding air (as with a highway tunnel), or it may be covered. Some elements of #$AirPathThroughSolid go `all the way through' the solid; such paths have at least two portals. See also #$Portal, #$Cavity, #$PieceOfFreeSpace.
guid: c0f2a4ea-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathType
direct specialization of: #$Cavity  

The path followed by an object revolving around another object, under the influence of gravitation.
guid: be011027-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathType
direct specialization of: #$Path-Spatial  

A #$Path-Spatial through air, while hanging from a solid, such as brachiating from one tree branch to another. An object following this #$Path-Spatial is immersed in the air but supported by the solid.
guid: c0fd5297-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathType
direct specialization of: #$Path-Spatial  

Other Path

The collection of all specified systems of paths and links, including both tangible path systems (such as the system of streets in a city) and abstract path systems (such as a multigraph). Each instance of #$PathSystem consists of a nonempty set of points (where each point is an instance of #$Thing, and is related to the instance of #$PathSystem via the predicate #$pointInSystem), a set of nodes (a subset of the set of points -- each node is related to the instance of #$PathSystem via the predicate #$nodeInSystem) a set of links (where each link is an instance of #$Path-Simple, and is related to the instance of #$PathSystem via the predicate #$linkInSystem), and optionally a set of loops (where each loop is an instance of #$Path-Cyclic, and is related to the instance of #$PathSystem via the predicate #$loopInSystem). In order to specify which link is between which two nodes in the system, which point is on which link in the system, which node is on which loop in the system, and so on, see the following predicates: #$pathBetween, #$pointOnPath, #$pointOnCycle, #$betweenOnPath, #$linkBetweenInSystem, #$junctionInSystem, #$deadEndInSystem, #$isolatedNodeInSystem, and #$connectedInSystem. Notable specializations of #$PathSystem include #$Semi-DirectedPathSystem, #$Multigraph, and #$SimplePathSystem. In order to specify the subsystem relation between path systems, see the predicate #$subPathSystems.
guid: bfd62da4-9c29-11b1-9dad-c379636f7270
direct instance of: #$Collection
direct specialization of: #$Thing  
direct generalization of: #$SpatialPathSystem #$PointFinitePathSystem #$Semi-DirectedPathSystem #$ConnectedPathSystem #$SimplePathSystem #$Multigraph

The collection of junctions of paths, each junction being an arrangement of three or more distinct instances of #$Path-Customary such that they are all locally connected to each other by joining at the #$JunctionOfPaths. It includes the case of two or more paths that 'cross' at a junction (because four path segments are thereby joined), but not the case in which the end of one path simply joins the end of another path, and no others. For junctions in #$PathSystems, see #$junctionInSystem. (Determining what constitutes a #$JunctionOfPaths depends on the #$PathTypes of the joined paths; if it is #$River then only a junction of rivers qualifies, not the place where a road joins a river.)
guid: c0fbbdc4-9c29-11b1-9dad-c379636f7270
direct instance of: #$ObjectType
direct specialization of: #$ArrangementOfLikeObjects  
direct generalization of: #$JunctionOfPipes

The collection of junctions or crossings of #$Path-Generics in each of which: one path crosses, or its end joins the side of, another path of the same, or possibly a somewhat different, #$PathType, without so intruding upon or affecting the path as to cause it to be different in nature or name on either side of that junction. (Examples: A small side street joins a major boulevard and the boulevard does not change size or name at the junction. A hallway ends at another hall, but only allows looking through a window into it. A railroad crossing. A small vein is one of the #$sideBranches of a large vein and the name of the large vein doesn't change at that point.)
guid: be9a14bc-9c29-11b1-9dad-c379636f7270
direct instance of: #$RegionType
direct specialization of: #$JunctionOfPaths  

The collection of all junctions of instances of #$Path-Customary in which one #$Path-Customary adjoining the junction #$branchesInto two or more others, the latter being about equal in size to one another and no wider than the former. Distinct from a #$SideBranchJunction in which a small #$Path-Customary joins the side of a large one.
guid: bed90aa4-9c29-11b1-9dad-c379636f7270
direct instance of: #$RegionType
direct specialization of: #$JunctionOfPaths  

The collection of junctions of instances of #$Path-Customary in which each junction is where a larger #$Path-Customary is joined along its side by a substantially smaller #$Path-Customary that ends there (this can be described using the predicate #$sideBranches). It is often a T-junction, but the smaller #$Path-Customary may join at any angle. This does not depend on any direction of movement or flow along the paths. In systems of named paths, it is usual for the large #$Path-Customary to keep the same name on both sides of the #$SideBranchJunction. See also the contrasting #$BranchingJunction.
guid: be3ed1d3-9c29-11b1-9dad-c379636f7270
direct instance of: #$RegionType
direct specialization of: #$Individual  

A specialization of #$SpatialThing-Localized. Each instance of #$CustomarySystemOfLinks is a customary or conventional network system consisting of interconnected links (instances of #$Path-Customary) and nodes of obvious types, where the elements of the system (i.e., the points, nodes, and links of the system) can be assumed without specifying them as sets (note that this is in contrast to instances of #$PathSystem, in which the sets of point, nodes, links, and loops (if any) have to be specified for the system). Instances of #$CustomarySystemOfLinks include pipe systems, road systems, vascular systems, wiring systems, and mechanical linkages. The links of any #$CustomarySystemOfLinks are assumed to share certain characteristics. For example, in a road system, pipes are not links, nor are streetlights, road paint, or other non-roadways; only the roadways forming the road system are links in that system. Moreover, what constitutes a #$JunctionOfPaths (q.v.) or #$pathTerminus (q.v.) in the system should be obvious from the system type. The links are related to the assumed system by #$linksOfCustomarySystem (q.v.).
guid: c0ee5ac3-9c29-11b1-9dad-c379636f7270
direct instance of: #$ObjectType
direct specialization of: #$SpatialThing-Localized  
direct generalization of: #$PipingSystem-Generic #$PathArtifactSystem

#$PathArtifactSystem is a specialization of #$Artifact-NonAgentive, #$InanimateThing, and #$CustomarySystemOfLinks. Each instance of #$PathArtifactSystem is an artificial system consisting of several instances of #$PathArtifact (q.v.). Important specializations of #$PathArtifactSystem include #$ComputerNetwork, #$RoadSystem, and #$SewerSystem
guid: be60aba5-9c29-11b1-9dad-c379636f7270
direct instance of: #$ExistingObjectType
direct specialization of: #$Artifact-NonAgentive  #$InanimateThing  #$CustomarySystemOfLinks  
direct generalization of: #$ComputerNetwork

Structural Kinds Of Path Systems

The collection of all specified systems of paths and links, including both tangible path systems (such as the system of streets in a city) and abstract path systems (such as a multigraph). Each instance of #$PathSystem consists of a nonempty set of points (where each point is an instance of #$Thing, and is related to the instance of #$PathSystem via the predicate #$pointInSystem), a set of nodes (a subset of the set of points -- each node is related to the instance of #$PathSystem via the predicate #$nodeInSystem) a set of links (where each link is an instance of #$Path-Simple, and is related to the instance of #$PathSystem via the predicate #$linkInSystem), and optionally a set of loops (where each loop is an instance of #$Path-Cyclic, and is related to the instance of #$PathSystem via the predicate #$loopInSystem). In order to specify which link is between which two nodes in the system, which point is on which link in the system, which node is on which loop in the system, and so on, see the following predicates: #$pathBetween, #$pointOnPath, #$pointOnCycle, #$betweenOnPath, #$linkBetweenInSystem, #$junctionInSystem, #$deadEndInSystem, #$isolatedNodeInSystem, and #$connectedInSystem. Notable specializations of #$PathSystem include #$Semi-DirectedPathSystem, #$Multigraph, and #$SimplePathSystem. In order to specify the subsystem relation between path systems, see the predicate #$subPathSystems.
guid: bfd62da4-9c29-11b1-9dad-c379636f7270
direct instance of: #$Collection
direct specialization of: #$Thing  
direct generalization of: #$SpatialPathSystem #$PointFinitePathSystem #$Semi-DirectedPathSystem #$ConnectedPathSystem #$SimplePathSystem #$Multigraph

A collection of collections. Each instance of #$PathSystemType-Structural is a collection of path systems that share a certain kind of structrue. Examples include #$PointFinitePathSystem, #$NodeFinitePathSystem, #$LinkFinitePathSystem, #$FinitaryJunctionPathSystem, #$SimplePathSystem, #$Multigraph, #$FiniteMultigraph, #$SimpleGraph-GraphTheoretic, #$ConnectedPathSystem, #$Semi-DirectedPathSystem, #$DirectedPathSystem, #$BidirectedPathSystem, #$DirectedAcyclicPathSystem, #$BoundedDirectedPathSystem, #$DirectedMultigraph, #$DirectedGraph, #$DirectedAcyclicGraph, #$BoundedDirectedAcyclicGraph, and #$NetworkFlowSystem-Bounded.
guid: befbfb9f-9c29-11b1-9dad-c379636f7270
direct instance of: #$CollectionType
direct specialization of: #$Collection  

A subcollection of #$PathSystem instances of which are connected , as opposed to being in separate pieces. For any distinct points A and B in a connected path system SYS, there is a path PATH in SYS that both A and B are on. That is, a path system SYS is an instance of #$ConnectedPathSystem if and only if, for any distinct points A and B in SYS, there is a path PATH in SYS such that (#$pathBetweenInSystem PATH A B SYS) holds. Note that according to this definition, a connected path system does not necessarily contain a link -- a path system containing a single node and no links will be a connected path system. Note also that because of the CycL treatment of paths (see #$pathInSystem) and nodes (see #$nodeInSystem), there is a path between every two points in SYS just in case there is a path between every two nodes in SYS.
guid: bd73edb5-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathSystemType-Structural
direct specialization of: #$PathSystem  
direct generalization of: #$ComputationalSystem #$ConnectedPhysicalPathSystem #$Tree-PathSystem

An instance of #$PathSystemType-Structural and the collection of #$PathSystems without loops or parallel links. This collection includes #$SimpleGraph-GraphTheoretic when there are no non-node points along links.
guid: c0f34819-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathSystemType-Structural
direct specialization of: #$PathSystem  
direct generalization of: #$Nerve #$Tree-PathSystem #$SimpleGraph-GraphTheoretic

An instance of #$PathSystemType-Structural and a subcollection of #$PathSystem. Each instance of #$Multigraph is an instance of #$PathSystem in which the only points are nodes in the system and all paths are made of links (i.e., no intermediate points along links). Sometime such a system is called a graph or multi-graph in graph theory. A #$Multigraph consists of nodes interconnected by links, with loops on single nodes allowed, and with multiple links between the same two nodes also allowed. (For a graph with no parallel links and no loops, see #$SimpleGraph-GraphTheoretic.
guid: bde212ef-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathSystemType-Structural #$AtemporalNecessarilyEssentialCollectionType
direct specialization of: #$PointFinitePathSystem  #$RelationalStructure  
direct generalization of: #$SimpleGraph-GraphTheoretic #$DirectedMultigraph

The collection of all #$PathSystems that are instances of both #$SimplePathSystem and #$Multigraph. Each instance of #$SimpleGraph-GraphTheoretic is a 'graph', as studied in graph theory, in which there are neither loops nor multiple links between the same pair of nodes.
guid: be269b3d-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathSystemType-Structural #$ObjectType
direct specialization of: #$SimplePathSystem  #$Multigraph  
direct generalization of: #$DirectedGraph

The collection of all #$PathSystems each of which has finitely many nodes, i.e., the collection of every #$PathSystem SYS such that the set (#$NodesFn SYS) is finite. See also #$nodeInSystem. Note that there may still be infinitely many 'points' along the links between nodes in such a system. There could also be infinitely many links, such as between just two nodes.
guid: c060247b-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathSystemType-Structural
direct specialization of: #$PathSystem  

The collection of all #$PathSystems each of which has at most finitely many 'points' on each link, i.e., the collection of every #$PathSystem SYS such that for each link LINK in SYS, (#$TheSetOf X (#$and (#$elementOf X (#$PointsInSystemFn SYS)) (#$pointOnPath X LINK))) is finite. (See also #$pointInSystem.) Note that in #$PathSystems, 'points' may occur along links between nodes (see #$nodeInSystem), while nodes themselves are always 'points' of the system.
guid: be35b345-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathSystemType-Structural
direct specialization of: #$PathSystem  
direct generalization of: #$Multigraph

The collection of all #$PathSystems each of which has finitely many links, i.e., the collection of every #$PathSystem SYS such that the set (#$LinksFn SYS) is finite. See also #$linkInSystem.
guid: bdb0062c-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathSystemType-Structural
direct specialization of: #$PathSystem  

The collection of all #$PathSystems in which all junctions are finitary, i.e., all junctions are intersections joining only finitely many links and loops. A junction X in a #$PathSystem SYS is finitary if there are only finitely many links and loops in SYS that X is on. See #$junctionInSystem and #$finitaryJunctionInSystem.
guid: be488a82-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathSystemType-Structural
direct specialization of: #$PathSystem  

The collection of all #$Multigraphs (interconnected systems of nodes and links) that have only finitely many nodes, links and loops. This is the intersection of #$Multigraph, #$NodeFinitePathSystem and #$LinkFinitePathSystem.
guid: bea2c49a-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathSystemType-Structural #$ObjectType
direct specialization of: #$Multigraph  

An instance of #$PathSystemType-Structural and a subcollection of #$PathSystem. Each instance of #$Semi-DirectedPathSystem is a path system SYS in which every link LINK is given at least one direction (specified by (#$linkFromToInSystem LINK X Y SYS)), and in which every loop is given two directions (so in a sense we can ignore the directions of loops). The directions of paths and non-loop-cycles (if there are any) in SYS are determined by the directions of links in SYS. When designing a particular semi-directed path system, it is convenient to create a constant for the system (say SYS1) and to assert that it is an instance of #$Semi-DirectedPathSystem (#$isa SYS1 #$Semi-DirectedPathSystem). One can then create a constant for each node (such as Node1) in the system, and a constant for each link (such as LinkA) in the system (using (#$isa LinkA #$Path-Simple), and then assert the directions of links using #$linkFromToInSystem (e.g., (#$linkFromToInSystem LinkA Node1 Node2 SYS1)). The axioms for #$linkFromToInSystem will allow one to infer other assertions, such as those involving #$pointOnPath, #$linkBetweenInSystem, #$nodeInSystem, and #$linkInSystem. One can then proceed creating loops, isolated points, and extra points on links, if they are desired.
guid: bebe0ecc-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathSystemType-Structural
direct specialization of: #$PathSystem  
direct generalization of: #$BidirectedPathSystem #$DirectedPathSystem

An instance of #$PathSystemType-Structural and a specialization of #$Semi-DirectedPathSystem. Each instance of #$DirectedPathSystem is a path system SYS in which every link LINK is given exactly one direction (specified by (#$linkFromToInSystem LINK X Y SYS), (#$PathFromFn LINK SYS), or (#$PathToFn LINK SYS)). Note that #$PathFromFn and #$PathToFn are only defined for directed path systems.
guid: c0a745ca-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathSystemType-Structural
direct specialization of: #$Semi-DirectedPathSystem  
direct generalization of: #$DirectedMultigraph #$DirectedAcyclicPathSystem

An instance of #$PathSystemType-Structural and a specialization of #$Semi-DirectedPathSystem. Each instance of #$BidirectedPathSystem is such that every link in it has two directions (see #$linkFromToInSystem).
guid: beffe753-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathSystemType-Structural
direct specialization of: #$Semi-DirectedPathSystem  

The collection of all directed simple graphs, i.e., node-and-link structure in which every link has one direction and no multiple links (between a pair of nodes) or loops are allowed, as studied in graph theory. This is the intersection of #$SimpleGraph-GraphTheoretic and #$DirectedMultigraph, which is the same as the intersection of #$SimpleGraph-GraphTheoretic and #$DirectedPathSystem.
guid: beb3df26-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathSystemType-Structural #$ObjectType
direct specialization of: #$SimpleGraph-GraphTheoretic  #$DirectedMultigraph  
direct generalization of: #$DirectedAcyclicGraph

A specialization of both #$DirectedPathSystem and #$Multigraph. Each instance of #$DirectedMultigraph is a multigraph in which every link has one direction. Note that there can be loops and multiple links between a pair of nodes in a given instance of #$DirectedMultigraph.
guid: c0ba0c32-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathSystemType-Structural #$AtemporalNecessarilyEssentialCollectionType
direct specialization of: #$DirectedPathSystem  #$Multigraph  
direct generalization of: #$DirectedAcyclicGraph #$DirectedGraph #$BayesNet

The collection of all #$DirectedPathSystems each of which has no directed cycle in it (see #$directedCycleInSystem). Note that each instance of #$DirectedAcyclicPathSystem has no loops in it, although it may have an undirected graph cycle in it.
guid: bdd9cff1-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathSystemType-Structural
direct specialization of: #$DirectedPathSystem  
direct generalization of: #$DirectedAcyclicGraph

The collection of all those #$ConnectedPathSystems that look like trees, i.e., those #$ConnectedPathSystems that have no #$Path-Cyclics at all. Note that since each instance of #$Tree-PathSystem has no cycles in it, it has no loops, nor multiple links between two nodes.
guid: be70229a-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathSystemType-Structural
direct specialization of: #$SimplePathSystem  #$ConnectedPathSystem  
direct generalization of: #$Nerve

The collection of all those #$DirectedGraphs (node-and-link structures in which each link has one direction) each of which has no directed cycle in it. This is the intersection of #$DirectedGraph and #$DirectedAcyclicPathSystem (which is the same as the intersection of #$SimpleGraph-GraphTheoretic and #$DirectedAcyclicPathSystem). A #$DirectedAcyclicGraph is often used as a representation of a #$PartialOrdering.
guid: bed5ca59-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathSystemType-Structural #$ObjectType
direct specialization of: #$DirectedGraph  #$DirectedAcyclicPathSystem  
direct generalization of: #$BayesNet

The collection of all those #$DirectedPathSystems each of which constains a unique node that is the source node in the system (see #$sourceNodeInSystem), and a unique node that is the sink node in the system (see #$sinkNodeInSystem).
guid: bd5bf898-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathSystemType-Structural
direct specialization of: #$DirectedPathSystem  #$ConnectedPathSystem  

The collection of all those #$DirectedAcyclicGraphs in each of which there is only a single source node and a single sink node. This is the intersection of #$DirectedAcyclicGraph and #$BoundedDirectedPathSystem. See #$sourceNodeInSystem and #$sinkNodeInSystem.
guid: c0a6d152-9c29-11b1-9dad-c379636f7270
direct instance of: #$PathSystemType-Structural #$ObjectType
direct specialization of: #$DirectedAcyclicGraph  

Path Predicates Not Requiring A Specified Path System

(#$onPath THING PATH) means that THING is located along (on or adjacent to) the #$Path-Generic PATH. THING could be a moving object, or it could be a stationary point (in the latter case, see the more specific predicate #$pointOnPath). For example, Saint Louis, Missouri was #$onPath U.S. Route 66, as was Missouri, any car driving along Route 66, and any lamp-post alongside it.
guid: c10b5746-9c29-11b1-9dad-c379636f7270
direct instance of: #$TransitiveBinaryPredicate #$IrreflexiveBinaryPredicate

(#$pointOnPath-Generic POINT PATH-GENERIC) holds just in case either (#$pointOnPath POINT PATH-GENERIC) or (#$pointOnCycle POINT PATH-GENERIC) holds. Note that (#$pointOnPath POINT PATH-GENERIC) and (#$pointOnCycle POINT PATH-GENERIC) cannot both hold, and hence (#$pointOnPath-Generic POINT PATH-GENERIC) amounts to (#$xor (#$pointOnPath POINT PATH-GENERIC) (#$pointOnCycle POINT PATH-GENERIC)).
guid: bf3dc2f7-9c29-11b1-9dad-c379636f7270
direct instance of: #$AsymmetricBinaryPredicate
direct specialization of: #$onPath

A specialization of the predicate #$onPath that relates a simple path (see #$Path-Simple) to any point on that path. (#$pointOnPath POINT PATH) means that POINT is a point along PATH. That is, POINT is on PATH but cannot move along PATH (even if it could move in some other sense). It might or might not be the case that POINT, or some part of it, is a part of PATH. POINT is not a subpath (see #$subPaths) of PATH; it is not something that is on PATH only occasionally (such as something moving along or stopped on PATH); and it is does not have PATH as a part (e.g. Washington DC is not a point on its own Pennsylvania Avenue). Note that the relative positions of points on a path do not in general form a linear order (see #$TotalOrdering) unless the points and the path are part of a particular #$PathSystem. For example, if no path system is specified, both Austin and Texas can be veiwed as points on Interstate 35.
guid: c0408997-9c29-11b1-9dad-c379636f7270
direct instance of: #$AsymmetricBinaryPredicate
direct specialization of: #$pointOnPath-Generic

(#$pointOnCycle POINT CYCLE) means that the #$Thing POINT is a stationary point (or place) on a #$Path-Cyclic CYCLE.
guid: c12d1757-9c29-11b1-9dad-c379636f7270
direct instance of: #$AsymmetricBinaryPredicate
direct specialization of: #$pointOnPath-Generic

(adjacentPathsAtJunction JUNCT PATH) means that the #$JunctionOfPaths JUNCT has PATH as one of the paths (instances of #$Path-Generic) joining it. A junction may connect many paths (it must connect at least three distinct paths), and a path may pass through many junctions, and may end at a junction. Examples: all the streets meeting at a certain #$Intersection-Street, the particular #$Trachea and both primary bronchi meeting at the #$TracheobronchialJunction between a certain person's #$Lungs, and three #$LongitudeLines intersecting at the #$SouthPole. Neither PATH nor JUNCTION need be instances of #$PartiallyTangible, #$TemporalThing, or #$SpatialThing; however if PATH is, JUNCTION must also be.
guid: bfd6e907-9c29-11b1-9dad-c379636f7270
direct instance of: #$AsymmetricBinaryPredicate

(#$betweenOnPath X Y Z PATH) means that X, Y and Z are points on the path PATH and X is between Y and Z. Note that this gives no ordering of Y and Z; it just claims that X is between them. Note: Given a #$Path-Customary PATH and points or places on PATH, #$betweenOnPath does not always determine a linear order (#$TotalOrdering) on the set of all points on PATH when PATH is not part of a specified #$PathSystem (since one thing on such a path -- #$onPath PATH -- may be part of another). However, in a specified #$PathSystem SYS, #$betweenOnPath does determine a linear order on the set of all points on PATH in SYS.
guid: c0e50f87-9c29-11b1-9dad-c379636f7270
direct instance of: #$QuaternaryPredicate

A #$CustomaryPathCycLConstant used for stating that a given path connects two things. (#$pathConnects PATH HERE THERE) means that PATH connects HERE and THERE. Often PATH is a physical path or connection along which objects or information may travel between HERE and THERE. Note that PATH might extend beyond HERE or THERE (cf. #$pathBetween). If PATH is bidirectional, then (#$pathConnects PATH THERE HERE) holds as well; but if PATH is unidirectional (see #$DirectedCustomaryPath), this does not hold; cf. the more general #$pathConnects-Commutative.
guid: c0f2a229-9c29-11b1-9dad-c379636f7270
direct instance of: #$TernaryPredicate

(#$pathBetween PATH X Y) means that the #$Path-Simple PATH goes between points (or places) X and Y, where X and Y do not 'overlap', and no further. Both X and Y have to be on PATH (see #$pointOnPath). Note that (#$pathBetween PATH X Y) is more specific than (#$pathConnects PATH X Y) because here the PATH cannot extend beyond X and Y. Within a particular #$PathSystem, a path's end points in the system are unique, and #$pathBetweenInSystem (q.v.) is restricted to paths and points in the system. When considered without a context of a path system, a path may have several different places at one end, such as Austin and Texas both being at the same end of some path along Highway I-35.
guid: c065f088-9c29-11b1-9dad-c379636f7270
direct instance of: #$TernaryPredicate
direct specialization of: #$pathConnects

(#$sideBranches MAINPATH SIDEPATH) means that the #$Path-Customary SIDEPATH ends where it joins the #$Path-Customary MAINPATH somewhere along the latter's length other than at an end. The basic nature and name of MAINPATH on either side of the junction does not change at that point; MAINPATH and SIDEPATH joined at a #$SideBranchJunction, which is a #$NonintrusiveJunction. Contrast this predicate with #$branchesInto.
guid: bf069a35-9c29-11b1-9dad-c379636f7270
direct instance of: #$AsymmetricBinaryPredicate #$ConnectionPredicate

A predicate that relates a given simple customary path (see #$Path-Simple and #$Path-Customary) to its terminating ends. (#$pathTerminus PATH END) means that END is a terminating end of PATH, and that there are no further paths of the same type issuing from END that are spatially disjoint from PATH itself. A terminal end of any simple customary path may be a dead-end (i.e. a closed-off path end) or it may be open; it cannot be a #$JunctionOfPaths with more paths of the same basic type issuing beyond it. Contrast this with the predicate #$deadEndInSystem, which indicates a terminus with respect to a specified #$PathSystem only.
guid: c10b572e-9c29-11b1-9dad-c379636f7270
direct instance of: #$BinaryPredicate
direct specialization of: #$endsOfPathSegment

(#$linksOfCustomarySystem ASSUMEDSYSTEM LINK) means that the #$CustomarySystemOfLinks ASSUMEDSYSTEM has the individual #$SimpleSegmentOfPath LINK as one of its links (where 'link' means a path with no junctions along it). Each such link is of the path type that ASSUMEDSYSTEM is made of: a highway system is assumed to be comprised of roadways linking junctions or towns (and some dead-ends); each roadway without junctions is one of the links. The parts of a road (pavement, streetlight, stripe in middle, culverts, etc.) are not #$linksOfCustomarySystem. Similarly the #$linksOfCustomarySystem of a plumbing system are the pipes, but not the straps holding the pipes. Thus a #$CustomarySystemOfLinks may have various kinds of #$parts that are not #$linksOfCustomarySystem. Contrast this with the formal case where a specified #$PathSystem is given; in this case the predicates #$linkInSystem and #$pathInSystem are used.
guid: be9b44d9-9c29-11b1-9dad-c379636f7270
direct instance of: #$AsymmetricBinaryPredicate #$PartPredicate
direct specialization of: #$parts

Path Predicates That Require A Specified Path System

A binary predicate that relates #$PathSystems (q.v.) to the points in those systems. (#$pointInSystem POINT SYSTEM) means that POINT is either a point on a path in, or a node in SYSTEM. Each path system has at least one point. Note that virtually any type of #$Thing can in principle serve as a point in some path-system (which is why the first argument-place of #$pointInSystem is not constrained to, e.g., instances of #$Individual). The set of all _nodes_ in a given path-system is an important subset of the set of all _points_ in that system; see #$nodeInSystem for the difference between nodes and other (i.e. non-node) points. See also #$PointsInSystemFn.
guid: c01c8e07-9c29-11b1-9dad-c379636f7270
direct instance of: #$AsymmetricBinaryPredicate

A specialization of #$pointInSystem (q.v.) that relates #$PathSystems (q.v.) to their nodes . (#$nodeInSystem NODE SYSTEM) means that NODE is a node in SYSTEM. The nodes of SYSTEM are distinguished from its other points as follows. (i) Every node in SYSTEM is a point in SYSTEM, but only nodes can be either end points of links (see #$linkBetweenInSystem), deadend points (see #$deadEndInSystem) or isolated points (i.e. points that are not on any link or loop; see #$isolatedNodeInSystem). (ii) Each point that is not a node must be somewhere on a single link. That is, for each point POINT in SYSTEM, either (#$pointOnPath POINT LINK) holds for unique link LINK in SYSTEM, or POINT is a node. Thus every intersection point (see #$junctionInSystem) in SYSTEM is a node. See also #$NodesInSystemFn.
guid: bfbd5122-9c29-11b1-9dad-c379636f7270
direct instance of: #$AsymmetricBinaryPredicate
direct specialization of: #$pointInSystem

(#$linkInSystem LINK SYS) means that LINK is an instance of #$Path-Simple taken as a primitive path (called a link) in the #$PathSystem SYS. For each link LINK in a path system SYS, there is a unique pair {X, Y} of different nodes in SYS (see #$nodeInSystem) such that X and Y are the two end-points of LINK in SYS. Other points can also be on LINK, but they cannot be nodes in SYS. There can be no point on a link that is different from its end points but nevertheless on another link; in other words, no matter how many points there are on a particular link in a path system, none of them can be an 'intersection' (see #$junctionInSystem) except the end points of the link, which are nodes in the system. Each link in SYS is also a path in SYS; that is, (#$linkInSystem LINK SYS) implies (#$pathInSystem LINK SYS). Note that there is no general collection of all links. Any path can be a link if you can somehow ignore the intersection points on it -- it all depends on the #$PathSystem. Note also that in some cases (such as talking about relations between different #$PathSystems), using (#$LinksFn SYS) to denote the set of all links in SYS is more convenient than using the predicate #$linkInSystem.
guid: bfe946ac-9c29-11b1-9dad-c379636f7270
direct instance of: #$AsymmetricBinaryPredicate
direct specialization of: #$pathInSystem

(#$linkBetweenInSystem LINK X Y SYS) means that in the #$PathSystem SYS, the #$Path-Simple LINK (a link in SYS, so that (#$linkInSystem LINK SYS) holds) has as its two end points X and Y (nodes in SYS, so that both (#$nodeInSystem X SYS) and (#$nodeInSystem Y SYS) hold). Since LINK connects the two end points X and Y when (#$linkBetweenInSystem LINK X Y SYS) holds, (#$linkBetweenInSystem LINK X Y SYS) implies (#$pathBetween LINK X Y). A link in a path system is a path whose end points are nodes in the system, and which has no other nodes along it (although it may have any number of non-node points along it). For each link LINK in SYS, there is a unique pair {X, Y} of different nodes in SYS such that (#$linkBetweenInSystem LINK X Y SYS) and (#$linkBetweenInSystem LINK Y X SYS) hold, and for any two nodes in SYS, there could be several different ('parallel') links between them. No point in SYS that is not a node can be an end point of a link. Only a node in SYS can be an 'intersection' point in SYS (see #$junctionInSystem), which implies that there is, in the system SYS, no point on a link LINK between X and Y that is an 'intersection' point of LINK and another link or a loop.
guid: be07a2f8-9c29-11b1-9dad-c379636f7270
direct instance of: #$QuaternaryPredicate
direct specialization of: #$pathBetweenInSystem

A #$PathSystemCycLConstant predicate that relates a given path system to each of the simple paths in it. (#$pathInSystem PATH SYS) means that PATH is a path in the system SYS. What constitutes a path in SYS is defined as follows. (i) Every link in SYS (see #$linkInSystem) is a path in SYS. (ii) Every subpath between points (see #$SubPathBetweenFn and #$pointInSystem) on a link in SYS is a path in SYS. (iii) The concatenation of paths PATH1 and PATH2 in SYS (see #$JoinPathsFn) is a path in SYS, provided there is only one point shared by both paths. Every path in the system is constructible by applying (i), (ii), and/or (iii) finitely many times. So for example a path in SYS might start somewhere along a link, go through several other links and nodes (see #$nodeInSystem), and end somewhere along a link. Or the path might simply go from one node to another. See also #$pathBetweenInSystem and #$linkBetweenInSystem.
guid: bd5a56eb-9c29-11b1-9dad-c379636f7270
direct instance of: #$AsymmetricBinaryPredicate

(#$pathBetweenInSystem PATH X Y SYS) means that PATH is a path in the #$PathSystem SYS, and X and Y are the end points (in the #$PathSystem) of PATH. If PATH is a link of the system (see #$linkInSystem), (#$pathBetweenInSystem PATH X Y SYS) iff (#$linkBetweenInSystem PATH X Y SYS). Note that there can be multiple paths in SYS between the same two points in SYS (which may or may not be nodes in SYS; see #$nodeInSystem). See also #$pathBetween when no #$PathSystem is specified.
guid: c0e14545-9c29-11b1-9dad-c379636f7270
direct instance of: #$QuaternaryPredicate

(#$cycleInSystem CYCLE SYS) means that CYCLE is a cycle in the path system SYS. A cycle in SYS is either a loop in SYS or the concatenation of two different paths PATH1 and PATH2 in SYS satisfying the following conditions: (i) there are two points X and Y in SYS such that (#$pathBetweenInSystem PATH1 X Y SYS) and (#$pathBetweenInSystem PATH2 X Y SYS), and (ii) no point in SYS other than X and Y is on both PATH1 and PATH2.
guid: be94da63-9c29-11b1-9dad-c379636f7270
direct instance of: #$AsymmetricBinaryPredicate

(#$loopInSystem LOOP SYS) means that LOOP is a 'loop' in SYS, which is like a link in SYS except that it has exactly one node on it as if it is a link whose two end nodes are the same. Each loop in SYS is also a cycle in SYS, see #$cycleInSystem. The differences between a loop and a (non-loop) cycle in SYS include that (i) there is exactly one point in SYS on a loop (which must be a node in SYS), but there may in general be any finite number of nodes (and even as many points as there are real numbers) on some (non-loop) cycle in SYS, and that (ii) The unique node in SYS on a loop may or may not be an end point of a link in SYS, but each node on a (non-loop) cycle in SYS must be an end point of at least two links in SYS. These imply that there can be at most one 'intersection point' on a loop in SYS but there can be any finite number of 'intersection points' on a (non-loop) cycle in SYS. See #$pointOnCycle and #$junctionInSystem. Note that under current treatment of loops in a path system, if one would like to talk about a 'loop' in a path system a 'part' of which is a path in the system, then he/she should make it a cycle rather than a loop in the system because according to what we said above, no 'part' of a loop in the system can be presented as a path in the system. Note also that in some cases (such as talking about relations between different #$PathSystems), using (#$LoopsInSystemFn SYS) to denote the set of all loops in SYS is more convenient than using the predicate #$loopInSystem.
guid: bf2899fb-9c29-11b1-9dad-c379636f7270
direct instance of: #$AsymmetricBinaryPredicate
direct specialization of: #$cycleInSystem

(#$junctionInSystem JUNCTION SYS) means that JUNCTION is a junction in the #$PathSystem SYS, i.e., a node in SYS that is an 'intersection' or 'branching point' of links or loops in SYS. (For the case when no SYS is specified, see #$JunctionOfPaths.) Formally, a node X in SYS is a junction in SYS iff either there are three (different) links in SYS such that X is on all of them, or there are two (different) loops in SYS such that X is on both of them, or there is a link in SYS and there is a loop in SYS such that X is on both of them. For different kinds of junctions in a path system, see #$threeWayJunctionInSystem, #$fourWayJunctionInSystem.
guid: bd9e3c53-9c29-11b1-9dad-c379636f7270
direct instance of: #$AsymmetricBinaryPredicate
direct specialization of: #$nodeInSystem

(#$threeWayJunctionInSystem JUNCT SYS) means that JUNCT is a 3-way junction in the specified #$PathSystem SYS. Formally, a 3-way junction in SYS is any point (actually, any node) X in SYS such that either there are exactly 3 links and no loops in SYS that X is on, or there are exactly 1 link and 1 loop in SYS that X is on. See #$junctionInSystem. When the junction is is simply a customary junction not based on a specified #$PathSystem, use #$ThreeWayJunctionOfPaths.
guid: c0d729ee-9c29-11b1-9dad-c379636f7270
direct instance of: #$AsymmetricBinaryPredicate
direct specialization of: #$finitaryJunctionInSystem #$junctionInSystem

(#$fourWayJunctionInSystem JUNCT SYS) means that JUNCT is a 4-way junction in the #$PathSystem SYS. Formally, a 4-way junction in SYS is any node X in SYS such that either there are exactly 4 links and no loops in SYS that X is on, there are exactly 2 loops and no links in SYS that X is on, or there are exactly 2 links and 1 loop in SYS that X is on.
guid: be3e5a74-9c29-11b1-9dad-c379636f7270
direct instance of: #$AsymmetricBinaryPredicate
direct specialization of: #$finitaryJunctionInSystem

(#$n-WayJu