Group theory crash #519
Comments
|
Right, rule like |
|
Thanks! egglog accepts that just fine. But how do I get it to check equality of ground terms? I try:
(check (= (id) (id)))
But it says check failed.
… On Feb 10, 2025, at 11:00 PM, Yihong Zhang ***@***.***> wrote:
Right, rule like a -> (plus a (id)) is supported in egg, but not directly in egglog. As egglog translates rules to Datalog/chase-like rules, all variables need to be bound. A standard workaround is to use a universe relation:
(datatype G
(id)
(inv G)
(plus G G)
)
(relation universe (G))
(rule ((= e (id))) ((universe e)))
(rule ((= e (inv a))) ((universe e)))
(rule ((= e (plus a b))) ((universe e)))
(birewrite (plus (plus a b) c) (plus a (plus b c)))
(birewrite (plus a (id)) a :when ((universe a)))
(birewrite (plus (inv a) a) (id) :when ((universe a)))
;; which gets translate to two (slightly inefficient) rules
;; (rule ((= e (plus (inv a) a)) (universe a)) ;; we don't need (universe a) here
;; ((union a (id))))
;; (rule ((= e (id)) (universe a))
;; ((union a (plus (inv a) a))))
—
Reply to this email directly, view it on GitHub <#519 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AA2QKN4T2KKM6TFZBQENWP32PGNZVAVCNFSM6AAAAABW35WJYCVHI2DSMVQWIX3LMV43OSLTON2WKQ3PNVWWK3TUHMZDMNBZHE3TCNZZGY>.
You are receiving this because you authored the thread.
|
|
In this case, |
|
Thanks! This all makes sense. But suppose I omitted your rule that ab=1 -> {b=a^1, a=b^-1}. Will it be the case that the check of “iab = ibia” can be made to succeed by choosing a high enough number with “run” (e.g. > 5, possibly infinity)? In other words, can egglog decide the ground word problem in the free group on two generators using only the three equations as given?
I ask because I am interested in using it as an automated theorem prover for equational logic (as well as a Skolem chase engine), and hope that I’m not conflating EggLog with Egg with EqSat.
… On Feb 11, 2025, at 12:14 AM, Yihong Zhang ***@***.***> wrote:
In this case, (id) has not been populated in the "database", and checking (= (id) (id)) implicitly checks the existence of (id), so it failed. It would work if we manually insert (id) into the database. I also made a slightly more involved example here.
(datatype G
(id)
(inv G)
(plus G G)
)
(relation universe (G))
(rule ((= e (id))) ((universe e)))
(rule ((= e (inv a))) ((universe e)))
(rule ((= e (plus a b))) ((universe e)))
(birewrite (plus (plus a b) c) (plus a (plus b c)))
(birewrite (plus a (id)) a :when ((universe a)))
(birewrite (plus (id) a) a :when ((universe a)))
(birewrite (plus (inv a) a) (id) :when ((universe a)))
(birewrite (plus a (inv a)) (id) :when ((universe a)))
;; ab=1 --> b=a^-1
(rule ((= (id) (plus a b)))
((union b (inv a))
(union a (inv b))))
;; need to populate (id) in the e-graph first
(id)
(check (= (id) (id)))
(constructor a () G)
(constructor b () G)
(let iab (inv (plus (a) (b))))
(let ibia (plus (inv (b)) (inv (a))))
(run 5)
(check (= iab ibia))
—
Reply to this email directly, view it on GitHub <#519 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AA2QKN432PQFIXOTCF3RSUD2PGWMRAVCNFSM6AAAAABW35WJYCVHI2DSMVQWIX3LMV43OSLTON2WKQ3PNVWWK3TUHMZDMNJQGA4DGMJUGM>.
You are receiving this because you authored the thread.
|
|
Yes! The issue I had in my previous program is that it didn't put a and b into the universe relation. We don't actually need the extra rule |
|
That’s great, this shows how to solve the ground word problem in universal algebra. If you’ll indulge me, I have two hopefully final questions:
1) how does this work with multiple sorts? For example, if I wanted to use a multi-sorted structure such as a category instead of a group, where the constructors depend on two sorts, Ob and Hom, how would the syntax change?
2) can this solution to the ground word problem be lifted to the full word problem? For example, in this scenario, if I take “forall c, c+a = c+b” and skolemize c into a fresh constant will egglog prove "c+a=c+b” if and only if “forall c, c+a = c+b” holds in the free group on two generators? In fact, I'm most curious in if it can handle equational entailment checking via skolemization, proving something like "(forall c, c+a = c+b) -> (forall d, a+d = b+d)" via skolemization and running forever. (I'm guessing Egglog can semi-decide entailment of cartesian theories (skolemized horn theories) but this has to be proven and I'm looking for a proof.)
Question 2 can be more subtle than it looks. Unfailing Knuth-Bendix completion, for example, solves the ground word problem, but simply skolemizing and running forever does *not* turn it into a semi-decision procedure for equational logic. (You have to make use of “refutational completeness” and encode some boolean logic to do so: see theorem 4.34 of https://rg1-teaching.mpi-inf.mpg.de/autrea-ss12/slides/slides21.pdf for example).
… On Feb 11, 2025, at 11:24 AM, Yihong Zhang ***@***.***> wrote:
Yes! The issue I had in my previous program is that it didn't put a and b into the universe relation. We don't actually need the extra rule
(datatype G
(id)
(inv G)
(plus G G)
)
(relation universe (G))
(rule ((= e (id))) ((universe e)))
(rule ((= e (inv a))) ((universe e)))
(rule ((= e (plus a b))) ((universe e)))
(birewrite (plus (plus a b) c) (plus a (plus b c)))
(birewrite (plus a (id)) a :when ((universe a)))
(birewrite (plus (id) a) a :when ((universe a)))
(birewrite (plus (inv a) a) (id) :when ((universe a)))
(birewrite (plus a (inv a)) (id) :when ((universe a)))
(constructor a () G)
(constructor b () G)
(universe (a))
(universe (b))
(push)
(union (id) (plus (a) (b)))
(run 5)
(check (= (a) (inv (b))))
(pop)
(push)
(let iab (inv (plus (a) (b))))
(let ibia (plus (inv (b)) (inv (a))))
(run 5)
(check (= iab ibia))
(pop)
—
Reply to this email directly, view it on GitHub, or unsubscribe.
You are receiving this because you authored the thread.Message ID: ***@***.***>
|
This was referenced Feb 12, 2025
Is this something you have in mind? Assuming I understand your question correctly, I think this is hard in current egglog, since egglog does not have real parametric/dependent types. Real parametric/dependent types introduce problems since each function is supposed to be backed by a database table, and it's not clear when to instantiate a parametric function (like
Does it suffice to show EqSat subsumes Skolem chase (which we show in the semantics paper)?
I think egglog can prove |
|
Thanks again for your response!
Dependent sorts are nice, but I really just mean multiple sorts, something like this for the action of a group on a set:
(datatype G A
(id : G)
(inv : G -> G)
(plus : G * G -> G)
(action : G * A -> A)
)
For categories in particular, they can be axiomatized using cartesian logic, so dependent sorts shouldn’t be necessary, just constructors that can use multiple sorts. Encoding multiple sorts into a single sort leads to verbosity that I’d like to avoid.
—
It wouldn’t surprise me if Egglog could decide the full word problem for universal algebra, but it has to be proven (at least, based solely on the Suciu paper). This is because in general, there is no way to turn an arbitrary semi-decision procedure for ground equality in universal algebra into a semi-decision procedure for non-ground equality:
Suppose I have a semi-decision procedure F : (s:Signature) -> (t:EquationalTheory s) -> (t1:GroundTerm t) -> (t2:GroundTerm t)->Bool, which is one way to understand EggLog based on the Suciu Paper. And suppose I want to implement a semi-decision procedure of type (s:Signature) -> (t:EquationalTheory s) -> (t1’:Term t) -> (t2’:Term t)->Bool. I might try to skolemize t1 and t2, resulting in ground terms on a signature s’ that is larger than s. But F only proves equality in the smaller vocabulary s! I can’t even invoke my original ground semi-decider F on the skolemizations of t1 and t2, because the skolemizations live in a different signature than the original terms. Type error!
So, for systems that prove the full world problem from the ground one, they have to show how. Sometimes, this can be trivial; maybe F can be directly used on the skolemized terms regardless of the change in signature. Sometimes, it is not: in unfailing knuth bendix completion, for example, you can’t just apply F directly to the skolemized terms, that results in incompleteness. Instead, you also have to change the theory t to talk about the new Skolem constants, and ensure they are “smaller” than all other constants, and use a refutational completeness property of the knuth bendix algorithm in order to prove completeness of F on s’.
At a practical level, I’m trying to connect egglog to CQL (http://categoricaldata.net), and so I’m trying to understand if I can do so “directly” (pick my own Skolem constants and pass the skolemized terms to egglog), or if something more involved is required (pick my own Skolem constants and then pass the skolemized terms to egglog but where egglog is run on a non-trivially different theory than I started with), to retain completeness (all provable (not necessarily ground) equalities eventually terminate with ’true’).
It's possible the Skolem chase may semi-decide the full word problem; I'll try to find a proof. I had mostly been thinking about how to use EqSat for the full word problem.
… On Feb 12, 2025, at 7:43 PM, Yihong Zhang ***@***.***> wrote:
how does this work with multiple sorts? For example, if I wanted to use a multi-sorted structure such as a category instead of a group, where the constructors depend on two sorts, Ob and Hom, how would the syntax change?
Is this something you have in mind?
(sort Ob)
(sort (Hom a b) for ((a b : Ob)))
(function id () (Hom a b) for ((a b : Ob)))
Assuming I understand your question correctly, I think this is hard in current egglog, since egglog does not have real parametric/dependent types. This also introduces new problems since each function is backed by a database table, and it's not clear when to instantiate a parametric function (like id) with concrete types.
I'm guessing Egglog can semi-decide entailment of cartesian theories (skolemized horn theories)
Does it suffice to show EqSat subsumes Skolem chase (which we show in the semantics paper)?
• can this solution to the ground word problem be lifted to the full word problem?
I think egglog can prove forall c, c+a = c+b by skomizing c to an uninterpreted constant. For entailment, if you have forall c, c+a = c+b an axiom and check if a+d() = b+d() holds (for Skolem constant d()), would that just work?
—
Reply to this email directly, view it on GitHub, or unsubscribe.
You are receiving this because you authored the thread.Message ID: ***@***.***>
|
Yeah egglog supports multiple sorts. There are also many examples in the web demo.
I never thought of it! This sounds interesting. Yes EqSat can semi-decide the ground word problem but I kinda just take the full word problem for granted. Let me know if you make any new discoveries about the connection between EqSat and the full word problem. |
|
I was about to write to Dan Suciu and ask if he knew if EqSat generalized to the full word problem, or if SkChase can solve the full word problem, when I realized you know him better than I do :-). With the multi-sorted syntax I have enough to start attaching egglog to CQL, but ultimately the completeness and possibly even soundness of doing so will hinge on the open questions described in this thread.
Here's a concrete example of what might go wrong lifting a ground word problem solver to the full word problem; I'm not quite sure how to test this in Egglog, but maybe you can help?
Let the signature have two sorts, "Void" and "nat" and two constants "one:nat" and "two:nat".
Then "one = two" should not be provable, but "forall x:Void, one = two" should be provable (according to the usual rules of multi-sorted equational logic with empty sorts).
But if you skolemize variable x into a fresh constant x', there's no proof rule to allow concluding one=two in an empty context with Void inhabited by constant x'.
What would egglog do here?
FWIW, empty sorts pop up in CQL a lot, because empty sorts are interpreted as empty database tables. This problem also comes up with entailment checking: the check {Nat,Void,one:Nat,two:Nat} |- {Nat,Void,one:Nat,two:Nat,forall x:Void, one = two} would come up when trying to prove that inclusion functors between algebraic theories are actually functorial.
… On Feb 17, 2025, at 2:24 PM, Yihong Zhang ***@***.***> wrote:
yihozhang
left a comment
(egraphs-good/egglog#519)
something like this for the action of a group on a set
Yeah egglog supports multiple sorts. There are also many examples in the web demo.
(datatype*
(G
(id)
(inv G)
(plus G G))
(A
(action G A)))
in general, there is no way to turn an arbitrary semi-decision procedure for ground equality in universal algebra into a semi-decision procedure for non-ground equality
I never thought of it! This sounds interesting. Yes EqSat can semi-decide the ground word problem but I kinda just take the full word problem for granted. Let me know if you make any new discoveries about the connection between EqSat and the full word problem.
—
Reply to this email directly, view it on GitHub, or unsubscribe.
You are receiving this because you authored the thread.
<#519 (comment)> <https://github.com/notifications/unsubscribe-auth/AA2QKN5YVDQUO6SLLGMYVVL2QJORLAVCNFSM6AAAAABW35WJYCVHI2DSMVQWIX3LMV43OSLTON2WKQ3PNVWWK3TUHMZDMNRUGE3DGMJWGI>
yihozhang
left a comment
(egraphs-good/egglog#519)
<#519 (comment)>
something like this for the action of a group on a set
Yeah egglog supports multiple sorts. There are also many examples in the web demo.
(datatype*
(G
(id)
(inv G)
(plus G G))
(A
(action G A)))
in general, there is no way to turn an arbitrary semi-decision procedure for ground equality in universal algebra into a semi-decision procedure for non-ground equality
I never thought of it! This sounds interesting. Yes EqSat can semi-decide the ground word problem but I kinda just take the full word problem for granted. Let me know if you make any new discoveries about the connection between EqSat and the full word problem.
—
Reply to this email directly, view it on GitHub <#519 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AA2QKN5YVDQUO6SLLGMYVVL2QJORLAVCNFSM6AAAAABW35WJYCVHI2DSMVQWIX3LMV43OSLTON2WKQ3PNVWWK3TUHMZDMNRUGE3DGMJWGI>.
You are receiving this because you authored the thread.
|
|
This is interesting. I actually don't know! Maybe another example is that given a signature containing an empty/singleton sort, how can egglog prove I don't think egglog can directly prove this. Here is one idea using denial constraint: For the denial rule to be sound, all the axiomatic rules need to saturate first, which is unlikely when the universal model is not finitely representable. So yeah, I'm not quite sure. Another idea is to encode a more powerful logic in egglog? I don't know if this is realistic though. |
|
Got it - maybe a solution will be found, and I’ve asked around. Thanks for all your help! I’ve attached Egglog to CQL and it is solving the ground world problems CQL generates like a champ; I look forward to the day when it can do even more. Do please close the thread at your discretion. -Ryan
PS Finally found a reference that the ground and non-ground word problems in universal algebra are distinct: "term rewriting and all that" by Nipkow, chapter 4.1, "the word problem for E is undecidable if the ground word problem for E is. The converse does not hold in general." So some equational systems will have an undecidable world problem but decidable ground word problem. For those, naive skolemization will be either unsound or incomplete or land in a different theory, I'm not sure. I'll keep looking to come up with a good example - the example with empty sorts doesn't really prove the point I'm looking for.
PPS For reference, here are the precise proofs I'm looking for:
- a proof that EqSat can be used as a (complete) semi-decision procedure for the full word problem (equality of terms containing variables) of a multi-sorted equational theory with possibly empty sorts. The obvious thing to do is take two open terms t1 and t2, herbrandize them to ground terms t1' and t2', and then ask EqSat if t1' = t2'. But that this obvious process is complete needs to be proved, because it doesn't work for arbitrary ground word problem solvers; in eg unfailing Knuth Bendix completion, you ask if true = false in an extended signature/theory containing new symbols true, false, and eq, with new axioms eq(x,x)=false and eq(t1',t2')=true. (So each check t1=t2 yields a new run of completion/saturation on a new theory and new signature.) In CQL we've seen both these two ways and other ways besides, of lifting ground solvers to the full word problem. I just need to figure out which one to use for egglog in particular. I'm thinking this is probably a completeness issue rather than a soundness one... . I'm tracking this here: CategoricalData/CQL#81
- Same question as above, but with SkChase in place of EqSat.
- Same two questions as above, but with Horn theory entailment rather than equational theory entailment.
Update Feb20: I asked Tobias Nipkow. He pointed to https://people.dmi.uns.ac.rs/~dockie/papers/001.pdf as an example variety with an undecidable equational theory but decidable ground word problem, but it is 'contrived' and uses an infinite set of equations. So I'm not sure how to use it here. Update Feb21: this paper says that decidability of implicational (horn) entailment and the solvability of the global word problem are the same. So maybe completeness of egglog for equational theorem proving might come from SkChase rather than EqSat.
… On Feb 19, 2025, at 1:36 PM, Yihong Zhang ***@***.***> wrote:
This is interesting. I actually don't know! Maybe another example is that given a signature containing an empty/singleton sort, how can egglog prove for all x,y, x=y
(datatype S (id))
(check ((= x y)) ;; ??
I don't think egglog can directly prove this.
Here is one idea using denial constraint:
(datatype S (id))
(relation U (S))
(S (id))
(rule (
(U s)
(U t)
(!= s t)
) (
;; alternatively, put something in a denial database)
(panic "the statement is false")
))
For the denial rule to be sound, all the axiomatic rules need to saturate first, which is unlikely when the universal model is not finitely representable. So yeah, I'm not quite sure.
Another idea is to encode a more powerful logic in egglog?
(datatype E
(Forall Var E)
(Exists Var E)
(And E E)
...
)
I don't know if this is realistic though.
—
Reply to this email directly, view it on GitHub, or unsubscribe.
You are receiving this because you authored the thread.Message ID: ***@***.***>
yihozhang left a comment (egraphs-good/egglog#519)
This is interesting. I actually don't know! Maybe another example is that given a signature containing an empty/singleton sort, how can egglog prove for all x,y, x=y
(datatype S (id))
(check ((= x y)) ;; ??
I don't think egglog can directly prove this.
Here is one idea using denial constraint:
(datatype S (id))
(relation U (S))
(S (id))
(rule (
(U s)
(U t)
(!= s t)
) (
;; alternatively, put something in a denial database)
(panic "the statement is false")
))
For the denial rule to be sound, all the axiomatic rules need to saturate first, which is unlikely when the universal model is not finitely representable. So yeah, I'm not quite sure.
Another idea is to encode a more powerful logic in egglog?
(datatype E
(Forall Var E)
(Exists Var E)
(And E E)
...
)
I don't know if this is realistic though.
—
Reply to this email directly, view it on GitHub, or unsubscribe.
You are receiving this because you authored the thread.Message ID: ***@***.***>
|
|
Is there a modern egglog equivalent to "saturate" from some previous papers? I'm now trying to hook up Egglog as a chase engine / initial model finder instead of theorem prover, so I'm trying to run rules until they reach a fixed point, even at risk of divergence. The examples I've found such as towers of Hanoi just choose a really big number and use 'run'. Thanks again! |
|
Yes! You can do |
|
Thanks! Another question: what does egglog do with what the chase would call contradictions? For example, if one and two are distinct constants of sort Nat, and we chase with a rule such as “one = two”, the desired behavior is usually for the chase to fail, rather than form a quotient where one = two are equated, as would happen in building an initial model. Can egglog be made to fail in such cases?
In the absence of support for chase failure, the output of the chase must be checked to be conservative over its input, in order to determine if the chase would have failed, which is a tough check, basically asking if any equations hold between input constants in the chase output that don’t hold in the input.
This isn’t a blocker for CQL integration - CQL will carry on with a contradictory chase just fine - but obviously in practice failing when e.g. “1=2” is detected is usually what’s desired, so I still wanted to ask.
… On Feb 21, 2025, at 5:45 PM, Yihong Zhang ***@***.***> wrote:
Yes! You can do (run-schedule (saturate (run))). The examples are outdated.
—
Reply to this email directly, view it on GitHub, or unsubscribe.
You are receiving this because you authored the thread.Message ID: ***@***.***>
yihozhang left a comment (egraphs-good/egglog#519)
Yes! You can do (run-schedule (saturate (run))). The examples are outdated.
—
Reply to this email directly, view it on GitHub, or unsubscribe.
You are receiving this because you authored the thread.Message ID: ***@***.***>
|
|
I’ve run into a blocker with a direct encoding of primary key constraints in egglog; I know for EqSat that EGDs need an encoding but I figured egglog, being closer to prolog, might support something direct. Anyway, I have a primary key constraint saying that if x and y (of type Person say) agree on their names then they are the same person. But egglog says:
(rule ((= (name x) (name y))) ((= x y)) )
In 1:32-38: (= x y)
Unbound function =
Is = allowed on the RHS of a rule? When I try with rewrite, I get a different error:
(rewrite ((= (name x) (name y))) ((= x y)) )
[ERROR] In 1:10-32: ((= (name x) (name y)))
parse error: expected call expression
If = is not allowed on the RHS, then is the standard approach to create a new equivalence relation and relate it to the built-in =?
Thanks again,
Ryan
… On Feb 21, 2025, at 7:28 PM, Ryan Wisnesky ***@***.***> wrote:
Thanks! Another question: what does egglog do with what the chase would call contradictions? For example, if one and two are distinct constants of sort Nat, and we chase with a rule such as “one = two”, the desired behavior is usually for the chase to fail, rather than form a quotient where one = two are equated, as would happen in building an initial model. Can egglog be made to fail in such cases?
In the absence of support for chase failure, the output of the chase must be checked to be conservative over its input, in order to determine if the chase would have failed, which is a tough check, basically asking if any equations hold between input constants in the chase output that don’t hold in the input.
This isn’t a blocker for CQL integration - CQL will carry on with a contradictory chase just fine - but obviously in practice failing when e.g. “1=2” is detected is usually what’s desired, so I still wanted to ask.
> On Feb 21, 2025, at 5:45 PM, Yihong Zhang ***@***.***> wrote:
>
> Yes! You can do (run-schedule (saturate (run))). The examples are outdated.
> —
> Reply to this email directly, view it on GitHub, or unsubscribe.
> You are receiving this because you authored the thread.Message ID: ***@***.***>
> yihozhang left a comment (egraphs-good/egglog#519)
> Yes! You can do (run-schedule (saturate (run))). The examples are outdated.
> —
> Reply to this email directly, view it on GitHub, or unsubscribe.
> You are receiving this because you authored the thread.Message ID: ***@***.***>
|
In chase's terminology, every sort value in egglog is a "marked null", so unioning one and two does not cause an error. Instead, users wrote rules like this
Ah right! To say two things are equivalent in the RHS, egglog uses the This also needs to be a |
|
Understood: re: the chase using only labeled nulls. BTW, in "Fast Left Kan Extension using the Chase": https://arxiv.org/abs/2205.02425 we found a fairness condition (condition 3 in Proposition 3 on p. 22) required for chase sequences implementing left kan extensions that is similar to yours, although so far we haven't been able to prove the conditions equivalent. Left Kan extensions can be used very directly to construct initial models. Also, I wanted to report that "birewrite" on ground terms does not seem to trigger "union", which I thought was surprising. The egglog below sets up a database table called Person with an attribute (and primary key) called name of type dom, and two people g1 and g2: If I use: the result is one Person, as expected. But if I use: then egglog still reports two people. |
|
Sorry was/am really swamped in a deadline push!
This looks interesting! I'll make sure to read it when I'm freer
Ah, I think this is because you don't edit: another common reason is maybe you haven't populated (name (g1)) or (name (g2)) in your database |
|
Sorry, the 1 vs 2 sized thing is after running to saturation. Here's the two full programs: gives size two but gives size one. The only difference between the two is "union" vs "birewrite". I was able to hook up egglog to CQL as a chase engine for both EGDs and TGDs using "union" for all ground equations and it seems to be working ok so far, but I'm still not clear why union and bi-rewrite would result in different models after saturation. |
|
I see it now! I think it's because in your first program, |
|
Great! I'm going to close this thread for now. We have an active Zulip where you can ask questions! https://egraphs.zulipchat.com/#narrow/stream/375765-egglog |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Hi all, I've been experimenting with encoding equational theories in the sense of universal algebra into Egglog. For example, group theory. I understand that I could enter a complete set of re-write rules as discovered by Knuth-Bendix completion but I wanted to see what would happen if I just use the usual 3 equation encoding:
I understand why the erroneous rule is flagged - its right hand side refers to the variable a that is not bound on the left, and the crash is on a kind of rule that is usually disallowed (variable -> non-variable). Here is the message:
I'm wondering - can Egglog be used to semi-decide ground equality of arbitrary equational theories, such as group theory? This paper: https://arxiv.org/pdf/2501.02413 makes it seem like the answer is 'yes' and so I'm trying to figure out how to do, and wondering if the above approach is correct or if there are other approaches.
The text was updated successfully, but these errors were encountered: