buc.ci is a Fediverse instance that uses the ActivityPub protocol. In other words, users at this host can communicate with people that use software like Mastodon, Pleroma, Friendica, etc. all around the world.

This server runs the snac software and there is no automatic sign-up process.

Admin email
abucci@bucci.onl
Admin account
@abucci@buc.ci

Search results for tag #lean

AodeRelay boosted

[?]Ricardo Tavares » 🌐
@t_var_s@phpc.social

Both and are having a moment of fresh adoption and scrutiny.

kcl.ac.uk/news/openais-navier-

    AodeRelay boosted

    [?]Daily CyberSecurity » 🌐
    @DailyCyberSecurity@infosec.exchange

    AlphaProof Code Signal proofs check libsignal machine code in four weeks. Here is what is covered, what is not, and what it means for WhatsApp users.

    dailytechnow.com/alphaproof-co

      AodeRelay boosted

      [?]Mohith kumar » 🌐
      @mohith808@mastodon.social

      POV: your security audit used to take years

      deepmind's agents just formally verified signal's actual code, down to machine instructions, in 4 weeks

      millions of lines of lean. humans reviewed about 1% of the code

      they re-added two old bugs. it proved both versions insecure

      deepmind.google/blog/introduci

        AodeRelay boosted

        [?]GNU/Linux.ch » 🌐
        @gnulinux@social.anoxinon.de

        Spielend Beweisen lernen mit Lean4

        In diesem Artikel geht es um die Programmiersprache Lean, die es erlaubt, mathematische Beweise zu führen, und ein Spiel, welches dabei helfen kann, Lean zu lernen.

        gnulinux.ch/beweisen-lernen-mi

          2 ★ 2 ↺

          [?]Anthony » 🌐
          @abucci@buc.ci

          Regarding the LB, https://fedi.kbg.sh/users/kevin/statuses/117085582358711627

          There's an interesting thing about strongly typed programming languages, especially dependently typed ones (1), wherein if you know the type signature of a function there is sometimes only one implementation of it, and that implementation will have lots of nice properties (e.g. Philip Wadler's Theorems for free! paper, also Jose Oliveira's work, and the followups to these). It's a fascinating set of results that holds out the possibility of at least some amount of automatic programming that has desirable, provable properties concerning correctness, resource use, security, and so on.

          However, that "some amount" is very important to remember. I'd argue that no matter how far such work is pushed, there will always be an infinite space of things one might wish to express in software that cannot be automatically programmed in that way. That's the Therac-25 space the LB evokes. We all know this intuitively, I think, yet in the various mystifications thrown up about computers and software and now LLMs it can be hard to remember.

          For example, I'd say so-called "side effects" or just "effects" are still a large blind spot of these methods. Without effects functional programming does little more than heat up a CPU (but the heat is an effect oops), so if we're being snarky we might say functional programming without effects isn't programming at all. But in spite of the gazillion attempts to do so, you really cannot faithfully capture all side effects of interest in a type system, for the simple reason that the real world is open-ended.(2) There's a funny contradiction that functional programming languages could not exist were it not for irreducibly effectful computational architectures to exist on. Asking the CPU to execute an instruction, and all the statefulness this necessarily involves, is a "side effect" in this view of computation, which is absurd.

          For these reasons I've found it fruitful to conceive of functional programming as an intricate bureaucracy sitting between the programmer and the real world.(3) Set up enough bureaucracy and you can comfortably pretend most of the real world isn't there most of the time. Some people do this for so long that they begin to think the bureaucracy is the real world (4); or they try to warp the real world till it becomes more and more like the bureaucracy.(5) But the real world is oozy and eventually squishes around all attempts to constrain it in this way. Neglecting this is how people end up being harmed by digital technology.



          (1) "leanslop" in the linked post refers to Lean, a dependently typed functional programming language that's being used to formalize mathematical ideas. We should always remember that Lean originated from Microsoft Research
          (2) There's a long history of philosophical arguments hiding behind that assertion but there's no space to get into that here. A less contentious way to put it would be that the claim that all side effects worth caring about can be captured in a type system is a philosophical commitment, not a fact about the world, and therefore it's possible it cannot be done
          (3) We use terms like runtimes, preludes, standard libraries, or APIs/ABIs (among others) for this bureaucracy
          (4) "Touch grass"
          (5) Financialization and neoliberalism, e.g.

            4 ★ 3 ↺

            [?]Anthony » 🌐
            @abucci@buc.ci

            Re: https://lipn.info/@mevenlennonbertrand/116997917683191056

            To riff on this a bit from a very different field at a very different scale, as a pretext to share an anecdote:

            When I was a graduate student I spent a fair amount of time (an embarrassing amount of time) trying to get a computer to learn how to play Tic-Tac-Toe (naughts and crosses) by self play, given minimal help. Why? Because it turns out to be significantly harder than you might think based on the simplicity of the game, and I was curious why. It's not that hard in the grand scheme of things, but it's weirdly harder than you'd (well, I'd) expect (1). So, I went about coding up a Tic-Tac-Toe implementation that could play as quickly as possible, since gameplay would be the inner loop of a search algorithm, tested it some, and set a self-play-based search I was working on loose. Before too long my search was logging data that suggested it had found at least one optimal player. I was excited because I had opinions about how to use self-play to guide strategy search and it seemed like I might have some data supporting those opinions (calling them "hypotheses" would be giving my past self too much credit).

            After quite a bit of testing, I discovered that my Tic-Tac-Toe implementation had a bug: in a small set of configurations of the board, my code would flag two in a row as a win instead of three in a row. My "optimal players" turned out to exploit this fact, choosing moves to drive the game into that set of configurations, then "winning" with two in a row. Oops. (2)

            I noticed the problem because some of my discovered players were beating a minimax player during post hoc testing, which I knew to be impossible. I was able to sort out why because Tic-Tac-Toe is small enough to exhaustively test: you can enumerate the

            by eye what was wrong.

            One might ask: why didn't you have unit tests to do this sort of thing? Well, after that experience I did do more routine testing. However, speaking more generally now, there's an infinite regress when it comes to checking whether or not an implementation of a set of rules is faithful to the intention of that set of rules. Barring some kind of theoretical guarantee you'd need some other implementation of the rules to perform that sort of test. How can you be certain that implementation is comprehensive and also doesn't have a bug? You sometimes can't, practically speaking, and sometimes you can't theoretically speaking either. When the domain becomes large and complicated enough that both the above features about Tic-Tac-Toe I took advantage of---a sure indicator grounded in theory, and the ability to comprehensively and satisfactorily test---fail to hold, you're a bit adrift. (4)

            I'm not very familiar with Lean, but I do know a bit about type theory, and modern type checkers tend to be Turing complete. Formal verification of a Turing complete programming language is not easy. I understand that practical type systems are designed to make type judgments of interest decidable, but that does not mean they're easy nor that the rules are easy to implement faithfully or test. It seems to me to be a tough problem, which is one of many reasons why I've taken the claims about LLMs doing this or that math thing with a big grain of salt. (5) I've expected to see the analog of my two-in-a-row "optimal" Tic-Tac-Toe players emerge to much fanfare for awhile now, and I expect to see many more.



            (1) Donald Michie reported his MENACE system, which was a rudimentary form of reinforcement learning, could learn a decent game of Tic-Tac-Toe within a few hundred games. Christopher Rosin reported his coevolution-based Tic-Tac-Toe learner, a variant of learning by self play, required tens of billions of games to achieve less competence. Arthur Samuel's system learned master-level checkers by self play faster than this.

            (2) Debugging a system by wrapping a search or optimization algorithm around it is an underappreciated technique I've used many times. It's a bit like fuzzing with an incentive to cause trouble.

            (3) When I said "given minimal help", I meant it: I didn't give the players knowledge of the board symmetries.

            (4) Personally I think it's incumbent on computer science professionals to flag when this is the case, since that's something we're educated to know (at least in principle).

            (5) "Under the assumption that the implementation of system Y is correct, a human-written formalization of problem X in system Y produced output that a team of humans verified could be adapted into a proof of theorem Z" would grab fewer headlines than "AI proves Z", though.

              28 ★ 9 ↺
              planetscape boosted

              [?]Anthony » 🌐
              @abucci@buc.ci

              A weird thing about being 50 is that there are programming languages that I've used regularly for longer than some of the software developers I work with have been alive. I first wrote BASIC code in the 1980s. The first time I wrote an expression evaluator--a fairly standard programming puzzle or homework--was in 1990. I wrote it in Pascal for an undergraduate homework assignment. I first wrote perl in the early 1990s, when it was still perl 4.036 (5.38.2 now). I first wrote java in 1995-ish, when it was still java 1.0 (1.21 now). I first wrote scala, which I still use for most things today, in 2013-ish, when it was still scala 2.8 (3.4.0 now). At various times I've been "fluent" in 8086 assembly, BASIC, C, Pascal, perl, python, java, scala; and passable in LISP/Scheme, Prolog, old school Mathematica, (early days) Objective C, matlab/octave, and R. I've written a few lines of Fortran and more than a few lines of COBOL that I ran in a production system once. I could probably write a bit of Haskell if pressed but for some reason I really dislike its syntax so I've never been enthusiastic about learning it well. I've experimented with Clean, Flix, Curry, Unison, Factor, and Joy and learned bits and pieces of each of those. I'm trying to decide whether I should try learning Idris, Agda, and/or Lean. I'm pretty sure I'm forgetting a few languages. Bit of 6502 assembly long ago. Bit of Unix/Linux shell scripting languages (old enough to have lived and breathed tcsh before switching to bash; I use fish now mostly).

              When I say passable: in graduate school I wrote a Prolog interpreter in java (including parsing source code or REPL input), within which I could run the classic examples like append or (very simple) symbolic differentiation/integration. As an undergraduate I wrote a Mathematica program to solve the word recognition problem for context-free formal languages. But I'd need some study time to be able to write these languages again.

              I don't know what the hell prompted me to reminisce about programming languages. I hope it doesn't come off as a humblebrag but rather like old guy spinning yarns. I think I've been through so many because I'm never quite happy with any one of them and because I've had a varied career that started when I was pretty young.

              I guess I'm also half hoping to find people on here who have similar interests so I'm going to riddle this post with hashtags: