Configuration Constraint Template Reference

This chapter explains the templates used when you create configuration constraints.

Before you read this chapter, you must understand the information about creating constraints in Configuration Constraints, Configuration Links and Configuration Resources.

This chapter includes the following topics:

About Configuration Constraint Processing

Unlike procedural languages like Siebel eScript or C++, constraints are elements of constraint programming. Constraint programming differs from procedural logic in several important ways.

In a procedural language, you write statements that are executed one after another. Control can be transferred to other parts of a program, but the method of execution remains serial. Procedural logic relies on groups of statements executed in order.

In constraint logic, you write constraints that describe what must be true about the solution. the Siebel Product Configurator engine organizes these constraints into a search plan and then searches systematically, trying different item values, until a solution that satisfies all the constraints is found. Constraints are evaluated in parallel rather than serial fashion. Their order of evaluation is unimportant.

For example, you write a series of configuration constraints that define all the ways a desktop computer can be configured. This is called the declarative portion of the customizable product, and the constraints are constraints on every solution. the Siebel Product Configurator engine requires that all constraints are observed in every solution. This is the key to understanding constraint programming: all constraints must be observed in every solution.

You then release this customizable product to users. Users interact with it by selecting components to configure a computer. Each item the user selects is treated by the Siebel Product Configurator engine as another constraint on the solution. These user-constraints are added to the constraints in the declarative portion of the product and are used to further narrow down the solutions the engine can create. If a user-constraint conflicts with a constraint in the declarative portion of the product, the user receives a message that provides options for resolving the conflict.

The Siebel Product Configurator engine must find a configuration that satisfies all the constraints in the declarative portion of the product, plus all those created by the user's choices (user-constraints). After the user adds or removes an item, the Siebel Product Configurator engine searches until it finds a solution that satisfies all the constraints, including the constraint created by the user's action. The Siebel Product Configurator engine then presents the solution. In many cases, the only thing that changes is that the item is added or removed.

However, other items may be added or removed depending on constraints in the declarative portion of the product. If the user selects an item and the Siebel Product Configurator engine cannot create a solution that satisfies all the constraints, the user is presented with an option to undo the current selection or previous selections so that all constraints can be satisfied.

Note that constraints are created both by the modeler and by the user. In the declarative portion of the product, the product administrator writes configuration constraints that define the relationships between items. For example, if item A is picked, item B is required. The user creates constraints by adding items. For example, picking item A creates a constraint that item A must be in the solution. The constraints that drive the solution are thus jointly provided by both the product administrator and the user.

It is important to understand that to produce a solution, the Siebel Product Configurator engine is free to do what is necessary to find a valid solution that satisfies all the constraints (declarative portion constraints and user-constraints). For example, the following are the only two constraints on items A and B in a customizable product:

The quantity of A < the quantity of B

The quantity of B != 4

If the user picks one A, the Siebel Product Configurator engine will require that there are at least two Bs in the solution. If the user then increases the quantity of A to two, the Siebel Product Configurator engine generates a solution in which there are at least three Bs. However, when the user adds the third A, instead of a solution that increases B by one, the new solution will have two more Bs, making the total number of Bs at least five. This occurs because both constraints must be satisfied, and because there is no constraint preventing the Siebel Product Configurator engine from generating solutions that increment B by more than one.

The following example illustrates that when there are several possible alternatives, the Siebel Product Configurator engine may choose any one of them. You have a customizable product with only the following two constraints on items A, B, and C:

Constrain A + B = C to be true

Constrain C = 1 to be true

In this example, either A or B can be zero, but not both. Neither can both be 1. the Siebel Product Configurator engine will choose either A or B and will actively exclude the other from the solution. For example, it could choose A and actively exclude B from the solution. It could also choose B and actively exclude A.

It is important when creating constraints to consider the domain of solutions the engine could produce. Otherwise, users may encounter unexpected results when they make selections. In the example above, you could write a constraint that prints a message to the user that A + B must equal 1 and then let users choose which option they want.

About Configuration Constraint Conditions

Many of the constraint templates contain conditions or expressions. For example:

Exclude template: [Item or condition] excludes [item or condition]
Require template: [Item or condition] requires [item or condition]

A condition is an explicit statement about the configuration. Conditions can play several roles in a constraint template. First, they can act as a test that determines whether a constraint is enforced. For example, you write the following constraint:

Item A > 4 excludes Item B

This constraint states that when the quantity of Item A is greater than 4 in the solution, then Item B cannot be present (is excluded). In this constraint, "Item A > 4" is a condition that, when true, causes Item B to be excluded.

When a condition is used as a test, the Siebel Product Configurator engine evaluates the condition and returns true or false. If the condition is true, the constraint is enforced.

Secondly, conditions can define a constraint. For example, you write the following constraint:

Item B excludes Item A > 4

This constraint states that when Item B is present in the solution, then the quantity of Item A in the solution cannot be greater than 4. In this constraint, "Item A > 4" is a condition that defines a constraint.

Conditions can take several forms:

Quantity comparisons. The preceding examples are quantity comparisons.
Item values. The value of attributes, linked items, and resources can be used as conditions.
Constraint Templates. Constraint templates can be used as conditions. When constraint templates are used as conditions, the Siebel Product Configurator engine does not enforce the constraint as a constraint but instead evaluates the template as true or false. This is discussed further below.

Boolean operators (AND, OR, NOT) are provided in the Constraints List to allow combining conditions together or to negate an expression used in a condition.

A third way to use conditions is when writing require or exclude constraints about relationships. In the constraint "item A requires Relationship B" the Siebel Product Configurator engine has no way to determine which items in Relationship B to add to the solution if the user picks item A. So when the user picks item A, the Siebel Product Configurator engine prints a message in the user's message area stating that a selection from Class B is required.

Compound Logic and Comparison Operators in Configuration Constraints

Both Compound Logic and Comparison operators test for the truth of their operands. They return a true or false rather than a quantity.

Compound Logic operators, such as AND, NOT, OR, are used to link expressions together when creating a constraint. For example: (Condition A AND Condition B) requires Item C. Compound Logic operators are also called Boolean operators.

The following information presents the Compound Logic operators you can use with constraint templates.

Table Compound Logic Operators

Operator	Example	Description
NOT	! (A)	Logical negation. True when A is false and false when A is true. A can be an item or sub-expression.
AND	A AND B	Both A and B. True only when both A and B are true. When used as a top-level constraint, means that only solutions where both A and B are true are allowed. A and B can be items or sub-expressions.
OR	A OR B	Either A or B or both. False only when both A and B are false. A and B can be items or sub-expressions.
Exclusive OR	A XOR B	A or B but not both. A and B must have opposite truth states. False when A and B are either both true or both false. A and B can be items or sub-expressions.
NOT AND	! (A AND B)	Converse of A AND B. False only when both A and B are true. When used as a top-level constraint, means that A and B cannot both be present. A and B can be items or sub-expressions.

Comparison operators compare their operands and return a true or false. In the following constraint, when the quantity of item A is less than item B (when the comparison is true), then item C is required.

(Item A < Item B) requires C

If you specify an item as an operand in a comparison, the quantity of the item in the solution is used to make the comparison. If you specify an expression as an operand, the expression must resolve to a number.

If you specify an expression that resolves to true or false, then true is assigned the value 1 and false is assigned the value 0.

The following table presents the Comparison operators you can use with constraint templates.

Table Comparison Operators

Operator	Example	Description
Greater than	A > B	A is greater than B
Not less than	A >= B	A is greater than or equal to B
Equals	A == B	A equals B
Equals (compound)	A==B==C==D	True if A=B AND A=C And A=D
Not equal to	A <> B	A does not equal B
Not greater than	A <= B	A is less than or equal to B
Less than	A < B	A is less than B

When you are building a constraint, you can compound the comparison operators. For example, you could build the following expression:

(A>B>C>D)

This expression is equivalent to the following expression:

A>B AND A>C AND A>D

Arithmetic Operators in Configuration Constraints

An arithmetic operator allows you to perform an arithmetic operation on two items. If an operand is a product, the value refers to the quantity of the product in the solution.

The operands in the expression can be two items or can be one item and a constant. For example, you can increase the quantity of an item by a constant amount.

If you specify an expression as one of the items, it must resolve to a quantity. If the expression resolves to true or false, then 1 is assigned to true, and 0 to false.

Results of calculations are handled differently for resources values than for product quantities. Calculation results for resources are expressed exactly, including a decimal point if necessary. Because product quantities represent discrete units, results involving them are rounded to the nearest integer.

The following table shows the arithmetic operators.

Table Arithmetic Operators

Operator	Example	Description
Addition	A + B	Sum of A and B. A and B can be items or expressions. Result is floating point if A or B is floating point.
Subtraction	A - B	Subtracts B from A. A and B can be items or expressions. Result is floating point if A or B is floating point.
Negation	-(A)	Additive inverse of A. Uses only one operand. A can be an item or expression.
Multiplication	A * B	Product of A and B. Result is floating point if A or B is floating point. A and B can be items or expressions.
Division	A / B	Quotient of A divided by B. Truncates ratio to integer if both A and B are integers. Result is floating point if A or B is floating point. A and B can be items or expressions.
Modulo	%(A, B)	Remainder of A divided by B. For example, %(1900, 72) results in 28. If A or B is floating point, the value is first rounded to the nearest integer; then the remainder is computed as for integers. A and B can be items or expressions.
Minimum	min(A, B)	Result is the smaller of A and B and is floating point if A or B is floating point. A and B can be items or expressions.
Maximum	max(A, B)	Result is the larger of A and B and is floating point if A or B is floating point. A and B can be items or expressions.

The following table shows additional arithmetic operators that also take numeric operands and produce numeric results. Use them to control numeric accuracy or change numeric characteristics.

Table Additional Arithmetic Operators

Operator	Example	How Used
Integer	int(A)	Truncates A down to an integer. For example, if the operand is 6.7, returns 6. A can be an item or expression. Useful only with properties.
Float	flo(A)	Converts A to a floating point. It is the same as multiplying the operand by 1.0. A can be an expression.
Absolute value	abs(A)	Returns the absolute value of A. A can be an item or expression.
Sign test	sgn(A)	Returns -1 if the quantity of A <0, 0 if A=0, 1 if A>0. A can be an expression.

Attribute Value (Advanced) Template

The Attribute Value (Advanced) template has the following form:

(for [any] items)

You can toggle between [any] and [all]. The Attribute Value (Advanced) template can be used only within a require constraint, and it changes the logic for conditions involving attributes. This template does not display in the Pick a Constraint list. Instead, it displays in the list for inserting a condition.

The following require constraint contains two attribute conditions:

Attribute C = M in Relationship A requires Attribute D=P in Relationship B

This constraint works as follows: If any item from Relationship A has Attribute C=M in the solution, then all the items from Relationship B must have Attribute D=P in the solution. This is the default behavior of the require template when it contains attribute conditions and is called the Any-All form.

By inserting the Attribute (Advanced) template into the constraint, you can create all the other combinations of Any-All logic:

Attribute C = M in Relationship A requires Attribute D=P (for any items) in Relationship B
If any item from Relationship A has Attribute C=M in the solution, then there must be at least one item from Relationship B that has Attribute D=P in the solution (Any-Any form).

Attribute C = M (for all items) in Relationship A requires Attribute D=P in Relationship B
If all the items from Relationship A have Attribute C = M in the solution, then all the items from Relationship B must have Attribute D = P in the solution (All-All form).

Attribute C = M (for all items) in Relationship A requires Attribute D=P (for any items) in Relationship B
If all the items from Relationship A have Attribute C=M in the solution then there must be at least one item from Relationship B that has Attribute D=P in the solution (All-Any form).

Note: The for all items clause makes the condition evaluate to true when there are no items in the relationship. If you want the condition to evaluate to false even when there are no items in the relationship, use the advanced rule template and add an AND clause to the condition which checks that the relationship has at least one item in it.

To create this logic in other constraint types, such as exclude constraints, use one of the Advanced Constraint Templates to create the constraint. Then insert a numAttr condition in the constraint.

Conditional Value Template

The Conditional Value Template has the following form:

( [value] when [condition] is true, otherwise [value] )

This template allows you constrain a value based on a condition. The [value] can be any number or item in the customizable product.

This template does not display in the Pick a Constraint list. Instead, it displays in the lists for inserting arguments in a constraint. You can insert the Conditional Value template anywhere you can insert a number. The most common use for this template is with provide and consume constraints.

For example, you want product P1 to provide 2 to the resource R when the quantity of product P2 is greater than 10. If the quantity of P2 is not greater than 10, you want product P1 to provide 1 to resource R. You would write this constraint as follows:

P1 provides (2 when P2 >10, otherwise 1) to R

If you wanted product P1 to provide 2 to resource R only when product P2 is greater than 10, you would write this constraint as follows:

P1 provides (2 when P2 >10, otherwise 0) to R

Constrain Template

The Constrain template has the form:

Constrain [an expression] to be true

The constraint template is useful for making simple comparison or quantity expressions into top-level constraints. For example, you want make sure that there are exactly 4 of Item B in every solution:

Constrain [Item B = 4] to be true

You can also use the Constraint template to create exclude and require constraints that have only one operand. For example the following constraint excludes Item B from the solution:

Constrain [Item B =0] to be true

To require at least 1 Item B in the solution:

Constrain [Item B >= 1] to be true

By using Compound Logic operators, you can yoke conditions together and then allow or disallow the combination. For example, you want to make sure that if the quantity of Item A > 4 in the solution, then Item B must be less than 5, and conversely:

Constrain [Item A > 4 AND Item B < 5] to be true

Constrain Attribute Conditions Template

The Constrain Attribute Conditions template has the following form:

An attribute] [=] [a value] [requires or excludes] [an attribute] [=] [a value]

This template allows you to constrain the selectable values for one attribute based on the value the user selects for another attribute. The requires and excludes operators in this template work the same way as those in the Require and the Exclude templates.

Use this template when attribute choices for one item affect allowable attribute choices for another item. For example, you sell shirts in small, medium and large sizes. The user picks the size by selecting a value for the Size attribute. These shirts come in red, green, and blue for small and medium sizes. Large size shirts come in red only. The user picks the color by selecting a value for the Color attribute.

Use this template to write constraints that restrict the choices available to users when they pick a size or color. For example, you would write a constraint that both blue and green colors exclude the large size. If the user selects large for size, the blue and green attributes cannot be selected for color. If the user selects color blue, then large cannot be selected for size.

Constrain Attribute Value Template

The Constrain Attribute Value template has the form:

[An attribute] [=] [a value]

The Constrain Attribute Value template sets the value of an attribute so that it cannot be overridden by the user during a configuration session. If you write a constraint that sets the attribute equal to a value, this has the same effect as setting the attribute value and saving the record in Product Administration, Customizable Product, and then Product Attributes. By setting the comparison operator to other than equals (=), you can constrain the allowable ranges for numeric attribute values. For example you could write a constraint that constrains an attribute value to > 100. In this fashion you can use the Constrain Attribute Value template to validate user input for range-of-values attribute domains.

Depending on the data type of the attribute domain, the attribute value can be set to one of the enumerated types, to the value of a linked item, the value of another item's attribute, to a string, or to a number.

You can use this template to restrict attribute values based on conditions that occur during a configuration session. For example, you could write a constraint that restricts one attribute's value if the user chooses a specified value for another attribute.

This template cannot be used to constrain the attributes of customizable products that are components in a customizable product. For example, customizable product CP1 has as one of its components customizable product CP2. You cannot use this template to constrain the values of attributes in CP2.

If the product administrator has set the value of an attribute in the Product Attributes list, this value cannot be overridden by a configuration constraint, or by the Siebel Product Configurator engine.

Constrain Conditionally Template

The Constrain Conditionally template has the form:

When [condition A is true] [enforce constraint B], otherwise

[enforce constraint C]

This template provides if-then-else logic. When the condition is true the first expression is enforced as a constraint. If the condition is false, the second expression is enforced as a constraint.

Another way to view the logic is as a relationship between a condition and two constraints:

If condition A is true, then B is enforced as a constraint, and C can be either true or false.
If condition A is false, then C is enforced as a constraint, and B can be either true or false.

The condition can be defined as a quantity comparison of a product, relationship, or resource. It can also be the value of a linked item. Compound logic operators (AND, OR, and so on) are provided to link conditions together.

The constraints can also be quantity comparisons of products, relationships, or resources. The value of a linked item can also be used.

Constrain Product Quantity Template

The Constrain Product Quantity template has the form:

[The quantity of a product] [=] [a value]

The template has three parts. The first operand names the product.

The operator, [=], defines how the product quantity is related to the third operand, [a value]. The operator is limited to numeric comparisons ( =, <, >, and so on).

The [a value] operand can be any of the following:

The quantity of a product in the solution
The quantity of items from another relationship in the solution
The quantity of items in the solution from a class within a relationship
The value of an attribute (the data type for the attribute must be number or integer)
A number

The "Insert a" tab provides two sets of arithmetic functions that allow you to combine these items. For example, you could write the following constraint:

The quantity of Item A from Items Class <= the quantity of Products-Class items

In this constraint, "the quantity of item A from Items Class" is the first operand. It names Item A in the Items class. The second operand is "<=".

The third operand is "the quantity of Products-Class items" and refers to items in the Products class. This class is contained within a relationship in the customizable product.

The constraint states that the quantity of Item A in the solution must be less than or equal to the number of items from the Products-Class in the solution.

Use Constrain Product Quantity constraints to set limits on the quantity of products that can be in the solution. The limits can be defined as a number or as the quantity of other items, or the value of an attribute.

Constrain Relationship Quantity Template

The Constrain Relationship Quantity template has the form:

[The quantity of a relationship] [=] [a value]

The quantity of a relationship is the total number of items that have been added to the solution from the relationship. For example, a relationship contains Item A and Item B. If there is one Item A and one Item B in the solution, then the relationship quantity is two. If there are two of Item A in the solution and no Item Bs, the relationship quantity is also two.

The operator, [=], defines how the relationship quantity is related to the third operand, [a value]. The operator is limited to numeric comparisons (=, <, >, and so on).

The [a value] operand can be any of the following:

The quantity of a product in the solution
The quantity of items from another relationship in the solution
The quantity of items in the solution from a class within a relationship
The value of an attribute (the data type for the attribute must be number or integer)
A number

The "Insert a" tab provides two sets of arithmetic functions that allow you to combine these items into expressions. For example, you could write the following constraint:

The quantity of Items from Items relationship <= (2 * [Training Classes "Intro Course" Items-limit-attribute])

The first operand is the relationship: "The quantity of Items from Items relationship." The operator is "<=". The second operand is the "Items-limit-attribute."

This constraint states that the quantity of items from the Items relationship must be less than or equal to twice the value of the "Items-limit-attribute" of the Intro Course. The Intro Course is located in the Training Classes relationship.

Use Constrain Relationship Quantity constraints to set limits on the quantity of products from a relationship that can be in the solution. The limits can be defined as a number or as the quantity of other items, or the value of an attribute.

Constrain Resource Value Template

The Constrain Resource Value template has the form:

[A resource] [=] [a value]

The template has three parts. The first operand names the resource.

The operator, [>], defines how the resource is related to the second operand, [a value]. The operator is limited to numeric comparisons (=, <, >, and so on).

The [a value] operand can be any of the following:

The quantity of a product in the solution
The quantity of items from another relationship in the solution
The quantity of items in the solution from a class within a relationship
The value of an attribute (the data type for the attribute must be number or integer)
A number

The "Insert a" tab provides two sets of arithmetic functions that allow you to combine these items into expressions.

Use the Constrain Resource Value template to define limits on the value of a resource. For example, you can constrain a resource to be greater than 0 and less than 5.

Display Message Template

The Display Message template has the following form:

[Item or condition] displays this rule's explanation

The Display Message template is one of two ways to communicate messages to the user. The other is the Display Recommendation template.

In the Display Message template, when the condition is true, the explanation you entered for the constraint is displayed to the user in the Message area. The explanation must describe the condition in the constraint and can add additional information.

Use the Display Message template to display messages when a defined condition is true.

For example, you write the following Display Message constraint:

When [Product A is selected], display this rule's explanation.

You then save the constraint and enter the following in the Explanation field:

Product A has been selected. You can purchase only two of these items.

During a configuration session, when the user selects Product A, the constraint explanation appears in the message area.

Display Recommendation Template

The Display Recommendation template has the following form:

[Item or condition] recommends [item or condition] by displaying this rule's explanation.

The Display Recommendation template displays the constraint's explanation based on the truth state of its two item/condition operands, as shown in the following table.

Table Truth Table for Display Recommendation Template

First Item/Condition	Second Item/Condition	Message Displays?
True	True	No
False	True	No
True	False	Yes
False	False	No

The table shows that the constraint explanation displays only when the first item/condition is true and the second is false. The recommendation displays in the user's message area.

The Boolean equivalent of how the Display Recommendation template works is shown below. The expression is true only when A is true and B is false. When the expression is true, the message displays.

NOT ((NOT A) OR B)

Use Display Recommendation constraints to up-sell or cross-sell other configuration options, to inform the user of configuration restrictions, or to offer configuration suggestions.

For example, when the user picks Product A, you want to display a message recommending Product B. If the user then picks Product B, you want to stop displaying the message.

You would write this constraint as follows:

Product A recommends Product B by displaying this rule's explanation.

In the constraint's Explanation field: When you select Product A, we recommend you also purchase Product B.

Exclude Template

The Exclude template has the form:

[item or condition] excludes [item or condition]

The exclude constraint is mutual. For example, if Item A is present in the solution, Item B cannot be present. Conversely, if Item B is present, Item A cannot be present.

The excludes constraint is functionally equivalent to a Boolean ! (A AND B), that is, a NAND operator. In the following table, a T (true) means the item is present in the solution. An F (false) means it is not present or is excluded.

Table Truth Table for Exclude

A	B	A AND B	! (A AND B)
T	F	False	True
F	T	False	True
F	F	False	True
T	T	True	False

The truth table shows that an exclude constraint is always true except when both operands are present in the solution.

Use an exclude constraint to:

Prevent technical configuration errors. For example, a computer operating system or software application may be incompatible with certain microprocessors.
Prevent configurations that are undesirable or ineffective. For example, in a financial model, an exclude constraint could prevent adding a low quality bond fund to a retirement portfolio.

Items

An item in an exclude constraint can be any of the following:

A relationship or class within a relationship
A product within a relationship or class

Here is how the exclude constraint works with items:

Product A excludes Product B
If Product A is present in the solution, then Product B cannot be present. If Product B is present in the solution, then Product A cannot be present.

Relationship A excludes Product B
If any product in Relationship A is present in the solution, then Product B is excluded. If Product B is present, then no product from Relationship A can be present.

Relationship A excludes Relationship B
If any Product in Relationship A is present in the solution, then no product in Relationship B can be present. If any product in Relationship B is present in the solution, then no product from Relationship A can be present.

Conditions

Conditions in an exclude constraint can take many forms. For example, an attribute condition specifies an attribute value. Here is a summary of how the exclude constraint works with conditions in general. How exclude constraints work with specific types of conditions is covered in the topics following this one.

Product A excludes Condition B
If Product A is present in the solution, then Condition B cannot be true. If Condition B is true in the solution, then product A cannot be present.

Relationship A excludes Condition B
If any product in Relationship A is present, Condition B cannot be true. If Condition B is true in the solution, then no product from Relationship A can be present.

Condition A excludes Product B
If Condition A is true in the solution, then Product B is excluded. If Product B is present in the solution, then Condition A cannot be true in the solution.

Condition A excludes Relationship B
If Condition A is true in the solution, then all products in relationship B are excluded. If any product from Relationship B is present in the solution, then Condition A cannot be true in the solution.

Condition A excludes Condition B
If Condition A is true in the solution, then Condition B cannot be true in the solution. If Condition B is true in the solution, then Condition A cannot be true in the solution.

Attribute Conditions

Attribute conditions are used to exclude specific attribute values for an item or group of items. For example, if the user picks item A, then the "Large" attribute value for item B is excluded.

In the constraint examples below, the attributes are defined on items in relationships within the customizable product. You can also define exclude constraints on the attributes of the customizable product itself.

In the following constraint examples, excluded means the user can no longer select the item. If the excluded item is a relationship, the user can no longer select any of the products in the relationship. Excluded also means the Siebel Product Configurator engine will not create solutions that contain the excluded item.

Product A excludes Attribute C = M in Relationship B
If Product A is present in the solution, then the value M will not be selectable for Attribute C in Relationship B.
If any product with Attribute C = M in Relationship B is present in the solution, then Product A is excluded from the solution.

Relationship A excludes Attribute C = M in Relationship B
If any product in Relationship A is present in the solution, then the value M will not be selectable for Attribute C in Relationship B.
If any product with Attribute C = M in Relationship B is present in the solution, then all the products in Relationship A are excluded from the solution.

Attribute C = M in Relationship A excludes Product B
If any product with Attribute C = M in Relationship A is present in the solution, then Product B is excluded from the solution.
If Product B is present in the solution, then the value M will not be selectable for Attribute C in Relationship B.

Attribute C = M in Relationship A excludes Relationship B
If any product with Attribute C = M in Relationship A is present in the solution, then all the products in Relationship B are excluded from the solution.
If any products from Relationship B are present in the solution, then the value M will not be selectable for Attribute C in Relationship B.

Attribute C = M in Relationship A excludes Attribute D = P in Relationship B
If any of the products with Attribute C = M in Relationship A are present in the solution, then the value P for Attribute D will not be selectable in Relationship B.
If any products with Attribute D=P in Relationship B are present in the solution, then the value M will not be selectable for Attribute C in Relationship A.

Quantity Conditions

Quantity conditions compare the quantities of two items. Depending on the session context in which a quantity condition is evaluated, it either returns true/false or is enforced as a constraint.

For example you write the following configuration constraint,

(Product A > Product B) excludes Product C

Context A. If the user picks Product A so that its quantity is greater than Product B, then Product C is excluded. In this case, the quantity condition is evaluated as true/false, and Product C is excluded when it is true.

Context B. If the quantity of Product A in the solution is not greater than Product B and the user picks Product C, then the quantity condition is enforced as a constraint. In all further solutions, the Siebel Product Configurator engine will require that the quantity of Product A is < = Product B if Product C is present.

Other Item Constraints

Several other types of conditions can also be used in exclude rules. In some cases these conditions do not make sense when used as the second operand in an exclude rule. The following table summarizes how to use item constraints.

Table Item Constraint Usage in Exclude Rules

Item Constraint	First Operand	Second Operand
Attribute Value	Yes	Yes
Consumes	No	No
Provides	No	No
Excludes	Yes	Yes
Excludes List	Yes	Yes
Requires	Yes	Yes
Requires List	Yes	Yes
Linked Item Value condition	Yes	Yes
Message, Recommends	No	No
Product Quantity	Yes	Yes
Relationship Quantity	Yes	Yes
Class Quantity	Yes	Yes

Nested Expressions as Conditions

The Exclude Template can itself be used as a condition in other constraints. The most common templates used for writing nested constraints are the Exclude and Require templates. For example you could write the configuration constraint:

Product A excludes (Product B excludes Product C)

The Boolean form of this constraint is as follows:

A NAND (B NAND C)

In the following table, a T (true) means the item is present in the solution. An F (false) means the item is not present or is excluded.

Table A AND ! (B AND ! (C))

Row	A	B	C	(B AND ! (C))	A AND ! ( B AND ! (C))
1	F	F	F	T	T
2	F	F	T	T	T
3	F	T	F	T	T
4	F	T	T	F	T
5	T	F	F	T	F
6	T	F	T	T	F
7	T	T	F	T	F
8	T	T	T	F	T

The truth table lets you analyze what happens when the user picks items. For example, there are no Product A, Product B, or Product C in the solution. The user picks Product B. You evaluate how the Siebel Product Configurator engine will respond as follows:

Picking B means that B is true, so eliminate all rows from the table where B is False. This leaves rows 3, 4, 7, and 8.
The engine returns solutions in which all constraints are true, so you can eliminate any of the remaining rows where the whole constraint is false. This means you can eliminate row 7. This leaves rows 3, 4, and 8.
Now examine the truth conditions for Product A and Product C in the rows 3. 4, and 8. The table shows that A is false in row 3 and 4 but true in row 8. This means that if the user picks B, then A can be either present or absent. It is not constrained. The table shows that C is false in row 3 but true in rows 4, and 8. This also means that C is not constrained. Thus, the user can pick B without A or C being excluded or required.

If A or C had been true in all three remaining rows, this means A or C is required. If A or C had been false in all three rows, this means A or C is excluded.

Multiple Operands

You can add multiple operands to an exclude constraint by clicking the Compound Field button when you create the constraint.

For example, you could create the constraint:

Item A excludes Item B > 2, Item C < 5

This constraint means the following:

If Item A is present in the solution, Item B cannot be greater than 2
If item A is present in the solution, Item C cannot be less than 5
If Item B is greater than 2 in the solution, Item A cannot be present
If item C is less than 5 in the solution, Item A cannot be present

Using commas to separate expressions is the same as writing two constraints:

Item A excludes Item B > 2

Item A excludes Item C < 5

If you want to write a constraint where you exclude the combination of two conditions you would do it as follows:

Item A excludes (Item B > 2 AND Item C < 5)

This constraint means that if Item A is present in the solution, the two conditions cannot be simultaneously true in the same solution. If Item A is present, the quantity of Item B can be greater than 2 as long as the quantity of Item C is not less than 5 and conversely.

Procedural Condition Templates

You can use two procedural condition rule templates together:

For information on how to use these templates, see Example of Using Procedural Condition Rules.

Procedural-Condition Check Template

The Procedural-Condition Check template has the form:

If procedural condition [item or condition] is true, enforce resultant condition item or condition

You use the Procedural-Condition Check template to check for a precondition. If the item or condition it checks for is true, then the resultant condition is enforced in the solution.

If condition 1 is satisfied before the user clicks, condition2 must be satisfied after the user clicks. Otherwise, an undo only conflict error message is generated. During LoadInstance, this rule is not enforced, because no precondition is satisfied.

For example, consider the following scenario:

Root Product

|_Relationship 1

|_Product A

|_Product B

|_Product C

Constraint: If the procedural condition saying that the quantity of Product A from Relationship 1 equals 1 is true, then enforce the resultant condition saying that the quantity of Product B from Relationship1 equals 1.

Expected Behavior: When Product A is selected and has a quantity of 1, user must select Product B and enter the quantity of 1 before performing any other operation. If the user makes a selection other than Product B, a conflict message is displayed.

The procedural condition applies only to relationships and attributes that are referenced by constraints. For example, consider the following scenario:

Root Product

|_Relationship 1

|_Product A

|_Product B

|_Product C

|_Relationship 2

|_ Product D

|_ Product E

Constraint: If procedural condition the quantity of Product A from Relationship 1 = 1 is true, enforce resultant condition the quantity of Product B from Relationship 1 = 1.

When the user selects Product A and then selects Product C, a conflict message is displayed, because Relationship 1 is referenced within the constraint and relationship items are loaded by the constraint engine. When the user selects Product A and then selects Product D, a conflict message is not displayed, because Relationship 2 is not referenced by any constraint.

Set Procedural Conditional Variable Template

The Set Procedural Conditional Variable template has the form:

[Item or condition] sets Procedural condition variable value to true

This template defines a variable on the product instance. This variable's name is the rule name, and its value is evaluated after each user click. The variable can be retrieved from the Siebel Product Configurator service using a script and can be used to control the application behavior dynamically.

Excluding Values in the Administration - Product Screen

You can specify in the Administration - Product screen that certain values are excluded based on the expression variables defined by Set Procedural Conditional Variable rules. You can do this using the property, CondExcl=exprVarName. The attribute values or products in the domain with this property are shown as excluded when exprVarName evaluates to true.

To exclude values based on Set Procedural Condition Variable rules

Navigate to Administration - Product screen, then the Products Definitions view.
In the Versions list, drill down on the Workspace version of the product.
Click the Properties view tab.
In the Properties list, add a new record and complete the necessary fields, as described in the following table.

Field	Comments
Name	Enter CondExcl.
Value	Enter an expression variable. The attribute values or products in the domain with this property are shown as excluded when this variable evaluates to true.

Example of Using Procedural Condition Rules

For example, consider the following scenario:

Customizable product A has a relationship R1 with products B1 and B2.
Product A has attribute C with enumerated values C1 and C2. The option C2 is valid only with product B2.
You want to show the C2 option even with the B1 product choice, and then display an appropriate message if C2 is chosen.

Set up the following constraint:

If procedural condition NOT (selection of [B2]) is true, then enforce resultant 
condition NOT (the attribute C = C2)

Provide and Consume Templates

The Provide template has the form:

[An item] provides [a value] to [a target]

The Consume template has the form:

[An item] consumes [a value] from [a target]

Provide and consume constraints positively or negatively increment the amount of the target operand each time the specified item is added to the solution. Provide constraints contribute a positive amount; that is, they increase the amount of the target. Consume constraints contribute a negative amount; that is, they reduce the amount of the target.

Contrast this behavior with the behavior of the require constraints. For example, Item A requires Item B. The first time the user picks Item A, if no item B is in the solution, the Siebel Product Configurator engine adds at least one Item B. The second time the user picks Item A, the engine does not increment Item B because the require constraint does not consider the quantity of Item A in the solution, only that Item A is present.

Now consider the constraint Item A provides 1 to Item B. Each time the user picks Item A, the Siebel Product Configurator engine increments the number of Item B in the solution by 1. This constraint ties the quantities of Item A and Item B together so that each Item A requires an Item B. Provide and consume constraints work directly with quantities expressed as resource or attribute values, while require constraints consider only the presence or absence of an item.

Note: Provide and Consume constraints work properly when the resource is defined in the parent product. For modeling scenarios that require embedding resources in the child product, use attributes of type Integer instead.

Item

The Item operand can be a product, a relationship, a product class within a relationship, a resource or an attribute. If the item is a relationship or class, the constraint applies to all the items in the relationship or class. For example, Relationship A provides 1 to Item B. Each time an item from Relationship A is added to the solution, Item B is added to the solution.

Value

The value operand defines the quantity to be contributed to the target. The Constraints view provides several methods for determining this quantity:

You can explicitly state the quantity, for example Item A consumes 1 from Item B. This constraint means that each Item A added to the solution decreases the amount of Item B in the solution by 1.
You can define the value as the quantity of another item, or the value of an attribute, linked item or resource. For example, Item A provides three times the quantity of Item B to Item C. This constraint means that for each Item A added to the solution, the quantity of Item C is incremented by three times the quantity of Item B.
You can define an expression that determines which products in the relationship or class specified in Item will increment the target. For example: Any item of Relationship A provides Relationship A, Attribute Color = Red to Item B. This constraint means that for each item in Relationship A for which the attribute Color = Red that is added to the solution, the quantity of Item B is incremented by one.

Target

The target operand is incremented by the amount specified in the value operand. The target can be a product, resource, or product attribute. It cannot be a relationship, a class, or an expression.

Product Target

When the target operand is a product, the quantity of the product is incremented. For example, Product A provides 2 to Product B. This constraint means that each Product A added to the solution increases the quantity of Product B (the target) by 2.

The consume constraint works the same way. For example, Product A consumes 2 from Product B. This constraint means that each Product A added to the solution decreases the quantity of Product B (the target) by 2.

Resource Target

When the target is a resource, the value of the resource is incremented. One of the most common uses of provides and consume constraints is to manage resources.

Resources keep track of configuration variables that increase or decrease as the user makes selections. For example, suppose you are creating a customizable product rule for configuring desktop computers. Your product includes several types of chassis. Each chassis has a different number of slots for expansion cards. The product also includes several types of expansion cards, such as disk controllers, and graphics cards.

You do not know in advance which chassis the customer will select or how many expansion cards. However, you do know you must keep track of the number of slots available in a chassis during the configuration process to verify that the computer is configured correctly.

Using provide and consume constraints to increment a resource is the way to handle this:

First define a resource to keep track of slots, for example Slots Available.
Then define an attribute called Slots on the chassis class. Create a enumerated values of data type integer. Create one record for each chassis type. The value for each record is an integer equal to the number of slots in the chassis type. This creates a menu of choices for setting the number of slots in a chassis. Assign the list of values to the Slots attribute definition.
Display the attributes for each chassis and set the value of the Slots attribute and save the record. This sets the number of slots in the chassis and prevents it from being changed by the user or the Siebel Product Configurator engine.
Add the chassis class to a relationship, Chassis.
Define an attribute called Slots Required on the expansion card class. Use a range of values domain and set the data type to Integer. Enter: ==1 as the validation expression. Enter 1 as the default value.
Display the attributes for each expansion card and save the Slots Required record. This sets the number of slots required at 1 and prevents it from being changed by the user or the Siebel Product Configurator engine.
Add the expansion card class to a relationship, Expansion Card.
Write the following constraint: Chassis provides Chassis Slots to Slots Available.
Write the following constraint: Expansion Card consumes Expansion Card Attribute = Slots Required from Slots Available.
Write constraints as needed to determine what happens if Slots Available is 0 or if it becomes negative.

When the user selects a chassis, the provide constraint increases the Slots Available resource by the number of slots in the chassis. Each time the user selects an expansion card, the consume constraint decreases the Slots Available resource by one. Thus, the Slots Available resource maintains a record of how many slots are available in the chassis during the configuration session.

If a resource has the same name in two different customizable products, the Siebel Product Configurator engines treats them as the same resource. You can take advantage of this in cases where one product with components is contained within another. For example, product with components CP2 is contained within product with components CP1. You define resource R1 in both products. Constraints in either product with components that contribute to R1, affect the value of R1 in both products. Use this behavior to allow a parent product with components to contribute to a resource in a child product with components.

Attribute Target

When the target is an attribute, the value of the attribute is incremented. Attribute targets are very similar in behavior and use as resource targets. There are several restrictions on using provide and consume constraints to manipulate attribute values:

The data type of the attribute must be numeric (Integer or Number).
The attribute must be available for manipulation. You must not have set the value of the attribute. You do this by selecting an attribute value and saving it in Product administration, Customizable Products, and then Product Attributes.
A child product with components can contribute to attributes defined on the parent. The parent cannot contribute to attributes defined on the child product. For example, product with components CP2 is contained within product with components CP1. CP2 can contribute to attributes defined within CP1. CP1 cannot contribute to attributes defined within CP2.

Use attributes as targets instead of defining multiple resources that keep track of similar variables. This ties the variables directly to a class and makes it easier to keep track of the variables' roles.

Simple Provide and Consume Templates

The Simple Provide template has the form:

Provides [a value] to [a target]

The Simple Consume template has the form:

Consume [a value] from [a target]

The Simple Provide and Simple Consume templates positively or negatively increment the amount of the target operand. These templates are intended for use as the action portion of a conditional constraint. If the condition is true, then a value is provided or consumed from the specified target.

The Simple Provide template contributes a positive amount, that is it increases the amount of the target. The Simple Consume template contributes a negative amount, that is it reduces the amount of the target.

Value

The value operand defines the quantity to be contributed to the target. The Constraints view provides several methods for determining this quantity:

You can explicitly state a number as the value.
You can define the value as the quantity of another item, or the value of an attribute, linked item or resource. For example, you can provide three times the quantity of Item B to Item C.
The value can be an expression that resolves to an amount. This amount is then contributed to the target. For example: When a condition is true, it provides Relationship A, Attribute Color = Red to Item B. This constraint means that when the condition is true, then each item in Relationship A for which the attribute Color = Red that is added to the solution, increments the quantity of Item B by one.

Target

The target operand is incremented by the amount specified in the value operand. The target can be a product, resource, or product attribute. It cannot be a relationship, a class, or an expression.

Product Target

When the target operand is a product, the quantity of the product is incremented in the solution.

Resource Target

When the target is a resource, the value of the resource is incremented.

Attribute Target

When the target is an attribute, the value of the attribute is incremented. Attribute targets are similar in behavior and use as resource targets. There are several restrictions on using provide and consume constraints to manipulate attribute values:

The data type of the attribute must be numeric (Integer or Number).
The attribute must be available for manipulation. You must not have set the value of the attribute. You set the value of an attribute by selecting an attribute value and saving it in Product Administration, Customizable Products, and then Product Attributes.
A child product with components can contribute to attributes defined on the parent. The parent cannot contribute to attributes defined on the child product. For example, product with components CP2 is contained within product with components CP1. CP2 can contribute to attributes defined within CP1. CP1 cannot contribute to attributes defined within CP2.

Relationship Item Constraint Template

The Relationship Item Constraint template has the form:

For each item [in a relationship], constrain [an expression] to be true

The "in a relationship" operand can be a whole relationship, a subclass of items in a relationship, or a product in a relationship. The "an expression" operand can be any constraint template or any constraint you construct from templates.

The purpose of the Relationship Item Constraint template is to allow you to write a constraint for items in a relationship as if you had written the constraint separately for each instance of the items. For example, you define Relationship A that contains the product with components desktop PC. The desktop PC is a product with components that includes two relationships: CPU and Hard Drive. You then write the following constraint:

For each item in Relationship A, constrain CPU requires Hard Drive to be true

This constraint enforces "CPU requires Hard Drive" separately on each instance of desktop PC in Relationship A. All the desktop PCs from Relationship A must have a hard drive if they have a CPU.

A require constraint does not do this. Suppose you had written the following constraint:

CPU requires Hard Drive

This constraint means if any desktop PC has a CPU from the CPU relationship then at least one desktop PC must have a hard drive from the Hard Drive relationship.

This means, for example, that if the user configures three desktop PCs, all with CPUs, then only one of them must have a hard drive. If the user removes the hard drive, the Siebel Product Configurator engine would add a hard drive to another desktop PC in the solution or add a new desktop PC that contains only a hard drive. The require constraint defines a constraint that is true about the group of desktop PCs in the solution rather than about individual desktop PCs.

Another problem with the require constraint is that it does not limit enforcement of the constraint to the items in Relationship A. If, in the require constraint example, desktop PCs were also contained in Relationship B, then desktop PCs configured from Relationship B would also be considered when enforcing the require constraint for desktop PCs configured from Relationship A.

An important use of this template is to write constraints that apply to products with components only when these products are contained in a relationship within another product with components.

Require Template

The Require template has the form:

[item or condition] requires [item or condition]

A require constraint is a logical implies. If the first operand is true then the second operand is implied (must be true). For example, Item A requires Item B. This constraint means that if Item A is present in the solution, then Item B must be present. Another example: Condition A requires Item B. This constraint means that if Condition A is true, then Item B must be present in the solution.

A require constraint is not mutual. The constraint Item A requires Item B does not imply Item B requires Item A. However, if Item B is excluded then Item A is also excluded. This is because when Item B is excluded, the constraint can never be true.

The require operator is functionally equivalent to the following Boolean expression:

(NOT A) OR B

In the first two columns of the following table, a 1 means the item is present in the solution. A 0 means it is absent or excluded.

Table Truth Table for Require Expressions

A	B	NOT A	(NOT A) OR B
1	0	0	False
0	1	1	True
0	0	1	True
1	1	0	True

The table shows that a require constraint behaves as follows:

False when Item A is present and Item B is not. (If Item B cannot be present, Item A cannot be present).
True when Item B is present and Item A is not.
True when neither is present.
True when both are present.

Use require constraints to:

To create a requires relationship for items in different relationships. For example, you can write a constraint that if Item A in relationship 1 is picked, then Item B in relationship 2 is required.
To add items to the configuration if a condition is true.
To create relationships between other items (conditions) when a product is added to the solution.

Items

An item can be any of the following:

A relationship or class within a relationship. For example, Relationship A requires Item B. This constraint means that when any product in relationship A is present in the solution, then Item B must be present.
A product within a relationship

When items are the operands, require constraints are concerned only with presence or absence, not quantity. For example, Item A requires Item B. When the first Item A is added to the solution, the Siebel Product Configurator engine will add at least one Item B if none are present. When the second Item A is added, the engine does not add any more Item B, since at least one is already present.

Here is how the require constraint works with items:

Product A requires Product B
If Product A is present in the solution, then Product B is required. If Product B is excluded, then Product A is excluded.

Relationship A requires Product B
If any product in Relationship A is present in the solution, then Product B is required. If Product B is excluded, then all the products in Relationship A are excluded.

Relationship A requires Relationship B
If any Product in Relationship A is present in the solution, then at least one product in Relationship B must be present. If all the products in Relationship B are excluded, then all the products in Relationship A are excluded.

Conditions

Conditions can take many forms. Here is a summary of how the require constraint works with conditions in general. How require constraints work with specific types of conditions is covered in the topics following this one.

Product A requires Condition B
If Product A is present in the solution, then Condition B is required to be true. If Condition B is false, then Product A is excluded.

Relationship A requires Condition B
If any product in Relationship A is present in the solution, Condition B is required to be true. If Condition B is false, then all the products in Relationship A are excluded.

Condition A requires Product B
If Condition A is true in the solution, then Product B is required. If Product B is excluded, then Condition A is required to be false.

Condition A requires Relationship B
If Condition A is true in the solution, then at least one product in relationship B must be present in the solution. If all the products in Relationship B are excluded, then Condition A is required to be false.

Condition A requires Condition B
If Condition A is true in the solution, then Condition B must also be true. If Condition B is false, then Condition A is required to be false.

Attribute Conditions

An attribute condition specifies an attribute value and uses it to identify the items in a relationship to which the constraint applies. In the constraint examples below, the attributes are defined on items in relationships within the product with components. You can also define require constraints on the attributes of the product with components itself.

In the constraints examples below, the equals operator is used in the attribute expressions. You can use all the math operators ( <, >, and so on) when writing this type of constraint.

Product A requires Attribute C = M in Relationship B
If Product A is present in the solution, then M is the only value selectable for Attribute C for all items in Relationship B.

Relationship A requires Attribute C = M in Relationship B
If any product in Relationship A is present in the solution, then M is the only value selectable for Attribute C for all items in Relationship B.

Attribute C = M in Relationship A requires Product B
If any product with Attribute C = M in Relationship A is present in the solution, then Product B must be present.

Attribute C = M in Relationship A requires Relationship B
If any product with Attribute C = M in Relationship A is present in the solution, then at least one of the products in Relationship B must be present.

Attribute C = M in Relationship A requires Attribute D = P in Relationship B
If any of the products with Attribute C = M in Relationship A are present in the solution, then P is the only value selectable for Attribute D in Relationship B.

Quantity Conditions

Quantity conditions compare the quantities of two items. Depending on the session context in which the quantity condition is evaluated, it either returns true/false or is enforced as a constraint.

For example you write the following constraint:

(Product A > Product B) requires Product C

If the user picks Product A so that its quantity is greater than Product B, then Product C is required. In this case, the quantity condition is evaluated as true/false, and Product C is required when it is true.

Contrast this with the following constraint:

Product C requires (Product A > Product B)

When the user picks Product C, the condition (Product A > Product B) is enforced as a constraint. In all further solutions, the quantity of Product A must be greater than the Product B. Also, if the quantity of Product B is greater than Product A in the solution, Product C is excluded.

Other Item Constraints

Several other types of conditions can also be used in require constraints. In some cases these conditions do not make sense when used as the second operand in a require constraint. This is because some conditions are always true (message conditions), or the condition cannot be enforced to be true (linked item conditions).

The following table summarizes how to use item constraints

Table Item Constraint Usage in Require Constraints

Item Constraint	First Operand	Second Operand
Attribute Value	Yes	Yes
Consumes	No	Yes
Provides	No	Yes
Excludes	Yes	Yes
Excludes List	Yes	Yes
Require	Yes	Yes
Require List	Yes	Yes
Linked Item Value condition	Yes	No
Message, Recommends	No	Yes
Product Quantity	Yes	Yes
Relationship Quantity	Yes	Yes
Class Quantity	Yes	Yes

Nested Expressions as Conditions

The Require template can itself be used as a condition in other constraints. The most common templates used for writing nested constraints are the Require and Exclude templates. For example, you could write the following configuration constraint:

Product A requires (Product B requires Product C)

The Boolean form of this constraint is as follows:

(NOT A) OR ((NOT B) OR C)

The following table shows the truth table for this constraint.

Table (NOT A) OR ((NOT B) OR C)

Row	A	B	C	NOT A	(NOT B) OR C	(NOT A) OR ((NOT B OR C)
1	F	F	F	T	T	T
2	F	F	T	T	T	T
3	F	T	F	T	F	T
4	F	T	T	T	T	T
5	T	F	F	F	T	T
6	T	F	T	F	T	T
7	T	T	F	F	F	F
8	T	T	T	F	T	T

The table lets you analyze what happens when the user picks items. Use the following steps to do this:

The engine must return solutions in which all constraints are true. Eliminate any rows where the top-level expression is False. In the table above, eliminate row 7.
To determine what happens when the user picks an item, look at all rows that list true for that item. For example, to analyze what happens when the user picks Product A, you would look at rows 5, 6, and 8 in the table above.
To determine what happens when a combination of items are picked, look at all the rows that list true for both items at once. For example, to analyze what happens when the user picks both Product A and Product B, you would look at only row 8 in the table above. (Row 7 is not considered since the top-level expression is false.)
If only one row has the correct truth conditions, this means the Siebel Product Configurator engine will return the result shown in that row. For example, look at row 8. This is the only remaining row that lists item A and B as both true. Since this row lists C as true, this means that when both A and B are present, C must be present.
If several rows have the condition you are analyzing, look at the truth conditions for each unpicked item in the rows. If they are all true, the unpicked item is required. If they are all false, the unpicked item is excluded. If an unpicked item lists true in some rows and false in others, this means the unpicked item is neither excluded nor required and is available.

The table reveals that the constraint has the following behavior:

When none of the products are present, the user can pick any of the three, and the other two will not be required.
If the user picks Product A and B, then Product C is required.

Thus, the constraint's behavior can be summarized this way: when the user picks Product A, the condition "Product B requires Product C" is enforced as a constraint.

Multiple Operands

You can add multiple operands to a require constraint by clicking the Compound Field button when you create the constraint.

For example, you could create the constraint:

Item A requires Item B > 2, Item C < 5

This constraint means the following:

If Item A is present in the solution, the quantity of Item B must be greater than 2
If item A is present in the solution, the quantity of Item C must be less than 5
If Item B cannot be greater than 2 in the solution, Item A is excluded
If item C cannot be less than 5 in the solution, Item A is excluded

This is the same as writing two constraints:

Item A requires Item B > 2

Item A requires Item C < 5

Require (Mutual) Template

The Require (Mutual) template has the following form:

[Item or Condition] and [Item or Condition] mutually require each other

Use this template when the requires relationship between items or conditions is mutual. For example, Product A requires Product B, AND Product B requires Product A.

When using components as the operands, you can specify global paths for either or both components.

The Boolean equivalent of the Require (Mutual) template is NOT(A XOR B).The following table shows the truth table for this template.

Table Truth Table for Require (Mutual)

A	B	A XOR B	NOT(A XOR B)
T	F	True	False
F	T	True	False
F	F	False	True
T	T	False	True

The behavior of the Require (Mutual) template is the same as the Exclude template, except that operands are required instead of excluded.

Set Initial Attribute Value Template

The Set Initial Attribute Value template has the form:

[An attribute] has an initial value of [a number]

The Set Initial Attribute Value template sets the numeric value of an item's attribute at the beginning of a configuration session. The attribute must be of data type Number or Integer. The attribute can have either an enumerated types or range of values type domain.

If attributes' value are set through the Set Initial Attribute Value Constraint template, the user cannot change these values at run time. They can only be changed by Provide and Consume rules.

Setting an attribute value in this fashion brings the attribute value under the control of all its contributors. This means that the attribute value must exactly equal the sum of all its contributors. For example, if during the configuration session, the amount contributed by provide and consume constraints exactly equals the attribute value, users will not be able to change the attribute value. If not, the user can adjust the value, but only if this also adjusts the amount contributed by the provide and consume constraints.

To set the initial value of an attribute that has a non-numeric data type, use the Set Preference template.

This template cannot be used to set the attributes of customizable products that are components in a customizable product. For example, customizable product CP1 has as one of its components customizable product CP2. You cannot use this template to set the values of attributes in CP2.

If the product administrator has set the value of an attribute in the Product Attributes list, this value cannot be overridden by a configuration constraint or by the Siebel Product Configurator engine.

Set Initial Resource Value Template

The Set Initial Resource Value template has the form:

[A resource] has an initial value of [a number]

The Set Initial resource Value template functions as a provide constraint and sets the numeric value of a resource at the beginning of a configuration session.

Before specifying a resource using this template, items must be present in the solution that contribute (provide or consume) to the resource. During a configuration session, other constraints can increase or decrease the value.

Resource values are under the exclusive control of provide and consume constraints. Users cannot set the value of a resource by entering a value in a selection page.

Set Preference Template

The Set Preference template has the form:

When possible, constrain [an expression] to be true with a [specified priority]

The expression in a preference constraint is enforced as a constraint only if it does not conflict with any other constraint type or with any user selections. The purpose of the Set Preference template is to allow you to create soft constraints that guide the Siebel Product Configurator engine in producing solutions but which the engine can ignore if needed to avoid conflicts or performance problems.

A key use for preference constraints is to cause a default selection of Item B based on the selection of Item A. This is called a dynamic default. You can set a default dynamically based on a previous user selection. The user can then override the default if desired by choosing a different item than the dynamic default.

For example, you could write the following constraint:

When possible, constrain [Item A requires Item B] to be true with a priority of [0].

When the user picks Item A, the engine will attempt to create a solution containing Item B. However, the engine is free not to include Item B in order to avoid conflicts and performance problems.

If users do not want Item B, they can remove it without creating a conflict. If you had written the constraint as "Item A requires Item B", Item B would be added when users picks Item A. If user tried to remove Item B, they would receive a conflict message.

Another use for the Set Preference Template is to set or modify the default value for an attribute. To do this, you would write a preference constraint where the expression, is Attribute A = value. The attribute would then be displayed with this value unless overridden by another constraint.

The priority operand in preference constraints determines the order in which multiple preference constraints for an item are evaluated. Preference constraints with priority 0 that apply to a specific item are evaluated first. Those with priority 1 that apply to that item are evaluated next, and so on.

For example, you have written two preference constraints that apply to a specific relationship. PrefConstraint A has a priority of 0. PrefConstraint B has a priority of 1. The Siebel Product Configurator engine will attempt to add PrefConstraint A to the solution before attempting to add PrefConstraint B.

Here is how the Siebel Product Configurator engine creates solutions containing preference constraints:

The engine generates a solution that enforces all constraints and user choices but does not include preference constraints.
The engine then adds the preference constraints one at a time for each item. It begins by adding the highest priority preference constraints for an item first. Preference constraints with the same priority are added in arbitrary order.
If the solution remains valid when a preference constraint is added, then the expression in the preference constraint is enforced as a constraint and becomes part of the solution.
If adding a preference constraint creates a conflict so that the solution fails, the preference constraint is skipped, and its expression is not enforced. The engine then goes on to the next preference constraint.
Preference constraints are evaluated after all other constraint types and before the engine searches for and sets default attribute values.

Enabling Dynamic Default

To enable dynamic default, set the Dynamic Default UI property for the root product to Y during product definition.

Saved Values for Dynamic Default

Behavior of the Set Preference template depends on whether you have enabled dynamic default.

If the Dynamic Default property is not specified or is set to N, child components that are deleted are reset to the default value specified in the Set Preference template when a user works on a configuration that was saved earlier.

If Dynamic Default property is set to Y, then child components that are deleted are not reset to the default value specified in the Set Preference template when the user works on a configuration that was saved earlier. They are still deleted when the user works on the configuration again.

For example, there is a Set Preference constraint rule that states: Item A requires Item B. When Siebel Product Configurator is launched, the user selects Item A and the preference constraint triggers the selection of Item B. The user removes Item B by setting its quantity to 0 and then saves the quote. At a later time, the user works on the quote and configures the product again:

If dynamic default is off, the child component is added to the product, because this is the default in Set Preference, even though the user removed it during the earlier Siebel Product Configurator session.
If dynamic default is on, the child component is not added to the product. It is still removed, because the user removed it during the earlier Siebel Product Configurator session.

Dynamic default applies only to items that are deleted. If the user changes the quantity to a non-zero value or changes any attribute value, the change remains in the next configuration session, and it is not reset to the default value, regardless of whether dynamic default is used.

New Tables for Dynamic Default

If you are upgrading, this list of the new tables used for dynamic default can be helpful to you for data migration and troubleshooting. The following new tables were added to capture the deleted items between configuration sessions:

S_ASSET_DEL
S_ORDER_ITM_DEL
S_QUOTE_ITM_DEL

When the user confirms deleting an item from the configuration session, a new record for the deleted item is inserted in the relevant table. During reconfiguration, the configurator logic checks the tables so that deleted items are not re-included during reconfiguration.

Using the S_ASSET_DEL Table with a Set Preference Constraint

When you deploy a new version of a customizable product that contains a new Set Preference constraint, you may not want this constraint to automatically add a new component to any existing assets when you modify them.

To do this, you must insert the appropriate record into the S_ASSET_DEL table for all existing assets affected by default products.

Observe the following guidelines:

Review all existing active assets affected by default products.
Add an entry to the S_ASSET_DEL table at the parent asset level, populating the following columns:
- ASSET_ID. Parent asset (not Root) for which the child item, selected by the default product, has been explicitly removed.
- PRODUCT_ID. ID of the product that must not automatically default.
- PORT_ID. This is a reference ID. It belongs to the relationship object of the customizable product that you do not wish to be affected by an automatic default product.