Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
skip to main content
research-article
Open access

Guided Equality Saturation

Published: 05 January 2024 Publication History

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.

References

[1]
Andrew Adams, Karima Ma, Luke Anderson, Riyadh Baghdadi, Tzu-Mao Li, Michaël Gharbi, Benoit Steiner, Steven Johnson, Kayvon Fatahalian, and Frédo Durand. 2019. Learning to optimize halide with tree search and random programs. TOG.
[2]
Luke Anderson, Andrew Adams, Karima Ma, Tzu-Mao Li, Tian Jin, and Jonathan Ragan-Kelley. 2021. Efficient automatic scheduling of imaging and vision pipelines for the GPU.
[3]
Lennart Augustsson, Mikael Rittri, and Dan Synek. 1994. Functional pearl: On generating unique names. Journal of Functional Programming, 4, 1 (1994), 117–123.
[4]
Franz Baader and Tobias Nipkow. 1998. Term rewriting and all that. Cambridge university press.
[5]
Leo Bachmair and Harald Ganzinger. 1994. Rewrite-based equational theorem proving with selection and simplification. Journal of Logic and Computation, 4, 3 (1994), 217–247.
[6]
Alexander Bentkamp, Jasmin Blanchette, Visa Nummelin, Sophie Tourret, Petar Vukmirović, and Uwe Waldmann. 2023. Mechanical Mathematicians. Commun. ACM, 66, 4 (2023), 80–90.
[7]
Jasmin Christian Blanchette, Sascha Böhme, and Lawrence C Paulson. 2013. Extending Sledgehammer with SMT solvers. Journal of automated reasoning, 51, 1 (2013), 109–128.
[8]
Jasmin Christian Blanchette, Lukas Bulwahn, and Tobias Nipkow. 2011. Automatic proof and disproof in Isabelle/HOL. In Frontiers of Combining Systems: 8th International Symposium, FroCoS 2011, Saarbrücken, Germany, October 5-7, 2011. Proceedings 8. 12–27.
[9]
Sascha Böhme and Tobias Nipkow. 2010. Sledgehammer: judgement day. In Automated Reasoning: 5th International Joint Conference, IJCAR 2010, Edinburgh, UK, July 16-19, 2010. Proceedings 5. 107–121.
[10]
Eduardo Bonelli, Delia Kesner, and Alejandro Ríos. 2000. A de Bruijn notation for higher-order rewriting. In International Conference on Rewriting Techniques and Applications. 62–79.
[11]
Kevin Buzzard, Johan Commelin, and Patrick Massot. 2020. Formalising perfectoid spaces. In Proceedings of the 9th ACM SIGPLAN International Conference on Certified Programs and Proofs. 299–312.
[12]
Arthur Charguéraud. 2012. The locally nameless representation. Journal of automated reasoning, 49, 3 (2012), 363–408.
[13]
Chun Chen, Jacqueline Chame, and Mary Hall. 2008. CHiLL: A framework for composing high-level loop transformations. Citeseer.
[14]
Tianqi Chen, Thierry Moreau, Ziheng Jiang, Lianmin Zheng, Eddie Yan, Haichen Shen, Meghan Cowan, Leyuan Wang, Yuwei Hu, and Luis Ceze. 2018. $TVM$: An automated end-to-end optimizing compiler for deep learning. In 13th $USENIX$ Symposium on Operating Systems Design and Implementation ($OSDI$ 18). 578–594.
[15]
Albert Cohen, Marc Sigler, Sylvain Girbal, Olivier Temam, David Parello, and Nicolas Vasilache. 2005. Facilitating the Search for Compositions of Program Transformations. In Proceedings of the 19th Annual International Conference on Supercomputing (ICS ’05). ACM, New York, NY, USA. 151–160. isbn:1595931678 https://doi.org/10.1145/1088149.1088169
[16]
Pierre Corbineau. 2006. Deciding equality in the constructor theory. In International Workshop on Types for Proofs and Programs. 78–92.
[17]
Chris Cummins, Pavlos Petoumenos, Zheng Wang, and Hugh Leather. 2017. End-to-End Deep Learning of Optimization Heuristics. In 26th International Conference on Parallel Architectures and Compilation Techniques, PACT 2017, Portland, OR, USA, September 9-13, 2017. IEEE Computer Society, 219–232. https://doi.org/10.1109/PACT.2017.24
[18]
N.G de Bruijn. 1972. Lambda calculus notation with nameless dummies, a tool for automatic formula manipulation, with application to the Church-Rosser theorem. Indagationes Mathematicae (Proceedings), 75, 5 (1972), 381–392. issn:1385-7258
[19]
Leonardo De Moura and Nikolaj Bjørner. 2007. Efficient E-matching for SMT solvers. In Automated Deduction–CADE-21: 21st International Conference on Automated Deduction Bremen, Germany, July 17-20, 2007 Proceedings 21. 183–198.
[20]
Leonardo De Moura and Nikolaj Bjørner. 2008. Z3: An efficient SMT solver. In International conference on Tools and Algorithms for the Construction and Analysis of Systems. 337–340.
[21]
Leonardo de Moura and Sebastian Ullrich. 2021. The Lean 4 Theorem Prover and Programming Language. In Automated Deduction - CADE 28 - 28th International Conference on Automated Deduction, Virtual Event, July 12-15, 2021, Proceedings, André Platzer and Geoff Sutcliffe (Eds.) (Lecture Notes in Computer Science, Vol. 12699). Springer, 625–635. https://doi.org/10.1007/978-3-030-79876-5_37
[22]
Nachum Dershowitz. 1993. A taste of rewrite systems. In Functional Programming, Concurrency, Simulation and Automated Reasoning. 199–228.
[23]
Gilles Dowek. 2001. Higher-order unification and matching. In Handbook of automated reasoning. 1009–1062.
[24]
Burak Ekici, Alain Mebsout, Cesare Tinelli, Chantal Keller, Guy Katz, Andrew Reynolds, and Clark Barrett. 2017. SMTCoq: A plug-in for integrating SMT solvers into Coq. In Computer Aided Verification: 29th International Conference, CAV 2017, Heidelberg, Germany, July 24-28, 2017, Proceedings, Part II 30. 126–133.
[25]
Trevor Evans. 1978. Word problems. Bull. Amer. Math. Soc., 84, 5 (1978), 789–802.
[26]
Oliver Flatt, Samuel Coward, Max Willsey, Zachary Tatlock, and Pavel Panchekha. 2022. Small Proofs from Congruence Closure. In 2022 Formal Methods in Computer-Aided Design (FMCAD). 75–83.
[27]
Emil Holm Gjørup and Bas Spitters. 2020. Congruence closure in cubical type theory. In Workshop on Homotopy Type Theory/Univalent Foundations. https://www.cs.au.dk/ spitters/Emil.pdf.
[28]
Georges Gonthier. 2008. Formal proof–the four-color theorem. Notices of the AMS, 55, 11 (2008), 1382–1393.
[29]
Michael J Gordon, Arthur J Milner, and Christopher P Wadsworth. 1979. Edinburgh LCF: a mechanised logic of computation. Springer.
[30]
Bastian Hagedorn, Johannes Lenfers, Thomas Koehler, Xueying Qin, Sergei Gorlatch, and Michel Steuwer. 2020. Achieving high-performance the functional way: a functional pearl on expressing high-performance optimizations as rewrite strategies. Proceedings of the ACM on Programming Languages, 4, ICFP (2020), 1–29.
[31]
Bastian Hagedorn, Larisa Stoltzfus, Michel Steuwer, Sergei Gorlatch, and Christophe Dubach. 2018. High performance stencil code generation with lift. In Proceedings of the 2018 International Symposium on Code Generation and Optimization, CGO 2018, Vösendorf / Vienna, Austria, February 24-28, 2018. ACM, 100–112.
[32]
Thomas Hales, Mark Adams, Gertrud Bauer, Tat Dat Dang, John Harrison, Hoang Le Truong, Cezary Kaliszyk, Victor Magron, Sean McLaughlin, and Tat Thang Nguyen. 2017. A formal proof of the Kepler conjecture. In Forum of mathematics, Pi. 5.
[33]
Jieh Hsiang, Hélène Kirchner, Pierre Lescanne, and Michaël Rusinowitch. 1992. The term rewriting approach to automated theorem proving. The Journal of Logic Programming, 14, 1-2 (1992), 71–99.
[34]
Joe Hurd. 2003. First-order proof tactics in higher-order logic theorem provers. Design and Application of Strategies/Tactics in Higher Order Logics, number NASA/CP-2003-212448 in NASA Technical Reports, 56–68.
[35]
Yuka Ikarashi, Jonathan Ragan-Kelley, Tsukasa Fukusato, Jun Kato, and Takeo Igarashi. 2021. Guided Optimization for Image Processing Pipelines. In VL/HCC.
[36]
Albert Qiaochu Jiang, Sean Welleck, Jin Peng Zhou, Timothée Lacroix, Jiacheng Liu, Wenda Li, Mateja Jamnik, Guillaume Lample, and Yuhuai Wu. 2023. Draft, Sketch, and Prove: Guiding Formal Theorem Provers with Informal Proofs. In The Eleventh International Conference on Learning Representations, ICLR 2023, Kigali, Rwanda, May 1-5, 2023. OpenReview.net. https://openreview.net/pdf?id=SMa9EAovKMC
[37]
Simon Peyton Jones, Andrew Tolmach, and Tony Hoare. 2001. Playing by the rules: rewriting as a practical optimisation technique in GHC. In Haskell workshop. 1, 203–233.
[38]
Donald E. Knuth. 1977. A Generalization of Dijkstra’s Algorithm. Inf. Process. Lett., 6, 1 (1977), 1–5. https://doi.org/10.1016/0020-0190(77)90002-3
[39]
D. E. Knuth and P. B. Bendix. 1983. Simple Word Problems in Universal Algebras. Springer Berlin Heidelberg, Berlin, Heidelberg. 342–376. isbn:978-3-642-81955-1 https://doi.org/10.1007/978-3-642-81955-1_23
[40]
Thomas Kœ hler. 2022. A domain-extensible compiler with controllable automation of optimisations. Ph. D. Dissertation. University of Glasgow.
[41]
Thomas Koehler and Michel Steuwer. 2021. Towards a Domain-Extensible Compiler: Optimizing an Image Processing Pipeline on Mobile CPUs. In 2021 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). 27–38.
[42]
Wen Kokke, Jeremy G. Siek, and Philip Wadler. 2020. Programming language foundations in Agda. Sci. Comput. Program., 194 (2020), 102440. https://doi.org/10.1016/J.SCICO.2020.102440
[43]
Smail Kourta, Adel Abderahmane Namani, Fatima Benbouzid-Si Tayeb, Kim Hazelwood, Chris Cummins, Hugh Leather, and Riyadh Baghdadi. 2022. Caviar: an e-graph based TRS for automatic code optimization. In Proceedings of the 31st ACM SIGPLAN International Conference on Compiler Construction. 54–64.
[44]
Ł ukasz Lachowski. 2018. On the complexity of the standard translation of lambda calculus into combinatory logic. Reports on Mathematical Logic, 19–42.
[45]
Chris Lattner and Vikram S. Adve. 2004. LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation. In 2nd IEEE / ACM International Symposium on Code Generation and Optimization (CGO 2004), 20-24 March 2004, San Jose, CA, USA. IEEE Computer Society, 75–88. https://doi.org/10.1109/CGO.2004.1281665
[46]
Florian Lemaitre, Benjamin Couturier, and Lionel Lacassagne. 2017. Cholesky factorization on SIMD multi-core architectures. Journal of Systems Architecture, 79 (2017), 1–15.
[47]
A Solar Lezama. 2008. Program synthesis by sketching. Ph. D. Dissertation. PhD thesis, EECS Department, University of California, Berkeley.
[48]
Jannis Limperg and Asta Halkjæ r From. 2023. Aesop: White-Box Best-First Proof Search for Lean. In Proceedings of the 12th ACM SIGPLAN International Conference on Certified Programs and Proofs. 253–266.
[49]
Saeed Maleki, Yaoqing Gao, Maria J Garzar, Tommy Wong, and David A Padua. 2011. An evaluation of vectorizing compilers. In 2011 International Conference on Parallel Architectures and Compilation Techniques. 372–382.
[50]
Naums Mogers, Valentin Radu, Lu Li, Jack Turner, Michael O’Boyle, and Christophe Dubach. 2020. Automatic generation of specialized direct convolutions for mobile GPUs. In Proceedings of the 13th Annual Workshop on General Purpose Processing using Graphics Processing Unit. 41–50.
[51]
Ravi Teja Mullapudi, Vinay Vasista, and Uday Bondhugula. 2015. PolyMage: Automatic Optimization for Image Processing Pipelines. SIGARCH Comput. Archit. News, 43, 1 (2015), March, 429–443. issn:0163-5964
[52]
Chandrakana Nandi, Max Willsey, Adam Anderson, James R Wilcox, Eva Darulova, Dan Grossman, and Zachary Tatlock. 2020. Synthesizing structured CAD models with equality saturation and inverse transformations. In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation. 31–44.
[53]
Chandrakana Nandi, Max Willsey, Amy Zhu, Yisu Remy Wang, Brett Saiki, Adam Anderson, Adriana Schulz, Dan Grossman, and Zachary Tatlock. 2021. Rewrite rule inference using equality saturation. arXiv preprint arXiv:2108.10436.
[54]
Charles Gregory Nelson. 1980. Techniques for program verification. Stanford University.
[55]
Greg Nelson and Derek C Oppen. 1980. Fast decision procedures based on congruence closure. Journal of the ACM (JACM), 27, 2 (1980), 356–364.
[56]
Robert Nieuwenhuis and Albert Oliveras. 2005. Proof-producing congruence closure. In Term Rewriting and Applications: 16th International Conference, RTA 2005, Nara, Japan, April 19-21, 2005. Proceedings 16. 453–468.
[57]
Robert Nieuwenhuis and Albert Oliveras. 2007. Fast congruence closure and extensions. Information and Computation, 205, 4 (2007), 557–580.
[58]
Jarkko Niittylahti, Juha Lemmetti, and Juhana Helovuo. 2002. High-performance implementation of wavelet algorithms on a standard PC. Microprocessors and Microsystems, 26, 4 (2002), 173–179.
[59]
Tobias Nipkow. 2002. Structured proofs in Isar/HOL. In International Workshop on Types for Proofs and Programs. 259–278.
[60]
D. Parello, O. Temam, A. Cohen, and J.-M. Verdun. 2004. Towards a Systematic, Pragmatic and Architecture-Aware Program Optimization Process for Complex Processors. In SC ’04: Proceedings of the 2004 ACM/IEEE Conference on Supercomputing. 15–15. https://doi.org/10.1109/SC.2004.61
[61]
Lawrence C Paulson and Kong Woei Susanto. 2007. Source-level proof reconstruction for interactive theorem proving. In International Conference on Theorem Proving in Higher Order Logics. 232–245.
[62]
Amir Pnueli, Michael Siegel, and Eli Singerman. 1998. Translation validation. In Tools and Algorithms for the Construction and Analysis of Systems: 4th International Conference, TACAS’98 Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS’98 Lisbon, Portugal, March 28–April 4, 1998 Proceedings 4. 151–166.
[63]
Varot Premtoon, James Koppel, and Armando Solar-Lezama. 2020. Semantic code search via equational reasoning. In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation. 1066–1082.
[64]
Jonathan Ragan-Kelley, Andrew Adams, Sylvain Paris, Marc Levoy, Saman P. Amarasinghe, and Frédo Durand. 2012. Decoupling algorithms from schedules for easy optimization of image processing pipelines. ACM Trans. Graph., 31, 4 (2012), 32:1–32:12.
[65]
Jonathan Ragan-Kelley, Connelly Barnes, Andrew Adams, Sylvain Paris, Frédo Durand, and Saman Amarasinghe. 2013. Halide: a language and compiler for optimizing parallelism, locality, and recomputation in image processing pipelines. Acm Sigplan Notices.
[66]
Alexandre Riazanov and Andrei Voronkov. 1999. Vampire. Lecture notes in computer science, 1632 (1999), 0292–0292.
[67]
Joseph J Rotman. 2006. A first course in abstract algebra: with applications.
[68]
Peter Scholze. 2021. Liquid tensor experiment. Experimental Mathematics, 1–6.
[69]
Daniel Selsam and Leonardo de Moura. 2016. Congruence closure in intensional type theory. In Automated Reasoning: 8th International Joint Conference, IJCAR 2016, Coimbra, Portugal, June 27–July 2, 2016, Proceedings 8. 99–115.
[70]
Savvas Sioutas, Sander Stuijk, Twan Basten, Henk Corporaal, and Lou Somers. 2020. Schedule synthesis for halide pipelines on gpus. TACO.
[71]
Gus Henry Smith, Andrew Liu, Steven Lyubomirsky, Scott Davidson, Joseph McMahan, Michael Taylor, Luis Ceze, and Zachary Tatlock. 2021. Pure tensor program rewriting via access patterns (representation pearl). arXiv preprint arXiv:2105.09377.
[72]
Mark Stephenson, Saman P. Amarasinghe, Martin C. Martin, and Una-May O’Reilly. 2003. Meta optimization: improving compiler heuristics with machine learning. In Proceedings of the ACM SIGPLAN 2003 Conference on Programming Language Design and Implementation 2003, San Diego, California, USA, June 9-11, 2003, Ron Cytron and Rajiv Gupta (Eds.). ACM, 77–90. https://doi.org/10.1145/781131.781141
[73]
Michel Steuwer, Christian Fensch, Sam Lindley, and Christophe Dubach. 2015. Generating performance portable code using rewrite rules: from high-level functional expressions to high-performance OpenCL code. In Proceedings of the 20th ACM SIGPLAN International Conference on Functional Programming, ICFP 2015, Vancouver, BC, Canada, September 1-3, 2015. ACM, 205–217.
[74]
Michel Steuwer, Thomas Koehler, Bastian Köpcke, and Federico Pizzuti. 2022. RISE & Shine: Language-Oriented Compiler Design. CoRR, abs/2201.03611 (2022), arXiv:2201.03611. arxiv:2201.03611
[75]
Michel Steuwer, Toomas Remmelg, and Christophe Dubach. 2017. Lift: a functional data-parallel IR for high-performance GPU code generation. In CGO. ACM, 74–85.
[76]
Ross Tate, Michael Stepp, Zachary Tatlock, and Sorin Lerner. 2009. Equality saturation: a new approach to optimization. In Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages. 264–276.
[77]
Sid Ahmed Ali Touati and Denis Barthou. 2006. On the decidability of phase ordering problem in optimizing compilation. In Proceedings of the Third Conference on Computing Frontiers, 2006, Ischia, Italy, May 3-5, 2006. ACM, 147–156. https://doi.org/10.1145/1128022.1128042
[78]
Alexa VanHattum, Rachit Nigam, Vincent T Lee, James Bornholt, and Adrian Sampson. 2021. Vectorization for digital signal processors via equality saturation. In Proceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems. 874–886.
[79]
Eelco Visser, Zine-el-Abidine Benaissa, and Andrew Tolmach. 1998. Building program optimizers with rewriting strategies. ACM Sigplan Notices, 34, 1 (1998), 13–26.
[80]
Yisu Remy Wang, Shana Hutchison, Jonathan Leang, Bill Howe, and Dan Suciu. 2020. SPORES: sum-product optimization via relational equality saturation for large scale linear algebra. arXiv preprint arXiv:2002.07951.
[81]
Christoph Weidenbach, Dilyana Dimova, Arnaud Fietzke, Rohit Kumar, Martin Suda, and Patrick Wischnewski. 2009. SPASS Version 3.5. In Automated Deduction–CADE-22: 22nd International Conference on Automated Deduction, Montreal, Canada, August 2-7, 2009. Proceedings 22. 140–145.
[82]
Freek Wiedijk. 2003. Formal proof sketches. In International Workshop on Types for Proofs and Programs. 378–393.
[83]
Max Willsey, Chandrakana Nandi, Yisu Remy Wang, Oliver Flatt, Zachary Tatlock, and Pavel Panchekha. 2021. Egg: Fast and extensible equality saturation. Proceedings of the ACM on Programming Languages, 5, POPL (2021), 1–29.
[84]
Chenming Wu, Haisen Zhao, Chandrakana Nandi, Jeffrey I Lipton, Zachary Tatlock, and Adriana Schulz. 2019. Carpentry compiler. ACM Transactions on Graphics (TOG), 38, 6 (2019), 1–14.
[85]
Yichen Yang, Phitchaya Phothilimthana, Yisu Wang, Max Willsey, Sudip Roy, and Jacques Pienaar. 2021. Equality saturation for tensor graph superoptimization. Proceedings of Machine Learning and Systems, 3 (2021).
[86]
Lianmin Zheng, Chengfan Jia, Minmin Sun, Zhao Wu, Cody Hao Yu, Ameer Haj-Ali, Yida Wang, Jun Yang, Danyang Zhuo, Koushik Sen, Joseph E. Gonzalez, and Ion Stoica. 2020. Ansor: Generating High-Performance Tensor Programs for Deep Learning. In 14th USENIX Symposium on Operating Systems Design and Implementation, OSDI 2020, Virtual Event, November 4-6, 2020. USENIX Association, 863–879. https://www.usenix.org/conference/osdi20/presentation/zheng
[87]
Oleksandr Zinenko. 2016. Interactive Program Restructuring. (Restructuration interactive des programmes). Ph. D. Dissertation. University of Paris-Saclay, France. https://tel.archives-ouvertes.fr/tel-01414770

Cited By

View all

Recommendations

Comments

Information & Contributors

Information

Published In

cover image Proceedings of the ACM on Programming Languages
Proceedings of the ACM on Programming Languages  Volume 8, Issue POPL
January 2024
2820 pages
EISSN:2475-1421
DOI:10.1145/3554315
Issue’s Table of Contents
This work is licensed under a Creative Commons Attribution 4.0 International License.

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 05 January 2024
Published in PACMPL Volume 8, Issue POPL

Permissions

Request permissions for this article.

Check for updates

Author Tags

  1. e-graphs
  2. equality saturation
  3. optimizing compilers
  4. theorem provers

Qualifiers

  • Research-article

Funding Sources

Contributors

Other Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

  • 0
    Total Citations
  • 724
    Total Downloads
  • Downloads (Last 12 months)724
  • Downloads (Last 6 weeks)144
Reflects downloads up to 04 Oct 2024

Other Metrics

Citations

Cited By

View all

View Options

View options

PDF

View or Download as a PDF file.

PDF

eReader

View online with eReader.

eReader

Get Access

Login options

Full Access

Media

Figures

Other

Tables

Share

Share

Share this Publication link

Share on social media