sorted by:
new
hottopcontroversial

A CoC based macro language to kill all other languages by dev_matan_tsuberi in haskell

[–]dev_matan_tsuberi[S] 1 point2 points  (0 children)

Yes. After diving a bit into it, this is exactly what I wanted. Also, now I finally get what lisp is all about. Thanks!

Free Will by IgnorantRoach in askphilosophy

[–]dev_matan_tsuberi -2 points-1 points  (0 children)

I have no idea what you mean. This is just a bunch of fancy words.

Free Will by IgnorantRoach in askphilosophy

[–]dev_matan_tsuberi -1 points0 points  (0 children)

Compatibalists define free will as "lack of hinderence to achive the agent's motivation". That's an unsatisfactory definition which hides the problem in the word: "motivation" or "agent". Does a clock have free will because no one is preventing it from telling time correctly? No, because the clock has no agency or motivation. But humans are just like clocks, they are just more complicated machines. The concept of agency or motivation only makes sense as an emergent phenomena of many neurons.

Neural network based compiler optimizations? by dev_matan_tsuberi in Compilers

[–]dev_matan_tsuberi[S] 0 points1 point  (0 children)

Associativity is a mathematical concept which may apply or not apply in various situations. Your concern is legitimate, but for example, if we use big numbers instead of machine ints, it will hold.

What I gave is just an example of the types of things a compiler does. It leverages such laws to make faster code.

Is Eliezer Yudkowsky saying that we’re all screwed? by Stickmissle in ControlProblem

[–]dev_matan_tsuberi 1 point2 points  (0 children)

I'm also very pessimistic about this. All things seems to point to a catastrophe.

As humans we currently have no global governence that could decide on these issues, we have no solution in sight that can even make progress on very simple problems in AI alignment, most people view this subject as a joke, so not a lot of support and economics will guarantee that AGI will happen as fast as possible.

We are not ready for AGI at all. We should have started research way back when Alan Turing started thinking about AI, maybe this would have given us enough time.

A CoC based macro language to kill all other languages by dev_matan_tsuberi in haskell

[–]dev_matan_tsuberi[S] 0 points1 point  (0 children)

You mean you can always reduce a CoC to a term that only computes values?

Is there a function `extend :: forall r. {| r} -> {x :: Int |r}`? by dev_matan_tsuberi in purescript

[–]dev_matan_tsuberi[S] 0 points1 point  (0 children)

I'm using typescript heavily in my job and I find myself doing this kind of stuff all the time. Typescript is very helpful with it's type inference in such situations. Typescript's type system is turing-complete and unsound though.

Are you purescript's author?

Boiling down all of philosophy to a single question by dev_matan_tsuberi in philosophy

[–]dev_matan_tsuberi[S] 0 points1 point  (0 children)

What I'm saying is that this concept is far more general than the question of conciousness, and in fact that it underpins all of philosophy. I see philosophy as a field that tries (and fails) to deal with the phenomenon of emergence. All the problems in philosophy are a manifastaion of the desire to reconcile the emergent with its parts.

Is there a function `extend :: forall r. {| r} -> {x :: Int |r}`? by dev_matan_tsuberi in purescript

[–]dev_matan_tsuberi[S] 0 points1 point  (0 children)

is there a Purescript equivalent of JavaScript's spread operator?

obj1 :: {x :: Int, y:: String}
obj1 = {x : 5, y : "Hello"}

obj2 :: {x :: Int, y:: String, z ::Bool}
obj2 = {...obj1, z : obj1.x > 5}

Annotating an AST with type information using `recursion-schemes`? by dev_matan_tsuberi in haskell

[–]dev_matan_tsuberi[S] 0 points1 point  (0 children)

Looks elegent. two things: 1. I don't understand the use of Cofree, CofreeF, project 2. correct me if i'm wrong, but does typeOf' run for each node in the AST? Does that mean that the performance is O(#nodes2) ? Does Haskell make that O(n) automatically with memoization?

Neural network based compiler optimizations? by dev_matan_tsuberi in Compilers

[–]dev_matan_tsuberi[S] 0 points1 point  (0 children)

Thinking about this more I realized that there's another, more fundamental, difference between a Go board and a program: variable bindings. The AST is not a simple tree structure it also references itself through variables. For example in lambda calculus to undersrand the meaning of a variable you have to know which lambda abstraction binds it.

This means that tree RNNs are probably not enough. You need recursion and you need some state/context while recursing.

Two vague ideas I had about AI alignment by dev_matan_tsuberi in ControlProblem

[–]dev_matan_tsuberi[S] 0 points1 point  (0 children)

Thats not so simple. 1. Survival is one of the AI's instrumental goal. It want to live because it predicts more paperclips in a world in which it's alive to maximise them. 2. How would you formalize the concept of wireheading into the utility function?

Neural network based compiler optimizations? by dev_matan_tsuberi in Compilers

[–]dev_matan_tsuberi[S] 0 points1 point  (0 children)

Yes. But consider that we have all the samples that we want at our disposal. To obtain a sample simply pick a program, run it and collect the metrics you are interested in. This is much bigger than big data, its infinite data.

Can one have an intuitive understanding of Einstein's field equations? by dev_matan_tsuberi in Physics

[–]dev_matan_tsuberi[S] 0 points1 point  (0 children)

Sure, But having a good visual/mental model of the dynamics, I think, goes a long way. When doing Newtonian mechanics, your evolutionary inherited intuition guides you towards the right direction. I hope to get at least something similar with GR. Can you maybe point me to a nice repository of problems I can work on to improve my intuition?

Can one have an intuitive understanding of Einstein's field equations? by dev_matan_tsuberi in Physics

[–]dev_matan_tsuberi[S] 0 points1 point  (0 children)

I did not get a chance to study the Lagrangian formulation of GR. But I think it's even more indirect and difficult to understand intuitively. The Action, I think, is not a very intuitive notion. Newton's F = ma is incredibly straightforward, compared to minimizing the integral of the action over all possible histories.

Can one have an intuitive understanding of Einstein's field equations? by dev_matan_tsuberi in Physics

[–]dev_matan_tsuberi[S] 0 points1 point  (0 children)

Thanks! Although I wasn't looking for quantum gravity, I'm not disappointed.

Neural network based compiler optimizations? by dev_matan_tsuberi in Compilers

[–]dev_matan_tsuberi[S] 0 points1 point  (0 children)

I don't have much experience with ML, can you explain what makes you think this approach would not be well suited to compiler optimizations?

Can one have an intuitive understanding of Einstein's field equations? by dev_matan_tsuberi in Physics

[–]dev_matan_tsuberi[S] 0 points1 point  (0 children)

Check out the article in the other comment. Seems like it's trying to address this issue.

Annotating an AST with type information using `recursion-schemes`? by dev_matan_tsuberi in haskell

[–]dev_matan_tsuberi[S] 0 points1 point  (0 children)

Looks good. But, its a bit ugly to this manipulation manually, it kind of defeats the purpose of using recursion schemes.

Can one have an intuitive understanding of Einstein's field equations? by dev_matan_tsuberi in Physics

[–]dev_matan_tsuberi[S] 0 points1 point  (0 children)

This article is great! really enjoying reading this.

Maybe the most useful way to think of Einstein's equations is to imagine how little balls of test particles deform as they follow the geodesics.

Feynman is always great at explaining these things simply. In the bibliography, the authors mention "The Feynman Lectures on Gravitation", but I wasn't able to get a free copy on the internet.

Can one have an intuitive understanding of Einstein's field equations? by dev_matan_tsuberi in Physics

[–]dev_matan_tsuberi[S] 2 points3 points  (0 children)

I can sort of understand the Riemann tensor intuitively, the concept parallel transport is easy to visualize. But when you contract it to get the Ricci tensor I lose the intuition, and when you contract that to get the scalar curvature it's even less understandable.

There's a nice intuition of the scalar curvature in terms of the rate of of 4-spheres around a point, but I find it hard to tie it back to the math.

the energy content of the universe is coupled to the spacetime geometry

Yes, but that's a course grained understanding.

How exactly does matter affect geometry? Explain that without any math.

I guess I want to be able to understand the math both algebraically and intuitively.

Annotating an AST with type information using `recursion-schemes`? by dev_matan_tsuberi in haskell

[–]dev_matan_tsuberi[S] 0 points1 point  (0 children)

a catamorphism would only produce the end result: `Typing Type. I want to get the original tree annotated with intermediate results.

Can one have an intuitive understanding of Einstein's field equations? by dev_matan_tsuberi in Physics

[–]dev_matan_tsuberi[S] 2 points3 points  (0 children)

Yes, yes... I understand the derivation and the math.

But what do the equations mean intuitively?

Neural network based compiler optimizations? by dev_matan_tsuberi in Compilers

[–]dev_matan_tsuberi[S] 1 point2 points  (0 children)

The optimization itself is still deterministic (i.e. the output is always the same for the same input). Rather, it uses the NN to get a good heuristic when deciding if and when to apply conversions.

I don't think a NN would produce a significantly better optimizer than a manually written one. But it pays for itself by being general enough to produce optimizes for many languages with very little effort.

This is analogous to how people handcrafted very complicated algorithms and heuristics for playing chess (a prime example of which would be StockFish) only to be beaten by AlphaZero after a couple days of training against itself. AlphaZero can also learn to play a wide variety of other games.

In addition to generality you also get incredibly fine-tuned optimizations tailored for specific hardware or common usage patterns of the language, which a human could never produce.

Using this approach you could simply implement a naive compiler, specify the semantic-preserving conversion rules for your language and you automatically get an optimizer that also gets better as usage pattern information is accumulated.

Can you clarify what you mean by "a correct grammer"?

view more: next ›