首页 > 最新文献

Proceedings of the ACM on Programming Languages最新文献

英文 中文
Guided Equality Saturation 指导平等饱和度
IF 1.8 Q2 COMPUTER SCIENCE, SOFTWARE ENGINEERING Pub Date : 2024-01-05 DOI: 10.1145/3632900
Thomas Kœhler, Andrés Goens, Siddharth Bhat, Tobias Grosser, Phil Trinder, Michel Steuwer
Rewriting is a principled term transformation technique with uses across theorem proving and compilation. In theorem proving, each rewrite is a proof step; in compilation, rewrites optimize a program term. While developing rewrite sequences manually is possible, this process does not scale to larger rewrite sequences. Automated rewriting techniques, like greedy simplification or equality saturation, work well without requiring human input. Yet, they do not scale to large search spaces, limiting the complexity of tasks where automated rewriting is effective, and meaning that just a small increase in term size or rewrite length may result in failure. This paper proposes a semi-automatic rewriting technique as a means to scale rewriting by allowing human insight at key decision points. Specifically, we propose guided equality saturation that embraces human guidance when fully automated equality saturation does not scale. The rewriting is split into two simpler automatic equality saturation steps: from the original term to a human-provided intermediate guide, and from the guide to the target. Complex rewriting tasks may require multiple guides, resulting in a sequence of equality saturation steps. A guide can be a complete term, or a sketch containing undefined elements that are instantiated by the equality saturation search. Such sketches may be far more concise than complete terms. We demonstrate the generality and effectiveness of guided equality saturation using two case studies. First, we integrate guided equality saturation in the Lean 4 proof assistant. Proofs are written in the style of textbook proof sketches, as a series of calculations omitting details and skipping steps. These proofs conclude in less than a second instead of minutes when compared to unguided equality saturation, and can find complex proofs that previously had to be done manually. Second, in the compiler of the Rise array language, where unguided equality saturation fails to perform optimizations within an hour and using 60 GB of memory, guided equality saturation performs the same optimizations with at most 3 guides, within seconds using less than 1 GB memory.
重写是一种原则性的术语转换技术,可用于定理证明和编译。在定理证明中,每次重写都是一个证明步骤;在编译中,重写可以优化程序术语。虽然可以手动开发重写序列,但这一过程无法扩展到更大的重写序列。自动重写技术,如贪婪简化或相等饱和,无需人工输入即可运行良好。然而,它们不能扩展到大型搜索空间,从而限制了自动重写有效的任务的复杂性,这意味着术语大小或重写长度的微小增加都可能导致失败。本文提出了一种半自动重写技术,通过在关键决策点允许人工洞察来扩展重写。具体来说,我们提出了引导式等价饱和,在全自动等价饱和无法扩展的情况下接受人工引导。重写分为两个较简单的自动等价饱和步骤:从原始术语到人工提供的中间指导,以及从指导到目标。复杂的重写任务可能需要多个向导,从而产生一连串的等价饱和步骤。向导可以是一个完整的术语,也可以是一个包含未定义元素的草图,这些元素会被等价饱和搜索实例化。这种草图可能比完整的术语简洁得多。我们通过两个案例研究证明了引导相等饱和的通用性和有效性。首先,我们在 Lean 4 证明助手中集成了引导相等饱和。证明是按照教科书证明草图的风格编写的,是一系列省略细节和跳过步骤的计算。与无引导的等式饱和相比,这些证明只需不到一秒而不是几分钟就能完成,而且还能找到以前必须手动完成的复杂证明。其次,在崛起数组语言的编译器中,非引导的等价饱和在一小时内无法执行优化,使用的内存为 60 GB,而引导的等价饱和在几秒钟内执行了相同的优化,最多只有 3 个引导,使用的内存不到 1 GB。
{"title":"Guided Equality Saturation","authors":"Thomas Kœhler, Andrés Goens, Siddharth Bhat, Tobias Grosser, Phil Trinder, Michel Steuwer","doi":"10.1145/3632900","DOIUrl":"https://doi.org/10.1145/3632900","url":null,"abstract":"Rewriting is a principled term transformation technique with uses across theorem proving and compilation. In theorem proving, each rewrite is a proof step; in compilation, rewrites optimize a program term. While developing rewrite sequences manually is possible, this process does not scale to larger rewrite sequences. Automated rewriting techniques, like greedy simplification or equality saturation, work well without requiring human input. Yet, they do not scale to large search spaces, limiting the complexity of tasks where automated rewriting is effective, and meaning that just a small increase in term size or rewrite length may result in failure. This paper proposes a semi-automatic rewriting technique as a means to scale rewriting by allowing human insight at key decision points. Specifically, we propose guided equality saturation that embraces human guidance when fully automated equality saturation does not scale. The rewriting is split into two simpler automatic equality saturation steps: from the original term to a human-provided intermediate guide, and from the guide to the target. Complex rewriting tasks may require multiple guides, resulting in a sequence of equality saturation steps. A guide can be a complete term, or a sketch containing undefined elements that are instantiated by the equality saturation search. Such sketches may be far more concise than complete terms. We demonstrate the generality and effectiveness of guided equality saturation using two case studies. First, we integrate guided equality saturation in the Lean 4 proof assistant. Proofs are written in the style of textbook proof sketches, as a series of calculations omitting details and skipping steps. These proofs conclude in less than a second instead of minutes when compared to unguided equality saturation, and can find complex proofs that previously had to be done manually. Second, in the compiler of the Rise array language, where unguided equality saturation fails to perform optimizations within an hour and using 60 GB of memory, guided equality saturation performs the same optimizations with at most 3 guides, within seconds using less than 1 GB memory.","PeriodicalId":20697,"journal":{"name":"Proceedings of the ACM on Programming Languages","volume":"43 10","pages":"1727 - 1758"},"PeriodicalIF":1.8,"publicationDate":"2024-01-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"139381775","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
引用次数: 0
Unboxed Data Constructors: Or, How cpp Decides a Halting Problem 无盒式数据构造函数:或者说,cpp 如何解决停顿问题
IF 1.8 Q2 COMPUTER SCIENCE, SOFTWARE ENGINEERING Pub Date : 2024-01-05 DOI: 10.1145/3632893
Nicolas Chataing, Stephen Dolan, Gabriel Scherer, J. Yallop
We propose a new language feature for ML-family languages, the ability to selectively unbox certain data constructors, so that their runtime representation gets compiled away to just the identity on their argument. Unboxing must be statically rejected when it could introduce confusion, that is, distinct values with the same representation. We discuss the use-case of big numbers, where unboxing allows to write code that is both efficient and safe, replacing either a safe but slow version or a fast but unsafe version. We explain the static analysis necessary to reject incorrect unboxing requests. We present our prototype implementation of this feature for the OCaml programming language, discuss several design choices and the interaction with advanced features such as Guarded Algebraic Datatypes. Our static analysis requires expanding type definitions in type expressions, which is not necessarily normalizing in presence of recursive type definitions. In other words, we must decide normalization of terms in the first-order λ-calculus with recursion. We provide an algorithm to detect non-termination on-the-fly during reduction, with proofs of correctness and completeness. Our algorithm turns out to be closely related to the normalization strategy for macro expansion in the cpp preprocessor.
我们为 ML-family 语言提出了一种新的语言特性,即有选择地取消某些数据构造函数的装箱功能,这样它们的运行时表示法就会被编译为其参数上的标识。如果开箱可能带来混淆,即具有相同表示的不同值,则必须静态地拒绝开箱。我们讨论了大数的用例,在这种情况下,开箱可以编写既高效又安全的代码,取代安全但缓慢的版本或快速但不安全的版本。我们解释了拒绝不正确的开箱请求所需的静态分析。我们介绍了 OCaml 编程语言中该功能的原型实现,讨论了几种设计选择以及与守护代数数据类型等高级功能的交互。我们的静态分析要求在类型表达式中扩展类型定义,而在存在递归类型定义的情况下,这并不一定是规范化的。换句话说,我们必须决定带有递归的一阶 λ 微积分中术语的归一化。我们提供了一种在还原过程中即时检测非终结的算法,并给出了正确性和完备性证明。我们的算法与 cpp 预处理器中宏扩展的规范化策略密切相关。
{"title":"Unboxed Data Constructors: Or, How cpp Decides a Halting Problem","authors":"Nicolas Chataing, Stephen Dolan, Gabriel Scherer, J. Yallop","doi":"10.1145/3632893","DOIUrl":"https://doi.org/10.1145/3632893","url":null,"abstract":"We propose a new language feature for ML-family languages, the ability to selectively unbox certain data constructors, so that their runtime representation gets compiled away to just the identity on their argument. Unboxing must be statically rejected when it could introduce confusion, that is, distinct values with the same representation. We discuss the use-case of big numbers, where unboxing allows to write code that is both efficient and safe, replacing either a safe but slow version or a fast but unsafe version. We explain the static analysis necessary to reject incorrect unboxing requests. We present our prototype implementation of this feature for the OCaml programming language, discuss several design choices and the interaction with advanced features such as Guarded Algebraic Datatypes. Our static analysis requires expanding type definitions in type expressions, which is not necessarily normalizing in presence of recursive type definitions. In other words, we must decide normalization of terms in the first-order λ-calculus with recursion. We provide an algorithm to detect non-termination on-the-fly during reduction, with proofs of correctness and completeness. Our algorithm turns out to be closely related to the normalization strategy for macro expansion in the cpp preprocessor.","PeriodicalId":20697,"journal":{"name":"Proceedings of the ACM on Programming Languages","volume":"9 5","pages":"1509 - 1539"},"PeriodicalIF":1.8,"publicationDate":"2024-01-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"139381997","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
引用次数: 0
Internal and Observational Parametricity for Cubical Agda 立方阿格达的内部参数性和观测参数性
IF 1.8 Q2 COMPUTER SCIENCE, SOFTWARE ENGINEERING Pub Date : 2024-01-05 DOI: 10.1145/3632850
Antoine Van Muylder, Andreas Nuyts, Dominique Devriese
Two approaches exist to incorporate parametricity into proof assistants based on dependent type theory. On the one hand, parametricity translations conveniently compute parametricity statements and their proofs solely based on individual well-typed polymorphic programs. But they do not offer internal parametricity: formal proofs that any polymorphic program of a certain type satisfies its parametricity statement. On the other hand, internally parametric type theories augment plain type theory with additional primitives out of which internal parametricity can be derived. But those type theories lack mature proof assistant implementations and deriving parametricity in them involves low-level intractable proofs. In this paper, we contribute Agda --bridges: the first practical internally parametric proof assistant. We provide the first mechanized proofs of crucial theorems for internal parametricity, like the relativity theorem. We identify a high-level sufficient condition for proving internal parametricity which we call the structure relatedness principle (SRP) by analogy with the structure identity principle (SIP) of HoTT/UF. We state and prove a general parametricity theorem for types that satisfy the SRP. Our parametricity theorem lets us obtain one-liner proofs of standard internal free theorems. We observe that the SRP is harder to prove than the SIP and provide in Agda --bridges a shallowly embedded type theory to compose types that satisfy the SRP. This type theory is an observational type theory of logical relations and our parametricity theorem ought to be one of its inference rules.
将参数性纳入基于依赖类型理论的证明助手有两种方法。一方面,参数性转换仅基于单个类型良好的多态程序,方便地计算参数性声明及其证明。但它们并不提供内部参数性:任何特定类型的多态程序都满足其参数性声明的形式证明。另一方面,内部参数化类型理论用额外的基元增强了普通类型理论,内部参数化可以从这些基元中推导出来。但是,这些类型理论缺乏成熟的证明助手实现,在它们中推导参数性涉及低层次的棘手证明。在本文中,我们贡献了 Agda 桥:第一个实用的内部参数化证明助手。我们首次为内部参数性的关键定理(如相对论)提供了机械化证明。我们通过类比 HoTT/UF 的结构同一性原理 (SIP),确定了证明内部参数性的高级充分条件,我们称之为结构相关性原理 (SRP)。我们阐述并证明了满足 SRP 的类型的一般参数性定理。通过我们的参数性定理,我们可以获得标准内部自由定理的单行证明。我们发现,SRP 比 SIP 更难证明,因此我们在 Agda 桥中提供了一种浅嵌入类型理论,用于组成满足 SRP 的类型。这种类型理论是逻辑关系的观察类型理论,我们的参数性定理应该是它的推理规则之一。
{"title":"Internal and Observational Parametricity for Cubical Agda","authors":"Antoine Van Muylder, Andreas Nuyts, Dominique Devriese","doi":"10.1145/3632850","DOIUrl":"https://doi.org/10.1145/3632850","url":null,"abstract":"Two approaches exist to incorporate parametricity into proof assistants based on dependent type theory. On the one hand, parametricity translations conveniently compute parametricity statements and their proofs solely based on individual well-typed polymorphic programs. But they do not offer internal parametricity: formal proofs that any polymorphic program of a certain type satisfies its parametricity statement. On the other hand, internally parametric type theories augment plain type theory with additional primitives out of which internal parametricity can be derived. But those type theories lack mature proof assistant implementations and deriving parametricity in them involves low-level intractable proofs. In this paper, we contribute Agda --bridges: the first practical internally parametric proof assistant. We provide the first mechanized proofs of crucial theorems for internal parametricity, like the relativity theorem. We identify a high-level sufficient condition for proving internal parametricity which we call the structure relatedness principle (SRP) by analogy with the structure identity principle (SIP) of HoTT/UF. We state and prove a general parametricity theorem for types that satisfy the SRP. Our parametricity theorem lets us obtain one-liner proofs of standard internal free theorems. We observe that the SRP is harder to prove than the SIP and provide in Agda --bridges a shallowly embedded type theory to compose types that satisfy the SRP. This type theory is an observational type theory of logical relations and our parametricity theorem ought to be one of its inference rules.","PeriodicalId":20697,"journal":{"name":"Proceedings of the ACM on Programming Languages","volume":"37 33","pages":"209 - 240"},"PeriodicalIF":1.8,"publicationDate":"2024-01-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"139382368","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
引用次数: 1
Internalizing Indistinguishability with Dependent Types 用依存类型内化可区分性
IF 1.8 Q2 COMPUTER SCIENCE, SOFTWARE ENGINEERING Pub Date : 2024-01-05 DOI: 10.1145/3632886
Yiyun Liu, Jonathan Chan, Jessica Shi, Stephanie Weirich
In type systems with dependency tracking, programmers can assign an ordered set of levels to computations and prevent information flow from high-level computations to the low-level ones. The key notion in such systems is indistinguishability: a definition of program equivalence that takes into account the parts of the program that an observer may depend on. In this paper, we investigate the use of dependency tracking in the context of dependently-typed languages. We present the Dependent Calculus of Indistinguishability (DCOI), a system that adopts indistinguishability as the definition of equality used by the type checker. DCOI also internalizes that relation as an observer-indexed propositional equality type, so that programmers may reason about indistinguishability within the language. Our design generalizes and extends prior systems that combine dependency tracking with dependent types and is the first to support conversion and propositional equality at arbitrary observer levels. We have proven type soundness and noninterference theorems for DCOI and have developed a prototype implementation of its type checker.
在具有依赖跟踪功能的类型系统中,程序员可以为计算分配一组有序的级别,并防止信息从高级计算流向低级计算。这类系统的关键概念是不可区分性:程序等价性的定义考虑了观察者可能依赖的程序部分。在本文中,我们将研究依赖跟踪在依赖类型语言中的应用。我们提出了不可区分性依赖性计算(DCOI),这是一个采用不可区分性作为类型检查程序所使用的相等定义的系统。DCOI 还将这种关系内化为观察者索引命题等价类型,这样程序员就可以在语言中对不可区分性进行推理。我们的设计概括并扩展了之前将依赖关系跟踪与依赖类型相结合的系统,并且是第一个支持任意观察者级别的转换和命题相等的系统。我们已经证明了 DCOI 的类型健全性和无干扰定理,并开发了其类型检查器的原型实现。
{"title":"Internalizing Indistinguishability with Dependent Types","authors":"Yiyun Liu, Jonathan Chan, Jessica Shi, Stephanie Weirich","doi":"10.1145/3632886","DOIUrl":"https://doi.org/10.1145/3632886","url":null,"abstract":"In type systems with dependency tracking, programmers can assign an ordered set of levels to computations and prevent information flow from high-level computations to the low-level ones. The key notion in such systems is indistinguishability: a definition of program equivalence that takes into account the parts of the program that an observer may depend on. In this paper, we investigate the use of dependency tracking in the context of dependently-typed languages. We present the Dependent Calculus of Indistinguishability (DCOI), a system that adopts indistinguishability as the definition of equality used by the type checker. DCOI also internalizes that relation as an observer-indexed propositional equality type, so that programmers may reason about indistinguishability within the language. Our design generalizes and extends prior systems that combine dependency tracking with dependent types and is the first to support conversion and propositional equality at arbitrary observer levels. We have proven type soundness and noninterference theorems for DCOI and have developed a prototype implementation of its type checker.","PeriodicalId":20697,"journal":{"name":"Proceedings of the ACM on Programming Languages","volume":"45 47","pages":"1298 - 1325"},"PeriodicalIF":1.8,"publicationDate":"2024-01-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"139382505","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
引用次数: 0
Total Type Error Localization and Recovery with Holes 总类型误差定位和孔洞恢复
IF 1.8 Q2 COMPUTER SCIENCE, SOFTWARE ENGINEERING Pub Date : 2024-01-05 DOI: 10.1145/3632910
Eric Zhao, Raef Maroof, Anand Dukkipati, Andrew Blinn, Zhiyi Pan, Cyrus Omar
Type systems typically only define the conditions under which an expression is well-typed, leaving ill-typed expressions formally meaningless. This approach is insufficient as the basis for language servers driving modern programming environments, which are expected to recover from simultaneously localized errors and continue to provide a variety of downstream semantic services. This paper addresses this problem, contributing the first comprehensive formal account of total type error localization and recovery: the marked lambda calculus. In particular, we define a gradual type system for expressions with marked errors, which operate as non-empty holes, together with a total procedure for marking arbitrary unmarked expressions. We mechanize the metatheory of the marked lambda calculus in Agda and implement it, scaled up, as the new basis for Hazel, a full-scale live functional programming environment with, uniquely, no meaningless editor states. The marked lambda calculus is bidirectionally typed, so localization decisions are systematically predictable based on a local flow of typing information. Constraint-based type inference can bring more distant information to bear in discovering inconsistencies but this notoriously complicates error localization. We approach this problem by deploying constraint solving as a type-hole-filling layer atop this gradual bidirectionally typed core. Errors arising from inconsistent unification constraints are localized exclusively to type and expression holes, i.e. the system identifies unfillable holes using a system of traced provenances, rather than localized in an ad hoc manner to particular expressions. The user can then interactively shift these errors to particular downstream expressions by selecting from suggested partially consistent type hole fillings, which returns control back to the bidirectional system. We implement this type hole inference system in Hazel.
类型系统通常只定义表达式类型良好的条件,使类型不良的表达式在形式上毫无意义。这种方法不足以作为驱动现代编程环境的语言服务器的基础,因为现代编程环境需要同时从定位错误中恢复,并继续提供各种下游语义服务。本文针对这一问题,首次对总体类型错误定位和恢复进行了全面的形式化阐述:标记 lambda 微积分。特别是,我们为有标记错误的表达式定义了一个渐进类型系统,它作为非空洞运行,同时还定义了一个标记任意无标记表达式的总过程。我们在 Agda 中对标记 lambda 微积分的元理论进行了机械化,并将其放大作为 Hazel 的新基础加以实现,Hazel 是一个全面的实时函数式编程环境,没有无意义的编辑器状态。标记的 lambda 微积分是双向类型的,因此本地化决策可以根据本地类型信息流进行系统预测。基于约束的类型推断可以利用更远的信息来发现不一致之处,但众所周知,这会使错误定位变得复杂。我们通过在渐进双向类型化核心之上部署约束求解作为类型漏洞填充层来解决这个问题。由不一致的统一约束引起的错误只定位在类型和表达式漏洞上,也就是说,系统使用一个追踪出处系统来识别无法填补的漏洞,而不是临时定位在特定的表达式上。然后,用户可以通过交互方式,从建议的部分一致的类型漏洞填充中进行选择,将这些错误转移到特定的下游表达式中,从而将控制权交还给双向系统。我们在 Hazel 中实现了这种类型洞推理系统。
{"title":"Total Type Error Localization and Recovery with Holes","authors":"Eric Zhao, Raef Maroof, Anand Dukkipati, Andrew Blinn, Zhiyi Pan, Cyrus Omar","doi":"10.1145/3632910","DOIUrl":"https://doi.org/10.1145/3632910","url":null,"abstract":"Type systems typically only define the conditions under which an expression is well-typed, leaving ill-typed expressions formally meaningless. This approach is insufficient as the basis for language servers driving modern programming environments, which are expected to recover from simultaneously localized errors and continue to provide a variety of downstream semantic services. This paper addresses this problem, contributing the first comprehensive formal account of total type error localization and recovery: the marked lambda calculus. In particular, we define a gradual type system for expressions with marked errors, which operate as non-empty holes, together with a total procedure for marking arbitrary unmarked expressions. We mechanize the metatheory of the marked lambda calculus in Agda and implement it, scaled up, as the new basis for Hazel, a full-scale live functional programming environment with, uniquely, no meaningless editor states. The marked lambda calculus is bidirectionally typed, so localization decisions are systematically predictable based on a local flow of typing information. Constraint-based type inference can bring more distant information to bear in discovering inconsistencies but this notoriously complicates error localization. We approach this problem by deploying constraint solving as a type-hole-filling layer atop this gradual bidirectionally typed core. Errors arising from inconsistent unification constraints are localized exclusively to type and expression holes, i.e. the system identifies unfillable holes using a system of traced provenances, rather than localized in an ad hoc manner to particular expressions. The user can then interactively shift these errors to particular downstream expressions by selecting from suggested partially consistent type hole fillings, which returns control back to the bidirectional system. We implement this type hole inference system in Hazel.","PeriodicalId":20697,"journal":{"name":"Proceedings of the ACM on Programming Languages","volume":"2 4","pages":"2041 - 2068"},"PeriodicalIF":1.8,"publicationDate":"2024-01-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"139384255","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
引用次数: 0
An Axiomatic Basis for Computer Programming on the Relaxed Arm-A Architecture: The AxSL Logic 宽松 Arm-A 架构上计算机编程的公理基础AxSL 逻辑
IF 1.8 Q2 COMPUTER SCIENCE, SOFTWARE ENGINEERING Pub Date : 2024-01-05 DOI: 10.1145/3632863
Angus Hammond, Zong-Chao Liu, Thibaut Pérami, Peter Sewell, Lars Birkedal, Jean Pichon-Pharabod
Very relaxed concurrency memory models, like those of the Arm-A, RISC-V, and IBM Power hardware architectures, underpin much of computing but break a fundamental intuition about programs, namely that syntactic program order and the reads-from relation always both induce order in the execution. Instead, out-of-order execution is allowed except where prevented by certain pairwise dependencies, barriers, or other synchronisation. This means that there is no notion of the 'current' state of the program, making it challenging to design (and prove sound) syntax-directed, modular reasoning methods like Hoare logics, as usable resources cannot implicitly flow from one program point to the next. We present AxSL, a separation logic for the relaxed memory model of Arm-A, that captures the fine-grained reasoning underpinning the low-overhead synchronisation mechanisms used by high-performance systems code. In particular, AxSL allows transferring arbitrary resources using relaxed reads and writes when they induce inter-thread ordering. We mechanise AxSL in the Iris separation logic framework, illustrate it on key examples, and prove it sound with respect to the axiomatic memory model of Arm-A. Our approach is largely generic in the axiomatic model and in the instruction-set semantics, offering a potential way forward for compositional reasoning for other similar models, and for the combination of production concurrency models and full-scale ISAs.
非常宽松的并发内存模型,如 Arm-A、RISC-V 和 IBM Power 硬件架构的并发内存模型,是大部分计算的基础,但却打破了程序的一个基本直觉,即语法程序顺序和从读取关系总是同时引起执行顺序。相反,除了某些成对依赖关系、障碍或其他同步所阻止的情况外,允许无序执行。这意味着没有程序 "当前 "状态的概念,这使得设计(并证明合理的)语法导向的模块化推理方法(如 Hoare 逻辑)具有挑战性,因为可用资源不能隐式地从一个程序点流向下一个程序点。我们提出的 AxSL 是一种适用于 Arm-A 宽松内存模型的分离逻辑,它捕捉到了高性能系统代码所使用的低开销同步机制的细粒度推理基础。特别是,当线程间排序引起读写时,AxSL 允许使用宽松读写来传输任意资源。我们在 Iris 分离逻辑框架中将 AxSL 机械化,在关键示例中加以说明,并证明它在 Arm-A 的公理内存模型方面是合理的。我们的方法在公理模型和指令集语义方面具有很大程度的通用性,为其他类似模型的组合推理以及生产并发模型和全面 ISA 的结合提供了潜在的发展方向。
{"title":"An Axiomatic Basis for Computer Programming on the Relaxed Arm-A Architecture: The AxSL Logic","authors":"Angus Hammond, Zong-Chao Liu, Thibaut Pérami, Peter Sewell, Lars Birkedal, Jean Pichon-Pharabod","doi":"10.1145/3632863","DOIUrl":"https://doi.org/10.1145/3632863","url":null,"abstract":"Very relaxed concurrency memory models, like those of the Arm-A, RISC-V, and IBM Power hardware architectures, underpin much of computing but break a fundamental intuition about programs, namely that syntactic program order and the reads-from relation always both induce order in the execution. Instead, out-of-order execution is allowed except where prevented by certain pairwise dependencies, barriers, or other synchronisation. This means that there is no notion of the 'current' state of the program, making it challenging to design (and prove sound) syntax-directed, modular reasoning methods like Hoare logics, as usable resources cannot implicitly flow from one program point to the next. We present AxSL, a separation logic for the relaxed memory model of Arm-A, that captures the fine-grained reasoning underpinning the low-overhead synchronisation mechanisms used by high-performance systems code. In particular, AxSL allows transferring arbitrary resources using relaxed reads and writes when they induce inter-thread ordering. We mechanise AxSL in the Iris separation logic framework, illustrate it on key examples, and prove it sound with respect to the axiomatic memory model of Arm-A. Our approach is largely generic in the axiomatic model and in the instruction-set semantics, offering a potential way forward for compositional reasoning for other similar models, and for the combination of production concurrency models and full-scale ISAs.","PeriodicalId":20697,"journal":{"name":"Proceedings of the ACM on Programming Languages","volume":"5 41","pages":"604 - 637"},"PeriodicalIF":1.8,"publicationDate":"2024-01-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"139380998","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
引用次数: 0
Shoggoth: A Formal Foundation for Strategic Rewriting Shoggoth:战略改写的形式基础
IF 1.8 Q2 COMPUTER SCIENCE, SOFTWARE ENGINEERING Pub Date : 2024-01-05 DOI: 10.1145/3633211
Xueying Qin, Liam O’CONNOR, Rob van Glabbeek, Peter Höfner, Ohad Kammar, Michel Steuwer
Rewriting is a versatile and powerful technique used in many domains. Strategic rewriting allows programmers to control the application of rewrite rules by composing individual rewrite rules into complex rewrite strategies. These strategies are semantically complex, as they may be nondeterministic, they may raise errors that trigger backtracking, and they may not terminate. Given such semantic complexity, it is necessary to establish a formal understanding of rewrite strategies and to enable reasoning about them in order to answer questions like: How do we know that a rewrite strategy terminates? How do we know that a rewrite strategy does not fail because we compose two incompatible rewrites? How do we know that a desired property holds after applying a rewrite strategy? In this paper, we introduce Shoggoth: a formal foundation for understanding, analysing and reasoning about strategic rewriting that is capable of answering these questions. We provide a denotational semantics of System S, a core language for strategic rewriting, and prove its equivalence to our big-step operational semantics, which extends existing work by explicitly accounting for divergence. We further define a location-based weakest precondition calculus to enable formal reasoning about rewriting strategies, and we prove this calculus sound with respect to the denotational semantics. We show how this calculus can be used in practice to reason about properties of rewriting strategies, including termination, that they are well-composed, and that desired postconditions hold. The semantics and calculus are formalised in Isabelle/HOL and all proofs are mechanised.
重写是一种多用途的强大技术,可用于许多领域。策略重写允许程序员将单个重写规则组合成复杂的重写策略,从而控制重写规则的应用。这些策略在语义上非常复杂,因为它们可能是非确定性的,可能会引发错误从而触发回溯,也可能不会终止。鉴于这种语义上的复杂性,我们有必要建立对重写策略的正式理解,并对它们进行推理,以回答以下问题:我们如何知道一个重写策略是正确的?我们如何知道重写策略会终止?我们如何知道一个重写策略不会因为我们组成了两个不兼容的重写而失败?我们如何知道应用重写策略后所需属性成立?在本文中,我们将介绍 Shoggoth:一个用于理解、分析和推理策略重写的形式基础,它能够回答这些问题。我们提供了策略重写的核心语言 System S 的指称语义,并证明了它与我们的大步操作语义的等价性,通过明确考虑分歧,我们扩展了现有的工作。我们进一步定义了一种基于位置的最弱前提条件微积分,以实现对重写策略的形式推理,并证明了这种微积分与指称语义的合理性。我们展示了如何在实践中使用这种微积分来推理重写策略的属性,包括终止、组合良好以及所需的后置条件成立。语义和微积分都用 Isabelle/HOL 形式化,所有证明都是机械化的。
{"title":"Shoggoth: A Formal Foundation for Strategic Rewriting","authors":"Xueying Qin, Liam O’CONNOR, Rob van Glabbeek, Peter Höfner, Ohad Kammar, Michel Steuwer","doi":"10.1145/3633211","DOIUrl":"https://doi.org/10.1145/3633211","url":null,"abstract":"Rewriting is a versatile and powerful technique used in many domains. Strategic rewriting allows programmers to control the application of rewrite rules by composing individual rewrite rules into complex rewrite strategies. These strategies are semantically complex, as they may be nondeterministic, they may raise errors that trigger backtracking, and they may not terminate. Given such semantic complexity, it is necessary to establish a formal understanding of rewrite strategies and to enable reasoning about them in order to answer questions like: How do we know that a rewrite strategy terminates? How do we know that a rewrite strategy does not fail because we compose two incompatible rewrites? How do we know that a desired property holds after applying a rewrite strategy? In this paper, we introduce Shoggoth: a formal foundation for understanding, analysing and reasoning about strategic rewriting that is capable of answering these questions. We provide a denotational semantics of System S, a core language for strategic rewriting, and prove its equivalence to our big-step operational semantics, which extends existing work by explicitly accounting for divergence. We further define a location-based weakest precondition calculus to enable formal reasoning about rewriting strategies, and we prove this calculus sound with respect to the denotational semantics. We show how this calculus can be used in practice to reason about properties of rewriting strategies, including termination, that they are well-composed, and that desired postconditions hold. The semantics and calculus are formalised in Isabelle/HOL and all proofs are mechanised.","PeriodicalId":20697,"journal":{"name":"Proceedings of the ACM on Programming Languages","volume":"50 43","pages":"61 - 89"},"PeriodicalIF":1.8,"publicationDate":"2024-01-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"139382205","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
引用次数: 0
Thunks and Debits in Separation Logic with Time Credits 有时间贷项的分离逻辑中的通项和借项
IF 1.8 Q2 COMPUTER SCIENCE, SOFTWARE ENGINEERING Pub Date : 2024-01-05 DOI: 10.1145/3632892
F. Pottier, Armaël Guéneau, Jacques-Henri Jourdan, Glen Mével
A thunk is a mutable data structure that offers a simple memoization service: it stores either a suspended computation or the result of this computation. Okasaki [1999] presents many data structures that exploit thunks to achieve good amortized time complexity. He analyzes their complexity by associating a debit with every thunk. A debit can be paid off in several increments; a thunk whose debit has been fully paid off can be forced. Quite strikingly, a debit is associated also with future thunks, which do not yet exist in memory. Some of the debit of a faraway future thunk can be transferred to a nearer future thunk. We present a complete machine-checked reconstruction of Okasaki's reasoning rules in Iris$, a rich separation logic with time credits. We demonstrate the applicability of the rules by verifying a few operations on streams as well as several of Okasaki's data structures, namely the physicist's queue, implicit queues, and the banker's queue.
thunk 是一种可变数据结构,提供简单的记忆化服务:它存储暂停的计算或计算结果。Okasaki [1999] 提出了许多利用 thunk 实现良好摊销时间复杂性的数据结构。他通过将借记与每个主干相关联来分析它们的复杂性。借记可以分几次还清;借记已还清的主干可以被强制还清。令人吃惊的是,借记还与未来的 Thunks 相关联,而这些 Thunks 还不存在于内存中。一个遥远的未来句子的部分借记可以转移到一个较近的未来句子中。我们在 Iris$ 中提出了经过机器校验的冈崎推理规则的完整重构,Iris$ 是一种具有时间积分的丰富分离逻辑。我们通过验证流上的一些操作以及冈崎的几种数据结构,即物理学家队列、隐式队列和银行家队列,证明了这些规则的适用性。
{"title":"Thunks and Debits in Separation Logic with Time Credits","authors":"F. Pottier, Armaël Guéneau, Jacques-Henri Jourdan, Glen Mével","doi":"10.1145/3632892","DOIUrl":"https://doi.org/10.1145/3632892","url":null,"abstract":"A thunk is a mutable data structure that offers a simple memoization service: it stores either a suspended computation or the result of this computation. Okasaki [1999] presents many data structures that exploit thunks to achieve good amortized time complexity. He analyzes their complexity by associating a debit with every thunk. A debit can be paid off in several increments; a thunk whose debit has been fully paid off can be forced. Quite strikingly, a debit is associated also with future thunks, which do not yet exist in memory. Some of the debit of a faraway future thunk can be transferred to a nearer future thunk. We present a complete machine-checked reconstruction of Okasaki's reasoning rules in Iris$, a rich separation logic with time credits. We demonstrate the applicability of the rules by verifying a few operations on streams as well as several of Okasaki's data structures, namely the physicist's queue, implicit queues, and the banker's queue.","PeriodicalId":20697,"journal":{"name":"Proceedings of the ACM on Programming Languages","volume":"31 3","pages":"1482 - 1508"},"PeriodicalIF":1.8,"publicationDate":"2024-01-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"139382935","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
引用次数: 0
Enhanced Enumeration Techniques for Syntax-Guided Synthesis of Bit-Vector Manipulations 增强型枚举技术,用于语法引导的位向量处理合成
IF 1.8 Q2 COMPUTER SCIENCE, SOFTWARE ENGINEERING Pub Date : 2024-01-05 DOI: 10.1145/3632913
Yuantian Ding, Xiaokang Qiu
Syntax-guided synthesis has been a prevalent theme in various computer-aided programming systems. However, the domain of bit-vector synthesis poses several unique challenges that have not yet been sufficiently addressed and resolved. In this paper, we propose a novel synthesis approach that incorporates a distinct enumeration strategy based on various factors. Technically, this approach weighs in subexpression recurrence by term-graph-based enumeration, avoids useless candidates by example-guided filtration, prioritizes valuable components identified by large language models. This approach also incorporates a bottom-up deduction step to enhance the enumeration algorithm by considering subproblems that contribute to the deductive resolution. We implement all the enhanced enumeration techniques in our SyGuS solver DryadSynth, which outperforms state-of-the-art solvers in terms of the number of solved problems, execution time, and solution size. Notably, DryadSynth successfully solved 31 synthesis problems for the first time, including 5 renowned Hacker's Delight problems.
在各种计算机辅助编程系统中,语法指导合成一直是一个普遍的主题。然而,位矢量合成领域面临着一些独特的挑战,这些挑战尚未得到充分应对和解决。在本文中,我们提出了一种新颖的合成方法,其中包含一种基于各种因素的独特枚举策略。从技术上讲,这种方法通过基于术语图的枚举来权衡子表达式的重复性,通过示例引导的过滤来避免无用的候选表达式,优先考虑由大型语言模型识别出的有价值的组件。这种方法还包含一个自下而上的演绎步骤,通过考虑有助于演绎解决的子问题来增强枚举算法。我们在 SyGuS 求解器 DryadSynth 中实现了所有增强型枚举技术,该求解器在求解问题数量、执行时间和解决方案大小方面都优于最先进的求解器。值得注意的是,DryadSynth 首次成功解决了 31 个综合问题,其中包括 5 个著名的黑客之乐问题。
{"title":"Enhanced Enumeration Techniques for Syntax-Guided Synthesis of Bit-Vector Manipulations","authors":"Yuantian Ding, Xiaokang Qiu","doi":"10.1145/3632913","DOIUrl":"https://doi.org/10.1145/3632913","url":null,"abstract":"Syntax-guided synthesis has been a prevalent theme in various computer-aided programming systems. However, the domain of bit-vector synthesis poses several unique challenges that have not yet been sufficiently addressed and resolved. In this paper, we propose a novel synthesis approach that incorporates a distinct enumeration strategy based on various factors. Technically, this approach weighs in subexpression recurrence by term-graph-based enumeration, avoids useless candidates by example-guided filtration, prioritizes valuable components identified by large language models. This approach also incorporates a bottom-up deduction step to enhance the enumeration algorithm by considering subproblems that contribute to the deductive resolution. We implement all the enhanced enumeration techniques in our SyGuS solver DryadSynth, which outperforms state-of-the-art solvers in terms of the number of solved problems, execution time, and solution size. Notably, DryadSynth successfully solved 31 synthesis problems for the first time, including 5 renowned Hacker's Delight problems.","PeriodicalId":20697,"journal":{"name":"Proceedings of the ACM on Programming Languages","volume":"46 13","pages":"2129 - 2159"},"PeriodicalIF":1.8,"publicationDate":"2024-01-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"139382479","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
引用次数: 1
When Subtyping Constraints Liberate: A Novel Type Inference Approach for First-Class Polymorphism 当子类型约束解放时:第一类多态性的新型类型推断方法
IF 1.8 Q2 COMPUTER SCIENCE, SOFTWARE ENGINEERING Pub Date : 2024-01-05 DOI: 10.1145/3632890
L. Parreaux, Aleksander Boruch-Gruszecki, Andong Fan, Chun Yin Chau
Type inference in the presence of first-class or “impredicative” second-order polymorphism à la System F has been an active research area for several decades, with original works dating back to the end of the 80s. Yet, until now many basic problems remain open, such as how to type check expressions like (𝜆𝑥. (𝑥 123, 𝑥 True)) id reliably. We show that a type inference approach based on multi-bounded polymorphism, a form of implicit polymorphic subtyping with multiple lower and upper bounds, can help us resolve most of these problems in a uniquely simple and regular way. We define F{≤}, a declarative type system derived from the existing theory of implicit coercions by Cretin and Rémy (LICS 2014), and we introduce SuperF, a novel algorithm to infer polymorphic multi-bounded F{≤} types while checking user type annotations written in the syntax of System F. We use a recursion-avoiding heuristic to guarantee termination of type inference at the cost of rejecting some valid programs, which thankfully rarely triggers in practice. We show that SuperF is vastly more powerful than all first-class-polymorphic type inference systems proposed so far, significantly advancing the state of the art in type inference for general-purpose programming languages.
几十年来,类型推断一直是一个活跃的研究领域,其原创性工作可以追溯到上世纪 80 年代末。然而,直到现在,许多基本问题仍悬而未决,例如如何对表达式进行类型检查,如 (𝜆𝑥.(𝑥 123, 𝑥 True)) id 这样的表达式进行可靠的类型检查。我们证明,基于多边界多态性的类型推断方法--一种具有多个下界和上界的隐式多态子类型--可以帮助我们以一种独特的简单而有规律的方式解决大多数此类问题。我们定义了 F{≤},这是一种声明式类型系统,源自 Cretin 和 Rémy(LICS 2014)的现有隐式强制理论;我们还介绍了 SuperF,这是一种新颖的算法,用于推断多态多界的 F{≤} 类型,同时检查用 F 系统语法编写的用户类型注释。我们的研究表明,SuperF 比迄今为止提出的所有第一类多态类型推断系统都要强大得多,极大地推动了通用编程语言类型推断技术的发展。
{"title":"When Subtyping Constraints Liberate: A Novel Type Inference Approach for First-Class Polymorphism","authors":"L. Parreaux, Aleksander Boruch-Gruszecki, Andong Fan, Chun Yin Chau","doi":"10.1145/3632890","DOIUrl":"https://doi.org/10.1145/3632890","url":null,"abstract":"Type inference in the presence of first-class or “impredicative” second-order polymorphism à la System F has been an active research area for several decades, with original works dating back to the end of the 80s. Yet, until now many basic problems remain open, such as how to type check expressions like (𝜆𝑥. (𝑥 123, 𝑥 True)) id reliably. We show that a type inference approach based on multi-bounded polymorphism, a form of implicit polymorphic subtyping with multiple lower and upper bounds, can help us resolve most of these problems in a uniquely simple and regular way. We define F{≤}, a declarative type system derived from the existing theory of implicit coercions by Cretin and Rémy (LICS 2014), and we introduce SuperF, a novel algorithm to infer polymorphic multi-bounded F{≤} types while checking user type annotations written in the syntax of System F. We use a recursion-avoiding heuristic to guarantee termination of type inference at the cost of rejecting some valid programs, which thankfully rarely triggers in practice. We show that SuperF is vastly more powerful than all first-class-polymorphic type inference systems proposed so far, significantly advancing the state of the art in type inference for general-purpose programming languages.","PeriodicalId":20697,"journal":{"name":"Proceedings of the ACM on Programming Languages","volume":"12 9","pages":"1418 - 1450"},"PeriodicalIF":1.8,"publicationDate":"2024-01-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"139383093","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
引用次数: 0
期刊
Proceedings of the ACM on Programming Languages
全部 Acc. Chem. Res. ACS Applied Bio Materials ACS Appl. Electron. Mater. ACS Appl. Energy Mater. ACS Appl. Mater. Interfaces ACS Appl. Nano Mater. ACS Appl. Polym. Mater. ACS BIOMATER-SCI ENG ACS Catal. ACS Cent. Sci. ACS Chem. Biol. ACS Chemical Health & Safety ACS Chem. Neurosci. ACS Comb. Sci. ACS Earth Space Chem. ACS Energy Lett. ACS Infect. Dis. ACS Macro Lett. ACS Mater. Lett. ACS Med. Chem. Lett. ACS Nano ACS Omega ACS Photonics ACS Sens. ACS Sustainable Chem. Eng. ACS Synth. Biol. Anal. Chem. BIOCHEMISTRY-US Bioconjugate Chem. BIOMACROMOLECULES Chem. Res. Toxicol. Chem. Rev. Chem. Mater. CRYST GROWTH DES ENERG FUEL Environ. Sci. Technol. Environ. Sci. Technol. Lett. Eur. J. Inorg. Chem. IND ENG CHEM RES Inorg. Chem. J. Agric. Food. Chem. J. Chem. Eng. Data J. Chem. Educ. J. Chem. Inf. Model. J. Chem. Theory Comput. J. Med. Chem. J. Nat. Prod. J PROTEOME RES J. Am. Chem. Soc. LANGMUIR MACROMOLECULES Mol. Pharmaceutics Nano Lett. Org. Lett. ORG PROCESS RES DEV ORGANOMETALLICS J. Org. Chem. J. Phys. Chem. J. Phys. Chem. A J. Phys. Chem. B J. Phys. Chem. C J. Phys. Chem. Lett. Analyst Anal. Methods Biomater. Sci. Catal. Sci. Technol. Chem. Commun. Chem. Soc. Rev. CHEM EDUC RES PRACT CRYSTENGCOMM Dalton Trans. Energy Environ. Sci. ENVIRON SCI-NANO ENVIRON SCI-PROC IMP ENVIRON SCI-WAT RES Faraday Discuss. Food Funct. Green Chem. Inorg. Chem. Front. Integr. Biol. J. Anal. At. Spectrom. J. Mater. Chem. A J. Mater. Chem. B J. Mater. Chem. C Lab Chip Mater. Chem. Front. Mater. Horiz. MEDCHEMCOMM Metallomics Mol. Biosyst. Mol. Syst. Des. Eng. Nanoscale Nanoscale Horiz. Nat. Prod. Rep. New J. Chem. Org. Biomol. Chem. Org. Chem. Front. PHOTOCH PHOTOBIO SCI PCCP Polym. Chem.
×
引用
GB/T 7714-2015
复制
MLA
复制
APA
复制
导出至
BibTeX EndNote RefMan NoteFirst NoteExpress
×
0
微信
客服QQ
Book学术公众号 扫码关注我们
反馈
×
意见反馈
请填写您的意见或建议
请填写您的手机或邮箱
×
提示
您的信息不完整,为了账户安全,请先补充。
现在去补充
×
提示
您因"违规操作"
具体请查看互助需知
我知道了
×
提示
现在去查看 取消
×
提示
确定
Book学术官方微信
Book学术文献互助
Book学术文献互助群
群 号:481959085
Book学术
文献互助 智能选刊 最新文献 互助须知 联系我们:info@booksci.cn
Book学术提供免费学术资源搜索服务,方便国内外学者检索中英文文献。致力于提供最便捷和优质的服务体验。
Copyright © 2023 Book学术 All rights reserved.
ghs 京公网安备 11010802042870号 京ICP备2023020795号-1