|
|
|
|
From Equations to Free TextIf we take the example of A + B = C, you can imagine something that recognises things that look like variables, and things that look like operators or functions. A model starts with a logical root, assumed to be true – you enter a statement, the variables are created if they do not exist, they are linked to the operators, and the "controlling" logical operator (the EQUALS in this case) is linked to the logical root. The "thing" doing the building has to know a bit about operator topology, but can use a relatively simple grammar, as all it is doing is combining predefined operators. If any of the states or values are known, they immediately flow into the newly built structure, so you find out about errors fairly quickly.You enter more statements, they are anded together to form a spine. We haven’t said anything about how these structures are to be used. We can alter states and values and ranges of values, see how they flow through the network. At this point, the operators are in control of what happens, and constrain the information in their links according to their semantics. A PLUS operator for example, has a strict topology but no predetermined direction – if it knows the value of all its legs except one, it will work out the value in that leg and propagate it. If we have said X = SUM(List), a hidden topology operator will patch the list objects onto the PLUS operator when the list arrives, so the PLUS operator doesn't have to know anything about structural change (the value will be killed and the patching undone if the list changes). We can introduce new logical spines, which are controlled by another spine. We can build two distinct structures, then find a connection between variables in the two structures, and turn islands of knowledge into an archipelago. People can collaborate, by building what they know and combining the results, without being concerned about integration. We can allow the structure to hypothesise about possible additions or alterations to its structure and it (or us) observe the results. What you find if you do this is just how limiting propositional logic is – sometimes a logical AND in one direction needs to operate as a logical OR in the other. But at least you can synthesise across logic, numbers, objects, lists. But what happens when you have built some part of a structure and want to temporarily pretend it is not there – you need existential control as well as logical control. And operators – yes you can do plus and multiply and IF and IFF and AND and have functions (which again are undirected – ABS one way produces a positive value, but the other way produces a discrete range) and have recursion and... You can store dynamically acquired distributions in the same structure, so some operators are hard edged and some function as statistical sources, and again the operators are undirected. But the operators are predefined or user defined, and not dynamically defined. Which brings us to text. Let’s start with "The cat sat on the mat". We have a dictionary, so create instances of definite article, cat, the relation ToSit, a preposition, mat. These are all variables. Now we start building operators – ToSit has a relation operator, which is intransitive – we build it. The relation operator connects what it can find in its local environment, so it grabs cat as its subject. We have an active map to handle the preposition – it attempts to find a meaning for "on" that will fit what it finds, and couples the location of ToSit (the map may have needed to go back to the subject of the relation) to the location (an attribute of object) of mat. We had a discourse object, which supports a sentence object, which provides logical and existential support to the ToSit relation – we currently have as true that the cat sat on the mat – the past participle "sat" changes the temporal range of the relation to be on or before the current time – the temporal range controls the validity of the logical connection for the relation in this case. OK, let’s do something hard. A word like "building" can be a noun or a present participle, "that" has many uses, "as" can be a preposition or a conjunction. When we instantiate the words, we build a chain structure between them and prune what we can, based on everything we can think of. "A building" – the indefinite article prunes the present participle. Looking only to neighbours is not nearly enough, and we can’t rely on the structure being linear. Some things are easy – 8000 square feet – some things are extremely hard, but the system chips away at alternatives, using everything it has, including what it has already read. We run into Section 23(a)(ii) when we are reading Section 7, so we create objects to represent Section 23 and (a) and (ii) (and we will hang the sentences off those objects), and make sure we clean up errors if we never get to build Section 23(a)(ii). When we are searching, we can follow the reference to the structure it indicates. We have a global dictionary of about 15000 words for contracts in a particular legal domain. The system encounters a definition – it builds it into a local dictionary, with an equivalence and defining structure hung off the object. The definition may be given in a sentence where the defined term is used later in the same sentence –when we find the definition, we check for use and modify the structure accordingly. When we scan the next sentence, we will first look in the local dictionary (and check the scope – the definition may look like "For the purposes of Section 9(b), Widget shall mean..."). Each word in the dictionary has all the parts of speech it can be, and all the meanings it can have. "Give", for example, links to the base form of ToGive, which may have a dozen meanings – different relations with different types of subject and object objects, and intransitive, transitive, ditransitive, causal forms. These alternatives will be pruned. Some relations, like ToThink or ToDeem, can support a structure similar to a sentence – "He thought he saw a pussycat" provides both existential and logical control to the ToSee relation. We could go on at length about aspects of the problem. Lawyers do go on at length, with long chains that are all tangled up and need to be slowly untangled (the system can read no faster than an attentive human). We are building structure interwoven with constraint reasoning on existing structure and hypothetical structure. The important point is you have to use everything you know for it to work. Ontologies have problems stemming from a static structure, when the objects they are describing are capable of movement within the classification - a female barramundi, for example. Grammars have a similar problem – only when you are in the midst of a dynamic structure building exercise do you realise just how useless a static grammar is. Worse, because both transmitter and receiver know the rules of grammar, they know they can leave things out or break the rules and the receiver will still understand. The things that are needed – existential control, computable inheritance, relations as objects, relations on relations, diffuse operators, active maps - see Extensions to the Orion Paradigm. In simple terms, we start with a discourse object, if we are in a legal document we add a section or paragraph object, and then a sentence object, and then build structure, starting with the words in a chain and then cutting and hacking and rearranging those objects until we have represented the meaning of the sentence within the discourse. The objects used the initial dictionary structure and built on it and changed it. We mention cutting and hacking – that may not sound nice – here is an example of what is meant – "He cut the rope with a knife" turns into "He used a knife to cut the rope" courtesy of an active map (which combines structure cutting and building and constraint reasoning together all mixed up) plugging in a relation.
|