What is the difference between "securely realizes" and "securely implements"? In some security proofs it is stated that "a protocol securely realizes an ideal functionality" while in some others "a protocol securely implements an ideal functionality".


Is there a meaningful difference or it is just another verb to say a
similar thing?
Also, is there any difference between emulation and simulation in the context of MPC?


Update: 

Example for question 1: Outsourced pattern matching, S. Faust, et al. see Definition 3 and compare with 5PM: secure pattern matching, J. Baron, et al. page 29 definition 5.

Example for question 2: wikipedia article on Universal composability:


  Literally, the protocol may simulate the other protocol (without
  having access to the code). The notion of security is derived by
  implication. Assume a protocol P_1 is secure per definition. If
  another protocol P_2 emulates protocol P_1 such that no environment
  tells apart the emulation from the execution of the protocol, then the
  emulated protocol P_2 is as secure as protocol P_1.
Realizes vs Implements
Given the context of the cited papers, they mean the same thing. That said, I would prefer realizes. Implements has a connotation of a source code implementation. There could be implementation flaws (buffer overflow, etc) that impact security. The protocol design is secure, but the implementation is not. That, to me, is the primary reason to prefer realizes over implements.
Simulate vs emulate
The difference in the wording on the Wiki stems from the difference between the two. I found this description of the general difference between the two to be good.

Emulation is the process of mimicking the outwardly observable behavior to match an existing target. The internal state of the emulation mechanism does not have to accurately reflect the internal state of the target which it is emulating.
Simulation, on the other hand, involves modeling the underlying state of the target. The end result of a good simulation is that the simulation model will emulate the target which it is simulating.

So, the wiki article says that &quot;the protocol may simulate the other protocol&quot;, but it doesn't have to simulate it (in terms of modeling the underlying state of the target). All it really has to do is emulate, or mimick the outwardly observable behavior. So, internally, we may be simulating the protocol, or we may be doing something else, as long as as long as the outside observable behavior matches.
Note that in Universal Composability, there is a simulator $S$, that is not called a simulator because it simulates the real functionality, it is called a simulator because

We often call the adversary $S$ a simulator. This is due to the fact that in typical proofs of security the constructed $S$ operates by simulating an execution of $\mathcal{A}$.