System and method for rule based content filtering

The invention of the present application is named "A Method and System for Rule-Based Content Filtering" and is a benefit to NORTON et al. Of US Provisional Application Reference No. 60/986,835 filed on November 9, 2007. , Named "System and Method for Rule Based Content Filtering", Norton Benefits of US Patent Application Reference No. 12 / 266,353 filed on November 6, 2008, and "An Engine" Named "for Rule Based Content Filtering" and claimed the benefit to NORTON of US Patent Application Reference No. 12 / 266,362 filed on November 6, 2008, all applications are cited in this application. Be incorporated.

The present invention relates to multimedia messaging services, in particular methods and systems for content filtering.

Multipurpose telecommunications services allow communication devices to exchange data containers with multiple components of different types. For example, the component may include data representing a text, image, audio signal, or video signal. Sophisticated terminal devices that handle such services are evolving rapidly, resulting in multiple "generations" of differentiated terminal devices in a relatively short period of time.

With the coexistence of multiple generations of terminal devices, incompatibility problems arise. The terminal device that transmits the data container is generally indifferent to the characteristics and performance of the receiving terminal device (or the receiving terminal device in the case of multicast communication). This allows the entire data container as described in US Simultaneous Continuing Application Reference No. 12 / 238,390, filed September 25, 2008, the content of which is incorporated herein by reference. Must be provided with the ability to ensure correct detection of the contents of the data container or specific components within it, as well as notify the receiving terminal device of all changes made to the original container. It becomes.

In addition to compatibility issues, communicating multiple components, each of which selectively has its own attachment, further increases exposure to malicious insertions such as viruses. Exposing the container to intrusion requires that content filtering capabilities be provided.

Within networks that provide multipurpose services, there is a demand for providing content filtering functions in addition to content adaptation.

It is an object of the present invention to provide a content filtering function in a network that provides a multimedia service. Another purpose is to incorporate content filtering capabilities into existing content adaptation features to achieve a comprehensive, effective, and economical system.

According to one configuration of the present invention, a network interface for receiving a container from a client and moving each container from a plurality of control units that identify and parse the container to each control unit, and a first feature of the content. An array of Boolean variables, determined by each operator applicable to the second operand that specifies the operand and the target value of the first operand, and the value of each Boolean arithmetic expression in each subset of the Boolean variables. A memory device that stores an array of encoded rules that specifies each content editing operation that is activated, and a transformer that each transcoder applies at least one of the encoded rules to a subset of containers. It provides an engine for editing the contents of a container, with multiple processors hosting the coder.

The engine is connected to an operation control unit that has computer-readable instructions stored in a computer-readable storage medium for performing arithmetic, management, and maintenance functions, and inputs an array of encoded rules. A graphical user interface with computer-readable instructions stored in computer-readable storage media, and a transcoder identifier assigned to each control unit. It further includes a configuration memory device for storing.

The engine is connected to a network interface to sort containers into container types that correspond to the protocols that formed the containers, and to move specific types of containers from multiple controls to specific controls. Further includes a sorting module with computer-readable instructions stored in a computer-readable storage medium.

The engine is connected to an operation control unit, has computer-readable instructions stored on a computer-readable medium, and has a means of assigning a transcoder to a dynamic control unit according to the flow rate of a time-varying container. Further equipped with a computer module.

The engine is further provided with a transcoder load balancing module connected to each control unit for evenly allocating container edit requests among the transcoders assigned to each control unit.

The engine is a blade server that hosts each subset of controls and transcoders, with a processor with multiple cores and multiple memories, each core being exclusively assigned to the transcoder of the subset of transcoders. A blade server having a device, an input interface, and an output interface is further provided.

The engine has a transcoder service module connected to each transcoder of multiple transcoders for receiving new programs from an external source, a program storage medium for storing multiple programs accessible to each transcoder, and a program storage medium. It further includes a program registry with computer-readable instructions stored in a computer-readable storage medium that identifies the functionality of each new program and organizes the program by each functionality.

In the engine described above, when executed, the transcoder service module causes the core of the processor to receive a specific container and an edit request from a specific control unit from a plurality of control units, and a program related to the edit request. It further comprises a computer-readable instruction stored in a computer-readable storage medium that allows selection and execution, and returns the result to a particular control unit.

The program registry provides computer-readable instructions that, when executed, cause the core of the processor to organize programs with their respective functions and replace existing programs with their new programs. In the engine described above, the program storage medium includes a resident program stored in the computer-readable storage medium and an external program stored in the computer-readable storage medium and dynamically loaded.

According to one configuration of the present invention, there is a step of selecting a component, a step of determining multiple binary conditions that characterize the content of the component, and at least two operands, each selected from a Boolean operator and a set of binary conditions. A stage of forming a set of Boolean arithmetic expressions having Boolean, and a stage of executing each Boolean arithmetic expression of the set of Boolean arithmetic expressions to determine a set of content specifiers having a one-to-one correspondence with the Boolean arithmetic expression, respectively. A method of filtering a data container having multiple components is provided, which comprises performing an editing function related to the content corresponding to the directive of.

The method further comprises performing additional editing functions based on a single binary condition.

The method further comprises arranging the Boolean expressions in an order in which the directives resulting from executing the Boolean expression conditionally prevent the execution of at least one subsequent Boolean expression.

The method described above further comprises determining a Boolean expression based on the specified descriptor of the content and the preset criteria corresponding to the descriptor. In the method described above, the steps of performing the editing function include scanning the content to detect malicious insertions and removing malicious detections, and scanning the content to detect malicious insertions. It has one step of deleting the content in response to the detection of malicious insertion.

According to yet another configuration of the present invention, there is a step of forming a set of descriptors of content, a step of specifying a set of criteria corresponding to the descriptor, a step of specifying a set of operators, and Boolean variables, respectively. Applies the operators from the set of operators to the first operand, which is the descriptor selected from the set of descriptors, and the second operand, which is the criterion selected from the set of criteria. The result, the stage of defining a set of Boolean variables, and the stage of defining a set of rules for each rule to execute the Boolean arithmetic expression of a subset of Boolean variables selected from the set of Boolean variables. The result of the execution provides a way to edit the content of a data container using a computer device, including performing a selected action from a set of actions related to the content.

In the method described above, the set of descriptors comprises at least one of a content size, a content family from a predetermined set of content families, an encoding method, and a priority designation.

In the method described above, a set of operators comprises one or more of a single-term operator, a binary operator, an arithmetic operator, a comparison operator, a logical operator, a set operator, and a user-defined operator.

The method further comprises entering a set of descriptors, a set of criteria, a set of operators, and a set of Boolean expressions through a graphical user interface with computer-readable instructions stored in the memory of the computer device. ..

It is convenient for the method to further include the step of selecting the content to include part of the data container.

According to another configuration of the present invention, the definition of a network interface that receives a multimedia data container from the network, and a set of filters in which each filter specifies a content descriptor, a descriptor criterion, and an operator definition. A filter definition module with computer-readable instructions stored in a computer-readable storage medium obtained from the user, and a set of content filtering rules from the user, each rule specifying a subset of filters and a Boolean formula for filtering behavior. Get a rule-building module with computer-readable instructions stored in a computer-readable storage medium, characterize the content of each component of the multimedia data container, determine the content descriptor, apply operators, and filter each A module that defines the state of, a module that determines the binary output of each rule, and a module that executes filtering operations related to the content based on the preset value of the binary output are installed, and each server unit A system is provided for filtering the contents of a multimedia data container, which comprises a plurality of server units having a set of processors and a set of memory devices.

The system configures the server unit to accept a multimedia data container, each of which comprises a computer-readable instruction stored in a computer-readable storage medium, (1) formed by any protocol selected from a set of known protocols. Modules, (2) modules that evenly distribute multimedia data containers among equally configured server units, and (3) modules that allow users to provide Boolean arithmetic expressions with algebraic syntax. By (4) a module that allows the user to provide Boolean expressions in the form of a tree structure, and (5) by editing and selecting a tree in which each node of the tree represents an operator and a set of their respective operants. A module that allows the user to enter a Boolean formula, a module that verifies the validity of the Boolean formula, and (7) the specific filtering action performed by the rule is at least one subsequent rule. A module that arranges the rules in order to prevent the execution of, (8) a module that instructs the user to specify a continuous rule consisting of at least one rule subject to the value of the Boolean arithmetic expression, and (9). It includes at least one module that presents a set of content filtering rules in the form of a format graph and (10) a module that optimizes the Boolean formula of each rule.

The system selects a specific rule that specifies each filter subset with at most a preset number of filters, and for each particular rule, the filter portion for all values in the filter subset. A computer-readable storage medium that evaluates the Boolean formula of the set and performs a step of generating an array of 2 μbits with μ> 1 as the number of filters in the filter subset and a step of storing the bit array in the memory device. It also includes a stored module with computer-readable instructions.

According to other configurations, the present invention provides a method of filtering the contents of a data container. The method comprises a stage of specifying a set of binary conditions, a stage of specifying a set of operators, a stage of forming a leaf vector, and a stage of forming a node vector.

A set of binary conditions characterizes the content. One of the operators is specified as a null successor, while each of the other operators is specified as a successor from within the operator set. The leaf vector comprises N> 1 leaf record. Each leaf record has a set of operators and leaf operators from each subset of binary conditions. The node vector comprises N node records, each of which has a node operator field and a node state field.

The operators on each leaf are applied to the individual binary conditions and the result is placed in the node state field of the node record. The operator successors for each leaf are then placed in the node operator field of the node record.

After processing each leaf record, the node vector is processed. Node records with common operators are identified and replaced by join records. Common operators are applied to the entry in the node state field of the identified node record, and the resulting state is placed in the node state field of the join record. The successors of the common operator are placed in the node operator field of the join record.

The content index is determined as the result of applying the common operator, subject to the condition that the successor of the common operator is the null successor. Alternatively, the method may continue to record the number of node records in the node vector after combining the node records of the common operator, and the content index will be the result corresponding to the number of node records equal to 1. Determined as a state. The method further comprises performing an editing operation specified by the value of the content index.

According to other configurations, the present invention constitutes a method of filtering the contents of a data container based on predetermining a determination vector. The method involves defining a set of binary conditions, where each binary condition is a function of the selected content descriptor and the criteria for each descriptor, as well as Boolean expressions and the corresponding content filtering behavior. The stage of defining, the stage of selecting Boolean expressions of the specified μ binary conditions expressed as a string consisting of μ bits with μ> 1, and the stage of 2 of the string.^{μ μ}Evaluate the Boolean expression for each of the values and each entry is 2 in the string^{μ μ}The state of the content metric corresponding to one of the values, 2^{μ μ}It includes a step of generating a decision vector consisting of an entry.

Upon receipt of the data container, the contents of the data container determine the specified μ binary condition values. The value of the resulting string of μ bits then indicates the index of the decision vector to get the value of the Boolean expression that determines whether the content filtering behavior needs to be applied. Used to vector).

Boolean expressions may be obtained in algebraic format with Boolean operators, operands, and delimiters. Boolean expressions are evaluated by inspecting the Boolean expressions to identify a simple pattern that encloses the Boolean operator and the two operands between the two delimiters. When a simple pattern is found, the Boolean operator is applied to the two operands to determine the binary value of the pattern, and the simple pattern with two delimiters is replaced with the binary value. The process of inspecting a Boolean expression to detect a simple pattern is until the Boolean expression is reduced to a single binary value ("true" or "false") that determines whether to apply the edit behavior. It repeats.

Alternatively, the Boolean expression may be obtained in the form of a tree structure with multiple nodes. Boolean expressions are then evaluated by continuously evaluating the nodes. A tree template with multiple records is created. Each record corresponds to its own node and has four fields for the first operand, the second operand, the current operator, and the successor record. Starting from the first record and working through the last record, the operators of the current record are applied to each binary value determined from the current value of the string to generate a new binary value. If the current record is the last record, the new binary value is the value of the Boolean expression. If the current record is an intermediate record, the new binary value is placed in the operand field of the successor record.

Embodiments of the present invention will be described herein using examples with reference to the accompanying drawings.

<figref num="1">FIG. 1 illustrates a network that supports a service control and editing engine that filters and matches data containers communicated over the network, according to embodiments of the present invention.</figref><figref num="2">FIG. 2 illustrates an editing engine including a control unit and a transcoder according to an embodiment of the present invention.</figref><figref num="3">FIG. 3 illustrates an exemplary structure of a multimedia container, a container component content descriptor, and a content filter according to an embodiment of the present invention.</figref><figref num="4">FIG. 4 illustrates an algebraic form of a Boolean expression associated with a set of rules applicable to a data container, according to an embodiment of the present invention.</figref><figref num="5">FIG. 5 describes the basic components of the content filtering process according to the embodiment of the present invention.</figref><figref num="6">FIG. 6 describes the process of deriving the content descriptor of the container according to the embodiment of the present invention.</figref><figref num="7">FIG. 7 illustrates a content filtering system according to an embodiment of the present invention.</figref><figref num="8">FIG. 8 describes a system similar to the system of FIG. 7, which is applied to a container having a plurality of components according to an embodiment of the present invention.</figref><figref num="9">FIG. 9 shows the details of the content filtering process according to the embodiment of the present invention.</figref><figref num="10">FIG. 10 describes a method of evaluating a Boolean operation expression of a rule according to an embodiment of the present invention.</figref><figref num="11">FIG. 11 illustrates a first exemplary rule tree structure for encoding filtering rules according to an embodiment of the present invention.</figref><figref num="12">FIG. 12 describes a first data structure for coding the rule tree structure of FIG.</figref><figref num="13">FIG. 13 illustrates a second exemplary rule tree structure for encoding filtering rules according to an embodiment of the present invention.</figref><figref num="14">FIG. 14 illustrates a first data structure of FIG. 12 that applies to the second exemplary rule tree of FIG.</figref><figref num="15">FIG. 15 describes a process of applying the first data structure illustrated in FIGS. 12 and 14 according to an embodiment of the present invention.</figref><figref num="16">FIG. 16 illustrates a second data structure that encodes a rule tree according to an embodiment of the present invention.</figref><figref num="17">FIG. 17 describes a process of applying the second data structure illustrated in FIG. 16 according to an embodiment of the present invention.</figref><figref num="18">FIG. 18 describes a process of determining the result of a rule using a rule tree according to an embodiment of the present invention.</figref><figref num="19">FIG. 19 details the steps of forming a leaf vector associated with the process of FIG. 18 according to an embodiment of the present invention.</figref><figref num="20">FIG. 20 describes a preprocessing method of a Boolean operation formula for executing a rule at high speed according to the embodiment of the present invention.</figref><figref num="21">FIG. 21 illustrates an exemplary implementation of the method of FIG.</figref><figref num="22">FIG. 22 illustrates the processing of data entries relating to filter definitions and rule definitions according to embodiments of the present invention.</figref><figref num="23">FIG. 23 describes the continuous filtering process of the components of the multimedia container.</figref><figref num="24">FIG. 24 describes a process of applying a plurality of content filtering rules according to an embodiment of the present invention.</figref><figref num="25">FIG. 25 illustrates a graph illustrating the dependencies between rules that determine content filtering behavior according to an embodiment of the present invention.</figref><figref num="26">FIG. 26 describes a module of the operation management unit of the engine of FIG. 2 according to the embodiment of the present invention.</figref><figref num="27">FIG. 27 illustrates the engine transcoder module of FIG. 2 according to an embodiment of the present invention.</figref><figref num="28">FIG. 28 illustrates the engine transcoder module of FIG. 2 according to an embodiment of the present invention.</figref>

the term Multimedia Services (MMS): The term is verbally multi-terminal, where different forms of information content such as text, audio signals, video signals, images, presentations, etc. are exchanged between terminals over a network. A media content communication service. The encoded information transmitted from one terminal to the other is usually arranged in a single data stream with time-interleaved segments corresponding to different information contents.

Container: A container is a computer file that is stored on a computer-readable medium and transmitted over a computer network. Containers are configured to contain various types of data. The container may support video streams with synchronization information that allows coordinated playback of multiple text, audio, and various streams.

Container component: A container has sections, each with data encoded in a particular format, such as text, audio data, image data, or video data. The term container component refers to the data in one section. Container components may be referred to as "components" for the sake of brevity. In multimedia messaging systems, components are also known as "media."

Container Screening: "Container screening" refers to the process of inspecting container content, including all components, to ensure that there are no unwanted insertions, especially harmful insertions.

Container Fit: "Container Fit" refers to the process of modifying the format of a container component that has been found to be incompatible with the decryption capabilities of individual receivers. If the container component cannot be presented to fit the receiver, the container component may be removed. The container adaptation process is receiver-specific , but the container screening process is independent of the intended receiver type.

Container Editing: The term "container editing" refers to the combined processing of container screening and container conformance.

Container conditioning: This term can be used synonymously with "container editing". However, container conditioning adds appropriate notifications to the container, even if the container has not been modified.

Transcoder: A transcoder is a device that performs a direct digital-to-digital conversion of encoded information, allowing information records in one format to be played back in different formats suitable for a particular receiver.

FIG. 1 describes a network 140 that provides a route from a transmitting device 120 to a receiving device 160, which will be referred to below as the transmitting unit 120 and the receiving unit 160. The network 140 supports a service control unit 103 and an editing engine 106, in addition to a number of other hardware terminal devices of different types. The transmitting unit 120 transmits to the receiving unit 160 a container that may contain data of different content types such as encoded text, audio signals, still images, animated images (fast display of images), and video signals. Next, the container may inspect the container and, if necessary, move it to the service control unit 103 that moves the container to the editing engine 106 that edits the contents of the container. The editing process includes data screening to ensure that there are no unwanted insertions, especially harmful insertions, content modification to meet specific requirements, and content adaptation that matches the decoding capabilities of individual receivers. including.

FIG. 2 illustrates the editing engine 106. The network interface 210 receives the container from the client via link 204. The container is moved to one of m&gt; 1 control units 240, individually identified as 240 (1), 240 (2), ..., 240 (m). The control unit 240 may be implemented as a separate hardware entity, or may share a computer device hosting a plurality of transcoders 280 as described below. The control unit 240 is protocol-specific and is programmed to handle containers, each of which is formed by an individual protocol. Control units that handle a particular protocol are said to be of the same control unit type. The control units are grouped into control unit groups, and each control unit group handles a container formed by the same protocol. The editing engine 106 may have different types of controls. However, the entire editing engine 106 may be configured to have the same type of controls. The editing engine 106 may also have a load balancing module 290.

The editing engine 106 has a plurality of transcoders 280 individually identified as 280 (1), 280 (2), ... 280 (n). The main function of Transcoder 280 is to perform a direct digital-to-digital conversion of encoded information in order to make information records in one format playable in different formats suitable for a particular receiver. is there. However, the transcoder may perform the content filtering process along with the content adaptation. A plurality of selected transcoders 280 are assigned to each control unit 240 forming a control assembly together. For example, in FIG. 2, control units 240 (1) and transcoders 280 (1) to 280 (5) form one control assembly installed on each computer device. The control unit 240 (m) and the transcoders 280 (n-2) to 280 (n) form other control assemblies installed on other computer devices. The control assembly is a single circuit board that supports processors and memory devices and is preferably installed on a server unit, also known as a "blade server".

The processor 220 hosts a network interface 210 and an operation management unit 230, which is also called an operation control unit. The network interface 210 receives the container from a client communicatively connected to the network 140 (FIG. 1). The operation management unit 230 includes computer-readable instructions stored in a computer-readable storage medium for executing operation, management, and maintenance functions.

The service control unit 103 may receive the container and send a container edit request to one of the edit engines 106.

The processor 220 is also connected to the operation control unit 230 and stored on a computer-readable medium for inputting an array of encoded rules and for assigning each control unit 240 a partial set of transcoders. Host a graphical user interface (not shown) with computer-readable instructions. The configuration memory device 260 stores the identifier of the transcoder assigned to each control unit.

The rules governing the content filtering process may be stored as a common rule file stored in the rule memory 225 accessed by each transcoder 280. Alternatively, each computer device (server unit) hosting the control unit and associated transcoder may store the relevant partial set of rule files.

FIG. 3 describes a container having a plurality of components 320 identified as 320 (1), 320 (2), etc., respectively. Component 320 may be text, audio recording, encoded image, video recording, and any other content type. The component content uses a set 330 of descriptors 332 identified as 332 (1), 332 (2), ..., 332 (j), and 332 (D), respectively, with D as the total number of descriptors. Characterized by. Content descriptors are defined by multiple attributes such as content type, identifier (first name), extension, digital signature, cryptographic capabilities, priority, and file size. Descriptors may be added or removed as content filtering requirements change as multimedia telecommunications evolves.

According to embodiments of the present invention, the characteristics of the content of a container component are represented as a set of binary variables, each of which determines whether the content meets a particular criterion. The value of the received container's content descriptor is determined by inspecting the container's content. Therefore, the transcoder performing this function is aware of the format of the received container and the meaning of the protocol in which the container was formed. The value of the characterizing binary variable is determined by applying operator 344 to the value of the content descriptor (342) entered by the installer (user) of the content filtering system and the two operands of the corresponding criterion 346. The operator 344 and the two operands 342 and 346 are said to form a filter 340 (also called a content condition or simply a condition). Thus, the contents of a container component are characterized by a set of filters, each with a "true" or "false" value.

Editing the container before conforming to fit the receiver is based on a set of rules, where each rule removes the entire content, removes malicious inserts found in the content, or Determine editing behavior that removes content attachments. Rules are functions of each subset of filters. When the filter is chosen to be a binary variable, the function that defines the rule is preferably formalized as a Boolean expression for a subset of the filter. In this way, the installer (user) of the content filtering system (discussed in more detail with respect to FIGS. 7 and 8) is an operation performed by the subset of the filter, the Boolean expression, and the result of executing the Boolean expression. Define the rule by.

FIG. 4 illustrates an algebraic form of a Boolean expression that is applicable to the components of a data container and is associated with a set of four rules stored in rule array 420. The same set of rules may also be applied to at least one component of the rule filter.

The first rule, rule 1, is defined by a single filter (size&gt; 30000), the content descriptor is the size of the component, the operator is "GREATER THAN", and the criterion is 30,000 (reference code). 440). If the result of the rule is Boolean "true", each action drops the component and stops processing the remaining rules for the component under consideration.

The second rule, rule 2, is defined by the Boolean expression 450 of two filters (size&gt; 5000) and (family message). The descriptor of the first filter is "size", the criterion is "5000", and the operator is "GREATER THAN". The descriptor of the second filter is "family", the criterion is "message", and the operator is "NOT EQUAL". Boolean expressions contain a single operator "OR". The behavior associated with rule 2 is the same as the behavior of rule 1.

The third rule, rule 3, is defined by a Boolean expression 460 consisting of three filters (size&gt; 25000), (content-type = image / wbmp), and (content-type = image / png). The descriptor of the first filter is "size", the criterion is "25000", and the operator is "GREATER THAN". The descriptor of the second filter is "content-type", the criterion is "image / wbmp", and the operator is "EQUAL". The descriptor of the third filter is "content-type", the standard is "image / png", and the operator is "EQUAL". Boolean expressions contain two operators "AND" and "OR". The operation of rule 3 is the same as the operation of rule 1. Note that "wbmp" refers to wireless bitmaps (wireless application protocols, WAP, graphics formats), and "png" refers to "Portable Network Graphics".

The fourth rule, rule 4, is defined by a single filter (family = message), the content of the descriptor is "family", the standard is "message", and the operator is "EQUAL" (reference code 470). ).

FIG. 5 is incorporated in the operation management unit 230 of FIG. 2, and has a user interface 520, a filter creation module 530 that acquires a filter definition, a rule construction module 540 that acquires a rule definition, a memory partition 550 that stores a filter definition, and FIG. The basic component of the data acquisition subsystem including the memory partition 560 for storing the rule definition (rule structure) will be described. The user interface 520 allows the installer (user) to provide input data 512 to define a set of filters and a set of rules. The filter creation module 530, when executed, causes a computer-readable instruction stored in a computer-readable storage medium to prompt the processor to enter the definition of the content descriptor, the criteria for each definition, and the operator. To be equipped. The value of the descriptor is determined by the contents of the received container.

The rule construction module 540 includes computer-readable instructions stored in a computer-readable storage medium, and when executed, inputs a Boolean operation expression for each rule and selects an operation from a predetermined set of operations. The processor prompts the installer to do so. Computer-readable instructions also cause the processor to parse Boolean expressions and determine the order of the terms of the representation to execute.

The filter definition is stored in the memory partition 550 of the memory device, and the rule definition is stored in the memory partition 560 of the same memory device or any other memory device.

FIG. 6 describes a process of determining the value of the content descriptor of the received container 612 by using the definition of the content descriptor stored in the memory partition 550. The received container 612 is parsed in step 620 to identify the components of the container. Each component is analyzed in step 640, and in step 650 the result is paired with the definition of the content descriptor read from memory partition 550.

FIG. 7 describes the overall configuration of the content filtering system according to the embodiment of the present invention. Memory 710 stores data for all relevant filters. Each filter has operators from set 740 of operators determined by module 530 of FIG. 5, content descriptors from set 720 of content descriptors determined in step 650 of FIG. 6, and module 530 of FIG. Defined by the descriptor criteria from the set of descriptor criteria determined in 730. The binary values ("true" and "false") of each filter are stored in memory device 750 for use in executing the set of rules defined in module 540 of FIG.

Each rule is defined by a subset of filters, Boolean expressions, and behavior. The memory 770 stores the encoded Boolean operation expression determined by the module 540 of FIG. 5 at the input of the system installer (user). The memory 760 stores the identifier of the filter used in each rule and each Boolean operation expression. The memory 780 stores an instruction of an editing operation executed according to the result of evaluation of each Boolean operation expression. Execution of each Boolean expression produces a binary result and each editing action. Upon completion of the editing operation, the edited content is arranged in the memory 790.

FIG. 7 describes a content filtering system according to an embodiment of the present invention, which is applied to a single component, while FIG. 8 shows that k&gt; is applied to one container component. The content filtering system will be described. The memory device 810 stores the data of all the related filters of each of the k container components. The data associated with each filter is specified as 812 (1) to 812 (k), respectively. Container components are processed continuously. The result of applying the operator of each filter to the component under consideration is stored in the memory 850. N&gt; One set of coded Boolean expressions is stored in memory 864. Boolean expressions are individually identified as 870 (1) to 870 (N), each associated with each editing action from N editing actions identified as 880 (1) to 880 (N), respectively. Be done.

FIG. 9 illustrates an exemplary process of content filtering. The system installers (users) for content filtering in FIGS. 7 and 8 initially have five content descriptors identified as 920 (1) to 920 (5), respectively, 922 (1) to 922, respectively. We have defined the criteria for the eight descriptors identified as (8) and the four operators identified as 924 (1) to 924 (4), respectively. The installers are identified as 930 (1) to 930 (12), respectively, and each filter has 12 filters that specify one of the content descriptors 920, one of the criteria 922, and one of the operators 924. Defined. In response to the determination of the values of the five content descriptors 920 (1) to 920 (5), the binary values of the twelve filters are determined, as described in step 650 of FIG.

The installer defined six Boolean expressions, each specified as 950 (1) to 950 (6), with each Boolean expression associated with a subset of 12 filters. For example, Boolean 950 (2) is associated with two filters 930 (1) and 930 (6), and Boolean 950 (5) is filters 930 (2), 930 (8), and 930 (11). ). The installer defined four behaviors, each identified as 960 (1) to 960 (4). The installer then used the rule building module 540 of FIG. 5 to define nine rules, each identified as 940 (1) to 940 (9). Each rule is associated with a single Boolean expression 950 and a single action 960. For example, rule 940 (1) specifies Boolean expressions 950 (2) and action 960 (2), while rule 940 (9) specifies Boolean expressions 950 (5) and action 960 (4). ..

The rule may be based on a single filter and the result of the rule is the binary value of the filter. For example, rule 940 (7) depends only on filter 930 (11).

Representation of Boolean expressions The installer of the content filtering system of FIGS. 7 and 8 may provide the Boolean expression 950 by the usual algebraic grammar or by the tree structure. The user interface 520 of FIG. 5 has a first module (not shown) that encodes a Boolean operation expression expressed in algebraic format and a second module (not shown) that encodes a Boolean operation expression expressed as a tree structure. ) Is provided. Each of the two modules provides its own template to allow the installer to specify Boolean expressions correctly.

Boolean expressions include simple operations, join operations, and compound operations. Simple operations are shown as operators and operands whose operators and operands are separated by two delimiters (such as two parentheses). The operators and operands may be listed in any order, and the two delimiters need not be distinguished from each other. The two operators are Boolean variables that represent two filters. The join operation comprises an operator and two simple operations in which the operator and two simple operations are separated by two delimiters. The compound operation includes an operator and two operations, all separated by two delimiters, in which any of the two operations may be a simple operation or a combined operation. The two operations that make up a compound operation may also be a compound operation. The delimiters for simple operations, combined operations, or compound operations may be the same.

FIG. 10 describes an evaluation method of a Boolean operation expression according to an embodiment of the present invention, which requires only recognition and execution of a simple operation. According to the method, a coded Boolean expression is parsed to identify a simple operation. The specified simple representation operators are applied to each operand (filter) to generate "true" or "false" binary values (eg, represented as "1" and "0"). .. The two delimiters of the operator, the operand, and the specified simple operation processed in this way are deleted and replaced with the result of the operation. This process recursively continues until the encoded Boolean expression is reduced to a single simple operation, which results in the Boolean expression.

In step 1012 of FIG. 10, a Boolean expression is checked to identify a simple operation. If a simple operation is found (step 1014), step 1016 executes the simple operation and generates a binary value. Step 1018 replaces simple operation operators, operands, and delimiters with binary values. Step 1012 is then revisited to look for other simple operations in the reduced Boolean structure. If step 1014 determines that no further simple operations are found in the current form of the Boolean expression, step 1020 checks the current form and a single binary value ("true", "false", or Determine if the current format is actually reduced to "1", "0"). If so, step 1022 reports a single binary value as the result of executing the Boolean expression. If step 1020 determines that the processed Boolean expression contains two or more binary values, step 1024 reports a notification that the Boolean expression is not formed correctly.

The process of FIG. 10 is preferably performed during data entry so that the user (installer) can correct the Boolean formula. The user interface 520 or some other component of the editing engine may include computer instructions that analyze misformed Boolean expressions and locate errors.

An alternative method of encoding and evaluating a Boolean expression according to an embodiment of the present invention relies on a graphical tree representation of the Boolean expression. An exemplary rule tree 1100 illustrating Boolean expressions for six operands (six filters), each identified as a filter 6 from a filter 1 which is a leaf of the tree, is illustrated in FIG. Θ_１, Θ_２, And Θ_３The three operators marked as are three operations {filter 1, Θ_１, Filter 2}, {Filter 3, Θ_２, Filter 4}, and {Filter 4, Θ_３, Filter 6} is defined. The successor immediately following each operator is defined. For example, Θ_１, Θ_２, And Θ_３Each successor of is the operator Θ_５, Θ_４, And Θ_４And the operator Θ_４And Θ_５The successes of each are Θ_５And "NULL". Operators with "NULL" successors produce the result of Boolean expressions.

Operator Θ_１Is the operator Θ_５Generates the binary output B1, which is the operand of. Operator Θ_２Is the operator Θ_４Generates the binary output B2, which is the operand of. Operator Θ_３Is the operator Θ_４Generates the binary output B3, which is the other operand of. Operator Θ_４Is the operator Θ_５Generates the binary output B4, which is the other operand of. Operator Θ_５Is the result of the Boolean expression represented by the tree Binary output B^＊To generate.

FIG. 12 describes a template array 1230 that represents the rule tree 1100 of FIG. The index 1220 of the template array 1230 varies from 0 to 19 as indicated in FIG. The template array 1230 is divided into a number of records equal to the total number of operators (5 in the exemplary tree of FIG. 11), where each record corresponds to an operator and performs a simple operation with two operands. Represent. The binary value of the filter is known after the container under consideration has been processed. In this way, a record has an index for each filter, an operator definition, and a pointer to another record that corresponds to the immediately following operator. A "null" pointer indicates that the current record is the last record to process. The user may enter the records in any order, and the module with the user interface 520 of FIG. 5 (not shown) may process the records continuously and any record may be processed. At that time, the record is reorganized so that the value of each operand has already been determined.

As described in FIG. 12, the first three records are applicable to the six filters that form the leaf of the tree, the operator Θ._１, Θ_２, And Θ_３Corresponds to. The pointer π (1) of the first record is the operator Θ._１Indicates the index 16 of the array that holds the binary result B (1) of. The pointer π (2) of the second record is the operator Θ._２Indicates the index 12 of the array that holds the binary result B (2) of. The pointer π (3) of the third record is the operator Θ._３Indicates the index 13 of the array that holds the binary result B (3) of. In this way, the two operands B (2) and B (3) have already been calculated when the fourth record is reached. Operator Θ_４The binary result of B (4) is written at position π (4) = 17. In this way, when the fifth record is reached, the two operands B (1) and B (4), respectively, are already known. Operator Θ_４Has no successor (ie has a null successor), so the operator Θ_４The binary output of is the result of a Boolean expression.

An exemplary activation of template sequence 1230 is also illustrated in FIG. The values of the filters 1 to 6 determined by the process of FIG. 6 are "true", "false", "true", "false", "true", and "true", respectively. Boolean operator Θ_１From Θ_５Is specified by the user as "AND", "OR", "AND", "AND", and "XOR", respectively. Operator Θ_４Since ("XOR") has an Null successor, the operator "XOR" produces the binary output "true" which is the result of the Boolean expression.

FIG. 13 illustrates a second exemplary rule tree 1300 corresponding to the Boolean formulas of the 11 leaves (filters) labeled L1 through L11, and FIG. 14 shows the template array 1230 of FIG. Similarly, a template array 1430 is described which is applied to the rule tree of FIG. 13 while changing the index 1420 from 0 to 43. Rule tree 1300 is Θ_２From Θ_１１It has 10 operators marked as. The first leaf L1 is the operator Θ, which has no successor._１１It is an operand of. For consistency, the first record (denoted as record 1 in FIG. 14) of the template array 1430 of FIG. 14 representing the rule tree 1300 conceptually has the values of the "don't care" operands φ and L1. Successor operator Θ_１１Allowable non-existent operator Θ carried as an operand of_１It is conceptually understood to include. As is known to those skilled in the art, the "don't care" value assigned to the operand φ may be in either the "true" state or the "false" state for convenience. The remaining 10 records, records 2 to 11 of the template array 1430, are the operators Θ._２From Θ_１１Corresponds to. Each entry L1, L2, to L11 in the template array 1430 of FIG. 14 is an index (pointer) to the filter. As described above with reference to FIG. 12, the organizing module 522 associated with the user interface 520 of FIG. 5 has an operand in which each record has already been determined so that the records can be processed continuously. Place the record.

FIG. 15 outlines a tree coding method using the template array 1230 (FIG. 12) or 1430 (FIG. 14). At step 1520, a template is generated, each with a plurality of records corresponding to the nodes in the tree. Each record has four fields, including the indexes of the two filters, the current operator, and a pointer to the successor record that corresponds to the successor of the current operator. In step 1530, the list of filters determined by the process of FIG. 6 is prepared for the container under consideration. At step 1540, the records in the tree template are processed continuously. The operand of each record is obtained by indexing the list of filters. Each operator is applied to the operand and the binary result is placed in the operand field of the successor record. At step 1550, the result of the operator in the last record is presented as the result of a Boolean expression represented by a tree.

FIG. 16 illustrates an alternative method of expressing a rule tree structure according to an embodiment of the present invention. The set of filters (conditions) associated with a rule is defined based on the content descriptor, descriptor criteria, and filter operators, as described above. The definition of a set of filters is stored in the filter definition array. A set of Boolean operators is defined by one operator with null successors and each other operator with successors from the set of operators. The filter forms a leaf of the tree and is divided into subsets of the filter, and the filters in the subset form the operands of the Boolean operator from within the set of Boolean operators. In particular, if the filter subset contains two filters, the total number of Boolean operators is equal to the total number of filters minus one.

Considering a set of M (M&gt; 1) filters, a leaf vector template with N leaf records and 1 &lt;N &lt;M is formed. Each leaf record has a leaf operator from within a set of operators and a subset of each filter. During installation, each leaf record contains an index of the operand (filter) in the operator and filter definition array. For each container component, the filter value for each leaf record is determined.

A node vector with a number of node records equal to the number N of leaf records is formed. Each node record has a node operator field and a node state field. At the installation stage, the node record is empty and contains no data. The state of the Boolean operator and the node in the node record is first determined during the processing of the leaf record. The N node records may be arranged in any order. However, it is convenient to first have a one-to-one correspondence between node records and leaf records. In this way, the Boolean operator of the node record j, 1 j N becomes the successor of the Boolean operator of the leaf vector j.

Depending on the determination of the filter value, the operator of each leaf is applied to each filter (each binary condition) and the result is placed in the node state field of the node record. The operator successor for each leaf is placed in the node operator field of the node record.

After processing all leaf records, node records are processed. Node records with common operators, called connection node records, are then identified herein. To generate a new state, the common operator is then applied to the node state of all connected node records. The operator field of the node record selected from the connected node record is replaced by the successor of the common operator, and the node state field of the selected node record is replaced by the new state just determined. The remaining join node records are removed from the node vector. Thus, with the replacement of each set of connected node records with joined node records, the number of node records in the node vector is reduced. The process of identifying the connection node record continues recursively until the node vector contains only one node record. The application result of the Boolean operator in the operator field of the remaining one node record is the evaluation result of the Boolean operation expression. The Boolean operator on the last node record has a null successor.

FIG. 16 illustrates a recursive rule construction 1600 that encodes a rule tree for an exemplary tree of FIG. 13 representing a Boolean expression consisting of 11 filters forming a leaf of the tree. The leaves (filters) are marked L1 to L11. In the tree of FIG. 13, leaf L1 is not associated with any other leaf. For unity, leaf L1 is artificially associated with leaf φ that shares the passive operator Θ1. The inserted leaf φ is assigned a "don't care" value. As is known to those skilled in the art, the "don't care" value can be conveniently assigned to either the "true" or "false" state.

Set of Boolean operators Θ_２From Θ_１１Is user-defined. Operator Θ_２From Θ_６Is associated with the leaf record, while the operator Θ_７From Θ_１１Is associated with the node record. Operator Θ_１１Has a null successor and each of the other operators Θ_２From Θ_１０Is the operator Θ, as illustrated in Listing 1610 of FIG._７From Θ_１１Has a successor from the set of.

The leaf vector 1620 comprises six records 1622, each identified as 1622 (1) to 1622 (6), and the assigned operator Θ._１From Θ_６Is placed in operator fields 1624 (1) to 1624 (6) with the index of the corresponding operand placed in operand fields 1626 (1) to 1626 (12). The operands of the operand fields of the six leaf records are {Φ, L1}, {L2, L3}, {L4, L5}, {L6, L7}, {L8, L9}, and {L10, L11}. ..

When the binary value of the filter is determined (FIGS. 5 and 6), leaf record 1622 is processed. Starting with leaf record 1622 (1), the artificial passive operator Θ_１Simply passes the value of L1 to the node state field 1642 (1) of the node record. Θ_１Operator Θ that is a successor of_１１Is placed in the operator field 1642 (1) of the node record. The second leaf record 1622 (2) is then processed and the operator Θ is used to generate the binary value B2 that is placed in the node state field 1642 (2) of the node record._２Applies to leaves L2 and L3 (filters L2 and L3). Operator Θ_９The operator Θ that is_２The successor of is placed in the operator field of node record 1622 (2). Processing continues until all node records 1642 (1) to 1642 (6) are determined.

Processing continues recursively using only the node vector 1640, and the leaf vector 1620 is no longer needed. Operator Θ in node record 1642 (1)_１１Are not paired in the node vector 1640 (1). Therefore, node record 1642 (1) remains unchanged. Any of the node records 1642 operator Θ_９Similarly, node record 1642 (2) remains unchanged because it does not contain. Node records 1642 (3) and 1642 (4) are applied to operands B3 and B4 to generate the binary result B7 placed in the node state field of node record 1642 (3) and replace B3. Common operator Θ_７Have. Θ_９The operator Θ that is_７The successor operator of is placed in the operator field of record 1642 (3), Θ_７To replace. Within the new join record 1642 (3), the now consumed node record 1642 (4) is deleted. Similarly, node records 1642 (5) and 1642 (6) are the operators Θ._８Successor operator Θ_１０Combined within a new node record with, and the common operator Θ_８Is applied to operands B5 and B6 to determine node state B8. The node vector 1640 has now been reduced to four node records identified by reference numeral 1640 (2). Node record 1640 (2) simply overwrites node record 1640 (1).

Processing continues recursively with node records 1642 (2) and 1642 (3) that are joined to generate a new join node record 1642 (2), while node records 1642 (1) and 1642 (4) are modified. Stay without. The two immutable node records are now records 1642 (1) and 1642 (3) in the reduced node vector 1640 (3).

Node records 1642 (2) and 1642 (3) are the common operators Θ._１０Have. The operator Θ to generate a new state B10 placed in the node state field of node record 1642 (2)._１０Applies to operands B9 and B8. Operator Θ_１０Successor operator Θ_１１Is placed in the node status field of node record 1642 (2). Output of Boolean expression B^＊Common operator Θ of node records 1642 (1) and 1642 (2) to generate_１１Applies to operands B1 and B10.

FIG. 17 describes a process of determining the output of the rule tree using the leaf vector template 1620 and the node vector template 1640 of FIG. In step 1720, a set of Boolean conditions (Boolean filters L2 to L11) that characterize the data content under consideration is determined. In step 1722, a leaf vector 1620 with N&gt; 1 leaf record 1622 is formed. Each leaf record 1622 has a Boolean operator field 1624 and a field for a subset of Boolean conditions (subsets of filters L2 to L11). In step 1724, a node vector 1640 of N node records 1642 is formed. Each node record 1642 includes a Boolean operator field 1644 and a node state field 1648. In step 1726, the operator of each leaf is applied with a subset of the respective Boolean conditions (Boolean filters) determined from the characteristics of the content data as described above with reference to FIGS. 5 and 6. The binary result is placed in the node status field of the selected node record 1642. In step 1728, the operator successor for each leaf is placed in the operator field of the selected node record. In step 1730, node records with common operators are replaced with join records, thus reducing the number of node records 1642 in node vector 1640. In step 1732, a common operator is applied to the node state of the replaced node record, and the binary result is placed in the operator field of the join record. In step 1734, the successors of the common operators determined from Listing 1610 in FIG. 16 are placed in the operator fields of the join node record. In step 1736, if the number of remaining node records is greater than 1, step 1730 is revisited to continue the process of joining the node records of the common operator. The rest

FIG. 18 is a flowchart showing details of the process of FIG. In step 1820, the leaf vector 1620 is formed, as detailed in FIG. Leaf records 1622 (1) to 1622 (N) are considered continuously. In step 1824, the index j is set equal to 0. If step 1826 determines that more leaf records should be processed, step 1828 increases the index j by 1 and the leaf set (set of filters) corresponding to the leaf index of the current leaf record. In step 1830, the operator θ of the current leaf record (operator Θ) is obtained._１From Θ_６To get one). Step 1832 applies the operator to the acquired set of leaves to produce binary output B. In step 1834, the successor S (θ) is determined from Listing 1610 in FIG.

The node state fields and operator fields of the node vector 1640 are described herein as U (j), V (j), 1 j N, i.e. U (j) and V (j). Node record 1642 (j) defines 1 j N. In step 1836, the value of B is placed in the node state field U (j) of the node vector 1640, and the value of S (θ) is placed in the operator field V (j) of the node vector 1640. If all leaf records 1622 (1) to 1622 (N) are processed, the index j is equal to the number N of leaf records, and each node record 1642 in node vector 1640 has its own node operator and node state. Have. In step 1840, the current value ν of the node record 1642 of the node vector 1640 is set equal to j (equal to N). In step 1842, if the current number of node records ν is greater than 1, the node vector is scanned to collect all node records 1642 with the same operator and combine such records. Current number of node records ν to be able to detect changes in the number of node records prior to scanning^＊= Ν is recorded (step 1843). In step 1844, the index k is set equal to zero, and step 1846 records the operator θ = V (k) in node record 1642 (k). Step 1848 examines the successor node records of the node vector 1640 to identify the number μ of successor node records with the same operator θ. If the number μ of the identified successor node records is zero (step 1850), the index k is incremented by 1 in step 1852, and if the index k is less than the current number of node records ν, step 1846 is revisited. Ru. If not, step 1856 collects (μ + 1) operands of the node record of the same operator θ and applies operator θ to the (μ + 1) operands to create a new state B of the join node record. To determine. In step 1860, the subsequent μ identified node records are deleted, and step 1862 puts a new state B in the node state field U (k) of node record 1642 (k) and node record 1642 (k). Insert the successor operator S (θ) into the operator field V (k) of. The number of remaining node records is determined as (ν-μ) in step 1864. Steps 1852 and 1854 are applied after step 1864 to determine if the node vector 1640 contains additional node records for the common operator. If step 1854 determines that k is less than ν, scanning the node vector continues from step 1846. Otherwise, if step 1854 determines that k = ν (k cannot exceed ν), then step 1855 is the current value of ν (last updated in step 1864) before. Value ν^＊Make sure it is smaller than. If not layered, an error is reported in step 1880. In particular, if the user-provided representation of the Boolean expression is incorrect, the request ν &lt;ν in step 1855.^＊Is not satisfied. ν &lt;ν^＊In the case of, step 1855 is followed by step 1842. When step 1842 determines that the number of remaining node records is 1, the state B that determines each editing operation.^＊The operators of the remaining node records are applied to their respective operands to determine (step 1890).

FIG. 19 is a detail of step 1820 of FIG. 18 forming the leaf vector 1620 of FIG. In step 1920, a set of filters (conditions) is formed, and in step 1922, leaf operators are determined based on user input as described with reference to FIGS. 5 and 6. Leaf operators are applied sequentially to generate the corresponding leaf record 1622. If step 1924 determines that at least one operator has not yet been applied, step 1926 adds a new leaf record 1622 to the leaf vector. Step 1928 selects one of the remaining operators, and step 1930 adds a filter associated with operator field 1624 in the leaf record. Step 1930 is repeated until step 1932 determines that all filters belonging to the selected operator are included in the current leaf record 1622. When the current leaf record 1622 is completed, step 1924 will be revisited, as determined in step 1932. If step 1924 determines that all leaf operators have been considered, the completed leaf vector 1620 is presented in step 1824 of FIG.

FIG. 20 describes a method of pre-calculating the binary value of the Boolean expression of the rule for each value of the set of filters. A set of filters is represented by a bit string having multiple bits with a one-to-one correspondence to the filter, such that each bit in the string corresponds to one filter. If μ&gt; 1 filter, the string is μ bits and 0 to 2^{μ μ}Includes hypothetical values that vary up to -1. In step 2012, a starting string value of 0 (with all μ bits set to zero) is set and 2^{μ μ}Each entry in the rule vector with entries is initialized to "0". In step 2014, the Boolean formula is evaluated using one of the methods described with reference to FIGS. 10, 15, or 17. In step 2016, the binary result ("true", "false") is the current value of the string (0 to 2).^{μ μ}-It is stored in the rule vector at the position corresponding to 1). In step 2018, the string value is increased by adding one. If step 2030 determines that each of the μ bits of the string has a value of 0, then the generation of the rule vector is complete (step 2040). In particular, the string in which each of the μ bits has a value of "1" is the rule vector (2).^{μ μ}-1) The string is reset to μ zeros by adding 1 in step 2018 as well as corresponding to the th entry. Alternatively, the string may have (μ + 1) bits with the most important bits used to indicate the completion of generation of the rule vector. The rule vector may then be used to directly determine the binary value of the Boolean expression at run time, thereby increasing the throughput of the content filtering system.

Overall, the method of filtering the contents of a data container thus comprises the following steps: (1) For each filter, a set of filters (binary condition), which is a function of the reference of the selected descriptor of the content and the individual descriptor, is defined. (2) Each rule defines a set of rules that specifies Boolean expressions and the corresponding content filtering behavior. (3) One Boolean expression is considered at a time. (4) Consider μ Boolean expressions of the filter (binary condition). The filter is represented as a string of μ bits, μ&gt; 1. (5) String 2^{μ μ}Evaluate the Boolean expression for each of the values, and each entry is 2 in the string^{μ μ}The state of the content metric corresponding to one of the values, 2^{μ μ}Generate a rule vector consisting of entries. (6) Repeat step (5) for all Boolean expressions. (7) Receive and parse the data container. (8) Depending on the contents of the data container, a rule is selected and the values of the specified μ filters of the selected rule are determined. (9) The rule vector corresponding to the selected rule is indexed, and the value of the entry in the rule vector corresponding to the index determined by the string consisting of μ bits is determined. (10) The content filtering operation is executed according to the value of the entry. (11) If the new rule needs to be applied to the received container, steps (8) to (10) are repeated.

FIG. 21 describes a rule vector for a rule that specifies a Boolean expression for a set of four filters (μ = 4) labeled L1, L2, L3, and L4. A set of filters is represented by a 4-bit string. The Boolean expression is evaluated for each of the 16 values 2112 of the string, varying from '0000' to '1111', and is "true" corresponding to the string value j, 0 j &lt;μ of the string. Alternatively, it produces a binary output 2114 (j) designated as "false".

Upon receipt of the container, the contents of the container component are inspected to determine the set of four filters for the rules discussed in FIG. For example, if four filters have the values "1", "0", "0", and "1", generate string 2140 of "1001" and the value of the Boolean expression is in the binary rule vector 2114. Read directly from position 9 (binary 1001).

The method of FIG. 20 with the exemplary description of FIG. 21 is suitable for rules that employ Boolean expressions of medium numbers of operators (filters). For example, with 8 filters, the binary rule vector 2114 is relatively short and has only 256 bits. For example, when a Boolean expression has 16 or more operands, it is preferable to evaluate the Boolean expression each time it needs to be evaluated, rather than storing a large binary rule vector. The number of operands per Boolean expression greater than 16 may not be possible.

FIG. 22 illustrates the processing of data entries related to filter and rule definitions. The process begins with determining if the rule file has already been generated (step 2220). If the rule file has not yet been generated, step 2222 will generate the file using conventional methods known to those of skill in the art. The next step is to add the rule to the rules file. Input and update of the rule file is started in step 2224. Step 2224 opens the rule file and moves the process to step 2226 prompting the user to indicate whether the new rule should be encoded and added to the rule file. The submission and update of the rule file is stopped by the user (step 2280). If more rules are added, the data acquisition module (not shown) located in the user interface 520 (FIG. 5, or operation, management, and maintenance module 230 (FIG. 2)) will generate a rule template. (Step 2230). The rule template may selectively take one of many forms and may be determined by the user. The format of the rule template is (1) whether the rules specified by the user should be applied continuously or in a hierarchical order, and (2) the Boolean expressions of the rules are in algebraic format. It depends on whether it should be entered or whether the nodes of the tree should be entered in a tree-structured format that represents operators and individual operands. In either case, the data acquisition module may provide each template with instructions that facilitate data entry. For example, a data acquisition module prompts the user to enter a simple operation, each with a set of operators and operands, and then guides the user to construct an algebraic form of Boolean expressions by proceeding to the preferred representation. You may. The validity of the constructed representation may be verified with each addition of new operators. .. When the Boolean expression is presented as a tree structure, the data acquisition module may display a general tree structure that can be pruned and validated when the user enters data about the selected nodes in the tree.

At step 2232, a rule identifier encoded in any suitable format is provided. In step 2234, a rule operation is specified, and step 2240 defines a Boolean expression associated with the rule. The rule behavior of a particular rule is applied by the value of the associated Boolean expression. Step 2240 comprises steps 2242, 2244, 2246, 2248, 2250, 2252, and 2260. Step 2242 generates the filter template described by reference numeral 340 in FIG. Step 2244 sets the type of filter that may be one of many descriptors for the contents of the container under consideration. Step 2246 sets the filter operator, which may be selected from a menu consisting of a single term operator, a binary operator, an arithmetic operator, a comparison operator, a logical operator, a set operator, and a user-defined operator. To do. Step 2248 sets filter criteria, which are target values or thresholds associated with the descriptor selected in step 2244. Step 2250 prompts the user to proceed to define a new filter for the rule or to define a Boolean expression that applies to the previously specified set of filters. Steps 2242 to 2248 are revisited until the user determines in step 2250 that all relevant filters are present to add other filters. Step 2252 prompts the user to enter a Boolean expression in one of the formats described above. As described in the case of FIG. 9, the rule is reduced to a passive operator that uses the value of a single filter to determine whether the rule behavior specified in step 2234 is applied. Note that it may be based on only one filter.

Step 2260 adds the just-configured rule to the rule file opened in step 2224. Note that the filter value for each rule thus configured should be determined as "runtime" depending on the processing of the received container. The encoded rule includes a filter identifier that may simply be the index of an array (not shown) that stores the filter.

The process of FIG. 22 is performed during system installation or update. The rules that are encoded and stored in the rules file are activated in "real time".

FIG. 23 illustrates a continuous filtering process for the components of a received multimedia container having a plurality of components. The processing order of the container components for content filtering is arbitrary and may be set by the user. If overall binding is imposed on the entire container for other operational reasons, the processing order of the components will be sequential.

When prompted by the control unit 240 (FIG. 2), the content filtering process starts in step 2320. Choosing the order in which the components should be processed, step 2340 determines whether at least one component should still be processed in step 2350. Otherwise, step 2380 ends the process and reports the result. At step 2360, step 2340 is revisited to determine if all the rules in the set of rules applicable to the component under consideration are executed and other components need to be processed. The module inserts notifications that direct all filtering actions applied to the component.

FIG. 24 is a detail of step 2360 (FIG. 23) in which a set of rules is applied to the contents of the container. Step 2360 applies to the components of the container. Step 2424 determines if the entire set of rules has been applied. If so, step 2480 adds a notification to the container that directs all content filtering actions that result from the execution of the set of rules. Otherwise, step 2428 selects the current rule and gets the definitions of all related filters associated with the selected current rule. In particular, if one rule influences the choice of another rule, the rules may be arranged in a particular order. In addition, inter-rule dependencies may be represented by formal graphs rather than simple sequences, as illustrated with reference to FIG.

Step 2430 executes the selected current rule. Step 2430 includes steps 2432, 2436, 2440, and 2444. Step 2432 determines whether all the filters identified in step 2428 are activated to determine the binary value of each filter. A filter is said to be activated when the filter operator is applied to each operand to generate a binary value for the filter. If all the filters associated with the current rule are activated, step 2432 transfers control to step 2460. In other cases, steps 2436, 2440, and 2444 are performed to generate the filter values under consideration. Step 2436 gets the operators and the values of their respective operands based on the characteristics of the container content under consideration, as described by reference to FIGS. 5 and 6. Step 2440 applies the operator to the operands, and step 2444 records the value of the current filter for use when evaluating the Boolean expression of the current rule.

Step 2460 acquires a Boolean expression according to one of the coding methods of FIG. 10, FIG. 15, or FIG. Step 2464 evaluates the Boolean expression. Step 2468 may apply the content filtering behavior associated with the current rule to the content of the content under consideration according to the value of the Boolean expression as determined in step 2464. At step 2470, if the content filtering behavior of the current rule results in the deletion of the entire container component, there is no need to execute subsequent rules, and step 2360 adds individual notifications to the deleted component. To do. If the component was not edited, or was edited but not deleted, step 2424 is revisited to determine if further rules need to be applied to the content under consideration. The entire component may be removed if the attachment has a malicious insertion that exceeds a certain threshold or is irremovable.

Dependence between rules In general, rules applicable to a particular content can have complementary, conflicting, or mutually exclusive actions. In the complementary operation, the result of content filtering does not have to depend on the order in which the rules are executed. In confrontational or mutually exclusive actions, one action takes precedence over the other. According to embodiments of the present invention, the user may be prompted to use graphs to define inter-rule relationships.

FIG. 25 illustrates a graph showing the hierarchical arrangement of the five rules labeled Rule 1 through Rule 5. The state of a rule is defined herein as a binary value resulting from the execution of the Boolean expression of the rule.

The "true" state of rule 1 results in an action labeled "action 1", after which step 2360 is considered complete. "action 1" is the opposite of the two, the first is to delete the entire component because the entire component is either too large or irreparable, and the second is that the component contains malicious insertions. You may indicate that the component is acceptable because it is too small, and that one of them is acceptable. The "false" state of Rule 1 indicates that the content has passed the first test and should follow the second Rule 2 test.

The state "true" of rule 2 causes an action labeled "action 2" in which the implementation of rule 5 continues. The "false" state of Rule 2 indicates that the content should pass the second test and follow the third Rule 3 test, and so on. If rule 4 is "false", the process ends without editing the content. The process may also be terminated after performing (only) one: {action 1}, {action 2 and action 5}, {action 3}, and {action 5}.

FIG. 26 describes the modules used by the operation management unit 230 listed below. Each module comprises computer-readable instructions stored in a computer-readable storage medium. (1) Server unit configuration module 2610, which is configured so that a server unit accepts a multimedia data container formed by a specific protocol, (2) A server unit, which is individually configured to process a common type data container. Load balancing module 2612, which evenly distributes multimedia data containers among, (3) Each filter defines a set of filters that specify content descriptors, descriptor criteria, and operator definitions. Filter definition module 2614, (4) Allows the user to provide Boolean arithmetic expressions by algebraic syntax, Boolean arithmetic expression acquisition module 2616, (5) Boolean operation by the user in the form of a tree structure. Boolean arithmetic expression acquisition module 2618, which allows the expression to be provided, (6) By editing and selecting a general tree diagram, where each tree node represents an operator and an individual set of operators. Boolean formula acquisition module 2620, which allows you to enter Boolean formulas, (7) Get a set of content filtering rules from the user, where each rule specifies the Boolean formula and filtering behavior of a subset of filters. Rule-building module 2622, (8) Verifying the validity of the Boolean arithmetic expression specified for the rule, Rule-verifying module 2624, (9) The specific filtering action performed by the rule is at least one subsequent rule. Rule placement module 2626, (10) A rule that prompts the user to specify a rule that follows a given rule, subject to the value of each Boolean arithmetic expression of the given rule. Interdependency module 2628, (11) format presents a set of content filtering rules in the form of a graph (FIG. 25).^{μ μ}Rule preprocessing module 2634, which generates an array of bits and stores an array of bits in a memory device (FIGS. 20 and 21), (14) Each container type corresponds to the protocol in which the container was formed at the source. , Sorting containers by container type and moving a particular type of container from a plurality of controls to a particular control, which may be associated with a network interface 210 and an operation control 230. Module 2636. The sorting module 2636 may be associated with the network interface 210 or the operation management unit 230.

FIG. 27 describes the modules used by the transcoder 280 and listed below according to embodiments of the present invention. Each module comprises computer-readable instructions stored in a computer-readable storage medium. (A) Module 2710 that characterizes the content of each component of the multimedia data container, determines the content descriptor, applies operators, and determines the state of the filter. (B) Module 2720 for run-time evaluation of Boolean expressions and determination of binary output of rules. Boolean expressions may be presented in algebraic grammar or tree structure. (C) Module 2730 that performs filtering operations on a given container content according to preset values of Boolean expressions for individual rules.

FIG. 28 illustrates a transcoder 280 with a transcoder service module 2810, a program registry 2820, and a program storage 2840 according to an embodiment of the present invention. When executed, the transcoder service module causes the core of the processor to receive specific containers and edit requests from specific controls from multiple controls, and to select and execute programs related to edit requests. It also includes a computer-readable instruction stored in a computer-readable storage medium that causes a specific control unit to return the result. The program registry provides computer-readable instructions that, when executed, cause the processor to organize programs by their individual functions and replace existing programs with their new programs.

The control unit 240 (FIG. 2) transfers the edit request to the transcoder 280. Upon receiving the edit request 2850, the transcoder service module 2810 uses the information contained in the edit request to identify which plug-in program to execute. The transcoder service module 2810 executes the selected plug-in program and returns the result to the respective control unit 240.

A "plug-in" is defined herein as a self-contained module devised to perform a particular task. The program storage 2840 comprises computer-readable instructions stored in a computer-readable storage medium and (a) first loaded resident plug-in 2842, and (b) dynamically loaded and replaces the resident plug-in. It has two types of plug-ins, a good external plug-in 2844.

Resident plugins provide basic functionality, and external plugins provide additional functionality, and content filtering and virus scanning are two examples of such functionality.

The plug-in is registered with the program registry 2820, which manages plug-in registration and access. Program Registry 2820 organizes plugins based on the characteristics of the plugin. Plugins may be located within a plugin group.

The plug-in program organizes the execution of the plug-in in a predetermined way. A plug-in program is constructed from a set of simple instructions that determine execution logic for a predetermined set of plug-ins with specific goals.

An example of a concise program that uses the plug-in is presented below.

<tables num="1"></tables>

The numbers on the left are introduced only for ease of reference and do not necessarily form part of the instruction.

Each "Execute" command always has the name of the plug-in as an argument that refers to the name of the resident plugin. External plugins are not referenced directly by name, as they are only executed if they are selective and therefore exist. Each "Execute Group" command has the name of the plugin group as an argument. The command "Execute Group" executes all plugins that belong to that group.

The first line describes that when all errors in the program occur, the program jumps to the 14th line and the execution is restarted on the 15th to 18th lines. Lines 2 and 3 perform the conformance setup to be completed. The fourth line decrypts the input if necessary, for example if the input is an email, the email is broken down into subcomponents. The 5th and 9th lines execute the plug-in group to which the content filtering plug-in belongs. Therefore, if it exists, the fifth line starts execution and ends at the ninth line. Lines 6 and 7, respectively, are used to perform the setup operations required to generate the conforming pipeline and to actually generate the conforming pipeline. The conforming pipeline contains a set of actions to be performed to perform the required conformance. Line 8 is intended to execute all external plugins that affect the conforming pipeline before the conforming pipeline is executed. Line 10 provides details of the input components that participate in the fit. Line 18 performs a task similar to the output component. Such information may be analyzed for reporting, billing, and other purposes not necessarily related to conforming features. The eleventh line performs optimization of the conforming pipeline. Line 12 executes all external plugins that perform conformance pipeline analysis and optimization prior to execution of the conformance pipeline. Line 13 executes the conforming pipeline. Line 15 characterizes the output components that are produced as a result of running the conforming pipeline. Line 16 executes all external plugins that affect the generated output components. Line 17 then performs an additional step to complete the fit (such as providing a detailed fit record).

Rules are stored permanently as "Rule Files". The rule file may be applied to two or more control units. Content filtering using a rule file applies the rules contained in the rule file to the media (content). If the given rule is "true", the corresponding action is performed. The behavior is to remove unwanted content such as viruses (including mobile-specific viruses), remove certain types of media (such as games), and use third-party applications (such as games). It may include performing an action on the media (like scanning the media for viruses). However, certain types of content may pass unprocessed.

The rule is defined in the operation management unit 230 (FIG. 2). The application of rules affecting content editing (filtering and adaptation) is made in Transcoder 280. Once the rule file is generated, the user selectively configures one of the control units 240 to send the rule file along with all the conformity requests to the transcoder 280 selected by the conformance request.

The behavior "Drop" ensures that the media is not part of the output of the content adaptation process. The operation "scan keep" results in a virus scan of the media. This assumes that you have an antivirus plugin installed. The media is actually "scan for virus" so that all media marked "scan for virus" is scanned for viruses wherever the appropriate plug-in program's anti-virus plug-in is executed. "Marked".

An example rule called Rule 1 is given below.

<tables num="2"></tables>

The name associated with rule 1 is "MaxFileSize50000", and the action corresponding to the rule is "Drop" to remove all media that match the filter included in the rule. This rule specifies two filters. The first filter is the "MaxFileSize" type applied to the file size. The filter operator is "GreaterThan" and the value is "50000". The second filter is characterized by a type called "Family". This filter is applied to a family of media (eg IMAGE, AUDIO, etc.). The operator associated with the filter is "NotEqual" and the value is "MESSAGE". Filters are combined using the Boolean operator "AND". In this way, if the file has a size greater than 50,000 and is not in the "MESSAGE" family, the specified action will be performed.

Another rule, called Rule 2, is described below.

<tables num="3"></tables>

The name of the rule is "MaxFileSize25000AndContentTypes" and the corresponding behavior is "Drop". The purpose of Rule 2 is to remove all media that match the filters contained within the rule. A detailed description of the structure of Rule 2 is given below.

Only the following filters are specified:

First filter: -The filter type is "MaxFileSize", and the filter is applied to the file size, -The operator is "Greater Than" -The value is "25000". "AND" Open parenthesis with Boolean filtering operator. Second filter: -The filter type is "ContentType", and the filter is applied to the media's content type (equivalent to mimetype). -The operator is "Equals" -The value is "image / wbmp". Third filter: -Has the Boolean filtering operator "OR" and -The filter type is "ContentType", and the filter is applied to the media's content type (equivalent to mimetype). -The operator is "Equals" -The value is "image / png". Closing brackets.

Thus, if the file has a size greater than "25000" and (has a content type equal to "image / wbmp" or a content type equal to "image / png"), it is specified in the rule. The action is performed. The operation acts on the media, or its attachment, if the media is a container such as email or MMS. The behavior is "keep" (match media), "keep &amp; scan" (scan the media for viruses before matching), "drop" (do not include attachments in the final message), "pass-through" (media) Does not fit and does not change).

The Example Rule 3 defined in the common rule file will be described below.

<tables num="4"></tables>

In another embodiment, rule 4 is presented that completes a common rule file.

<tables num="5"></tables>

In this case, the common rule file includes rule 3 which "drops" all files having a size greater than 300,000 and rule 4 which performs a virus scan on all media that are messages.

Consider the case where a common rule file is applied to all control units and some control units "X" define a rule file containing rules 1 and 2. When sending a conformance request to the selected transcoder, the control unit sends a rule file called "RuleFile1" containing rules 1 to 4. The structure of "RuleFile1" is presented.

<tables num="6"></tables>

In the context of embodiments that provide this feature, XML is used to manage the rule structure within the rule file. This ensures portability and scalability. The XML version of RuleFile1 is shown below.

<tables num="7"></tables>

An example of content filtering is shown below. Multimedia container: MMS Features: Name: mms1.mms Family: MESSAGE Size: 171100 Content type: application / vnd.wap.multipart.mixed Number of attachments: 3 Features of MMS attachments: Name: image.jpg Family: IMAGE Size: 75000 Content type: image / jpg Name: image2.jpg Family: IMAGE Size: 45000 Content type: image / jpg Name: image.png Family: IMAGE Size: 50000 Content type: image / png Consider.

Content filtering is performed by the following steps. MMS goes through content filtering: -Since the media belongs to the family "MESSAGE", the rule "VirusScan" evaluates to "true" for this media. -Media is marked "scan for virus". Attachment image.jpg goes through content filtering: -The rule "MaxFileSize50000" evaluates to "true" because the media is not a message and the size of the message is greater than 50,000. -Media is marked "Drop". Attachment image2.jpg goes through content filtering: -No rule evaluates to "true" for this media. The second attachment image.png goes through content filtering: -Since the media has a size larger than 25000 and the content type is "image / png", the rule "MaxFileSize25000AndContentTypes" evaluates this media to "true" and -Media is marked "Drop".

The plug-in program restarts after running the content filtering plug-in. This causes the anti-virus plug-in to scan the MMS media and its contents for viruses. The conforming process then begins. Consider the case where conformance and content filtering produce output MMS of the following form:

MMS Features: Name: mms1out.mms Family: MESSAGE Size: 25175 Content type: application / vnd.wap.multipart.mixed Number of attachments: 2 Features of MMS attachments: Name: image2.gif Family: IMAGE Size: 24000 Content type: image / gif Name: removal_notification.txt Family: TEXT Size: 75 Content type: text / plain

As a result of the content fit, "image2.jpg" is assumed to fit the output "image2.gif". Note that "image.jpg" and "image.png" are "dropped" and are not part of the output MMS resulting from the application of content filtering behavior. A new media "removal_notification.txt" is added to the output message. This results from the removal of "image.jpg" and "image.png". The transcoder is devised so that a descriptive text notification is attached as the media is removed. This notice is intended to provide the MMS receiver with an explanation that some of the media originally in the MMS was incompatible and removed.

Inside the transcoder, there is an antivirus scan in the form of an external plugin. In this case, the plug-in architecture is used to provide an interface to third-party antivirus scanning engines such as McAfee®, Kaspersky®. The presence of antivirus plugins is as selective as any external plugin. At the plug-in program level, a plug-in program intended to run an anti-virus plug-in may include a command to run the plug-in group to which the anti-virus plug-in belongs.

Running an antivirus plugin does not automatically mean that the media will be scanned for viruses. Virus scanning is only performed on media marked "scan for virus" by content filtering. Some third-party antivirus engines may be installed as standalone libraries. Other third-party antivirus engines may be installed as client-server. Antivirus plugins are written in such a way that they connect properly to a third-party antivirus engine. In each case, the antivirus plug-in is the transcoder's entry point for performing virus scans on content-matched media.

Thus, in the above embodiments, the following functions, (1) a function to parse the message to check the attachment, and (2) a function to characterize the attachment to filter according to the content type. (3) A function is provided that adapts a set of user-defined extensible hierarchical rules to determine whether a media element is preferred or not.

The editing action determines how the media attachment is handled. The editing action may include one or more of providing attachments for the conformance process, maintaining the attachments and scanning the media for viruses before providing them for the conformance process, and dropping the attachments. Good. The editing operation may include invoking an antivirus and intrusion prevention software program.

Although specific embodiments of the present invention have been described in detail, the embodiments described are intended to be exemplary and non-limiting. Various modifications and modifications of the embodiments shown in the drawings and described herein can be made within the scope of the claims in a broader configuration without departing from the scope of the present invention. [Item 1] A system for filtering the contents of a multimedia data container, which includes a network interface for receiving the multimedia data container from the network and a plurality of server units, and each server unit is a processor. A filter that has a set and computer-readable instructions stored on computer-readable media, and each filter gets the definition of a set of filters from the user that specifies the content descriptor, descriptor criteria, and operator definitions. Definition module, A rule-building module for retrieving a set of content filtering rules from the user, having computer-readable instructions stored on a computer-readable medium, where each rule specifies a Boolean formula and filtering behavior for a subset of the filter. , A module that characterizes the content of each component of a multimedia data container, determines the content descriptor, applies the operator, and determines the state of each of the filters, determines the binary output of each of the rules. A system having a set of memory devices in which a module for performing a filtering operation related to the content according to a preset value of the binary output is installed. [Item 2] The system according to item 1, further comprising a module for enabling the user to provide the Boolean operation expression by algebraic grammar. [Item 3] The system according to any one of items 1 to 2, further comprising a module for allowing the user to provide the Boolean operation expression in the form of a tree structure. [Item 4] An item further comprising a module for allowing the user to enter the Boolean expression by editing and pruning the drawing of the tree, where each node of the tree represents an operator and a corresponding set of operands. The system according to any one of 1 to 3. [Item 5] The item according to any one of items 1 to 4, further comprising a module for arranging the rule in an order in which the specific filtering operation executed by the rule excludes the execution of at least one subsequent rule. system. [Item 6] The system according to any one of items 1 to 5, further comprising a module for displaying the set of content filtering rules in the form of a formal graph. [Item 7] Select a specific rule that specifies each subset of filters with at most a preset number of filters, for each of the specific rules, for all values of the subset of the filter. Evaluate the Boolean expression in the subset of the filter and set μ&gt; 1 as the number of filters in the subset of the filter to be 2.^{μ μ}The system according to any one of items 1 to 6, further comprising a module for generating an array consisting of bits and storing the array consisting of bits in a memory device. [Item 8] A step of specifying a set of binary conditions that characterize the content, and an operation in which one operator is specified as a null successor and each other operator is specified as a successor from the set of operators. The stage of specifying a set of children, and each leaf record has N&gt; 1 leaf record, with the operator of the leaf from within the set of operators and each subset of the binary condition. The stage of forming a leaf vector, the stage of forming a node vector consisting of N node records, each of which has a node operator field and a node state field, and the stage of applying the operator of each leaf to each binary condition, The stage of placing the result in the node status field of the node record and the stage of placing the successor of the operator of each leaf in the node operator field of the node record. Replacing the identified node record with the common operator with a join record with the successor of the common operator, and applying the common operator to the entry in the node state field of the identified node record. A method of filtering the content of a data container, comprising a step of recursively performing placing the result of the state in the node state field of the join record. [Item 9] The method according to item 8, further comprising a step of determining the content index as the state of the result according to the successor of the common operator which is the null successor. [Item 10] Item 8 further includes a step of determining the number of node records of the node vector after the replacement, and a step of determining the content index as the state of the result corresponding to the number of node records equal to 1. 9. The method according to any one of 9. [Item 11] The method according to any one of items 9 to 10, further comprising a step of executing a designated editing operation related to the content according to the value of the content index. [Item 12] The stage of receiving the data that characterizes the receiver of the data container, the stage of confirming the compatibility between the content and the feature of the receiver, and when the content is incompatible with the feature, the content is subjected to the feature. The method according to any one of items 8 to 11, further comprising a step of modification and. [Item 13] A filter definition module for retrieving a definition of a set of filters from the user, where each filter is a function of the selected descriptor of the content and the individual criteria corresponding to the descriptor. A Boolean expression acquisition module for the user to provide a set of Boolean expressions and corresponding content filtering actions for the filter, and the specified μ represented as a string of μ bits with μ&gt; 1. Select the Boolean expression for the filter and select 2 in the string^{μ μ} Evaluating each Boolean expression for each of the values, each entry is said 2 of the string.^{μ μ} The state of the content metric corresponding to one of the values 2^{μ μ}A preprocessing module for generating a rule vector consisting of entries is provided, and each of the filter definition module, the Boolean arithmetic expression acquisition module, and the preprocessing module is a computer-readable instruction stored in a computer-readable storage medium. An operation controller for use in a system that filters said content of a multimedia data container. [Item 14] The Boolean arithmetic expression acquisition module is stored in a computer-readable medium that allows the user to acquire the Boolean arithmetic expression in an algebraic format having a Boolean operator, an operand, and a delimiter. A computer-readable instruction is provided, and the preprocessing module inspects the Boolean arithmetic expression to identify a simple pattern that sandwiches a Boolean operator and two operands between two delimiters, and if the simple pattern is found. , The Boolean operator is applied to the two operands to determine the binary value of the pattern, and the simple pattern and the two delimiters are replaced with the binary value. The operation controller according to item 13, further comprising a computer-readable instruction stored in a computer-readable storage medium for the purpose. [Item 15] The Boolean arithmetic expression acquisition module includes a computer-readable instruction that enables a user to acquire the Boolean arithmetic expression in the form of a tree structure having a plurality of nodes, and the preprocessing module has each record. To generate a tree template that corresponds to a node of, and has multiple records containing the first operand, the second operand, the current operator, and four fields for subsequent records, and start with the first record. And up to the last record, apply the operator of the current record to each binary value to generate a new binary value. If the current record is the last record, the new binary value is Boolean operation. Determined as the value of the expression, and if the current record is an intermediate record, a computer-readable instruction for continuously advancing the placement of the new binary value in the operand field of the subsequent record. The operation controller according to any one of items 13 to 14, which is provided.