;;; Mode: Lisp; Package: ocml
;;; File created in WebOnto
(in-package "OCML")
(in-ontology lpmo)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;; lpmo descriptions;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(def-class #_description (#_sdpo:description)
((has-title :type string)
(has-description :type string)
(d-uses :type #_parameter)))
(def-class #_actor-profile (#_description)
((d-uses :type #_parameter)))
(def-class #_object-description (#_description)
((d-uses :type #_object-parameter)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;; lpmo context and situation ;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(def-class #_situation (#_sdpo:situation))
(def-class #_state-situation (#_situation)
((has-part :type #_state-situation)
(part-of :type #_state-situation)
(satisfies :type #_state-description)))
(def-class #_state-description (#_description) ?sd
((d-uses :type #_situation-parameter :min-cardinality 2))
:constraint (exists (?r ?s)
(and (d-uses ?sd ?r)
(#_functional-role ?r)
(d-uses ?sd ?s)
(#_parameter ?s))))
(def-class #_mobile-state-situation (#_state-situation)
((has-part :type #_mobile-state-situation)
(part-of :type #_mobile-state-situation)
(satisfies :type #_mobile-state-description)))
(def-class #_mobile-state-description (#_description) ?sd
((d-uses :type #_mobile-situation-parameter :min-cardinality 2))
:constraint (exists (?r ?s)
(and (d-uses ?sd ?r)
(#_functional-role ?r)
(d-uses ?sd ?s)
(#_parameter ?s))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;; lpmo parameter ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(def-class #_parameter (#_sdpo:situation-parameter)
((has-instance-title :type string)
(has-parameter-title :type string)))
(def-class #_situation-parameter (#_parameter))
(def-class #_state-parameter (#_situation-parameter))
(def-class #_mobile-situation-parameter (#_parameter))
(def-class #_mobile-state-parameter (#_mobile-situation-parameter))
(def-class #_object-parameter (#_parameter))
(def-class #_aim (#_state-parameter)
((has-parameter-title :value "Aim")
(defined-by :type (or (#_aim-description aim-member)))))
(def-class #_mobile-aim (#_mobile-state-parameter)
((has-parameter-title :value "Aim")
(defined-by :type (or (#_aim-description aim-member)))))
(def-class #_aim-description (#_description)
((d-uses :type #_competency)))
(def-class #_state-location (#_mobile-state-parameter)
((has-parameter-title :value "Situational Location")))
(def-class #_profile-parameter (#_situation-parameter))
(def-class #_competency (#_profile-parameter)
((level :type string)
(has-parameter-title :value "Competency")
(has-description :type string)
(is-equivalent-to :type #_equivalent-competencies-list)
(is-similar-to :type #_similar-competencies-list)
(hasAssociatedDomainConcepts :type list)
(targets-location :type #_location)
(targets-aim :type #_aim)
(requires-comp :type #_requires-competencies-list)))
(def-class #_gap-parameter (#_state-parameter #_mobile-state-parameter)
((has-parameter-title :value "Competency Gap")))
(def-class #_equivalent-competencies-list (list))
(def-class #_similar-competencies-list (list))
(def-class #_requires-competencies-list (list))
(def-class #_technical-environment (#_profile-parameter)
((has-parameter-title :value "Technical Environment")))
(def-class #_educational-method (#_profile-parameter)
((has-parameter-title :value "Educational Method")))
(def-class #_learning-style (#_profile-parameter)
((has-parameter-title :value "Learning Style")
(defined-by :type #_css:fslsm-member)))
(def-class #_prototypical-learning-style (#_profile-parameter)
((has-parameter-title :value "Prototypical Learning Style")
(defined-by :type #_css:fslsm-prototypical-member)))
(def-class #_location (#_profile-parameter #_mobile-state-parameter)
((has-parameter-title :value "Location")
(defined-by :type #_css:location-member)))
(def-class #_latitude (#_mobile-state-parameter)
((has-parameter-title :value "Latitude")))
(def-class #_longitude (#_mobile-state-parameter)
((has-parameter-title :value "Longitude")))
(def-class #_profile-interaction-type (#_profile-parameter)
((has-parameter-title :value "Actor Interaction")
(defined-by :value #_css:interaction-member)))
(def-class #_state-interaction-type (#_state-parameter #_mobile-state-parameter)
((has-parameter-title :value "Situational Interaction")))
(def-class #_learning-time (#_mobile-state-parameter #_state-parameter)
((has-min-time :type integer)
(has-max-time :type integer)
(has-parameter-title :value "Learning Time")))
(def-class #_state-language (#_mobile-state-parameter #_state-parameter)
((has-parameter-title :value "Situational Language")))
(def-class #_runtime-environment (#_technical-environment)
((supports-standard :type #_metadata-standard)
(has-parameter-title :value "Runtime Environment")))
(def-class #_metadata-standard (#_state-parameter)
((has-parameter-title :value "Metadata Standard")))
(def-class #_profile-language (#_profile-parameter)
((has-parameter-title :value "Actor Language")))
(def-class #_actor (#_parameter)
((defined-by :type #_actor-profile)
(has-parameter-title :value "Actor")))
(def-class #_resource (#_parameter)
((targets :type #_goal)))
(def-class #_domain (#_parameter)
((has-parameter-title "Domain")))
(def-class #_service (#_resource))
(def-class #_object (#_resource)
((has-parameter-title :value "Object")
(defined-by :type #_object-description)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;; lpmo process (parameters...) ;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(def-class #_goal-description (#_description)
((has-effect :type #_state-description)
(has-assumption :type #_state-description)))
(def-class #_action-goal-description (#_goal-description))
(def-class #_support-goal-description (#_goal-description))
(def-class #_get-situation-parameters-goal-description (#_support-goal-description))
(def-class #_get-competency-gap-goal-description (#_support-goal-description))
(def-class #_get-actor-profile-goal-description (#_support-goal-description))
(def-class #_flow-element (#_parameter)
((part-of :type #_composite-process-entity)
(has-predecessor :type #_flow-element)
(has-successor :type #_flow-element)))
(def-class #_goal (#_flow-element) ?lg
((plays :type #_goal-role)
(defined-by :type #_goal-description)
(adressess-aim :type #_aim))
:constraint (exists (?r ?s)
(and (plays ?lg ?r)
(#_action-goal-role ?r)
(defined-by ?lg ?s)
(#_action-goal-description ?s)))
:constraint (exists (?t ?u)
(and (plays ?lg ?t)
(#_process-goal-role ?t)
(defined-by ?lg ?u)
(#_process-goal-description ?u)))
:constraint (exists (?v ?w)
(and (plays ?lg ?v)
(#_support-goal-role ?v)
(defined-by ?lg ?w)
(#_support-goal-description ?w))))
(def-class #_process () ?lp
((defined-by :type #_process-description)
(targets :type #_goal))
:constraint (for-all (?x ?y)
(and (targets ?lp ?x)
(#_goal ?x)
(plays ?x ?y)
(#_process-goal-role ?y))))
(def-class #_action-type (#_parameter))
(def-class #_process-entity (#_flow-element)
((targets :type #_goal)
(type :type #_actiont-type)
(has-predecessor :type #_flow-element :max-cardinality 1)
(has-successor :type #_flow-element :max-cardinality 1)))
(def-class #_action-type (#_parameter))
(def-class #_assessment-type (#_action-type))
(def-class #_learning-type (#_action-type))
(def-class #_action-entity (#_process-entity) ?ae
()
:constraint (for-all (?x ?y)
(and (targets ?ae ?x)
(#_goal ?x)
(plays ?x ?y)
(#_action-goal-role ?y))))
(def-class #_composite-process-entity (#_process-entity)
((has-part :type #_flow-element)))
(def-class #_action-entity-sequence (#_composite-process-entity)
((has-part :type #_action-entity)))
(def-class #_control-flow-entity (#_flow-element))
(def-class #_loop-entity (#_control-flow-entity)
((executes :type #_process-entity)))
(def-class #_loop-until-entity (#_loop-entity))
(def-class #_loop-while-entity (#_loop-entity))
(def-class #_intersection-entity (#_control-flow-entity) ?ie
:constraint (exists (?r ?s)
(and (has-successor ?ie ?r)
(not (#_intersection-entity ?r))
(has-predecessor ?ie ?s)
(not (#_intersection-entity ?s)))))
(def-class #_merge-entity (#_intersection-entity)
((has-predecessor :type #_process-entity :min-cardinality 2)))
(def-class #_simple-merge-entity (#_merge-entity))
(def-class #_synchronization-entity (#_merge-entity))
(def-class #_branch-entity (#_intersection-entity)
((has-successor :type #_process-entity :min-cardinality 2)))
(def-class #_multiple-choice-entity (#_branch-entity))
(def-class #_exclusive-choice-entity (#_branch-entity))
(def-class #_parallel-split-entity (#_branch-entity))
(def-class #_process-description (#_description) ?pd
((d-uses :min-cardinality 2))
:constraint (exists (?r ?s ?t)
(and (d-uses ?pd ?r)
(#_goal ?r)
(d-uses ?pd ?s)
(#_flow-element ?s))))
(def-class #_condition ())
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;; lpmo roles ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(def-class #_role (#_sdpo:situation-role)
((has-title :type string)))
(def-class #_description-role (#_role))
(def-class #_goal-role (#_description-role)
((played-by :type #_goal)))
(def-class #_action-goal-role (#_goal-role))
(def-class #_process-goal-role (#_goal-role))
(def-class #_support-goal-role (#_goal-role))
(def-class #_functional-role (#_role))
(def-class #_actor-role (#_functional-role)
((played-by :type #_actor)))
(def-class #_learner-role (#_actor-role))
(def-class #_resource-role (#_functional-role)
((played-by :type #_resource)))
(def-class #_repository-role (#_resource-role)
((played-by :type #_repository)))
(def-class #_repository (#_resource)
((has-parameter-title :value "Repository")
(has-url :type string)
(has-description :type string)
(targetsLanguage :type list)
(targetsDomain :type list)
(targetsCompetency :type list)
(targetsCompetencyInDomain :type list)))
;;; repository instances
(def-instance #_oai-language-rep #_repository
((has-instance-title "OAI-LANGUAGE-REP")
(has-url "http://www.lang.ltsn.ac.uk/oai/oai.aspx")
(has-description "Higher Education Academy Repository for Languages & Linguistics")
(targetsLanguage ("French" "English"))
(targetsDomain (linguistic languages))
(targetsCompetency (basic-french-comp expert-french-comp advanced-french-comp))
(targetsCompetencyInDomain (linguistic-french-language basic-french-in-languages-competency advanced-french-in-languages-competency))
))
(def-instance #_open-learn-language-rep #_repository
((has-instance-title "OPEN-LEARN-LANGUAGE-REP")
(has-url "http://openlearn.open.ac.uk/course/category.php?id=9")
(has-description "Modern Languages in Open Learn")
(targetsLanguage ("English"))
(targetsDomain (managerial languages linguistic))
(targetsCompetency (expert-french-comp basic-french-comp advanced-french-comp))
(targetsCompetencyInDomain (managerial-french-language basic-french-in-languages-competency advanced-french-in-languages-competency))
))
(def-instance #_open-learn-history-rep #_repository
((has-instance-title "OPEN-LEARN-ARTS-AND-HISTORY-REPOSITORY")
(has-url "http://openlearn.open.ac.uk/course/category.php?id=3")
(has-description "Arts and History in Open Learn")
(targetsLanguage ("English"))
(targetsDomain (history ol-arts-history))
(targetsCompetency (basic-brighton-pavillion-comp advanced-brighton-pavillion-comp))
))
(def-instance #_open-learn-maths-rep #_repository
((has-instance-title "OPEN-LEARN-MATHS-REP")
(has-url "http://openlearn.open.ac.uk/course/category.php?id=8")
(has-description "Mathematics and Statistics in Open Learn")
(targetsLanguage ("English"))
(targetsDomain (maths))
(targetsCompetency (basic-maths-comp expert-maths-comp advanced-maths-comp))
(targetsCompetencyInDomain (basic-maths-in-maths-competency differential-equations-in-maths-competency fourier-modelling-in-maths-competency))
))
(def-instance #_open-learn-live-rep #_repository
((has-instance-title "OPEN-LEARN-LIVE-REPOSITORY")
(has-url "http://www.open.ac.uk/openlearn/")
(has-description "Live Query on the Open Learn Resources.")
(targetsLanguage ("English"))
(targetsDomain (maths managerial linguistic ol-arts-history ol-business-management ol-society ol-study-skills ol-how-to ol-education ol-health-lifestyle ol-it-computing ol-mathematics-statistics ol-modern-languages ol-science-nature ol-technology))
(targetsCompetency (basic-maths-comp expert-maths-comp advanced-maths-comp))
(targetsCompetencyInDomain (basic-maths-in-maths-competency differential-equations-in-maths-competency fourier-modelling-in-maths-competency))
))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;; metadata representations ;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(def-class #_metadata-representation (#_sdpo:description))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;; ims ld from here ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(def-class #_imsld-representation (#_metadata-representation)
((has-title :type string)
(has-id :type string) ;;;#_imsld-compliant ids without blanks
(refines :type (or(#_process-description #_parameter)))))
(def-class #_imsld-component (#_imsld-representation)
())
(def-class #_imsld-design (#_imsld-representation) ?id
((refines :type #_process-description)
(has-method :type #_imsld-method)
(has-components :type #_imsld-components)
(targets :type #_imsld-objective))
:constraint (exists (?r ?s ?t)
(and (targets ?id ?r)
(#_imsld-objective ?r)
(refines ?r ?s)
(#_goal ?s)
(plays ?s ?t)
(#_process-goal-role ?t))))
(def-class #_imsld-activity-entity (#_imsld-component)
((refines :type #_process-entity)
(has-scuccessor :type #_imsld-activity-entity)
(has-predecessor :type #_imsld-activity-entity)
(is-visible :type boolean)))
(def-class #_imsld-activity (#_imsld-activity-entity) ?ia
((refines :type #_action-entity)
(has-description :type #_imsld-activity-description)
(has-completion :type (or (#_imsld-user-choice #_imsld-time-limit #_imsld-valued-property)))
(has-environment :type #_imsld-environment)
(targets :type #_imsld-objective))
:constraint (exists (?r ?s ?t)
(and (targets ?ia ?r)
(#_imsld-objective ?r)
(refines ?r ?s)
(#_goal ?s)
(plays ?s ?t)
(#_action-goal-role ?t))))
(def-class #_imsld-user-choice (#_imsld-representation)
((has-completion-value :type boolean)))
(def-class #_imsld-time-limit (#_imsld-representation)
())
(def-class #_imsld-learning-activity (#_imsld-activity)
())
(def-class #_imsld-support-activity (#_imsld-activity)
())
(def-class #_imsld-activity-description (#_imsld-representation)
((grounded-to :type #_imsld-item)))
(def-class #_imsld-activity-structure (#_imsld-activity-entity) ?as
((refines :type #_composite-process-entity)
(has-activity-ref :type #_imsld-activity :min-cardinality 1))
:constraint (exists (?r ?s ?t)
(and (refines ?as ?r)
(#_composite-process-entity ?r)
(has-part ?r ?s)
(#_action-entity ?s))))
(def-class #_imsld-environment (#_imsld-component)
((is-visible :type boolean)
(composed-of :type #_imsld-environment-entity)))
(def-class #_imsld-environment-entity (#_imsld-representation)
((refines :type #_resource)))
(def-class #_imsld-learning-object (#_imsld-environment-entity)
((refines :type #_object)
(grounded-to :type #_imsld-item)))
(def-class #_imsld-learning-service (#_imsld-environment-entity)
((refines :type #_service)
(grounded-to :type #_imsld-item)))
(def-class #_imsld-item (#_imsld-representation) ?ii
((refines :type #_resource)
(is-visible :type boolean)
(has-href :type string))
:constraint (exists (?r ?s) (and (has-href ?ii ?r)
(#_imsld-resource ?s)
(has-href ?r))))
(def-class #_imsld-resource (#_imsld-representation)
((refines :type #_resource)
(has-href :type string)))
(def-class #_imsld-method (#_imsld-representation)
((has-play :type #_imsld-play :min-cardinality 1)
(has-conditions :type #_imsld-condition)))
(def-class #_imsld-play (#_imsld-representation)
((has-act :type #_imsld-act :min-cardinality 1)))
(def-class #_imsld-act (#_imsld-representation)
((has-role-part :type #_imsld-role-part :min-cardinality 1)))
(def-class #_imsld-objective (#_imsld-representation)
((refines :type #_goal)
(has-objective-description :type #_imsld-objective-description)))
(def-class #_imsld-objective-description (#_imsld-representation)
((refines :type #_goal-description)
(grounded-to :type #_imsld-item)))
(def-class #_imsld-role (#_imsld-component)
((refines :type #_actor-role)))
(def-class #_imsld-role-part (#_imsld-representation)
((has-role-ref :type #_imsld-role)
(has-acitivity-ref :type #_imsld-activity-entity)
(has-environment-ref :type #_imsld-environment)))
(def-class #_imsld-property (#_imsld-component)
((refines :type #_parameter)
(has-datatype :type #_imsld-datatype)
(has-current-value :type #_imsld-valued-property)
(has-initial-value :type #_imsld-valued-property)
(has-restriction :type #_imsld-restriction)))
(def-class #_imsld-valued-property (#_imsld-component)
((refines :type #_parameter)
(has-property :type #_imsld-property)
(has-value :type string)))
(def-class #_imsld-datatype (#_imsld-representation)
())
(def-class #_imsld-restriction (#_imsld-representation)
((has-restriction :type string)))
(def-class #_imsld-global-property (#_imsld-property)
((has-uri :type string)))
(def-class #_imsld-local-property (#_imsld-property)
((has-uri :type string)))
(def-class #_imsld-condition (#_imsld-representation)
((refines :type #_parameter)
(has-property-ref :type #_imsld-property)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; adlscorm alignment from here ;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(def-class #_adlscorm-representation (#_metadata-representation)
((has-title :type string)))
(def-class #_adlscorm-organization (#_adlscorm-representation) ?ao
((refines :type (or(#_process-description #_composite-process-entity)))
(targets :type #_adlscorm-objective) ;;; only implicit defined as part of the sequencing
(follows :type #_adlscorm-sequencing))
:constraint (exists (?r ?s ?t)
(and (targets ?ao ?r)
(#_adlscorm-objective ?r)
(refines ?r ?s)
(#_goal ?s)
(plays ?s ?t)
(#_process-goal-role ?t))))
(def-class #_adlscorm-item (#_adlscorm-representation) ?ai
((refines :type #_action-entity)
(grounded-to :type #_adlscorm-resource)
(is-visible :type boolean)
(targets :type #_adlscorm-objective) ;;; only implicitly defined as part of the sequencing
(follows :type #_adlscorm-sequencing))
:constraint (exists (?r ?s ?t)
(and (targets ?ai ?r)
(#_adlscorm-objective ?r)
(refines ?r ?s)
(#_goal ?s)
(plays ?s ?t)
(#_action-goal-role ?t))))
(def-class #_adlscorm-resource (#_adlscorm-representation)
((refines :type #_object)
(has-href :type string)
(has-type :type #_adlscorm-type)
(has-scorm-type :type #_adlscorm-scorm-type)))
(def-class #_adlscorm-scorm-type (#_adlscorm-representation))
(def-class #_adlscorm-sco-type (#_adlscorm-scorm-type))
(def-class #_adlscorm-asset-type (#_adlscorm-scorm-type))
(def-class #_adlscorm-type (#_adlscorm-representation))
(def-class #_adlscorm-web-type (#_adlscorm-type))
(def-class #_adlscorm-text-type (#_adlscorm-type))
(def-class #_adlscorm-sequencing (#_adlscorm-representation)
((d-uses :type #_adlscorm-sequencing-parameter)))
(def-class #_adlscorm-sequencing-parameter (#_adlscorm-representation))
(def-class #_adlscorm-objective (#_adlscorm-sequencing-parameter)
((refines :type #_goal)))
(def-class #_adlscorm-global-objective (#_adlscorm-objective))
(def-class #_adlscorm-primary-objective (#_adlscorm-objective))
(def-class #_adlscorm-rollup-rule (#_adlscorm-sequencing-parameter)
((has-rollup-condition :type #_adlscorm-rollup-condition)
(has-rollup-action :type #_adlscorm-rollup-action)))
(def-class #_adlscorm-control-mode (#_adlscorm-sequencing-parameter))
(def-class #_adlscorm-delivery-control (#_adlscorm-sequencing-parameter))
(def-class #_adlscorm-rollup-condition (#_adlscorm-sequencing-parameter))
(def-class #_adlscorm-rollup-action (#_adlscorm-sequencing-parameter))
(def-class #_adlscorm-sequencing-rule (#_adlscorm-sequencing-parameter))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;; INSTANCES ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;aims
(def-instance french-expert-aim #_aim
((has-instance-title "Learning French (Expert Level)")
(defined-by french-expert-aim-description)))
(def-instance french-expert-aim-description #_aim-description
((d-uses (basic-french-comp advanced-french-comp expert-french-comp))))
(def-instance french-basic-aim #_aim
((has-instance-title "Learning French (Basic Level)")
(defined-by french-basic-aim-description)))
(def-instance french-basic-aim-description #_aim-description
((d-uses (basic-french-comp))))
(def-instance french-advanced-aim #_aim
((has-instance-title "Learning French (Advanced Level)")
(defined-by french-advanced-aim-description)))
(def-instance french-advanced-aim-description #_aim-description
((d-uses (basic-french-comp advanced-french-comp))))
(def-instance maths-advanced-aim #_aim
((has-instance-title "Learning Maths (Advanced Level)")
(defined-by maths-advanced-aim-description)))
(def-instance maths-advanced-aim-description #_aim-description
((d-uses (basic-maths-comp advanced-maths-comp))))
(def-instance maths-expert-aim #_aim
((has-instance-title "Learning Maths (Expert Level)")
(defined-by maths-expert-aim-description)))
(def-instance maths-expert-aim-description #_aim-description
((d-uses (basic-maths-comp advanced-maths-comp expert-maths-comp diff-equations-comp))))
(def-instance maths-basic-aim #_aim
((has-instance-title "Learning Maths (Basic Level)")
(defined-by maths-basic-aim-description)))
(def-instance maths-basic-aim-description #_aim-description
((d-uses (basic-maths-comp))))
;;;mobile aims
(def-instance geography-aim #_mobile-aim
((has-instance-title "Local Geography")
(defined-by #_css:p3-geography-aim)))
(def-instance culture-aim #_mobile-aim
((has-instance-title "Local Culture")
(defined-by #_css:p4-culture-aim)))
(def-instance history-aim #_mobile-aim
((has-instance-title "Local History")
(defined-by #_css:p2-history-aim)))
(def-instance local-language-aim #_mobile-aim
((has-instance-title "Local Language")
(defined-by #_css:p1-language-aim)))
(def-instance local-language-culture-aim #_mobile-aim
((has-instance-title "Local Language and Culture")
(defined-by language-culture-aim-description #_css:a1-language-culture-aim)))
(def-instance language-culture-aim-description #_aim-description
((d-uses (basic-french-comp advanced-french-comp expert-french-comp basic-german-comp basic-spanish-comp))))
(def-instance local-history-culture-aim #_mobile-aim
((has-instance-title "Local History and Culture")
(defined-by history-culture-aim-description #_css:a2-history-culture-aim)))
(def-instance history-culture-aim-description #_aim-description
((d-uses (basic-brighton-pavillion-comp advanced-brighton-pavillion-comp east-anglia-comp))))
(def-instance local-geography-history-aim #_mobile-aim
((has-instance-title "Local Geography and History")
(defined-by geography-history-aim-description #_css:a3-geography-history-aim)))
(def-instance geography-history-aim-description #_aim-description
((d-uses (east-anglia-comp))))
;;; locations
(def-instance france-location #_location
((has-instance-title "France")))
(def-instance germany-location #_location
((has-instance-title "Germany")
(defined-by #_css:p8-location-germany)))
(def-instance london-location #_location
((has-instance-title "London")
(defined-by #_css:p1-location-london)))
(def-instance brighton-location #_location
((has-instance-title "Brighton, UK")
(defined-by #_css:p2-location-brighton)))
(def-instance milton-keynes-location #_location
((has-instance-title "Milton Keynes, UK")
(defined-by #_css:p3-location-milton-keynes)))
(def-instance paris-location #_location
((has-instance-title "Paris, FR")
(defined-by #_css:p4-location-paris)))
(def-instance toulouse-location #_location
((has-instance-title "Toulouse, FR")
(defined-by #_css:p5-location-toulouse)))
(def-instance italy-location #_location
((has-instance-title "Italy")))
(def-instance spain-location #_location
((has-instance-title "Spain")
( defined-by #_css:p9-location-spain)))
(def-instance uk-location #_location
((has-instance-title "UK")
(defined-by #_css:p6-location-uk)))
(def-instance france-location #_location
((has-instance-title "France")
(defined-by #_css:p7-location-france)))
(def-instance germany-location #_location
((has-instance-title "Germany")
(defined-by #_css:p8-location-germany)))
(def-instance us-location #_location
((has-instance-title "United States")))
(def-instance participative-method #_educational-method
((has-instance-title "Participative")))
(def-instance non-participative-method #_educational-method
((has-instance-title "Non-Participative")))
;;; reusable roles and parameters from here
(def-instance default-process-goal-role #_process-goal-role
((has-title "Default Process Goal Role")))
(def-instance default-action-goal-role #_action-goal-role
((has-title "Default Action Goal Role")))
(def-instance french-advanced-lo #_object)
(def-instance french-expert-lo #_object)
(def-instance learner-role #_learner-role
((has-title "Default Learner")))
(def-instance state-interactive-type #_state-interaction-type
((has-instance-title "Interactive")))
(def-instance state-non-interactive-type #_state-interaction-type
((has-instance-title "Non-Interactive")))
(def-instance profile-interactive-type #_profile-interaction-type
((has-instance-title "Interactive")))
(def-instance profile-non-interactive-type #_profile-interaction-type
((has-instance-title "Non-Interactive")))
(def-instance brad-interactive-type #_profile-interaction-type
((has-instance-title "Brad's Interactivity")
(defined-by #_css:i1-brad-p-interaction-member)))
(def-instance angie-interactive-type #_profile-interaction-type
((has-instance-title "Angie's Interactivity")
(defined-by #_css:i2-angie-interaction-member)))
(def-instance imsld-standard #_metadata-standard
((has-instance-title "IMS LD")))
(def-instance #_adlscorm-standard #_metadata-standard
((has-instance-title "ADL SCORM")))
(def-instance reload-#_adlscorm-rte #_runtime-environment
((has-instance-title "Reload ADL SCORM Player")
(supports-standard adl-scorm-standard)))
(def-instance reload-imsld-rte #_runtime-environment
((has-instance-title "Reload IMS LD Player")
(supports-standard imsld-standard)))
(def-instance semantic-#_rte #_runtime-environment
((has-instance-title "LPMO Runtime Environment")))
(def-instance short-learning-time #_learning-time
((has-instance-title "Short")
(has-min-time 0)
(has-max-time 9)))
(def-instance medium-learning-time #_learning-time
((has-instance-title "Medium")
(has-min-time 10)
(has-max-time 15)))
(def-instance long-learning-time #_learning-time
((has-instance-title "Long")
(has-min-time 16)))
(def-instance english-state-language #_state-language
((has-instance-title "English")))
(def-instance french-state-language #_state-language
((has-instance-title "French")))
(def-instance spanish-state-language #_state-language
((has-instance-title "Spanish")))
(def-instance english-profile-language #_profile-language
((has-instance-title "English")))
(def-instance french-profile-language #_profile-language
((has-instance-title "French")))
(def-instance spanish-profile-language #_profile-language
((has-instance-title "Spanish")))
(def-instance brad-p-learning-style #_learning-style
((has-instance-title "Brad P.'s Learning Style")
(defined-by fslsm-brad-p-style)))
(def-instance angie-j-learning-style #_learning-style
((has-instance-title "Angie J.'s Learning Style")
(defined-by fslsm-angie-j-style)))
(def-instance p1-active-visual-style #_prototypical-learning-style
((has-instance-title "Active-Visual Learning Style")
( defined-by fslsm-p1-active-visual-style)))
(def-instance p2-reflective-style #_prototypical-learning-style
((has-instance-title "Reflective Learning Style")
( defined-by fslsm-p2-reflective-style)))
(def-instance p3-sensing-sequential-style #_prototypical-learning-style
((has-instance-title "Sensing-Sequential Learning Style")
( defined-by fslsm-p3-sensing-sequential-style)))
(def-instance p4-intuitive-global-style #_prototypical-learning-style
((has-instance-title "Intuitive-Global Learning Style")
( defined-by fslsm-p4-intuitive-global-style)))
(def-instance p5-verbal-style #_prototypical-learning-style
((has-instance-title "Verbal Learning Style")
( defined-by fslsm-p5-verbal-style)))
(def-instance brad-profile #_actor-profile
((has-title "Brads Profile")
(d-uses (basic-french-comp basic-english-comp basic-maths-comp profile-interactive-type participative-method english-profile-language brad-p-learning-style us-location))))
(def-instance brad-actor #_actor
((has-instance-title "Brad P.")
(defined-by brad-profile)))
(def-instance guest-profile #_actor-profile
((has-title "Guest Profile")
(d-uses (profile-interactive-type participative-method english-profile-language uk-location))))
(def-instance guest-actor #_actor
((has-instance-title "Guest")
(defined-by guest-profile)))
(def-instance angie-profile #_actor-profile
((has-title "Angies Profile ")
(d-uses (basic-french-comp basic-maths-comp profile-interactive-type non-participative-method us-location english-profile-language angie-j-learning-style))))
(def-instance angie-actor #_actor
((has-instance-title "Angie J.")
(defined-by angie-profile)))
;;; process dependent elements and situation descriptions
(def-instance french-basic-state-description #_state-description
((has-title "Initial state")
(d-uses (basic-french-comp basic-maths-comp interactive-type semantic-#_rte learner-role))))
(def-instance french-advanced-state-description #_state-description
((has-title "French advanced state")
(d-uses (basic-french-comp basic-maths-comp interactive-type semantic-#_rte learner-role french-advanced-lo))))
(def-instance french-expert-state-description #_state-description
((has-title "French Expert State")
(d-uses (basic-french-comp basic-maths-comp interactive-type semantic-#_rte learner-role advanced-french-comp expert-french-comp))))
(def-instance french-advanced-comp-state-description #_state-description
((has-title "French Advanced Learned State")
(d-uses (basic-french-comp basic-maths-comp interactive-type semantic-#_rte learner-role advanced-french-comp))))
(def-instance french-basic-situation #_state-situation
((satisfies french-basic-state-description)))
(def-instance french-advanced-situation #_state-situation
((satisfies french-advanced-state-description)))
(def-instance french-expert-situation #_state-situation
((satisfies french-expert-state-description)))
(def-instance french-advanced-comp-situation #_state-situation
((satisfies french-advanced-comp-state-description)))
(def-instance basic-german-comp #_competency
((has-instance-title "Basic German Competency")
(targets-aim (culture-aim))
(targets-location (germany-location))
(hasAssociatedDomainConcepts (german-concept))
(level "Introductory")))
(def-instance basic-german-language-comp #_competency
((has-instance-title "Basic German Language Competency")
(targets-aim (local-language-aim))
(targets-location (germany-location))
(hasAssociatedDomainConcepts (german-language-concept))
(level "Introductory")))
(def-instance basic-spanish-comp #_competency
((has-instance-title "Basic Spanish Competency")
(targets-aim (local-language-aim))
(targets-location (spain-location))
(hasAssociatedDomainConcepts (spanish-language-concept))
(level "Introductory")))
(def-instance basic-english-comp #_competency
((has-instance-title "Basic English Competency")
(targets-location (uk-location))
(targets-aim (local-language-aim))
(is-similar-to (english-grammar-comp))
(hasAssociatedDomainConcepts (english-language-concept))
(level "Introductory")))
(def-instance english-grammar-comp #_competency
((has-instance-title "English Grammar in Context Competency")
(targets-location (uk-location))
(targets-aim (local-language-aim))
(requires-comp (basic-english-comp))
(is-similar-to (basic-english-comp))
(hasAssociatedDomainConcepts (english-language-concept english-grammar-concept))
(level "Advanced")))
(def-instance east-anglia-comp #_competency
((has-instance-title "East Anglia History Competency")
(targets-location (uk-location))
(targets-aim (local-geography-history-aim culture-aim))
(requires-comp (basic-english-comp))
(is-similar-to (basic-brighton-pavillion-comp advanced-brighton-pavillion-comp))
(hasAssociatedDomainConcepts (east-anglia-concept))
(level "Introductory")))
(def-instance basic-french-comp #_competency
((has-instance-title "Basic French Competency")
(has-description "Familiarity with the basic vocabulary and grammtical concepts of the French language.")
(is-similar-to (advanced-french-comp beginners-french-comp expert-french-comp))
(targets-aim (french-basic-aim local-language-aim))
(is-equivalent-to (beginners-french-comp))
(requires-comp (french-foundations-comp))
(targets-location (france-location))
(hasAssociatedDomainConcepts (french-language-concept))
(level "Introductory")))
(def-instance general-france-comp #_competency
((has-instance-title "General France Competency")
(has-description "Background on french history and culture.")
(is-similar-to (advanced-french-comp beginners-french-comp expert-french-comp basic-french-comp))
(targets-aim (history-aim culture-aim))
(requires-comp (french-foundations-comp))
(targets-location (france-location))
(hasAssociatedDomainConcepts (france-concept))
(level "Introductory")))
(def-instance beginners-french-comp #_competency
((has-instance-title "French Beginners Competency")
(is-similar-to (advanced-french-comp))
(is-equivalent-to (basic-french-comp))
(targets-aim (local-language-aim))
(targets-location (france-location))
(hasAssociatedDomainConcepts (french-language-concept))
(level "Introductory")))
(def-instance louvre-comp #_competency
((has-instance-title "Louvre Competency")
(is-similar-to (advanced-french-comp basic-french-competency))
(targets-aim (culture-aim))
(targets-location (paris-location))
(hasAssociatedDomainConcepts (louvre-concept))
(level "Introductory")))
(def-instance french-foundations-comp #_competency
((has-instance-title "French Foundations Competency")
(is-similar-to (advanced-french-comp basic-french-comp))
(targets-aim (local-language-aim))
(targets-location (french-location))
(hasAssociatedDomainConcepts (french-language-concept))
(level "Introductory")))
(def-instance advanced-french-comp #_competency
((has-instance-title "Advanced French Competency")
(has-description "Advanced capabilities of French language. Familiarity with grammar and wide range of vocabulary.")
(is-similar-to (basic-french-comp expert-french-comp beginners-french-comp french-foundations-comp))
(targets-location (france-location))
(targets-aim (local-language-aim))
(is-equivalent-to (advanced-french-comp))
(requires-comp (basic-french-comp beginners-french-comp french-foundations-comp))
(hasAssociatedDomainConcepts (french-language-concept french-grammar-concept))
(level "Advanced")))
(def-instance expert-french-comp #_competency
((has-instance-title "Expert French Competency")
(has-description "Expert-level capabilities of French language. Proficiency with grammar and wide range of vocabulary.")
(is-similar-to (advanced-french-comp basic-french-comp beginners-french-comp french-foundations-comp))
(targets-location (france-location))
(requires-comp (basic-french-comp advanced-french-comp beginners-french-comp french-foundations-comp))
(hasAssociatedDomainConcepts (french-language-concept french-grammar-concept))
(targets-location (france-location paris-location))
(targets-aim (local-language-aim))
(level "Expert")))
(def-instance basic-brighton-pavillion-comp #_competency
((has-instance-title "Introduction to the Brighton Pavillion")
(is-similar-to (advanced-brighton-pavillion-comp))
(targets-location (brighton-location))
(targets-aim (culture-aim))
(is-similar-to (advanced-brighton-pavillion-comp))
(hasAssociatedDomainConcepts (brighton-pavillion-culture-concept brighton-pavillion-history-concept))
(level "Introductory")))
(def-instance advanced-brighton-pavillion-comp #_competency
((has-instance-title "Advanced Background on the Brighton Area")
(targets-location (brighton-location))
(targets-aim (culture-aim))
(is-similar-to (basic-brighton-pavillion-comp))
(hasAssociatedDomainConcepts (brighton-pavillion-history-concept brighton-pavillion-culture-concept)) ;;need to introduce another domain concept
(targets-location (uk-location brighton-location))
(level "Advanced")))
(def-instance advanced-maths-comp #_competency
((has-instance-title "Advanced Maths Competency")
(has-description "Advanced understanding of mathematical concepts.")
(hasAssociatedDomainConcepts (maths-basics-concept differential-equations-concept))
(requires-comp (beginners-maths-comp basic-maths-comp))
(is-similar-to (expert-maths-comp introductory-maths-comp beginners-maths-comp basic-maths-comp))
(level "Advanced")))
(def-instance diff-equations-comp #_competency
((has-instance-title "Differential Equations Competency")
(has-description "Ability to deal with differential equations.")
(hasAssociatedDomainConcepts (maths-basics-concept differential-equations-concept))
(requires-comp (beginners-maths-comp basic-maths-comp))
(is-similar-to (expert-maths-comp introductory-maths-comp beginners-maths-comp basic-maths-comp))
(level "Advanced")))
(def-instance expert-maths-comp #_competency
((has-instance-title "Expert Maths Competency")
(has-description "Expert understanding of mathematical concepts.")
(hasAssociatedDomainConcepts (differential-equations-concept fourier-series-concept))
(requires-comp (beginners-maths-comp basic-maths-comp advanced-maths-comp))
(is-similar-to (advanced-maths-comp introductory-maths-comp beginners-maths-comp basic-maths-comp))
(level "Expert")))
(def-instance fourier-series-comp #_competency
((has-instance-title "Modelling with Fourier Series Competency")
(hasAssociatedDomainConcepts (differential-equations-concept fourier-series-concept))
(requires-comp (beginners-maths-comp basic-maths-comp advanced-maths-comp expert-maths-comp))
(is-similar-to (advanced-maths-comp introductory-maths-comp beginners-maths-comp basic-maths-comp expert-maths-comp))
(level "Expert")))
(def-instance basic-maths-comp #_competency
((has-instance-title "Basic Maths Competency")
(has-description "Familiarity with basic mathematical concepts.")
(targets-aim (maths-basic-aim))
(requires-comp (beginners-maths-comp))
(hasAssociatedDomainConcepts (maths-basics-concept))
(is-equivalent-to (introductory-maths-comp))
(is-similar-to (advanced-maths-comp expert-maths-comp introductory-maths-comp beginners-maths-comp))
(level "Introductory")))
(def-instance beginners-maths-comp #_competency
((has-instance-title "Beginners Maths Competency")
(has-description "Foundational understanding of mathematical concepts.")
(hasAssociatedDomainConcepts (maths-basics-concept))
(is-similar-to (advanced-maths-comp expert-maths-comp basic-maths-comp))
(level "Introductory")))
(def-instance introductory-maths-comp #_competency
((has-instance-title "Introductory Maths Competency")
(hasAssociatedDomainConcepts (maths-basics-concept))
(is-equivalent-to (basic-maths-comp))
(is-similar-to (advanced-maths-comp expert-maths-comp))
(level "Introductory")))
(def-class #_process-goal-description (#_goal-description)
((has-postcondition :type #_aim)))
(def-instance french-exp-interact-semantic-goal-desc #_process-goal-description
((has-title "Contextualized French Expert Goal Description")
(has-assumption french-basic-situation)
(has-postcondition french-expert-aim)
(has-description "Learning French at the Expert Level by using interactive learning objects and no specific metadata RTE")))
(def-instance french-advanced-goal-desc #_action-goal-description
((has-title "French Advanced Goal Description")
(has-assumption french-basic-situation)
(has-effect french-advanced-situation)
(has-description "Learning French at the Expert Level by using interactive learning objects and no specific metadata RTE")))
(def-instance french-expert-goal-desc #_action-goal-description
((has-title "Contextualized French Expert Goal Description")
(has-assumption french-advanced-comp-situation)
(has-effect french-expert-situation)
(has-description "Learning French at the Expert Level by using interactive learning objects and no specific metadata RTE")))
(def-instance french-assessment-goal-desc #_action-goal-description
((has-title "French Assessment Goal")
(has-assumption french-advanced-situation)
(has-effect (french-advanced-situation french-advanced-comp-situation))
(has-description "Assessing the French Skills of the Learner")))
(def-instance french-exp-interact-semantic-goal #_goal
((has-instance-title "Contextualized French Expert Goal")
(plays default-process-goal-role)
(defined-by french-exp-interact-semantic-goal-desc)))
(def-instance french-advanced-goal #_goal
((has-instance-title "French Advanced Goal")
(plays default-action-goal-role)
(defined-by french-advanced-goal-desc)))
(def-instance french-expert-goal #_goal
((has-instance-title "French Expert Goal")
(plays default-action-goal-role)
(defined-by french-expert-goal-desc)))
(def-instance french-assessment-goal #_goal
((has-instance-title "French Assessment Goal")
(plays default-action-goal-role)
(defined-by french-assessment-goal-desc)))
(def-instance french-expert-process #_process
((defined-by french-expert-process-description)
(targets french-exp-interact-semantic-goal)))
(def-instance french-expert-process-description #_process-description
((d-uses (french-exp-interact-semantic-goal french-advanced-goal french-expert-goal french-assessment-goal french-advanced-activity french-assessment-activity french-expert-activity french-advanced-split))))
(def-instance french-advanced-activity #_action-entity
((targets french-advanced-goal)
(has-successor french-expert-activity)))
(def-instance french-assessment-activity #_action-entity
((targets french-assessment-goal)
(has-successor french-advanced-split-activity)))
(def-instance french-expert-activity #_action-entity
((targets french-expert-goal)
(has-predecessor french-advanced-activity)))
(def-instance french-advanced-split #_exclusive-choice-entity
((has-predecessor french-assessment-activity)
(has-successor french-advanced-activity french-expert-activity)))
(def-instance imsld-design-french-expert #_imsld-design
((refines french-expert-process-description)
(targets imsld-french-expert-interact-process-objective)))
(def-instance imsld-french-advanced-activity #_imsld-activity
((refines french-advanced-activity)
(targets imsld-french-advanced-objective)))
(def-instance imsld-french-expert-activity #_imsld-activity
((refines french-expert-activity)
(targets imsld-french-expert-objective)))
(def-instance imsld-french-assessment-activity #_imsld-activity
((refines french-assessment-activity)
(targets imsld-french-assessment-objective)))
(def-instance imsld-french-assessment-objective #_imsld-objective
((refines french-assessment-goal)))
(def-instance imsld-french-advanced-objective #_imsld-objective
((refines french-advanced-goal)))
(def-instance imsld-french-expert-objective #_imsld-objective
((refines french-expert-goal)))
(def-instance imsld-french-expert-objective #_imsld-objective
((refines french-expert-goal)))
(def-instance imsld-french-expert-interact-process-objective #_imsld-objective
((refines french-expert-interact-semantic-goal)))
(def-instance imsld-french-expert-act-structure #_imsld-activity-structure
((has-activity-ref imsld-french-advanced-activity imsld-french-expert-activity imsld-french-assessment-activity)))
(def-instance imsld-french-learner #_imsld-role
((refines learner-role)))
;;; adlscorm process instances
(def-instance adlscorm-french-expert-org #_adlscorm-organization
((targets adlscorm-french-expert-interact-process-objective)
(refines french-expert-process-description)))
(def-instance adlscorm-french-assessment-objective #_adlscorm-objective
((refines french-assessment-goal)))
(def-instance adlscorm-french-advanced-objective #_adlscorm-objective
((refines french-advanced-goal)))
(def-instance adlscorm-french-expert-objective #_adlscorm-objective
((refines french-expert-goal)))
(def-instance adlscorm-french-expert-interact-process-objective #_adlscorm-objective
((refines french-expert-interact-semantic-goal)))
(def-instance adlscorm-french-advanced-activity #_adlscorm-item
((refines french-advanced-activity)
(targets adlscorm-french-advanced-objective)))
(def-instance adlscorm-french-expert-activity #_adlscorm-item
((refines french-expert-activity)
(targets adlscorm-french-expert-objective)))
(def-instance adlscorm-french-assessment-activity #_adlscorm-item
((refines french-assessment-activity)
(targets adlscorm-french-assessment-objective)))
;; lifting functions
(deflift lift-competency-list #_parameter ()
(("has-instance-title" "XMLCompetencyList/Parameter/ParameterValue/text()")))
(deflift lift-situation-parameter #_situation-parameter ()
(("has-instance-title" "Parameter/ParameterValue/text()")
("has-parameter-title" "Parameter/ParameterTitle/text()")))
(deflift lift-situation #_state-description ()
(("d-uses" (lift-situation-parameter '("Situation/Parameter") :AS-VALUES))))
(deflower lower-parameter #_parameter
(lambda (uses)
(let ((res "")
(tagname (ocml::the-slot-value uses 'ocml::has-parameter-title)))
(setf tagname (remove #\Space tagname))
(setf res (concatenate 'string res "<"))
(setf res (concatenate 'string res tagname))
(setf res (concatenate 'string res ">"))
;(setf res (concatenate 'string res (internal-lower-#_parameter uses)))
(setf res (concatenate 'string res (ocml::the-slot-value uses 'ocml::has-instance-title)))
(setf res (concatenate 'string res ""))
(setf res (concatenate 'string res tagname))
(setf res (concatenate 'string res ">")))))
(deflower lower-interaction-type #_interaction-type
'(("Interaction" "has-instance-title")))
;get gap analasys
(deflower lower-competency-name #_competency
'(("Competency" "has-instance-title")))
(deflower lower-aim-name #_aim
'(("AimName" "has-instance-title")))
(deflower lower-competency #_competency
'(("CompetencyDescription"
(("Name" "has-instance-title")
("Description" "has-description")
(lower-#_competency-targets-aim "targets-aim")
(lower-#_competency-equivalents "is-equivalent-to")
(lower-#_competency-similars "is-similar-to")
(lower-#_competency-requirements "requires-comp")
; (lower-competency-component "hasComponent")
("Level" "level")))))
(def-class #_targets-aims-list (list))
(deflower lower-competency-targets-aim #_targets-aims-list
(lambda (equi)
(let ((res "")
(l nil))
(loop for comp in equi do
(setf l (lower-aim-name comp)) ;;;
(setf res (concatenate 'string res l)))
(setf res (concatenate 'string res "")))))
(deflower lower-competency-equivalents #_equivalent-competencies-list
(lambda (equi)
(let ((res "")
(l nil))
(loop for comp in equi do
(setf l (lower-competency-name comp))
(setf res (concatenate 'string res l)))
(setf res (concatenate 'string res "")))))
(deflower lower-competency-similars #_similar-competencies-list
(lambda (equi)
(let ((res "")
(l nil))
(loop for comp in equi do
(setf l (lower-competency-name comp))
(setf res (concatenate 'string res l)))
(setf res (concatenate 'string res "")))))
(deflower lower-competency-requirements #_requires-competencies-list
(lambda (equi)
(let ((res "")
(l nil))
(loop for comp in equi do
(setf l (lower-competency-name comp))
(setf res (concatenate 'string res l)))
(setf res (concatenate 'string res "")))))
;;; lowering for lpmo repositories
(def-class #_repository-and-domain-list (list))
(deflower lower-repository-and-domain-list repository-and-domain-list
(lambda (equi)
(let ((res "")
(l nil))
(loop for comp in equi do
(print comp)
(setf l (lower-repository (first comp)))
(setf res (concatenate 'string res l)))
(setf res (concatenate 'string res "")))))
(def-class targeted-language-list (list))
(def-class targeted-domain-list (list))
(def-class targeted-competency-list (list))
(def-class targeted-competency-in-domain-list (list))
(deflower lower-repository #_repository
'(("RepositoryDescription"
(("Name" "has-instance-title")
("Description" "has-description")
("Url" "has-url")
(lower-#_repository-languages "targetsLanguage")
(lower-#_repository-domains "targetsDomain")
(lower-#_repository-competency-domain "targetsCompetencyInDomain")))))
(deflower lower-repository-languages targeted-language-list
(lambda (equi)
(let ((res "")
(l nil))
(loop for comp in equi do
(setf l (concatenate 'string "" comp))
(setf l (concatenate 'string l ""))
(setf res (concatenate 'string res l)))
(setf res (concatenate 'string res "")))))
(deflower lower-repository-domains targeted-domain-list
(lambda (equi)
(let ((res "")
(l nil))
(loop for comp in equi do
(setf l (lower-domain-name comp))
(setf res (concatenate 'string res l)))
(setf res (concatenate 'string res "")))))
(deflower lower-repository-competency-domain targeted-competency-in-domain-list
(lambda (equi)
(let ((res "")
(l nil))
(loop for comp in equi do
(setf l (lower-competency-in-domain comp))
(setf res (concatenate 'string res l)))
(setf res (concatenate 'string res "")))))
;; FURTHER LIFTING and LOWERING DISTANCES:
(defparameter *max-distance* 6.0)
(def-class distance-data ()
((has-member-title :type string)
(has-prototype-distance :type prototype-distance)
(has-smallest-prototype-distance :type prototype-distance)))
(def-class prototype-distance ()
((has-prototype-title :type string)
(has-distance :type float)))
(deflift lift-prototype-distance prototype-distance ()
(("has-prototype-title" "Distance/PrototypeTitle/text()")
("has-distance" "Distance/PrototypeDistance/text()")))
(deflift lift-smallest-prototype-distance prototype-distance ()
(("has-prototype-title" "SmallestDistance/PrototypeTitle/text()")
("has-distance" "SmallestDistance/PrototypeDistance/text()")))
(deflift lift-distance-data distance-data ()
(("has-member-title" "DistancesResults/Member/text()")
("has-prototype-distance" (lift-prototype-distance '("DistancesResults/Distance") :AS-VALUES))
("has-smallest-prototype-distance" (lift-smallest-prototype-distance '("DistancesResults/SmallestDistance") :AS-VALUES))))