Pecan: An Automated Theorem Prover for Automatic Sequences using Büchi Automata
aa r X i v : . [ c s . L O ] F e b Pecan: An Automated Theorem Prover forAutomatic Sequences using Büchi Automata
Reed Oei, Dun Ma, Christian Schulz, and Philipp Hieronymi
University of Illinois at Urbana-Champaign, Urbana, USA reedoei2,dunma2,cschulz3,[email protected]
Abstract.
Pecan is an automated theorem prover for reasoning aboutproperties of Sturmian words, an important object in the field of combi-natorics on words. It is capable of efficiently proving non-trivial mathe-matical theorems about all Sturmian words.
Keywords:
Automatic theorem proving · Sturmian words · Implemen-tation.
Pecan is a system for automated theorem proving originally designed to decidemathematical statements about families of infinite words, in particular aboutSturmian words, and based on well-known decision procedures for Büchi au-tomata due to Büchi [3]. Pecan is inspired by Walnut [12] by Mousavi, anotherautomated theorem prover for deciding combinatorical properties of automaticwords.
Automatic words are sequences of terms characterized by finite au-tomata. The main motivation to create this new tool is to decide whether astatement is true for every element of an infinite family of words rather thanjust determining the truth of the statement for a single given words. In sucha situation not every word in this family of words is automatic, but the wholefamily can be recognized by an automaton. Since the infinite families of wordswe want to consider are often indexed by real numbers, it is convenient to workwith Büchi automata instead of finite automata. The canonical example of sucha automatic family of words are the
Sturmian words , that is the family ( w α,ρ ) of all words w = ( w n ) over the alphabet { , } such that there is ρ ∈ [0 , , calledthe intercept , and an irrational α ∈ (0 , , called the slope , with w n = ⌊ nα + ρ ⌋ − ⌊ ( n − α + ρ ⌋ for all n ∈ N . Using Pecan, we can automatically reprove classical and recenttheorems about Sturmian words, like the fact that they are not periodic, withinminutes, and even have been able to prove completely new mathematical theo-rems using this software.The idea of using automata-based decision procedures to prove theorems incombinatorics on words has been championed by Jeffrey Shallit and successfullyimplemented in several papers of Shallit and his many co-authors (see Shallit [17] Reed Oei, Dun Ma, Christian Schulz, and Philipp Hieronymi for a survey and Baranwal, Schaeffer, Shallit [2] for implementations of decisionprocedure for individual Sturmian words). The development of Pecan is ourcontribution to this exciting research program. We leave the detailed discussionof the mathematical background such as why Sturmian words can representedusing automata and which statements about Sturmian words can be proved usingPecan, to the upcoming paper [6]. Here we describe the implementation of Pecanand discuss its performance.
Pecan improves on Walnut [12], a similar automata-based theorem prover forautomatic sequences, by using Büchi automata instead of finite automata. Thisdifference enables Pecan to handle uncountable families of sequences, allowingus quantify over all Sturmian words. Additionally, the Pecan language is ableto use multiple numeration systems at a time, has a concept of types outside ofnumeration systems, and has meta-programming language, Praline.Many other theorem provers exist, such as SMT solvers and proof assis-tants, like Coq [18] or Isabelle [13]. To our knowledge, no SMT solver supportsreasoning about Sturmian words. Systems like Coq or Isabelle have projects at-tempting to formalize some aspects of combinatorics on words and automaticsequences [8,9]. However, proofs in these systems are mostly human written,with some help from heuristics or specialized solvers, rather than being fullyautomatic, as in Pecan.Büchi automata have also been used extensively in program verification insystems such as SPIN [5]. However, we are interested in proving mathematicalresults, rather than proofs about properties of programs. For this reason, wemust allow unrestricted use of logical operations, such as negation, rather thanrestricting to more limited forms of expressing properties, such as linear temporallogic, which such systems tend to use for performance reasons.
Support for this project was provided by the Illinois Geometry Lab. This projectwas partially supported by NSF grant DMS-1654725.
This section contains an informal introduction to words, automata, and thenotation that we use. For precise statements and proof, we refer the reader toAllouche and Shallit [1] or Khoussainov and Nerode [10].Let Σ ∗ denote the set of finite words on the alphabet Σ , let Σ + denote theset of nonempty finite words on the alphabet Σ , and let Σ ω denote the set of ω -words on the alphabet Σ .For a word w , let w [ i ] denote the i -letter of w . Let w ( i, n ) denote the length- n factor of w starting at i and ending at i + n − , that is, w [ i . . . i + n −
1] = w [ i ] w [ i + 1] · · · w [ i + n − . Let | w | denote the length of w . ecan: An Automated Theorem Prover 3 Büchi automata are an extension of the standard finite automata to infiniteinputs. A Büchi automata A = ( Q, Σ, δ, q , F ) accepts an infinite word w ∈ Σ ω ifthe run of the automaton on the word w visits an accepting state (i.e., a state in F ) infinitely many times. The set of words accepted by A is its language , L ( A ) .Notably, nondeterministic Büchi automata and not equivalent to deterministicBüchi automata, and many interesting properties are only expressible via nonde-terministic Büchi automata. For that reason, we simply refer to nondeterministicBüchi automata as Büchi automata, without qualification. Additionally, whenwe say “automata” without qualification, we refer to Büchi automata. Impor-tantly, the languages that Büchi automata define are closed under intersection,union, projection, and complementation, and emptiness checking is decidable. For full documentation on the features of Pecan, see the more comprehensivemanual available at our repository [14].
Directives are the interface to Pecan, instructing it to perform actions (e.g., provea theorem). We discuss the most important:
Restrict , Structure , and
Theorem . Restrict VARIABLES are TYPE_PREDICATE .
In all following code in the file in which the
Restrict appears, the variablesspecified are now consider to be of the specified type.
Structure TYPE_PREDICATE defining { FUNCTION_PREDICATES }
Defines a new structure. The
TYPE_PREDICATE is essentially the part written af-ter the is in a restriction. For example, in Restrict x is nat. , the type predicateis nat ; in
Restrict i is ostrowski(a). , the type predicate is ostrowski(a) . Thefunction predicates become available to be called using the names in quotes—this feature allows for ad-hoc polymorphism, as described in Section 4. It is alsoused to resolve arithmetic operators, such as + (which calls the relevant adder )and < (which calls the relevant less ). Theorem ( " THEOREM NAME " , { PREDICATE }).Theorem is the interface to the theorem proving capabilities of Pecan, stating thatPecan show attempt to prove the specified
PREDICATE is true.Below is an example of using all three features from above: specifying astructure called nat , restricting variables, and then proving a theorem, which istrue because of the dynamic call resolution.
Structure nat defining {" adder ": bin_add ( any , any , any )," less ": bin_less ( any , any )}Restrict a , b are nat .Theorem ( "" , { ∀ a ,b. a < b ⇔ bin_less (a , b)}). Reed Oei, Dun Ma, Christian Schulz, and Philipp Hieronymi
Automatic Words
Any predicate P can be interpreted as a word by writing P [ i ] ,which is treated as if P ( i ) is true, and if P ( i ) is false. Currently only binaryautomatic words are supported. We use the following translations into the IR: – P [ i ] = 0 ¬ P ( i ) – P [ i ] = 1 P ( i ) – P [ i ] = Q [ j ] P ( i ) ⇐⇒ P ( j ) – P [ i ] = Q [ j ] ¬ ( P ( i ) ⇐⇒ P ( j )) – P [ i..j ] = P [ k..ℓ ] j + k = i + ℓ ∧ ∀ n ∈ typ ( i ) .i + n < j ⇒ P [ i + n ] = P [ k + n ] This section describes the high-level the implementation of Pecan. We give aformal definition of the Pecan language, starting with the typing rules and asso-ciated definitions in Section 4.1, and then the rules for evaluation in Section 4.2.Figure 1 is the syntax for the core of the Pecan language. Pecan also supportssome simple syntactic sugar, such as if P then Q , which expands into ¬ P ∨ Q , or n*x for some literal number n , which expands into x+x+x+...+x with n repetitions. P, f ∈ PredicateNames V ∈ VariableMaps a, x, y, z ∈ Identifiers n, m ∈ N A ∈ Automata
Prog ::=
Definition τ ::= P | P ( x ) Definition ::= P ( x : τ ) := Pred | Restrict x are P ( x ) Pred ::= true | false | Pred ∨ Pred | ¬
Pred | Pred ∧ Pred | ∃ x. Pred | E < E | E = E | P ( E ) | Aut ( V, A ) E ::= E + E | E - E | x | n | f ( E ) Fig. 1.
Syntax of the core of Pecan. A type in Pecan is represented by a Büchi automaton. We say that x : τ when x ∈ L ( τ ) , sometimes simply written, as an analogy to logical predicates, as τ ( x ) .Types may be partially applied . For example, if τ = P ( x , . . . , x n ) , where P issome Büchi automaton, then y : τ when ( x , . . . , x n , y ) ∈ L ( P ) ; and τ ( y ) holdswhen y : τ . In the concrete syntax of Pecan, we write y is tau or y ∈ tau ; forone or more variables, we can write x, y, z are tau to mean x : τ , y : τ , z : τ .The judgement Γ ⊢ x : τ means that we can prove τ ( x ) is true in the typeenvironment Γ , consisting of pairs x : τ . We write the domain of Γ as dom Γ .The judgement Γ ⊢ P prop means that P is a well-formed proposition in theenvironment Γ . A predicate P ( x : τ ) := Q is well-formed when x : τ ⊢ Q prop.Below, we assume that the set of all well-formed predicates, which have alreadybeen checked, is ambiently available as P . ecan: An Automated Theorem Prover 5 Structures.
In order to support ad-hoc polymorphism, Pecan allows the defini-tion and use of structures . This feature facilitates the use of nicer syntax for arith-metic expressions (e.g., x +( y + z ) = w instead of ∃ t. adder ( x, y, t ) ∧ adder ( t, z, w ) )without tying ourselves to a single numeration system. For example, adder willbe resolved to some concrete predicate predicate based on the type of x , y , and z . We assume structure definitions are ambiently available in the program. Definition 1. A structure is a pair ( t ( x ) , D ) where x are identifiers and D is amap of identifiers to call templates of the form f ( y ) , where for each y ⊆ x ∪ {∗} ; ∗ denotes “any.” The name of the structure is t . We write the sequence of indexes of the arguments that are ∗ , called pa-rameters , as params ( f ( y )) . A call template is n -ary if | params ( f ( y )) | = n . Thesequence of the indexes of the other arguments (i.e., not ∗ ), called implicits , is implicit ( f ( y )) . For example, params ( f ( a, ∗ , b, ∗ )) = [2 , and implicit ( f ( a, ∗ , b, ∗ )) =[1 , . We assume that typechecking has been done before evaluating, becausewe may need structure information at runtime to resolve dynamic calls , that is,calls whose name matches some definition inside a structure. We denote the typethat an expression e got when typechecking by typ ( e ) .We write t [ P ] = Q ( y , . . . , y m ) to look up a definition in the associated map D , and we say that t has an m -ary definition for P in this case. If t does nothave a definition for P , then we write t [ P ] = ⊥ . Definition 2.
A structure is called numeric if it has a ternary definition for adder and a binary definition less . We write x + y = z when adder ( x, y, z ) holds and x < y when less ( x, y ) holds. A numeric structure may also optionallycontain the following definitions: – A binary definition equal ( x, y ) , written x ≡ y . The default is equality, x = y . – A unary definition zero ( z ) . The default is z = 0 ω . – A unary definition one ( x ) . The default is ≤ x ∧ ∀ y.y = 0 ∨ x ≤ y . Definition 3.
We can resolve a call P ( e ) as Q ( a : τ ) , written P ( e ) Q ( a : τ ) ,if Q ( a : τ ) ∈ P and for some structure t ( x , . . . , x ℓ ) , for each ≤ i ≤ | e | , either:1. typ ( e i ) = t ( x , . . . , x ℓ ) , and t [ P ] = Q ( b , . . . , b m ) such that for each ≤ j ≤ m , a j = ( x k if implicit ( Q ( b , . . . , b m ))[ k ] = je k if params ( Q ( b , . . . , b m ))[ k ] = j
2. typ ( e i ) = s ( y , . . . , y p ) , where s = t and s [ P ] = ⊥ .or, if none of the arguments have a definition for P , then P ( e ) P ( a : τ ) . Γ ⊢ e : τ Expression Typing
The expression typing rules are standard,with the exception that we can treat any predicate as a function by not writing
Reed Oei, Dun Ma, Christian Schulz, and Philipp Hieronymi it’s last argument (e.g., f ( x ) denotes the y such that f ( x, y ) holds). τ is numeric Γ ⊢ i : τ Int x : τ ∈ ΓΓ ⊢ x : τ Var Γ ⊢ a : τ Γ ⊢ b : τ ⊕ ∈ { + , −} Γ ⊢ a ⊕ b : τ Op Γ ⊢ e : τ ( f ( x : τ, r : σ ) := e ′ ) ∈ P Γ ⊢ f ( e ) : σ Func Γ ⊢ P prop Well-formed Propositions Γ ⊢ a : τ Γ ⊢ b : τ ⋊⋉ ∈ {≡ , < } Γ ⊢ a ⋊⋉ b prop Rel Γ ⊢ Aut ( V, A ) prop Aut Γ ⊢ P prop Γ ⊢ Q prop ⊕ ∈ {∨ , ∧} Γ ⊢ P ⊕ Q prop BinPred Γ ⊢ P prop Γ ⊢ ¬ P prop Comp
Γ, x : τ ⊢ P prop Γ ⊢ ∃ x : τ.P prop Exists Γ ⊢ e : τ ( f ( x : τ ) := e ′ ) ∈ P Γ ⊢ f ( e ) prop Call
Pecan is a simple tree-walking interpreter written in Python 3 [19] which type-checks and processes each top-level construct in order. Operations with non-trivial implementations are described in detail below. Most basic automata op-erations (e.g., conjunction, disjunction, complementation, emptiness checking,simplification) are implemented using the Spot library [4].
Automata Representation
Automata are represented by a pair of ( V, A ) ,where V is a map taking variable names to an ordered list of APs that representit, called the variable map , and A is a Spot automaton (specifically, a value oftype spot.twa_graph ). We use the convention that calligraphic letters representactual Büchi automata, and Fraktur letters represent automata in the Pecansense of a pair of a variable map and Büchi automaton.A variable map V is a finite set of mappings x [ ap , . . . , ap n ] such that forall distinct variables x and y , V [ x ] ∩ V [ y ] = [] . We denote by V [ x ] the list of APsthat x is represented by, and we denote by V ∪ W the union of two variablesmaps union, which is only defined when the only keys that V and W have incommon have identical APs. V ⊔ W is the disjoint union of these maps. V \ K is the variable map containing every entry x a ∈ V such that x K .For two variable maps V and W , V ≪ W denotes their biased merge , whichis a pair ( U, θ ) of a variable map U and a substitution θ such that U = V ∪ W θ .A substitution is a set of mappings a b where a and b are both APs, which canbe applied to a variable map or an automaton to rename the APs in them. Forexample, if θ = { a d, c e } , then { x [ a, b, c ] } θ = { x [ d, b, e ] } . When itis clear, we also write V ≪ W to denote just the resulting variable map, withoutthe associated substitution. ecan: An Automated Theorem Prover 7 Below, we describe the evaluation of Pecan programs via a big-step relation E ⇓ A . Automata literals (generally loaded from files), written Aut ( V, A ) , simplyevaluate to be the automata they store: Aut ( V, A ) ⇓ ( V, A ) . Logical Operations
Fundamental automata operations (i.e., ∧ and ∨ , rep-resented by ⊕ below) are defined below. ( V, A ) ⊕ ( W, B ) = (cid:26) ( V ≪ W, A ⊕ B ) if | S ( A ) | < | S ( B ) | ( W ≪ V, A ⊕ B ) otherwise where S ( A ) denotes the set of states of A . We also define ¬ ( V, A ) = ( V, ¬A ) . Substitution
Let A = ( V, A ) , where A = ( Q, ∆, δ, q , F ) be a Büchi au-tomaton where ∆ is the set of formulas involving ∧ , ∨ , and ¬ on a finite set X of APs. We now define the substitution A [ y/x ] , replacing x by y . Let A = [ a ] be the list of APs representing x (i.e., A = V [ x ] ), and let B = [ b ] be the list ofAPs representing y , which we assume is ambiently available. This can be storedglobally, and generated when needed if the variable y has never been used before.Define A [ y/x ] = ( V ′ , A ′ ) where V ′ = ( V \ { x } ) ∪ { y B } , and A ′ =( Q, ∆ ′ , δ ′ , q , F ) , with the new set of variables X ′ = ( X \ A ) ∪ B and the sameunderlying alphabet, such that: ∆ ′ = { ϕ [ b/a ] : ϕ ∈ ∆ } ; and δ ′ = { ( s, d, ϕ [ b/a ]) : ( s, d, ϕ ) ∈ δ ′ } Predicate Calls e ⇓ ( A , x ) nonvar ( e ) = [ k , . . . , k ℓ ] P ( X ) Q ( y ) ( Q ( z : τ ) := R ) ∈ P R ⇓ B P ( e ) ⇓ proj x k ,...,x kℓ (cid:16)^ A ∧ B [ y/z ] (cid:17) Call where nonvar ( e ) denotes the nonvariable positions in e . Existential Quantification ( τ ( x ) ∧ P ) ⇓ ( V, A )( ∃ x ∈ τ.P ) ⇓ proj V [ x ] ( V, A ) Exist
Here proj V [ x ] ( A ) denotes the automaton A after projecting out every APrepresenting x in the variable map V [ x ] ; this operation is implemented in Spot. Expressions
An expression E evaluates to a pair ( A , x ) of an automaton A and a variable x . Many rules, like Add , need to evaluate subexpressions. Whileevaluating a subexpression e , it may be that we generate fresh variables to storethe result, which must be projected out. The only case in which this does notoccur is when the subexpression is itself a variable. We write proj x ( A ) to denoteprojecting out the intermediate variables resulting from computing expressionsthat are not variables. For example, if a ⇓ ( A , x ) and b ⇓ ( B , y ) then proj a,b ( A ) denotes proj V ( A ) where V = { v : ( e, v ) ∈ { ( a, x ) , ( b, y ) } , e = v } . Reed Oei, Dun Ma, Christian Schulz, and Philipp Hieronymi x ⇓ ( ⊤ , x ) Var x fresh ⇓ ( zero ( x ) , x ) Zero x fresh ⇓ ( one ( x ) , x ) One a ⇓ ( A , x ) b ⇓ ( B , y ) ( x + y = z ) ⇓ C z fresh a + b ⇓ ( proj a,b ( A ∧ B ∧ C ) , z ) Add a ⇓ ( A , x ) b ⇓ ( B , y ) ( z + y = x ) ⇓ C z fresh a − b ⇓ ( proj a,b ( A ∧ B ∧ C ) , z ) Sub n times z }| { · · · + 1 ⇓ ( A , x ) n ⇓ ( A , x ) Int f ( e, x ) ⇓ A x fresh f ( e ) ⇓ ( proj e ( A ) , x ) Func a ⇓ ( A , x ) b ⇓ ( B , y ) ( x ⋊⋉ y ) ⇓ C ⋊⋉ ∈ {≡ , < } a ⋊⋉ b ⇓ proj a,b ( A ∧ B ∧ C ) Rel
We evaluate the performance of Pecan by generating automata for fundamentaldefinitions in the field of combinatorics on words and proving theorems aboutSturmian words using these definitions. We consider characteristic
Sturmianwords, i.e., where the intercept is , which we write c α = w α, ; all definitions areparameterized by the slope of Sturmian word. To our knowledge, there are noother tools to which Pecan can be directly compared. Our results indicate thatour approach is practical, as we are able to prove many interesting theoremsusing only an ordinary computer. There is not space to discuss the definitionsand theorems encoded, but our repository contains the complete code [15].We record several metrics for each predicate: the number of atoms , how many alternating quantifier blocks it contains (i.e., alternating universal and existentialquantifiers), the runtime in seconds, the number of states and edges in the inter-mediate automaton with the greatest number of states, and the final number ofstates and edges, when applicable. Alternating quantifier blocks increase the run-time due to the encoding of ∀ x.P ( x ) as ¬ ( ∃ x. ¬ P ( x )) , as complementing Büchiautomata has a very poor worst-case complexity of at least Ω ((0 . n ) n ) [20].We write these blocks as ∀ n ∃ n ∀ n . . . . Quantifiers range over countable do-mains unless otherwise noted; ∀ R and ∃ R are quantifiers ranging over domainsof cardinality | R | .As an example of computing these metrics, consider the following definition. Definition 4.
A factor x of a word w is special if x and x are factors of w . In Pecan, we can define this for Sturmian words as follows.
Restrict a is bco_standard . ecan: An Automated Theorem Prover 9
Restrict i ,j ,k ,n are ostrowski (a).special_factor (a ,i ,n) :=( ∃ j. factor_lt_len (a ,i ,n ,j) ∧ $ C [j+n] = 0) ∧ ( ∃ k. factor_lt_len (a ,i ,n ,k) ∧ $ C [k+n] = 1)
The numeric structure ostrowski(a) specifies the numeration system for thevariables i , j , k and n making Sturmian words into automatic sequences, and $ C[i] denotes the i -th letter of the Sturmian word—the same automaton worksfor every slope. Pecan expands this to: special_factor (a ,i ,n) :=( ∃ j. ostrowski (a ,j) ∧ factor_lt_len (a ,i ,n ,j) ∧¬ ( ∃ v0 . adder (j ,n , v0 ) ∧ $ C( v0 ))) ∧ ( ∃ k. ostrowski (a ,k) ∧ factor_lt_len (a ,i ,n ,k) ∧ ( ∃ v1 . adder (k ,n , v1 ) ∧ $ C( v1 )))
We can see that special_factor has atoms and has complexity ∃ ∀ in prenexnormal form. Here, factor_lt_len(a,i,n,j) means c a [ i..i + n ] = c a [ j..j + n ] . Max FinalName Complexity Atoms Runtime (s) States Edges States EdgesMirror invariant ∃ . Unbordered ∃ . Cube ∃ . Least period ∀ . Max unbordered subfactor ∀ . Palindrome ∃ . Period ∃ . Recurrent ∀∃ . Special factor ∃ ∀ . Factor Lt (idx) ∃∀
11 702 . Eventually periodic ∃ ∀∃
12 216 . Reverse factor ∃∀
12 842 . Antipalindrome ∃ ∀
13 242 . Antisquare ∀
13 1844 . Square ∀
13 2138 . ∗ | (10) ∗ ∀
16 77 . Fig. 2.
Common definitions about Sturmian words.
Figure 2 shows performance statistics for creating the automata representingvarious common definitions in Pecan. The automaton for Eventually Periodic isempty because of the classic result that there are no Sturmian words that areeventually periodic. One might guess that Cube would be more expensive thanSquare; however, we can define Cube very efficiently in terms of Square. Thesame is true for higher powers, as well as many other predicates: for example,both Mirror Invariant and Palindrome are relatively easy to compute, as theyare straighforwardly defined using Reverse Factor. We can see that, even thoughthe automata often become quite large (e.g., having over million states in thecase of Antisquare), we are still able to handle them relatively easily.Figure 3 shows performance statistics for proving theorems about Sturmianwords in Pecan. These theorems are a mix of classical results, known theorems, ∀ R ∃ . . . ∀ R ∃ . . . ∃ R ∃ . . . ∀ R ∀ . . . ∀ R ∃ . . . ∀ R ∀ . . . ∀ R ∃∀ . . . ∀ R ∃ . . . ∀ R ∀∃ . . . ∀ R ∃ . . . ∀ R ∀∃ . . . ∀ R ∀ . . . ∀ R ∀ . . . ∀ R ∀∃ . . . ∀ R ∀ . . . ∀ R ∀ ∃
10 1 0 . . . ∀ R ∀∃∀∃∀∃
17 1 3 . . . ∀ R ∀ ∃
18 1 156 . . . ∀ R ∀∃ ∀
22 1 489 . . . Fig. 3.
Theorems about Sturmian words, grouped by complexity and number of atoms.Number column shows how many theorems are in each group. Theorems evaluate tosingle state automata, so we omit the data about the final automaton. and some new results we proved using Pecan, described in [6]. Overall, our resultsshow that Pecan is a viable theorem proving tool for Sturmian words, and wehypothesize it will also be useful for other Büchi-automatic sequences.
We presented Pecan, the first system, to our knowledge, implementing a generalpurpose decision procedure for Büchi-automatic sequences, and in particular,statements about Sturmian words. The system aims to be a convenient inter-face for specifying definitions and proving theorems about such sequences, withfeatures such as custom numeration systems, enabled by the type system, andconvenient syntax for indexing into automatic sequences. We provide a formaldescription of the system, then evaluate the performance of Pecan by building au-tomata representing common definitions and proving theorems about Sturmianwords. We show that Pecan has reasonable performance, despite the theoreticalworst-case, indicating that the approach is practical.In the future, we hope to expand the statements that Pecan is capable ofhandling, by integrating known extensions such as multiplication by quadraticirrationals, as described in [7]. We also hope to continue using Pecan to provetheorems about Sturmian words, both to provide new proofs of old results, aswell as proving more new results. It may also be interesting to support moreexpressive kinds of automata that still have the desired closure properties, suchas ( ω -)operator precedence automata [16]. We would also like to integrate Pecaninto a general-purpose proof assistant, such as Isabelle or Lean [11]. ecan: An Automated Theorem Prover 11 References ω abs/1603.06017 (2016), http://arxiv.org/abs/1603.0601713. Nipkow, T., Paulson, L.C., Wenzel, M.: Isabelle/HOL: a proof assistant for higher-order logic, vol. 2283. Springer Science & Business Media (2002)14. Oei, R., Ma, D., Schulz, C., Hieronymi, P.: Pecan. available athttps://github.com/ReedOei/Pecan (2021)15. Oei, R., Ma, D., Schulz, C., Hieronymi, P.: Pecan. available athttps://github.com/ReedOei/SturmianWords (2021)16. Panella, F., Pradella, M., Mandrioli, D., Lonati, V.: Operator Precedence ω -languages (2013)17. Shallit, J.: Decidability and enumeration for automatic sequences:a survey. In: Computer science—theory and applications, Lec-ture Notes in Comput. Sci., vol. 7913, pp. 49–63. Springer,Heidelberg (2013). https://doi.org/10.1007/978-3-642-38536-0_5,https://doi-org.proxy2.library.illinois.edu/10.1007/978-3-642-38536-0_518. Team, T.C.D.: The coq proof assistant, version8.11.0 (Jan 2020). https://doi.org/10.5281/zenodo.3744225,https://doi.org/10.5281/zenodo.37442252 Reed Oei, Dun Ma, Christian Schulz, and Philipp Hieronymi19. Van Rossum, G., Drake, F.L.: Python 3 Reference Manual. CreateSpace, ScottsValley, CA (2009)20. Yan, Q.: Lower Bounds for Complementation of omega-AutomataVia the Full Automata Technique. Logical Methods in ComputerScience4