US10355713B2 - Computer architecture for emulating a correlithm object logic gate using a context input - Google Patents
Computer architecture for emulating a correlithm object logic gate using a context input Download PDFInfo
- Publication number
- US10355713B2 US10355713B2 US15/783,470 US201715783470A US10355713B2 US 10355713 B2 US10355713 B2 US 10355713B2 US 201715783470 A US201715783470 A US 201715783470A US 10355713 B2 US10355713 B2 US 10355713B2
- Authority
- US
- United States
- Prior art keywords
- correlithm object
- logical
- correlithm
- input
- represented
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active, expires
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/25—Integrating or interfacing systems involving database management systems
- G06F16/258—Data format conversion from or to a database
-
- H—ELECTRICITY
- H03—ELECTRONIC CIRCUITRY
- H03M—CODING; DECODING; CODE CONVERSION IN GENERAL
- H03M13/00—Coding, decoding or code conversion, for error detection or error correction; Coding theory basic assumptions; Coding bounds; Error probability evaluation methods; Channel models; Simulation or testing of codes
- H03M13/03—Error detection or forward error correction by redundancy in data representation, i.e. code words containing more digits than the source words
- H03M13/05—Error detection or forward error correction by redundancy in data representation, i.e. code words containing more digits than the source words using block codes, i.e. a predetermined number of check bits joined to a predetermined number of information bits
- H03M13/13—Linear codes
- H03M13/15—Cyclic codes, i.e. cyclic shifts of codewords produce other codewords, e.g. codes defined by a generator polynomial, Bose-Chaudhuri-Hocquenghem [BCH] codes
- H03M13/151—Cyclic codes, i.e. cyclic shifts of codewords produce other codewords, e.g. codes defined by a generator polynomial, Bose-Chaudhuri-Hocquenghem [BCH] codes using error location or error correction polynomials
- H03M13/1575—Direct decoding, e.g. by a direct determination of the error locator polynomial from syndromes and subsequent analysis or by matrix operations involving syndromes, e.g. for codes with a small minimum Hamming distance
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/22—Indexing; Data structures therefor; Storage structures
- G06F16/2228—Indexing structures
- G06F16/2272—Management thereof
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/22—Microcontrol or microprogram arrangements
- G06F9/223—Execution means for microinstructions irrespective of the microinstruction function, e.g. decoding of microinstructions and nanoinstructions; timing of microinstructions; programmable logic arrays; delays and fan-out problems
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
- G06N20/00—Machine learning
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
- G06N20/00—Machine learning
- G06N20/20—Ensemble learning
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
- G06N5/00—Computing arrangements using knowledge-based models
- G06N5/02—Knowledge representation; Symbolic representation
- G06N5/022—Knowledge engineering; Knowledge acquisition
Definitions
- the present disclosure relates generally to computer architectures for emulating a processing system, and more specifically to computer architectures for emulating a correlithm object logic gate using a context input.
- Ordinal based number systems only provide information about the sequence order of the numbers themselves based on their numeric values. Ordinal numbers do not provide any information about any other types of relationships for the data being represented by the numeric values such as similarity. For example, when a conventional computer uses ordinal numbers to represent data samples (e.g. images or audio signals), different data samples are represented by different numeric values. The different numeric values do not provide any information about how similar or dissimilar one data sample is from another. Unless there is an exact match in ordinal number values, conventional systems are unable to tell if a data sample matches or is similar to any other data samples. As a result, conventional computers are unable to use ordinal numbers by themselves for comparing different data samples and instead these computers rely on complex signal processing techniques.
- data samples e.g. images or audio signals
- Determining whether a data sample matches or is similar to other data samples is not a trivial task and poses several technical challenges for conventional computers. These technical challenges result in complex processes that consume processing power which reduces the speed and performance of the system. The ability to compare unknown data samples to known data samples is crucial for many security applications such as face recognition, voice recognition, and fraud detection.
- Ordinal based number systems only provide information about the sequence order of the numbers themselves based on their numeric values. Ordinal numbers do not provide any information about any other types of relationships for the data being represented by the numeric values such as similarity. For example, when a conventional computer uses ordinal numbers to represent data samples (e.g. images or audio signals), different data samples are represented by different numeric values. The different numeric values do not provide any information about how similar or dissimilar one data sample is from another. Unless there is an exact match in ordinal number values, conventional systems are unable to tell if a data sample matches or is similar to any other data samples. As a result, conventional computers are unable to use ordinal numbers by themselves for comparing different data samples and instead these computers rely on complex signal processing techniques.
- data samples e.g. images or audio signals
- Determining whether a data sample matches or is similar to other data samples is not a trivial task and poses several technical challenges for conventional computers. These technical challenges result in complex processes that consume processing power which reduces the speed and performance of the system.
- security application e.g. face recognition, voice recognition, and fraud detection.
- the system described in the present application provides a technical solution that enables the system to efficiently determine how similar different objects are to each other and to perform operations based on their similarity.
- the system uses an unconventional configuration to perform various operations using categorical numbers and geometric objects, also referred to as correlithm objects, instead of ordinal numbers.
- categorical numbers and correlithm objects on a conventional device involves changing the traditional operation of the computer to support representing and manipulating concepts as correlithm objects.
- a device or system may be configured to implement or emulate a special purpose computing device capable of performing operations using correlithm objects.
- Implementing or emulating a correlithm object processing system improves the operation of a device by enabling the device to perform non-binary comparisons (i.e.
- the system is configured to use binary integers as categorical numbers rather than ordinal numbers which enables the system to determine how similar a data sample is to other data samples.
- Categorical numbers provide information about similar or dissimilar different data samples are from each other.
- categorical numbers can be used in facial recognition applications to represent different images of faces and/or features of the faces.
- the system provides a technical advantage by allowing the system to assign correlithm objects represented by categorical numbers to different data samples based on how similar they are to other data samples.
- the system is able to assign correlithm objects to different images of people such that the correlithm objects can be directly used to determine how similar the people in the images are to each other.
- the system is able to use correlithm objects in facial recognition applications to quickly determine whether a captured image of a person matches any previously stored images without relying on conventional signal processing techniques.
- Correlithm object processing systems use new types of data structures called correlithm objects that improve the way a device operates, for example, by enabling the device to perform non-binary data set comparisons and to quantify the similarity between different data samples.
- Correlithm objects are data structures designed to improve the way a device stores, retrieves, and compares data samples in memory.
- Correlithm objects also provide a data structure that is independent of the data type and format of the data samples they represent. Correlithm objects allow data samples to be directly compared regardless of their original data type and/or format.
- a correlithm object processing system uses a combination of a sensor table, a node table, and/or an actor table to provide a specific set of rules that improve computer-related technologies by enabling devices to compare and to determine the degree of similarity between different data samples regardless of the data type and/or format of the data sample they represent.
- the ability to directly compare data samples having different data types and/or formatting is a new functionality that cannot be performed using conventional computing systems and data structures.
- correlithm object processing system uses a combination of a sensor table, a node table, and/or an actor table to provide a particular manner for transforming data samples between ordinal number representations and correlithm objects in a correlithm object domain.
- Transforming data samples between ordinal number representations and correlithm objects involves fundamentally changing the data type of data samples between an ordinal number system and a categorical number system to achieve the previously described benefits of the correlithm object processing system.
- correlithm objects allows the system or device to compare data samples (e.g. images) even when the input data sample does not exactly match any known or previously stored input values. For example, an input data sample that is an image may have different lighting conditions than the previously stored images. The differences in lighting conditions can make images of the same person appear different from each other.
- the device uses an unconventional configuration that implements a correlithm object processing system that uses the distance between the data samples which are represented as correlithm objects and other known data samples to determine whether the input data sample matches or is similar to the other known data samples. Implementing a correlithm object processing system fundamentally changes the device and the traditional data processing paradigm.
- Implementing the correlithm object processing system improves the operation of the device by enabling the device to perform non-binary comparisons of data samples.
- the device is able to determine how similar the data samples are to each other even when the data samples are not exact matches.
- the device is able to quantify how similar data samples are to one another. The ability to determine how similar data samples are to each others is unique and distinct from conventional computers that can only perform binary comparisons to identify exact matches.
- the problems associated with comparing data sets and identifying matches based on the comparison are problems necessarily rooted in computer technologies. As described above, conventional systems are limited to a binary comparison that can only determine whether an exact match is found. Emulating a correlithm object processing system provides a technical solution that addresses problems associated with comparing data sets and identifying matches.
- Using correlithm objects to represent data samples fundamentally changes the operation of a device and how the device views data samples.
- the device can determine the distance between the data samples and other known data samples to determine whether the input data sample matches or is similar to the other known data samples.
- the device is able to determine a degree of similarity that quantifies how similar different data samples are to one another.
- digital circuits represent a single state using two logic levels. These levels are referred to, for example, as a logic 1 or a logic 0, HIGH or LOW, True or False, or ON or OFF. Most logic systems use positive logic, in which case a logic “0” is represented by zero volts and a logic “1” is represented by a higher voltage, such as +5 volts.
- the two discrete voltage levels representing the digital values of “1's” (one's) and “0's” (zero's) are commonly called: BInary digiTS, and in digital and computational circuits and applications they are normally referred to as binary BITS.
- a voltage surge can exceed the noise margins built around logic “0” and “1” such that a BIT value of “0” may be mispresented as a value of “1,” and a BIT value of “1” may be misrepresented as a value of “0.”
- voltage surge can cause conventional electronic and computer circuits to malfunction.
- the present disclosure describes representing logical “0's” and “1's” (or High/Low; True/False; On/Off) using correlithm objects which exhibit immunity to these significant noise impulses.
- logical “0's” and logical “1's” or High/Low; True/False; On/Off
- any binary values e.g., High/Low; True/False; On/Off; etc.
- any electrical or computer system built using correlithm objects to represent binary values is more robust and hardened against voltage surges and other forms of significant noise, such as EMP impulses.
- an EMP noise impulse may affect a few bits (e.g., up to five bits) of the 64-bit correlithm object.
- an EMP noise impulse may affect a few bits (e.g., up to five bits) of the 64 bit correlithm object.
- the remaining bits (e.g., up to sixty bits) of the 64-bit correlithm object would remain intact and collectively would still represent a logical “1.”
- the remaining bits e.g., up to sixty bits
- the remaining bits would adequately represent the original logical value.
- correlithm objects can be used to emulate logical values and logical functions with a robustness and immunity to noise that is not available in conventional computer systems. In at least this way, the use of correlithm objects to emulate logical values and logical functions improves the operation of a computer itself.
- FIG. 1 is a schematic view of an embodiment of a special purpose computer implementing correlithm objects in an n-dimensional space;
- FIG. 2 is a perspective view of an embodiment of a mapping between correlithm objects in different n-dimensional spaces
- FIG. 3 is a schematic view of an embodiment of a correlithm object processing system
- FIG. 4 is a protocol diagram of an embodiment of a correlithm object process flow
- FIG. 5 is a schematic diagram of an embodiment a computer architecture for emulating a correlithm object processing system
- FIG. 6 illustrates one embodiment of a correlithm object binary logic function gate
- FIG. 7 illustrates one embodiment of a flowchart implementing a process performed by binary logic function gate
- FIG. 8 illustrates one embodiment of a correlithm object unary logic function gate
- FIG. 9 illustrates one embodiment of a flowchart implementing a process performed by unary logic function gate
- FIG. 10 illustrates one embodiment of a correlithm object binary flip-flop device.
- FIGS. 1-5 describe various embodiments of how a correlithm object processing system may be implemented or emulated in hardware, such as a special purpose computer.
- FIGS. 6-10 describe various embodiments of using correlithm objects to emulate logic gates.
- FIG. 1 is a schematic view of an embodiment of a user device 100 implementing correlithm objects 104 in an n-dimensional space 102 .
- user devices 100 include, but are not limited to, desktop computers, mobile phones, tablet computers, laptop computers, or other special purpose computer platform.
- the user device 100 is configured to implement or emulate a correlithm object processing system that uses categorical numbers to represent data samples as correlithm objects 104 in a high-dimensional space 102 , for example a high-dimensional binary cube. Additional information about the correlithm object processing system is described in FIG. 3 . Additional information about configuring the user device 100 to implement or emulate a correlithm object processing system is described in FIG. 5 .
- ordinal binary integers representing data to perform various operations such as counting, sorting, indexing, and mathematical calculations. Even when performing operations that involve other number systems (e.g. floating point), conventional computers still resort to using ordinal binary integers to perform any operations.
- Ordinal based number systems only provide information about the sequence order of the numbers themselves based on their numeric values. Ordinal numbers do not provide any information about any other types of relationships for the data being represented by the numeric values, such as similarity. For example, when a conventional computer uses ordinal numbers to represent data samples (e.g. images or audio signals), different data samples are represented by different numeric values. The different numeric values do not provide any information about how similar or dissimilar one data sample is from another.
- conventional computers are only able to make binary comparisons of data samples which only results in determining whether the data samples match or do not match. Unless there is an exact match in ordinal number values, conventional systems are unable to tell if a data sample matches or is similar to any other data samples. As a result, conventional computers are unable to use ordinal numbers by themselves for determining similarity between different data samples, and instead these computers rely on complex signal processing techniques. Determining whether a data sample matches or is similar to other data samples is not a trivial task and poses several technical challenges for conventional computers. These technical challenges result in complex processes that consume processing power which reduces the speed and performance of the system.
- the user device 100 operates as a special purpose machine for implementing or emulating a correlithm object processing system.
- Implementing or emulating a correlithm object processing system improves the operation of the user device 100 by enabling the user device 100 to perform non-binary comparisons (i.e. match or no match) between different data samples. This enables the user device 100 to quantify a degree of similarity between different data samples. This increases the flexibility of the user device 100 to work with data samples having different data types and/or formats, and also increases the speed and performance of the user device 100 when performing operations using data samples.
- the user device 100 employs the correlithm object processing system to allow the user device 100 to compare data samples even when the input data sample does not exactly match any known or previously stored input values.
- Implementing a correlithm object processing system fundamentally changes the user device 100 and the traditional data processing paradigm.
- Implementing the correlithm object processing system improves the operation of the user device 100 by enabling the user device 100 to perform non-binary comparisons of data samples.
- the user device 100 is able to determine how similar the data samples are to each other even when the data samples are not exact matches.
- the user device 100 is able to quantify how similar data samples are to one another. The ability to determine how similar data samples are to each others is unique and distinct from conventional computers that can only perform binary comparisons to identify exact matches.
- the user device's 100 ability to perform non-binary comparisons of data samples also fundamentally changes traditional data searching paradigms.
- conventional search engines rely on finding exact matches or exact partial matches of search tokens to identify related data samples.
- conventional text-based search engine are limited to finding related data samples that have text that exactly matches other data samples.
- These search engines only provide a binary result that identifies whether or not an exact match was found based on the search token.
- Implementing the correlithm object processing system improves the operation of the user device 100 by enabling the user device 100 to identify related data samples based on how similar the search token is to other data sample. These improvements result in increased flexibility and faster search time when using a correlithm object processing system.
- the ability to identify similarities between data samples expands the capabilities of a search engine to include data samples that may not have an exact match with a search token but are still related and similar in some aspects.
- the user device 100 is also able to quantify how similar data samples are to each other based on characteristics besides exact matches to the search token.
- Implementing the correlithm object processing system involves operating the user device 100 in an unconventional manner to achieve these technological improvements as well as other benefits described below for the user device 100 .
- Computing devices typically rely on the ability to compare data sets (e.g. data samples) to one another for processing.
- a computing device is configured to compare an input of an unknown person to a data set of known people (or biometric information associated with these people).
- the problems associated with comparing data sets and identifying matches based on the comparison are problems necessarily rooted in computer technologies.
- conventional systems are limited to a binary comparison that can only determine whether an exact match is found.
- an input data sample that is an image of a person may have different lighting conditions than previously stored images. In this example, different lighting conditions can make images of the same person appear different from each other.
- the user device 100 uses an unconventional configuration that uses correlithm objects to represent data samples.
- Using correlithm objects to represent data samples fundamentally changes the operation of the user device 100 and how the device views data samples.
- the user device 100 can determine the distance between the data samples and other known data samples to determine whether the input data sample matches or is similar to the other known data samples, as explained in detail below.
- the user device 100 is able to distinguish between two images of the same person with different lighting conditions and two images of two different people by using correlithm objects 104 .
- Correlithm objects allow the user device 100 to determine whether there are any similarities between data samples, such as between two images that are different from each other in some respects but similar in other respects. For example, the user device 100 is able to determine that despite different lighting conditions, the same person is present in both images.
- the user device 100 is able to determine a degree of similarity that quantifies how similar different data samples are to one another.
- Implementing a correlithm object processing system in the user device 100 improves the operation of the user device 100 when comparing data sets and identifying matches by allowing the user device 100 to perform non-binary comparisons between data sets and to quantify the similarity between different data samples.
- using a correlithm object processing system results in increased flexibility and faster search times when comparing data samples or data sets.
- implementing a correlithm object processing system in the user device 100 provides a technical solution to a problem necessarily rooted in computer technologies.
- correlithm object processing system provides a technical advantage by allowing the system to identify and compare data samples regardless of whether an exact match has been previous observed or stored.
- the user device 100 is able to identify similar data samples to an input data sample in the absence of an exact match.
- This functionality is unique and distinct from conventional computers that can only identify data samples with exact matches.
- a correlithm object 104 is a point in the n-dimensional space 102 , sometimes called an “n-space.”
- the value of ‘n’ represents the number of dimensions of the space.
- an n-dimensional space 102 may be a 3-dimensional space, a 50-dimensional space, a 100-dimensional space, or any other suitable dimension space.
- the number of dimensions depends on its ability to support certain statistical tests, such as the distances between pairs of randomly chosen points in the space approximating a normal distribution. In some embodiments, increasing the number of dimensions in the n-dimensional space 102 modifies the statistical properties of the system to provide improved results.
- Increasing the number of dimensions increases the probability that a correlithm object 104 is similar to other adjacent correlithm objects 104 .
- increasing the number of dimensions increases the correlation between how close a pair of correlithm objects 104 are to each other and how similar the correlithm objects 104 are to each other.
- Correlithm object processing systems use new types of data structures called correlithm objects 104 that improve the way a device operates, for example, by enabling the device to perform non-binary data set comparisons and to quantify the similarity between different data samples.
- Correlithm objects 104 are data structures designed to improve the way a device stores, retrieves, and compares data samples in memory. Unlike conventional data structures, correlithm objects 104 are data structures where objects can be expressed in a high-dimensional space such that distance 106 between points in the space represent the similarity between different objects or data samples. In other words, the distance 106 between a pair of correlithm objects 104 in the n-dimensional space 102 indicates how similar the correlithm objects 104 are from each other and the data samples they represent.
- Correlithm objects 104 that are close to each other are more similar to each other than correlithm objects 104 that are further apart from each other.
- correlithm objects 104 used to represent images of different types of glasses may be relatively close to each other compared to correlithm objects 104 used to represent images of other features such as facial hair.
- An exact match between two data samples occurs when their corresponding correlithm objects 104 are the same or have no distance between them.
- the distance between their correlithm objects 104 can be used to indicate their similarities.
- the distance 106 between correlithm objects 104 can be used to identify both data samples that exactly match each other as well as data samples that do not match but are similar. This feature is unique to a correlithm processing system and is unlike conventional computers that are unable to detect when data samples are different but similar in some aspects.
- Correlithm objects 104 also provide a data structure that is independent of the data type and format of the data samples they represent. Correlithm objects 104 allow data samples to be directly compared regardless of their original data type and/or format. In some instances, comparing data samples as correlithm objects 104 is computationally more efficient and faster than comparing data samples in their original format. For example, comparing images using conventional data structures involves significant amounts of image processing which is time consuming and consumes processing resources. Thus, using correlithm objects 104 to represent data samples provides increased flexibility and improved performance compared to using other conventional data structures.
- correlithm objects 104 may be represented using categorical binary strings.
- the number of bits used to represent the correlithm object 104 corresponds with the number of dimensions of the n-dimensional space 102 where the correlithm object 102 is located.
- each correlithm object 104 may be uniquely identified using a 64-bit string in a 64-dimensional space 102 .
- each correlithm object 104 may be uniquely identified using a 10-bit string in a 10-dimensional space 102 .
- correlithm objects 104 can be identified using any other suitable number of bits in a string that corresponds with the number of dimensions in the n-dimensional space 102 .
- the distance 106 between two correlithm objects 104 can be determined based on the differences between the bits of the two correlithm objects 104 . In other words, the distance 106 between two correlithm objects can be determined based on how many individual bits differ between the correlithm objects 104 .
- the distance 106 between two correlithm objects 104 can be computed using Hamming distance or any other suitable technique.
- a first correlithm object 104 is represented by a first 10-bit string (1001011011) and a second correlithm object 104 is represented by a second 10-bit string (1000011011).
- the Hamming distance corresponds to the number of bits that differ between the first correlithm object 104 and the second correlithm object 104 .
- the Hamming distance between the first correlithm object 104 and the second correlithm object 104 can be computed as follows:
- the Hamming distance is equal to one because only one bit differs between the first correlithm object 104 and the second correlithm object.
- a third correlithm object 104 is represented by a third 10-bit string (0110100100).
- the Hamming distance between the first correlithm object 104 and the third correlithm object 104 can be computed as follows:
- the Hamming distance is equal to ten because all of the bits are different between the first correlithm object 104 and the third correlithm object 104 .
- a Hamming distance equal to one indicates that the first correlithm object 104 and the second correlithm object 104 are close to each other in the n-dimensional space 102 , which means they are similar to each other.
- a Hamming distance equal to ten indicates that the first correlithm object 104 and the third correlithm object 104 are further from each other in the n-dimensional space 102 and are less similar to each other than the first correlithm object 104 and the second correlithm object 104 .
- the similarity between a pair of correlithm objects can be readily determined based on the distance in n-dimensional space between the pair correlithm objects.
- the distance between a pair of correlithm objects 104 can be determined by performing an XOR operation between the pair of correlithm objects 104 and counting the number of logical high values in the binary string.
- the number of logical high values indicates the number of bits that are different between the pair of correlithm objects 104 which also corresponds with the Hamming distance between the pair of correlithm objects 104 .
- the distance 106 between two correlithm objects 104 can be determined using a Minkowski distance such as the Euclidean or “straight-line” distance between the correlithm objects 104 .
- the distance 106 between a pair of correlithm objects 104 may be determined by calculating the square root of the sum of squares of the coordinate difference in each dimension.
- the user device 100 is configured to implement or emulate a correlithm object processing system that comprises one or more sensors 302 , nodes 304 , and/or actors 306 in order to convert data samples between real world values or representations and to correlithm objects 104 in a correlithm object domain.
- Sensors 302 are generally configured to convert real world data samples to the correlithm object domain.
- Nodes 304 are generally configured to process or perform various operations on correlithm objects in the correlithm object domain.
- Actors 306 are generally configured to convert correlithm objects 104 into real world values or representations. Additional information about sensors 302 , nodes 304 , and actors 306 is described in FIG. 3 .
- Performing operations using correlithm objects 104 in a correlithm object domain allows the user device 100 to identify relationships between data samples that cannot be identified using conventional data processing systems. For example, in the correlithm object domain, the user device 100 is able to identify not only data samples that exactly match an input data sample, but also other data samples that have similar characteristics or features as the input data samples. Conventional computers are unable to identify these types of relationships readily.
- Using correlithm objects 104 improves the operation of the user device 100 by enabling the user device 100 to efficiently process data samples and identify relationships between data samples without relying on signal processing techniques that require a significant amount of processing resources. These benefits allow the user device 100 to operate more efficiently than conventional computers by reducing the amount of processing power and resources that are needed to perform various operations.
- FIG. 2 is a schematic view of an embodiment of a mapping between correlithm objects 104 in different n-dimensional spaces 102 .
- the user device 100 performs operations within the correlithm object domain using correlithm objects 104 in different n-dimensional spaces 102 .
- the user device 100 may convert different types of data samples having real world values into correlithm objects 104 in different n-dimensional spaces 102 .
- the user device 100 may convert data samples of text into a first set of correlithm objects 104 in a first n-dimensional space 102 and data samples of audio samples as a second set of correlithm objects 104 in a second n-dimensional space 102 .
- a first set of correlithm objects 104 A are defined within a first n-dimensional space 102 A and a second set of correlithm objects 104 B are defined within a second n-dimensional space 102 B.
- the n-dimensional spaces may have the same number dimensions or a different number of dimensions.
- the first n-dimensional space 102 A and the second n-dimensional space 102 B may both be three dimensional spaces.
- the first n-dimensional space 102 A may be a three dimensional space and the second n-dimensional space 102 B may be a nine dimensional space.
- Correlithm objects 104 in the first n-dimensional space 102 A and second n-dimensional space 102 B are mapped to each other.
- a correlithm object 104 A in the first n-dimensional space 102 A may reference or be linked with a particular correlithm object 104 B in the second n-dimensional space 102 B.
- the correlithm objects 104 may also be linked with and referenced with other correlithm objects 104 in other n-dimensional spaces 102 .
- a data structure such as table 200 may be used to map or link correlithm objects 194 in different n-dimensional spaces 102 .
- table 200 is referred to as a node table.
- Table 200 is generally configured to identify a first plurality of correlithm objects 104 in a first n-dimensional space 102 and a second plurality of correlithm objects 104 in a second n-dimensional space 102 .
- Each correlithm object 104 in the first n-dimensional space 102 is linked with a correlithm object 104 is the second n-dimensional space 102 .
- table 200 may be configured with a first column 202 that lists correlithm objects 104 A as source correlithm objects and a second column 204 that lists corresponding correlithm objects 104 B as target correlithm objects.
- table 200 may be configured in any other suitable manner or may be implemented using any other suitable data structure.
- one or more mapping functions may be used to convert between a correlithm object 104 in a first n-dimensional space and a correlithm object 104 is a second n-dimensional space.
- FIG. 3 is a schematic view of an embodiment of a correlithm object processing system 300 that is implemented by a user device 100 to perform operations using correlithm objects 104 .
- the system 300 generally comprises a sensor 302 , a node 304 , and an actor 306 .
- the system 300 may be configured with any suitable number and/or configuration of sensors 302 , nodes 304 , and actors 306 .
- An example of the system 300 in operation is described in FIG. 4 .
- a sensor 302 , a node 304 , and an actor 306 may all be implemented on the same device (e.g. user device 100 ).
- a sensor 302 , a node 304 , and an actor 306 may each be implemented on different devices in signal communication with each other for example over a network.
- different devices may be configured to implement any combination of sensors 302 , nodes 304 , and actors 306 .
- Sensors 302 serve as interfaces that allow a user device 100 to convert real world data samples into correlithm objects 104 that can be used in the correlithm object domain. Sensors 302 enable the user device 100 compare and perform operations using correlithm objects 104 regardless of the data type or format of the original data sample. Sensors 302 are configured to receive a real world value 320 representing a data sample as an input, to determine a correlithm object 104 based on the real world value 320 , and to output the correlithm object 104 . For example, the sensor 302 may receive an image 301 of a person and output a correlithm object 322 to the node 304 or actor 306 .
- sensors 302 are configured to use sensor tables 308 that link a plurality of real world values with a plurality of correlithm objects 104 in an n-dimensional space 102 .
- Real world values are any type of signal, value, or representation of data samples. Examples of real world values include, but are not limited to, images, pixel values, text, audio signals, electrical signals, and biometric signals.
- a sensor table 308 may be configured with a first column 312 that lists real world value entries corresponding with different images and a second column 314 that lists corresponding correlithm objects 104 as input correlithm objects.
- sensor tables 308 may be configured in any other suitable manner or may be implemented using any other suitable data structure.
- one or more mapping functions may be used to translate between a real world value 320 and a correlithm object 104 is a n-dimensional space. Additional information for implementing or emulating a sensor 302 in hardware is described in FIG. 5 .
- Nodes 304 are configured to receive a correlithm object 104 (e.g. an input correlithm object 104 ), to determine another correlithm object 104 based on the received correlithm object 104 , and to output the identified correlithm object 104 (e.g. an output correlithm object 104 ).
- nodes 304 are configured to use node tables 200 that link a plurality of correlithm objects 104 from a first n-dimensional space 102 with a plurality of correlithm objects 104 in a second n-dimensional space 102 .
- a node table 200 may be configured similar to the table 200 described in FIG. 2 . Additional information for implementing or emulating a node 304 in hardware is described in FIG. 5 .
- Actors 306 serve as interfaces that allow a user device 100 to convert correlithm objects 104 in the correlithm object domain back to real world values or data samples. Actors 306 enable the user device 100 to convert from correlithm objects 104 into any suitable type of real world value. Actors 306 are configured to receive a correlithm object 104 (e.g. an output correlithm object 104 ), to determine a real world output value 326 based on the received correlithm object 104 , and to output the real world output value 326 . The real world output value 326 may be a different data type or representation of the original data sample.
- a correlithm object 104 e.g. an output correlithm object 104
- the real world output value 326 may be a different data type or representation of the original data sample.
- the real world input value 320 may be an image 301 of a person and the resulting real world output value 326 may be text 327 and/or an audio signal identifying the person.
- actors 306 are configured to use actor tables 310 that link a plurality of correlithm objects 104 in an n-dimensional space 102 with a plurality of real world values.
- an actor table 310 may be configured with a first column 316 that lists correlithm objects 104 as output correlithm objects and a second column 318 that lists real world values.
- actor tables 310 may be configured in any other suitable manner or may be implemented using any other suitable data structure.
- one or more mapping functions may be employed to translate between a correlithm object 104 in an n-dimensional space and a real world output value 326 . Additional information for implementing or emulating an actor 306 in hardware is described in FIG. 5 .
- a correlithm object processing system 300 uses a combination of a sensor table 308 , a node table 200 , and/or an actor table 310 to provide a specific set of rules that improve computer-related technologies by enabling devices to compare and to determine the degree of similarity between different data samples regardless of the data type and/or format of the data sample they represent.
- the ability to directly compare data samples having different data types and/or formatting is a new functionality that cannot be performed using conventional computing systems and data structures.
- Conventional systems require data samples to be of the same type and/or format in order to perform any kind of operation on the data samples. In some instances, some types of data samples are incompatible with each other and cannot be compared because there is no common format available.
- a device implementing a correlithm object processing system uses a combination of a sensor table 308 , a node table 200 , and/or an actor table 310 to compare and perform operations using correlithm objects 104 in the correlithm object domain regardless of the type or format of the original data samples.
- the correlithm object processing system 300 uses a combination of a sensor table 308 , a node table 200 , and/or an actor table 310 as a specific set of rules that provides a particular solution to dealing with different types of data samples and allows devices to perform operations on different types of data samples using correlithm objects 104 in the correlithm object domain.
- comparing data samples as correlithm objects 104 is computationally more efficient and faster than comparing data samples in their original format.
- using correlithm objects 104 to represent data samples provides increased flexibility and improved performance compared to using other conventional data structures.
- the specific set of rules used by the correlithm object processing system 300 go beyond simply using routine and conventional activities in order to achieve this new functionality and performance improvements.
- correlithm object processing system 300 uses a combination of a sensor table 308 , a node table 200 , and/or an actor table 310 to provide a particular manner for transforming data samples between ordinal number representations and correlithm objects 104 in a correlithm object domain.
- the correlithm object processing system 300 may be configured to transform a representation of a data sample into a correlithm object 104 , to perform various operations using the correlithm object 104 in the correlithm object domain, and to transform a resulting correlithm object 104 into another representation of a data sample.
- Transforming data samples between ordinal number representations and correlithm objects 104 involves fundamentally changing the data type of data samples between an ordinal number system and a categorical number system to achieve the previously described benefits of the correlithm object processing system 300 .
- FIG. 4 is a protocol diagram of an embodiment of a correlithm object process flow 400 .
- a user device 100 implements process flow 400 to emulate a correlithm object processing system 300 to perform operations using correlithm object 104 such as facial recognition.
- the user device 100 implements process flow 400 to compare different data samples (e.g. images, voice signals, or text) are to each other and to identify other objects based on the comparison.
- Process flow 400 provides instructions that allows user devices 100 to achieve the improved technical benefits of a correlithm object processing system 300 .
- a user device 100 can implement or emulate the correlithm object processing system 300 which provides an unconventional solution that uses categorical numbers and correlithm objects 104 to represent data samples.
- the system 300 may be configured to use binary integers as categorical numbers to generate correlithm objects 104 which enables the user device 100 to perform operations directly based on similarities between different data samples.
- Categorical numbers provide information about how similar different data sample are from each other.
- Correlithm objects 104 generated using categorical numbers can be used directly by the system 300 for determining how similar different data samples are from each other without relying on exact matches, having a common data type or format, or conventional signal processing techniques.
- a non-limiting example is provided to illustrate how the user device 100 implements process flow 400 to emulate a correlithm object processing system 300 to perform facial recognition on an image to determine the identity of the person in the image.
- the user device 100 may implement process flow 400 to emulate a correlithm object processing system 300 to perform voice recognition, text recognition, or any other operation that compares different objects.
- a sensor 302 receives an input signal representing a data sample.
- the sensor 302 receives an image of person's face as a real world input value 320 .
- the input signal may be in any suitable data type or format.
- the sensor 302 may obtain the input signal in real-time from a peripheral device (e.g. a camera). In another embodiment, the sensor 302 may obtain the input signal from a memory or database.
- the sensor 302 identifies a real world value entry in a sensor table 308 based on the input signal.
- the system 300 identifies a real world value entry in the sensor table 308 that matches the input signal.
- the real world value entries may comprise previously stored images. The sensor 302 may compare the received image to the previously stored images to identify a real world value entry that matches the received image. In one embodiment, when the sensor 302 does not find an exact match, the sensor 302 finds a real world value entry that closest matches the received image.
- the sensor 302 identifies and fetches an input correlithm object 104 in the sensor table 308 linked with the real world value entry.
- the sensor 302 sends the identified input correlithm object 104 to the node 304 .
- the identified input correlithm object 104 is represented in the sensor table 308 using a categorical binary integer string.
- the sensor 302 sends the binary string representing to the identified input correlithm object 104 to the node 304 .
- the node 304 receives the input correlithm object 104 and determines distances 106 between the input correlithm object 104 and each source correlithm object 104 in a node table 200 .
- the distance 106 between two correlithm objects 104 can be determined based on the differences between the bits of the two correlithm objects 104 .
- the distance 106 between two correlithm objects can be determined based on how many individual bits differ between a pair of correlithm objects 104 .
- the distance 106 between two correlithm objects 104 can be computed using Hamming distance or any other suitable technique.
- the distance 106 between two correlithm objects 104 can be determined using a Minkowski distance such as the Euclidean or “straight-line” distance between the correlithm objects 104 .
- the distance 106 between a pair of correlithm objects 104 may be determined by calculating the square root of the sum of squares of the coordinate difference in each dimension.
- the node 304 identifies a source correlithm object 104 from the node table 200 with the shortest distance 106 .
- a source correlithm object 104 with the shortest distance from the input correlithm object 104 is a correlithm object 104 either matches or most closely matches the received input correlithm object 104 .
- the node 304 identifies and fetches a target correlithm object 104 in the node table 200 linked with the source correlithm object 104 .
- the node 304 outputs the identified target correlithm object 104 to the actor 306 .
- the identified target correlithm object 104 is represented in the node table 200 using a categorical binary integer string.
- the node 304 sends the binary string representing to the identified target correlithm object 104 to the actor 306 .
- the actor 306 receives the target correlithm object 104 and determines distances between the target correlithm object 104 and each output correlithm object 104 in an actor table 310 .
- the actor 306 may compute the distances between the target correlithm object 104 and each output correlithm object 104 in an actor table 310 using a process similar to the process described in step 410 .
- the actor 306 identifies an output correlithm object 104 from the actor table 310 with the shortest distance 106 .
- An output correlithm object 104 with the shortest distance from the target correlithm object 104 is a correlithm object 104 either matches or most closely matches the received target correlithm object 104 .
- the actor 306 identifies and fetches a real world output value in the actor table 310 linked with the output correlithm object 104 .
- the real world output value may be any suitable type of data sample that corresponds with the original input signal.
- the real world output value may be text that indicates the name of the person in the image or some other identifier associated with the person in the image.
- the real world output value may be an audio signal or sample of the name of the person in the image.
- the real world output value may be any other suitable real world signal or value that corresponds with the original input signal.
- the real world output value may be in any suitable data type or format.
- the actor 306 outputs the identified real world output value.
- the actor 306 may output the real world output value in real-time to a peripheral device (e.g. a display or a speaker).
- the actor 306 may output the real world output value to a memory or database.
- the real world output value is sent to another sensor 302 .
- the real world output value may be sent to another sensor 302 as an input for another process.
- FIG. 5 is a schematic diagram of an embodiment a computer architecture 500 for emulating a correlithm object processing system 300 in a user device 100 .
- the computer architecture 500 comprises a processor 502 , a memory 504 , a network interface 506 , and an input-output (I/O) interface 508 .
- the computer architecture 500 may be configured as shown or in any other suitable configuration.
- the processor 502 comprises one or more processors operably coupled to the memory 504 .
- the processor 502 is any electronic circuitry including, but not limited to, state machines, one or more central processing unit (CPU) chips, logic units, cores (e.g. a multi-core processor), field-programmable gate array (FPGAs), application specific integrated circuits (ASICs), graphics processing units (GPUs), or digital signal processors (DSPs).
- the processor 502 may be a programmable logic device, a microcontroller, a microprocessor, or any suitable combination of the preceding.
- the processor 502 is communicatively coupled to and in signal communication with the memory 204 .
- the one or more processors are configured to process data and may be implemented in hardware or software.
- the processor 502 may be 8-bit, 16-bit, 32-bit, 64-bit or of any other suitable architecture.
- the processor 502 may include an arithmetic logic unit (ALU) for performing arithmetic and logic operations, processor registers that supply operands to the ALU and store the results of ALU operations, and a control unit that fetches instructions from memory and executes them by directing the coordinated operations of the ALU, registers and other components.
- ALU arithmetic logic unit
- the one or more processors are configured to implement various instructions.
- the one or more processors are configured to execute instructions to implement sensor engines 510 , node engines 512 , actor engines 514 and logic engines 515 that implement logic gates 600 , 800 , and 1000 .
- the sensor engines 510 , the node engines 512 , and the actor engines 514 are implemented using logic units, FPGAs, ASICs, DSPs, or any other suitable hardware.
- the sensor engines 510 , the node engines 512 , and the actor engines 514 are each configured to implement a specific set of rules or process that provides an improved technological result.
- the sensor engine 510 is configured to receive a real world value 320 as an input, to determine a correlithm object 104 based on the real world value 320 , and to output the correlithm object 104 . Examples of the sensor engine 510 in operation are described in FIG. 4 .
- the node engine 512 is configured to receive a correlithm object 104 (e.g. an input correlithm object 104 ), to determine another correlithm object 104 based on the received correlithm object 104 , and to output the identified correlithm object 104 (e.g. an output correlithm object 104 ).
- the node engine 512 is also configured to compute distances between pairs of correlithm objects 104 . Examples of the node engine 512 in operation are described in FIG. 4 .
- the actor engine 514 is configured to receive a correlithm object 104 (e.g. an output correlithm object 104 ), to determine a real world output value 326 based on the received correlithm object 104 , and to output the real world output value 326 . Examples of the actor engine 514 in operation are described in FIG. 4 .
- the memory 504 comprises one or more non-transitory disks, tape drives, or solid-state drives, and may be used as an over-flow data storage device, to store programs when such programs are selected for execution, and to store instructions and data that are read during program execution.
- the memory 504 may be volatile or non-volatile and may comprise read-only memory (ROM), random-access memory (RAM), ternary content-addressable memory (TCAM), dynamic random-access memory (DRAM), and static random-access memory (SRAM).
- the memory 504 is operable to store sensor instructions 516 , node instructions 518 , actor instructions 520 , sensor tables 308 , node tables 200 , actor tables 310 , truth tables 612 , 812 , and 1008 , and/or any other data or instructions.
- the sensor instructions 516 , the node instructions 518 , and the actor instructions 520 comprise any suitable set of instructions, logic, rules, or code operable to execute the sensor engine 510 , node engine 512 , and the actor engine 514 , respectively.
- the sensor tables 308 , the node tables 200 , and the actor tables 310 may be configured similar to the sensor tables 308 , the node tables 200 , and the actor tables 310 described in FIG. 3 , respectively.
- the network interface 506 is configured to enable wired and/or wireless communications.
- the network interface 506 is configured to communicate data with any other device or system.
- the network interface 506 may be configured for communication with a modem, a switch, a router, a bridge, a server, or a client.
- the processor 502 is configured to send and receive data using the network interface 506 .
- the I/O interface 508 may comprise ports, transmitters, receivers, transceivers, or any other devices for transmitting and/or receiving data with peripheral devices as would be appreciated by one of ordinary skill in the art upon viewing this disclosure.
- the I/O interface 508 may be configured to communicate data between the processor 502 and peripheral hardware such as a graphical user interface, a display, a mouse, a keyboard, a key pad, and a touch sensor (e.g. a touch screen).
- FIG. 6 illustrates one embodiment of a binary correlithm object logic function gate 600 that receives a first input correlithm object 602 and a second input correlithm object 604 , implements a particular logical operator 606 according to a context input correlithm object 608 (in one embodiment), and outputs an output correlithm object 610 .
- Binary correlithm object logic function gate 600 implements up to sixteen different logical operators 606 upon binary values represented by inputs correlithm objects 602 and 604 .
- the logical operators 606 are represented by correlithm objects in a truth table 612 , an example of which is illustrated in FIG. 6 .
- gate 600 outputs an output correlithm object 610 representing a logical “0” or “1”.
- the system will assign the same correlithm object for input 602 to represent a logical “0” as the correlithm object to represent a logical “0” in row 614 of the truth table 812 . Further, the system will assign the same correlithm object for input 602 to represent a logical “1” as the correlithm object to represent a logical “1” in row 614 of the truth table 812 . Similarly, the system will assign the same correlithm object for input 604 to represent a logical “0” as the correlithm object to represent a logical “0” in row 616 of the truth table 812 . Further, the system will assign the same correlithm object for input 604 to represent a logical “1” as the correlithm object to represent a logical “1” in row 616 of the truth table 812 .
- logic function gate 600 implements only the logical “Not AND (NAND)” function or, alternatively in one embodiment, assume that binary correlithm object logic function gate 600 implements a number of logical operators 606 and that context input correlithm object 608 represents a value that selects the “Not AND (NAND)” function.
- each of the logical operators 606 are represented by a different, corresponding correlithm object.
- the context input 608 is also represented by a correlithm object that is set to match the correlithm object of the logical operator 606 to be applied in a particular operation of logic function gate 600 .
- the context input 608 is represented by a correlithm object that is set to the same n-bit (e.g., 64-bit) word of binary values as the correlithm object that represents the NAND function logical operator 606 .
- the logic function gate 600 determines the distance in n-dimensional space between the correlithm object of the context input 608 and each of the correlithm objects representing the logical operators 606 .
- the logic function gate 600 selects for application whichever correlithm object representing a logical operator 606 is closest in n-dimensional space to the correlithm object of the context input 608 .
- the logic function gate 600 determines the Hamming distance between the correlithm object of the context input 608 and each of the correlithm objects representing the logical operators 606 , and selects the logical operator 606 based on which one has the smallest Hamming distance between its correlithm object and the correlithm object of the context input 608 .
- the correlithm object of the context input 608 is the closest in n-dimensional space to the correlithm object representing the NAND gate (e.g., has the smallest Hamming distance)
- the portion of the truth table 612 that corresponds to the NAND function e.g., ordered logical values c1, c1, c1, c0
- the logic function gate 600 determines (at least in part) the output 610 .
- first input correlithm object 602 is a 64-bit correlithm object that represents a logical “0”.
- input correlithm object 602 may comprise a unique 64-bit word of “1's” and “0's” that is assigned to represent a logical “0”.
- second input correlithm object 604 is a 64-bit correlithm object that represents a logical “0”.
- input correlithm object 604 may comprise a different unique 64-bit word of “1's” and “0's” that is also assigned to represent a logical “0”.
- Binary logic function gate 600 determines the Hamming distance (or otherwise determines the distance in n-dimensional space) between input correlithm object 602 and the correlithm objects in row 614 of the truth table 612 . Even if noise modifies some of the bits of the n-bit input correlithm object 602 and/or some of the bits of the n-bit correlithm objects representing the logical “0” and “1” values in row 614 of the truth table 612 , the Hamming distance between the input correlithm object 602 representing a logical “0” and the correlithm object representing logical “0's” in row 614 (shown in the cells where row 614 intersects columns 620 and 622 of the truth table 612 ) will be smaller than the Hamming distance between the input correlithm object 602 representing a logical “0” and the correlithm object representing logical “1's” in row 614 (shown in the cells where row 614 intersects columns 624 and 626 of the
- the smaller Hamming distance calculation means that the input correlithm object 602 is closer in n-dimensional space to the correlithm object representing logical “0's” in row 614 than to the correlithm object representing logical “1's” in row 614 .
- columns 620 and 622 are selected as matches for input correlithm object 602 based upon these Hamming distance calculations.
- Logic function gate 600 also determines the Hamming distance (or otherwise determines the distance in n-dimensional space) between input correlithm object 604 and the correlithm objects in row 616 of the truth table 612 . Even if noise modifies some of the bits of the n-bit input correlithm object 604 and some of the bits of the n-bit correlithm objects representing the logical “0” and “1” values in row 616 , the Hamming distance between the correlithm object input 604 representing a logical “0” and the correlithm object representing logical “0's” in row 616 (shown in the cells where row 616 intersects columns 620 and 624 of the truth table 612 ) will be smaller than the Hamming distance between the input correlithm object 604 representing a logical “0” and the correlithm object representing logical “1's” in row 616 (shown in the cells where row 616 intersects columns 622 and 626 of the truth table 612 ).
- the smaller Hamming distance calculation means that the input correlithm object 604 is closer in n-dimensional space to the correlithm object representing logical “0's” in row 616 than to the correlithm object representing logical “1's” in row 616 .
- columns 620 and 624 are selected as matches for correlithm object input 604 based upon these Hamming distance calculations.
- column 620 includes a logical “0” in row 614 which maps to the logical “0” represented by input 602
- column 620 further includes a logical “0” in row 616 which maps to the logical “0” represented by input 604 .
- Output correlithm object 610 may comprise a unique n-bit (e.g., 64-bit) word of 1's and 0's that is assigned to represent this resulting logical “1.”
- the logic function gate 600 can implement the logical operators 606 associated with truth table 612 using correlithm objects rather than traditional voltage values to represent logical “0's” and “1's.”
- any of the logical operators 606 illustrated in FIG. 6 can be implemented either by building a logic function gate 600 dedicated to that logical operator 606 , or by using a context input correlithm object 608 to identify a particular logical operator 606 in a multi-faceted logic function gate 600 .
- the bits of the n-bit input correlithm objects 602 or 604 would be affected by the noise. Or, perhaps a few of the bits of the n-bit correlithm object values in the truth table 612 would be affected by the noise. However, the remaining bits of the n-bit input correlithm objects 602 or 604 (or correlithm objects representing values in the truth table 612 ) would remain close enough to the core of the original input correlithm object 602 or 604 (or correlithm objects representing values in the truth table 612 ) to accurately represent the original logical value.
- the system upon calculating the Hamming distance between the input correlithm object 602 (or 604 ) with the correlithm objects representing logical “0's” or “1's” in row 614 (or row 616 ), the system would associate the input correlithm object 602 (or 604 ) with the correct values in the truth table 612 with a greater degree of likelihood than in conventional computer systems that experience a significant noise event. Similarly, a significant noise event would not significantly affect the output correlithm object 610 either. In particular, perhaps a few of the bits of the n-bit output correlithm object 610 would be affected by the noise.
- the remaining bits of the n-bit output correlithm object 610 would remain close enough to the core of the original output correlithm object 610 to accurately represent the original logical value of “1.”
- the implementation of a correlithm object logic function gate 600 improves the operation of the underlying electronic circuit or computer in comparison to conventional approaches of implementing logic gates.
- a different n-bit correlithm object is used to represent a logical “0” or logical “1” in input 602 than is used for input 604 .
- a different n-bit correlithm object is used to represent a logical “0” or logical “1” in output 610 than is used in either inputs 602 or 604 .
- the same correlithm object is used to represent the logical “0's” in columns 620 and 622 of row 614 ; and the same correlithm object is used to represent the logical “1's” in columns 624 and 626 of row 614 .
- the same correlithm object is used to represent the logical “0's” in columns 620 and 624 of row 616 ; and the same correlithm object is used to represent the logical “1's” in columns 622 and 626 of row 616 .
- FIG. 7 illustrates one embodiment of a flowchart 700 implementing a process performed by binary correlithm object logic function gate 600 which stores in memory a logical operator truth table 612 at step 702 .
- Logic function gate 600 receives a first input correlithm object 602 at step 704 and a second input correlithm object 604 and step 706 .
- Logic function gate 600 further receives a context input correlithm object 608 at step 708 .
- logic function gate 600 determines an n-dimensional distance (e.g., Hamming distance) between first input correlithm object 602 and the correlithm object representing logical “0's” in the first group of input values in truth table 612 , such as in the cells where row 614 and columns 620 and 622 intersect in truth table 612 illustrated in FIG. 6 .
- logic function gate 600 determines an n-dimensional distance (e.g., Hamming distance) between first input correlithm object 602 and the correlithm object representing logical “1's” in the first group of input values in truth table 612 , such as in the cells where row 614 and columns 624 and 626 intersect in truth table 612 illustrated in FIG. 6 .
- step 716 logic function gate 600 selects the logical “0” values, such as the cells where row 614 intersects columns 620 and 622 of truth table 612 .
- step 718 logic function gate 600 selects the logical “1” values, such as the cells where row 614 intersects columns 624 and 626 of truth table 612 .
- step 720 logic function gate 600 determines an n-dimensional distance (e.g., Hamming distance) between second input correlithm object 604 and the correlithm object representing logical “0's” in the second group of input values in truth table 612 , such as in the cells where row 616 and columns 620 and 624 intersect in truth table 612 illustrated in FIG. 6 .
- n-dimensional distance e.g., Hamming distance
- logic function gate 600 determines an n-dimensional distance (e.g., Hamming distance) between second input correlithm object 604 and the correlithm object representing logical “1's” in the second group of input values in truth table 612 , such as in the cells where row 616 and columns 622 and 626 intersect in truth table 612 illustrated in FIG. 6 .
- n-dimensional distance e.g., Hamming distance
- step 726 logic function gate 600 selects the logical “0” values, such as the cells where row 616 intersects columns 620 and 624 of truth table 612 .
- step 728 logic function gate 600 selects the logical “1” values, such as the cells where row 616 intersects columns 622 and 626 of truth table 612 .
- step 730 logic function gate 600 determines the n-dimensional distance (e.g., Hamming distance) between the context input correlithm object 608 and each correlithm object representing logical operators 606 in truth table 612 .
- logic function gate 600 selects the logical operator 606 with the closest n-dimensional distance (e.g., smallest Hamming distance) to the context input correlithm object 608 .
- step 734 logic function gate 600 determines output correlithm object 610 based on the logical “0's” or “1's” selected at steps 716 or 718 , the logical “0's” or “1's” selected at steps 726 or 728 , and the logical operator 606 selected at step 732 .
- logic function gate 600 determines an appropriate output correlithm object 610 from column 620 of truth table 612 based on the logical operator 606 that is selected at step 732 . If logical “1's” are selected at steps 718 and 728 , then logic function gate 600 determines an appropriate output correlithm object 610 from column 626 of truth table 612 based on the logical operator 606 that is selected at step 732 .
- logic function gate 600 determines an appropriate output correlithm object 610 from column 622 of truth table 612 based on the logical operator 606 that is selected at step 732 . If logical “1” is selected at step 718 and logical “0” is selected at step 726 , then logic function gate 600 determines an appropriate output correlithm object 610 from column 624 of truth table 612 based on the logical operator 606 that is selected at step 732 . Execution terminates at step 736 .
- FIG. 8 illustrates one embodiment of a unary correlithm object logic function gate 800 that receives an input correlithm object 802 , implements a particular logical operator 806 according to a context input correlithm object 808 (in one embodiment), and outputs an output correlithm object 810 .
- Unary correlithm object logic function gate 800 implements up to four different logical operators 806 upon binary values represented by input correlithm object 802 .
- the logical operators 806 are represented by correlithm objects in a truth table 812 , an example of which is illustrated in FIG. 8 .
- gate 800 outputs an output correlithm object 810 representing a logical “0” or “1”.
- the system will assign the same correlithm object for input 802 to represent a logical “0” as the correlithm object to represent a logical “0” in row 814 of the truth table 812 .
- the system will assign the same correlithm object for input 802 to represent a logical “1” as the correlithm object to represent a logical “1” in row 814 of the truth table 812 .
- logic function gate 800 The operation of logic function gate 800 is described below in conjunction with a particular example. In this example, assume that unary correlithm object logic function gate 800 implements only the logical “Equivalent” function or, alternatively in one embodiment, assume that unary correlithm object logic function gate 800 implements a number of logical operators 806 and that correlithm object context input 808 represents a value that selects the “Equivalent” logical operator.
- each of the logical operators 806 are represented by a different, corresponding correlithm object.
- the context input 808 is also represented by a correlithm object that is set to match the correlithm object of the logical operator 806 to be applied in a particular operation of logic function gate 800 .
- the context input 808 is represented by a correlithm object that is set to the same n-bit (e.g., 64-bit) word of binary values as the correlithm object that represents the Equivalent function logical operator 806 .
- the logic function gate 800 determines the distance in n-dimensional space between the correlithm object of the context input 808 and each of the correlithm objects representing the logical operators 806 .
- the logic function gate 800 selects for application whichever correlithm object representing a logical operator 806 is closest in n-dimensional space to the correlithm object of the context input 808 .
- the logic function gate 800 determines the Hamming distance between the correlithm object of the context input 808 and each of the correlithm objects representing the logical operators 806 , and selects the logical operator 806 based on which one has the smallest Hamming distance between its correlithm object and the correlithm object of the context input 808 .
- the correlithm object of the context input 808 is the closest in n-dimensional space to the correlithm object representing the NAND gate (e.g., has the smallest Hamming distance)
- the portion of the truth table 812 that corresponds to the NAND function e.g., ordered logical values c0, c1 is used by the logic function gate 800 in determining (at least in part) the output 810 .
- input correlithm object 802 is an n-bit (e.g., 64-bit) correlithm object that represents a logical “0”.
- input correlithm object 802 may comprise a unique n-bit (e.g., 64-bit) word of 1's and 0's that is assigned to represent a logical “0”.
- Logic function gate 800 determines the Hamming distance (or otherwise determines the distance in n-dimensional space) between correlithm object input 802 and the correlithm objects in row 814 of the truth table 812 .
- the Hamming distance between the input correlithm object 802 representing a logical “0” and the correlithm object representing a logical “0” in row 814 will be smaller than the Hamming distance between the correlithm object input 802 representing a logical “0” and the correlithm object representing a logical “1” in row 614 (shown in the cell where row 614 intersects column 818 of the truth table 812 ).
- the smaller Hamming distance calculation means that the correlithm object for input 802 is closer in n-dimensional space to the correlithm object representing a logical “0” in row 814 than to the correlithm object representing a logical “1” in row 814 .
- column 816 is selected as a match for correlithm object input 802 based upon these Hamming distance calculations.
- Output correlithm object 810 may comprise a unique n-bit (e.g., 64-bit) word of 1's and 0's that is assigned to represent this logical “0.” Conversely, if input correlithm object 802 had represented a logical “1,” then column 818 would have been selected based upon the Hamming distance calculations, and upon implementing the Equivalent function, the resulting binary value would be a logical “1”. Output correlithm object 810 may comprise a unique n-bit (e.g., 64-bit) word of 1's and 0's that is assigned to represent the logical “1” in this instance.
- n-bit e.g., 64-bit
- the logic function gate 800 can implement the logical operators associated with truth table 812 using correlithm objects rather than traditional voltage values to represent logical “0's” and “1's.”
- any of the logical operators 806 illustrated in FIG. 8 can be implemented either by building a logic function gate 800 dedicated to that logical operator 806 , or by using a context input 808 to identify a particular logical operator 806 in a multi-faceted logic function gate 800 .
- the bits of the n-bit correlithm object values in the truth table 812 would be affected by the noise. However, the remaining bits of the n-bit input correlithm object 802 (or correlithm objects representing values in the truth table 812 ) would remain close enough to the core of the original input correlithm object 802 (or correlithm objects representing values in the truth table 812 ) to accurately represent the original logical value.
- the system upon calculating the Hamming distance between the input correlithm object 802 with the correlithm objects representing logical “0's” or “1's” in row 814 , the system would associate the input correlithm object 802 with the correct values in the truth table 812 with a greater degree of likelihood than in conventional computer systems that experience a significant noise event. Similarly, a significant noise event would not significantly affect the output correlithm object 810 either. In particular, perhaps a few of the bits of the n-bit output correlithm object 810 would be affected by noise.
- n-bit output correlithm object 810 would remain close enough to the core of the output original correlithm object 810 to accurately represent the original logical value of “1.”
- the implementation of a correlithm object logic function gate 800 improves the operation of the underlying electronic circuit or computer in comparison to conventional approaches of implementing logic gates.
- a different n-bit correlithm object is used to represent a logical “0” or logical “1” in output 810 than is used in either input 802 .
- FIG. 9 illustrates one embodiment of a flowchart 900 implementing a process performed by unary logic function gate 800 which stores in memory a logical operator truth table 812 at step 902 .
- Logic function gate 800 receives an input correlithm object 802 at step 804 and a context input correlithm object 808 at step 906 .
- logic function gate 800 determines an n-dimensional distance (e.g., Hamming distance) between input correlithm object 802 and the correlithm object representing a logical “0” in the input values of truth table 812 , such as in the cell where row 814 and column 816 intersects in truth table 812 illustrated in FIG. 8 .
- n-dimensional distance e.g., Hamming distance
- logic function gate 800 determines an n-dimensional distance (e.g., Hamming distance) between input correlithm object 802 and the correlithm object representing a logical “1” in the input values of truth table 612 , such as in the cell where row 814 and column 818 intersects in truth table 812 illustrated in FIG. 6 .
- n-dimensional distance e.g., Hamming distance
- n-dimensional distance between input correlithm object 802 and the correlithm object representing a logical “0” is closer than the n-dimensional distance between input correlithm object 802 and the correlithm object representing a logical “1,” (e.g., smaller Hamming distance) as determined at step 912 .
- execution proceeds to step 914 .
- execution proceeds to step 916 .
- logic function gate 800 selects the logical “0” value, such as the cell where row 814 intersects column 816 of truth table 812 .
- logic function gate 800 selects the logical “1” value, such as the cell where row 814 intersects column 818 of truth table 812 .
- step 918 logic function gate 800 determines the n-dimensional distance (e.g., Hamming distance) between the context input correlithm object 808 and each correlithm object representing logical operators 806 in truth table 812 .
- logic function gate 800 selects the logical operator 806 with the closest n-dimensional distance (e.g., smallest Hamming distance) to the context input correlithm object 808 .
- step 922 logic function gate 800 determines output correlithm object 810 based on the logical “0” or “1” selected at steps 914 or 916 , and the logical operator 806 selected at step 920 .
- logic function gate 800 determines an appropriate output correlithm object 810 from column 816 of truth table 812 based on the logical operator 806 that is selected at step 920 . If a logical “1” is selected at step 916 , then logic function gate 800 determines an appropriate output correlithm object 810 from column 818 of truth table 812 based on the logical operator 806 that is selected at step 920 . Execution terminates at step 924 .
- FIG. 10 illustrates one embodiment of a binary correlithm object flip-flop device 1000 that receives a state input correlithm object 1002 and a set/reset correlithm object 1004 , and outputs an output correlithm object 1006 , which is returned as feedback to device 1000 as state input correlithm object 1002 .
- Device 1000 implements a truth table 1008 that has two stable states and can be used to store state information for device 1000 .
- the binary values that are input into device 1000 and their relationship in n-dimensional space to the logical values stored in truth table 1008
- device 1000 outputs output correlithm object 1006 representing a logical state (e.g., logical “0” or logical “1”).
- the system will assign the same correlithm object for input 1002 to represent a logical “0” as the correlithm object to represent a logical “0” in row 1010 of the truth table 1008 . Further, the system will assign the same correlithm object for input 1002 to represent a logical “1” as the correlithm object to represent a logical “1” in row 1010 of the truth table 1008 . Similarly, the system will assign the same correlithm object for input 1004 to represent a logical “0” as the correlithm object to represent a logical “0” in row 1012 of the truth table 1008 . Further, the system will assign the same correlithm object for input 1004 to represent a logical “1” as the correlithm object to represent a logical “1” in row 1012 of the truth table 1008 .
- Each of the correlithm objects described in conjunction with device 1000 are n-bit digital words comprising binary values.
- the set/reset input correlithm object 1004 and the corresponding correlithm objects in row 1012 of the truth table 1008 are larger n-bit digital words than the state input correlithm object 1002 and the corresponding correlithm objects in row 1010 of truth table 1008 .
- the set/reset input correlithm object 1004 and the corresponding correlithm objects in row 1012 of the truth table 1008 are 128-bit digital words whereas the state input correlithm object 1002 and the corresponding correlithm objects in row 1010 of truth table 1008 are 64-bit digital words.
- the device 1000 allocates more weight to the logical value of the set/reset input correlithm object 1004 than the logical value of state input correlithm object 1002 when determining the appropriate state of device 1000 , as described in detail below.
- binary correlithm object flip-flop device 1000 receives both the state input correlithm object 1002 and the set/reset input correlithm object 1004 .
- Device 1000 determines the distance in n-dimensional space between the state input correlithm object 1002 (representing logical “1” in this example) and the correlithm object representing a logical “0” in row 1010 of the truth table 1008 .
- this distance in n-dimensional space is represented by determining a Hamming distance 1020 between the binary values of state input correlithm object 1002 and the binary values of the correlithm object representing a logical “0” in row 1010 of the truth table 1008 .
- Device 1000 determines a Hamming distance 1022 between state input correlithm object 1002 (representing logical “1” in this example) and the correlithm object representing a logical “1” in row 1010 of the truth table 1008 .
- state of the device 1000 as represented by state input correlithm object 1002 is a logical “0,” then the Hamming distance 1020 between it and the correlithm object representing a logical “0” in row 1010 of the truth table 1008 will be very small, trending to zero depending on how much noise has altered the binary values of either the state input correlithm object 1002 and/or the correlithm object representing a logical “0” in row 1010 of the truth table 1008 .
- the Hamming distance 1022 between it and the correlithm object representing a logical “1” in row 1010 of the truth table 1008 will be large, trending to “n” for an n-bit correlithm object 1002 (e.g., Hamming distance 1022 trends to 64 for a 64-bit correlithm object 1002 ). If the state of the device 1000 as represented by state input correlithm object 1002 is a logical “1,” (as it is in this particular example) then the Hamming distance calculations 1020 and 1022 will be reversed.
- the Hamming distance 1020 between state input correlithm object 1002 (representing logical “1” in this example) and the correlithm object representing a logical “0” in row 1010 of the truth table 1008 will trend toward “n” for an n-bit correlithm object 1002 ; and the Hamming distance 1022 between state input correlithm object 1002 (representing logical “1” in this example) and the correlithm object representing a logical “1” in row 1010 of the truth table 1008 will trend toward zero depending on the amount of noise, as described above.
- Device 1000 also determines the Hamming distance 1024 between the set/reset input correlithm object 1004 and the correlithm object representing a logical “0” in row 1012 of the truth table 1008 ; and the Hamming distance 1026 between set/reset input correlithm object 1004 and the correlithm object representing a logical “1” in row 1012 of the truth table 1008 .
- set/reset input correlithm object 1004 represents a logical “0,” (as it is in this particular example), then the Hamming distance 1024 between it and the correlithm object representing a logical “0” in row 1012 of the truth table 1008 will be very small, trending to zero depending on how much noise has altered the binary values of either the set/reset input correlithm object 1004 and/or the correlithm object representing a logical “0” in row 1012 of the truth table 1008 .
- the Hamming distance 1026 between it and the correlithm object representing a logical “1” in row 1012 of the truth table 1008 will be large, trending to “n” for an n-bit correlithm object 1002 (e.g., Hamming distance 1026 will be trending to 128 for a 128-bit correlithm object 1004 ).
- the Hamming distances 1020 and 1024 between the correlithm objects 1002 and 1004 and their corresponding correlithm objects representing logical “0's” in truth table 1008 , respectively, are added together; and the Hamming distances 1022 and 1026 between the correlithm objects 1002 and 1004 and their corresponding correlithm objects representing logical “1's” in truth table 1008 , respectively, are also added together.
- the output correlithm object 1006 is set to represent a logical “0” if the addition of the Hamming distances 1020 and 1024 for the logical “0” values is less than the addition of the Hamming distances 1022 and 1026 for the logical “1” values.
- the output correlithm object 1006 is set to represent a logical “1” if the addition of the Hamming distances 1022 and 1026 for the logical “1” values is less than the addition of the Hamming distances 1020 and 1024 for the logical “0” values.
- the Hamming distance 1020 trended to 64
- the Hamming distance 1022 trended to zero
- the Hamming distance 1024 trended to zero
- the Hamming distance 1026 trended to 128.
- output correlithm object 1006 is set to a logical “0” value. In this way, the state of the device 1000 was flipped from a logical “1” value to a logical “0” value.
- set/reset input correlithm object 1004 is a larger n-bit digital word than state input correlithm object 1002 (e.g., 128-bit versus 64-bit)
- device 1000 effectively gives more weight to the Hamming distances 1024 and 1026 for reset input correlithm object 1004 than the Hamming distances 1020 and 1022 for the state input correlithm object 1002 .
- the Hamming distance 1026 between the set/reset input correlithm object 1004 (representing logical “0” in this example) and the correlithm object representing logical “1” in row 1012 of truth table 1008 is 128, whereas the Hamming distance 1020 between the state input correlithm object 1002 (representing logical “1” in this example) and the correlithm object representing logical “0” in row 1010 of truth table 1008 is 64.
- device 1000 is permitted to change states.
- the correlithm object output 1006 representing a logical “0” is fed back to device 1000 as state input correlithm object 1002 .
- set/reset input correlithm object 1004 still represents a logical “0” value.
- the state input correlithm object 1002 now representing a logical “0” instead of the previous logical “1,” the Hamming distance 1020 trends to zero and the Hamming distance 1022 trends to 64.
- the Hamming distance 1024 remains trending to zero and the Hamming distance 1026 remains trending to 128.
- the correlithm object output 1006 remains a logical “0” value. In effect, the state of device 1000 has latched to a logical “0” value.
- the state of the device 1000 will change to a logical “1” value.
- the state input correlithm object 1002 still representing a logical “0”
- the Hamming distance 1020 trends to zero and the Hamming distance 1022 trends to 64.
- the Hamming distance 1024 now trends to 128 and the Hamming distance 1026 now trends to zero.
- the output correlithm object 1006 changes to a logical “1” value.
- the correlithm object output 1006 representing a logical “1” is fed back to device 1000 as state input correlithm object 1002 .
- set/reset input correlithm object 1004 still represents a logical “1” value.
- the state input correlithm object 1002 now representing a logical “1” instead of the previous logical “0,” the Hamming distance 1020 trends to 64 and the Hamming distance 1022 trends to zero.
- the Hamming distance 1024 remains trending to 128 and the Hamming distance 1026 remains trending to zero.
- the correlithm object output 1006 remains a logical “1” value. In effect, the state of device 1000 has latched to a logical “1” value.
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- Software Systems (AREA)
- General Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- Mathematical Physics (AREA)
- Databases & Information Systems (AREA)
- Data Mining & Analysis (AREA)
- Artificial Intelligence (AREA)
- Evolutionary Computation (AREA)
- Computing Systems (AREA)
- Computer Vision & Pattern Recognition (AREA)
- Medical Informatics (AREA)
- Probability & Statistics with Applications (AREA)
- Pure & Applied Mathematics (AREA)
- Algebra (AREA)
- Computational Linguistics (AREA)
- Image Analysis (AREA)
Abstract
Description
In this example, the Hamming distance is equal to one because only one bit differs between the
The Hamming distance is equal to ten because all of the bits are different between the
Claims (20)
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US15/783,470 US10355713B2 (en) | 2017-10-13 | 2017-10-13 | Computer architecture for emulating a correlithm object logic gate using a context input |
Applications Claiming Priority (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US15/783,470 US10355713B2 (en) | 2017-10-13 | 2017-10-13 | Computer architecture for emulating a correlithm object logic gate using a context input |
Publications (2)
Publication Number | Publication Date |
---|---|
US20190115936A1 US20190115936A1 (en) | 2019-04-18 |
US10355713B2 true US10355713B2 (en) | 2019-07-16 |
Family
ID=66097140
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US15/783,470 Active 2038-02-03 US10355713B2 (en) | 2017-10-13 | 2017-10-13 | Computer architecture for emulating a correlithm object logic gate using a context input |
Country Status (1)
Country | Link |
---|---|
US (1) | US10355713B2 (en) |
Citations (10)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5946673A (en) | 1996-07-12 | 1999-08-31 | Francone; Frank D. | Computer implemented machine learning and control system |
US6167391A (en) * | 1998-03-19 | 2000-12-26 | Lawrence Technologies, Llc | Architecture for corob based computing system |
US6941287B1 (en) | 1999-04-30 | 2005-09-06 | E. I. Du Pont De Nemours And Company | Distributed hierarchical evolutionary modeling and visualization of empirical data |
US6943686B2 (en) | 2001-12-06 | 2005-09-13 | Robert Allen | Adjustable alarm device for sliding doors and windows |
US6947913B1 (en) * | 2001-08-23 | 2005-09-20 | Lawrence Technologies, Llc | Systems and methods for generating string correlithm objects |
US7015835B2 (en) | 2004-03-17 | 2006-03-21 | Lawrence Technologies, Llc | Imposing and recovering correlithm objects in conjunction with table lookup |
US7031969B2 (en) | 2002-02-20 | 2006-04-18 | Lawrence Technologies, Llc | System and method for identifying relationships between database records |
US7031897B1 (en) * | 1999-09-24 | 2006-04-18 | Intrinsity, Inc. | Software modeling of logic signals capable of holding more than two values |
US7130784B2 (en) * | 2001-08-29 | 2006-10-31 | Intel Corporation | Logic simulation |
US7310622B2 (en) | 2002-08-13 | 2007-12-18 | Lawrence Technologies, Llc | Representing and manipulating correlithm objects using quantum objects |
-
2017
- 2017-10-13 US US15/783,470 patent/US10355713B2/en active Active
Patent Citations (12)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5946673A (en) | 1996-07-12 | 1999-08-31 | Francone; Frank D. | Computer implemented machine learning and control system |
US6167391A (en) * | 1998-03-19 | 2000-12-26 | Lawrence Technologies, Llc | Architecture for corob based computing system |
US6941287B1 (en) | 1999-04-30 | 2005-09-06 | E. I. Du Pont De Nemours And Company | Distributed hierarchical evolutionary modeling and visualization of empirical data |
US7031897B1 (en) * | 1999-09-24 | 2006-04-18 | Intrinsity, Inc. | Software modeling of logic signals capable of holding more than two values |
US6947913B1 (en) * | 2001-08-23 | 2005-09-20 | Lawrence Technologies, Llc | Systems and methods for generating string correlithm objects |
US7130784B2 (en) * | 2001-08-29 | 2006-10-31 | Intel Corporation | Logic simulation |
US6943686B2 (en) | 2001-12-06 | 2005-09-13 | Robert Allen | Adjustable alarm device for sliding doors and windows |
US7031969B2 (en) | 2002-02-20 | 2006-04-18 | Lawrence Technologies, Llc | System and method for identifying relationships between database records |
US7246129B2 (en) | 2002-02-20 | 2007-07-17 | Lawrence P Nick | System and method for identifying relationships between database records |
US7349928B2 (en) | 2002-02-20 | 2008-03-25 | Syngence Corporation | System and method for identifying relationships between database records |
US7310622B2 (en) | 2002-08-13 | 2007-12-18 | Lawrence Technologies, Llc | Representing and manipulating correlithm objects using quantum objects |
US7015835B2 (en) | 2004-03-17 | 2006-03-21 | Lawrence Technologies, Llc | Imposing and recovering correlithm objects in conjunction with table lookup |
Non-Patent Citations (5)
Title |
---|
Lawrence, P. N., "Computer Architecture for Emulating a Binary Correlithm Object Flip Flop," U.S. Appl. No. 15/783,572, filed Oct. 13, 2017, 63 pages. |
Lawrence, P. N., "Computer Architecture for Emulating a Binary Correlithm Object Logic Gate," U.S. Appl. No. 15/783,785, filed Oct. 13, 2017, 64 pages. |
Lawrence, P. N., "Computer Architecture for Emulating a Unary Correlithm Object Logic Gate," U.S. Appl. No. 15/783,738, filed Oct. 13, 2017, 62 pages. |
Lawrence, P. N., Correlithm Object Technology, Apr. 2004, 229 pages. |
Meersman, R. et al., "On the Move to Meaningful Internet Systems 2005: CooplS, DOA and ODBASE," OTM Confederated International Conferences CooplS, DOA and ODBASE Oct. 2005 Agia Napa, Cyprus, Proceedings, Part I, Oct. 31-Nov. 4, 2005, pp. 763-779. |
Also Published As
Publication number | Publication date |
---|---|
US20190115936A1 (en) | 2019-04-18 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US10460009B2 (en) | Computer architecture for emulating an image output adapter for a correlithm object processing system | |
US10467499B2 (en) | Computer architecture for emulating an output adapter for a correlithm object processing system | |
US10366141B2 (en) | Computer architecture for emulating n-dimensional workspaces in a correlithm object processing system | |
US10380221B2 (en) | Computer architecture for emulating a correlithm object processing system | |
US10409885B2 (en) | Computer architecture for emulating a distance measuring device for a correlithm object processing system | |
US10783298B2 (en) | Computer architecture for emulating a binary correlithm object logic gate | |
US10810028B2 (en) | Computer architecture for detecting members of correlithm object cores in a correlithm object processing system | |
US10762397B1 (en) | Computer architecture for emulating image mapping in a correlithm object processing system | |
US10481930B1 (en) | Computer architecture for emulating a foveal mechanism in a correlithm object processing system | |
US11347969B2 (en) | Computer architecture for training a node in a correlithm object processing system | |
US10355713B2 (en) | Computer architecture for emulating a correlithm object logic gate using a context input | |
US10599795B2 (en) | Computer architecture for emulating a binary correlithm object flip flop | |
US10783297B2 (en) | Computer architecture for emulating a unary correlithm object logic gate | |
US10896052B2 (en) | Computer architecture for emulating a correlithm object processing system that uses portions of a mapping table in a distributed node network | |
US10915341B2 (en) | Computer architecture for processing correlithm objects using a selective context input | |
US10922109B2 (en) | Computer architecture for emulating a node in a correlithm object processing system | |
US11113630B2 (en) | Computer architecture for training a correlithm object processing system | |
US10719339B2 (en) | Computer architecture for emulating a quantizer in a correlithm object processing system | |
US10915337B2 (en) | Computer architecture for emulating correlithm object cores in a correlithm object processing system | |
US10824452B2 (en) | Computer architecture for emulating adjustable correlithm object cores in a correlithm object processing system | |
US10810026B2 (en) | Computer architecture for emulating drift-away string correlithm objects in a correlithm object processing system | |
US10789081B2 (en) | Computer architecture for emulating drift-between string correlithm objects in a correlithm object processing system | |
US10990424B2 (en) | Computer architecture for emulating a node in conjunction with stimulus conditions in a correlithm object processing system | |
US10380082B2 (en) | Computer architecture for emulating an image input adapter for a correlithm object processing system | |
US20190294453A1 (en) | Computer architecture for emulating a correlithm object processing system that places portions of correlithm objects and portions of a mapping table in a distributed node network |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: BANK OF AMERICA CORPORATION, NORTH CAROLINA Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:LAWRENCE, PATRICK N.;REEL/FRAME:043861/0502 Effective date: 20171013 |
|
FEPP | Fee payment procedure |
Free format text: ENTITY STATUS SET TO UNDISCOUNTED (ORIGINAL EVENT CODE: BIG.); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY |
|
STPP | Information on status: patent application and granting procedure in general |
Free format text: NOTICE OF ALLOWANCE MAILED -- APPLICATION RECEIVED IN OFFICE OF PUBLICATIONS |
|
STPP | Information on status: patent application and granting procedure in general |
Free format text: PUBLICATIONS -- ISSUE FEE PAYMENT VERIFIED |
|
STCF | Information on status: patent grant |
Free format text: PATENTED CASE |
|
MAFP | Maintenance fee payment |
Free format text: PAYMENT OF MAINTENANCE FEE, 4TH YEAR, LARGE ENTITY (ORIGINAL EVENT CODE: M1551); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY Year of fee payment: 4 |