|
26
|
|
edited Nov 17 2009 at 1:46 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
A calculus that is very efficient from both conceptual and computational standpoints is based on just two types of logical connectives, both of variable $k$-ary scope. The formulas of this calculus parse into a family of graph-theoretical data structures whose underlying graphs are called "painted and rooted cacti" (PARCs). Hence the name "cactus language" for this style of propositional calculus, in either its traversal string or parse graph forms.
The first kind of propositional expression is a parenthesized sequence of propositional expressions, written as $⦗ ~ e_1 ﹐ e_2 ﹐ \ldots ﹐ e_{k-1} ﹐ e_k ~ ⦘$ and read to say that exactly one of the propositions $e_1, e_2, \ldots, e_{k-1}, e_k$ is false, in other words, that their minimal negation is true. A clause of this form maps into a PARC structure called a lobe, in this case, one that is painted with the colors $e_1, e_2, \ldots, e_{k-1}, e_k$ as shown below.
The second kind of propositional expression is a concatenated sequence of propositional expressions, written as $e_1 ~ e_2 ~ \ldots ~ e_{k-1} ~ e_k$ and read to say that all of the propositions $e_1, e_2, \ldots, e_{k-1}, e_k$ are true, in other words, that their logical conjunction is true. A clause of this form maps into a PARC structure called a node, in this case, one that is painted with the colors $e_1, e_2, \ldots, e_{k-1}, e_k$ as shown below.
All other propositional connectives can be obtained through combinations of these two forms. Strictly speaking, the parenthesized form is sufficient to define the concatenated form, making the latter formally dispensable, but it is convenient to maintain it as a concise way of expressing more complicated combinations of parenthesized forms. While working with expressions solely in propositional calculus, it is easiest to use plain parentheses for logical connectives. In contexts where ordinary parentheses are needed for other purposes an alternate typeface — for example, $⦗ ~ ﹐ ~ ⦘$ — may be used for logical operators.
See above links for further details.
|
|
|
|
|
25
|
|
edited Nov 12 2009 at 4:56 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
A calculus that is very efficient from both conceptual and computational standpoints is based on just two types of logical connectives, both of variable $k$-ary scope. The formulas of this calculus parse into a family of graph-theoretical data structures whose underlying graphs are called "painted and rooted cacti" (PARCs). Hence the name "cactus language" for this style of propositional calculus, in either its traversal string or parse graph forms.
The first kind of propositional expression is a parenthesized sequence of propositional expressions, written as $⦗ ~ e_1 ﹐ e_2 ﹐ \ldots ﹐ e_{k-1} ﹐ e_k ~ ⦘$ and read to say that exactly one of the propositions $e_1, e_2, \ldots, e_{k-1}, e_k$ is false, in other words, that their minimal negation is true. A clause of this form maps into a PARC structure called a lobe, in this case, one that is painted with the colors $e_1, e_2, \ldots, e_{k-1}, e_k$ as shown below.
The second kind of propositional expression is a concatenated sequence of propositional expressions, written as $e_1 ~ e_2 ~ \ldots ~ e_{k-1} ~ e_k$ and read to say that all of the propositions $e_1, e_2, \ldots, e_{k-1}, e_k$ are true, in other words, that their logical conjunction is true. A clause of this form maps into a PARC structure called a node, in this case, one that is painted with the colors $e_1, e_2, \ldots, e_{k-1}, e_k$ as shown below.
All other propositional connectives can be obtained through combinations of these two forms. Strictly speaking, the parenthesized form is sufficient to define the concatenated form, making the latter formally dispensable, but it is convenient to maintain it as a concise way of expressing more complicated combinations of parenthesized forms. While working with expressions solely in propositional calculus, it is easiest to use plain parentheses for logical connectives. In contexts where ordinary parentheses are needed for other purposes an alternate typeface — for example, $⦗ ~ ﹐ ~ ⦘$ — may be used for logical operators.
Table 1 collects a sample of basic propositional forms as expressed in terms of cactus connectives.
…
Temporary work area
See above links for testing and scaling images …further details.
|
|
|
|
|
24
|
|
edited Nov 12 2009 at 4:51 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
A calculus that is very efficient from both conceptual and computational standpoints is based on just two types of logical connectives, both of variable $k$-ary scope. The formulas of this calculus parse into a family of graph-theoretical data structures whose underlying graphs are called "painted and rooted cacti" (PARCs). Hence the name "cactus language" for this style of propositional calculus, in either its traversal string or parse graph forms.
The first kind of propositional expression is a parenthesized sequence of propositional expressions, written as $⦗ ~ e_1 ﹐ e_2 ﹐ \ldots ﹐ e_{k-1} ﹐ e_k ~ ⦘$ and read to say that exactly one of the propositions $e_1, e_2, \ldots, e_{k-1}, e_k$ is false, in other words, that their minimal negation is true. A clause of this form maps into a PARC structure called a lobe, in this case, one that is painted with the colors $e_1, e_2, \ldots, e_{k-1}, e_k$ as shown below.
![Cactus Graph Lobe Connective][3]
The second kind of propositional expression is a concatenated sequence of propositional expressions, written as $e_1 ~ e_2 ~ \ldots ~ e_{k-1} ~ e_k$ and read to say that all of the propositions $e_1, e_2, \ldots, e_{k-1}, e_k$ are true, in other words, that their logical conjunction is true. A clause of this form maps into a PARC structure called a node, in this case, one that is painted with the colors $e_1, e_2, \ldots, e_{k-1}, e_k$ as shown below.
![Cactus Graph Node Connective][4]
All other propositional connectives can be obtained through combinations of these two forms. Strictly speaking, the parenthesized form is sufficient to define the concatenated form, making the latter formally dispensable, but it is convenient to maintain it as a concise way of expressing more complicated combinations of parenthesized forms. While working with expressions solely in propositional calculus, it is easiest to use plain parentheses for logical connectives. In contexts where ordinary parentheses are needed for other purposes an alternate typeface — for example, $⦗ ~ ﹐ ~ ⦘$ — may be used for logical operators.
See above links for further details
Table 1 collects a sample of basic propositional forms as expressed in terms of cactus connectives.
…
Temporary work area for testing and scaling images …
   
|
|
|
|
23
|
|
edited Nov 12 2009 at 4:50 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
A calculus that is very efficient from both conceptual and computational standpoints is based on just two types of logical connectives, both of variable $k$-ary scope. The formulas of this calculus parse into a family of graph-theoretical data structures whose underlying graphs are called "painted and rooted cacti" (PARCs). Hence the name "cactus language" for this style of propositional calculus, in either its traversal string or parse graph forms.
The first kind of propositional expression is a parenthesized sequence of propositional expressions, written as $⦗ ~ e_1 ﹐ e_2 ﹐ \ldots ﹐ e_{k-1} ﹐ e_k ~ ⦘$ and read to say that exactly one of the propositions $e_1, e_2, \ldots, e_{k-1}, e_k$ is false, in other words, that their minimal negation is true. A clause of this form maps into a PARC structure called a lobe, in this case, one that is painted with the colors $e_1, e_2, \ldots, e_{k-1}, e_k$ as shown below.
![Cactus Graph Lobe Connective][3] The second kind of propositional expression is a concatenated sequence of propositional expressions, written as $e_1 ~ e_2 ~ \ldots ~ e_{k-1} ~ e_k$ and read to say that all of the propositions $e_1, e_2, \ldots, e_{k-1}, e_k$ are true, in other words, that their logical conjunction is true. A clause of this form maps into a PARC structure called a node, in this case, one that is painted with the colors $e_1, e_2, \ldots, e_{k-1}, e_k$ as shown below.
![Cactus Graph Node Connective][4]
All other propositional connectives can be obtained through combinations of these two forms. Strictly speaking, the parenthesized form is sufficient to define the concatenated form, making the latter formally dispensable, but it is convenient to maintain it as a concise way of expressing more complicated combinations of parenthesized forms. While working with expressions solely in propositional calculus, it is easiest to use plain parentheses for logical connectives. In contexts where ordinary parentheses are needed for other purposes an alternate typeface — for example, $⦗ ~ ﹐ ~ ⦘$ — may be used for logical operators.
Table 1 collects a sample of basic propositional forms as expressed in terms of cactus connectives.
…
Temporary work area
See above links for testing and scaling images …further details.
|
|
|
|
|
22
|
|
edited Nov 12 2009 at 3:52 |
::: temporary work area for testing images All other propositional connectives can be obtained through combinations of these two forms. Strictly speaking, latexthe parenthesized form is sufficient to define the concatenated form, unicode … $making the latter formally dispensable, but it is convenient to maintain it as a concise way of expressing more complicated combinations of parenthesized forms. While working with expressions solely in propositional calculus, it is easiest to use plain parentheses for logical connectives. In contexts where ordinary parentheses are needed for other purposes an alternate typeface — for example, $⦗ ~ x ﹐ y ﹐ z ~ ⦘$$ $$\nu_k (x_1, \ldots, x_k)$$ $$\nu_k (x_1, \ldots, x_k) \quad \iff \quad x_j = 0 ~ \text{for exactly one}~ j \⦘$ — may be used for logical operators. Table 1 collects a sample of basic propositional forms as expressed in [1, k]$$terms of cactus connectives. … Temporary work area for testing and scaling images …
|
|
|
|
|
21
|
|
edited Nov 12 2009 at 2:22 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
A calculus that is very efficient from both conceptual and computational standpoints is based on just two types of logical connectives, both of variable $k$-ary scope. The formulas of this calculus parse into a family of graph-theoretical data structures whose underlying graphs are called "painted and rooted cacti" (PARCs). Hence the name "cactus language" for this style of propositional calculus, in either its traversal string or parse graph forms.
- The first kind of propositional expression is a parenthesized sequence of propositional expressions, written as $⦗ ~ e_1 ﹐ e_2 ﹐ \ldots ﹐ e_{k-1} ﹐ e_k ~ ⦘$ and read to say that exactly one of the propositions $e_1, e_2, \ldots, e_{k-1}, e_k$ is false, in other words, that their minimal negation is true. A clause of this form maps into a PARC structure called a lobe, in this case, one that is painted with the colors $e_1, e_2, \ldots, e_{k-1}, e_k$ as shown below.
- The second kind of propositional expression is a concatenated sequence of propositional expressions, written as $e_1 ~ e_2 ~ \ldots ~ e_{k-1} ~ e_k$ and read to say that all of the propositions $e_1, e_2, \ldots, e_{k-1}, e_k$ are true, in other words, that their logical conjunction is true. A clause of this form maps into a PARC structure called a node, in this case, one that is painted with the colors $e_1, e_2, \ldots, e_{k-1}, e_k$ as shown below.
:::
temporary work area for testing images, latex, unicode —…
$$⦗x﹐y﹐z⦘$$$⦗ ~ x ﹐ y ﹐ z ~ ⦘$$
$$\nu_k (x_1, \ldots, x_k)$$
$$\nu_k (x_1, \ldots, x_k) \quad \iff \quad x_j = 0 ~\text{for exactly one}~ j \in [1, k]$$
|
|
|
|
|
20
|
|
edited Nov 12 2009 at 2:06 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
A calculus that is very efficient from both conceptual and computational standpoints is based on just two types of logical connectives, both of variable $k$-ary scope. The formulas of this calculus parse into a family of graph-theoretical data structures whose underlying graphs are called "painted and rooted cacti" (PARCs). Hence the name "cactus language" for this style of propositional calculus, in either its traversal string or parse graph forms.
- The first kind of propositional expression is a parenthesized sequence of propositional expressions, written as $⦗ ~ e_1 ﹐ e_2 ﹐ \ldots ﹐ e_{k-1} ﹐ e_k ~ ⦘$ and read to say that exactly one of the propositions $e_1, e_2, \ldots, e_{k-1}, e_k$ is false, in other words, that their minimal negation is true. A clause of this form maps into a PARC structure called a lobe, in this case, one that is painted with the colors $e_1, e_2, \ldots, e_{k-1}, e_k$ as shown below.
temporary work area for testing images, latexand , unicode —
$$⦗x﹐y﹐z⦘$$
$$\nu_k (x_1, \ldots, x_k)$$
$$\nu_k (x_1, \ldots, x_k) \quad \iff \quad x_j = 0 ~\text{for exactly one}~ j \in [1, k]$$
|
|
|
|
|
19
|
|
edited Nov 12 2009 at 1:45 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
A calculus that is very efficient from both conceptual and computational standpoints is based on just two types of logical connectives, both of variable $k$-ary scope. The formulas of this calculus parse into a family of graph-theoretical data structures whose underlying graphs are called "painted and rooted cacti" (PARCs). Hence the name "cactus language" for this style of propositional calculus, in either its traversal string or parse graph forms.
temporary work area for testing latex and unicode —
$$⦗x﹐y﹐z⦘$$
$$\nu_k (x_1, \ldots, x_k)$$
$$\nu_k (x_1, \ldots, x_k) \quad \iff \quad x_j = 0 ~\text{for exactly one}~ j \in [1, k]$$
|
|
|
|
|
18
|
|
edited Nov 11 2009 at 22:54 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
temporary work area for testing latex and unicode —
$$⦗x﹐y﹐z⦘$$
$$\nu_k (x_1, \ldots, x_k)$$
$$\nu_k (x_1, \ldots, x_k) \quad \iff \quad x_j = 0 ~\text{for exactly one}~ j \in [1, k]$$
|
|
|
|
|
17
|
|
edited Nov 11 2009 at 22:52 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
A calculus that is very efficient from both conceptual and computational standpoints is based on just two types of logical connectives, both of variable $k$-ary scope. The formulas of this calculus parse into a family of graph-theoretical data structures whose underlying graphs are called "painted and rooted cacti" (PARCs). Hence the name "cactus language" for this style of propositional calculus, in either its traversal string or parse graph forms.
temporary work area for testing latex and unicode —
$$⦗x﹐y﹐z⦘$$
$$\nu_k (x_1, \ldots, x_k)$$
$$\nu_k (x_1, \ldots, x_k) \quad \iff \quad x_j = 0 ~\text{for exactly one}~ j \in [1, k]$$
|
|
|
|
|
16
|
|
edited Nov 11 2009 at 22:00 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
A calculus that is very efficient from both conceptual and computational standpoints is based on just two types of logical connectives, both of variable $k$-ary scope. The formulas of this calculus parse into a family of graph-theoretical data structures whose underlying graphs are called "painted and rooted cacti" (PARCs). Hence the name "cactus language" for this style of propositional calculus, in either its traversal string or parse graph forms.
temporary work area for testing images, latex , and unicode …—
$$⦗x﹐y﹐z⦘$$
$$\nu_k (x_1, \ldots, x_k)$$
$$\nu_k (x_1, \ldots, x_k) \quad \iff \quad x_j = 0 ~\text{for exactly one}~ j \in [1, k]$$
|
|
|
|
|
15
|
|
edited Nov 11 2009 at 20:34 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
A calculus that is very efficient from both conceptual and computational standpoints is based on just two types of logical connectives, both of variable $k$-ary scope. The formulas of this calculus parse into a family of graph-theoretical data structures whose underlying graphs are called "painted and rooted cacti" (PARCs). Hence the name "cactus language" for this style of propositional calculus, in either its traversal string or parse graph forms.
temporary work area for testing images, latex, unicode …
$$⦗e 1﹐e 2﹐…﹐e k−1﹐e k⦘$$$⦗x﹐y﹐z⦘$$
$$\nu_k (x_1, \ldots, x_k)$$
$$\nu_k (x_1, \ldots, x_k) \quad \iff \quad x_j = 0 ~\text{for exactly one}~ j \in [1, k]$$
|
|
|
|
|
14
|
|
edited Nov 11 2009 at 20:28 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
A calculus that is very efficient from both conceptual and computational standpoints is based on just two types of logical connectives, both of variable $k$-ary scope. The formulas of this calculus parse into a family of graph-theoretical data structures whose underlying graphs are called "painted and rooted cacti" (PARCs). Hence the name "cactus language" for this style of propositional calculus, in either its traversal string or parse graph forms.
temporary work area for testing images, latex, unicode …
$$⦗x﹐y﹐z⦘$$$⦗e 1﹐e 2﹐…﹐e k−1﹐e k⦘$$
$$\nu_k (x_1, \ldots, x_k)$$
$$\nu_k (x_1, \ldots, x_k) \quad \iff \quad x_j = 0 ~\text{for exactly one}~ j \in [1, k]$$
|
|
|
|
|
13
|
|
edited Nov 11 2009 at 20:21 |
|
|
|
|
|
|
12
|
|
edited Nov 11 2009 at 20:16 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
A calculus that is very efficient from both conceptual and computational standpoints is based on just two types of logical connectives, both of variable $k$-ary scope. The formulas of this calculus parse into a family of graph-theoretical data structures whose underlying graphs are called "painted and rooted cacti" (PARCs). Hence the name "cactus language" for this style of propositional calculus, in either its traversal string or parse graph forms.
temporary work area for testing images, latex, unicode …
![Cactus Graph Lobe Connective][3]
![Cactus Graph Node Connective][4]
$$⦗x﹐y﹐z⦘$$
$$\nu_k (x_1, \ldots, x_k)$$
$$\nu_k (x_1, \ldots, x_k) \quad \iff \quad x_j = 0 ~\text{for exactly one}~ j \in [1, k]$$
|
|
|
|
|
11
|
|
edited Nov 11 2009 at 19:58 |
|
|
|
|
|
|
10
|
|
edited Nov 11 2009 at 19:52 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
A calculus that is very efficient from both conceptual and computational standpoints is based on just two types of logical connectives, both of variable $k$-ary scope. The formulas of this calculus parse into a family of graph-theoretical data structures whose underlying graphs are called "painted and rooted cacti" (PARCs). Hence the name "cactus language" for this style of propositional calculus, in either its traversal string or parse graph forms.
temporary work area for testing images, latex, unicode …
![Cactus Graph Lobe Connective][3]
![Cactus Graph Node Connective][4]
$$⦗x﹐y﹐z⦘$$
$$\nu_k (x_1, \ldots, x_k)$$
$$\nu_k (x_1, \ldots, x_k) \quad \iff \quad x_j = 0 ~\text{for exactly one}~ j \in [1, k]$$
|
|
|
|
|
9
|
|
edited Nov 11 2009 at 19:30 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
A calculus that is very efficient from both conceptual and computational standpoints is based on just two types of logical connectives, both of variable $k$-ary scope. The formulas of this calculus parse into a family of graph-theoretical data structures whose underlying graphs are called "painted and rooted cacti" (PARCs). Hence the name "cactus language" for this style of propositional calculus, in either its traversal string or parse graph forms.
temporary work area for testing images, latexand , unicode —…
$$⦗x﹐y﹐z⦘$$
$$\nu_k (x_1, \ldots, x_k)$$
$$\nu_k (x_1, \ldots, x_k) \quad \iff \quad x_j = 0 ~\text{for exactly one}~ j \in [1, k]$$
|
|
|
|
|
8
|
|
edited Nov 11 2009 at 17:38 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
A calculus that is very efficient from both conceptual and computational standpoints is based on just two types of logical connectives, both of variable $k$-ary scope. The formulas of this calculus parse into a family of graph-theoretical data structures whose underlying graphs are called "painted and rooted cacti" (PARCs). Hence the name "cactus language" for this style of propositional calculus, in either its traversal string or parse graph forms.
temporary work area for testing latex and unicode —
$$⦗x﹐y﹐z⦘$$
$$\nu_k (x_1, \ldots, x_k)$$
$$\nu_k (x_1, \ldots, x_k) \quad \iff \quad x_j = 0 ~\text{for exactly one}~ j \in [1, k]$$
|
|
|
|
|
7
|
|
edited Nov 11 2009 at 15:48 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
temporary work area for testing latex and unicode —
$$⦗x﹐y﹐z⦘$$
$$\nu_k(x_1, $\nu_k (x_1, \dots, ldots, x_k)$$
$$\nu_{k}(x_{1},\ldots, x_{k})$$
$$\nu_k(x_1,\dots,x_k)$$
$$\nu_k(x_1,\dots,x_k) $\nu_k (x_1, \ldots, x_k) \quad \iff \quad x_j = 0 ~\text{for exactly one}~ j \in [1, k].$$
$$\nu_k(x_1,\dots,x_k) \quad \iff \quad x_j = 0 \:\text{for exactly one}\: j \in [1, k].$$
$$\nu_k(x_1,\dots,x_k) \iff x_j = 0 \:\mbox{for exactly one}\: j \in [1, k].$$k]$$
|
|
|
|
|
6
|
|
edited Nov 11 2009 at 15:42 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
temporary work area for testing latex and unicode —
code =
![$$\nu\sb k (x\sb 1,
$$⦗x﹐y﹐z⦘$$
$$\nu_k(x_1, \ldots, x\sb k) = 1 dots, x_k)$$
$$\nu_{k}(x_{1},\ldots, x_{k})$$
$$\nu_k(x_1,\dots,x_k)$$
$$\nu_k(x_1,\dots,x_k) \quad \iff \quad x\sb j x_j = 0 \; \text{for ~\text{for exactly one} \; one}~ j \in [1, k].$$](http://latex.mathoverflow.net/png?%24%24%5Cnu%5Fk%20%28x%5F1%2C%20%5Cldots%2C%20x%5Fk%29%20%3D%201%20%5Cquad%20%5Ciff%20%5Cquad%20x%5Fj%20%3D%200%20%5C%3B%20%5Ctext%7Bfor%20exactly%20one%7D%20%5C%3B%20j%20%5Cin%20%5B1%2C%20k%5D%2E%24%24%0A)
result k].$$
$$\nu_k(x_1,\dots,x_k) \quad \iff \quad x_j =
![$$\nu\sb k (x\sb 1, \ldots, x\sb k) = 1 \quad \iff \quad x\sb j = 0 \; \text{for exactly one} \; j \in [1, k].$$](http://latex.mathoverflow.net/png?%24%24%5Cnu%5Fk%20%28x%5F1%2C%20%5Cldots%2C%20x%5Fk%29%20%3D%201%20%5Cquad%20%5Ciff%20%5Cquad%20x%5Fj%20%3D%200%20%5C%3B%20%5Ctext%7Bfor%20exactly%20one%7D%20%5C%3B%20j%20%5Cin%20%5B1%2C%20k%5D%2E%24%24%0A)
This displays okay 0 \:\text{for exactly one}\: j \in the latex sidebar, but fails at [1, k].$$
$$\nu_k(x_1,\dots,x_k) \sb here.
Oh, it's only the math preview that fails.
code =
result iff x_j =
This displays okay 0 \:\mbox{for exactly one}\: j \in the latex sidebar, but doesn't show up here.
code =
result =1, k].$$
|
|
|
|
|
5
|
|
edited Nov 11 2009 at 14:45 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
temporary work area for testing latex and unicode —
code =
![$$\nu\sb k (x\sb 1, \ldots, x\sb k) = 1 \quad \iff \quad x\sb j = 0 \; \text{for exactly one} \; j \in [1, k].$$](http://latex.mathoverflow.net/png?%24%24%5Cnu%5Fk%20%28x%5F1%2C%20%5Cldots%2C%20x%5Fk%29%20%3D%201%20%5Cquad%20%5Ciff%20%5Cquad%20x%5Fj%20%3D%200%20%5C%3B%20%5Ctext%7Bfor%20exactly%20one%7D%20%5C%3B%20j%20%5Cin%20%5B1%2C%20k%5D%2E%24%24%0A)
result =
This displays okay in the latex sidebar, but fails at \sb here.
Oh, it's only the math preview that fails.
code =
result →
this =
This displays okay in the latex sidebar, but doesn't show up here???.
code =
result →=
|
|
|
|
|
4
|
|
edited Nov 11 2009 at 14:32 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
temporary work area for testing latex and unicode —
code = 
result →
this displays okay in the latex sidebar, but doesn't show up here ???
code = 
result →
|
|
|
|
|
3
|
|
edited Nov 11 2009 at 14:20 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
temporary work area for testing latex and unicode —
code = 
result →
not showing
this displays okay in the latex sidebar, but doesn't show up here ???
|
|
|
|
|
2
|
|
edited Nov 11 2009 at 14:10 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
temporary work area for testing latex and unicode —
 →
not showing up
|
|
|
|
|
1
|
|
answered Nov 11 2009 at 4:40 |
I doubt if there's anything like the best of all possible formal languages for boolean expressions, but there are many ways of coming up with calculi that are more efficient than most of the ones currently in common use.
You might enjoy exploring the possibilities of using minimal negation operators as the fundamental primitives of a propositional calculus.
|
|
|
