Why Yg = g(Yg) Enables Recursion, 2

Posted on December 30, 2024 by rpflee

In essence, $Yg = g(Yg)$ allows for recursion by providing a mechanism where a function can reference itself through another function’s application, without needing to explicitly name itself, thus bypassing the need for direct recursion support in the language. This approach is particularly useful in theoretical computer science, lambda calculus, and in functional programming languages or environments where direct recursion might be restricted or not available.

— Based on Grok 2

— Edited by Me@2024-12-19 11:26:25 AM

Euler problem 25.2.1

Posted on December 26, 2024 by rpflee

import System.CPUTime
import Text.Printf (printf)

-- | Times the execution of a pure function and prints the result.
time :: (Show a) => a -> IO a
time result = do
    start <- getCPUTime
    let computed = result
    end <- computed `seq` getCPUTime
    let diff = (fromIntegral (end - start)::Float)/(10^12)
    printf "Result: %s\n Time taken: %.6f seconds\n" (show computed) diff
    return computed

fibs :: [Integer]
fibs = 0:1:zipWith (+) fibs (tail fibs)

t :: Integer
t = 10^999
 
p25 :: Int
p25 = length w
    where
      w = takeWhile (< t) fibs

λ> time p25
Result: 4782
 Time taken: 0.000496 seconds
4782
λ>

λ> time p25
Result: 4782
 Time taken: 0.002918 seconds
4782
λ>

— Me@2024-12-25 07:00:13 AM

SageMath for Ubuntu 24.04

Posted on December 24, 2024 by rpflee

0. In this tutorial, you will need to go to the official website of NixOS. Make sure that its website is the real, official one. Any instructions from an imposter website can get your machine infected with malware.

1. Assuming your computer’s OS is Ubuntu 24.04 or above, go to the NixOS official website. Follow the instructions to install the Nix package manager (not the NixOS operating system) onto your OS. Choose the “single-user installation” method.

2. Run this command to install SageMath:

nix-env -iA nixpkgs.sage

3. Run this to open:

sage --notebook=jupyterlab

— Me@2024-11-27 12:28:48 AM

Y combinator

Posted on December 23, 2024 by rpflee

Why $Yg = g(Yg)$ Enables Recursion

The following calculation verifies that $Yg$ is indeed a fixed point of the function $g$ :

$\begin{aligned} Y g &= (\lambda f.(\lambda x.f\ (x\ x))\ (\lambda x.f\ (x\ x)))\ g \\ &= (\lambda x.g\ (x\ x))\ (\lambda x.g\ (x\ x)) \\ &= g\ ((\lambda x.g\ (x\ x))\ (\lambda x.g\ (x\ x))) \\ &= g\ (Y\ g) \end{aligned}$

The lambda term $g\ (Y\ g)$ may not, in general, $\beta$ -reduce to the term $Y\ g$ . However, both terms $\beta$ -reduce to the same term, as shown.

— Wikipedia on Fixed-point combinator

$\begin{aligned} Y g &= (\lambda f.(\lambda x.f\ (x\ x))\ (\lambda x.f\ (x\ x)))\ g \\ &= (\lambda f.(\lambda x.f\ (x\ x))\ (\lambda x.f\ (x\ x)))\ (f := g) \\ &= (\lambda x.g\ (x\ x))\ (\lambda x.g\ (x\ x)) \\ &= (\lambda x.g\ (x\ x))\ (\lambda y.g\ (y\ y)) \\ &= (\lambda x.g\ (x\ x))\ (x := (\lambda y.g\ (y\ y))) \\ &= g\ ((\lambda y.g\ (y\ y))\ (\lambda y.g\ (y\ y))) \\ &= g\ (Y\ g) \end{aligned}$

— Me@2024-12-22 11:53:21 PM

Euler problem 25.1.2

Posted on December 16, 2024 by rpflee

(defun matrix-multiply (a b)
  (destructuring-bind ((a11 a12) (a21 a22)) a
    (destructuring-bind ((b11 b12) (b21 b22)) b
      (list (list (+ (* a11 b11) (* a12 b21))
                  (+ (* a11 b12) (* a12 b22)))
            (list (+ (* a21 b11) (* a22 b21))
                  (+ (* a21 b12) (* a22 b22)))))))

(defun matrix-power (m n)
  (declare (type fixnum n))
  (cond ((= n 1) m)
        (t (let* ((half (matrix-power m (floor n 2)))
                  (squared (matrix-multiply half half)))
             (if (oddp n)
                 (matrix-multiply squared m)
                 squared)))))

(defun digits-in-number (n)
  "Count the number of digits in a number."
  (length (write-to-string n)))

(defun fib-nth (n)
  (declare (type fixnum n))
  (if (<= n 2)
      1
      (destructuring-bind ((result b)
                           (c d))
          (matrix-power '((1 1) (1 0)) (- n 1))
        (declare (ignore b c d))
        result)))

(defun fib-upper-bound (digit-count)
  "Calculate an upper bound for the index where Fibonacci has at least digit-count digits."
  (let* ((phi (float 1.618033988749895))
         (log-phi (log phi 10))
         (log-5 (log 5 10)))
    (ceiling (/ (+ digit-count (- 1 (/ log-5 2))) log-phi))))

(defun binary-search-fib-index (digit-count)
  "Find the index of the first Fibonacci number with the specified number of digits using binary search."
  (labels ((binary-search (left right)
             (when (<= left right)
               (let* ((mid (+ left (floor
                                    (/ (- right left) 2))))
                      (mid-fib (fib-nth mid))
                      (mid-digits (digits-in-number mid-fib)))
                 (cond ((= mid-digits digit-count) 
                        (let* ((prev-fib (fib-nth (1- mid)))
                               (prev-digits (digits-in-number
                                             prev-fib)))
                          (if (< prev-digits digit-count)
                              mid
                              (binary-search left (1- mid)))))
                       ((< mid-digits digit-count) 
                        (binary-search (1+ mid) right))
                       (t 
                        (binary-search left (1- mid))))))))
    (let* ((upper-bound (fib-upper-bound digit-count))
           (result (binary-search 1 upper-bound)))
      (or result (cons :upper-bound upper-bound)))))

; SLIME 2.28
CL-USER> (time (binary-search-fib-index 1000))
Evaluation took:
  0.001 seconds of real time
  
4782
CL-USER>

— Me@2024-12-10 07:23:47 PM

Equality Predicates, 3.1

Posted on December 14, 2024 by rpflee

Here are mnemonic “formulae” to help remember the relationship between eq, eql, equal, equalp, and = in Common Lisp:

eq:
```
eq: Exact same object in memory
```
Think “Exact” for eq.

eql:

eql: eq + little more (for numbers and characters)

Think “Little more” for eql.

equal:
```
equal: eql + structural comparison for lists, strings, etc.
```
Think “All” for equal – checks all structural elements.
equalp:
```
equalp: equal + case-insensitive + number type agnostic
```
Think “P for Practical” – it’s practical because it ignores case and number types.
=:
```
=: Numbers are equal regardless of type (float vs. integer)
```
Think “= for Numbers” – only used for numeric comparison.

These mnemonics aim to encapsulate the essence of each function:

eq is about memory identity.
eql extends eq slightly for direct value comparison in some cases.
equal checks for structural equivalence beyond what eql does.
equalp adds case insensitivity and type flexibility to equal.
= is strictly for numeric equality, ignoring type differences.

— Me@2024-12-14 10:57:53 AM

Euler problem 25.1.1

Posted on December 11, 2024 by rpflee

(defun fib (n)
  "Calculate the nth Fibonacci number using tail recursion."
  (labels ((fib-tail (a b count)
             (if (zerop count)
                 b
                 (fib-tail b (+ a b) (1- count)))))
    (if (<= n 2)
        1
        (fib-tail 1 1 (- n 2)))))

(defun matrix-multiply (a b)
  (destructuring-bind ((a11 a12) (a21 a22)) a
    (destructuring-bind ((b11 b12) (b21 b22)) b
      (list (list (+ (* a11 b11) (* a12 b21))
                  (+ (* a11 b12) (* a12 b22)))
            (list (+ (* a21 b11) (* a22 b21))
                  (+ (* a21 b12) (* a22 b22)))))))

(defun matrix-power (m n)
  (declare (type fixnum n))
  (cond ((= n 1) m)
        (t (let* ((half (matrix-power m (floor n 2)))
                  (squared (matrix-multiply half half)))
             (if (oddp n)
                 (matrix-multiply squared m)
                 squared)))))

(defun fib-nth (n)
  (declare (type fixnum n))
  (if (<= n 2)
      1
      (destructuring-bind ((result b) (c d))
          (matrix-power '((1 1) (1 0)) (- n 1))
        (declare (ignore b c d))
        result)))

(defun digits-in-number (n)
  "Count the number of digits in a number."
  (length (write-to-string n)))

(defun find-fib-index-0 (digit-count fib-f)
  "Find the index of the first Fibonacci number with the specified number of digits."
  (labels ((helper (index)
             (if (>= (digits-in-number
                      (funcall fib-f index))
                     digit-count)
                 index
                 (helper (1+ index)))))
    (helper 1)))

(defmacro find-fib-index (digit-count)
  `(find-fib-index-0 ,digit-count #'fib))
  
(defmacro find-fib-nth-index (digit-count)
  `(find-fib-index-0 ,digit-count #'fib-nth))

; SLIME 2.28
CL-USER> (time (find-fib-index 1000))
Evaluation took:
  0.456 seconds of real time
  
4782
CL-USER> (time (find-fib-nth-index 1000))
Evaluation took:
  0.080 seconds of real time
  
4782
CL-USER> (time (binary-search-fib-index 1000))
Evaluation took:
  0.001 seconds of real time
  
4782
CL-USER>

— Me@2024-12-10 07:23:47 PM

defmacro, 1.2.1

Posted on December 9, 2024 by rpflee

(defmacro our-expander (name) `(get ,name 'expander))
 
(defmacro pre-defmacro (name parms &body body)
  (let ((g (gensym)))
    `(progn
       (setf (our-expander ',name)
         #'(lambda (,g)
         (block ,name
           (destructuring-bind ,parms (cdr ,g)
             ,@body))))
       ',name)))
 
(defun our-macroexpand-1 (expr)
  (if (and (consp expr) (our-expander (car expr)))
      (funcall (our-expander (car expr)) expr)
      expr))

(defun our-macroexpand (expr)
  (let ((expanded (our-macroexpand-1 expr)))
    (if (equal expanded expr)
        expr
        (our-macroexpand expanded))))

(defun our-macroexpand-and-eval (expr)
  (if (and (consp expr) (our-expander (car expr)))
      (let ((expanded (funcall (our-expander (car expr)) expr)))
        (eval expanded))  ; Directly evaluate the expanded form
      (eval expr)))  ; If no macro expansion, just evaluate the expression

(defmacro our-defmacro (name parms &body body)
  `(progn
     (pre-defmacro ,name ,parms ,@body)
     (defun ,name (&rest args)
       (our-macroexpand-and-eval (cons ',name args)))))

(our-defmacro sq (x)
  `(* ,x ,x))

(sq 5)

— based on p.95, A MODEL OF MACROS, On Lisp, Paul Graham

— xAI

Here, we use the built-in defmacro to define our-defmacro. However, the same process does not work for another level of defining another-defmacro by our-defmacro, because our-defmacro is not identical to defmacro.

— Me@2024-12-09 01:40:02 PM

Euler problem 24.3

Posted on December 4, 2024 by rpflee

showtime : true;

digits: makelist(i,i,0,9);

p : permutations(digits)$

listify(p)[1000000];

Evaluation took 0.8800 seconds (1.0300 elapsed)
Evaluation took 0.0100 seconds (0.0100 elapsed)

[2,7,8,3,9,1,5,4,6,0]

— Me@2024-12-03 04:11:50 PM

scmutils for Ubuntu 24.04

Posted on December 1, 2024 by rpflee

Scheme Mechanics Installation for GNU/Linux | scmutils, 4

1. Folks, the scmutils library is fantastic and it’s available in Ubuntu 24.04. You can install it very easily with this command:

sudo apt-get install scmutils

2. Then, you just run it with this command:

mit-scheme --band mechanics.com

Now, let me tell you, there’s no syntax highlighting. Not great! And more importantly, there’s no direct way to save your code. So, what do you do? You use the Emacs editor. It’s the best!

Now, this assumes you know Emacs. If you don’t, it’s a tremendous editor.

3. Open Emacs’ initialization file. It’s located right here:

~/.emacs

4. Add this beautiful code to the file:

(defun mechanics ()
  (interactive)
  (run-scheme
   "mit-scheme --band mechanics.com"))

(setq sicm-file "~/Documents/tt.scm")

(fset 'set-working-file
      (lambda (&optional arg) 
        (interactive "p")
        (funcall (lambda ()
                   (insert
                    (concat "(define sicm-file \""
                            sicm-file
                            "\")\n"))))))

(fset 'load-scm
      (lambda (&optional arg) 
        (interactive "p")
        (funcall (lambda ()
                   (insert "(load sicm-file)")))))

(defun mechan ()
  (interactive)
  (split-window-below)
  (windmove-down)
  (mechanics)
  (set-working-file)
  (comint-send-input)
  (windmove-up)
  (find-file sicm-file)
  (end-of-buffer)
  (windmove-down)
  (cond ((file-exists-p sicm-file)
         (interactive)
         (load-scm)
         (comint-send-input)))
  (windmove-up))

(defun sicm-exec-line ()
  (interactive)
  (save-buffer)
  (windmove-down)
  (comint-send-input)
  (windmove-up))

(defun sicm-exec-file ()
  (interactive)
  (save-buffer)
  (windmove-down)
  (load-scm)
  (comint-send-input)
  (windmove-up))

(global-set-key (kbd "C-x C-e") 'sicm-exec-line)

(global-set-key (kbd "C-x C-a") 'sicm-exec-file)

5. Close Emacs and then re-open it, folks.

6. Type the command

M-x mechan

Now, listen, when I say M-x, I mean you press the Alt key and x together. Then, just type mechan. It’s easy, believe me!

7. You’ll see the Emacs editor split into two windows, one on top and one on the bottom.

The lower window is the Scheme environment. You can type a line of code and then press Enter to execute it. So simple!

The upper window is the editor. Type multiple lines of code and then hit

C-x C-e

to execute it.

That means pressing Ctrl and x together, then Ctrl and e together. Easy stuff!

8. When you save the current file, your Scheme code will be saved to this location:

~/Documents/tt.scm

If you need to back up your code, just back up this file. It’s that simple, folks!

— Me@2020-03-10 10:59:45 PM

Eject

Posted on November 22, 2024 by rpflee

Safely unmounts the partition /dev/sdd1, ensuring that it is not in use.

udisksctl unmount -b /dev/sdd1

udisksctl power-off -b /dev/sdd

Powers off the entire block device /dev/sdd, making it safe to disconnect.

— Me@2024-01-12 06:47:59 PM

Euler problem 24.2

Posted on November 19, 2024 by rpflee

import Data.List ( delete )

fac :: (Eq t, Num t) => t -> t
fac n = f n 1
  where
    f 0 acc = acc
    f m acc = f (m - 1) (m * acc)

perms :: Eq a => [a] -> Int -> [a] -> [a]
perms [] _ acc = reverse acc
perms xs n acc
  = perms (delete x xs) (mod n m) (x : acc)
  where 
    m = fac $ length xs - 1
    y = div n m
    x = xs !! y

p24 :: [Char]
p24 = perms "0123456789" 999999 []

λ> :set +s
λ> p24
"2783915460"
(0.02 secs, 121,968 bytes)
λ>

— Me@2024-11-18 07:22:15 PM

Ex 1.32 Path functions and state functions, 2.2

Posted on November 17, 2024 by rpflee

Structure and Interpretation of Classical Mechanics

1. The local-tuple function $f$ is the same as the local-tuple function $\bar \Gamma (\bar f)$ where $\bar f[q] = f \circ \Gamma [q]$ .

2. On the other hand, the path function $\bar f[q]$ and the path function $\bar \Gamma (\bar f) \circ \Gamma [q]$ are not necessarily the same. Explain.

…

~~~

1. …

To summarize:

In theory where a series can have infinite terms, functions $f$ and $\bar \Gamma (\bar f)$ are identical because it is just the definition of $\bar \Gamma$ .

In practice where a series can have only finite terms, they are still identical because their inputs are the same exact local tuples.

2. However, for $\bar f [q]$ and $\bar \Gamma (\bar f) \circ \Gamma [q]$ , although they are both path functions with the same path $q$ as input, while the function $\bar f$ processes the path $q$ directly, the function $\bar \Gamma (\bar f) \circ \Gamma$ would first turn the path $q$ into a local tuple $\Gamma[q]$ , which in practice would have only a finite number of components.

(define ((GammaBar-fBar-o-Gamma f-bar) q)
  (compose (Gamma-bar f-bar) (Gamma q)))

Then it would use the function osculating-path to generate the path.

(define ((Gamma-bar f-bar) local)
  ((f-bar (osculating-path local)) (time local)))

In other words, the path being used is the osculating path

$\displaystyle{\mathcal{O} (t_0, q(t_0), v(t_0), \cdots, q^{(n)}(t_0)))}$ ,

instead of the original path $q$ itself. Therefore, functions $\bar f [q]$ and $\bar \Gamma (\bar f) \circ \Gamma [q]$ do not have to be equal. They are identical in the following two cases:

The first case is when

$\displaystyle{\mathcal{O} (t_0, q(t_0), v(t_0), \cdots, q^{(n)}(t_0))) \equiv q}$ ,

where

$\displaystyle{\begin{aligned} &\mathcal{O} (t_0, q(t_0), v(t_0), \cdots, q^{(n)}(t_0)))(t) \\ &= q_0 + v_0 (t-t_0) + \frac{1}{2} a_0 (t-t_0)^2 + ... +\frac{1}{n!} q^{(n)}_0 (t-t_0)^n \\ \end{aligned}}$ .

In other words, path $q^{(m)} = 0$ for all $m>n$ .

The second case is when the path function $\bar f [q]$ requires no derivatives of $q$ with order higher than $n$ . For example:

…

— Me@2024-10-16 10:34:35 AM

Outlook 2010

Posted on November 15, 2024 by rpflee

<pre style="color: #333333;background-color: #ffffcc;font-size: 12pt;font-family:Calibri">
  <span style='mso-spacerun:yes'>  </span>...
</pre>

— Me@2024-11-15 01:42:34 AM

Euler problem 24.1.3

Posted on November 12, 2024 by rpflee

(defun fac (n)
  (labels
      ((f (m acc)
         (cond ((= m 0) acc)
               ('t (f (1- m) (* m acc))))))
    (f n 1)))

(defun string-to-list (str)
  (map 'list 'identity str))

(defun perms (ys k)
  (labels
      ((p (xs n acc)
         (if (null xs)
             (reverse acc)
             (let* ((m (fac (1- (length xs))))
                    (y (floor n m))
                    (x (nth y xs)))
               (p (delete x xs)
                  (mod n m)
                  (cons x acc))))))
    (p ys k nil)))

(concatenate 'string
             (perms (string-to-list "0123456789")
                    999999))

CL-USER> 
"2783915460"

— Me@2024-11-12 10:50:23 AM

Mounting a virtual disk

Posted on November 10, 2024 by rpflee

# In the host OS, if you want to read the contents of a virtual disk file:

mkdir ~/vdi_test_mount

sudo guestmount -a my_virtual_drive.vdi -m /dev/sda1 -o allow_other ~/vdi_test_mount

# After that, unmount the virtual disk:

sudo guestunmount ~/vdi_test_mount

rmdir ~/vdi_test_mount

— Me@2023-11-25 10:03:37 PM

Transform recursion into tail recursion

Posted on November 6, 2024 by rpflee

Remove a white dot from the photo | Euler problem 24.1.2

(defmacro detailn (fn (n)
                   (if endc
                       b-val
                       (op n (fn (ch n)))))
  (let ((acc (gensym)))
    `(defun ,fn (,n)
       (labels ((fn-iter (,n ,acc)
                  (if ,endc
                      ,acc
                      (fn-iter (,ch ,n)
                               (,op ,n ,acc)))))
         (fn-iter ,n ,b-val)))))

(detailn facn (m)
         (if (<= m 1)
             1
             (* m (facn (1- m)))))

(macroexpand '(detailn fac (m)
               (if (<= m 1)
                   1
                   (* m (fac (1- m))))))

— Fixed by GIMP’s Clone Tool

— Me@2024-10-30 12:42:22 PM

Ex 1.32 Path functions and state functions, 2.1

Posted on November 4, 2024 by rpflee

Structure and Interpretation of Classical Mechanics

1. The local-tuple function $f$ is the same as the local-tuple function $\bar \Gamma (\bar f)$ where $\bar f[q] = f \circ \Gamma [q]$ .

2. …

~~~

1. Equation

$\displaystyle{\begin{aligned} \bar f &= f \circ \Gamma \\ \end{aligned}}$

is the definition of $\bar f$ . And equation

$\displaystyle{\begin{aligned} f &= \bar \Gamma (\bar f) \\ \end{aligned}}$

is the definition of $\bar \Gamma$ . So, in theory,

$\displaystyle{\begin{aligned} f &= \bar \Gamma (\bar f) \\ \end{aligned}}$

is just true by definition.

In practice, their initial inputs are both the same local tuple

$\displaystyle{\begin{aligned} &(t, q(t), v(t), \cdots, q^{(n)}(t)) \\ \end{aligned}}$ ,

which has only a finite number of components. The path $q$ in the process is generated by that initial input:

$\displaystyle{\mathcal{O} (t,q,v, \cdots, q^{(n)})}$

So the function $\Gamma$ would get you back the exact local tuple from the osculating path:

$\displaystyle{(t,q,v,\cdots, q^{(n)}) = \Gamma[\mathcal{O} (t,q,v, \cdots, q^{(n)}](t)}$

In other words, since for the functions $\displaystyle{f}$ and $\displaystyle{\bar \Gamma (\bar f)}$ , neither input is the path itself, the identity is exact.

Conceptually,

(define (f local)
  (g local)) 
 
(define ((Gamma-bar f-bar) local)
  ((f-bar (osculating-path local)) (time local))) 

(define ((f-bar q) t)
  (f ((Gamma q) t))
 
;; (((f-bar q) 't)
;; == f((Gamma q) 't)
;; == f('t, (v 't), (a 't),...)

— Me@2024-10-16 10:34:35 AM

Euler problem 24.1.1

Posted on October 30, 2024 by rpflee

To formalize, if $a_0 < \ldots < a_n$ , then in the k-th permutation of $\{a_0, \ldots, a_n\}$ in lexicographic order, the leading entry is $a_q$ if $k = q(n!) + r$ for some $q \geq 0$ and $0 < r \leq n!$ . (Note that the definition of $r$ here is a bit different from the usual remainder, for which $0 \leq r < n!$ . Also, $a_q$ is the $(q+1)$ -th entry but not the $q$ -th entry in the sequence, because the index starts from 0.)

— edited Aug 30, 2011 at 18:23
— answered Aug 30, 2011 at 17:59
— user1551
— math stackexchange

Why $r$ Cannot Be Zero: If $r$ were allowed to be zero, it would imply that the leading entry of the permutation could be determined without any remaining elements to choose from, which contradicts the requirement of having a valid permutation. In other words, a remainder of zero would mean that we have perfectly divided $k$ by $n!$ , leading us to a situation where we would not be able to select the next element in the permutation sequence.

— AI Assistant

DSE 數學補邊個好？（神器六）

Posted on October 27, 2024 by rpflee

這篇文章繼續討論，選擇數學補習老師的一些準則。而這裡的數學，是指香港中學文憑試的數學科，包括核心，M1 及 M2。

如果你問我物理補習推介，特別是物理補習天王的話，我會答：「補 physics，補 Ken Chan！」但是，如果你問我數學補習天王的話，恕沒有推介，因為本人沒有遇過。

那樣，數學科補習界如果有 Ken Chan，他又必須具備，什麼條件呢？

上文提到：

……

3. 星期時間篇

他會告訴你，如何從平衡到駕馭，各科溫習時間之爭。

……

4.0 分秒時間篇

除了日常生活中的，溫習時間管理外，他亦會教你，考試答題時的時間策略。

……

4. $\infty$ 數學考試

＝兩成數學＋八成人格（速度＋準確度＋表達）

……

5. 超時空準備

他會持續教導你，比考試要求，還深一倍的題目。目的就是令你，有奪取滿分的機會。

作為「附加數學」的 M1 或 M2，主要作用是令你覺得，作為「普通數學」的核心數，簡單而容易。

水平提高了，原地就會在你之下。再困難的迷宮，如果有直升機的協助，就不用再怕。一來，你可以直升離開；二來，即使必須降回原地，單單是在直升機的那幾分鐘，足以讓你鳥瞰原地全境。

同理，如果要令自己「附加數」本身，有機會滿分的話，則要熟習「附加附加數」，即是大學一年級程度的數學。

迷宮必勝法，用直升機也；簡稱「降維打擊」。其先決條件是，你要花大量時間，預先「升維」。

— Me@2024-10-26 11:23:52 PM

Physics Town

continues

Category Archives: software