% Add times in the form [hours, minutes past]. % tadd(A, B, A+B). % A and B must be bound at call. tadd([Ah, Am], [Bh, Bm], [Sh, Sm]) :- Sm is Am + Bm, Sm < 60, Sh is Ah + Bh. tadd([Ah, Am], [Bh, Bm], [Sh, Sm]) :- X is Am + Bm, X >= 60, Sm is X - 60, Sh is Ah + Bh + 1. % Tell if a time in the form [hours, minutes past] is <= another. % tleq(A, B) % succeeds if A is earlier or the same as B. tleq([Ah, Am], [Ah, Bm]) :- Am =< Bm. tleq([Ah, _], [Bm, _]) :- Ah < Bm. % Encode the train schedule. The fact at(station, time, train) means that % the indicated train is stopped at the station at the indicated time. at(alphaville, [7,0], e1). at(fortuna, [8,10], e1). at(alphaville, [7,10], e2). at(betaville, [7,40], e2). at(clarksville, [8,30], e2). at(discovery, [9,10], e2). at(ephemeral, [10,0], e2). at(fortuna, [10,30], e2). at(gamesport, [11,20], e2). at(hope_springs, [12,0], e2). at(betaville, [7,20], e3). at(clarksville, [7,50], e3). at(discovery, [8,10], e3). at(fortuna, [8,40], e3). at(alphaville, [7,20], e4). at(discovery, [7,50], e4). at(fortuna, [8,30], e4). at(gamesport, [9,00], e4). at(hope_springs, [9,30], e4). at(betaville, [7,30], e5). at(clarksville, [8,20], e5). at(gamesport, [8,50], e5). at(hope_springs, [9,0], e5). at(alphaville, [7,40], e6). at(betaville, [8,10], e6). at(discovery, [8,50], e6). at(fortuna, [9,20], e6). at(gamesport, [9,40], e6). at(hope_springs, [10,0], e6). at(betaville, [7,50], e7). at(discovery, [8,10], e7). at(fortuna, [8,40], e7). at(alphaville, [7,50], e8). at(ephemeral, [8,30], e8). at(fortuna, [9,0], e8). at(gamesport, [9,20], e8). at(hope_springs, [9,40], e8). at(alphaville, [8,30], e9). at(betaville, [9,0], e9). at(ephemeral, [9,30], e9). at(fortuna, [9,50], e9). at(gamesport, [10,20], e9). at(hope_springs, [10,50], e9). at(clarksville, [8,40], e10). at(gamesport, [9,10], e10). at(alphaville, [9,30], e11). at(betaville, [10,0], e11). at(discovery, [10,30], e11). at(fortuna, [11,0], e11). at(hope_springs, [11,30], e11). at(alphaville, [10,10], e12). at(betaville, [10,50], e12). at(clarksville, [11,30], e12). at(ephemeral, [12,0], e12). at(alphaville, [9,0], w1). at(clarksville, [8,10], w1). at(discovery, [8,0], w1). at(ephemeral, [7,40], w1). at(fortuna, [7,20], w1). at(hope_springs, [7,0], w1). at(alphaville, [10,50], w2). at(betaville, [10,10], w2). at(clarksville, [9,30], w2). at(discovery, [9,0], w2). at(ephemeral, [8,20], w2). at(fortuna, [8,0], w2). at(gamesport, [7,30], w2). at(hope_springs, [7,10], w2). at(alphaville, [10,20], w3). at(clarksville, [9,40], w3). at(ephemeral, [9,10], w3). at(fortuna, [8,50], w3). at(gamesport, [8,20], w3). at(hope_springs, [7,50], w3). at(clarksville, [10,0], w4). at(gamesport, [8,40], w4). at(hope_springs, [8,20], w4). at(alphaville, [11,10], w5). at(discovery, [9,40], w5). at(hope_springs, [8,50], w5). at(discovery, [9,50], w6). at(hope_springs, [9,10], w6). at(discovery, [10,5], w7). at(hope_springs, [9,15], w7). at(betaville, [10,30], w8). at(discovery, [10,0], w8). at(ephemeral, [9,40], w8). at(hope_springs, [9,20], w8). at(betaville, [11,20], w9). at(discovery, [10,50], w9). at(ephemeral, [10,30], w9). at(gamesport, [10,10], w9). at(hope_springs, [9,50], w9). at(betaville, [10,40], w10). at(ephemeral, [10,10], w10). at(alphaville, [12,5], w11). at(betaville, [11,30], w11). at(discovery, [11,10], w11). at(fortuna, [10,50], w11). at(hope_springs, [10,20], w11). at(alphaville, [11,50], w12). at(clarksville, [11,20], w12). at(fortuna, [10,40], w12). % The predicate ride meaans that if you are available for boarding at % station Leave at time Now, and take train Train, you will arrive at % station Arrive at time Then. Now must be bound when used, and Leave % is sort of assumed to be, though I don't think the rule requires that. ride(Leave, Now, Arrive, Then, Train) :- at(Leave, LeaveTime, Train), tleq(Now, LeaveTime), at(Arrive, Then, Train), tleq(LeaveTime, Then). % The predicate trip(Leave, Now, Arrive, Then, Path, Trains) is true % if, given you are available to board a train at station Leave at time Now, % you can reach station Arrive at time Then, passing through a series of % stations given by the list Path, taking a series of trains given by the % list Trains. The list Path is a list of stations beginning with Leave % and ending with Arrive. The Predicate is requires at least 4 minutes % at each intermediate station for transfer time. I assume that the rule % is used with Leave and Now already bound. % This is the basis rule for trip. It represents a trip consisting of one % train ride, and is essentially a use of ride. trip(Leave, Now, Arrive, Then, [Leave, Arrive], [Train]) :- ride(Leave, Now, Arrive, Then, Train). % This is the recursive rule for Trip. It is satisfied if you can find a % ride from station Leave to some intermediate station XferSta on train Train, % arriving at time XWhen. After arriving, you must wait four minutes until % time WhenAvail, when you are available to board another train. You must % then be able to take a trip from XferSta to Arrive, arriving there at % time Then. The list of stations is Leave plus the stations traversed % in your trip from XferSta to Arrive. The list of trains is the one you % use to get to XferSta plus the ones you use from XferSta to Arrive. trip(Leave, Now, Arrive, Then, [Leave, XferSta | Route], [Train | Trains]) :- ride(Leave, Now, XferSta, XWhen, Train), Leave \= XferSta, Arrive \= XferSta, tadd(XWhen, [0,4], WhenAvail), trip(XferSta, WhenAvail, Arrive, Then, [XferSta | Route], Trains). % The clauses % Leave \= XferSta, Arrive \= XferSta, % just make sure that the system does not waste time padding trips with rides % that never leave the station. The station list is given as % [Leave, XferSta | Route] % in the rule just to give individual access to the first two members of % the list when writing the rule. % This is the top-level call. It is satisfied if you can, starting at 7:00 % at alphaville, take a trip to hope_springs, arrive at HopeTime, wait one % at least 1 minute until HopeLeaveTime, then travel back to alphaville, % arriving at PlaneTime, but not later than noon. The list Trains is just % the entire list of trains there and back, taken from each call to % trip and appended. The list Route is the list of stations likewise % created, except that hope_springs is not repeated. to_flight(PlaneTime, Route, Trains) :- trip(alphaville, [7,0], hope_springs, HopeTime, RouteTo, TrainsTo), tadd(HopeTime, [0,1], HopeLeaveTime), trip(hope_springs, HopeLeaveTime, alphaville, PlaneTime, [hope_springs | RouteFrom], TrainsFrom), tleq(PlaneTime, [12,0]), append(RouteTo, RouteFrom, Route), append(TrainsTo, TrainsFrom, Trains). % I use % [hope_springs | RouteFrom] % instead of the simle alternative % RouteFrom % to set RouteFrom to the route for the return trip _less_ the starting % station, hope_springs. This avoids repeating hope_springs in the final % list after the concatination. This works because I know the route from % the second use of trip must begin at hope_springs, so by forcing the % the route to resolve with [hope_springs | RouteFrom], I force the % variable to become the route less its first member.