My Blog

A Beginner’s guide to Writing Data Flip Flop in Verilog

2024-12-01T00:00:00+00:00
In this blog post we will see a beginners guide on how to write DFF (Data Flip Flop) in Verilog. Verilog is a Hardware Description Language (HDL) which is used to describe the functionality of a hardware (electronic systems) in a programming language. There are many resources online if you want to learn more about Verilog.
DISCLAIMER</a> </h3>
We will be only looking at the Behavior modelling and not Gate level modelling. Since behavior modelling is easier to understand and read.
What is a Data Flip Flop?Implementing DFF</a> </h2>

Testing our DFF</a> </h2> Now that we have implemented our DFF, we have to test it to make sure its behaving as expected. Question: What’s the behavior that we want to test? Answer: At the positive edge of the clock, whatever value(usually binary) is passed as input (D) should be the output. During other times, the output will be the previous output. Let’s write our testbench: module dff_tb; reg D = 0; reg CLK = 0; wire Q; DFF dff( .D(D), .CLK(CLK), .Q(Q) ); always #5 CLK <= ~CLK; initial begin #10 D = 1; #10 D = 0; #10 D = 1; #10 $finish; end initial $monitor("[Time=%0t] D = %0b CLK = %0b Q = %0b", $time, D, CLK, Q); endmodule</code></pre> In our testbench, we have defined two variables (D and CLK) which will be the inputs of the data flip flop and we have declared one variable (Q) which will be the output of our flip flop. Next we have initialized our data flip flop (DFF) by passing in our variables. Now comes the meaty part. We have three procedural blocks, always</li> initial</li> </ul> The always block toggles the value of CLK every 5 seconds. In the first initial block, we are assigning values to the D</code> register. At time unit 10ns</code> , the value of D</code> is 1</code></li> At time unit 20ns</code>, the value of D</code> is 0</code></li> At time unit 30ns</code> , the value of D</code> is 1</code></li> </ul> In the second initial block, we have a system task called monitor</code>. It continuously tracks and displays the values of specified signals whenever there is a change in any of them. When we run the testbench, we will get the following output: [Time: 0], D=0, CLK=0, Q=x [Time: 5], D=0, CLK=1, Q=0 [Time: 10], D=1, CLK=0, Q=0 [Time: 15], D=1, CLK=1, Q=1 [Time: 20], D=0, CLK=0, Q=1 [Time: 25], D=0, CLK=1, Q=0 [Time: 30], D=1, CLK=0, Q=0 [Time: 35], D=1, CLK=1, Q=1 dff_tb.v:21: $finish called at 40 (1s) [Time: 40], D=1, CLK=0, Q=1</code></pre> Whenever the value of CLK</code> is 1, the value of Q</code> is whatever the value of D</code>. And other times (value of CLK=0</code>), the value of Q</code> is the previous value of D</code>. Voila 🎉 we have successfully implemented and tested our Data Flip Flop. To take it further, you can use this to build Registers.

Writing a simple Lexer
2024-04-08T00:00:00+00:00
In this blog post, I’ll be going over how to write a simple Lexer</em> that parses and generates Tokens</em> for few characters. We’ll also add few rules to the parsing logic on how to parse certain characters.</p>
The code can be found on Github</a>.</p>
Let’s first define what we are trying to parse</em>. We’ll parse the following characters.</p>

{</code> → open curly bracket</li>
}</code> → closed curly bracket</li>
(</code> → open parenthesis</li>
)</code> → closed parenthesis</li>
*</code> → star</li>
+</code> → plus</li>
,</code> → comma</li>
.</code> → dot</li>
-</code> → minus</li>
</ul>
Our goal is to parse these characters and generate token out of these. Generally we call these characters lexemes</em>. For example, {</code> is represented as LEFT_BRACE</code> and you can name it whatever you want as long it represents the correct token. Let’s breakdown our problem. Currently, our goal is to parse only one character. Let’s choose {</code> for our initial implementation.</p>
We should parse the {</code> and generate a token like LEFT_BRACE {</code> in a string format.</p>
Initial implementation</a>
</h2>

Let’s start by defining our token type because eventually we’ll be generating token once we parse a character.</p>
from</span> enum</span> import</span> Enum</span></span>
</span>
class</span> TokenType</span>(</span>Enum</span>)</span>:</span></span>
	LEFT_BRACE</span> =</span> 1</span></span></code></pre>
In the above code snippet, I have created a class named TokenType</code> which is an enum</em>, which holds all the required tokens</em> for our parser(lexer). Currently we have only one token which is the left curly brace ({</code>), we’ll add more once we setup our parser.</p>
Now let’s create a class for our Lexer which takes in a source</em>, which are the characters that we want to parse.</p>
class</span> Lexer</span>:</span></span>
	def</span> __init__</span>(</span>self</span>,</span> source</span>)</span>:</span></span>
		self</span>.</span>source</span> =</span> source</span></span>
		</span></span>
if</span> __name__</span> ==</span> "</span>__main__</span>"</span>:</span></span>
	characters</span>:</span> str</span> =</span> "</span>{</span>"</span> #</span> for now only one</span></span>
	lexer</span> =</span> Lexer</span>(</span>characters</span>)</span></span></code></pre>
In the above code snippet, we have defined a class named Lexer</code> which will hold everything that we need to achieve our goal. Our Lexer</em> takes in a source</em> which is nothing but a string of characters,</em> that contains the character that we need to parse.</p>
Under the if</em> condition, we have a variable named characters</code> which will hold the things we need to parse. Currently it contains {</code> , we’ll add more later. Right after that, we have initialized our Lexer</code> class by passing in the characters</em> as source</em>.</p>
The next step is to “consume” the character and for now, let’s print it.</p>
Consume characters</a>
</h2>

Let’s add a method that consume characters one by one. For now, we implement this method that’ll print the character it consumes.</p>
class</span> Lexer</span>:</span></span>
	def</span> __init__</span>(</span>self</span>,</span> source</span>)</span> -></span> None</span>:</span></span>
		self</span>.</span>source</span> =</span> source</span></span>
		self</span>.</span>start_position</span> =</span> 0</span></span>
		self</span>.</span>current_position</span> =</span> 0</span></span>
	</span></span>
	def</span> consume_characters</span>(</span>self</span>)</span> -></span> None</span>:</span></span>
		while</span> (</span>not</span> self</span>.</span>isAtEnd</span>(</span>)</span>)</span>:</span></span>
			self</span>.</span>start_position</span> =</span> self</span>.</span>current_position</span></span>
			self</span>.</span>_consume_character</span>(</span>)</span></span>
			</span></span>
	def</span> _consume_character</span>(</span>self</span>)</span> -></span> None</span>:</span></span>
		current_character</span>:</span> str</span> =</span> self</span>.</span>eat_and_move_on</span>(</span>)</span></span>
		print</span>(</span>current_character</span>)</span></span>
		</span></span>
	def</span> eat_and_move_on</span>(</span>self</span>)</span>:</span></span>
		self</span>.</span>current_position</span> =</span> self</span>.</span>current_position</span> +</span> 1</span></span>
		return</span> self</span>.</span>source</span>[</span>self</span>.</span>current_position</span> -</span> 1</span>]</span></span>
		</span></span>
	def</span> isAtEnd</span>(</span>self</span>)</span> -></span> bool</span>:</span></span>
		return</span> self</span>.</span>current_position</span> >=</span> len</span>(</span>self</span>.</span>source</span>)</span></span></code></pre>
There are a few things to unpack from the above code snippet. Let’s look at one by one. We have two similar methods consume_characters</code> and _consume_character</code>. And we have a couple of helper methods isAtEnd</code> and eat_and_move_on</code> which we are using to make a clear abstraction.</p>
consume_characters</code> is a top level method. The goal of this method is to consume all the characters that we pass one by one until it reaches the EOF(End of file). This method uses the isAtEnd</code> helper method to constantly check whether it reached the end of the file or not.</p>
If it doesn’t reach the end of the file, we are doing two things</p>

Setting the value of start_position</code> to the current value of current_position</code> . We will see why we are doing this.</li>
Second we are calling the _consume_character</code> method. The goal of the method is to consume the one character at a time and process it. For now we are just printing it.</li>
</ul>
The isAtEnd</code> method is pretty self explanatory, it checks whether the current_position</em> reaches the end of the file. It does that by comparing the value of the current_position</em> and the length of the source</em> (which is the string of characters that we want to parse).</p>
As the name suggests, the eat_and_move_on</code> method “eats” the current character that the current_position</code> points to and then increment the value of the current_position</code> so that on the next iteration, it can “eat” the next character. Here “eat” is just a metaphor for consume</em>.</p>
We’ll update our initialization code and test our current functionality.</p>
if</span> __name__</span> ==</span> "</span>__main__</span>"</span>:</span></span>
	characters</span>:</span> str</span> =</span> "</span>{</span>"</span> #</span> for now only one</span></span>
	lexer</span> =</span> Lexer</span>(</span>characters</span>)</span></span>
	lexer</span>.</span>consume_characters</span>(</span>)</span></span></code></pre>
Go ahead and run this code and see what’s happening. You should see {</code> on the console.</p>
We can add more characters to our characters</code> variable and our program will still consume and eat all the characters. Try to run the program by modifying the value of the characters</code> variable to this: {}{}{}{}</code> , you should see all the characters print in a new line. Now that we’ve written our logic to consume character one by one, we can start generating token from it. But first of all what are tokens</em>?</p>
Tokens</a>
</h2>

Tokens are the smallest unit of meaningful text in programming languages, such as keywords, identifiers, operators, literals and punctuation marks. Tokens serve as the basic building blocks of the language’s syntax and used to represent individual elements within code.</p>
As you have seen from the code snippet at the very beginning of this blog post, we have a token type</em> called LEFT_BRACE</code> which is a meaningful representation of {</code>. These are what we call as tokens</em>. Let’s look at a few more single character token types.</p>
from</span> enum</span> import</span> Enum</span></span>
</span>
class</span> TokenType</span>(</span>Enum</span>)</span>:</span></span>
  LEFT_BRACE</span>        =</span> 1</span></span>
  RIGHT_BRACE</span>       =</span> 2</span></span>
  LEFT_PAREN</span>        =</span> 3</span></span>
  RIGHT_PAREN</span>       =</span> 4</span></span>
  STAR</span>              =</span> 5</span></span>
  PLUS</span>              =</span> 6</span></span>
  MINUS</span>             =</span> 7</span></span>
  COMMA</span>             =</span> 8</span></span>
  DOT</span>               =</span> 9</span></span></code></pre>
In the above code snippet, we’ve added few more meaningful representation of the characters. You’ll see how tokens come together once we start generating it buy parsing the characters. Let’s generate tokens now, shall we?</p>
Generating Tokens</a>
</h2>

We’ll start from where we left off. In our Lexer</code> class, specifically in the consume_character</code> method, we were just printing the characters. Now we’ll use the characters to generate tokens. Let’s first generate a token for the {</code> (LEFT_BRACE) character.</p>
But how do we represent tokens</em>? Currently we have represented them as text like LEFT_BRACE</code> , RIGHT_BRACE</code> and so on. But we have to represent them in some way. We’ll create a Token</code> class which for now only holds the character</em> and the textual representation</em> of that character.</p>
class</span> Token</span>:</span></span>
	def</span> __init__</span>(</span>self</span>,</span> tt</span>:</span> TokenType</span>,</span> value</span>:</span> chr</span>)</span> -></span> None</span>:</span></span>
		self</span>.</span>token_type</span> =</span> tt</span></span>
		self</span>.</span>value</span>      =</span> value</span></span>
	</span></span>
	def</span> __repr__</span>(</span>self</span>)</span> -></span> str</span>:</span></span>
    return</span> f</span>"</span>{</span>self</span>.</span>token_type</span>}</span> {</span>self</span>.</span>value</span>}</span>"</span></span></code></pre>
In the above code snippet, we’ve created a Token</code> class, which holds the token type</em> and the value</em>(character) of the token. Now that we can represent tokens</em> in some form, let’s start generating them.</p>
class</span> Lexer</span>:</span></span>
	def</span> __init__</span>(</span>self</span>,</span> ...</span>)</span> -></span> None</span>:</span></span>
		...</span></span>
		...</span></span>
		self</span>.</span>tokens</span>:</span> list</span> =</span> [</span>]</span> #</span> we store all the tokens in a list</span></span>
	</span></span>
	def</span> _consume_character</span>(</span>self</span>)</span> -></span> None</span>:</span></span>
		current_character</span>:</span> str</span> =</span> self</span>.</span>eat_and_move_on</span>(</span>)</span></span>
		if</span> current_character</span> ==</span> '</span>{</span>'</span>:</span></span>
			self</span>.</span>generate_token</span>(</span>TokenType</span>.</span>LEFT_BRACE</span>.</span>name</span>)</span></span>
		</span></span>
	def</span> generate_token</span>(</span>self</span>,</span> tt</span>:</span> TokenType</span>)</span> -></span> None</span></span>
		text</span>:</span> str</span> =</span> self</span>.</span>source</span>[</span>self</span>.</span>start_position</span>:</span>self</span>.</span>current_position</span>]</span></span>
		token</span>:</span> Token</span> =</span> Token</span>(</span>tt</span>,</span> text</span>)</span></span>
		self</span>.</span>tokens</span>.</span>append</span>(</span>token</span>)</span></span></code></pre>
Let’s unpack the above code.</p>
I’ve added a new method named generate_token</code> which takes in the TokenType</code> based on the character which we are currently parsing and it gets the text</em>(character) from the source</em> using the start position</em> and the current position</em>. Finally it creates a new Token</em> object and pushes it into our tokens</em> list.</p>
In the consume_character</code> , I’ve added an if condition</em> which checks for the {</code> character and if it’s true</em> then, we use the generate_token</code> method by passing in the token type</em> and generate the token.</p>
Go ahead and execute this code and try to print the tokens</code> list and see what is in that list for yourself.</p>
Currently, we are generating token only for the {</code> character. We will now add all the characters that our lexer</em> needs to parse and generate token.</em> If you look at the above TokenType</code> class we’ve added all the lexemes that we are trying to parse. Now the only thing that we have to do is generate tokens based on the characters. Let’s do that.</p>
def</span> _consume_character</span>(</span>self</span>)</span> -></span> None</span>:</span></span>
		current_character</span>:</span> str</span> =</span> self</span>.</span>eat_and_move_on</span>(</span>)</span></span>
		if</span> current_character</span> ==</span> '</span>{</span>'</span>:</span></span>
			self</span>.</span>generate_token</span>(</span>TokenType</span>.</span>LEFT_BRACE</span>.</span>name</span>)</span></span>
		if</span> current_character</span> ==</span> '</span>}</span>'</span>:</span></span>
			self</span>.</span>generate_token</span>(</span>TokenType</span>.</span>RIGHT_BRACE</span>.</span>name</span>)</span></span>
		if</span> current_character</span> ==</span> '</span>(</span>'</span>:</span></span>
			self</span>.</span>generate_token</span>(</span>TokenType</span>.</span>LEFT_PAREN</span>.</span>name</span>)</span></span>
		if</span> current_character</span> ==</span> '</span>)</span>'</span>:</span></span>
			self</span>.</span>generate_token</span>(</span>TokenType</span>.</span>RIGHT_PAREN</span>.</span>name</span>)</span></span>
		if</span> current_character</span> ==</span> '</span>*</span>'</span>:</span></span>
			self</span>.</span>generate_token</span>(</span>TokenType</span>.</span>STAR</span>.</span>name</span>)</span></span>
		if</span> current_character</span> ==</span> '</span>+</span>'</span>:</span></span>
			self</span>.</span>generate_token</span>(</span>TokenType</span>.</span>PLUS</span>.</span>name</span>)</span></span>
		if</span> current_character</span> ==</span> '</span>-</span>'</span>:</span></span>
			self</span>.</span>generate_token</span>(</span>TokenType</span>.</span>MINUS</span>.</span>name</span>)</span></span>
		if</span> current_character</span> ==</span> '</span>,</span>'</span>:</span></span>
			self</span>.</span>generate_token</span>(</span>TokenType</span>.</span>COMMA</span>.</span>name</span>)</span></span>
		if</span> current_character</span> ==</span> '</span>.</span>'</span>:</span></span>
			self</span>.</span>generate_token</span>(</span>TokenType</span>.</span>DOT</span>.</span>name</span>)</span></span></code></pre>
We’ve added few more if conditions</em> to check for other types of characters and generate tokens for them. Don’t worry about the beauty of the code, since Python doesn’t support switch cases we have used if conditions</em>, we can also avoid using if statements</em> and do this much more cleaner. But to keep things simple we are gonna stay with this for now.</p>
Ignoring whitespaces</a>
</h2>

Let’s add the ability to ignore (discard) whitespaces to our Lexer. We will take three things into consideration.</p>

Simple space (’ ‘)</li>
Carriage return (’\r’)</li>
New line (’\n’)</li>
</ol>
If we come across these characters during our source language parsing we should ignore them. We’ll add this functionality to our _consume_character</code> function. But first we’ll define a function to check whitespace characters.</p>
def</span> isWhitespace</span>(</span>self</span>,</span> character</span>:</span> str</span>)</span> -></span> bool</span>:</span></span>
	SPACE</span> =</span> '</span> '</span></span>
	NEWLINE</span> =</span> '</span>\n</span>'</span></span>
	CARRIAGE_RETURN</span> =</span> '</span>\r</span>'</span></span>
	return</span> character</span> in</span> [</span>SPACE</span>,</span> NEWLINE</span>,</span> CARRIAGE_RETURN</span>]</span></span>
	</span></span>
def</span> _consume_character</span>(</span>self</span>)</span> -></span> None</span>:</span></span>
	current_character</span>:</span> str</span> =</span> self</span>.</span>eat_and_move_on</span>(</span>)</span></span>
	...</span></span>
	</span></span>
	if</span> self</span>.</span>isWhitespace</span>(</span>current_character</span>)</span>:</span></span>
		return</span></span></code></pre>
We’ve added a method named isWhitespace</code> which takes in a character we are currently parsing and checks whether it is a white space</em> or not. In the _consume_character</code> method we are using that function by passing in the character. If it returns true</em> we are returning from the function, which means we are doing nothing (discarding). That’s it, we’ve successfully added our functionality to ignore whitespaces. Go ahead and play around with the code and see what happens.</p>
Two character lexemes</a>
</h2>

So far we’ve seen only one character lexemes like {, }, (, and so on. We’ll look at how to handle relational operators</strong></em>. Things like:</p>

!=</code></li>
==</code></li>
<=</code></li>
>=</code></li>
</ul>
As you can see, there will be two cases that we have to deal with when parsing these characters and generating tokens. Let’s look at an example for !=</code></p>
Parsing !=</code></a>
</h3>

The bang operator (!</code>) can be used as a standalone operator, which stands for negation</em> or not.</em> So when parsing !</code> we have to check whether the next character is =</code> or something else. If it is =</code> we have to consider both of the character as a single token, which represents !=</code> (not equal to</em>).</p>
If it is only !</code> we have to consider it as not</em> (negation) operator. Let’s add the functionality to achieve this.</p>
class</span> TokenType</span>(</span>Enum</span>)</span>:</span></span>
	...</span></span>
	...</span></span>
	BANG</span> =</span> 10</span></span>
	BANG_EQUAL</span> =</span> 11</span></span>
	</span></span>
class</span> Lexer</span>:</span></span>
	...</span></span>
	def</span> match_next_character</span>(</span>self</span>,</span> expected_character</span>:</span> str</span>)</span> -></span> bool</span>:</span></span>
		if</span> self</span>.</span>isAtEnd</span>(</span>)</span>:</span> return</span> False</span></span>
		if</span> (</span>self</span>.</span>source</span>[</span>self</span>.</span>current_position</span>]</span> !=</span> expected_character</span>)</span>:</span> return</span> False</span></span>
		</span></span>
		self</span>.</span>current_position</span> =</span> self</span>.</span>current_position</span> +</span> 1</span></span>
		return</span> True</span></span>
		</span></span>
	def</span> _consume_character</span>(</span>self</span>)</span> -></span> None</span>:</span></span>
		current_character</span>:</span> str</span> =</span> self</span>.</span>eat_and_move_on</span>(</span>)</span></span>
		...</span></span>
		...</span></span>
		if</span> current_character</span> ==</span> '</span>!</span>'</span>:</span></span>
			if</span> self</span>.</span>match_next_character</span>(</span>'</span>=</span>'</span>)</span>:</span></span>
				self</span>.</span>generate_and_add_token</span>(</span>TokenType</span>.</span>BANG_EQUAL</span>.</span>name</span>)</span></span>
			self</span>.</span>generate_and_add_token</span>(</span>TokenType</span>.</span>BANG</span>.</span>name</span>)</span></span>
			</span></span>
characters</span>:</span> str</span> =</span> "</span>!==</span>"</span></span>
lexer</span>.</span>consume_characters</span>(</span>)</span></span></code></pre>
Let’s unpack. We’ve added a new method named match_next_character</code> which takes in the expected_character</em> which we are looking for and returns true</em> if it matches else false</em>.</p>
In the _consume_character</code> method we’ve added a condition to check if the current character that we are parsing is !</code> , if its true</em>, we are checking whether the next character</em> is equal to =</code>. If its true</em>, we are generating a token with the BANG_EQUAL</code> type, else BANG</code> type. We are using the keyword BANG</code> because, this operator (!</code>) is called as bang operator</em>.</p>
If you notice, in the match_next_character</code> method, we are incrementing the value of current_position</code></em>. Why is that? It’s because, we’ve confirmed that the next character matches the =</code> character, so we have to treat !=</code> as a single operator. For this particular reason, we are incrementing the current_position</code> value.</p>
If we didn’t do that, our Lexer will parse the =</code> again even after we consider the !=</code> as a single operator. Go ahead and comment out that line and run the code to see the difference.</p>
Voila 🎉 we’ve successfully parsed the !=</code> operator. In a similar way, we can able to parse the remaining three relational operators</em>.</p>
if</span> current_character</span> ==</span> '</span>=</span>'</span>:</span></span>
    self</span>.</span>generate_and_add_token</span>(</span></span>
        TokenType</span>.</span>EQUAL_EQUAL</span>.</span>name</span> if</span> self</span>.</span>match_next_character</span>(</span>'</span>=</span>'</span>)</span> else</span> TokenType</span>.</span>EQUAL</span>.</span>name</span></span>
    )</span></span>
if</span> current_character</span> ==</span> '</span><</span>'</span>:</span></span>
    self</span>.</span>generate_and_add_token</span>(</span></span>
        TokenType</span>.</span>LESS_THAN_EQUAL</span>.</span>name</span> if</span> self</span>.</span>match_next_character</span>(</span>'</span>=</span>'</span>)</span> else</span> TokenType</span>.</span>LESS_THAN</span>.</span>name</span></span>
    )</span></span>
if</span> current_character</span> ==</span> '</span>></span>'</span>:</span></span>
    self</span>.</span>generate_and_add_token</span>(</span></span>
        TokenType</span>.</span>GREATER_THAN_EQUAL</span>.</span>name</span> if</span> self</span>.</span>match_next_character</span>(</span>'</span>=</span>'</span>)</span> else</span> TokenType</span>.</span>GREATER_THAN</span>.</span>name</span></span>
    )</span></span></code></pre>Keyword Parsing</a>
</h2>

Let’s examine some keywords commonly found in most programming languages. To keep things simpler, let’s take some keywords from Python.</p>

and</code></li>
or</code></li>
not</code></li>
if</code></li>
elif</code></li>
else</code></li>
while</code></li>
for</code></li>
break</code></li>
continue</code></li>
def</code></li>
return</code></li>
class</code></li>
print</code></li>
</ul>
Let’s breakdown the approach for parsing the keywords.</p>
Whenever we come across a character, we will first check whether it is an alphabet or not, why? because all the keywords</em> above only contain alphabets. Once we confirm that it’s an alphabet, we’ll peek</em> through the following characters and check each and every character is an alphabet or not. Once we reach a non-alphabet</em> character, we will stop there and take the text</em> we parsed. Then we will check the parsed word with our keywords list, if we find a match, we will be generating the appropriate token.</p>
class</span> TokenType</span>(</span>Enum</span>)</span>:</span></span>
	...</span></span>
	...</span></span>
  #</span> Keywords</span></span>
  AND</span> =</span> 18</span></span>
  OR</span> =</span> 19</span></span>
  NOT</span> =</span> 20</span></span>
  IF</span> =</span> 21</span></span>
  ELIF</span> =</span> 22</span></span>
  ELSE</span> =</span> 23</span></span>
  WHILE</span> =</span> 24</span></span>
  FOR</span> =</span> 25</span></span>
  BREAK</span> =</span> 26</span></span>
  CONTINUE</span> =</span> 27</span></span>
  DEF</span> =</span> 28</span></span>
  RETURN</span> =</span> 29</span></span>
  CLASS</span> =</span> 30</span></span>
  PRINT</span> =</span> 31</span></span></code></pre></span>
class</span> Lexer</span>:</span></span>
   #</span> Keywords object which we will use to match against the parsed text</span></span>
    KEYWORDS</span> =</span> {</span></span>
    "</span>and</span>"</span>:</span> TokenType</span>.</span>AND</span>.</span>name</span>,</span></span>
    "</span>or</span>"</span>:</span> TokenType</span>.</span>OR</span>.</span>name</span>,</span></span>
    "</span>not</span>"</span>:</span> TokenType</span>.</span>NOT</span>.</span>name</span>,</span></span>
    "</span>if</span>"</span>:</span> TokenType</span>.</span>IF</span>.</span>name</span>,</span></span>
    "</span>elif</span>"</span>:</span> TokenType</span>.</span>ELIF</span>.</span>name</span>,</span></span>
    "</span>else</span>"</span>:</span> TokenType</span>.</span>ELSE</span>.</span>name</span>,</span></span>
    "</span>while</span>"</span>:</span> TokenType</span>.</span>WHILE</span>.</span>name</span>,</span></span>
    "</span>for</span>"</span>:</span> TokenType</span>.</span>FOR</span>.</span>name</span>,</span></span>
    "</span>break</span>"</span>:</span> TokenType</span>.</span>BREAK</span>.</span>name</span>,</span></span>
    "</span>continue</span>"</span>:</span> TokenType</span>.</span>CONTINUE</span>.</span>name</span>,</span></span>
    "</span>def</span>"</span>:</span> TokenType</span>.</span>DEF</span>.</span>name</span>,</span></span>
    "</span>return</span>"</span>:</span> TokenType</span>.</span>RETURN</span>.</span>name</span>,</span></span>
    "</span>class</span>"</span>:</span> TokenType</span>.</span>CLASS</span>.</span>name</span>,</span></span>
    "</span>print</span>"</span>:</span> TokenType</span>.</span>PRINT</span>.</span>name</span></span>
	}</span></span>
	...</span></span>
	...</span></span>
	if</span> current_character</span>.</span>isalpha</span>(</span>)</span>:</span></span>
	  while</span> (</span>self</span>.</span>peek</span>(</span>)</span>.</span>isalpha</span>(</span>)</span>)</span>:</span></span>
	      self</span>.</span>eat_and_move_on</span>(</span>)</span></span>
	  keyword</span>:</span> str</span> =</span> self</span>.</span>source</span>[</span>self</span>.</span>start_position</span>:</span>self</span>.</span>current_position</span>]</span></span>
	  self</span>.</span>generate_and_add_token</span>(</span></span>
	      Lexer</span>.</span>KEYWORDS</span>.</span>get</span>(</span>keyword</span>,</span> None</span>)</span></span>
	  )</span></span>
	  </span></span>
    def</span> peek</span>(</span>self</span>)</span> -></span> chr</span>:</span></span>
        if</span> self</span>.</span>isAtEnd</span>(</span>)</span>:</span> return</span> '</span>\0</span>'</span></span>
        return</span> self</span>.</span>source</span>[</span>self</span>.</span>current_position</span>]</span></span></code></pre>
There is a lot to unpack. Let’s look at it one by one.</p>
We have added all the keywords that we needed under TokenType</code> and we have also created a KEYWORDS</code> object, which holds all the keywords with their names as keys</em> and their respective token types as their values</em>.</p>
We have also added a new method named peek</code> . The job of this method is to return the character in the current_position</em>. We will use this method to read (parse) keywords.</p>
Finally we’ve added an if condition</em> which checks whether the character we are parsing is an alphabet</em> or not. If it is an alphabet we will continue reading the following characters using the peek</code> method until we reach any non-alphabetic</em> character. Once we have reached the end of the non-alphabetic character, we will use the value of start_position</code> and current_position</code> to get the parsed text or character. Since our KEYWORDS</code> object holds all the necessary keyword, we’ll match it against that object. If we find a match then generate the appropriate token, else do nothing.</p>
We have reached the end of this blog post. We have created a Lexer that parses quite a lot of content. On that note, try adding support for parsing strings</em>, numbers</em> and identifiers.</em> To take it one step further modify the code to parse a subset of Javascript.</p>


Associative and Commutative property of Addition in Coq
2024-03-28T00:00:00+00:00
In this blog post, I’ll be going over associative</strong> and commutative</strong> property of addition</strong></em>. Also, I’ll be going over how to prove that using Coq. But first of all, what is addition</em>?</p>
Addition</a>
</h2>

We all know what addition</em> is but I’ll still explain it in brief. In mathematics, addition</em> is the process of adding two or more numbers together to find the final result. Addition is represented by the +</strong> symbol. For example: 1 + 1</strong> equals 2, 10 + 10</strong> equals 20</strong> so on.</p>
In programming perspective, think of +</strong> as a function that takes in two arguments of type number(Integer) and adds them together and returns the result. Now we know what addition</em> is let’s take a look at some properties of addition</em>.</p>
Induction</a>
</h2>

Before looking into the properties of addition</em>, let’s first take a look at what induction</em> is. Because we are going to use proof by induction</strong> method to solve the theorems/proofs.</p>
What is Proof by Induction</strong>?</p>
“Mathematical Induction is a method for proving that a statement P(n)</em> is true for every natural number n</em>, that is, infinitely many cases P(0), P(1), P(2), P(3)…..P(n)</em> all hold. This is done by first proving a simple case, then also showing that if we assume the claim is true for a given case, then the next case is also true.” — From Wikipedia</strong>.</p>
If we break this down step by step, Mathematical induction contains two steps.</p>

Show it is true for the first one.</li>
Show that if any one is true then the next one is true.</li>
</ol>
Then all are true.</p>
Induction step 1</a>
</h3>

We have to prove the base case, ie., n = 0 or n = 1</strong></em>.</p>
Induction step 2</a>
</h3>


Assume</strong> it is true for n = k</strong></em>, where k</strong> is an arbitrary number.</li>
Prove</strong> it is true for n = k + 1</strong></em> (we can use the n = k</strong></em> as a fact).</li>
</ul>
We’ll see how this(induction</em>) works out when proving the associative</em> and commutative</em> property of addition</em></p>
Associative property</a>
</h2>

Associative property of addition states that, no matter how a set of three or more numbers are grouped together, the sum remains the same</em>.</p>
For example, if a, b and c</em> are natural numbers then a + (b + c) = (a + b) + c</strong>. Let’s apply some natural numbers to a, b and c</em>.</p>
Let a = 10, b = 20 and c = 30,</strong> therefore:</p>
10 + (20 + 30) = (10 + 20) + 30</span></span>
10 + 50 = 30 + 30</span></span>
60 = 60</span></span></code></pre>
This is associative property in a nutshell. In the above example, we’ve only taken three numbers a, b and c</em> but it can be more as well.</p>
Okay, now that we know the associative property of addition, let’s prove that using Coq.</p>
(*</span> Prove associative proerty of addition </span>*)</span></span>
Theorem</span> proving_add_associative</span>:</span> forall</span> a b c</span>:</span> nat</span>, a </span>+</span> (b </span>+</span> c) </span>=</span> (a </span>+</span> b) </span>+</span> c.</span></span>
	Proof</span>.</span></span>
	intros</span> a b c.</span></span>
	induction</span> a </span>as</span> [</span>|</span> a' IHa'].</span></span>
	-</span> simpl</span>. </span>reflexivity</span>.</span></span>
	-</span> simpl</span>. </span>rewrite</span> IHa'. </span>reflexivity</span>.</span></span>
	Qed</span>.</span></span></code></pre>
The above theorem states that, for all natural numbers a, b and c, a + (b + c) is equal to (a + b) + c.</em></p>
Between the Proof</code> and Qed</code> tactic is where we write our proof. Since we have three variables a, b and c,</em> we have to bring them into our proof. To do that, we can use the intros</code> tactic which is short for introduction or introduce</em>.</p>
induction</a>
</h3>

The line induction a as [| a' IHa'].</code> does induction on variable a</em>. When induction</em> is applied on a,</em> we have two cases to prove.</p>

When a = 0</li>
When a = k, where k</em> is an arbitrary number.</li>
</ol>
In the above command, we have two things mentioned inside the square brackets( []</code> ). These are the names of the variables</em> we assigned as part of induction. Our base case is a = 0</strong>, so we don’t have to assign/create any variable for that. For our second case, a = k</strong> we have to create a variable to hold the arbitrary number, for that we have created a variable named a’</strong>.</p>
What is IHa’</strong>?</a>
</h3>

IH</strong> is short for Induction Hypothesis</strong>. And IHa’,</strong> a’</em> is added in the name because this hypothesis is for a’</em>. So for readability we have named it as IHa’</strong>. You can name the variables whatever you want. I could’ve done like this as well [| k' IHk']</code>.</p>
Going further</a>
</h3>

Now, let’s see what is the state of our theorem when we execute the intros.</code> tactic and induction</code> tactic.</p>
</p>
As you can see, after applying proof by induction</em> we have two goals.</p>

When a = 0</strong></li>
When a = S a’</strong>, where S a’</em> is an arbitrary number.</li>
</ol>
Now, lets solve the first goal. We can focus on the goal using -</code> sign.</p>
</p>
We know that 0 plus anything equals anything</em>. In this case, on the left hand side we have 0 + (b + c)</strong> and on the right hand side we have 0 + b + c</strong>. So, we can simplify the LHS and RHS like b + c = b + c</strong> using the simpl.</code> tactic, which gives us</p>
</p>
Now we can use reflexivity.</code> tactic to prove the equality. Since both LHS and RHS are equal, executing the reflexivity</em> tactic would solve our first goal.</p>
</p>
Let’s focus on our second goal using the -</code> .</p>
</p>
In our second goal, we have to prove S a' + (b + c) = S a' + b + c</strong>. We also got an induction hypothesis(IHa'), which states that a' + (b + c) = a' + b + c</strong>. Here, we’ve assumed that this hypothesis is true,</strong></em> so that we can use this hypothesis to prove our goal.</p>
Let’s use the simpl.</code> tactic to simplify both LHS and RHS.</p>
</p>
Executing the simpl.</code> tactic grouped our variables. If you look at LHS, we have a' + (b + c)</strong>. In our induction hypothesis we have assumed that a' + (b + c) = a' + b + c</strong> is true</em>. Therefore, we can use this hypothesis to prove our goal.</p>
Let’s rewrite our statement using the induction hypothesis. We can use the rewrite.</code> tactic to do this. Executing rewrite IHa'</code> results in</p>
</p>
As you can see, we’ve replaced(rewrote) a' + (b + c)</strong> with a' + b + c,</strong> because we have assumed a' + (b + c) = a' + b + c</strong> to be true</em>. Now if you look at both LHS and RHS, its equal. We can check the equality property using the reflexivity.</code> command.</p>
</p>
Boom! we’ve proved the associative property</em> of addition</em>.</p>
Commutative property</a>
</h2>

I’m too lazy to add the images to explain each and every step, so I'm planning to make a video explaining things. Will be uploading soon once the blog goes live!</p>
References</a>
</h2>


Induction: https://en.wikipedia.org/wiki/Mathematical_induction</a></li>
Associative property: https://en.wikipedia.org/wiki/Associative_property</a></li>
Commutative property: https://en.wikipedia.org/wiki/Commutative_property</a></li>
</ul>


Modelling and Proving logic gates in Coq
2024-03-23T00:00:00+00:00
In this post, we’ll explore how to model primitive logic gates such as AND, OR and NOT in Coq. Furthermore, we’ll take an additional step by proving their properties. First of all what is Coq?</p>
DISCLAIMER:</strong> I’m not an expect in Coq. I’m learning it out of curiosity. So whatever I’m saying in this post, take it with a grain of salt.</p>
Coq</a>
</h2>

Coq is a functional programming language which is also a proof assistant used for formal verification and theorem proving. It provides a formal language for expressing mathematical statements and proofs.</p>
I’m not gonna go into Coq as there are many resources available online if you want to learn. I’m gonna only focus on modelling the logic gates and proving their properties. I highly recommend you to follow along by writing code. Use the Coq online interpreter</a> to write code. We’ll be doing two things.</p>

Model all the three primitive logic gates(AND, OR and NOT)</li>
Prove the properties of the primitive gates we modelled.</li>
</ol>
First, let’s focus on modelling them.</p>
And gate</a>
</h2>

Let’s first look at the truth table of AND gate.</p>
| A | B | OUT |</span></span>
|---|---|-----|</span></span>
| 0 | 0 | 0   |</span></span>
| 0 | 1 | 0   |</span></span>
| 1 | 0 | 0   |</span></span>
| 1 | 1 | 1   |</span></span></code></pre>
By looking at the above truth table, we can tell that:</p>

If both the inputs are true, then the output is true.</li>
If any one of the input is false then the output is false.</li>
</ol>
Now, let’s model it in Coq.</p>
Definition</span> AND</span> (a</span>:</span> bool</span>) (b</span>:</span> bool</span>)</span>:</span> bool</span> :</span>=</span> </span></span>
	match</span> a </span>with</span></span>
	|</span> true</span> =</span>></span> b</span></span>
	|</span> false</span> =</span>></span> false</span></span>
	end</span>.</span></span></code></pre>
In the above code, we created a Definition,</strong> which in imperative programming languages we call it functions</em>. The name of the definition is AND</strong>, which takes two arguments of type boolean. We are doing pattern matching expression in the body of the definition.</p>

a</em> is the term being matched.</li>
true</em> and false</em> are the patterns being matched against a</em></li>
b</em> is the expression to be evaluated if a</em> matches true</em></li>
false</em> is the expression to be evaluated if a</em> matches false</em></li>
</ol>
By using the match</code> construct, we we’re able to pattern match the expression and model the AND gate.</p>
OR gate</a>
</h2>

Let’s first look at the truth table of OR gate.</p>
| A | B | OUT |</span></span>
|---|---|-----|</span></span>
| 0 | 0 | 0   |</span></span>
| 0 | 1 | 1   |</span></span>
| 1 | 0 | 1   |</span></span>
| 1 | 1 | 1   |</span></span></code></pre>
By looking at the above truth table, we can tell that</p>

If both the inputs are false, then the output is false</li>
If any one of the input is true, then the output is true.</li>
</ol>
Now, let’s model it in Coq.</p>
Definition</span> OR</span> (a</span>:</span> bool</span>) (b</span>:</span> bool</span>)</span>:</span> bool</span> :</span>=</span></span>
	match</span> a </span>with</span></span>
	|</span> true</span> =</span>></span> true</span></span>
	|</span> false</span> =</span>></span> b</span></span>
	end</span>.</span></span></code></pre>
The name of the definition is OR</strong>, which takes two arguments of type boolean.</p>

a</em> is the term being matched.</li>
true</em> and false</em> are the pattern being matched against.</li>
b</em> is the expression to be evaluated if a</em> matches false</em></li>
true</em> is the expression to be evaluated if a</em> matches true</em></li>
</ol>
NOT gate</a>
</h2>

Let’s first look at the truth table of NOT gate</p>
| A | OUT |</span></span>
|---|-----|</span></span>
| 0 | 1   |</span></span>
| 1 | 0   |</span></span></code></pre>
By looking at the above truth table, we can tell that</p>

If the input is 0(false</em>), then the output is 1(true</em>)</li>
If the input is 1(true</em>), then the output is 0(false</em>)</li>
</ol>
Now, let’s model it in Coq.</p>
Definition</span> NOT</span> (a</span>:</span> bool</span>)</span>:</span> bool</span> :</span>=</span></span>
	match</span> a </span>with</span></span>
	|</span> true</span> =</span>></span> false</span></span>
	|</span> false</span> =</span>></span> true</span></span>
	end</span>.</span></span></code></pre>
The name of the definition is NOT,</strong> which takes in one argument of type boolean.</p>

a</em> is the term being matched.</li>
true</em> and false</em> are the pattern being matched against</li>
false</em> is the expression to be evaluated if a</em> matched true</em></li>
true</em> is the expression to be evaluated if a</em> matched false</em></li>
</ol>
Now that we’ve modelled the primitive gates, let’s prove their properties. In simple terms, think of it like a test case that we would write to test some functionality. In this case, we’ve modelled primitive gates like a function that would return something based on the input. So, we would be proving if the function we’ve created works as expected or not.</p>
Proving NOT gate property</a>
</h2>

Let’s first prove NOT gate, because we only have to prove couple of cases. In Coq, we’ll use the Theorem</strong> command to prove mathematical theorem or properties. Theorem</strong> is used to declare propositions that we want to prove formally. The thing that we want to prove here is that the property of the NOT</strong> definition.</p>
There are two cases we must prove:</p>

true = false</li>
false = true</li>
</ol>
Let’s just look at the theorem.</p>
Theorem</span> proving_not</span>:</span> forall</span> (a</span>:</span> bool</span>), NOT (NOT a) </span>=</span> a.</span></span>
	intros</span>.</span></span>
	destruct</span> a.</span></span>
	simpl</span>; </span>reflexivity</span>.</span></span>
	simpl</span>; </span>reflexivity</span>.</span></span>
Qed</span>.</span></span></code></pre>
There are a lot of thing to breakdown in the above code. Let’s do it one by one.</p>
Theorem</a>
</h3>

Theorem’s start with the Theorem</strong> keyword, followed by the name of the theorem. In this case, the name of our theorem is proving_not</strong>. So the syntax would be,</p>
Theorem <name_of_the_theorem>:</code> , followed by what we are trying to prove. In this case, we are trying to prove for all “a”(which is a boolean type), NOT (NOT a) = a,</strong></em> which means, if we expand the NOT (NOT a)</strong> definition by replacing a</em> with true</em> or false</em>, the result should be equal to a</em>. For example,</p>
a = true, so</span></span>
NOT (NOT a) = a => NOT (NOT true)</span></span>
			    => NOT false</span></span>
		        => true</span></span>
</span>
a = false, so</span></span>
NOT (NOT a) = a => NOT (NOT false)</span></span>
			    => NOT true</span></span>
			    => false					</span></span>
	</span></span></code></pre>
When we execute Theorem proving_not: forall (a: bool), NOT (NOT a) = a.</code> , this is what Coq creates for us to prove. It creates a goal</strong></em>, which we should prove. The goal</em> is nothing but, what we stated in our Theorem</em></p>
</p>
intros</a>
</h3>

intros</code> is a keyword that is part of tactics</strong></em>. What are tactics</em>? Tactics are commands or procedures used to manipulate and reason about proofs within the proof environment.</p>
intros</code> is part of the Introduction tactics</em>. It is used to introduce variables into the proof context. In our case, we have only one variable which is a</strong></em>. So it brings a</em> into the proof context so that we can manipulate it and prove our theorem.</p>
When intros.</code> gets executed, it brings a</em> into the context. This is what happens when it gets executed.</p>
</p>
You can see a horizontal line, the things above the line contains variables, hypothesis, etc in the context that we use to manipulate to solve the proof. As you can see here, we have a: bool</code> which is the only variable that belongs in our Theorem</em>. The things below the horizontal line is when we need to prove to achieve our goal.</p>
destruct</a>
</h3>

destruct</code> keyword is used to perform case analysis on an inductive type</em>, breaking down the proofs into separate cases based on the possible constructors of the type. It is commonly used to reason about values of an inductive type by considering all possible cases individually.</p>
When we execute destruct a.</code> , it creates two subgoals</em> for us to prove.</p>
</p>
As you can see from the above picture, the destruct</code> tactic breaks down our initial goal into two subgoals because we have to solve for two different cases which is true</em> and false</em>. Now we have to solve these two goals. First we’ll solve NOT (NOT true) = true</code> because that is what is currently in the context.</p>
simpl</a>
</h3>

simpl</code> keyword is short for simplify</em>. We use this tactic to simplify the expression in the proof context by performing computation and reduction according to the definitions of the involved terms. For example, In our case we have an expression NOT (NOT true)</code> . What simpl</code> does is reduce the expression recursively until it cannot be reduced further. If we reduce this expression:</p>
NOT (NOT true) => NOT (false) => true</span></span></code></pre>
If we run the simpl.</code> command this is what we get:</p>
</p>
As you can see, it reduced the expression NOT (NOT true)</code> to true</code> . Now that we have true = true</code> we have to check it. For that we have to use one more tactic.</p>
reflexivity</a>
</h3>

The reflexivity</code> tactic is used to prove goals that assert equality between two terms or expressions. It asserts that any term is equal to itself, which is known as the reflexivity property of equality. When we execute reflexivity.</code> , it checks if the LHS is equal to the RHS syntactically. If yes, we have proved the goal, otherwise we didn’t. Let’s see.</p>
</p>
As you see from the above screenshot, now we have only one goal to prove. This is because we have proved our first goal ie. true = true</code>. Now let’s prove our second goal, which is NOT (NOT false) = false</code>.</p>
Given the current knowledge, how would you prove it? Its exactly the same as how we solved our first goal. We’ll first simplify</em> the expression and then check the equality</em>. To simplify the expression we’ll use simpl.</code> , once its simplified we’ll use reflexivity.</code> to check the equality. Once we’ve executed these two tactics, this is what we get.</p>
</p>
Congratulations, you’ve solved your first theorem. As you can see, there are no more goals</em> to prove. Which means we’ve successfully solved/proved the property of NOT gate</strong>.</p>
Proving AND gate property</a>
</h2>

Let’s first look at the theorem and break it down step by step.</p>
Theorem</span> and_property</span>:</span> forall</span> (b c</span>:</span> bool</span>),</span></span>
	(AND b c) </span>=</span> (AND c b).</span></span>
	Proof</span>.</span></span>
	intros</span> b c.</span></span>
	destruct</span> b.</span></span>
	-</span> destruct</span> c.</span></span>
		+</span> simpl</span>. </span>reflexivity</span>.</span></span>
		+</span> simpl</span>. </span>reflexivity</span>.</span></span>
	-</span> destruct</span> c.</span></span>
		+</span> simpl</span>. </span>reflexivity</span>.</span></span>
		+</span> simpl</span>. </span>reflexivity</span>.</span></span>
Qed</span>.</span></span></code></pre>
What does the above theorem asks us to prove? It says that, for all b</em> and c</em> which is of type boolean</em>, prove (AND b c) = (AND c b)</em>. What is AND</strong>? You can think of AND</strong> as a definition or function which takes in two arguments of type boolean and returns a boolean. Basically it does logical AND</em> operation on the arguments and returns the result.</p>
In simple terms, this is what we have to prove:</p>

true = true</li>
false = false</li>
false = false</li>
false = false</li>
</ol>
Now, let’s breakdown our proof step by step:</p>
What’s the goal that we have to prove?</p>
</p>
Currently we have one goal, as we prove, we’ll break it down into subgoals and prove it step by step. As always, the first step is to bring the variables into context. Here the variables are b</em> and c</em>. We know what tactic to use to introduce variables into the context.</p>
intros</a>
</h3>

The line intros b c</code> in our proof, brings the b</em> and c</em> variables into the context so that we can use them in subsequent tactics. This is what happens when that tactic gets executed.</p>
</p>
destruct</a>
</h3>

We use destruct</code> to breakdown our goals into small chunks. The line destruct b</code> replaces b</em> with true</em> and false</em> because that’s the type of b</em>. And it breaks it into individual goals. This is how it looks once we execute destruct b</code>.</p>
</p>
As you can see, it replaces b</em> with true</em> and false</em>. The first goal is true</em> case and the second goal is for false</em> case.</p>
The next line destruct c</code> does the same thing for c,</em> it replaces c</em> with true</em> and false</em>. But since we’ve already broken down the goals before, executing this command won’t break it down further. You might have noticed the -</strong> sign before the destruct c</code> command, we’ll get to it shortly. This is how it looks once we execute - destruct c</code>.</p>
</p>
As you can see, both b</em> and c</em> got replaced with true</em> and false</em>. Now we can able to prove it one by one.</p>
The line + simpl. reflexivity.</code> , let’s break this down. What is +</code> ? Just like -</code> , plus(+</strong>) is used to focus on subgoals that we are gonna prove. Let’s what happens to the goal when we execute only +</code></p>
</p>
As you can see, previously we have two goals, now we have only one. Because +</code> focuses on only one goal at a time. Now that we’ve got a goal to prove, let’s prove it.</p>
From the original statement + simpl. reflexivity</code> we’ve seen what +</code> does. Now let’s look at simpl.</code> Let’s try and execute simpl.</code> and see what happens.</p>
simpl</a>
</h3>

</p>
As the name suggests, it simplifies our statement/condition. Now we have true = true</strong>, which we know is equal. Can you guess what is the tactic</em> we use to check equality?? You guessed it right.</p>
reflexivity</a>
</h3>

Let’s execute reflexivity.</code> and see what happens.</p>
</p>
Reflexivity checks for equality. If LHS and RHS are equal, its success. Since we’ve proved our subgoal, Coq says we are done with our subgoal and we should be focusing on our next subgoal. To do that, we need to use the +</code> symbol. Just like the previous subgoal we can use the same set of commands to solve the next subgoal. But let’s first see what’s our subgoal is.</p>
</p>
Now that we know how to simplify the goal and check for equality let’s do that. Let’s execute simpl. reflexivity</code> . Which first simplifies the statement and checks for equality.</p>
</p>
</p>
It says, we’ve completed our subproof and asking us to focus on our goals. To do that, we should use -</code>. But before that let’s recap what we’ve proved in our first two subgoals. So far, we’ve proved — true = true</strong> and false = false</strong>. We’ve couple more cases to prove, which are — false = false</strong> and false = false</strong>. That is what our next goal is gonna be.</p>
Let’s focus on our next goal by executing -</code></p>
</p>
We’ve to expand c</em> now, we can use the destruct</code> tactic to do that. Executing destruct c.</code> would give us:</p>
</p>
We’ve got two subgoals. We’ve seen a similar pattern before, when we were proving for b</em>. The same way we prove these two subgoals. Executing the below statements would solve the proof.</p>
+</span> simpl</span>. </span>reflexivity</span> (*</span> solves the 1st subgoal </span>*)</span></span>
+</span> simpl</span>. </span>reflexivity</span> (*</span> solves the 2nd subgoal </span>*)</span></span></code></pre>
</p>
Voila! We have proved our theorem</em>. As you can see, we’ve no more goals which means we have proved (AND b c) = (AND c b)</strong>.</p>
Armed with the basics of proving theorems, take on the challenge of proving (OR b c) = (OR c b). The steps mirror those we've used for solving (AND b c) = (AND c b). If you've grasped at least half of what I've shared, you've already achieved a great deal. Now, dive into theorem proving with confidence!</p>


Unlocking the Mystery of Coq's Pattern Matching: The Journey Through minustwo
2024-03-18T00:00:00+00:00
I was learning Coq for fun, hoping someday that I would prove some theorems(JK). While learning Coq, specifically pattern matching</em>, I stumbled upon this definition named minustwo</strong></em>. As the name suggests, it subtracts 2 from the number you provide but with some cases. Let’s look at the definition to understand more.</p>

DISCLAIMER:</strong> I’m not an expert in Coq, I’m just experimenting</p>
</blockquote>
Definition</span> minustwo</span> (n</span>:</span> nat</span>)</span>:</span> nat</span> :</span>=</span></span>
	match</span> n </span>with</span></span>
	|</span> O</span> =</span>></span> O</span></span>
	|</span> S</span> O</span> =</span>></span> O</span></span>
	|</span> S</span> (</span>S</span> m) </span>=</span>></span> m</span></span>
	end</span>.</span></span></code></pre>
Let’s breakdown the above code.</p>
We have created a definition</em> which in imperative languages we call them functions</em>. The name of the definition is minustwo,</strong> which takes one argument n</em> of type nat</em> (short for Natural number).</p>
The body of the definition contains a match</em> statement. In Coq, we use match</em> statement for pattern matching</em>. You can think of match</em> as switch case</em> in other languages, but not exactly the same.</p>
We have three cases:</p>

If n</em> is O</em>, return O</em></li>
If n</em> matches with S O</em>, return O</em></li>
If n</em> matches with S (S m)</em>, return m</em></li>
</ol>
O</em> represents capital “O” and not numeral “0”. In Coq, both represents the same thing. We can replace “O” with “0” as well.</p>
But, what is S O</code></em>? What exactly is S</em> ? S</em> is short for Successor</strong> which is a constructor</em> in Coq(in-built). We can look at the signature of S</em> by executing this command: Check S.</code> Which gives us:</p>
</p>
This states that S</em> takes in a natural number(nat) and returns a natural number(nat). So,</p>

S O.</code> returns 1</li>
S 1.</code> returns 2</li>
S 2.</code> returns 3</li>
and so on. We can check that by executing Compute S n</code> , replace n</em> which a natural number</li>
</ul>
</p>
Instead of doing S O</em>, S 1</em>, S 2</em> and so on. We could also do something like:</p>

S (S O)</code> which returns 2</li>
S (S (S O))</code> which returns 3</li>
S (S (S (S O)))</code> which returns 4</li>
S (S (S (S (S O))))</code> which returns 5</li>
</ul>
Now that we know what S</em> is, and what it does, let’s go back to original code.</p>
Executing minustwo</a>
</h2>

How can we execute(call) minustwo</strong></em>? We can use the Compute</strong></em> vernacular which Coq provides. We can do something like:</p>
Compute</span> minustwo </span>0</span>. </span>(*</span> returns 0 </span>*)</span></span>
Compute</span> minustwo </span>1</span>. </span>(*</span> returns 0 </span>*)</span></span>
Compute</span> minustwo </span>2</span>. </span>(*</span> returns 0 </span>*)</span></span>
Compute</span> minustwo </span>3</span>. </span>(*</span> returns 1 </span>*)</span></span></code></pre>
Let’s take a look at the first statement Compute minustwo 0</code>. Essentially, we are passing O</code> to minustwo</strong></em> definition.</p>
match</span> n </span>with</span></span>
	|</span> O</span> =</span>></span> O</span></span>
	|</span> S</span> O</span> =</span>></span> O</span></span>
	|</span> S</span> (</span>S</span> m) </span>=</span>></span> m</span></span>
end</span>.</span></span></code></pre>
By looking at the body of the definition, we are handling the case for O</code> , which is O => O</code>. That is why when we pass O</code> it returns O</code>.</p>
For, Compute minustwo 1</code> , we are passing 1</code> to the minustwo</strong></em> definition, we are handling the case for 1</em>, which is S O</em>. As we know, S O = 1</em>. This case will match and it returns O</em>.</p>
For, Compute minustwo 2</code>, we are passing 2</em> to the minustwo</strong></em> definition. For this case, we don’t have any direct case. What we have is S (S m) ⇒ m.</em> So how does this work?</p>
When we pass 2</em>, under the hood, Coq transforms 2</em> to S (S O)</em>. So if we match this with the pattern in our case, it looks something like:</p>
S (S O) = S (S m)</span></span></code></pre>
In our match</em> case, we are returning m</em> if the pattern matches to S (S m)</em>. But what is m</em>? If we look at the above analysis S (S O) = S (S m)</code> , in the place of m</em> we have O</em> on LHS. So we’ll be returning O</em> as the result which is exactly what we needed. Because 2 - 2 = 0</strong>. Let’s do 5 - 2</strong> now and see how it works.</p>
5 - 2</a>
</h2>

Compute minustwo 5.</code>  When we run this command we expect the output to be 3.</em> Let’s breakdown. As we know, Coq represents 5</em> under the hood as,</p>
5 = S (S (S (S (S 0))))</span></span></code></pre>
So, let’s match this with our case:</p>
S (S (S (S (S 0)))) = S (S m)</span></span>
		            => S (S (S (S (S 0))))</span></span>
		        m   => S (S (S 0))</span></span></code></pre>
m</em> matches with S (S (S 0))</code> which when reduced we get 3</em>. That is exactly what we want, because 5 - 2 = 3</strong>. The reduction happens like:</p>
m	=> S (S (S 0))</span></span>
	=> S (S 1)</span></span>
	=> S 2</span></span>
	=> 3</span></span></code></pre>Conclusion</a>
</h2>

I was struggling to understand this for the past couple of hours before starting to write this post. I was finally able to grasp the concept after delving into the minustwo</code></strong> example and experimenting with different inputs. Through this journey, I gained a deeper appreciation for the elegance and power of pattern matching in Coq. It's amazing how a seemingly simple construct can unlock so much potential in our code.</p>


Lazy evaluation
2024-03-15T00:00:00+00:00
Trying to figure out what lazy evaluation</strong></em> is after knowing Haskell is fully lazy. Let’s write a normal sum function which takes in two arguments and add them and return the value. There would be two variants of the function:</p>

Eager evaluation</li>
Lazy evaluation</li>
</ol>
Eager evaluation</a>
</h2>
function</span> sum</span>(</span>a</span>:</span> number</span>,</span> b</span>:</span> number</span>)</span>:</span> number</span> {</span></span>
	return</span> a</span> +</span> b</span></span>
}</span></span>
</span>
console</span>.</span>log</span>(</span>sum</span>(</span>10</span> +</span> 20</span>,</span> 100</span>)</span>)</span></span></code></pre>
In the above code snippet, we are calling the sum</code> function by passing two arguments. First is 10 + 20</strong> and the second is 100</strong>.</p>
What happens in this situation is, Typescript will first evaluate 10 + 20</strong> and gets the result which would be 30</strong>. Then it would call the sum</code> function by passing in 30 and 100</strong></p>
Lazy evaluation</a>
</h2>
function</span> sum</span>(</span>a</span>:</span> (</span>)</span> =></span> number</span>,</span> b</span>:</span> (</span>)</span> =></span> number</span>)</span>:</span> (</span>)</span> =></span> number</span> {</span></span>
	return</span> (</span>)</span> =></span> a</span>(</span>)</span> +</span> b</span>(</span>)</span></span>
}</span></span>
</span>
console</span>.</span>log</span>(</span>sum</span>(</span>(</span>)</span> =></span> (</span>10</span> +</span> 20</span>)</span>,</span> (</span>)</span> =></span> 100</span>)</span>(</span>)</span>)</span></span></code></pre>
In the above code snippet, what happens is, we’ve defined the arguments and return types as functions, which would return a number.</p>
So, when the calling the sum</code> function, we wouldn’t pass the numbers directly, instead we pass in functions which returns a number. Now the return type of the sum</code> function is a function that returns a number,</em> which would be the final result.</p>
Creating a Lazy type</a>
</h2>
Let’s create a lazy type and update the above lazy sum function</p>
type</span> Lazy</span><</span>T</span>></span> =</span> (</span>)</span> =></span> T</span></span>
</span>
function</span> sum</span>(</span>a</span>:</span> Lazy</span><</span>number</span>></span>,</span> b</span>:</span> Lazy</span><</span>number</span>></span>)</span>:</span> Lazy</span><</span>number</span>></span> {</span></span>
	return</span> (</span>)</span> =></span> a</span>(</span>)</span> +</span> b</span>(</span>)</span>;</span></span>
}</span></span></code></pre>Don’t need, don’t evaluate</a>
</h2>
How can we avoid big computations that are not needed? We don’t evaluate them. Let’s take a look at couple of examples that demonstrate this.</p>
function</span> recurse</span><</span>T</span>></span>(</span>)</span>:</span> T</span> {</span></span>
	return</span> recurse</span>(</span>)</span>;</span></span>
}</span></span>
</span>
function</span> sum</span>(</span>a</span>:</span> number</span>,</span> b</span>:</span> number</span>)</span>:</span> number</span> {</span></span>
	return</span> a</span>;</span></span>
}</span></span>
</span>
console</span>.</span>log</span>(</span>sum</span>(</span>10</span> +</span> 20</span>,</span> recurse</span>(</span>)</span>)</span>)</span></span></code></pre>
In the above code snippet, we have two functions. One is a recursive function named recurse</code> and another one is sum</code>.</p>
The recurse</code> function just calls itself and it doesn’t contain any base case so it won’t exit. The sum</code> function, doesn’t actually adds the two arguments, instead it returns the first argument as it is.</p>
Finally we call the sum</code> function by passing two things. One is 10 + 20 = 30</strong> and the other is we are passing(calling) the recurse</code> function. What happens when we run the code?</p>

We’ll get: [ERR]: Maximum call stack size exceeded</code></p>
</blockquote>
Even before actually executing the function, Javascript will first evaluate 10 + 20 which gives 30. And after that, it calls the recurse function. Since this function doesn’t have a base case, it won’t exit. Which leads to stack size exceed. Even though we didn’t do anything with the “return value” of the recurse</code> function inside the sum</code> function, our program crashes. How can we resolve this?</p>
function</span> sum</span>(</span>a</span>:</span> Lazy</span><</span>number</span>></span>,</span> b</span>:</span> Lazy</span><</span>number</span>></span>)</span>:</span> Lazy</span><</span>number</span>></span> {</span></span>
	return</span> a</span>;</span></span>
}</span></span>
</span>
console</span>.</span>log</span>(</span>sum</span>(</span>(</span>)</span> =></span> 10</span> +</span> 20</span>,</span> (</span>)</span> =></span> recurse</span>(</span>)</span>)</span>)</span>;</span></span></code></pre>
What happens if we run the above program? We’ll get:</p>

[LOG]: () => 10 + 20</code></p>
</blockquote>
This is because our sum</code> function returns the first argument as it is, which is nothing but a function. As you see from the above result, it doesn’t evaluate the expression because we haven’t really called the function. Let’s now call the sum</code> function.</p>
console</span>.</span>log</span>(</span>sum</span>(</span>(</span>)</span> =></span> 10</span> +</span> 20</span>,</span> (</span>)</span> =></span> recurse</span>(</span>)</span>)</span>(</span>)</span>)</span>;</span></span></code></pre>
It’ll return 30</code> as the return value.</p>
As you can see, we are only returning a</code>(the first argument) and not the “value” of the recurse</code> function. But since we made it evaluate lazily, it won’t crash our program by going into infinite recursion</em> before actually executing our function. This is the advantage of lazy evaluation.</p>
Generators</a>
</h2>
Generators are part of Javascript that does lazy evaluation. Let’s modify our sum function and make it use generator.</p>
function</span>*</span> sum</span>(</span>a</span>:</span> number</span>,</span> b</span>:</span> number</span>)</span>:</span> Generator</span><</span>number</span>></span> {</span></span>
	yield</span> a</span> +</span> b</span></span>
}</span></span>
</span>
let</span> sumGenerator</span>:</span> Generator</span><</span>number</span>></span> =</span> sum</span>(</span>10</span> +</span> 20</span>,</span> 100</span>)</span>;</span></span>
</span>
console</span>.</span>log</span>(</span>sumGenerator</span>.</span>next</span>(</span>)</span>.</span>value</span>)</span></span></code></pre>
In the above code snippet, we have a generator function</em> named sum</strong>. The generator function returns a generator</em>. We call the sum</strong> function by passing in 10 + 20 = 30</strong> and 100</strong>. The execution won’t happen, instead it returns a generator</em>. The generator will have various different states that I’m not gonna go into.</p>
The generator will give have a next</strong> function, which upon called will execute the expression(30 + 100), which gives the result 130.</p>
Real world</a>
</h2>
Let’s try to create a function that generates an infinite list of numbers. Let’s look at two different ways:</p>

Naive approach</li>
Generator approach (Lazy evaluation)</li>
</ol>
Naive approach</a>
</h2>
function</span> infiniteList</span>(</span>)</span>:</span> number</span>[</span>]</span> {</span></span>
	let</span> n</span>:</span> Array</span><</span>number</span>></span> =</span> [</span>]</span></span>
	for</span> (</span>let</span> i</span> =</span> 0</span>;</span> ;</span> i</span>++</span>)</span> {</span></span>
		n</span>.</span>push</span>(</span>i</span>)</span>;</span></span>
	}</span></span>
	return</span> n</span>;</span></span>
}</span></span>
</span>
infiniteList</span>(</span>)</span>;</span></span></code></pre>
If we try to execute the above code snippet, the function will keep on executing and doesn’t return anything. We haven’t mentioned the upper limit in the for loop because we wanted to generate an infinite list. Since the function won’t return anything, its not useful. How would we solve this?</p>
Generator approach</a>
</h2>
function</span>*</span> infiniteList</span>(</span>)</span>:</span> Generator</span><</span>number</span>></span> {</span></span>
	for</span> (</span>let</span> i</span> =</span> 0</span>;</span>;</span> i</span>++</span>)</span> yield</span> i</span></span>
}</span></span>
</span>
let</span> infiniteListGenerator</span>:</span> Generator</span><</span>number</span>></span> =</span> infiniteList</span>(</span>)</span>;</span></span>
</span>
for</span> (</span>let</span> i</span> of</span> infiniteListGenerator</span>)</span> {</span></span>
	console</span>.</span>log</span>(</span>i</span>)</span></span>
}</span></span></code></pre>

DISCLAIMER</strong>: Running the above code eats up your memory fast</p>
</blockquote>
In the above code snippet, we’ve created a generator function</em> named infiniteList,</strong> which iterates from 0 to Infinity. Then we are calling the generator function which returns a generator(infiniteListGenerator</strong>). Finally we are iterating over the generator which gives us values from 0 to Infinity.</p>
The difference between the naive approach and the generator approach is that, the naive approach won’t even return anything until it completes the calculation. On the other hand, the generator approach evaluates it one by one, once it evaluates it returns the result of the evaluation back to the caller.</p>
Using this feature, now we can easily able to generate infinite lists. Let’s say we wanted first 10, 100, 1000 and 10,000 values. We could do something like:</p>
Array</span>.</span>from</span>(</span>new</span> Array</span>(</span>10</span>)</span>,</span> (</span>)</span> =></span> infiniteListGenerator</span>.</span>next</span>(</span>)</span>.</span>value</span>)</span>;</span></span>
Array</span>.</span>from</span>(</span>new</span> Array</span>(</span>100</span>)</span>,</span> (</span>)</span> =></span> infiniteListGenerator</span>.</span>next</span>(</span>)</span>.</span>value</span>)</span>;</span></span>
Array</span>.</span>from</span>(</span>new</span> Array</span>(</span>1000</span>)</span>,</span> (</span>)</span> =></span> infiniteListGenerator</span>.</span>next</span>(</span>)</span>.</span>value</span>)</span>;</span></span>
Array</span>.</span>from</span>(</span>new</span> Array</span>(</span>10000</span>)</span>,</span> (</span>)</span> =></span> infiniteListGenerator</span>.</span>next</span>(</span>)</span>.</span>value</span>)</span>;</span></span>
Array</span>.</span>from</span>(</span>new</span> Array</span>(</span>100000</span>)</span>,</span> (</span>)</span> =></span> infiniteListGenerator</span>.</span>next</span>(</span>)</span>.</span>value</span>)</span>;</span></span></code></pre>
Of course it would take performance hits once the value gets bigger. But the point is, its possible to generate infinite list with the help of lazy evaluation. Next time when you want to avoid big computations when generating something, try lazy evaluation.</p>


Sequential Logic
2024-03-07T00:00:00+00:00
To know more about Sequential logic</strong>, we need to first know about Combinational logic</strong>.</p>
Combinational logic</a>
</h2>
In digital circuits combinational logic refers to circuits whose output solely depends on the current values of the input. Whenever the input the changes, the output changes respectively. Combinational logic doesn’t involve time, it is purely depend on the current state of the values.</p>
Some examples of logic circuits that comes under Combination logic are NAND, AND, OR, NOT, XOR</strong> gates. These are elementary gates that are used to perform boolean algebra. Let’s look at a specific gate: AND</strong>. The truth table of the AND gate looks like this:</p>
| A | B | OUT |</span></span>
|---|---|-----|</span></span>
| 0 | 0 |  0  |</span></span>
| 0 | 1 |  0  |</span></span>
| 1 | 0 |  0  |</span></span>
| 1 | 1 |  1  |</span></span></code></pre>
To reiterate, whenever the value of the input signals changes, the output changes.</p>
Sequential logic</a>
</h2>
Sequential logic on the other hand deals with time</strong></em>. Whenever we take time</strong></em> into consideration, we have to deal with memory and state. In Sequential logic, the output not only depends on the current input but also on the previous inputs. Sequential logic has state</strong></em>, which is nothing but memory</strong></em>. But the combinational logic doesn’t have state since it doesn’t deal with time</strong></em>. Some examples of logic circuits that comes under Sequential logic are Flip-Flop, Bit, Registers, RAM</strong>.</p>
There are two types of Sequential logic circuits:</p>

Synchronous</strong></li>
Asynchronous</strong></li>
</ol>
But before looking into these two types of sequential logic circuits, we need to know about clock signals</strong></em>. What are clock signals?</p>
Clock signals</a>
</h2>
In electronics, a clock signal is an electronic logic signal(voltage or current) that oscillates between a high and a low state at a constant frequency.</p>
In a Synchronous logic circuit, the clock signal is applied to all storage devices, like flip-flops and causes them to change state simultaneously.</p>
A clock signal is produced by electronic oscillator called a clock generator. The most common form of clock signal is the square wave form.</p>
Circuits using clock signal for synchronization may become active at either raising edge, falling edge or in the case of double data rate, both in the raising edge and falling edge of the clock cycle.</p>
Synchronous Sequential logic</a>
</h2>
In Synchronous Sequential logic circuits, the state of the device(circuit) changes only at discrete time intervals in response to a clock signal</strong></em>. For example, a Data Flip Flop(DFF) can be implemented using Synchronous sequential logic:</p>
module</span> DFF</span>(</span></span>
	input</span> D, clk,</span></span>
	output</span> reg</span> Q</span></span>
);</span></span>
	always</span> @(</span>posedge</span> clk) Q </span><=</span> D;</span></span>
endmodule</span></span></code></pre>
In the above code, we have implemented DFF using Verilog. DFF takes a data input(D</strong>) and a clock signal(clk</strong>). Whenever the clock signal goes from negedge(0)</strong></em> to posedge(1),</strong></em> the output would be the input.</p>
Asynchronous Sequential logic</a>
</h2>
In Asynchronous Sequential logic, the state of the device(circuit) can change at any time in response to changing inputs. For example, the same DFF can be implemented using Asynchronous sequential logic:</p>
module</span> DFF</span>(</span></span>
	input</span> D, clk, reset,</span></span>
	output</span> Q</span></span>
);</span></span>
	always</span> @(</span>posedge</span> clk </span>or</span> posedge</span> reset) </span>begin</span></span>
		if</span> (reset) </span>begin</span></span>
			Q </span><=</span> 0</span>;</span></span>
		end</span> else</span> begin</span></span>
			Q </span><=</span> D;</span></span>
		end</span></span>
	end</span></span>
endmodule</span></span></code></pre>
In the above code example, we’ve added an input named reset</strong>, which is part of the always</code> block sensitive list. Along with the clock signal(clk</code>), whenever the reset</code> is 1</code> our circuit resets the value of the output to 0</code>. In this case, the DFF resets the value of the output to 0</code>.</p>
This is what we mean by the state of the device(circuit) can change at any time in response to changing inputs</em>.</p>


Writing a Counter in Verilog
2024-03-07T00:00:00+00:00
This post is about how to write a 4-bit Counter with synchronous reset</strong> in Verilog. But what do I mean by Counter</strong>? A Counter counts from 0 to n, where n > 0. Usually we count in decimals like 0, 1, 2, 3, 4, 5...n. But computers don’t count like that, they count in binary</em> as we all know.</p>
The 4-bit Counter counts from 0 to 15. But why only 15? because that’s the highest value of the number that we can represent in 4-bits (0000 = 0, 1111 = 15).</p>
Let’s count from 0 to 15 in Binary:</strong></p>
0000  = 0 </span></span>
0001 = 1</span></span>
0010 = 2</span></span>
0011 = 3</span></span>
0100 = 4 </span></span>
0101 = 5 </span></span>
0110 = 6 </span></span>
0111 = 7 </span></span>
1000 = 8 </span></span>
1001 = 9 </span></span>
1010 = 10 </span></span>
1011 = 11 </span></span>
1100 = 12 </span></span>
1101 = 13 </span></span>
1110 = 14 </span></span>
1111 = 15 </span></span></code></pre>
Now let’s first look at how to write a 4-bit Counter in Verilog without Synchronous reset</strong></em>.</p>
//</span> counter.v</span></span>
module</span> Counter4Bit</span>(</span></span>
	input</span> clk,</span></span>
	output</span> reg</span> [</span>3</span>:</span>0</span>] count </span>//</span> 4-bit to hold value till 1111 (15 in Decimal)</span></span>
);</span></span>
	always</span> @(</span>posedge</span> clk) </span>begin</span></span>
		count </span><=</span> count </span>+</span> 1</span>;</span></span>
	end</span></span>
endmodule</span></span></code></pre>module</span> counter_tb</span>;</span></span>
	reg</span> clk;</span></span>
	wire</span> [</span>3</span>:</span>0</span>] count;</span></span>
</span>
	Counter4Bit</span> counter</span>(</span></span>
		.clk(clk), .count(count)</span></span>
	)</span>;</span></span>
</span>
	always</span> #1</span> clk </span>=</span> ~</span>clk;</span></span>
</span>
	initial</span> begin</span></span>
		clk </span>=</span> 0</span>; </span>//</span> initial value of clk at 0ns time unit.</span></span>
</span>
		#100</span> $finish</span>; </span>//</span> stop the simulation after 100ns time unit</span></span>
	end</span></span>
endmodule</span></span></code></pre>
If we run the above design</em> code along with the testbench</em>, we can see that the output of count</em> will always be x</strong>. But what is x</strong>? In Verilog, x</strong> represents unknown</em> or undefined</em> value.</p>
The reason is because:</p>

At time unit 0ns</code>, the value of clk</code> is 0</code> and the value of count</code> is x</code> which is the initial value.</li>
At time unit 1ns</code>, the value of clk</code> is 1</code> and the value of count</code> is still x</code> . This is because we can’t add anything with unknown or undefined value. That is why at the positive edge of the clk</code> , count = x + 1</code> which results to x</code>.</li>
</ul>
</p>
So, how can we fix this? We need to provide a way to set the value of count</code> to 0</code> when the clk</code> (clock) goes from negative edge to positive edge (0 to 1). This is where reset</code> comes in. Let’s take a look at the slightly modified version of the design code</em> and testbench</em>.</p>
//</span> design code</span></span>
module</span> Counter4Bit</span>(</span></span>
	input</span> clk, reset,</span></span>
	output</span> reg</span> [</span>3</span>:</span>0</span>] count</span></span>
);</span></span>
	always</span> @(</span>posedge</span> clk) </span>begin</span></span>
		if</span> (reset) </span>begin</span></span>
			count </span><=</span> 0</span>;</span></span>
		end</span> else</span> begin</span></span>
			count </span><=</span> count </span>+</span> 1</span>;</span></span>
		end</span></span>
	end</span></span>
endmodule</span></span></code></pre>//</span> testbench</span></span>
module</span> counter_tb</span>;</span></span>
	reg</span> clk, reset;</span></span>
	wire</span> [</span>3</span>:</span>0</span>] count;</span></span>
</span>
	Counter4Bit</span> counter</span>(</span></span>
		.clk(clk),</span></span>
		.reset(reset),</span></span>
		.count(count)</span></span>
	)</span>;</span></span>
</span>
	//</span> for every 2ns time unit, clk goes from 0 to 1 to 0</span></span>
	always</span> #1</span> clk </span>=</span> ~</span>clk;</span></span>
</span>
	initial</span> begin</span></span>
		clk </span>=</span> 0</span>; reset </span>=</span> 0</span>; </span>//</span> set initial values at 0ns time unit</span></span>
		#1</span> reset</span>=</span>1</span>; </span>//</span> set the initial value of count to 0</span></span>
		#1</span> reset</span>=</span>0</span>; </span>//</span> increment count</span></span>
</span>
		#30</span> $finish</span>; </span>//</span> stop the simulation after 33ns time unit</span></span>
	end</span></span>
endmodule</span></span></code></pre>
Let’s breakdown the above design code</em> and testbench</em>:</p>

We’ve added a reset</code> wire as output in Counter4Bit</code> module. Whenever the value of reset</code> is 1</code> it sets count</code> to 0</code>.</li>
In the testbench,</em> we’ve set the initial value of reset</code> to 0</code> at 0ns</code> time unit.</li>
At 1ns</code> time unit, we are making reset</code> as 1</code> , this make sure that the initial value of count</code> is set to 0</code>. Also this happens when the value of clk</code> is 1</code>.</li>
At 2ns</code> time unit, we are making reset</code> as 0</code> to start incrementing the value of count</code> by 1.</li>
</ul>
When we run the above design code</em> and testbench</em>:</p>

At time unit 0ns</code>, clk=0, reset=0 and count=xxxx</li>
At time unit 1ns</code> , clk=1, reset=1 and count=0</li>
At time unit 2ns</code>, clk=0, reset=0 and count=0</li>
At time unit 3ns</code>, clk=1, reset=0 and count=1</li>
At time unit 4ns</code>, clk=0, reset=0 and count=1</li>
At time unit 5ns</code>, clk=1, reset=0 and count=10</li>
At time unit 6ns</code> , clk=0, reset=0 and count=10</li>
….</li>
At time unit 32ns</code>, clk=0, reset=0 and count=1111</li>
</ul>
</p>
This is a brief description about how to write a 4-bit Counter with Synchronous reset in Verilog. The reference code can be found here</a>.</p>
Keyword Parsing

References </a> </h2>

Induction: https://en.wikipedia.org/wiki/Mathematical_induction</a></li>
Associative property: https://en.wikipedia.org/wiki/Associative_property</a></li>
Commutative property: https://en.wikipedia.org/wiki/Commutative_property</a></li> </ul>

reflexivity

Conclusion

Real world
Naive approach</li>
Naive approach </a> </h2>
Generator approach

Naive approach </a> </h2>
Generator approach

Generator approach

Combinational logicSequential logic

Synchronous</strong></li>
Clock signalsSynchronous Sequential logic
Asynchronous Sequential logic

Sequential logic

Synchronous</strong></li>
Clock signalsSynchronous Sequential logic
Asynchronous Sequential logic

Clock signalsSynchronous Sequential logic
Asynchronous Sequential logic

Synchronous Sequential logic
Asynchronous Sequential logic

Asynchronous Sequential logic

My Blog

A Beginner’s guide to Writing Data Flip Flop in Verilog

Writing a simple Lexer

Associative and Commutative property of Addition in Coq

Modelling and Proving logic gates in Coq

Unlocking the Mystery of Coq's Pattern Matching: The Journey Through minustwo

Lazy evaluation

Sequential Logic

Writing a Counter in Verilog

My Blog

A Beginner’s guide to Writing Data Flip Flop in Verilog

Writing a simple Lexer

Ignoring whitespaces</a> </h2> Let’s add the ability to ignore (discard) whitespaces to our Lexer. We will take three things into consideration.</p> Simple space (’ ‘)</li> Carriage return (’\r’)</li>

Associative and Commutative property of Addition in Coq

Induction step 1</a> </h3> We have to prove the base case, ie., n = 0 or n = 1</strong></em>.</p> Induction step 2</a> </h3> Assume</strong> it is true for n = k</strong></em>, where k</strong> is an arbitrary number.</li>

Induction step 2</a> </h3> Assume</strong> it is true for n = k</strong></em>, where k</strong> is an arbitrary number.</li>

Modelling and Proving logic gates in Coq

Unlocking the Mystery of Coq's Pattern Matching: The Journey Through minustwo

Lazy evaluation

Real world</a> </h2> Let’s try to create a function that generates an infinite list of numbers. Let’s look at two different ways:</p> Naive approach</li>

Sequential Logic

Writing a Counter in Verilog

Real world
Naive approach</li>
Naive approach </a> </h2>
Generator approach
