Comment by throwaway13qf85 | Hacker News Reader

Comment by throwaway13qf85 | Hacker News Reader

throwaway13qf85

In case anyone is turned off by the expectation of wishy-washy flim-flam, it's worth noting that Graham Priest may be a professor of philosophy, but is most well known for his work in logic, particularly in non-standard logics (i.e. not propositional or predicate logic) that allow non-boolean truth values, or weaken or remove some of the axioms of classical logic.

I assume that what's relevant here will be his work on paraconsistent logics (which allow contradictions) but I think an equally interesting line of work is linear logics. It's of interest to computer scientists because of its relationship to linear type theory (in the same way that the Curry-Howard correspondence links type theory and classical logic) and because it has close relationships with quantum computing.

In particular, you are not allowed to delete or duplicate elements/propositions/types (corresponding to physical processes that cannot arbitrarily create or destroy particles, the "no deletion theorem" and "no cloning theorem" of quantum information theory), so functions of the type

  duplicate :: a -> (a, a)

and

  delete :: a -> ()

are not allowed in a linear type system. Practically, this means that many operations can be optimized by the compiler to in-place mutations, because it is guaranteed that there is only ever one reference to a particular object.

Fuzzy logic is a vary useful non boolean logic system. http://en.wikipedia.org/wiki/Fuzzy_logic In practice it's somewhat like neural net's but in a far more human readable format and vary useful for things like washing machines that have lot's of flakey sensors and little processing power. But the basic idea is statements truth is percentage based. For example "this statement is true" would be 50% true and there is no contradiction.

PS: Yet another 1960's discovery that keeps being renamed and rediscovered.

One of the interesting properties of fuzzy logic is that you can model boolean logic as a special case.

That seems like Bayesian inference, which goes back farther.

There would still be a contradiction if the sentence did not say "This sentence is 50% true."

Do you have personal, real-world examples of fuzzy logic being useful to you? I find Bayesian statistics useful regularly; fuzzy logic not so much. What am I missing?

The tradeoff between accuracy and speed. Real world devices ofen have tight feedback loops and flakey sensors so you need something that aproximates Bayesian logic without being bogged down.

The only real world example I have Persionaly used was a controller for a hacked together hot tub, the basic problem was generally adapting a simple program concept to both limited processing power and flakey data. You want to write if temperature is > value instead you go if 70% sensors in area x say temperature > value. You could try to find a better aproximation but the more you calculate the longer it is until you can process more data. We also had ~380 bytes of RAM and 2000 bytes for sorce code so things needed to be simple.

Sure, you could try and find the actual energy in the hot tub water but that's not needed, you really just want to know if the heater is on for to long with the pump off then shutdown for safety otherwise shutdown if temperature is probably to hot.

Don't immutable data structures give us most of the benefits? Clojure, for example, approaches this by preferring values over hidden, mutable state (e.g. classes). We see libraries like Om take advantage of the fact that comparing two complex structures (e.g. a hash map) is simply a reference equality test.

http://clojure.org/state

http://swannodette.github.io/2013/12/17/the-future-of-javasc...

Immutable data structures give us many benefits, but linear types promise most of those plus safe mutability. Think of it as a compile-time proof that you'll be getting vector fusion style speed-ups.

Not at all. Linear types ensure that types are "used" exactly once. Mutability would correspond to type creation while reading would be a use.

For a fun little example of thinking in linear types, take a look at Brent Yorgey's blog post: http://byorgey.wordpress.com/2011/02/24/enumerating-linear-i...

(Edit: The Yorgey post listed links to the whole cycle, but it begins here: http://byorgey.wordpress.com/2011/01/26/counting-linear-lamb...)

Clojure transients are linear types.

How? Please refute this claim: "Transients have very little, if anything, to do with types."

Why would I claim this? Transients are about the internal nature of a function but have nothing to do with the return value or type. See "Transient data structures are a solution to this optimization problem that integrates with the Clojure model and provides the same thread safety guarantees you expect of Clojure." at http://clojure.org/transients

Transients are a different type from the corresponding persistent, as seen by the fact that different operations are supported. Clojure's programmer-facing type system doesn't expose the transient type explicitly, but the semantics certainly implements a linear type system.

From the page you linked:

"""

Capture return value, use for next call

Not persistent, so you can't hang onto interim values or alias

"""

From Rich Hickey himself: http://www.infoq.com/interviews/hickey-clojure-protocols

More context: http://c2.com/cgi/wiki?LinearTypes

Reply on news.ycombinator.com