Add theorem commands

CS1527/assessment-2/.envrc

@@ -0,0 +1,2 @@
+export NIX_PATH="nixpkgs=flake:nixpkgs"
+use nix

CS1527/assessment-2/assessment2.py

@@ -0,0 +1,404 @@
+#!/usr/bin/env python
+"""Usage: `python assessment2.py {subcommand} {expressions}`
+
+If expressions are not provided, they are taken from each line of stdin.
+Documentation of subcommands is available from `python assessment2.py -h`.
+
+Examples for marking criteria:
+  1. Eval: `python assessment2.py eval "(((2*(3+2))+5)/2)"`
+  2. Tree: `python assessment2.py render-tree "(((2*(3+2))+5)/2)"`
+  3. Preorder:  `python assessment2.py format-prefix "(((2*(3+2))+5)/2)"`
+     In-order:  `python assessment2.py format-infix "(((2*(3+2))+5)/2)"`
+     Postorder: `python assessment2.py format-postfix "(((2*(3+2))+5)/2)"`
+  4. Errors: `python assessment2.py eval "(4*3*2)" "(4*(2))" "(4*(3+2)*(2+1))" "(2*4)*(3+2)" "((2+3)*(4*5)" "((2+3)*(4*5)" "(2+5)*(4/(2+2)))" "(2+5)*(4/(2+2)))" "(((2+3)*(4*5))+(1(2+3)))"`
+  5. Tests: `python assessment2.py test`
+
+Tests can be run with `pytest assessment2.py` or `python assessment2.py test`.
+
+All of the formatting is implemented with post-order traversals. This is
+necessary to output parenthesis in the pre- and in-order cases. It could also be
+done with a buffer and a combined traversal (with callbacks before, between, and
+after subtree visits), but that requires mutation.
+
+Note: this program requires Python 3.12 due to the generic syntax used to define
+`BTree.traverse`. Pytest is also required. These should be installed already
+on Codio.
+"""
+# stdlib
+from dataclasses import dataclass
+from typing import Literal, Tuple, Callable, cast, override
+from operator import add, sub, mul, truediv as div
+from argparse import ArgumentParser
+import sys
+import re
+from textwrap import dedent
+
+# pytest, from https://pypi.org/project/pytest/
+# authors can be found at https://github.com/pytest-dev/pytest/graphs/contributors,
+import pytest
+
+OPERATORS: dict[Literal["+", "-", "*", "/"], Callable[[float, float], float]] = {
+    "+": add,
+    "-": sub,
+    "*": mul,
+    "/": div,
+}
+
+
+class BTree:
+    value: float
+
+    def traverse[T](
+        self,
+        value: Callable[["Value", int], T],
+        operator: Callable[["Operator", T, T, int], T],
+        depth: int = 0,
+    ) -> T:
+        """Traverse the binary tree with a post-order traversal
+
+        `value` takes the value node and its depth from the root node
+        `operator` takes the operator node, the results of traversing the left
+            and right subtrees, and the depth of the node
+
+        The tree could, for example, be evaluated with `traverse`:
+            ```
+                (...).traverse(
+                    lambda node, _: node.value,
+                    lambda node, left, right, _: OPERATORS[node.operator](left, right)
+                )
+            ```
+        """
+        raise NotImplementedError
+
+    def as_preorder_str(self) -> str:
+        """Format the tree in prefix notation"""
+        return self.traverse(
+            lambda value, _: str(value.value),
+            lambda op, left, right, _: f"({op.operator} {left} {right})",
+        )
+
+    def as_inorder_str(self) -> str:
+        """Format the tree as a typical parenthesized expression"""
+        return self.traverse(
+            lambda value, _: str(value.value),
+            lambda op, left, right, _: f"({left} {op.operator} {right})",
+        )
+
+    __str__ = as_inorder_str
+
+    def as_inorder_lines(self) -> str:
+        """Format the tree, visually as a tree"""
+        return self.traverse(
+            lambda value, depth: " " * depth + str(value.value),
+            lambda op, left, right, depth: f"{left}\n{' ' * depth}{op.operator}\n{right}",
+        )
+
+    def as_postorder_str(self) -> str:
+        """Format the tree in postfix notation (RPN)"""
+        return self.traverse(
+            lambda value, _: str(value.value),
+            lambda op, left, right, _: f"{left} {right} {op.operator}",
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class Value(BTree):
+    value: float
+
+    @override
+    def traverse[T](
+        self,
+        value: Callable[["Value", int], T],
+        operator: Callable[["Operator", T, T, int], T],
+        depth: int = 0,
+    ) -> T:
+        """Traverse the binary tree with a post-order traversal
+
+        `value` takes the value node and its depth from the root node
+        `operator` takes the operator node, the results of traversing the left
+            and right subtrees, and the depth of the node
+
+        The tree could, for example, be evaluated with `traverse`:
+            ```
+                (...).traverse(
+                    lambda node, _: node.value,
+                    lambda node, left, right, _: OPERATORS[node.operator](left, right)
+                )
+            ```
+        """
+
+        return value(self, depth)
+
+
+@dataclass(frozen=True, slots=True)
+class Operator(BTree):
+    operator: Literal["+", "-", "*", "/"]
+    left: BTree
+    right: BTree
+
+    @property
+    def value(self) -> float:  # type: ignore - the field should be read-only
+        return OPERATORS[self.operator](self.left.value, self.right.value)
+
+    @override
+    def traverse[T](
+        self,
+        value: Callable[["Value", int], T],
+        operator: Callable[["Operator", T, T, int], T],
+        depth: int = 0,
+    ) -> T:
+        """Traverse the binary tree with a post-order traversal
+
+        `value` takes the value node and its depth from the root node
+        `operator` takes the operator node, the results of traversing the left
+            and right subtrees, and the depth of the node
+
+        The tree could, for example, be evaluated with `traverse`:
+            ```
+                (...).traverse(
+                    lambda node, _: node.value,
+                    lambda node, left, right, _: OPERATORS[node.operator](left, right)
+                )
+            ```
+        """
+
+        return operator(
+            self,
+            self.left.traverse(value, operator, depth + 1),
+            self.right.traverse(value, operator, depth + 1),
+            depth,
+        )
+
+
+def parse(expr: str) -> BTree:
+    """Parse a parenthesized expression as in the spec.
+
+    Requires a single parenthesized string, potentially with whitespace
+    Raises ValueError on parse errors
+    """
+
+    def number(expr: str) -> Tuple[BTree, str] | None:
+        if not expr[0].isdigit():
+            return None
+        rest = expr.lstrip("0123456789")
+        return Value(int(expr[: len(expr) - len(rest)])), rest.lstrip()
+
+    def parenthesized(expr: str) -> Tuple[BTree, str] | None:
+        if not expr.startswith("("):
+            return None
+        expr = expr[1:].lstrip()
+
+        left, expr = operand(expr)
+
+        operator, expr = expr[0], expr[1:]
+        if operator not in OPERATORS:
+            raise ValueError(f"Unknown operator {operator}")
+        operator = cast(Literal["+", "-", "*", "/"], operator)
+
+        right, expr = operand(expr.lstrip())
+
+        if not expr.startswith(")"):
+            if expr and expr[0] in OPERATORS:
+                raise ValueError("Too many operands in expression")
+            raise ValueError("Expected closing parenthesis")
+        return Operator(operator, left, right), expr[1:].lstrip()
+
+    def operand(expr: str) -> Tuple[BTree, str]:
+        v = number(expr) or parenthesized(expr)
+        if not v:
+            raise ValueError(
+                "Expected a number or the beginning of a parenthesized expression"
+            )
+        return v
+
+    result = parenthesized(expr.lstrip())
+    if not result or result[1]:
+        # If rest is non-empty, then something was after the parenthesis starting the expression
+        # i.e. the full expression was not parenthesized.
+        raise ValueError("Expected parenthesized expression at the top level")
+
+    return result[0]
+
+
+@pytest.mark.parametrize(
+    ("expr", "ast"),
+    [
+        ("(1 + 1)", Operator("+", Value(1), Value(1))),
+        (
+            "(2*(3+ 2))",
+            Operator("*", Value(2), Operator("+", Value(3), Value(2))),
+        ),
+        (" (1 +1) ", Operator("+", Value(1), Value(1))),
+    ],
+)
+def test_parse(expr: str, ast: BTree):
+    """Test parsing of expressions"""
+    assert parse(expr) == ast
+
+
+@pytest.mark.parametrize(
+    ("expr", "value"),
+    [
+        ("(1 + 2)", 3),
+        ("(12 + (((4 / 2) * 3) + (3 * 2)))", 24),
+        ("(((2 * (3 + 2)) + 5) / 2)", 7.5),
+    ],
+)
+def test_eval(expr: str, value: float):
+    """Test evaluation"""
+    assert parse(expr).value == value
+
+
+@pytest.mark.parametrize(
+    ("expr", "tree"),
+    [
+        (
+            "(1 + 2)",
+            """
+                 1
+                +
+                 2
+            """,
+        ),
+        (
+            "(1 + (((4 / 2) * 3) + (3 * 2)))",
+            """
+                 1
+                +
+                    4
+                   /
+                    2
+                  *
+                   3
+                 +
+                   3
+                  *
+                   2
+            """,
+        ),
+        (
+            "(((2*(3+2))+5)/2)",
+            """
+                   2
+                  *
+                    3
+                   +
+                    2
+                 +
+                  5
+                /
+                 2
+            """
+        )
+    ],
+)
+def test_inorder_lines(expr: str, tree: str):
+    """Test tree rendering"""
+    assert parse(expr).as_inorder_lines() == dedent(tree).strip("\n")
+
+
+@pytest.mark.parametrize(
+    ("expr", "prefix"),
+    [
+        ("(1 + 2)", "(+ 1 2)"),
+        ("(1 + (((4 / 2) * 3) + (3 * 2)))", "(+ 1 (+ (* (/ 4 2) 3) (* 3 2)))"),
+    ],
+)
+def test_prefix(expr: str, prefix: str):
+    """Test prefix formatting"""
+    assert parse(expr).as_preorder_str() == prefix
+
+
+@pytest.mark.parametrize(
+    ("expr"),
+    [
+        "(1 + 2)",
+        "(1 + (((4 / 2) * 3) + (3 * 2)))",
+        "(((3 + 2) * 2) + (((7 / 3) * 5) - 3))",
+    ],
+)
+def test_infix_roundtrip(expr: str):
+    """Test infix formatting roundtrips"""
+    assert str(parse(expr)) == expr
+
+
+@pytest.mark.parametrize(
+    ("expr", "postfix"),
+    [
+        ("(1 + 2)", "1 2 +"),
+        ("(1 + (((4 / 2) * 3) + (3 * 2)))", "1 4 2 / 3 * 3 2 * + +"),
+    ],
+)
+def test_postfix(expr: str, postfix: str):
+    """Test postfix formatting"""
+    assert parse(expr).as_postorder_str() == postfix
+
+
+@pytest.mark.parametrize(
+    ("expr", "err"),
+    [
+        ("(4 * 3 * 2)", "Too many operands in expression"),
+        ("(4 * (2))", "Unknown operator )"),
+        ("(4 * (3 + 2) * (2 + 1))", "Too many operands in expression"),
+        ("(2 *4)*(3+2)", "Expected parenthesized expression at the top level"),
+        ("(2+5)*(4/(2+2))", "Expected parenthesized expression at the top level"),
+        ("(((2+3)*(4*5))+(1(2+3)))", "Unknown operator ("),
+    ],
+)
+def test_error(expr: str, err: str):
+    """Test error messages"""
+    with pytest.raises(ValueError, match=re.escape(err)):
+        parse(expr)
+
+
+if __name__ == "__main__":
+    parser = ArgumentParser(usage=__doc__)
+    subcommands = parser.add_subparsers(title="Subcommands", required=True)
+
+    def with_expressions(parser):
+        parser.add_argument(
+            "expressions",
+            nargs="*",
+            help="The expressions to operate on. If none are provided, operate on lines of stdin.",
+        )
+        return parser
+
+    with_expressions(
+        subcommands.add_parser("eval", help="Evaluate the expression")
+    ).set_defaults(func=lambda expr: expr.value)
+    with_expressions(
+        subcommands.add_parser("render-tree", help="Render the expression as a tree")
+    ).set_defaults(func=BTree.as_inorder_lines)
+    with_expressions(
+        subcommands.add_parser(
+            "format-prefix", help="Format the expression in prefix notation"
+        )
+    ).set_defaults(func=BTree.as_preorder_str)
+    with_expressions(
+        subcommands.add_parser(
+            "format-infix",
+            help="Format the expression in typical parenthesized infix notation",
+        )
+    ).set_defaults(func=BTree.as_inorder_str)
+    with_expressions(
+        subcommands.add_parser(
+            "format-postfix",
+            help="Format the expression in postfix notation, i.e. as RPN",
+        )
+    ).set_defaults(func=BTree.as_postorder_str)
+    subcommands.add_parser("test", help="Run tests").set_defaults(
+        func=lambda: pytest.main([__file__])
+    )
+    args = parser.parse_args()
+    if "expressions" in args:
+        for expression in args.expressions or sys.stdin:
+            if len(args.expressions) > 1:
+                print(expression + ":")
+            try:
+                parsed = parse(expression)
+            except ValueError as e:
+                print(f"Error: {e}")
+                continue
+            print(args.func(parsed))
+    else:
+        args.func()

CS1527/assessment-2/shell.nix

@@ -0,0 +1,3 @@
+{ pkgs ? import <nixpkgs> {} }: pkgs.mkShell {
+  packages = [(pkgs.python312.withPackages (p: with p; [ python-lsp-server pytest pytest-watch black ])) pkgs.nodePackages.pyright];
+}

MA1511/sets.tex

@@ -254,11 +254,11 @@ $+$ and $\times$ on $\Z/k$:
 \section*{Countable Sets}
 A set $X$ is finite if $\exists n \geq 0. $ a bijection $\{1, ...n\} \to X$ \\
 Pigeonhole Principle: for finite $X$, any injective $f: X \to X$ is also surjective. \\
-$\N$ is infinite. Proof: $f: \N \to \N$ is trivially injective, and $\neg\exists x.~f(x) = 0$, and so not surjective. \\
+$\N$ is infinite. Proof: $f: \N \to \N $ defined by $ f(x) = x + 1$ is trivially injective, and $\neg\exists x.~f(x) = 0$, and so not surjective. \\
 By the inverse of the Pigeonhole Principle, $\N$ is infinite.\\
 A set $X$ is \emph{countably infinite} iff there exists a bijection $\N \to X$. \\
 A set is \emph{countable} iff it is finite or countably infinite. \\
-Any subset of $\N$ is countable. Proof: Let $X \in \N$.\\
+Any subset of $\N$ is countable. Proof: Let $X \subseteq \N$.\\
 If $X$ is finite, it's trivially countable.
 Otherwise, $X$ is infinite and it must be shown that $X$ is countably infinite. \\
 For $k \in \N$, $X_{>k} = \{ n \in X | n > k \}$. Then $X_{>k} \not= \varnothing$, as $X$ would be a subset of $\{1..k\}$ and would be finite. \\

MA2008/2024-09-24

@@ -0,0 +1 @@
+

MA2008/decls.tex

@@ -0,0 +1,76 @@
+\documentclass[fleqn]{article}
+\usepackage{amsmath,amssymb,amsthm}
+\usepackage[margin=0.25in]{geometry}
+\usepackage{enumitem}
+\usepackage{systeme}
+\usepackage{mathtools}
+
+\date{}
+\author{}
+
+\newcommand{\paren}[1]{\left(#1\right)}
+\newcommand{\powerset}[1]{\mathcal{P}\paren{#1}}
+\renewcommand{\Re}[1]{\operatorname{\mathbb{R}e}\paren{#1}}
+\renewcommand{\Im}[1]{\operatorname{\mathbb{{I}}m}\paren{#1}}
+\newcommand{\C}{\mathbb{C}}
+\newcommand{\N}{\mathbb{N}}
+\newcommand{\Z}{\mathbb{Z}}
+\newcommand{\Q}{\mathbb{Q}}
+\newcommand{\R}{\mathbb{R}}
+\newcommand{\conj}[1]{\overline{#1}}
+\renewcommand{\mod}[1]{\left|#1\right|}
+\newcommand{\abs}[1]{\left|#1\right|}
+\newcommand{\polar}[2]{#1\paren{\cos{\paren{#2}} + i\sin{\paren{#2}}}}
+\newcommand{\adj}[1]{\operatorname{adj}#1}
+\newcommand{\card}[1]{\left|#1\right|}
+\newcommand{\littletaller}{\mathchoice{\vphantom{\big|}}{}{}{}}
+\newcommand{\restr}[2]{{% we make the whole thing an ordinary symbol
+  \left.\kern-\nulldelimiterspace % automatically resize the bar with \right
+  #1 % the function
+  \littletaller % pretend it's a little taller at normal size
+  \right|_{#2} % this is the delimiter
+  }}
+
+\makeatletter
+\renewcommand*{\env@matrix}[1][*\c@MaxMatrixCols c]{%
+  \hskip -\arraycolsep
+  \let\@ifnextchar\new@ifnextchar
+  \array{#1}}
+\makeatother
+
+
+% https://gitlab.com/jim.hefferon/linear-algebra/-/blob/master/src/sty/linalgjh.sty
+\newlength{\grsteplength}
+\setlength{\grsteplength}{1.5ex plus .1ex minus .1ex}
+
+\newcommand{\grstep}[2][\relax]{%
+   \ensuremath{\mathrel{
+       \hspace{\grsteplength}\mathop{\longrightarrow}\limits^{#2\mathstrut}_{
+                                     \begin{subarray}{l} #1 \end{subarray}}\hspace{\grsteplength}}}}
+\newcommand{\repeatedgrstep}[2][\relax]{\hspace{-\grsteplength}\grstep[#1]{#2}}
+
+\newcommand{\swap}{\leftrightarrow}
+
+% https://tex.stackexchange.com/a/198806
+\makeatletter
+\newcommand{\subalign}[1]{%
+  \vcenter{%
+    \Let@ \restore@math@cr \default@tag
+    \baselineskip\fontdimen10 \scriptfont\tw@
+    \advance\baselineskip\fontdimen12 \scriptfont\tw@
+    \lineskip\thr@@\fontdimen8 \scriptfont\thr@@
+    \lineskiplimit\lineskip
+    \ialign{\hfil$\m@th\scriptstyle##$&$\m@th\scriptstyle{}##$\hfil\crcr
+      #1\crcr
+    }%
+  }%
+}
+\makeatother
+
+\theoremstyle{definition}
+\newtheorem*{theorem}{Theorem}
+\newtheorem*{lemma}{Lemma}
+\newtheorem*{corollary}{Corollary}
+
+\theoremstyle{remark}
+\newtheorem*{note}{Note}

MA2008/linear-transforms.tex

@@ -0,0 +1,27 @@
+\input{decls.tex}
+\title{Vector Spaces and Linear Transformations}
+\begin{document}
+\maketitle
+
+\begin{description}
+\item[Linear Transformation] A function $\phi: V \to W$ between vector spaces $V$ and $W$ (over some field $K$), such that
+	\begin{align*}
+		\phi(v + w) & \equiv \phi(v) + \phi(w) \\
+		\phi(x \cdot v) & \equiv x \cdot \phi(v) \tag{For $x \in K$}
+	\end{align*}
+\end{description}
+
+Differentiation is a linear transformation.
+Solutions to $f'' + f = 0$ for function $f$ are a vector space.
+
+\begin{theorem}
+For any scalars $\lambda, \mu \in \R$, there is a unique solution such that $f(0) = \mu$ and $f'(0) = \lambda$
+\end{theorem}
+The vector space is then two-dimensional, with basis $sin(x), cos(x)$
+
+
+\subsection*{}
+Vector spaces are used over finite fields in \emph{Algebraic Coding Theory}. The field is $\mathbb{F}_2 = \{0, 1\}$ - the integers mod 2.
+Binary strings of length $n$ are then a vector space over $\mathbb{F}_2^n$.
+ECC can be based on vector subspaces of $F_2^n$. (Vector subspaces are closed subsets of a vector space).
+\end{document}

MA2008/tmpl.tex

@@ -0,0 +1,6 @@
+\input{decls.tex}
+\title{}
+\begin{document}
+\maketitle
+
+\end{document}