Theory SIMPLE-BIKES

Source code: bike-domain.lisp
List of other known theories

Theories included by Simple-Bikes:

    Vt-Design
       Configuration-Design
          Frame-Ontology
             Kif-Relations
                Kif-Sets
                Kif-Lists
                   Kif-Numbers
          Kif-Meta
             Kif-Sets
             Kif-Lists ...
       Scalar-Quantities
          Physical-Quantities
             Frame-Ontology ...
             Abstract-Algebra
                Frame-Ontology ...
       Standard-Units
          Physical-Quantities ...
    Standard-Units ...

No theories include Simple-Bikes.

30 classes defined:

    Bike-Component
       Bicycle
       Transmission
       Brake-System
          Coaster-Brake
          Hand-Brakes
       Frame
          Battaglin-Sl
          Battaglin-Slx
       Stem
          Itm-400
          Superitalia-Pro
          Control-Tech
       Handlebars
       Seat
       Wheel-Assy
          Front-Wheel
          Rear-Wheel
       Multi-Spd-Transmission
       Saddle
       Seat-Post
       Chain
       Pedals
       Crankset
       Bottom-Bracket
       Freewheel
       Front-Derailer
       Rear-Derailer
       Wheel
       Tire

No relations defined.

No functions defined.

No instances defined.

The following constants were used from included theories:

Class defined as a class in theory Frame-Ontology
Component defined as a class in theory Configuration-Design
Documentation defined as a relation in theory Frame-Ontology
Has-Attribute defined as a relation in theory Configuration-Design
Has-Constraint defined as a relation in theory Configuration-Design
Has-Subpart defined as a relation in theory Configuration-Design
Mass-Dimension defined as a object in theory Standard-Units
Positive-Integer defined as a class in theory Kif-Numbers
Scalar-Quantity defined as a class in theory Scalar-Quantities
Subclass-Of defined as a relation in theory Frame-Ontology
The-Constraint defined as a function in theory Configuration-Design
Value-Type defined as a relation in theory Frame-Ontology

The following constants were used from theories not included:

Model-Id defined as a relation in theory Vt-Domain
Weight defined as a relation in theory Vt-Domain

The following constants were undefined:

Dimension Bike.Front-Wheel Bike.Rear-Wheel Bike.Transmission Bike.Stem Bike.Bars Bike.Frame Bike.Brakes Bike.Seat Transmission.Bottom-Bracket Transmission.Chain Transmission.Freewheel Transmission.Crankset Transmission.Pedals Frame.Size Frame.Seat-Post-Size Stem.Clamp-Dia Stem.Length Handlebars.Dia Seat.Saddle Seat.Seat-Post Seat.Post Wheel-Assy.Wheel Wheel-Assy.Tire Transmission.Front-Derailer Transmission.Rear-Derailer Saddle.Model-Id Seat-Post.Model-Id Seat-Post.Tube-Dia Number-Of-Rings Bottom-Bracket.Type Number-Of-Speeds Hubtype Max-Width Min-Width Width

Class BIKE-COMPONENT

Root class for bike component classes.

Subclass-Of: Component

Has-Attribute: Weight
Weight:: Slot-Value-Type: Scalar-quantity

Axioms:

(=> (Bike-Component ?B) (= (Dimension (Weight ?B)) Mass-Dimension))

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class BICYCLE

Subclass-Of: Bike-component

Bike.Bars:: Slot-Value-Type: Handlebars
Bike.Brakes:: Slot-Value-Type: Brake-system
Bike.Frame:: Slot-Value-Type: Frame
Bike.Front-Wheel:: Slot-Value-Type: Front-wheel
Bike.Rear-Wheel:: Slot-Value-Type: Rear-wheel
Bike.Seat:: Slot-Value-Type: Seat
Bike.Stem:: Slot-Value-Type: Stem
Bike.Transmission:: Slot-Value-Type: Transmission
Has-Subpart:: Bike.bars, Bike.brakes, Bike.frame, Bike.front-wheel, Bike.rear-wheel, Bike.seat, Bike.stem, Bike.transmission

Axioms:

(=> (Bicycle ?B) 
    (And (Has-Constraint 
             ?B
             (The-Constraint 
                 '(= (Frame.Seat-Post-Size (Bike.Frame ?X)) 
                     (Seat.Post-Dia (Bike.Seat ?X)) )))
         (Has-Constraint 
             ?B
             (The-Constraint '(= (Stem.Clamp-Dia (Bike.Stem ?X)) 
                                 (Handlebars.Dia (Bike.Bars ?X)) )))
         (Has-Constraint 
             ?B
             (The-Constraint 
                 '(= (Bottom-Bracket.Type (Bike.Frame ?X)) 
                     (Bottom-Bracket.Type 
                         (Transmission.Bottom-Bracket 
                             (Bike.Transmission ?X) )))))
         (Has-Constraint 
             ?B
             (The-Constraint 
                 '(= (Size (Wheel.Hub (Rear-Wheel ?X))) 
                     (Size (Trans.Freewheel (Bike.Transmission ?X))) )))))

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class TRANSMISSION

Subclass-Of: Bike-component

Has-Attribute: Number-of-speeds
Has-Subpart:: Transmission.bottom-bracket, Transmission.chain, Transmission.crankset, Transmission.freewheel, Transmission.pedals
Number-Of-Speeds:: Slot-Value-Type: Positive-integer

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class BRAKE-SYSTEM

Subclass-Of: Bike-component

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class FRAME

Frame including forks and headset.

Subclass-Of: Bike-component

Has-Attribute:: Bottom-bracket.type, Frame.seat-post-size, Frame.size, Model-id

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class STEM

Subclass-Of: Bike-component

Has-Attribute: Model-id, Stem.clamp-dia, Stem.length

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class HANDLEBARS

Subclass-Of: Bike-component

Has-Attribute: Handlebars.dia, Model-id

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class SEAT

Subclass-Of: Bike-component

Has-Subpart: Seat.saddle, Seat.seat-post
Seat.Post:: Slot-Value-Type: Seat-post
Seat.Saddle:: Slot-Value-Type: Saddle

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class WHEEL-ASSY

Subclass-Of: Bike-component

Has-Subpart: Wheel-assy.tire, Wheel-assy.wheel
Wheel-Assy.Tire:: Slot-Value-Type: Tire
Wheel-Assy.Wheel:: Slot-Value-Type: Wheel

Axioms:

(=> (Wheel-Assy ?X) 
    (Has-Constraint 
        ?X
        (The-Constraint '(And (=< (Width (Wheel-Assy.Tire ?Z)) 
                                  (Max-Width (Wheel-Assy.Wheel ?Z)) )
                              (>= (Width (Wheel-Assy.Tire ?Z)) 
                                  (Min-Width (Wheel-Assy.Wheel ?Z)) )))))

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class FRONT-WHEEL

Subclass-Of: Wheel-assy

Axioms:

(=> (Front-Wheel ?X) 
    (Has-Constraint ?X
                    (The-Constraint 
                        '(= (Hubtype (Wheel-Assy.Wheel ?Z)) Front) )))

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class REAR-WHEEL

Subclass-Of: Wheel-assy

Axioms:

(=> (Rear-Wheel ?X) 
    (Has-Constraint ?X
                    (The-Constraint 
                        '(= (Hubtype (Wheel-Assy.Wheel ?Z)) Rear) )))

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class MULTI-SPD-TRANSMISSION

Subclass-Of: Bike-component

Has-Subpart: Transmission.front-derailer, Transmission.rear-derailer
Transmission.Front-Derailer:: Slot-Value-Type: Front-derailer
Transmission.Rear-Derailer:: Slot-Value-Type: Rear-derailer

Axioms:

(=> (Multi-Spd-Transmission ?T) 
    (And (Has-Constraint ?T
                         (The-Constraint '(> (Number-Of-Speeds ?X) 1) ))
         (Has-Constraint 
             ?T
             (The-Constraint 
                 '(= (Number-Of-Speeds ?X) 
                     (* (Number-Of-Speeds (Transmission.Freewheel ?X) )
                        (Number-Of-Rings (Transmission.Crankset ?X)) ))))))

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class COASTER-BRAKE

Subclass-Of: Brake-system

Has-Attribute: Model-id

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class HAND-BRAKES

Subclass-Of: Brake-system

Has-Attribute: Model-id

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class SADDLE

Subclass-Of: Bike-component

Has-Attribute: Saddle.model-id

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class SEAT-POST

Subclass-Of: Bike-component

Has-Attribute: Seat-post.model-id, Seat-post.tube-dia

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class CHAIN

Subclass-Of: Bike-component

Has-Attribute: Model-id

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class PEDALS

Subclass-Of: Bike-component

Has-Attribute: Model-id

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class CRANKSET

Crankset includes chain rings.

Subclass-Of: Bike-component

Has-Attribute: Model-id, Number-of-rings

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class BOTTOM-BRACKET

Subclass-Of: Bike-component

Has-Attribute: Bottom-bracket.type, Model-id

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class FREEWHEEL

Subclass-Of: Bike-component

Has-Attribute: Model-id, Number-of-speeds

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class FRONT-DERAILER

Subclass-Of: Bike-component

Has-Attribute: Model-id

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class REAR-DERAILER

Subclass-Of: Bike-component

Has-Attribute: Model-id

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class WHEEL

Subclass-Of: Bike-component

Has-Attribute: Hubtype, Max-width, Min-width

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class TIRE

Subclass-Of: Bike-component

Has-Attribute: Width

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class BATTAGLIN-SL

Subclass-Of: Frame

Axioms:

(=> (Battaglin-Sl ?F) 
    (And (Has-Constraint ?F
                         (The-Constraint '(= (Model-Id ?X) 10-9170) ))
         (Has-Constraint ?F
                         (The-Constraint '(Member (Frame.Size ?X) 
                                                  (Setof (* 49 Cm) 
                                                         (* 51 Cm) 
                                                         (* 53 Cm) 
                                                         (* 55 Cm) 
                                                         (* 57 Cm) 
                                                         (* 59 Cm) ))))
         (Has-Constraint 
             ?F
             (The-Constraint '(= (Frame.Seat-Post-Size ?X) 
                                 (* 27.2 Mm) )))
         (Has-Constraint ?F
                         (The-Constraint 
                             '(= (Bottom-Bracket.Type ?X) Italian) ))
         (Has-Constraint ?F
                         (The-Constraint '(= (Component.Cost ?X) 
                                             (* 575 Dollars) )))
         (Has-Constraint ?F
                         (The-Constraint '(= (Weight ?X) (* 5.7 Lbs)) ))))

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class BATTAGLIN-SLX

Subclass-Of: Frame

Axioms:

(=> (Battaglin-Slx ?F) 
    (And (Has-Constraint ?F
                         (The-Constraint '(= (Model-Id ?X) 10-9160) ))
         (Has-Constraint ?F
                         (The-Constraint '(Member (Frame.Size ?X) 
                                                  (Setof (* 48 Cm) 
                                                         (* 50 Cm) 
                                                         (* 52 Cm) 
                                                         (* 54 Cm) 
                                                         (* 56 Cm) 
                                                         (* 58 Cm) 
                                                         (* 60 Cm) 
                                                         (* 62 Cm) ))))
         (Has-Constraint 
             ?F
             (The-Constraint '(= (Frame.Seat-Post-Size ?X) 
                                 (* 27.2 Mm) )))
         (Has-Constraint ?F
                         (The-Constraint 
                             '(= (Bottom-Bracket.Type ?X) Italian) ))
         (Has-Constraint ?F
                         (The-Constraint '(= (Component.Cost ?X) 
                                             (* 795 Dollars) )))
         (Has-Constraint ?F
                         (The-Constraint '(= (Weight ?X) (* 6.0 Lbs)) ))))

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class ITM-400

Subclass-Of: Stem

Axioms:

(=> (Itm-400 ?S) 
    (And (Has-Constraint ?S
                         (The-Constraint '(= (Model-Id ?X) 51-5602) ))
         (Has-Constraint ?S
                         (The-Constraint '(= (Stem.Clamp-Dia ?X) 
                                             (* 25.9 Mm) )))
         (Has-Constraint ?S
                         (The-Constraint '(= (Weight ?X) 
                                             (* 305 Gram) )))
         (Has-Constraint ?S
                         (The-Constraint '(= (Component.Cost ?X) 
                                             (* 32.95 Dollars) )))))

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class SUPERITALIA-PRO

Subclass-Of: Stem

Axioms:

(=> (Superitalia-Pro ?S) 
    (And (Has-Constraint ?S
                         (The-Constraint '(= (Model-Id ?X) 51-5605) ))
         (Has-Constraint ?S
                         (The-Constraint '(= (Stem.Clamp-Dia ?X) 
                                             (* 25.9 Mm) )))
         (Has-Constraint ?S
                         (The-Constraint '(= (Weight ?X) 
                                             (* 280 Gram) )))
         (Has-Constraint ?S
                         (The-Constraint '(= (Component.Cost ?X) 
                                             (* 39.95 Dollars) )))))

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

Class CONTROL-TECH

Subclass-Of: Stem

Axioms:

(=> (Control-Tech ?S) 
    (And (Has-Constraint ?S
                         (The-Constraint '(= (Model-Id ?X) 51-6746) ))
         (Has-Constraint ?S
                         (The-Constraint '(= (Stem.Clamp-Dia ?X) 
                                             (* 26.0 Mm) )))
         (Has-Constraint ?S
                         (The-Constraint '(= (Weight ?X) 
                                             (* 220 Gram) )))
         (Has-Constraint ?S
                         (The-Constraint '(= (Component.Cost ?X) 
                                             (* 54.95 Dollars) )))))

Defined in theory: Simple-bikes
Source code: bike-domain.lisp

This document was generated using Ontolingua.
Formatting and translation code was written by

François Gerbaux and Tom Gruber