namespace
  default=http://www.wsmo.org/2004/d3/d3.2/v0.1/20040531/resources/dt.wsml#
  dc=http://purl.org/dc/elements/1.1#
  wsml=http://www.wsmo.org/2004/d16/d16.1/v0.2/20040418#
  
ontology http://www.wsmo.org/2004/d3/d3.2/v0.1/20040531/resources/dt.wsml
non-functional-properties 
  dc:title "Date and Time Ontology"
  dc:creator "DERI International"
  dc:subject "Date", "Time", "Date and Time Algebra"
  dc:description "generic representation of data and time including basic algebra"
  dc:publisher "DERI International"
  dc:contributor "Holger Lausen", "Axel Polleres", "Ruben Lara"
  dc:date "2004-05-24"
  dc:type http://www.wsmo.org/2004/d2/v0.3/20040329/#ontos
  dc:format "text/plain"
  dc:language "en-US"
  dc:relation http://www.isi.edu/~pan/damltime/time-entry.owl, 
    http://www.w3.org/TR/xmlschema-2/  
  dc:coverage "general"
  dc:rights http://www.deri.org/privacy.html
  version "$Revision: 1.10 $"


conceptDefinitions

  concept instant 
    non-functional-properties
      dc:description "An instant represents a particular point in time"

  concept interval
    non-functional-properties
      dc:description "An interval represents a duration between 2 points in time"
    start oftype instant
    end oftype instant

  concept date 
    non-functional-properties
      dc:description "concept date and its representation according to the Gregorian calendar"
    subconceptOf instant
    dayOfMonth oftype dayOfMonth
    monthOfYear oftype monthOfYear
    year oftype year

  concept dayOfMonth 
    non-functional-properties
      dc:description "day of a month is represented by an integer"
    subconceptOf integer

  concept year 
    non-functional-properties
      dc:description "year is represented by an integer"
    subconceptOf integer

  concept monthOfYear 
    non-functional-properties
      dc:description "monthOfYear is represented by an integer"
    subconceptOf integer

  concept time
    hourOfDay oftype hourOfDay
    minuteOfHour oftype minuteOfHour
    secondOfMinute oftype secondOfMinute
  
  concept secondOfMinute 
    non-functional-properties
      dc:description "a secondOfMinute is represented by an integer"
    subconceptOf integer

  concept minuteOfHour 
    non-functional-properties
      dc:description "a minuteOfHour is represented by an integer"
    subconceptOf integer

  concept hourOfDay 
    non-functional-properties
      dc:description "a hourOfDay is represented by an integer"
    subconceptOf integer

  concept dateAndTime 
    non-functional-properties
      dc:description "concept date and time and representing together a specific point of time (instant)"
    subconceptOf instant
    date oftype date
    time oftype time


relationDefinitions

  relation invalid
    non-functional-properties
      dc:description "the invalid ralation is one way to encode an integrity constraints,
        if the extension of this relation is non empty the ontology is inconsitent, i.e.
        the extension contains all invalid resources.
        Axioms can be used to define the extension e.g. validMonthOfYear"
    parameter AnyObject
      non-functional-properties
        dc:description "the relation has only one parameter which can be of any type 
          (oftype defintions is omitted)."
  
  relation <
    non-functional-properties
      dc:description "The smaller as relation (<) denotes the ordinal relationship
        between X and Y, such as (X,Y) is a tuple of the binary relation < iff
        X is a predecessor of Y.
        Note: This relation is not used in the prefix notation '<'(X,Y) but in 
        infix notation: X < Y
        In this ontology we extend this (for numbers) common notion to instants
        (particular points in time)"
      dc:relation >
    parameter X oftype instant
    parameter Y oftype instant
    
  relation >
    non-functional-properties
      dc:description "The greater then relation (>) denotes the ordinal relationship
        between X and Y, such as (X,Y) is a tuple of the binary relation < iff
        X is a sucessor of Y.
        Note: This relation is not used in the prefix notation '>'(X,Y) but in 
        infix notation: X > Y
        In this ontology we extend this (for numbers) common notion to instants
        (particular points in time)"
      dc:relation >
    parameter X oftype instant
    parameter Y oftype instant
  
  comment: obviously the following relations would be more intuitive as function
  comment: symbols, however the current WSMO Meta Model only allows nary relations
  relation julianDayNumber
    non-functional-properties
      dc:description "The Julian Day Count is a uniform count of days from a remote epoch 
        in the past (about 4712 BC). At this instant, the Julian Day Number is 0. Once 
        you have the Julian Day Number of a particular date in history, it is easy to 
        calculate time elapsed between it and any other Julian Day Number"
      dc:source http://quasar.as.utexas.edu/BillInfo/JulianDatesG.html
    parameter Instant oftype instant
      non-functional-properties
        dc:descripion "For each instant there should exist a corresponding Julian Day 
          Number, however it may not be always defined only by this binary predicate, 
          e.g. if the instant is represented as Gregorian Date and it is a date between 
          1582 and 1924 a country  must be given as third parameter (since e.g. Greece 
          changed no earlier then 9th of March 1924 from the Julian to the Gregorian Calendar)"
        comment: The following dc:source indicates which country changed in which year 
        comment: from the Julian to the Gregorian Calendar
        dc:source http://members.brabant.chello.nl/~h.reints/cal/whenjul2greg.htm
    parameter JulianDayNumber oftype instant

  relation daysBetween
    non-functional-properties
      dc:description "(Instant1, Instant2, Difference) is a triple of the ternary relation 
        daysBetween iff Instant1 and Instant2 are members of the concept 'instant' (particular 
        point in time) and Instant2 is 'Difference' days after Instant1."
    parameter Instant1 oftype instant
    parameter Instant2 oftype instant
    parameter Difference oftype integer

   relation secondsBetween
     non-functional-properties
       dc:description "(Instant1, Instant2, Difference) is a triple of the ternary relation 
        secondsBetween iff Instant1 and Instant2 are members of the concept 'instant' (particular 
        point in time) and Instant2 is 'Differnce' seconds after Instant1."
      parameter Instant1 oftype instant
      parameter Instant2 oftype instant
      parameter Difference oftype integer

  relation secondsFromMidnight
    non-functional-properties
      dc:description "(Time, SecondsFromMidnight) is a tuple of the binary relation 
        secondsFromMidnight iff SecondsFromMidnight are the seconds elapsed from
        00:00:00 of the same day.
        This simplifies the axiomatization of the difference between two given times"
    parameter Time oftype time
    parameter SecondsFromMidnight oftype integer
    
  relation contains
    non-functional-properties
      dc:description "(Interval, X) is a tuple of the binary relation 
        contains iff Interval contains X and X is an instant or an interval"
    parameter Interval1 oftype interval
    parameter X oftype (instant or interval)
    

axiomDefintions

  axiom validMonthOfYear
    non-functional-properties
      dc:description "integrity constraint for valid monthOfYear"
    logical-expression
    "invalid (X) <-
       X memberOf monthOfYear and 
       (X < 1 or X > 12)."

  axiom validDayOfMonth
    non-functional-properties
      dc:description "integrity constraint for valid dayOfMonths"
    logical-expression
      "invalid (X) <-
         X memberOf dayOfMonth and 
         (X < 1 or X > 31)."

  axiom validDate
    non-functional-properties
      dc:description "Integrity Constraints for date.
        The dayOfMonth is valid in dependency of the actual monthOfYear, in a leap
        year the month 2 of the Year has 29 days otherwise 28. For leap years holds
        the following:  Every year divisible by 4 is a leap year.  However, every 
        year divisible by 100 is not a leap year. However, every year divisible by 
        400 is a leap year after all.
        
        Note: This axiomatization is still impricse, since the country plays a role
        when defining a valid day of the month: E.g. 1712 was a double leap year
        in Sweden, i.e. February 1712 had 30 days in Sweden.
        
        The mathimatical function symbol modulo is assumed to be defined elsewhere
        as that it returns the remainder after an integer division of its 
        first argument by its second"
      dc:source http://www.tondering.dk/claus/cal/node3.html

    logical-expression
      "invalid (X) <-
         X memberOf date and 
         (invalid(X.monthOfYear) or invalid(X.year)
         or (X.dayOfMonth > 31 and X.monthOfYear = 1)
         or (X.dayOfMonth > 28 and X.monthOfYear = 2 
           and not (modulo(X.year,4) = 0 and (modulo(X.year,100) != 0 or modulo(X.year,400) = 0)))
         or (X.dayOfMonth > 29 and X.monthOfYear = 2)
         or (X.dayOfMonth > 31 and X.monthOfYear = 3)
         or (X.dayOfMonth > 30 and X.monthOfYear = 4)
         or (X.dayOfMonth > 31 and X.monthOfYear = 5)
         or (X.dayOfMonth > 30 and X.monthOfYear = 6)
         or (X.dayOfMonth > 31 and X.monthOfYear = 7)
         or (X.dayOfMonth > 31 and X.monthOfYear = 8)
         or (X.dayOfMonth > 30 and X.monthOfYear = 9)
         or (X.dayOfMonth > 31 and X.monthOfYear = 10)
         or (X.dayOfMonth > 30 and X.monthOfYear = 11)
         or (X.dayOfMonth > 31 and X.monthOfYear = 12)
         )."

  axiom validHourOfDay
    non-functional-properties
      dc:description "integrity constraint for valid hourOfDay:"
    logical-expression
      "invalid (X) <-
         X memberOf hourOfDay and 
         (X < 0 or X > 23)."

  axiom validMinuteOfHour
    non-functional-properties
      dc:description "integrity constraint for valid minuteOfHour:"
    logical-expression
      "invalid (X) <-
         X memberOf minuteOfHour and 
         (X < 0 or X > 59)."

  axiom validSecondOfMinute
    non-functional-properties
      dc:description "integrity constraint for valid secondOfMinute:"
    logical-expression
      "invalid (X) <-
         X memberOf secondOfMinute and 
         (X < 0 or X > 59)."

  axiom validTime
    non-functional-properties
      dc:description "integrity constraint for valid time:"
    logical-expression
      "invalid (X) <-
         X memberOf time and 
         (invalid(X.hourOfDay) or invalid(X.minuteOfHour) or invalid(X.secondOfMinute))."

  axiom validDateAndTime
    non-functional-properties
      dc:description "integrity constraint for valid dateAndTimes:"
    logical-expression
      "invalid (X) <-
         X memberOf dateAndTime and 
         (invalid(X.date) or invalid(X.time))."

  axiom equalityDate
    non-functional-properties
      dc:description "computes equality of a date"
    logical-expression
      "X = Y <-
         Y memberOf date and X memberOf date and
         X.dayOfMonth = Y.dayOfMonth and
         X.monthOfYear = Y.monthOfYear and
         X.year = Y.year."

  axiom beforeDate
    non-functional-properties
      dc:description "computes if a given date X is before another date Y"
    logical-expression
      "X < Y <-
        Y memberOf date and X memberOf date and
        ((X.dayOfMonth = Y.dayOfMonth and X.monthOfYear = Y.monthOfYear and X.year = Y.year) or
        (X.monthOfYear < Y.monthOfYear and X.year = Y.year) or
        (X.year < Y.year))."


  axiom afterDate
    non-functional-properties
      dc:description "defined as inverse of beforeDate"
    logical-expression
      "X > Y <- Y < X"
      
  axiom julianDayNumber
    non-functional-properties
      dc:description "This Axiom describes how the correct Julian Day Number
        can be computed for a given Gregorian Calendar Date. Note
        that the Gregorian Calendar was introduced in 15.October 1582. 
        however until 1919 this axiomatization is not unambiguous since the country
        should be taken into to account as 3rd parameter (e.g. Greece 
        changed at the 9 Mar 1924 from the Julian to the Gregorian calendar).
        
        Details to the axiomatization
        If the month is January or February we subtract 1 from the year to get a new Year
        and add 12 to the month to get a new Month. (Thus, we are thinking of January and 
        February as being the 13th and 14th month of the previous year and March is the 
        start of the year, this simplifies the calculation considering the leap year)
        
        Within the calculation the fractional part of all results has to be dropped,
        here we use the function symbol floor() [it can be rewritten as predicate,
        however it gets less readable]
        
        A more lengthy description of this axiomatization can be found at
        http://quasar.as.utexas.edu/BillInfo/JulianDatesG.html"
        
      dc:source http://quasar.as.utexas.edu/BillInfo/JulianDatesG.html,
        http://members.brabant.chello.nl/~h.reints/cal/whenjul2greg.htm
    logical-expression
      "julianDayNumber(X, JDN) <-
         X memberOf date and
         ((
            X.monthOfYear < 3 and
            Y = X.year -1 and
            M = X.monthOfYear + 12
          ) 
          or 
          (
            X.monthOfYear > 2 and
            Y = X.year and
            M = X.monthOfYear 
         ))
         and
         D = X.dayOfMonth and
         A = floor(Y / 100) and
         B = floor(A / 4) and
         C = 2 - A + B and
         E = floor(365.25 * (Y + 4716)) and
         F = floor(30.6001 * (M + 1)) and
         JDN = C + D + E + F - 1524."

  axiom daysBetweenDates
    non-functional-properties
      dc:description "the difference in days between 2 dates"
    logical-expression
      "daysBetween(D1, D2, X) <-
         D1 memberOf date and D2 memberOf date and
         julianDayNumber(D1, JDN_D1) and
         julianDayNumber(D2, JDN_D2) and
         X = JDN_D1 - JDN_D2."

  axiom equalityTime
    non-functional-properties
      dc:description "computes if two given times are the same"
    logical-expression
      "X = Y <-
         X memberOf time and Y memberOf time and
         X.secondOfMinute = Y.secondOfMinute and
         X.minuteOfHour = Y.minuteOfHour and 
         X.hourOfDay = Y.hourOfDay."

  axiom beforeTime
    non-functional-properties
      dc:description "computes if a given time X is before another time Y"
    logical-expression
      "X < Y <-
         X memberOf time and Y memberOf time and
         ((X.secondOfMinute < Y.secondOfMinute and X.minuteOfHour = Y.minuteOfHour and X.hourOfDay = Y.hourOfDay) or
         (X.minuteOfHour < Y.minuteOfHour and X.hourOfDay = Y.hourOfDay) or
         (X.hourOfDay < Y.hourOfDay))."

  axiom afterTime
    non-functional-properties
      dc:description "defined as inverse of beforeTime"
    logical-expression
      "X > Y <- Y < X."

  axiom secondsFromMidnight
    non-functional-properties
      dc:description "computes the amount of seconds from midnight"
    logical-expression
      "secondsFromMidnight(T, X) <-
         T memberOf time and
         X = T.secondOfMinute + (T.minuteOfHour*60) + (T.hourOfDay*60*60)."

  axiom secondsBetweenTimes
    non-functional-properties
      dc:description "the difference in seconds between 2 times"
    logical-expression
      "secondsBetween(T1, T2, X) <-
         T1 memberOf time and T2 memberOf time and
         secondsFromMidnight(T1, SFM_T1) and
         secondsFromMidnight(T2, SFM_T2) and
         X = SFM_T1 - SFM_T2."

  axiom equalityDateAndTime
    non-functional-properties
      dc:description "computes if Date and Time are equal"
    logical-expression
      "X = Y <-
         X memberOf dateAndTime and Y memberOf dateAndTime and
         X.date = Y.date and
         X.time = Y.time."

  axiom beforeDateAndTime
    non-functional-properties
      dc:description "computes if a given date and time X is before another date and time Y"
    logical-expression
      "X < Y <-
        X memberOf dateAndTime and Y memberOf dateAndTime and
        ((X.date = Y.date and X.time < Y.time) or
         X.date < Y.date)."

  axiom afterDateAndTime
    non-functional-properties
    dc:description "defined as inverse of beforeDateAndTime"
    logical-expression
    "X > Y <- Y < X."

  axiom secondsBetweenDateAndTime
    non-functional-properties
      dc:description "computes the difference in seconds between two different DateAndTime"
    logical-expression
      "secondsBetween(D1, D2, X) <-
        D1 memberOf dateAndTime and D2 memberOf dateAndTime and
        julianDayNumber(D1.date, JDN_D1) and
        julianDayNumber(D2.date, JDN_D2) and
        secondsFromMidnight(D1.time, SFM_T1) and
        secondsFromMidnight(D2.time, SFM_T2) and
        X = SFM_T1 + JDN_D1 * 24 * 60 * 60 -
            (SFM_T2 + JDN_D2 * 24 * 60 * 60)."

  axiom daysBetweenDateAndTime
    non-functional-properties
      dc:description "the difference in days between two different DateAndTime"
    logical-expression
      "daysBetween(D1, D2, X) <-
        D1 memberOf dateAndTime and D2 memberOf dateAndTime and
        daysBetween(D1.date, D2.date, X)."

  axiom intervalContainment
    non-functional-properties
      dc:description "computes if a interval X contains a second interval Y"
    logical-expression
      "contains(X, Y) <-
         X memberOf interval and Y memberOf interval and
         (X.start < Y.start or X.start = Y.start) and
         (X.end > Y.end or X.end = Y.end)."

  axiom instantContainment
    non-functional-properties
    dc:description "computes if a interval X contains a instant Y"
    logical-expression
    "contains(X, Y) <-
       X memberOf interval and Y memberOf instant and
       (X.start < Y or X.start = Y) and
       (X.end > Y or X.end = Y)."