╭────────────────────────────── Results ───────────────────────────────╮
│ │
│ │
│ [l/NOU] Proposition: Acceptance of full step-size in globalized Newt│
│ [l/NMA] Theorem: Conditions for invertible R in QR factorization │
│ [l/NOU] Algorithm: Globalized Newton's method for unconstrained opti│
│ [l/CAL] Theorem: Leibniz integral rule │
│ [l/REA] Theorem: Sequence converging absolutely to zero also converg│
│ [l/STC] Proposition: Probability of nothing is zero │
│ [l/LNA] Theorem: Uniqueness of basis size │
│ [l/REA] Theorem: Bolzano-Weierstrass Theorem │
│ [l/LNA] Lemma: Gram-Schmidt on a basis does not produce zeros │
│ [l/FUN] Lemma: Bilinear forms send zeros to zeros │
╰──────────────────────────────────────────────────────────────────────╯
╭────────────────────────────── Theorems ──────────────────────────────╮
│> bz 10 / 1166│
╰──────────────────────────────────────────────────────────────────────╯{' '}
Searching "bz" in telescope. Notice the fuzzy matches!
This makes writing more of the book much quicker because linking theorems can be
automated into a few keystrokes.
## Generating new SHAs
Running `minimath label` at the root of this project with automatically label
all unlabelled [marks](#mark). If it sees a line that goes
```tex
\Proposition{The empty event has probability zero}
```
It will overwrite it with
```tex
\Proposition{The empty event has probability zero}\label{a0a9280}
```
So adding new [marks](#mark) is a seamless process.
# Appendix
## Why SHA?
The 7-character hashes used to uniquely identify [marks](#mark) in the project
will be called **SHAs**. They used to be randomly generated but now we're just
hashing the timestamp at which they are created, so they are rightfully hashes.
```rust
use std::hash::{Hash, Hasher, DefaultHasher};
use std::time::{SystemTime, UNIX_EPOCH};
const CHARSET: &[u8; 16] = b"abcdef0123456789";
fn random() -> [u8; 7] {
let mut s = DefaultHasher::new();
SystemTime::now().duration_since(UNIX_EPOCH).unwrap().hash(&mut s);
let mut u: u64 = s.finish();
std::array::from_fn(|_| CHARSET[((u % 16) as usize, u /= 16).0])
}
```
These are modelled after git's 40-character [SHA-1 hashes][git-docs-hash] to
uniquely identify commits. "40-character SHA-1 hash" is a mouthful, so the
community often call it something shorter in online discussions, often referring
to it as a hash, or more specifically, the hash of a commit. Given enough time,
some even started calling it a SHA.
- - GitHub documentation refers to it as a SHA
([source](https://docs.github.com/pull-requests/committing-changes-to-your-project/creating-and-editing-commits/about-commits)).
- - GitHub Action's environment variable referring to this entity is named
`GITHUB_SHA`
([source](https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/store-information-in-variables#default-environment-variables)).
- - StackOverflow discussions refer to them as SHA
([s1](https://stackoverflow.com/questions/18134627),
[s2](https://stackoverflow.com/questions/18134627),
[s3](https://stackoverflow.com/a/1552353/25049714)).
I've considered calling it a `Hash` but I've decided against that because `Hash`
is already a [Rust trait][Hash]. I've rejected the idea of `Tag` because the
repository also deals with `git` tags, so there might be some confusion. `Token`
technically works, but that brings in too many external ideas tied to
authentication or even machine learning.
And so within this project, these will hereby be known as SHAs. Now if you see a
line of Rust that goes
```rust
struct SHA([u8; 7]);
```
You'd know why.
-----BEGIN PGP SIGNATURE-----
iIcEARYKAC8WIQQGQ2nZKQaBbx4oz152/Vz+3Y5sMgUCajPo9REcYnJldzRrQGdt
YWlsLmNvbQAKCRB2/Vz+3Y5sMiN4AQCMkPo5+hcL2OT1xVJ2WYjFtFPzUrgkSIKD
tWbQj2t8ZAEAtz5+oROgK8sSXfnsYeTxoVGvR7j+jrQyK2eL9qYFHAY=
=3PEM
-----END PGP SIGNATURE-----