juan_gandhi: (Default)

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


Mar. 6th, 2017 12:46 pm
juan_gandhi: (Default)
Dunning-Kruger with Math.

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!


Same with logic, by the way.
juan_gandhi: (VP)
My students, well, kind of half-failed, unfortunately.

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)
juan_gandhi: (VP)

  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. It's not Boolean.
juan_gandhi: (VP)
Why t.f. are they all called sets, in the casual speak? Could be as well lists, right? We know what a list is. Nowhere in logic anybody applies comprehension or foundation or choice axioms to the "sets of formulas"; they also don't have to be infinite. If they are, we need to specify, what kind of infinity.
juan_gandhi: (VP)
I started talking about topos logic at BACAT, so here are slides, which are, mostly, just a plan of my next talk. References: Johnstone, TT.


(sorry, sharing was not set properly; fixed)


Dec. 4th, 2013 04:36 pm
juan_gandhi: (VP)
Just posted slides from my logic lectures; notified twitter.

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

Here's my account: http://www.slideshare.net/VladPatryshev
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=0BwRrcixvqFQgTHdYMTZnVzBhSWM&usp=sharing
juan_gandhi: (VP)
I don't believe there's much meaning in it, but I post them here: http://www.meetup.com/COEN260/about/


juan_gandhi: (Default)

October 2017

1 2 3 45 6 7
8 910 11 12 13 14
15 16 17 18 19 20 21


RSS Atom

Most Popular Tags

Style Credit

Expand Cut Tags

No cut tags
Page generated Oct. 22nd, 2017 06:27 am
Powered by Dreamwidth Studios