From 1cd6f44af8cebe568df292a457feacfdb7e046bf Mon Sep 17 00:00:00 2001
From: Kristofers Solo <dev@kristofers.xyz>
Date: Tue, 7 May 2024 00:34:35 +0300
Subject: [PATCH] fix issues

---
 main.typ | 29 +++++++++++++++--------------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/main.typ b/main.typ
index 8f24c65..648e2db 100644
--- a/main.typ
+++ b/main.typ
@@ -87,10 +87,10 @@ Simplified version (to get the idea)
 for each tuple tr in r: (for each tuple ts in s: test pair (tr, ts))
 ```
 
-Block transfer cost:  $n_r ∗ b_s + b_r$ block transfers would be required,
+Block transfer cost: $n_r dot b_s + b_r$ block transfers would be required,
 where $b_r$ -- blocks in relation $r$, same for $s$. Each scan of the inner
-relation requires one seek, and the scan of the outer relation requires one
-seek per block, leading to a total of $2 ∗b_r$ seeks.
+relation requires one seek, and the scan of the outer relation requires one seek
+per block, leading to a total of $2 dot b_r$ seeks.
 
 == Block-nested join
 
@@ -306,19 +306,20 @@ serializable.
 
 == Protocols
 
-We say that a schedule S is *legal* under a given locking protocol if S is a possible
-schedule for a set of transactions that follows the rules of the locking protocol. We say
-that a locking protocol ensures conflict serializability if and only if all legal schedules
-are *conflict serializable*; in other words, for all legal schedules the associated →relation
-is acyclic.
-\ *Recoverable* schedule is one where, for each pair of transactions $T_i$ and
+We say that a schedule S is *legal* under a given locking protocol if S is a
+possible schedule for a set of transactions that follows the rules of the
+locking protocol. We say that a locking protocol ensures conflict
+serializability if and only if all legal schedules are *conflict serializable*;
+in other words, for all legal schedules the associated $->$ relation is acyclic.
+
+*Recoverable* schedule is one where, for each pair of transactions $T_i$ and
 $T_j$ such that $T_j$ reads a data item previously written by $T_i$, the commit
 operation of $T_i$ appears before the commit operation of $T_j$.
-\ *Cascadeless* schedule is one where, for each pair of transactions $T_i$ and
-$T_j$ such that $T_j$ reads a data item previously written by $T_i$, the commit
-operation of $T_i$ appears before the read operation of $T_j$. 
-Every cascadeless schedule is also recoverable.
 
+*Cascadeless* schedule is one where, for each pair of transactions $T_i$ and
+$T_j$ such that $T_j$ reads a data item previously written by $T_i$, the commit
+operation of $T_i$ appears before the read operation of $T_j$. Every cascadeless
+schedule is also recoverable.
 
 === Lock-based
 
@@ -485,7 +486,7 @@ $B=5;T_"disk"=0.001;T_"seek"=0.1$
 === Nested-Loop Join Method
 + Nested-loop join:
   - For each pattern in $r_1$, search all patterns in $r_2$.
-+ Total Combinations: $75435 dot 11456=$
++ Total Combinations: $75435 dot 11456$
 + Time Calculation for Nested-Loop Join:
   - Reading and searching time for each combination: $0.001+0.1=0.101 "ms"$
   - Total time: $75435 dot 11456 dot 0.101 = 87282519.36 "ms"$