CushionTheBlow (구 BluemoonSoft)

In logic, a logical connective, also called a truth-functional connective, logical operator or propositional operator, is a logical constant which represents a syntactic operation on well-formed formulas. The formula that results from applying a logical connective to well-formed formulas is a well-formed formula itself. If a logical connective is applied to sentences then the result is a compound sentence, and the truth-value of the resulting compound sentence is determined uniquely by the truth-values of the sentences to which it was applied. Consequently, a logical connective can be seen as a function which maps the truth-values of the sentences to which it is applied to either true or false.

Introduction
The basic logical operators are:

Negation (not) (¬ or ~)
Conjunction (and) (∧ or &)
Disjunction (or) (∨)
Material implication (if...then) (->, => or ⊃)
Biconditional (if and only if) (<->, ≡, or =)

Some others are:

Exclusive disjunction (xor) (<->/)
Joint denial (nor) (↓)
Alternative denial (nand) (↑)
Material nonimplication (->/)
Converse nonimplication (<-/)
Converse implication (<-)
Tautology (T)
Contradiction (⊥)

For example, the statements it is raining and I am indoors can be reformed using various different connectives to form sentences that relate the two in ways which augment their meaning:

It is raining and I am indoors.
If it is raining then I am indoors.
It is raining if I am indoors.
It is raining if and only if I am indoors.
It is not raining.

If we write 'P' for It is raining and 'Q' for I am indoors and we use the usual symbols for logical connectives, then the above examples could be represented in symbols, respectively:

P & Q
P -> Q
Q -> P
P <-> Q
¬P

Reference:
http://en.wikipedia.org/wiki/Logical_connective

A deductive system (also called a deductive apparatus of a formal system) consists of the axioms (or axiom schemata) and rules of inference that can be used to derive (prove) the theorems of the system.

Such a deductive system is intended to preserve deductive qualities in the formulas that are expressed in the system. Usually the quality we are concerned with is truth as opposed to falsehood. However, other modalities, such as justification or belief may be preserved instead.

In order to sustain its deductive integrity, a deductive apparatus must be definable without reference to any intended interpretation of the language. The aim is to ensure that each line of a derivation is merely a syntactic consequence of the lines that precede it. There should be no element of any interpretation of the language that gets involved with the deductive nature of the system.

Reference:
http://en.wikipedia.org/wiki/Deductive_system

In number theory, Levy's conjecture states that all odd integers greater than 5 can be represented as the sum of an odd prime number and an even semiprime. To put it algebraically, 2n + 1 = p + 2q always has a solution in primes p and q (not necessarily distinct) for n > 2. The Levy conjecture is similar to but stronger than Goldbach's weak conjecture.

For example, 47 = 13 + 2 × 17 = 37 + 2 × 5 = 41 + 2 × 3 = 43 + 2 × 2. (sequence A046927 in OEIS) counts how many different ways 2n + 1 can be represented as p + 2q.

According to MathWorld, the conjecture has been checked for all odd positive integers less than 10^9.

Reference:
http://en.wikipedia.org/wiki/Levy%27s_conjecture

In mathematics, a semiprime (also called biprime or 2-almost prime, or pq number) is a natural number that is the product of two (not necessarily distinct) prime numbers. The first few semiprimes are 4, 6, 9, 10, 14, 15, 21, 22, 25, 26, ... (sequence A001358 in OEIS).

As of 2007, the largest known semiprime is (2^32,582,657 − 1)^2, which has over 19 million digits. This is the square of the largest known prime. The square of any prime number is a semiprime, so the largest known semiprime will always be the square of the largest known prime, unless the factors of the semiprime are not known. It is conceivable that somebody could find a way to prove a larger number is a semiprime without knowing the two factors, but so far that has only happened for smaller semiprimes.

The value of Euler's totient function for a semiprime n = pq is particularly simple when p and q are distinct:

φ(n) = n + 1 − (p + q).

Reference:
http://en.wikipedia.org/wiki/Semiprime

Induction or inductive reasoning, sometimes called inductive logic, is the process of reasoning in which the premises of an argument are believed to support the conclusion but do not entail it; i.e. they do not ensure its truth. Induction is a form of reasoning that makes generalizations based on individual instances. It is used to ascribe properties or relations to types based on tokens (i.e., on a number of observations or experiences); or to formulate laws based on limited observations of recurring phenomenal patterns. Induction is employed, for example, in using specific propositions such as:

This ice is cold.
A billiard ball moves when struck with a cue.

...to infer general propositions such as:

All ice is cold.
All billiard balls move when struck with a cue.

Inductive reasoning has been attacked several times. Historically, David Hume denied its logical admissibility. During the twentieth century, thinkers such as Karl Popper and David Miller have disputed the existence, necessity and validity of any inductive reasoning, including probabilistic (Bayesian) reasoning.

Note that Mathematical induction is not a form of inductive reasoning. Mathematical induction is a form of deductive reasoning.

Reference:
http://en.wikipedia.org/wiki/Inductive_reasoning

"Survival of the fittest" is a phrase which is shorthand for a concept relating to competition for survival or predominance. Originally applied by Herbert Spencer in his Principles of Biology of 1864, Spencer drew parallels to his ideas of economics with Charles Darwin's theories of evolution by what Darwin termed natural selection.

Although Darwin used the phrase "survival of the fittest" as a synonym for "natural selection", it is a metaphor, not a scientific description. It is not generally used by modern biologists, who use the phrase "natural selection" almost exclusively.

An interpretation of the phrase to mean "only the fittest organisms will prevail" (a view common in social Darwinism) is not consistent with the actual theory of evolution. Any organism which is capable of reproducing itself on an ongoing basis will survive as a species, not just the "fittest" ones. A more accurate characterization of evolution would be "survival of the fit enough", although this is sometimes regarded as a tautology.

Reference:
http://en.wikipedia.org/wiki/Survival_of_the_fittest

In computer operating systems, a light-weight process (LWP) is a means of achieving multitasking. In contrast to a regular (full-blown) process, an LWP shares all (or most of) its logical address space and system resources with other process(es); in contrast to a thread, a light-weight process has its own private process identifier and parenthood relationships with other processes. Moreover, while a thread can either be managed at the application level or by the kernel, an LWP is always managed by the kernel and it is scheduled as a regular process. One significant example of a kernel that supports LWPs is the Linux kernel.

On most systems, a light-weight process also differs from a full-blown process, in that it only consists of the bare minimum execution context and accounting information that is needed by the scheduler, hence the term light-weight. Generally, a process refers to an instance of a program, while an LWP represents a thread of execution of a program (indeed, LWPs can be conveniently used to implement threads, if the underlying kernel does not directly support them). Since a thread of execution does not need as much state information as a process, a light-weight process does not carry such information.

As a consequence of the fact that LWPs share most of their resources with other LWPs, they are unsuitable for certain applications, where multiple full-blown processes are needed, e.g. to avoid memory leaks (a process can be replaced by another one) or to achieve privilege separation (processes can run under other credentials and have other permissions). Using multiple processes also allows the application to more easily survive if a process of the pool crashes or is exploited.

Reference:
http://en.wikipedia.org/wiki/Light-weight_process

A semaphore, in computer science, is a protected variable (an entity storing a value) or abstract data type (an entity grouping several variables that may or may not be numerical) which constitutes the classic method for restricting access to shared resources, such as shared memory, in a multiprogramming environment (a system where several programs may be executing, or taking turns to execute, at once). Semaphores exist in many variants, though usually the term refers to a counting semaphore, since a binary semaphore is better known as a mutex. A counting semaphore is a counter for a set of available resources, rather than a locked/unlocked flag of a single resource. It was invented by Edsger Dijkstra and first used in the THE operating system.

Semaphores are the classic solution to preventing race conditions in the dining philosophers problem, although they do not prevent resource deadlocks.

Reference:
http://en.wikipedia.org/wiki/Semaphore_%28programming%29

Mutual exclusion (often abbreviated to mutex) algorithms are used in concurrent programming to avoid the simultaneous use of a common resource, such as a global variable, by pieces of computer code called critical sections.

Examples of such resources are fine-grained flags, counters or queues, used to communicate between code that runs concurrently, such as an application and its interrupt handlers. The problem is acute because a thread can be stopped or started at any time.

To illustrate: suppose a section of code is altering a piece of data over several program steps, when another thread, perhaps triggered by some unpredictable event, starts executing. If this second thread reads from the same piece of data, the data, in the process of being overwritten, is in an inconsistent and unpredictable state. If the second thread tries overwriting that data, the ensuing state will probably be unrecoverable. These critical sections of code accessing shared data must therefore be protected, so that other processes which read from or write to the chunk of data are excluded from running.

A mutex is also a common name for a program object that negotiates mutual exclusion among threads, also called a lock.

Reference:
http://en.wikipedia.org/wiki/Mutual_exclusion

In computer programming, a callback is executable code that is passed as an argument to other code. It allows a lower-level software layer to call a subroutine (or function) defined in a higher-level layer.

Usually, the higher-level code starts by calling a function within the lower-level code passing to it a pointer or handle to another function. While the lower-level function executes, it may call the passed-in function any number of times to perform some subtask. In another scenario, the lower-level function registers the passed-in function as a handler that is to be called asynchronously by the lower-level at a later time in reaction to something.

A callback can be used as a simpler alternative to polymorphism and generic programming, in that the exact behavior of a function can be dynamically determined by passing different (yet compatible) function pointers or handles to the lower-level function. This can be a very powerful technique for code reuse.

Reference:
http://en.wikipedia.org/wiki/Callback_%28computer_science%29