(Mathematics:)

Beginning of a phrase binding a name to a certain value. The scope of the binding is understood (from clues from natural language, usually).

For instance:

Let x satisfy
x2=x+1.
Then 1/x=x-1.

(Computer science:)

(Lisp, functional programming languages:)
A special form for binding one or more values to names. The scope of the binding is the extent of the form (in older Lisps, e.g. Emacs Lisp, this is the dynamic extent, and the binding is dynamic binding; in functional programming languages and the newer Lisps, e.g. Common Lisp or Scheme, this is the static extent, and the binding is static binding).

Even in an impure functional language (Scheme, Lisp with static binding, ML and the like), this is not assignment in any form! All that happens is that certain values are given names for a short scope. (However, these names may later be assigned, e.g. with Scheme's set! special form; that is assignment...).

The Lispish form of let is:

(let ((VAR1 VAL1)
      ; ...
      (VALk VALk))
  BODY)
which evaluates the form(s) BODY with VALi named VARi. Note that all bindings occur simultaneously here.

This Lispish let is really just syntactic sugar for Scheme's

((lambda (VAR1 ... VARk)
    BODY)
 VAL1 ... VALk)
(The Lisp equivalent is essentially the same, but requires a funcall).

Other functional language's lets are the same conceptually, but generally with a more verbose concrete syntax.

(BASIC:)
Presumably inspired by the much earlier usage in Lisp (above), and exhibiting the usual confusion exemplified by BASIC's "it's too hard for beginners, let's tell them something wrong" attitude, BASIC uses the LET keyword as a prefix to assignment!

The original BASIC required the LET in

100 LET X=something
(it simplifies the parser somewhat). But LET quickly became optional (it doesn't make any real difference to the hardness of parsing BASIC).

In BASIC's defence, we could claim it's trying to echo the mathematical usage (at the top of this writeup). But that still embodies the same confusion between binding and assignment. This helps confuse anyone who grew up on BASIC (author of present writeup included) when they first hear of the Lispish let, or when they try to grok the C++ difference between assignment (operator=) and binding (the copy constructor).