Hacker News Reader

Comment by ukj | Hacker News Reader

There are different kinds of "equality", beyond the one you are invoking: https://ncatlab.org/nlab/show/equality#DifferentKinds

The most obvious example of A != A being true I can think of is the evaluation of this expression in any programming language:

   Time.now == Time.now

View on HN

I think you just made an equivocation as those Time.now’s are not the same

  A = Time.now
  A != Time.now
  A == A

Just because Time.now looks like the same symbol it is not as it is an impure function that never returns the same result.

We are not talking about the same computation. What you think I mean is [1]. What I actually mean is [2].

  [1] pry(main)> eval("a != a")
  NameError: undefined local variable or method `a' for main:Object from (pry):1:in `eval'
  [2] pry(main)> eval("Time.now != Time.now")
  => true

I am not assigning the function to a variable - I am lazy-evaluating it.

It's not equivocation because [2] is expressed exactly the same way in English. Now is not now. It is trivially true.

When I use a word, Humpty Dumpty said in rather a scornful tone, it means just what I choose it to mean — neither more nor less

I disagree, because in both programming languages and in natural language, "now" is not a constant: it's a function that returns a different value depending on when it's called.

While the syntax is "now", what you're really saying is now(Ti) for some i.

So the sentence, in both natural language and most programming languages becomes:

    now(T0) != now(T1)

Which is easier to understand, with all arguments made explicit.

Now, some "clever" programming language might automatically translate this from

    now != now

    a := now(T0)
    a != a

Which will be surprising to the programmer in most cases (but might be what's desired in others).

The important thing is that "now" is not a comstant, but a function.

Yes! "Now" is not a constant. It's a function. It's a function that takes no arguments. It's also a function that can be lazy-evaluated.

  f() != f()
  A != A

You seem to be agreeing with me but your response to me starts with the English phrase "I disagree".

I disagree, that's the thing: "now" is a function that takes one implicit argument: time.

So "now" is a trickery to hide the fact you're really saying "now(Ti)", for varying i.

I'm not tripping over syntax, but I think you are:

You think you're saying

    A != A

When you're really saying

    A1 != A2

(Or rather

    now(t0) != now(t1)

)

And of course the second form is unsurprising.

You are talking about a different function.

The function I am talking about doesn't take any arguments.

    [1] pry(main)> Time.now(1)
    ArgumentError: wrong number of arguments (given 1, expected 0)

It doesn't take an explicit argument, but time is definitely an implicit argument of your function; how else do you think the function is implemented?

We are talking about function declaration not implementation, right?

The expression A = A can be trivially re-written in another notation as equal(A,A). The reason you don't question the implementation of the equal() function is because it's declared as being true however it's implemented.

So, I declare f() != f() as being true. I also declare that f() takes no arguments. All I am doing is translating (transpiling?) English into Ruby.

"Now is not now" => "Time.now != Time.now"

Talking about function arguments is not even in point. What's the argument to now() in English?

> All I am doing is translating (transpiling?) English into Ruby.

Incorrectly.

> "Now is not now" => "Time.now != Time.now"

Sure, “Now (pointedly looks at watch) is not now (pointedly looks at watch)” is true, and the equivalent of the Ruby. Ruby expressions lack the implicit simultaneity that English sentences wthout some contextual signal of explicit time dependency have, and your mistranslation ignores this.

Where is the "explicit simultinaity" in looking at your watch twice?

The English and Ruby terms map 1:1.

Now(Time.now) is not(!=) Now (Time.now)

Why do you call the correct "incorrect"?

> Where is the "explicit simultinaity" in looking at your watch twice?

Nowhere; that's the contextual signal that defeats the implicit simultaneity the English sentence would have without that body language.

So you looked at your watch twice at the same time?

The English sentence "Now is not Now" describes my thought process (1st person view), not my body language (3rd person view).

My thought process occurs over time. Exactly like the Ruby process.

> The function I am talking about doesn't take any arguments.

All impure functions have an implicit dependency on (some subset of) the state of the universe when they execute; in mathematics and logic something with this kind of dependency is typically noted by parameterizing it by time when the actual precise nature of the dependency is outside of the scope of the immediate analysis (because a dependency on the state of the universe at the time of execution is equivalent to a dependency on the time of execution with a hidden function mapping time to state of the universe.)

That impure functions methods are in many programming languages syntactically not distinguished from pure ones does not change the logic here.

That Time.now(at time t0) is distinct from Time.now(at time t1) is... unsurprising, and not an example of A != A in logical terms.

You know what the state of the universe is when you do logic?

Tell us more! I didn't believe in omniscience until now.

Time.now(t1) and Time.now(t2) is meaningless in this context because t1 and t2 are unbound variables. What are you passing to your function? Where is it coming from?

My function says you are overlooking something.

  [1] pry(main)> Time.now(t1)
  NameError: undefined local variable or method `t1' for main:Object from (pry):1:in `__pry__'
  [2] pry(main)> Time.now(1)
  ArgumentError: wrong number of arguments (given 1, expected 0) from (pry):2:in `now'

If you're familiar with the literature of programming languages, you'll see references to the "world" or the "universe" all the time. That's the kind of universe we mean in this discussion, not the one Carl Sagan talked about.

As for the rest: please provide the implementation of your Time.now function and I'll tell you its implicit parameters. If you're not talking about an actual function that can be run by a computer, then please tell me so and I'll drop it -- I'm not interested in hypothetical functions tautologically defined not to be equal to themselves.

>please provide the implementation of your Time.now function and I'll tell you its implicit parameters.

You are missing the point about extensional and intensional properties of functions.

If you want to look "inside" my Time.now function then maybe you should also look "inside" your equality function and find its implicit parameters?

Here's some Python boiler plate - implement equality and make the assertions pass.

  def f():
    return 1

  def equal(x,y): 
    # Implement equality

  assert not equal(1,2)
  assert equal(1,1)
  assert equal(f, f)

>If you're not talking about an actual function that can be run by a computer

As far as I can tell you are not talking about such a function either when you speak about equality, but I'll reserve judgment until you produce an implementation.

>I'm not interested in hypothetical functions tautologically defined not to be equal to themselves.

OK, but you are interested in hypothetical functions tautologically defined to be equal to themselves.

That's perfectly fine - we are interested in different tautologies.

You want to say equal(f,f) is true.

I want to say not equal(f,f) is true.

We want to say different things.

Well, it seems our disagreeme is obvious.

You only want to talk about pure functions. I want to talk about ALL functions.

So lets define the function "pure" such that

  pure(f) -> True when f is a pure function
  pure(g) -> False when g is an impure function

What would you say is the truth-value of pure(pure) ?

https://en.wikipedia.org/wiki/Impredicativity

dragonwriter wrote:

> "All impure functions have an implicit dependency on (some subset of) the state of the universe when they execute"

You wrote:

> "You only want to talk about pure functions. I want to talk about ALL functions."

Find the error.

>Find the error.

Still waiting for you to implement equal() as a "pure" function.

We can discuss what you mean by "error" once we have a referent (that's not just in your head) to talk about.

You know what... let me take your red herring away from you. Forget the Time.now function. Here's a !=a as a "pure" function.

   In [1]: class A:
   ...:     def __eq__(self, other):
   ...:         return False
   ...:
   In [2]: a = A()
   In [3]: assert a != a
   In [4]: assert a == a
   AssertionError

Will you now permit me to speak freely about A != A without you moralising about my reasoning?

Will you now recognise my right to free speech and free thought, or must I fall in line?

By the way... your conception of a pure function is incoherent.

Parameters ARE inputs. Results ARE outputs. Renaming them to something else is just obscuring the fact that you are still talking about a function with side-effects.

So using Python as my model of computation this is a pure function, but it does nothing:

   def f(): pass

This is NOT a pure function. It has outputs.

   def g(): return True

This is NOT a pure function. It mandates input.

   def h(x): pass

This is NOT a pure function - it mandates input and produces output:

   def j(x): return x

This is a pure function. It calculates the answer to 2+2, but doesn't tell you what it is.

   def k(): 2+2

If pure functions take no input and produce no output, what is there left to analyse? What is Logic and Mathematics talking ABOUT?

These are imperative commands to execute, as apposed to a declarative statement comparing a value to itself.

You can’t switch between symbolic representations to use the meaning of one to make statements about the other because the meaning of the symbols also switch.

So you are telling me that I can't choose to declare that A = A is false?

Telling me what I can and can't do is an imperative statement...

You certainly may define your own symbology.

But if you want to communicate with others you’ll need to agree on your symbology.

In the common mathematical understanding A != A is defined as a false statement. In any example that one can contemplate it would become a true statement then you are replacing one of the ‘A’ symbols with something that is not ‘A’ in your mind.

Which is to say you are using the wrong symbols to represent the idea you intend to communicate.

Indeed I want to communicate with others, but I do not insist on communicating with Mathematicians in particular. I want to communicate with anybody who wants to talk to me about the nature of time. And when we converse about time I want to be able to say the obvious: now is not now. If we get more serious about this time business we might even want to formally express that:

  A != A

If anybody insist that the above is false then they can exclude themselves from any formal or informal conversation about time on the basis of incomensurability of our paradigms

The above is a false statement because if we say A is "true" then the statement becomes "true != true" which is obviously a false statement. In fact if we put anything in the place of A the results are the same.

If, however, you wish to communicate the evaluation of a function such as "now()", then you would express that as two invocations of that function

now() != now()

t != t'

or simply

A != B

So simply using 'A' to mean things not exclusively 'A' is unnecessarily ambiguous. This makes it not only useless for communication between people but also makes it useless for forming any meaningful conclusions.

Failure to be completely expressive about a paradigm is not itself a paradigm. Its just faulty reasoning.

I am not looking for an a debate; or to be “set straight”.

I am telling you that in my model what I am saying is true . Yes I am talking about function invocation. In Ruby:

  a = lambda { Time.now }
  a.call != a.call

Or…

  x = “Time.now != Time.now”
  eval(x) == true

Not to get bogged down in any particular notation/syntax… I am expressing the same thing in different ways.

  f() != f()
  !( f() == f() )
  A != A
  Now is not now.

If you disagree with this - you are welcome to disengage me.

No need to bring Ruby into this; every language with impure functions (which is almost every language) can reproduce your example.

    f() != f()

And it's not hard to find an f that will satisfy this. This is not surprising or insightful to anyone with programming experience.

Do note two things:

The notation f.call is the same as f(), i.e. function invocation. You're not comparing functions but invoking them and comparing their results.

I don't know the equivalent syntax in Ruby, but in other languages the following is always true:

    f == f

That is, comparing the actual function (something that is constant even if the function is impure) instead of invoking it twice and comparing the results.

Note that the assertion "two things that are not the same might be different" is completely unsurprising. We're just letting syntax confuse us in this discussion.

I am bringing Ruby into the discussion so that I can simply point to an ostensive/empirical example - it spares all of us from the tedious "define it!" game.

It depends on which evaluation strategy you are using. Call by value or call by reference.

   def f
      return Time.now
   end
   f == f

It produces exactly the same effect as the one I am going for. Look past the syntax.

I don't know Ruby. In your example, if you're comparing the function itself, it is true that

   f == f

But it's not true if that's function invocation and there are implicit arguments. Applying a function and comparing its definition are of course different.

The evaluation strategy must come after we agree whether we're comparing values after invocation or definitions. If it's invocations, the evaluation strategy you pick can change the meaning of the program, so that we must discuss semantics.

In all of these cases,

    A == A

Once we make all implicit assumptions explicit.

What does it mean to compare a function to itself without evaluating it?

There are many ways of comparing functions.

A straightforward way can be to simply compare the text of the functions, as written in your programming language of choice, in this case Ruby.

Just take the text of both functions, do a diff, and if it says they are the same, they are the same.

Another comparison could be more abstract, since we know there's more than one way to accomplish the same with a programming language: two functions are the same if, given the same input, they produce the same output. You can either prove this by extension, if the number of possible inputs is finite and small, or you can prove it logically. With some languages which enforce purity using types, you can even show two functions are the same just by looking at their signatures, no need to evaluate anything! (this is one advantage of some statically typed languages, by the way!)

> There are no implicit arguments to the function I have in mind. Passing an argument to the function I have in mind is an error.

Yes, there are implicit arguments. You don't see them because they are implicit! A function that returns the moment in time, "now", of course depends on an implicit argument: the current time! How else is it going to know the moment of "now", otherwise? Think about how such a function is implemented.

>There are many ways of comparing functions.

Indeed. I pointed this out and provided a link in my first post on this thread.

>You don't see them because they are implicit!

The fact that my function takes no arguments is implicit in the specification of my function. I know because I said the English sentence "The function that I have in mind takes no arguments".

You seem to be suggesting that I don't know what function I am thinking about but you do. This is a very peculiar hypothesis.

Your function does take implicit arguments. There's no way your Ruby function can return the current time ("now") without external dependencies that supply that time.

If you want to argue otherwise, you must provide this hypothetical implementation that complies with your specs. I'm telling you that your function effectively can't exist as you describe it. In order for your function to work it requires an implicit argument (the "world" if you want to be coarse, though in this case we know it's the time).

If you want to argue that

    magical function is not magical function

that's fine, but also uninteresting. Magic is not bound by the constraints of the physical universe. We generally don't find arguing about leprechauns and unicorns for this reason (at least, not seriously).

You are asking me to provide the hypothetical implementation for a real-world function?

I don't know how to respond to this. Just observe the thing I am showing you. THAT is what I am talking about. It's right before your eyes - I took it from my head and made it real.

>If you want to argue that

I DON'T want to argue! All I am doing here is expressing myself - you are the one jumping down my throat.

This is me telling you that I am not interested in any social game of figuring out "who is right or who is wrong". If that's the game you are playing - I am happy to terminate the interaction.

What I mean by f() != f() in the abstract is precisely that Ruby program in the concrete. Nothing more - nothing less.

There is no room for "right" and "wrong" here. Those are moral judgments and I've committed no moral violation of any sort.

I'm asking you to provide the actual implementation of your hypothetical function now().

I don't need to know the implementation of the real function Time.now from Ruby because, without looking at its source code, I can tell you that it has implicit arguments.

How can I tell this? Because it's impossible for your Ruby program to tell the time without some kind of interaction with an external source (be it the computer clock, the internet or whatever); this source is your implicit parameter and it's why two invocations of your function don't return the same value. It is impossible for your function not to have this source of time, either implicitly or explicitly.

If you disagree, then please explain how your function tells time.

And I am asking you to provide the actual implementation of your hypothetical function equal().

I don't need to know the implementation of the real function == from any programming language because, without looking at any source code I can tell you that it has implicit arguments: a tautology.

If you disagree, then please explain how equality functions.

I read your point as similiar to u/tgflynn's point about modeling (upthread).

Being a simple bear, so formal logic breaks my head, I agree.

Just a hunch:

These "impedance mismatches" are one root cause for our society's current epistemological crisis. Cases where we can't even agree to a shared base truth.

Further, "now is not now" is a bit like paradox, no? The ability to hold two contradictory thoughts in your head at the same time. A large fraction of people recoil from ambiguity. Also a source of endless strife.

>Failure to be completely expressive about a paradigm is not itself a paradigm. Its just faulty reasoning.

I am being as expressive as my expressivity allows!

   for x in all-entities-in-universe: SOMETIMES(x = x)

Here is an example in Python:

   class A: pass
   class B:
      def __eq__(self, other): return False
   a = A()
   b = B()
   assert (a = a)
   assert not (b = b)

Would you be willing to lead by example and be completely expressive about the paradigm in which fault() is a meaningful function?

Don't moralise about my reasoning, when you are done implementing fault() we can pass my function as an input to yours. That will settle the matter without ceremony.

Good example why programming and logic are related, but not the same.

Yes well..

Any two objects are the same, except for their differences. Any two objects are different, except for their similarities.

"Sameness" and "difference" are abstract assertions. So in saying that you are doing programming; or maybe I am doing fuzzy logic.

From my perspective it seems like you are evaluating this expression:

  same?(Logic, Programming) -> False

But a different Oracle machine might produce a different answer :)

Reply on news.ycombinator.com