Trains Schedule Puzzle Prolog Examples

```% Add times in the form [hours, minutes past].
% 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,
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),
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.```