The title is my interpretation of this question. Below is what I have attempted so far:
Case 1: Ɛ ∈ L(M)
L(M1) = L(M)
L(M2) = {Q2, Σ2, q20, F2, 𝛿2}
Q={q0, ... , qi}
Q2={q20, ... , q2i+1}
Σ2 = Σ
q2i+1 ∈ F2 iff qi ∈ F
𝛿2(q2i+1, a) = 𝛿(qi, a)
Case 2: Ɛ ∉ L(M)
L(M2) = L(M)
L(M1) = {Q1, Σ1, q10, F1, 𝛿1}
...
What you have so far looks good but incomplete. Here's a description of what's left; writing it out in symbols is left as an exercise.
In the first case, if the language already contains the empty string, we're done and can use the automaton for the language directly with no modification. If it does not contain the empty string already, we can add a new initial state and have it transition like the original initial state. If we leave all other transitions alone and make this new initial state accepting, we will accept the empty string as well as anything the original automaton accepted.
In the second case, if the language does not already contain the empty string, we're done and can use the automaton for the language directly with no modification. If it does contain the empty string already, we can add a new initial state and have it transition like the original initial state. If we leave all other transitions alone and don't make this new initial state accepting, we will not accept the empty string but will continue to accept everything else.
This is the best that can be done, in general. However, specific languages might have smaller automata than these constructed after adding or removing the empty string. For instance, the language consisting of only the empty string has a DFA with two states, but a minimal DFA for that language with the empty string removed has one state. Similarly, the language of all non-empty strings has a DFA with two states, but adding the empty string to that language means there's a one-state DFA for that language. So this construction does not always give the smallest DFA possible, but it is guaranteed to work for all cases, including those where there is no smaller DFA for the language (e.g., adding the empty string to the empty language forces the addition of a new state).
Related
As we know, the definition of 'finite state automata' is:
Then we have this finite state automat described as:
Then we have the conclusion:
Question is : Instead of accept an empty string, what if the automat first read string is '2', which is not belong to the alphabet(0,1) of this automata. will this automata still go to accept state?
pics quoted from book <Introduction to the Theory of Computation>
When a machine is defined, one of its items is the alphabet (second one in your definition). We are not allowed to test our machine outside the scope of the alphabet. Therefore, all strings of L (accepted strings) and L-bar (rejected strings) should come out of Sigma-start.
I am just new in automata field. I have read many articles, and seen many video. I stuck in some first topics. It can be easy for others. but after spending a lot of time,i am still unable to understand it.
TOPIC is: Ambiguity in alphabet
An alphabet is = {A, Aa, bab, d}
and a string is s= AababA
and author says that, this is ambiguous alphabet, because when computer reads it , it reads from left to right. After the capital A, there again A that is prefix of small a, will create ambiguity. A letter(symbol) should not be prefix again of a new letter.
moreover author says.
we will tokenize it (AababA) in two ways:
(Aa) (bab) (A)
(A) (abab) (A)
after that , first one is ok, second is not ok due to ambiguity in alphabet define above.
What is procedure to tokenize the above string in two ways? is there any specific rule?
How alphabet is ambiguous due to second group.
If it is invalid due to prefix of A, then how? What is the role of prefix in ambiguity of alphabet?
If we don't think about prefix, and we just simply match the both string group with above alphabet, then we can easily judge, that second is not matching with above alphabet, then why do we need to discuss that prefix?
I hope, this question will be considered important, so that answer will help me to make my self out of this confusion. I will be very thankful .
The author chose a confusing example. If you share the source where you got this example, I could give a better answer, but I would argue that in this case, there is no practical ambiguity. If you see Aa, you can know that the first lexeme must be "Aa", because nothing in the alphabet starts with "a".
For an easier example, consider the alphabet {A, a, Aa} and string "AAaAaaA"
You could tokenize this in the following ways:
(A) (A) (a) (A) (a) (a) (A)
(A) (Aa) (A) (a) (a) (A)
(A) (A) (a) (Aa) (a) (A)
(A) (Aa) (Aa) (A)
This is most often resolved by choosing the longest lexeme that matches in each case, which would yield the last tokenization.
Now let us return to your example, but let's make the string a little bit different: "AababAe".
You could tokenize the string in the following ways:
(Aa) (bab) (A) <error>
(A) <error>
In one branch, you have an error. In one branch, you don't. As you noted, the tokenizer should choose the first. Both have errors, though. The point is that there is an explicit choice here to prefer the longest valid tokenization. Nothing in the alphabet forces you to make this choice. It is just as valid to choose the shortest matching option. This would be massively impractical, but it is a valid choice.
I've seen := used in several code samples, but never with an accompanying explanation. It's not exactly possible to google its use without knowing the proper name for it.
What does it do?
http://en.wikipedia.org/wiki/Equals_sign#In_computer_programming
In computer programming languages, the equals sign typically denotes either a boolean operator to test equality of values (e.g. as in Pascal or Eiffel), which is consistent with the symbol's usage in mathematics, or an assignment operator (e.g. as in C-like languages). Languages making the former choice often use a colon-equals (:=) or ≔ to denote their assignment operator. Languages making the latter choice often use a double equals sign (==) to denote their boolean equality operator.
Note: I found this by searching for colon equals operator
It's the assignment operator in Pascal and is often used in proofs and pseudo-code. It's the same thing as = in C-dialect languages.
Historically, computer science papers used = for equality comparisons and ← for assignments. Pascal used := to stand in for the hard-to-type left arrow. C went a different direction and instead decided on the = and == operators.
In the statically typed language Go := is initialization and assignment in one step. It is done to allow for interpreted-like creation of variables in a compiled language.
// Creates and assigns
answer := 42
// Creates and assigns
var answer = 42
Another interpretation from outside the world of programming languages comes from Wolfram Mathworld, et al:
If A and B are equal by definition (i.e., A is defined as B), then this is written symbolically as A=B, A:=B, or sometimes A≜B.
■ http://mathworld.wolfram.com/Defined.html
■ https://math.stackexchange.com/questions/182101/appropriate-notation-equiv-versus
Some language uses := to act as the assignment operator.
In a lot of CS books, it's used as the assignment operator, to differentiate from the equality operator =. In a lot of high level languages, though, assignment is = and equality is ==.
This is old (pascal) syntax for the assignment operator. It would be used like so:
a := 45;
It may be in other languages as well, probably in a similar use.
A number of programming languages, most notably Pascal and Ada, use a colon immediately followed by an equals sign (:=) as the assignment operator, to distinguish it from a single equals which is an equality test (C instead used a single equals as assignment, and a double equals as the equality test).
Reference: Colon (punctuation).
In Python:
Named Expressions (NAME := expr) was introduced in Python 3.8. It allows for the assignment of variables within an expression that is currently being evaluated. The colon equals operator := is sometimes called the walrus operator because, well, it looks like a walrus emoticon.
For example:
if any((comment := line).startswith('#') for line in lines):
print(f"First comment: {comment}")
else:
print("There are no comments")
This would be invalid if you swapped the := for =. Note the additional parentheses surrounding the named expression. Another example:
# Compute partial sums in a list comprehension
total = 0
values = [1, 2, 3, 4, 5]
partial_sums = [total := total + v for v in values]
# [1, 3, 6, 10, 15]
print(f"Total: {total}") # Total: 15
Note that the variable total is not local to the comprehension (so too is comment from the first example). The NAME in a named expression cannot be a local variable within an expression, so, for example, [i := 0 for i, j in stuff] would be invalid, because i is local to the list comprehension.
I've taken examples from the PEP 572 document - it's a good read! I for one am looking forward to using Named Expressions, once my company upgrades from Python 3.6. Hope this was helpful!
Sources: Towards Data Science Article and PEP 572.
It's like an arrow without using a less-than symbol <= so like everybody already said "assignment" operator. Bringing clarity to what is being set to where as opposed to the logical operator of equivalence.
In Mathematics it is like equals but A := B means A is defined as B, a triple bar equals can be used to say it's similar and equal by definition but not always the same thing.
Anyway I point to these other references that were probably in the minds of those that invented it, but it's really just that plane equals and less that equals were taken (or potentially easily confused with =<) and something new to define assignment was needed and that made the most sense.
Historical References: I first saw this in SmallTalk the original Object Language, of which SJ of Apple only copied the Windows part of and BG of Microsoft watered down from them further (single threaded). Eventually SJ in NeXT took the second more important lesson from Xerox PARC in, which became Objective C.
Well anyway they just took colon-equals assiment operator from ALGOL 1958 which was later popularized by Pascal
https://en.wikipedia.org/wiki/PARC_(company)
https://en.wikipedia.org/wiki/Assignment_(computer_science)
Assignments typically allow a variable to hold different values at
different times during its life-span and scope. However, some
languages (primarily strictly functional) do not allow that kind of
"destructive" reassignment, as it might imply changes of non-local
state.
The purpose is to enforce referential transparency, i.e. functions
that do not depend on the state of some variable(s), but produce the
same results for a given set of parametric inputs at any point in
time.
https://en.wikipedia.org/wiki/Referential_transparency
For VB.net,
a constructor (for this case, Me = this in Java):
Public ABC(int A, int B, int C){
Me.A = A;
Me.B = B;
Me.C = C;
}
when you create that object:
new ABC(C:=1, A:=2, B:=3)
Then, regardless of the order of the parameters, that ABC object has A=2, B=3, C=1
So, ya, very good practice for others to read your code effectively
Colon-equals was used in Algol and its descendants such as Pascal and Ada because it is as close as ASCII gets to a left-arrow symbol.
The strange convention of using equals for assignment and double-equals for comparison was started with the C language.
In Prolog, there is no distinction between assignment and the equality test.
I have to create a deterministic finite automata accepting the set of strings with an even number of 1 and ends with 0.Should I include 0 as a string from this set? and how can I do this?
Should I include 0 as a string from this set?
Yes
And how do I do this?
To construct a finite automaton, you need to identify the states and transitions. The Myhill-Nerode theorem allows you to find the necessary (and sufficient!) states of for a finite automaton if you are able to identify the equivalence classes of "indistinguishable" strings.
Two strings x and y are indistinguishable, in this sense, if for any other string z, either both xz and yz are in the language, or neither is.
In your case, let's try to identify equivalence classes. The empty string is in some equivalence class. The string 0 is in a different equivalent class, since you can add the empty string to 0 and get a string in the language (whereas you can't add the empty string to the empty string to get a string in the language). We have found two distinct equivalence classes so far - one for the empty string, one for 0. Both of these will need different states in our FA.
What about the string 1? It's distinguishable from both 0 and the empty string, since you can add 10 to 1 to get 110, a string in the language, but you can't add it to 0 or the empty string to get a string in the language. So we have yet another state.
What about the string 00? This string is not in the language, and no other string can be added to this string to get a string in the language. This is another equivalence class. It turns out that the next strings, 01 and 10, are also in this class.
The string 11 ends up being in the same class as the empty string: you can add any string in the language to 11 and get another string in the language. If you try all strings of length 3, you will find that all of those already fall into one of the above classes, and you can stop checking at that point.
So we have four states - let's call them [-], [0], [1], and [00]. Now we figure out transitions.
If you get a 0 in [-], you need to go to [0]... and if you get a 1, you need to go to [1]. For the rest, just figure out what string you'd get by adding to the canonical one, and which class the resulting string would be in... and go to that state.
Given Question is to construct a Finite Automata with even number of 1's and ends with 0.
So the alphabet of the language is {0,1}
These are the the strings that are accepted by the language.
The Language always consists of '0' before its final state as it is the end of the string and we reach the final state when we reach the last '0' in the string.
Here in the normal procedure of conversion of it into the finite automata we get NFA
Then we need to convert the NFA to DFA by combining 2 states into single and simplifying them.
New transition diagram
Here we had drawn the new transition diagram based on the states reached by a specific state at a given input. Then the new states formed by joining 2 states [ here {q0,q2} state is formed]
This new state {q0,q1} on 0 as input goes to itself (as q0 on 0 goes to q0 and q2 on 0 goes to q2).
So let us conside this new state {q0,q2} as a new state q2'
So by using the Transition state diagram we can easily make the required DFA
Deterministic Finite Automata
The above diagram is the constructed finite automata accepting the set of strings with an even number of 1's and ending with 0.
q0 - is the Initial state
q2'- is the Final state
I want to construct a deterministic finite automata that accepts the following language:
{w ∈ {a,b}* : each a in w is immediately preceded by a b}
So far I've got >⨀ ---b---> O ---a---> O.
'>' = initial state
⨀ = final state
A good way to think about FAs is by trying to think about how many different situations you can be in, in terms of how you are going to get to a string in the language. Let's start with a few small strings and see what I mean.
Say you start with the empty string. What can you append to this to get a string in the language? Well, the empty string is in the language, so we can append the empty string (i.e., nothing) and also have a string in the language. Additionally, we can append any string in the language we are going for to the empty string, and we will get a string in the language (trivially). We will need at least one state to remember the empty string (and strings like it - strings to which we can append the empty string or any other string in the language and still have a string in the language); this will be the start/initial state, and since the empty string is in the language (we check this easily), we know the start/initial state will be accepting.
Now let's consider the string a. This is an example of a string not in the language, and there's nothing we can add to the end of this string to cause it to be in the language; we've already violated the condition that all a's in the string are preceded by b's. The set of strings we can add to this to get a string in the language is the empty set, and therefore, we will need a state distinct from the one we've already identified to remember this string and strings like it - strings to which we cannot add anything to get a string in the language.
To recap, we have identified two states: an accepting start/initial state, and what we call a "dead" state - a state that is not accepting and which does not ever lead to an accepting state.
Let's try the string b. This string is in the language, and so we can add the empty string to it. We can also trivially add any other string in the language to the end of this string, and get another string in the language. However, we can also add an a followed by any string in the language, and get another string in the language. For instance, we can add the string a followed by bbabb to get babbabb, which is also in the language. The set of strings which we can add is therefore a set we haven't seen before, and we will need a new state to represent this string - the string b - and strings like it. It will be accepting, since the string b is a string in the language.
You should try the strings aa, ab, ba, and bb. You should find that the strings aa and ab are both already covered by our dead state (we can't add any strings to the end of these to get anything in our language), and that the string ba is covered by the start/initial state (we can only add to this strings already in the language to get other strings in the language), and that bb corresponds to the third state we identified (adding any string, or a single a followed by any string, will result in a string also in the language). Since we have exhausted all strings of length 2 and not added any new states, we know that these are all the states that we need in the FA; we could add others, but they'd be unnecessary.
To get the transitions, all we need to do is to make sure that all the states lead to the correct place. In other words, since the string a is formed by adding the character a to the end of the empty string, we need a transition from the start/initial state (corresponding to the empty string) to the dead state (corresponding to the string a) which occurs when the FA reads the symbol a. Similarly, we need a transition from the start/initial state to the third state on the symbol b. The other transitions are found similarly: on either an a or a b, the dead state transitions to itself, and the third state loops on b and transitions to the start/initial state on an a. Once each state has a transition for each symbol in the alphabet, you have a complete (and correct) FA. Moreoever, by constructing it in this fashion, you guarantee that you have a minimal FA... which is a nice way to solve problems requesting one, instead of coming up with an arbitrary one and minimizing it post-hoc.
State 1 (accepting, initial state):
On input 'a', go to state 3 (permanently rejecting the string)
On input 'b', go to state 2
State 2 (accepting):
On input 'a', go to state 1
On input 'b', go to state 2
State 3 (not accepting)
On input 'a' or 'b', stay in state 3
Conceptually, State 1 represents "a valid string whose final letter is not b", State 2 represents "a valid string whose final letter is b", and State 3 represents "a string that is not valid"
In graphed form: