Passive learning in finite state automata

Question

I'm reading the following paragraph in the Foundations of Machine learning book https://cs.nyu.edu/~mohri/mlbook/ on page 362 (of the book).

Now i'm fairly new to the concept of DFA but i have some experience. I have some questions over the paragraph.

1. Why do they want a deterministic automata that accepts the positively labeled string "a" or "b"? Surely you would want to reject $"b"$ since it is negatively labelled?

2. Is "a" meant to be a string of characters ie a = 01010101 or is it a single letter itself?

3. What is the minimal two state automata that accepts "a" or "b" could someone describe it? Also i'm unsure how it differs from the single state machine they describe next for the language a*? Could someone explicitly describe both? I don't see what the difference between the two cases is and maybe thats why i don't understand why one has two states and the other a single state.

I would really appreciate any help as i'm really trying to understand the concepts they talk about.

Answer 1

1. they want a DFA with as few states as possible that accepts the string 'a' and rejects the string 'b'
2. 'a' is meant as the symbol a, not as a shorthand that represents the bit string you gave. In formal language theory it's allowed to use letters as symbols.
3. They are trying to distinguish here between the DFA with the fewest states that accepts 'a' and rejects 'b', and the minimal DFA accepting the language {'a'}. See below.

The smallest DFA which accepts 'a' and rejects 'b' actually has two states, if you use the standard conventions that dead states must be represented and all transitions must be shown:

       +--a--+
       |     |
----->q0<----+
       |
       b
       |
       V
      q1<----+
       |     |
       +-a,b-+

In the above DFA, q0 is accepting. No smaller DFA accepts 'a' and rejects 'b'. You know this since the DFA must have an accepting state to accept anything, and a non-accepting state to reject anything, and since a state can't be both simultaneously, we need two. Now, the distinction the quoted passage is getting at is that the DFA that accepts the language {'a'} is larger (because it excludes everything except 'a', not just 'b'):

----->q0--a-->q1
      |       |
      b      a,b
      |       |
      |       V
      +------>q2<---+
              |     |
              +-a,b-+

Here, q1 is accepting. Notice that we needed an extra state to avoid accepting longer strings of 'a's.