อะไรคือความแตกต่างระหว่างความสัมพันธ์เชิงตรรกะและการจำลอง?

ฉันเป็นผู้เริ่มต้นในการทำงานกับวิธีการพิสูจน์ความเท่าเทียมกันของโปรแกรม ฉันได้อ่านบทความสองสามฉบับเกี่ยวกับการนิยามความสัมพันธ์เชิงตรรกะหรือการจำลองเพื่อพิสูจน์ว่าโปรแกรมสองโปรแกรมนั้นมีความเท่าเทียมกัน แต่ฉันค่อนข้างสับสนเกี่ยวกับเทคนิคทั้งสองนี้

ฉันรู้ว่าความสัมพันธ์เชิงตรรกะนั้นมีการกำหนดแบบ inductively ขณะที่การจำลองขึ้นอยู่กับการทำเงิน ทำไมพวกเขาจึงนิยามในรูปแบบดังกล่าว? อะไรคือข้อดีและข้อเสียของพวกเขาตามลำดับ? ฉันควรเลือกอันไหนในสถานการณ์ที่แตกต่างกัน

ฉันมีคำตอบสำหรับคำถามนี้ซึ่งอาจเป็นนวนิยาย ในความเป็นจริงฉันยังคงคิดถึงมันในช่วง 6 เดือนที่ผ่านมาและมันยังไม่ได้เขียนในเอกสาร

วิทยานิพนธ์ทั่วไปคือหลักการให้เหตุผลเชิงความสัมพันธ์เช่น "ความสัมพันธ์เชิงตรรกะ", "การจำลอง" และแม้แต่ "ค่าคงที่" คือการแสดงให้เห็นถึงข้อมูลที่เป็นนามธรรมหรือการซ่อนข้อมูล เมื่อใดก็ตามที่มีการซ่อนข้อมูลหลักการเหล่านี้จะก่อให้เกิดความเสียหาย

คนแรกที่ค้นพบว่ามันเป็นนักทฤษฎีออโตมาตะ ออโตมีสถานะที่ซ่อนอยู่ ดังนั้นคุณต้องใช้เหตุผลเชิงเหตุผลเพื่อพูดคุยเกี่ยวกับความเท่าเทียมของพวกเขา นักทฤษฎีออโตมาตะต้องดิ้นรนกับโฮโมมอร์ฟิซึมในระยะหนึ่งยอมแพ้และเกิดความคิดที่เรียกว่า "การปกปิดเชิงสัมพันธ์" ซึ่งเป็นรูปแบบของความสัมพันธ์จำลอง

มิลเนอร์หยิบความคิดขึ้นมาในกระดาษที่รู้จักกันน้อย แต่พื้นฐานมากที่เรียกว่า " ความคิดเกี่ยวกับพีชคณิตของการจำลองระหว่างโปรแกรม " ในปี 1971 Hoare รู้และใช้มันในการสร้าง " หลักฐานการพิสูจน์ความถูกต้องของข้อมูล " ในปี 1972 ฟังก์ชั่นที่เป็นนามธรรมแทนความสัมพันธ์เพราะเขาคิดว่าพวกเขาเป็น "เรียบง่าย") หลังจากนั้นเขาก็ถอนการอ้างสิทธิ์ที่เรียบง่ายและกลับไปใช้ความสัมพันธ์ใน " การปรับแต่งการกลั่นกรองข้อมูล " Reynolds ใช้การให้เหตุผลเชิงสัมพันธ์ใน " Craft of Programming", บทที่ 5 (1981). เขาคิดว่าความสัมพันธ์นั้นเป็นธรรมชาติและทั่วไปมากกว่าฟังก์ชั่นที่เป็นนามธรรมถ้าคุณย้อนกลับไปอ่านบทนี้คุณจะพบความคิดเกี่ยวกับตัวแปรเชิงสัมพันธ์ที่แฝงตัวอยู่รอบ ๆ รออีกสองปีต่อมา Reynolds ตีพิมพ์ "ประเภท, นามธรรมและตัวแปรหลากหลาย" (1983)

ดูเหมือนว่าความคิดทั้งหมดนี้ไม่มีส่วนเกี่ยวข้องกับประเภท แต่พวกเขาทำจริงๆ ภาษา Stateful และรูปแบบได้ในตัวนามธรรมข้อมูล คุณไม่จำเป็นต้องกำหนด "ประเภทข้อมูลนามธรรม" เพื่อซ่อนข้อมูล คุณเพิ่งประกาศตัวแปรท้องถิ่นและซ่อนไว้ เราสามารถสอนให้นักเรียนชั้นปีที่ 1 ในชั้นเรียน Java ได้ภายในสองสามสัปดาห์แรก ไม่มีเหงื่อ.

$\forall$$\exists$

$M$$M'$$M$$M'$$X$$X'$$R$$F(X)$ and $F(X')$, parameterized by the types of their states, then check that the two machines are related by the relation $F(R)$.

So, simulations and relational parametricity are essentially the same idea. It is not merely a superficial resemblance. The former is made for stateful languages where there is built-in data abstraction. The latter is made for stateless languages where data abstraction is obtained via type variables.

What about logical relations then? On the surface, logical relations appear to be a more general idea. Whereas parametricity talks about how to relate type variables within the same model, logical relations appear to relate types across different models. (Dave Clarke wrote a brilliant exposition of this earlier.) But my feeling is (and it still needs to be demonstrated) that this is an instance of some form of higher-type parametricity which hasn't yet been formulated. Stay tuned for more progress on that front.

[Note added] The connection between logical relations and simulations is discussed in our recent paper Logical relations and parametricty: A Reynolds programme for Category Theory and Programming Languages.

One of the key differences is that logical relations are used as a technique for showing that a class of programs (eg, input to a compiler) correspond to another class of programs (eg, the output of the compiler), whereas simulation relations are used to show the correspondence between two programs.

The similarity between the two notions is that they both define a relation used to show the correspondence between two different entities. In some sense, one can think of a logical relation as a simulation relation that is defined inductively on the syntax of types. But different kinds of simulation relations exist.

Logical relations can used to show the correspondence between a language such as ML and its translation into assembly language, as in the paper you read. A logical relation is defined inductively on the type structure. A logical relation provides a compositional means for showing, for example, that a translation is correct, by showing that the translation is correct for each type constructor. At function types the correctness condition condition would say something like, the translation of this function takes well-translated input to well-translated output.

Logical relations are a versatile technique for languages based on the lambda calculus. Other applications of logical relations include (from here): characterising lambda definability, relating denotational semantic definitions, characterising parametric polymorphism, modelling abstract interpretation, verifying data representations, defining fully abstract semantics and modelling local state in higher-order languages.

Simulation relations are generally used to show the equivalence of two programs. Typically such programs produce some kind of observation, such as sending messages on channels. One program P simulates another Q if P can do everything that Q can do, though perhaps more.

Bisimulation, roughly, is two simulation relations put together. You show that program P and simulate program Q and that program Q can simulate program P and you have a bisimulation, though additional conditions are generally present. Wikipedia's entry on bisimulation is a good (more precise) starting point. Thousands of variants of the idea exist, but it is a fundamental idea that has been reinvented in more or less the same form computer science, modal logic and model theory. Sangiorgi's article gives a wonderful history of the idea.

One paper establishing a relationship between the two notions is A Note on Logical Relations Between Semantics and Syntax by Andy Pitts which uses logical relations, ultimately a semantic notion defined syntactally, to prove a certain property about applicative bisimulation, which is a purely syntactic notion.

The two types of relations appear to be used in different contexts. Logical simulations for typed languages and simulation relations when dealing with process calculi or modal logics interpreted over transition systems. Dave Clarke has provided much intuitive explanation, so I will just add a few pointers that may help.

There has been work on characterising both notions using abstract interpretation. It may not be what you want, but at least both notions are treated in the same mathematical framework.

Samson Abramsky used logical relations to prove soundness and termination of strictness analysis for the lazy Lambda calculus (Abstract Interpretation, Logical Relations, and Kan Extensions). He also showed that the logical relations define abstraction functions in the Galois connection sense of abstract interpretation. More recently, Backhouse and Backhouse showed how to construct Galois connections for higher-order types from Galois connections for base types and that these constructions can be equivalently described using logical relations (Logical Relations and Galois Connections). Thus, in the specific context of typed functional languages, the two notions are equivalent.

Simulation relations characterise property preservation between Kripke structures for various modal and temporal logics. Instead of types, we have modalities in a logic. Simulation relations also define Galois connections and hence, abstractions. One can ask if these abstractions have special properties. The answer is that standard abstractions are sound and simulation relation-based abstractions are complete. The notion of completeness is with respect to Galois connections, which may not concur with ones intuitive interpretation. This line of work has been developed by David Schmidt (Structure-Preserving Binary Relations for Program Abstraction), and Francesco Ranzato and Francesco Tapparo (Generalized Strong Preservation by Abstract Interpretation).

I'd say that the two concepts are somewhat vague. Both are about binary relations of computational mechanisms which somehow embody a notion of equality. Logical relations are defined by induction of type-structure, while simulations can be defined however you want, but the term alludes to coinduction.

It is misleading to say that logical relations are restrictied to lambda-calculi or sequential languages, although that's where logical relations originated. For example in our work on fully abstract models for System F, we defined logical relations for typed $\pi$-calculi.