fix: typo

o(n^3) -> o(3^n)

README.md

@@ -0,0 +1,118 @@
+# Typst Project Template with Automated Releases
+
+This repository serves as a template for creating documents with [Typst](https://typst.app/), a modern, markup-based typesetting system. It includes a pre-configured GitHub Actions workflow that automatically compiles your document and creates a GitHub Release whenever you push a new version tag.
+
+## Features
+
+- **Automated PDF Compilation**: Automatically compiles `main.typ` into `main.pdf` on every run.
+- **Dependency Caching**: Uses `typst-community/setup-typst` to cache dependencies listed in `requirements.typ`, speeding up subsequent builds.
+- **Automatic Releases**: Creates a new GitHub Release with the compiled PDF attached whenever a tag matching the `v*.*.*` pattern is pushed.
+- **Manual Workflow Trigger**: Allows for manual builds directly from the GitHub Actions tab, perfect for testing changes without creating a release.
+
+## File Structure
+
+```bash
+.
+├── .github/
+│   └── workflows/
+│       └── release.yml     # The GitHub Actions workflow definition.
+├── main.typ                # Your main Typst document entry point.
+├── requirements.typ        # List your Typst package dependencies here.
+├── bibliography.yml        # A sample bibliography file (if needed).
+└── README.md               # This file.
+```
+
+- **`main.typ`**: This is the heart of your document. All your content should start here.
+- **`requirements.typ`**: If your project uses external Typst packages, you should specify them here. The workflow will automatically fetch and cache them. For example:
+
+```typst
+#import "@preview/fletcher:0.5.8"
+#import "@preview/physica:0.9.5"
+```
+
+- **`.github/workflows/release.yml`**: This file defines the Continuous Integration/Continuous Deployment (CI/CD) pipeline. See the "Workflow Breakdown" section below for a detailed explanation.
+
+## How to Use This Template
+
+There are two primary ways to use the automation provided in this template.
+
+### Method 1: Creating a Release/Tag (Recommended)
+
+This is the standard way to publish a new version of your document. The workflow will automatically create a GitHub Release and attach your compiled PDF.
+
+1. **Commit Your Changes**: Make sure all your latest changes to the `.typ` files are committed to your main branch.
+
+```bash
+git add .
+git commit -m "Finalize version 1.0.0"
+```
+
+2. **Tag the Version**: Create a new Git tag that follows the semantic versioning format (e.g., `v1.0.0`, `v1.2.3`).
+
+```bash
+git tag v1.0.0
+```
+
+3. **Push the Tag**: Push your commits and the new tag to GitHub.
+
+```bash git push origin main
+git push origin v1.0.0
+```
+
+Once the tag is pushed, the "Release" workflow will automatically start. It will compile `main.typ` and create a new release on your repository's "Releases" page, named `v1.0.0 — <current_date>`, with `main.pdf` attached as an asset.
+
+### Method 2: Manual Build for Testing
+
+If you want to compile the PDF to see the result without creating a public release, you can trigger the workflow manually.
+
+1. Navigate to the **Actions** tab in your GitHub repository.
+2. In the left sidebar, click on the **Release** workflow.
+3. You will see a message: "This workflow has a `workflow_dispatch` event trigger." Click the **Run workflow** dropdown button.
+4. You will be prompted to enter a `version` string. This is for informational purposes in the run log; you can enter any value (e.g., `test-build`).
+5. Click the green **Run workflow** button.
+
+The workflow will run, but the final "Release" step will be skipped. You can download the compiled `main.pdf` from the "Artifacts" section on the summary page for that workflow run.
+
+## Workflow Breakdown (`release.yml`)
+
+The automation is powered by the `.github/workflows/release.yml` file. Here is a step-by-step explanation of what it does.
+
+### Triggers
+
+The workflow is triggered by two events:
+
+1. **`push: tags:`**: Runs automatically when a tag matching the pattern `v[0-9]+.[0-9]+.[0-9]+*` is pushed.
+2. **`workflow_dispatch:`**: Allows the manual execution described above.
+
+### Permissions
+
+- `contents: write`: This is essential. It grants the workflow permission to create GitHub Releases and upload files (artifacts) to them.
+
+### Job: `build`
+
+The workflow consists of a single job named `build` that runs on an `ubuntu-latest` virtual machine.
+
+- **`actions/checkout@v4`**: This step checks out your repository's code so the workflow can access your `.typ` files.
+
+- **`typst-community/setup-typst@v4`**: This community action installs the specified version of Typst (`0.13`). The `cache-dependency-path` key is configured to look at `requirements.typ`, enabling caching of Typst packages to make future runs faster.
+
+- **`Compile Typst files`**: A simple shell command that runs the Typst compiler, taking `main.typ` as input and producing `main.pdf`.
+
+```bash
+typst compile main.typ main.pdf
+```
+
+- **`Upload PDF file`**: This step uses `actions/upload-artifact@v4` to save the generated `main.pdf` as a workflow artifact. This is useful for every run, as it allows you to download the PDF even if a release isn't created.
+
+- **`Get current date`**: Creates a timestamp that is used in the release name for uniqueness.
+
+- **`softprops/action-gh-release@v1`**: This is the final step that creates the release.
+  - `if: github.ref_type == 'tag'`: This crucial condition ensures this step **only runs if the workflow was triggered by a tag**. It is skipped during manual `workflow_dispatch` runs.
+  - `name: "${{ github.ref_name }} — ${{ env.DATE }}"`: Sets the release title to the tag name (e.g., `v1.0.0`) plus the date.
+  - `files: main.pdf`: Attaches the compiled `main.pdf` to the release.
+
+## Customization
+
+- **Typst Version**: To use a different version of Typst, simply change the `typst-version` in the `release.yml` file.
+- **Main File**: If your main Typst file is not named `main.typ`, you will need to update the `Compile Typst files` and `Release` steps in `release.yml`.
+- **Release Assets**: You can add more files to the release (e.g., a ZIP of the source code) by modifying the `files:` list in the `Release` step.

main.typ

@@ -488,14 +488,6 @@ ka $L in NP$ un ka $SAT <_p L$ (vai jebkura cita zināma NP-pilna problēma).
   - Ja $A(x) = 1$, tad $T(x) = 1$.
   - Ja $A(x) = 0$, tad $T(x) = 0$ vai $T(x)$ neapstājas.
 
-Tas, ka problēma ir daļēji atrisināma, nozīmē, ka nav konkrēta un *vispārīga*
-algoritma, kas vienmēr varētu sniegt pareizu "nē" atbildi gadījumiem ārpus
-problēmas.
-
-Var būt iespējams konstruēt Tjūringa mašīnu, kas apstājas un sniedz
-"nē" atbildi noteiktiem gadījumiem ārpus problēmas, bet tas nav garantēts
-visiem gadījumiem (_un īsti nav apskatīts šajā kursā_).
-
 #teo[$A$ -- daļēji atrisināma tad un tikai tad, ja $A$ -- algoritmiski sanumurējama.]
 
 Cits nosaukums daļējai atrisināmībai ir atpazīstamība (angl.
@@ -505,8 +497,8 @@ recognizability/recognizable).
 
 Problēma $A$, kurai neviena no $A$, $overline(A)$ nav daļēji atrisināma?
 
-- $"EQUIV"(M_1, M_2) = 1$, ja $forall x: M_1(x) = M_2(x)$.
-- $overline("EQUIV")(M_1, M_2) = 1$, ja $exists x: M_1(x) != M_2(x)$.
+- $equiv(M_1, M_2) = 1$, ja $forall x: M_1(x) = M_2(x)$.
+- $overline(equiv)(M_1, M_2) = 1$, ja $exists x: M_1(x) != M_2(x)$.
 
 
 = Nekustīgo punktu teorija
@@ -560,11 +552,11 @@ QED.
 Notācija, kas tiek izmantota, lai raksturotu *funkciju* sarežģītību
 asimptotiski.
 
-=== Lielais-O (formālā definīcija)
+=== Lielais-$O$ (formālā definīcija)
 
 $f(n) in O(g(n))$, ja:
 
-$exists C > 0, exists n_0 > 0:$ $(forall n >= n_0: f(n) <= c * g(n))$
+$exists C > 0, exists n_0 > 0:$ $(forall n >= n_0: f(n) <= c dot g(n))$
 
 Tas nozīmē, ka funkcija $f(n)$ asimptotiski nepārsniedz konstanti $c$ reizinātu
 $g(n)$.
@@ -651,7 +643,7 @@ Tātad vienādojums ir
 patiess.
 
 === Piemērs (mazais-$o$)
-$ 2^n n^2 =^? o(n^3) $
+$ 2^n n^2 =^? o(3^n) $
 
 Pēc tās pašas aprakstītās īpašības, kā @small-o-example-3, sanāktu
 $ lim_(n->oo) (2^n n^2)/3^n $
@@ -757,6 +749,9 @@ $
   U_c "TIME" (N^c) = P
 $
 
+Labs mentālais modelis, lai pierādītu, ka algoritms pieder $"LOGSPACE"$ -- ja
+var iztikt ar $O(1)$ mainīgo daudzumu, kur katrs mainīgais ir no $0$ līdz $N$
+vai noteikts fiksētu vērtību skaits.
 
 === Laika-Telpas sakarības
 
@@ -764,7 +759,7 @@ $
   Ja $f(n) >= log N$, tad
   $
     "TIME"(f(N)) subset.eq "SPACE"(f(N)) subset.eq \
-    subset.eq U_c "TIME" (c^(f(N)))
+    subset.eq union.big_c "TIME" (c^(f(N)))
   $
 ]
 
@@ -772,7 +767,7 @@ Laiks $O(f(N)) ->$ atmiņa $O(f(N))$.
 
 === Asimptotiskas augšanas hierarhija
 
-Sekojošas funkcijas pieaugums pie $x -> infinity$:
+Sekojošas funkcijas pieaugums pie $x -> oo$:
 
 $log(x) << x << x dot log(x) << x^k << a^x << x! << x^x$
 
@@ -787,7 +782,36 @@ _$x^epsilon$ ir izņemts laukā, lai nejauktu galvu_
 
 _Source; Mathematics for Computer Science, 2018, Eric Lehman, Google Inc._
 
-= Klase P (TODO)
+= Klase P
+
+== Definīcija
+
+Klase $P$ ir problēmu kopa, ko var atrisināt ar deterministisku Tjūringa mašīnu
+polinomiālā laikā.
+
+- $P=union.big_k "TIME"(n^k)$
+
+Citiem vārdiem: problēma pieder $P$, ja eksistē deterministiska Tjūringa
+mašīna, kas to atrisina O($n^k$) soļos, kādai konstantei $k$.
+
+Klase $P$ tiek uzskatīta par praktiski atrisināmo problēmu klasi. Visi
+saprātīgie deterministiskie skaitļošanas modeļi ir polinomiāli ekvivalenti
+(vienu var simulēt ar otru polinomiālā laikā).
+
+== Piemērs ($"PATH"$)
+
+- Dots grafs $G$ un divas virsotnes $u$, $v$.
+- Jautājums: vai eksistē ceļš no $u$ uz $v$?
+- Rupjais-spēks: pārbaudīt visus ceļus -- eksponenciāls laiks.
+- Efektīvs algoritms: meklēšana plašumā (breadth-first search); laika
+  sarežģītība: $O(abs(V) + abs(E))$.
+
+== Piemērs ($"RELPRIME"$)
+
+- Doti skaitļi $x$, $y$ (binārā kodējumā).
+- Jautājums: vai skaitļi ir savstarpēji pirmskaitļi?
+- Efektīvs algoritms: Eiklīda algoritms (izmantojot $mod$); laika sarežģītība:
+  $O(log n)$ (jo katrā iterācijā skaitļi būtiski samazinās).
 
 = Klase NP
 
@@ -796,15 +820,17 @@ _Source; Mathematics for Computer Science, 2018, Eric Lehman, Google Inc._
 #NP (nederminēti-polinomiālas) problēmas
 ir problēmas (2 ekvivalentas definīcijas):
 
-+ $L in NP$, ja eksistē pārbaudes algoritms - $O(n^c)$ laika Tjūringa mašīna $M$:
++ $L in NP$, ja eksistē pārbaudes algoritms -- $O(n^c)$ laika Tjūringa mašīna $M$:
   + Ja $L(x) = 1$, tad eksistē y: $M(x, y) = 1$.
   + Ja $L(x) = 0$, tad visiem y: $M(x, y) = 0$.
+  + _Informācija $y$ var saturēt brīvi definētu informāciju._
+  + _Pārbaudes algoritmā tas ir risinājums, ko tas pārbauda._
 + #NP = problēmas $L$, ko var atrisināt ar nedeterminētu mašīnu $O(n^c)$ laikā.
 
 Ekvivalence ir pierādīta ar abpusēju pārveidojumu no pārbaudītāja uz nedet.
 #TM un atpakaļ.
 
-== NP-pilnas probēmas un to redukcijas
+== NP-pilnas problēmas un to redukcijas
 
 === Polinomiāla redukcija $(<=#sub("poly"))$
 
@@ -883,11 +909,11 @@ Vai dotā lineāru nevienādību sistēma ar bināriem mainīgajiem ir atrisinā
   $x_n$) ievieš jaunus mainīgos $y_i$.
 - Katriem vārtiem formulē atbilstošas izteiksmes.
 
-Piemērs AND vārtiem. Nosaucam ievades kā x, y un izvadi kā z: $z = x and y$
+Piemērs `AND` vārtiem. Nosaucam ievades kā x, y un izvadi kā z: $z = x and y$
 
 #table(
   columns: 4,
-  [*$x$*], [*$y$*], [*$z$*], [*$z = x and z$?*],
+  [*$x$*], [*$y$*], [*$z$*], [*$z = x and y$?*],
   $0$, $0$, $0$, [jā],
   $0$, $0$, $1$, [nē],
   $0$, $1$, $0$, [jā],
@@ -980,42 +1006,43 @@ Vārdiski. Jauns grafs $G$, kurā ir visas virsotnes no $V$, bet
 visas šķautnes, kas ir $G$ nav $G'$ un pretēji -- visas šķautnes
 kā nav $G$ ir $G'$.
 
-#figure(diagram(
-  cell-size: 1mm,
-  node-stroke: 0pt,
-  spacing: 1em,
-  node-shape: circle,
-  // phantom location nodes
-  dot-node((0, 0), <b1>),
-  dot-node((-2, 1), <a1>),
-  dot-node((0, 2), <c1>),
+#figure(
+  diagram(
+    cell-size: 1mm,
+    node-stroke: 0pt,
+    spacing: 1em,
+    node-shape: circle,
+    // phantom location nodes
+    dot-node((0, 0), <b1>),
+    dot-node((-2, 1), <a1>),
+    dot-node((0, 2), <c1>),
 
-  dot-node((0, 4), <b2>),
-  dot-node((-2, 5), <a2>),
-  dot-node((0, 6), <c2>),
+    dot-node((0, 4), <b2>),
+    dot-node((-2, 5), <a2>),
+    dot-node((0, 6), <c2>),
 
-  // label nodes
-  node((rel: (0.7em, 0.7em), to: <b1>), $B$),
-  node((rel: (-0.7em, 0em), to: <a1>), $A$),
-  node((rel: (0.7em, 0.7em), to: <c1>), $C$),
-  node((1, 1), text(green, $G$)),
+    // label nodes
+    node((rel: (0.7em, 0.7em), to: <b1>), $B$),
+    node((rel: (-0.7em, 0em), to: <a1>), $A$),
+    node((rel: (0.7em, 0.7em), to: <c1>), $C$),
+    node((1, 1), text(green, $G$)),
 
-  node((rel: (0.7em, 0.7em), to: <b2>), $B$),
-  node((rel: (-0.7em, 0em), to: <a2>), $A$),
-  node((rel: (0.7em, 0.7em), to: <c2>), $C$),
-  node((1.6, 5), text(green, $G "papildinājums"$)),
+    node((rel: (0.7em, 0.7em), to: <b2>), $B$),
+    node((rel: (-0.7em, 0em), to: <a2>), $A$),
+    node((rel: (0.7em, 0.7em), to: <c2>), $C$),
+    node((1.6, 5), text(green, $G "papildinājums"$)),
 
-  edge(<a1>, <b1>),
-  edge(<c1>, <b1>, "--", stroke: yellow),
-  edge(<c1>, <a1>),
-  edge(<a2>, <b2>, "--", stroke: yellow),
-  edge(<c2>, <b2>),
-  edge(<c2>, <a2>, "--", stroke: yellow),
-)),
-caption: "Papildgrafa piemērs",
+    edge(<a1>, <b1>),
+    edge(<c1>, <b1>, "--", stroke: yellow),
+    edge(<c1>, <a1>),
+    edge(<a2>, <b2>, "--", stroke: yellow),
+    edge(<c2>, <b2>),
+    edge(<c2>, <a2>, "--", stroke: yellow),
+  ),
+  caption: "Papildgrafa piemērs",
 )
 
-Ir spēkā sakarība $"INDSET"(G, k) = "CLIQUE"(G, k)$.
+Ir spēkā sakarība $"INDSET"(G, k) = "CLIQUE"(G', k)$.
 
 = Extras
 
@@ -1046,6 +1073,14 @@ Ir spēkā sakarība $"INDSET"(G, k) = "CLIQUE"(G, k)$.
       log_8(3x-4)=log_8(5x+2) \
       "so," 3x-4=5x+2
     $,
+
+    [Pow. to log],
+    $
+      a^(log_a (x)) = x
+    $,
+    $
+      2^(log_2 (x)) = x
+    $,
   ))
 ]
 
@@ -1065,6 +1100,7 @@ Ir spēkā sakarība $"INDSET"(G, k) = "CLIQUE"(G, k)$.
     $ e^x $, $ e^x $, "",
     $ a^x $, $ a^x ln(a) $, $ a > 0 $,
     $ ln(x) $, $ 1 / x $, "",
+    $ log_a (x) $, $ 1 / (x ln(a)) $, "",
     $ 1 / x $, $ -1 / x^2 $, "",
     $ 1 / x^n $, $ -n / x^(n+1) $, "",
     $ sqrt(x) $, $ 1 / (2 sqrt(x)) $, "",
@@ -1072,6 +1108,64 @@ Ir spēkā sakarība $"INDSET"(G, k) = "CLIQUE"(G, k)$.
   )
 ]
 
+== Atvasinājumu īpašības
+#context [
+  #set text(size: 11pt)
+  #show math.equation: set text(weight: 400, size: 11pt)
+
+  #table(
+    columns: 3,
+    [*Rule Name*], [*Function*], [*Derivative*],
+
+    [Summa], [$ f(x) + g(x) $], [$ f'(x) + g'(x) $],
+    [Starpība], [$ f(x) - g(x) $], [$ f'(x) - g'(x) $],
+    [Reizinājums], [$ f(x) dot g(x) $],
+    [
+      $
+        f'(x) dot g(x) + \
+        f(x) dot g'(x)
+      $
+    ],
+
+    /*
+    [Quotient Rule], [$ (f'(x) dot g(x) - f(x) * g'(x)) / (g(x))^2 $], [$ (f'(x) * g(x) - f(x) * g'(x)) / (g(x))^2 $],
+    [Chain Rule], [$ f(g(x)) $], [$ f'(g(x)) dot g'(x) $],
+    [Euler’s Number Exponent Rule], [$ e^x $], [$ e^x $],
+    [Constant Exponent Rule], [$ a^x $], [$ a^x dot ln(a) $],
+    [Natural Log Rule], [$ ln(x) $], [$ 1 / x $],
+    [Logarithm Rule], [$ log_a(x) $], [$ 1 / (x dot ln(a)) $],
+    [Sine Rule], [$ sin(x) $], [$ cos(x) $],
+    [Cosine Rule], [$ cos(x) $], [$ -sin(x) $],
+    [Tangent Rule], [$ tan(x) $], [$ sec^2(x) $],
+    [Cosecant Rule], [$ csc(x) $], [$ -csc(x) dot cot(x) $],
+    [Secant Rule], [$ sec(x) $], [$ sec(x) dot tan(x) $],
+    [Cotangent Rule], [$ cot(x) $], [$ -csc^2(x) $],
+    */
+  )
+]
+
+== Kāpinājumu īpašības
+#context [
+  #set text(size: 11pt)
+  #show math.equation: set text(weight: 400, size: 11pt)
+
+  #table(
+    columns: 2,
+    [*Rule Name*], [*Formula*],
+
+    [Reizinājums], [$ a^m dot a^n = a^(m+n) $],
+    [Dalījums], [$ a^m / a^n = a^(m-n) $],
+    [Pakāpes pakāpe], [$ (a^m)^n = a^(m dot n) $],
+    [Reizinājuma pakāpe], [$ (a dot b)^m = a^m dot b^m $],
+    [Dalījuma pakāpe], [$ (a/b)^m = a^m / b^m $],
+    [0-pakāpe], [$ a^0 = 1 $],
+    [Negatīva pakāpe], [$ a^(-m) = 1 / a^m $],
+    [Saikne ar sakni], [$ a^(m/n) = root(n, a^m) $],
+  )
+]
+
+
+
 == Noderīgas izteiksmes laika analīzē<time_analysis_expressions>
 
 $
@@ -1079,8 +1173,8 @@ $
   sum_(i=1)^(n) i^2 = (n(n+1)(2n+1))/(6)\
   sum_(i=1)^(n) i^3 = ( (n(n+1))/(2))^2 \
   // Geometric series (ratio r \neq 1)
-  r > 1: sum_(i=0)^(n) a*r^i = a * (r^(n+1)-1)/(r-1) quad \
-  r < 1: sum_(i=0)^(infinity) a*r^i = (a)/(1-r) \
+  r > 1: sum_(i=0)^(n) a dot r^i = a dot (r^(n+1)-1)/(r-1) quad \
+  r < 1: sum_(i=0)^(oo) a dot r^i = (a)/(1-r) \
   // Logarithmic sum
   sum_(i=1)^(n) log i = log(n!) approx n log n - n + O(log n) \
   // Exponential sum (appears in brute-force algorithms)