updated as per your suggestion

Author: Vipullakum007

docs/DBMS/Indexing And Hashing/hashing.md

@@ -58,7 +58,7 @@ graph TD;
 The problem with static hashing is that it does not expand or shrink dynamically as the size of the database grows or shrinks. Dynamic hashing provides a mechanism in which data buckets are added and removed dynamically and on-demand. Dynamic hashing is also known as extended hashing.
 
 #### Organization
-The prefix of an entire hash value is taken as a hash index. Only a portion of the hash value is used for computing bucket addresses. Every hash index has a depth value to signify how many bits are used for computing a hash function. These bits can address \(2^n\) buckets. When all these bits are consumed, that is, when all the buckets are full, then the depth value is increased linearly and twice the buckets are allocated.
+The prefix of an entire hash value is taken as a hash index. Only a portion of the hash value is used for computing bucket addresses. Every hash index has a depth value to signify how many bits are used for computing a hash function. These bits can address $(2^n)$ buckets. When all these bits are consumed, that is, when all the buckets are full, then the depth value is increased linearly and twice the buckets are allocated.
 
 ```mermaid
 graph TD;

docs/DBMS/Indexing And Hashing/indexing.md

@@ -99,25 +99,25 @@ graph TD;
 
 #### Structure of B+ Tree
 - **Internal Nodes:**
-    - Contain at least ⌈n/2⌉ pointers, except the root node.
+    - Contain at least $⌈n/2⌉$ pointers, except the root node.
     - At most, an internal node can contain n pointers.
 
 - **Leaf Nodes:**
-    - Contain at least ⌈n/2⌉ record pointers and ⌈n/2⌉ key values.
+    - Contain at least $⌈n/2⌉$ record pointers and $⌈n/2⌉$ key values.
     - At most, a leaf node can contain n record pointers and n key values.
     - Every leaf node contains one block pointer P to point to the next leaf node, forming a linked list.
 
 #### B+ Tree Insertion
 1. **Insertion at Leaf Node:**
     - If a leaf node overflows, split node into two parts.
-    - Partition at i = ⌊(m+1)/2⌋.
+    - Partition at $i = ⌊(m+1)/2⌋$.
     - First i entries are stored in one node.
     - Rest of the entries (i+1 onwards) are moved to a new node.
     - ith key is duplicated at the parent of the leaf.
 
 2. **Insertion at Non-leaf Node:**
     - Split node into two parts.
-    - Partition the node at i = ⌈(m+1)/2⌉.
+    - Partition the node at $i = ⌊(m+1)/2⌋$.
     - Entries up to i are kept in one node.
     - Rest of the entries are moved to a new node.
 

docs/DBMS/Storage And File Structure/dbms-file-structure.md

@@ -93,4 +93,3 @@ graph TD;
 The organization of data inside a file plays a major role in how efficiently these operations can be performed. The method used to locate the file pointer to a desired record inside a file varies based on whether the records are arranged sequentially or clustered.
 
 In summary, understanding the various file structures and their operations is crucial for efficient database management, ensuring optimal performance and reliability.
-```