Configuration-Design is an ontology for describing configuration design tasks: describing components, parameters, constraints, and configurations. Like parametric design tasks, a configuration design task is a search for values of parameters that satisfy a set of constraints. In configuration design, artifacts are described by collections of components, related by subpart relationships. Each component has associated parameters and constraints. The specification of a particular design task, such as the VT task for designing an elevator, is the description of a system component like an elevator, a set of constraints on that component (e.g., customer requirements), and a library of background constraints (e.g., laws of physics) and available components. A valid design is a complete description of the system component, with values for relevant parameters and choices for subcomponents, that satisifies all the constraints.The definitions in this ontology embody this tight relationship between components, constraints, and parameters. Constraints are defined as unary predicates that hold for components. Parameters are unary functions on components; in this theory, parameters are called attributes. Components are related to other components through binary subpart relations.
The configuration-design ontology is intended for design tasks involving parametric constraint satisfaction (with decomposition by components), and part selection. In configuration design, the set of chosen components determines the set of relevant parameters and constraints. There is no built-in notion of component connection, only hierarchical subpart relations.
The configuration design theory does not restrict the expressiveness or form of the constraints. A constraint is any limitation on the values of parameters (i.e., attributes of components in this theory). Some constraints appear as part of the definition of a class. For example, a value-type restriction on an attribute of a class of components is a constraint. Similarly, component classes may have constant values for some attributes as part of their definitions. Such constraints are inherited to subclasses. We assume that systems will have special-purpose mechanisms for dealing with definitional constraints such as downward-inherited values and value-type restrictions. Other constraints, such as arithmetic relationships among numeric parameters, are reified as explicit linguistic objects (constraint expresssions). We distinguish and reify these constraints
because they determine the kind of reasoning to use (e.g., constraint satisfaction algorithm). We anticipate that system will analyze the form of these reified constraints to decide how to process them, and to associate other knowledge with these constraints qua objects (e.g., when they are useful to apply).
Frame-Ontology
Kif-Relations
Kif-Sets
Kif-Lists
Kif-Numbers
Kif-Meta
Kif-Sets
Kif-Lists ...
Vt-Design
Simple-Bikes
Vt-Domain
Vt-Example
Attribute-Slot
Quantity-Slot
Attribute-Slot-Name
Attribute-Term
Attribute-Term-Operator
Attribute-Value
Component
Valid-Component
Component-Class
Component-Constant
Component-Term
Config-Relation-Constant
Configuration-Thing
Constraint
Constraint-Expression
Constraint-Term
Function-Constant
Ground-Term
Attribute-Value-Constant
Logical-Operator
Object-Constant
Relation-Constant
Subpart-Slot
Subpart-Slot-Name
Truth-Value-Constant
The following constants were used from included theories:
All constants that were mentioned were defined.
Top level class for configuration ontology. Used to identify mutually disjoint root classes that might be assimilated into other ontologies.
A component is a primitive module or assembly of primitive modules that participate in a design. Components need not correspond to physically whole objects such as standard parts from a parts catalog. Components may also represent functional and behavioral abstractions. This ontology only says that components are the locus of attributes and constraints. To say that a component C has-attribute A means that there is a function A from C to the value of the attribute. In object-oriented terminology, one can think of A as a slot of C, and calling it an attribute means that it may be mentioned in constraints on C. Similarly, a component C has-subpart S means the function S maps C to another component which plays the S role in C. Subpart slots may identify structural, functional, or similar kinds of relationships among components.
Slots Of Instances:
The meta class of component classes.
Slots Of Instances:
(<=> (Component-Class ?C) (Subclass-Of ?C Component))
A component has an attribute if the attribute value is given by a unary function, called an attribute-slot, that is defined for that component. Calling a slot an attribute means that it is a design parameter: it will need to be assigned a value and may be mentioned in constraints.
(=> (Has-Attribute ?Component ?Attribute-Slot)
(Value-Cardinality ?Component ?Attribute-Slot 1) )
A component has an subpart if the subpart is given by a unary function, called a subpart-slot, that is defined for that component.
(=> (Has-Subpart ?Component ?Subpart-Slot)
(Value-Cardinality ?Component ?Subpart-Slot 1) )
To say a component has a constraint means that the constraint has been associated with the component. The constraint holds for the component iff it is a SATISFIED-CONSTRAINT of the component.
An attribute slot is a unary function from COMPONENTs to ATTRIBUTE-VALUEs, which are either scalar quantities or strings.
Slots Of Instances:
(=> (Attribute-Value ?X) (Or (Real-Number ?X) (String ?X)))
A supart slot is a unary function from COMPONENTs to other components. It is antisymmetric and antireflexive.
Slots Of Instances:
Relation to limit the values of an attribute-slot to quantities of a given physical-dimension.
Slots Of Instances:
A constraint is a description that limits the permissible values for attributes of components in a design. Every constraint is specified with a KIF expression of type constraint-expression. This expression describes a constraint over components; attributes and subparts of the component are denoted by functional terms within the constraint expression.
Slots Of Instances:
slot on constraint objects whose value is a KIF sentence (the syntactic thing, a list expression).
A constructor for constraint objects. Given a constraint expression, it denotes the associated constraint object. This means that constraints are uniquely defined by their expressions.
(<=> (The-Constraint ?Expression ?Constraint)
(And (Constraint-Expression ?Expression)
(= (Constraint.Expression ?Constraint) ?Expression) ))
A constraint specifies a class of components (i.e., those that satisfy the constraint expression). The constraint expression has one free variable, which denotes the component being constrained. The relation satisfies-constraint says how the expression is associated with the component. The class of components satisfying a constraint is denoted by a KAPPA expression that quantifies over the free variable in the constraint expression.
(<=> (Satisfies-Constraint ?Component ?Constraint)
(And (Component ?Component)
(Constraint ?Constraint)
(Holds (Denotation
(Listof
'Kappa
(Listof
(Free-Variable-In
(Constraint.Expression ?Constraint) ))
(Constraint.Expression ?Constraint) ))
?Component)))
A component is 'configured' or fully specified if all of its constraints are satisfied and all of its subparts are also configured. By definition, there exist values for all the attributes of a component. Whether an agent can tell you what the values of attributes are is not part of the definition of configured component. Knowing all the constraints associated with a component will require making a closed world assumption on the has-constraint slot.
(<=> (Valid-Component ?Component)
(And (Component ?Component)
(=> (Has-Constraint ?Component ?Constraint)
(Satisfies-Constraint ?Component ?Constraint) )
(=> (Has-Subpart ?Component ?Part-Slot)
(Valid-Component (Value ?Part-Slot ?Component)) )))
A contraint expression is a KIF sentence with a single free variable denoting a component. All the terms in the sentence denote either attribute values or components (i.e., the component denoted by the free variable or one of its subparts). No existential or universal quantification may be introduced. The full set of logical operators are allowed. A restricted set of relations are allowed, and the restriction is also left to be defined in specializations of this ontology.
(=> (Constraint-Expression ?Sent)
(And (= 1 (Cardinality (Freevars-In-Expression ?Sent)))
(Restricted-Constraint-Sentence ?Sent
Logical-Operator
Relation-Constant
Function-Constant)))
restricted-constraint-sentence is a predicate used to specify a class of sentences that are restricted by the set of operators and terminals in the grammar. The first argument is a KIF sentence. The second is a class of logical operators (a class whose instances are the allowed operators). The third argument is a class of relation operators, such as '<. And the fourth argument is a class of operators that can be used to form terms. These ``operators'' are actually symbols (relation constants), not the relations denoted by be these symbols. In KIF, symbols can be denoted by quoting them.
(Nth-Domain Restricted-Constraint-Sentence 1 Sentence)
(<=> (Restricted-Constraint-Sentence
?Sentence
?Class-Of-Logical-Operators
?Class-Of-Relation-Constants
?Class-Of-Attribute-Term-Operators)
(And (Sentence ?Sentence)
(Subclass-Of ?Class-Of-Logical-Operators Logical-Operator)
(Subclass-Of ?Class-Of-Relation-Constants
Relation-Constant)
(Subclass-Of ?Class-Of-Attribute-Term-Operators
Function-Constant)
(Or (Exists
(?R @Tlist)
(And (= ?Sentence (Listof ?R @Tlist))
(Instance-Of ?R ?Class-Of-Relation-Constants)
(=> (Item ?T (Listof @Tlist))
(Restricted-Constraint-Term
?T
?Class-Of-Attribute-Term-Operators))))
(Logical-Operator ?Sentence)
(Exists
(?Op @Sentences)
(And (= ?Sentence (Listof ?Op @Sentences))
(Instance-Of ?Op ?Class-Of-Logical-Operators)
(=> (Item ?S (Listof @Sentences))
(Restricted-Constraint-Sentence
?S
?Class-Of-Logical-Operators
?Class-Of-Relation-Constants
?Class-Of-Attribute-Term-Operators)))))))
(<=> (Restricted-Constraint-Term ?Term
?Class-Of-Attribute-Term-Operators)
(And (Term ?Term)
(Subclass-Of ?Class-Of-Attribute-Term-Operators
Function-Constant)
(Or (Restricted-Attribute-Term
?Term
?Class-Of-Attribute-Term-Operators)
(Component-Term ?Term) )))
(<=> (Restricted-Attribute-Term ?Term
?Class-Of-Attribute-Term-Operators)
(Or (Attribute-Value-Constant ?Term)
(Exists (?Attr-Slot ?Comp)
(And (= ?Term (Listof ?Attr-Slot ?Comp))
(Attribute-Slot-Name ?Attr-Slot)
(Component-Term ?Comp) ))
(Exists
(?Oper @Args)
(And (= ?Term (Listof ?Oper @Args))
(Instance-Of ?Oper
?Class-Of-Attribute-Term-Operators)
(=> (Item ?Arg (Listof @Args))
(Restricted-Attribute-Term
?Arg
?Class-Of-Attribute-Term-Operators))))))
A relation constant is a symbol that denotes a KIF relation.
An object constant is a symbol, a number specifier, or a string that denotes some object in the universe of discourse.
A function constant is a symbol that denotes a KIF function.
A truth-value constant is a symbol that denotes a logical value of true or false. It is not a predicate!
The relations allowed for a constraint expression will vary by specializations of this ontology. At the minimum, the relations should hold over attribute values or components.
A constraint term is an expression denoting either a component or the value of an attribute of a component.
(=> (Constraint-Term ?Term)
(Or (Component-Term ?Term) (Attribute-Term ?Term)) )
An attribute term is an expression that denotes the value of an attribute of a component. It is either a constant value or an term comprising a unary function (the attribute slot) and a component term.
(=> (Attribute-Term ?X)
(Or (Attribute-Value-Constant ?X)
(Exists (?Attr-Slot ?Comp)
(And (= ?X (Listof ?Attr-Slot ?Comp))
(Attribute-Slot-Name ?Attr-Slot)
(Component-Term ?Comp) ))
(Exists (?Oper @Args)
(And (= ?X (Listof ?Oper @Args))
(Attribute-Term-Operator ?Oper)
(=> (Item ?Arg (Listof @Args))
(Attribute-Term ?Arg) )))))
left underdefined, so specializations can restrict values to taste.
the constant naming some attribute slot.
Slots Of Instances:
(<=> (Attribute-Slot-Name ?Const)
(And (Funconst ?Const)
(Value-Type ?Const Denotation Attribute-Slot) ))
the constant naming some subpart slot.
(=> (Component-Term ?X)
(Or (Component-Constant ?X)
(Indvar ?X)
(And (List ?X)
(Exists (?F ?Comp)
(And (= ?X (Listof ?F ?Comp))
(Subpart-Slot-Name ?F)
(Component-Term ?Comp) )))))
A component constant is a KIF object constant that denotes a component.
Slots Of Instances:
Slots Of Instances:
(<=> (Ground-Term ?Expression)
(And (Term ?Expression)
(Value-Type ?Expression Freevars-In-Expression Empty) ))
A nonquantified expression may contain free variables, which are universally quantified. This function returns the set of such variables contained in a term expression.
(= (Freevars-In-Expression ?Exp)
(Cond ((Indvar ?Exp) (Setof ?Exp))
((List ?Exp)
(Union (Freevars-In-Expression (First ?Exp))
(Freevars-In-Expression (Rest ?Exp)) ))
(True (Setof)) ))
For expressions with exactly one free variable, this function denotes that variable. It is otherwise undefined.
(= (Free-Variable-In ?Exp)
(If (= 1 (Cardinality (Freevars-In-Expression ?Exp)))
(The ?Variable
(Member ?Variable (Freevars-In-Expression ?Exp)) )))