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:
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:
juan_gandhi: (VP)
I don't believe there's much meaning in it, but I post them here:


juan_gandhi: (Default)

August 2017

   1 23 4 5
6 7 8 9 10 11 12
13 14 15 16 1718 19
20 21 2223242526


RSS Atom

Most Popular Tags

Style Credit

Expand Cut Tags

No cut tags
Page generated Aug. 23rd, 2017 06:19 am
Powered by Dreamwidth Studios