I'm confused by your question.
I'm assuming you meant something like the following:
Alice sends Bob a twice-encrypted message.
Alice generates a fresh new symmetric key Ks,
encrypts a plaintext message once with Ks,
then encrypts the resulting data again using Bob's public key.
Alice also "encrypts" the symmetric key Ks with Alice's private key,
and sends that encrypted key to Bob.
Bob "decrypts" the symmetric key Ks using Alice's public key,
then uses Ks (and his own private key) to decrypt the plaintext message.
The conclusion reached from this exchange of messages is
that Bob can not be sure that the message was written by Alice but
Alice can be sure that only Bob can read.
But how can we reach this conclusion: Bob does not know if it was
Alice who wrote if he had to get the Alice's public key for the symmetric
I'm assuming the normal public-key assumption that everyone's public key is, in fact, common knowledge and can be looked up in some public directory or another,
and Alice and Bob have somehow obtained (perhaps from that public directory) and validated each other's public keys.
Setting aside the fact that "encrypting" with a private key is almost certainly a protocol flaw...
Even though Bob uses the public key that he knows is Alice's public key, he cannot be certain that the plaintext message came from Alice.
If Bob is as good at cryptography as we hope he is, he realizes that the true sequence of events may perhaps be something more like:
A long time ago, Alice "encrypted" a symmetric key Ks
with Alice's private key and sent that encrypted message to Mallory --
or sent it to some uninvolved 4th party, and Mallory overheard and recorded that message.
Mallory forwarded a copy of
that message to Bob with forged headers making it look like an
encrypted message from Alice (which it is) to Bob (which it isn't)
related to the double-encrypted message that Bob will soon receive
(which it isn't).
(With some systems, it's not necessary for Mallory to ever
copy any message from Alice -- with some systems, it may be
possible for Mallory to simply flip a coin enough times and send
those random bits to Bob with forged headers making it look like a
encrypted message from Alice to Bob related to the double-encrypted
message that Bob will soon receive).
Then Mallory and Bob both look up Alice's public key in the public
directory to "decrypt" that random message into a symmetric key Ks.
Once Mallory has the symmetric key Ks, it's easy
for him to forge a message to Bob that appears to come from Alice.
Mallory encrypts any plaintext message of his choice once with Ks, then
encrypting the resulting data again using Bob's public key
(which he looks up in some public directory).
Since there's no way for Bob to distinguish these messages from Mallory from identical messages from Alice, Bob can't possibly know if the messages he received really came from Alice or not.
(There are other, better authentication protocols that would allow Bob to know whether or not the messages he received really came from Alice).