(define (domain airport_map_merging)
        (:extends
	        (uri "http://www.daml.org/2001/10/html/airport-ont" :prefix airport)
	        (uri "http://www.daml.org/2001/06/map/map-ont" :prefix map)
                (uri "http://www.w3.org/2000/10/XMLSchema" :prefix xsd)
		(uri "http://www.w3.org/2000/01/rdf-schema" :prefix rdfs)
        )

        (:types
                Airport - Object
                Layer - Object
		Color - Object
		MapObject - Object
		Polygon - MapObject
		PredefinedLayer - Layer
		Point - MapObject
		Icon - MapObject
		Map - Object
		Location - Object
		DrawingLayer - Layer
		Line - MapObject
		String - Object
        )

        (:constants
		 red - Color
		 green - Color
		 blue - Color
	         @map:Layer1 - @map:DrawingLayer
	)


        (:predicates
	        (name ob1 - Object ob2 - Object)
                (iataCode ob1 - Object ob2 - Object)
                (icaoCode ob1 - Object ob2 - Object)
                (latitude ob1 - Object ob2 - Object)
                (longitude ob1 - Object ob2 - Object)
                (location ob1 - Object ob2 - Object)
                (elevation ob1 - Object ob2 - Object)

		(label ob1 - Object ob2 - Object)
		(layer ob1 - Object ob2 - Object)
		(color ob1 - Object ob2 - Object)
		(object ob1 - Object ob2 - Object)

		(underlyingObject ob1 - Object ob2 - Object)

		(is-Airport ob1 - Object)
		(is-Map ob1 - Object)
		(is-Location ob1 - Object)
		(is-Line ob1 - Object)
		(is-Point ob1 - Object)
		(is-Layer ob1 - Object)
		(is-Color ob1 - Object)
		(is-Polygon ob1 - Object)
		(is-PredefinedLayer ob1 - Object)
		(is-Icon ob1 - Object)
		(is-DrawingLayer ob1 - Object)
		(is-MapObject ob1 - Object)
        )

        (:axioms



	        (T-> @airport:Airport Airport)

		(T-> @map:Map Map)

		(T-> @xsd:string String)

                (forall (x - Airport y - Object)
		        (if (name x y)
	                    (is @xsd:string y)))

		(forall (x - Object)
		        (iff (@airport:is-Airport x) (is-Airport x)))

		(forall (x y - Object)
		        (if (and (is-Airport x) (name x y))
	                    (is @xsd:string y)))


                (forall (x - Map y - Object)
		        (if (name x y)
	                    (is @xsd:string y)))

		(forall (x - Object)
		        (iff (@map:is-Map x) (is-Map x)))

		(forall (x y - Object)
		        (if (and (is-Map x) (name x y))
	                    (is @xsd:string y)))



		(forall (x y - Object)
		        (if (@airport:name x y) (name x y)))


	        (forall (x z - Object)
		        (if (and (@rdfs:label x z) (is-Airport x))
			    (and (label (@skolem:aPoint x) - Point z)
			         (is @xsd:string z))))

	        (forall (x z - Object)
		        (if (and (@airport:location x z) (is-Airport x))
			    (and (label (@skolem:aPoint x) - Point z)
			         (is @xsd:string z))))

	        (forall (x z - Object)
		        (if (and (@airport:icaoCode x z) (is-Airport x))
			    (and (label (@skolem:aPoint x) - Point z)
			         (is @xsd:string z))))

	        (forall (x z - Object)
		        (if (and (@airport:iataCode x z) (is-Airport x))
			    (and (label (@skolem:aPoint x) - Point z)
			         (is @xsd:string z))))

	        (forall (x z - Object)
		        (if (and (@airport:name x z) (is-Airport x))
			    (and (label (@skolem:aPoint x) - Point z)
			         (is @xsd:string z))))


	        (forall (x - Airport z - Object)
		        (if (@rdfs:label x z)
			    (label (@skolem:aPoint x) - Point z)))

		(forall (x - Airport z - Object)
		        (if (@airport:location x z)
			    (label (@skolem:aPoint x) - Point z)))

	        (forall (x - Airport z - Object)
		        (if (@airport:icaoCode x z)
			    (label (@skolem:aPoint x) - Point z)))

	        (forall (x - Airport z - Object)
		        (if (@airport:iataCode x z)
			    (label (@skolem:aPoint x) - Point z)))

	        (forall (x - Airport z - Object)
		        (if (@airport:name x z)
			    (label (@skolem:aPoint x) - Point z)))


		(forall (x y z  - Object)
		        (if (and (@airport:latitude x y) (@airport:longitude x z)
                                 (is-Airport x))
			    (and
		                 (underlyingObject (@skolem:aPoint x) - Point (@built_in:expandPrefixtoURI x))
		                 (location (@skolem:aPoint x) - Point (@skolem:aLocation x) - Location)
                                 (latitude (@skolem:aLocation x) - Location y)
		                 (longitude (@skolem:aLocation x) - Location z)
		                 (object @map:Layer1 (@skolem:aPoint x) - Point))))

		(forall (x - Airport y z  - Object)
		        (if (and (@airport:latitude x y)
			         (@airport:longitude x z))
			    (and
		                 (underlyingObject (@skolem:aPoint x) - Point (@built_in:expandPrefixtoURI x))
		                 (location (@skolem:aPoint x) - Point (@skolem:aLocation x) - Location)
                                 (latitude (@skolem:aLocation x) - Location y)
		                 (longitude (@skolem:aLocation x) - Location z)
		                 (object @map:Layer1 (@skolem:aPoint x) - Point))))



                (forall (x y - Object)
		        (iff (@map:underlyingObject x y) (underlyingObject x y)))


		(forall (x - Airport y - Object)
		        (if (name x y)
		            (@airport:name x y)))

		(forall (x - Map y - Object)
		        (if (name x y)
		            (@map:name x y)))


		(forall (x y - Object)
		        (if (and (name x y) (is-Map x))
		            (@map:name x y)))


	        (forall (x y - Object)
		        (iff (@airport:iataCode x y) (iataCode x y)))


	        (forall (x y - Object)
		        (iff (@airport:icaoCode x y) (icaoCode x y)))


                (T-> @map:Location Location)

		(forall (x - Airport y - Object)
		        (if (latitude x y)
	                    (is @xsd:double y)))


		(forall (x y - Object)
		        (if (and (is-Airport x) (latitude x y))
	                    (is @xsd:double y)))


		(forall (x - Location y - Object)
		        (if (latitude x y)
	                    (is @xsd:double y)))

	        (forall (x - Object)
		        (iff (@map:is-Location x) (is-Location x)))


		(forall (x y - Object)
		        (if (and (is-Location x) (latitude x y))
	                    (is @xsd:double y)))


		(forall (x y - Object)
		        (iff (@map:latitude x y) (latitude x y)))


		(forall (x - Location y - Object)
		        (iff (latitude x y)
		             (@map:latitude x y)))


	        (forall (x y - Object)
		        (if (and (latitude x y) (is-Location x))
		            (@map:latitude x y)))


	        (forall (x - Airport y - Object)
		        (if (longitude x y)
	                    (is @xsd:double y)))

		(forall (x y - Object)
		        (if (and (is-Airport x) (longitude x y))
	                    (is @xsd:double y)))


		(forall (x - Location y - Object)
		        (if (longitude x y)
	                    (is @xsd:double y)))

		(forall (x y - Object)
		        (if (and (is-Location x) (longitude x y))
	                    (is @xsd:double y)))


		(forall (x - Location y - Object)
		        (iff (longitude x y)
		             (@map:longitude x y)))

		(forall (x y - Object)
		        (if (and (longitude x y) (is-Location x))
		            (@map:longitude x y)))



		(T-> @map:Point Point)

	        (forall (x - Object)
		        (iff (@map:is-Point x) (is-Point x)))


		(T-> @map:Line Line)

	        (forall (x - Object)
		        (iff (@map:is-Line x) (is-Line x)))

		(forall (x y - Object)
		        (if (and (is-Airport x) (location x y))
	                    (is @xsd:string y)))




		(forall (x y - Object)
		        (iff (@map:location x y) (location x y)))


		(forall (x - Point y - Object)
		        (if (location x y)
		            (@map:location x y)))

		(forall (x y - Object)
		        (if (and (location x y) (is-Point x))
		            (@map:location x y)))

                (forall (x - Object)
		        (if (is Line x)
                            (and (location x (@skolem:Line1 x) - Location) (location x (@skolem:Line2 x) - Location)
			         (not (= (@skolem:Line1 x) (@skolem:Line2 x))))))

                (forall (x - Object)
		        (if (is-Line x)
                            (and (location x (@skolem:Line1 x) - Location) (location x (@skolem:Line2 x) - Location)
			         (not (= (@skolem:Line1 x) (@skolem:Line2 x))))))


		(forall (x y - Object)
		        (if (and (is-Airport x) (elevation x y))
	                    (is @xsd:double y)))

		(forall (x y - Object)
		        (iff (@airport:elevation x y) (elevation x y)))


		(forall (x y - Object)
		        (if (and (is-Point x) (label x y))
	                    (is @xsd:string y)))

		(forall (x y - Object)
		        (iff (@map:label x y) (label x y)))



                (T-> @map:Layer Layer)

	        (forall (x - Object)
		        (iff (@map:is-Layer x) (is-Layer x)))


		(forall (x y - Object)
		        (if (and (is-Map x) (layer x y))
	                    (is-Layer y)))

		(forall (x y - Object)
		        (iff (@map:layer x y) (layer x y)))


		(forall (x y - Object)
		        (if (and (is-Layer x) (name x y))
	                    (is @xsd:string y)))



	     (T-> @map:DrawingLayer DrawingLayer)

	     (forall (x - Object)
		     (iff (@map:is-DrawingLayer x) (is-DrawingLayer x)))

	     (T-> @map:MapObject MapObject)

	     (forall (x - Object)
		     (iff (@map:is-MapObject x) (is-MapObject x)))

	     (forall (x y - Object)
		      (iff (@map:object x y) (object x y)))



            (T-> @map:Color Color)

	     (forall (x - Object)
		     (iff (@map:is-Color x) (is-Color x)))

	 

	    (forall (x y - Object)
		     (if (and (is-Line x) (color x y))
	                    (is-Color y)))



	    (forall (x y - Object)
		     (iff (@map:color x y) (color x y)))


            (T-> @map:Polygon Polygon)

	     (forall (x - Object)
		     (iff (@map:is-Polygon x) (is-Polygon x)))


	    (T-> @map:PredefinedLayer PredefinedLayer)

	     (forall (x - Object)
		     (iff (@map:is-PredefinedLayer x) (is-PredefinedLayer x)))

	    (T-> @map:Icon Icon)

	     (forall (x - Object)
		     (iff (@map:is-Icon x) (is-Icon x)))






	)
)