Benefits of New Operations

Oct 13, 2025 by talynt.org 22 views

In the existing main-branch spec, the only way to introduce an anchored key is with a ValueOf statement, by the operation NewEntryFromValueOf. However, this may not be sufficient for all use cases. In this article, we will explore alternative ways to introduce a new anchored key, including new operations and custom deduction rules.

STEP 1: New Operations

For applications, we might also want to introduce a new anchored key as (for example) the sum of two unknown values. This is a clean solution for the Transitively Rich Girl use case, for example. In other words, x and y are values defined in previous PODs. I know something about them (maybe x >= 3 and y >= 5), but I don't know the precise values. I want to be able to reason about x+y.

We want to make sure, when we introduce a new anchored key, that it can only have one well-defined value. But as long as x and y are well-defined, the sum is well-defined as well.

So, I proposed new operations:

NewEntryFromSum: This operation would introduce a new anchored key as the sum of two unknown values.
NewEntryFromDifference: This operation would introduce a new anchored key as the difference of two unknown values.
NewEntryFromProduct: This operation would introduce a new anchored key as the product of two unknown values.

Do we want these?

Benefits of New Operations

The new operations would provide a more flexible way to introduce new anchored keys, allowing users to reason about more complex relationships between values. For example, if we know that x >= 3 and y >= 5, we can use the NewEntryFromSum operation to introduce a new anchored key x+y >= 8.

Potential Drawbacks

However, introducing new operations may also introduce new complexity and potential errors. We need to carefully consider the implications of each new operation and ensure that they are well-defined and consistent with the existing spec.

STEP 2: Custom Deduction Rules

Do we want to allow custom deduction rules to introduce new anchored keys as well?

Here's a sample use case. You could define a custom statement AppendOrUpdate that appends a key-value pair to a Merkle tree (unless the key is already in the Merkle tree, in which case it updates the value). Semantically, this is the same as the Python dictionary assignment tree[k] = v. The custom statement would be implemented in-circuit as AppendOrUpdate(old_tree, k, v, new_tree) and it would be valid if and only if new_tree is the correct output of this operation.

(This is slightly different from the Append example in the docs at complete_draft: book/src/merkleexample.md. That Append statement forces that k is not a key in old_tree, while AppendOrUpdate allows that k is an existing key, and its value gets updated to v.)

In an AppendOrUpdate statement, new_tree is uniquely determined from old_tree, k, v -- in other words, it's a well-defined function.

So, a user might want to do an AppendOrUpdate operation on an unknown Merkle root old_tree, and then prove some claims about the resulting Merkle root new_tree.

Benefits of Custom Deduction Rules

Allowing custom deduction rules would provide a more flexible and extensible way to introduce new anchored keys. Users could define their own custom statements and operations, allowing them to reason about more complex relationships between values.

Potential Drawbacks

However, allowing custom deduction rules may also introduce new complexity and potential errors. We need to carefully consider the implications of each custom rule and ensure that they are well-defined and consistent with the existing spec.

Conclusion

In conclusion, introducing new anchored keys is a complex task that requires careful consideration of the implications of each new operation or custom rule. We need to balance the benefits of flexibility and extensibility with the potential drawbacks of complexity and error.

Ultimately, the decision to introduce new operations or custom deduction rules will depend on the specific use cases and requirements of the application. We need to carefully evaluate the trade-offs and make an informed decision that meets the needs of the users.

Recommendations

Based on the analysis above, I recommend the following:

Introduce new operations: We should introduce new operations such as NewEntryFromSum, NewEntryFromDifference, and NewEntryFromProduct to provide a more flexible way to introduce new anchored keys.
Allow custom deduction rules: We should allow custom deduction rules to introduce new anchored keys, providing a more flexible and extensible way to reason about complex relationships between values.
Carefully evaluate trade-offs: We need to carefully evaluate the trade-offs of introducing new operations and custom deduction rules, ensuring that they are well-defined and consistent with the existing spec.

In our previous article, we explored alternative ways to introduce a new anchored key, including new operations and custom deduction rules. In this article, we will answer some frequently asked questions (FAQs) about introducing new anchored keys.

Q: What is an anchored key?

An anchored key is a key that is uniquely determined by a set of values. In other words, it is a key that has a well-defined value.

Q: Why do we need new operations to introduce anchored keys?

The existing ValueOf statement is not sufficient for all use cases. We need new operations to introduce anchored keys that are more complex, such as the sum or difference of two unknown values.

Q: What are the benefits of introducing new operations?

Introducing new operations provides a more flexible way to introduce new anchored keys, allowing users to reason about more complex relationships between values.

Q: What are the potential drawbacks of introducing new operations?

Introducing new operations may also introduce new complexity and potential errors. We need to carefully consider the implications of each new operation and ensure that they are well-defined and consistent with the existing spec.

Q: Can we allow custom deduction rules to introduce new anchored keys?

Yes, we can allow custom deduction rules to introduce new anchored keys. This would provide a more flexible and extensible way to reason about complex relationships between values.

Q: What are the benefits of allowing custom deduction rules?

Allowing custom deduction rules provides a more flexible and extensible way to introduce new anchored keys, allowing users to define their own custom statements and operations.

Q: What are the potential drawbacks of allowing custom deduction rules?

Allowing custom deduction rules may also introduce new complexity and potential errors. We need to carefully consider the implications of each custom rule and ensure that they are well-defined and consistent with the existing spec.

Q: How do we ensure that new operations and custom deduction rules are well-defined and consistent with the existing spec?

We need to carefully evaluate the trade-offs of introducing new operations and custom deduction rules, ensuring that they are well-defined and consistent with the existing spec.

Q: What is the recommended approach for introducing new anchored keys?

Based on our analysis, we recommend introducing new operations and allowing custom deduction rules to provide a more flexible and extensible way to introduce new anchored keys.

Q: What are the next steps for introducing new anchored keys?

The next steps for introducing new anchored keys are to:

Develop new operations: Develop new operations such as NewEntryFromSum, NewEntryFromDifference, and NewEntryFromProduct to provide a more flexible way to introduce new anchored keys.
Allow custom deduction rules: Allow custom deduction rules to introduce new anchored keys, providing a more flexible and extensible way to reason about complex relationships between values.
Carefully evaluate trade-offs: Carefully evaluate the trade-offs of introducing new operations and custom deduction rules, ensuring that they are well-defined and consistent with the existing spec.

By following these steps, we can provide a more flexible and extensible way to introduce new anchored keys, while minimizing the potential drawbacks of complexity and error.