### found something to read

Oct. 14th, 2017 11:51 amWeak monadic second-order logic (quantification over finite collections of domain objects) - "good for computing".

You're viewing juan_gandhi's journalCreate a Dreamwidth Account Learn More | light | Reload page in style:

Weak monadic second-order logic (quantification over finite collections of domain objects) - "good for computing".

Just occurred to me. Reducing facts of real life to math entities is a kind of Dunning-Kruger disease. You can't get the complexity and all the aspects, but math you know, so kaboom - a monad! a linear space! a probability! a derivative! an integral!

Sad.

Same with logic, by the way.

1. What is the domain of the function ln(x)?

2.Give answers to the following questions (yes/no) with short explanations

- Is the set {(0,0)} a binary relation on ℕ?

- Define an operation on sets like this: A Op B = {{A}, {B}}. Do we have a commutative monoid?

- Take the set {1,2,7} and define an operation like this: x Op y = x. Is it a monoid?

3. Is implication operation, P→Q, associative? Commutative? Does it have a neutral element?

4. Simplify the following WFF: C ∨ (A→B) ∨ (B→A) ∨ C

5. Convert the following WFF to DNF: (A∨B)∧(C∨¬B)∧(¬A∨C)

implicit class StreamOfResults[T](source: Stream[Result[T]]) { def |>[U](op: T ⇒ Result[U]) = source map (t ⇒ t flatMap op) def filter(p: T ⇒ Outcome) = source |> (x => p(x) andThen Good(x)) def map[U](f: T ⇒ U) = source map (_ map f) }

implicit class StreamOfResults[T](source: Stream[Result[T]]) { def |>[U](op: T ⇒ Result[U]) = source map (t ⇒ t flatMap op) def filter(p: T ⇒ Result[_]) = source |> (x ⇒ p(x) returning x) def map[U](f: T ⇒ U) = source map (_ map f) }

E.g. use case:

// this method could be written in a couple of lines, but it's better to keep the details def streamOfNewEobSelectors(): StreamOfResults[Element] = { // this function pairs an html element with its content def withContent(e: Element): Result[(Element, String)] = e.outerHtml() map ((e, _)) // here we have a stream of elements paired with their content val pairs: StreamOfResults[(Element, String)] = streamOfEobElements |> withContent // here we filter the stream, leaving only the elements containing new stuff // note that the stuff we don't need is not kicked out, it's labeled as bad with an explanation val newOnes: StreamOfResults[(Element, String)]] = pairs filter (p => isNewClaim(p._2)) // here we forget the html newOnes map {case p:(Element, String) => p._1} }

Note that

`filter`

does not take a `boolean`

, it takes an `Outcome`

, which is a logical value, from the logic that I'm trying to work on. (toposes lurking behind the scene)

https://docs.google.com/presentation/d/

(sorry, sharing was not set properly; fixed)

Kaboom, 1000+ views within a couple of hours. Omfg.

Here's my account: http://www.slideshare.net/

Where are the lectures there - you tell me (if you can't find them (if you want to see them))

Comments welcome.

Here's actually a link to Google docs: https://drive.google.com/folderview?id=

- found something to read
- Godel, Einstein, Morgenstern
- DKM
- something new
- want a quiz?
- from the desk of brilliant paula bean
- got my slides
- ever heard of Snm theorem?
- set of types, set of formulas
- building types from scratch
- just found
- slides for logic of toposes (part 2)
- slideshare
- talking about my slides
- contravariance by example

- Style: Neutral Good for Practicality by

No cut tags