在agda'内工作；s决策框架

我在使用字符串可判定性时遇到问题。首先，我很困惑为什么在Agda中使用可判定性如此困难，而在Coq中，它看起来像黄油一样光滑。当我试图证明这个关于字符串的简单定理时，Agda展现了一个混乱的定义，除非你确切地知道你要做什么，否则这几乎是不可能的。如何通过模式匹配处理字符串的可判定性，从而保持定义的灵活性

我使用Stump的keep功能代替Agda的inspect

keep : ∀{ℓ}{A : Set ℓ} → (x : A) → Σ A (λ y → x ≡ y)
keep x = ( x , refl )

--first roadblock
eqbStringrefl' : forall (b : String) →  true ≡ (b == b)
eqbStringrefl' b with keep (b ≟ b)
eqbStringrefl' b | (.true Relation.Nullary.because Relation.Nullary.ofʸ refl) , snd = {!!}
eqbStringrefl' b | (.false Relation.Nullary.because Relation.Nullary.ofⁿ ¬p) , snd = {!!}

以下是Agda的输出：

-- Goal: true ≡
--       Relation.Nullary.Decidable.Core.isYes
--       (Relation.Nullary.Decidable.Core.map′
--        (λ x →
--           Agda.Builtin.String.Properties.primStringToListInjective b b
--           (Data.List.Relation.Binary.Pointwise.Pointwise-≡⇒≡
--            (Data.List.Relation.Binary.Pointwise.map
--             (λ {z} {z = z₁} →
--                Agda.Builtin.Char.Properties.primCharToNatInjective z z₁)
--             x)))
--        (λ x →
--           Data.List.Relation.Binary.Pointwise.map
--           (cong Agda.Builtin.Char.primCharToNat)
--           (Data.List.Relation.Binary.Pointwise.≡⇒Pointwise-≡
--            (cong Data.String.toList x)))
--        (Data.List.Relation.Binary.Pointwise.decidable
--         (λ x y →
--            Relation.Nullary.Decidable.Core.map′
--            (Data.Nat.Properties.≡ᵇ⇒≡ (Agda.Builtin.Char.primCharToNat x)
--             (Agda.Builtin.Char.primCharToNat y))
--            (Data.Nat.Properties.≡⇒≡ᵇ (Agda.Builtin.Char.primCharToNat x)
--             (Agda.Builtin.Char.primCharToNat y))
--            (Data.Bool.Properties.T?
--             (Agda.Builtin.Char.primCharToNat x Data.Nat.≡ᵇ
--              Agda.Builtin.Char.primCharToNat y)))
--         (Data.String.toList b) (Data.String.toList b)))
-- ————————————————————————————————————————————————————————————
-- snd : Relation.Nullary.Decidable.Core.map′
--       (λ x →
--          Agda.Builtin.String.Properties.primStringToListInjective b b
--          (Data.List.Relation.Binary.Pointwise.Pointwise-≡⇒≡
--           (Data.List.Relation.Binary.Pointwise.map
--            (λ {z} {z = z₁} →
--               Agda.Builtin.Char.Properties.primCharToNatInjective z z₁)
--            x)))
--       (λ x →
--          Data.List.Relation.Binary.Pointwise.map
--          (cong Agda.Builtin.Char.primCharToNat)
--          (Data.List.Relation.Binary.Pointwise.≡⇒Pointwise-≡
--           (cong Data.String.toList x)))
--       (Data.List.Relation.Binary.Pointwise.decidable
--        (λ x y →
--           Relation.Nullary.Decidable.Core.map′
--           (Data.Nat.Properties.≡ᵇ⇒≡ (Agda.Builtin.Char.primCharToNat x)
--            (Agda.Builtin.Char.primCharToNat y))
--           (Data.Nat.Properties.≡⇒≡ᵇ (Agda.Builtin.Char.primCharToNat x)
--            (Agda.Builtin.Char.primCharToNat y))
--           (Data.Bool.Properties.T?
--            (Agda.Builtin.Char.primCharToNat x Data.Nat.≡ᵇ
--             Agda.Builtin.Char.primCharToNat y)))
--        (Data.String.toList b) (Data.String.toList b))
--       ≡ Relation.Nullary.yes refl
-- b   : String

如果我现在应用重写，目标会简化，但假设列表中仍然有一团混乱。 当我尝试ctrl-a时，尽管目标似乎无法推断，但我得到以下错误：

Goal: true ≡ true
Not implemented: The Agda synthesizer (Agsy) does not support
copatterns yet

尽管如此，我还是能够继续，就好像snd术语是非常干净的一样，然后应用基本规则得出最终证明

eqbStringrefl'' : forall (b : String) →  true ≡ (b == b)
eqbStringrefl'' b with keep (b ≟ b)
eqbStringrefl'' b | (.true Relation.Nullary.because Relation.Nullary.ofʸ refl) , snd rewrite snd = {!!}
eqbStringrefl'' b | (.false Relation.Nullary.because Relation.Nullary.ofⁿ ¬p) , snd = {!!}
-- eqbStringrefl'' b | (.true Relation.Nullary.because Relation.Nullary.ofʸ refl) , snd rewrite snd = refl
-- eqbStringrefl'' b | (.false Relation.Nullary.because Relation.Nullary.ofⁿ ¬p) , snd = ⊥-elim (¬p refl)

---

最后一行是完整的证明。任何建议都会有帮助

通过导入定义了可判定性概念的

Relation.Nullary

，您可以 将获得访问权限，Agda将高兴地重新启动

（.true Relation.Nullary.cause Relation.Nullary.ofʸrefl）

as

yes refl

另一个是

no-p

---

关于目标的类型，它来自这样一个事实，即字符串的相等是通过字符列表上的逐点相等来获得的，而字符的相等是通过它们作为数字的基本表示的相等来获得的。这很冗长，但这给了我们一个被Agda认可为安全且相当有效的定义。

那么有没有任何可能的方法来避免扩展的定义，或者至少隐藏它？还有，你知道为什么在我有一个明显的自反性目标的情况下，在这个定义中，目标类型不再有效吗？我不这么认为。至于auto，不幸的是，它不再被维护，一旦您开始使用copatterns（在本例中，它依赖于stdlib中使用copatterns的部分），它就会简单地放弃，因为还没有人教它如何处理这些事情。