idris中列表的简单等式证明(证明xs ++ [x] = ys ++ [y] -> x=y -> xs = ys)
在idris中，列表的简单等式证明是指证明一个等式在特定条件下成立的过程。具体来说，我们要证明的等式是 xs ++ [x] = ys ++ [y]，并且已知 x=y 和 xs = ys。
首先，我们可以使用列表的归纳法来证明这个等式。归纳法是一种常用的证明方法，它通过证明基本情况和归纳步骤来推导出结论。
基本情况： 当 xs 和 ys 都为空列表时，即 xs = [] 且 ys = []，我们可以将等式 xs ++ [x] = ys ++ [y] 展开为 [] ++ [x] = [] ++ [y]，显然，这个等式成立，因为两边都等于 [x]。
归纳步骤： 假设等式 xs ++ [x] = ys ++ [y] 对于任意非空列表 xs 和 ys 都成立，即 xs = a::xs' 且 ys = b::ys' 时，有 a::xs' ++ [x] = b::ys' ++ [y]。
我们需要证明当 xs = a::xs' 且 ys = b::ys' 时，有 a::xs' ++ [x] = b::ys' ++ [y]。
根据等式 xs = ys，我们可以得到 a::xs' = b::ys'，进一步得到 a = b 和 xs' = ys'。
根据等式 x=y，我们可以得到 x = y。
将 a::xs' ++ [x] 和 b::ys' ++ [y] 展开，得到 a::(xs' ++ [x]) 和 b::(ys' ++ [y])。
根据归纳假设，我们知道 xs' ++ [x] = ys' ++ [y]，因此 a::(xs' ++ [x]) = b::(ys' ++ [y])。
由于 a = b 和 xs' = ys'，我们可以得到 a::(xs' ++ [x]) = b::(ys' ++ [y]) = a::(ys' ++ [y])。
根据列表的性质，如果两个列表的头部元素相等且尾部列表相等，则这两个列表相等。因此，我们可以得到 xs' ++ [x] = ys' ++ [y]，进一步得到 xs' = ys'。
综上所述，我们证明了当 xs = a::xs' 且 ys = b::ys' 时，有 a::xs' ++ [x] = b::ys' ++ [y]。
根据归纳法的原理，我们可以得出结论：对于任意非空列表 xs 和 ys，如果 xs ++ [x] = ys ++ [y]，且 x=y，则 xs = ys。
在云计算领域中，idris可以用于开发和验证云原生应用程序。云原生应用程序是一种基于容器化、微服务架构和自动化管理的应用程序，它具有高可伸缩性、高可用性和弹性等特点。
腾讯云提供了一系列与云计算相关的产品，例如云服务器、云数据库、云存储等。您可以通过访问腾讯云官方网站（https://cloud.tencent.com/）了解更多关于这些产品的详细信息。
相关·内容
1回答
Agda使用以下操作符显示集合之间的逆：
_↔_ : ∀ {f t} → Set f → Set t → Set _
在Idris中也有类似的吗？我试图在列表中定义包的相等性
data Elem : a -> List a -> Type where
Here : {xs : List a} -> Elem x (x :: xs)
There : {xs : List a} -> Elem x xs -> Elem x (y :: xs)
(~~) : List a -> List a -> Type
xs ~~ ys {a} = Elem
浏览 2提问于2014-12-03得票数 6
回答已采纳
1回答
import Data.Vect
import Data.Vect.Quantifiers
sameKeys : Vect n (lbl, Type) -> Vect n (lbl, Type) -> Type
sameKeys xs ys = All (uncurry (=)) (zip (map fst xs) (map fst ys))
g : {xs,ys : Vect n (lbl, Type)} -> sameKeys xs ys -> map (\b => fst b) xs = map (\b => fst b) ys
g {xs = [
浏览 1提问于2017-10-04得票数 3
回答已采纳
我正在学习Idris，我有一个新手的问题。
我正在做使用Idris进行类型驱动开发这本书的第8.3章的练习2。重点是为您自己的Vector实现DecEq。这就是我得到的结果：
data Vect : Nat -> Type -> Type where
Nil : Vect 0 elem
(::) : elem -> Vect n elem -> Vect (S n) elem
headUnequal : {xs : Vect n a} -> {ys : Vect n a} -> (contra : (x = y) -> Void) ->
浏览 6提问于2018-07-30得票数 2
回答已采纳
我正在学习idris，并且对证明列表的性质非常感兴趣。 如果你看一下standard library，就会发现“两个列表是相等的，如果它们的头是相等的，它们的尾是相等的”。 consCong2 : {x : a} -> {xs : List a} -> {y : b} -> {ys : List b} ->
x = y -> xs = ys -> x :: xs = y :: ys
consCong2 Refl Refl = Refl 我们也可以证明另一个方向 consCong2' : {x : a} -> {xs : List a} -&g
浏览 15提问于2019-09-12得票数 1
回答已采纳
1回答
我是新的依赖型，并有一个Haskell经验，正在慢慢学习Idris。作为一种努力，我想写一个赫夫曼编码。目前，我正试图编写一个证据，证明代码树的“扁平化”产生了前缀代码，但被量词卡住了。
我有一个简单的归纳命题，即一个列表是另一个列表的前缀：
using (xs : List a, ys : List a)
data Prefix : List a -> List a -> Type where
pEmpty : Prefix Nil ys
pNext : (x : a) -> Prefix xs ys -> Prefix (x
浏览 1提问于2014-12-02得票数 3
回答已采纳
使用附加的zipWith (如以下代码)，效果很好：
zipWith (\x,y => x + y) [1,2,3] [4,5,6]
但是，使用级联代替使用两个列表列表失败：
zipWith (\xs,ys => xs ++ ys) [[1],[2],[3]] [[4],[5],[6]]
有错误：
When checking argument x to constructor Prelude.List.:::
No such variable a
我注意到，可以不犯错误地做以下工作：
zipWith (++) [[1],[2],[3]] [[4],[5],[6]]
浏览 3提问于2016-01-13得票数 0
回答已采纳
下面的Idris证明没有打打字机。
hts : (s : Stream a) -> (head s :: tail s = s)
hts (x::xs) = Refl
我得到的错误是：
Type mismatch between
x :: Delay xs = x :: Delay xs
and
x :: Delay (tail (x :: Delay xs)) = x :: Delay xs
对于非空的Vect的打字机也有类似的证明：
import Data.Vect
htv : (s : Vect (S k) a) -&
浏览 3提问于2018-01-03得票数 6
我有以下几点：
elem :: Eq a => a -> [a] -> Bool
elem _ [] = False
elem x (y:ys) = x == y || elem x ys
我怎么证明x的y和z的..。
elem z (xs ++ ys) == elem z xs || elem z ys
我试着让左边和右边相当，但是我的努力都没有取得任何成果。
L.S elem z (x:xs ++ y:ys) = z==x || z==y || elem xs || elem ys
R.S elem z (x:xs) || elem z (y:ys) = z==x ||
浏览 1提问于2015-03-05得票数 2
回答已采纳
1回答
我正试图在Idris中实现，作为的一种可能的解决办法，但是，当我在MkReveal构造函数上进行模式匹配时，f的选择似乎丢失了，反而变成了一个自由参数。
首先，inspect的Idris端口
%default total
data Reveal : {a : Type} -> {b : a -> Type} -> (f : (x : a) -> b x) -> (x : a) -> (y : b x) -> Type where
MkReveal : {a : Type} -> {b : a -> Type} -> {f : (
浏览 2提问于2020-05-21得票数 0
回答已采纳
我想提出这样一个理由：“反向不改变列表中的值，所以这个语句是正确的。”
但我想知道我是否能用一个更完整的答案来证明这一点。
下面是我正在使用的定义：
reverse :: [a] -> [a]
reverse [] = []
reverse (x : xs) = reverse xs ++ [x]
sum :: Num a => [a] -> a
sum [] = 0
sum (x : xs) = x + sum xs
编辑：，所以我问我的教授，他告诉我用这个和定义
sum :: [Int] -> Int
sum [] = 0
sum (x : xs) = x +
浏览 4提问于2021-08-11得票数 1
我正在做Idris中9.1节中的练习2，我不知道如何填补最后一个漏洞(见下面的notInTail )。
我读过的答案，但我被困在了另一个地方。
data Last : List a -> a -> Type where
LastOne : Last [value] value
LastCons : (prf : Last xs value) -> Last (x :: xs) value
notInNil : Last [] value -> Void
notInNil LastOne impossible
notInNil (LastCons _
浏览 0提问于2019-05-14得票数 0
回答已采纳
我被Idris卡住了(再说一次，叹息)。我从第10章的类型驱动开发和Idris一书中做了一个关于合并排序的练习。
import Data.Vect
import Data.Vect.Views
sort2 : Ord a => (l: a) -> (r: a) -> (a, a)
sort2 l r = if l <= r then (l, r) else (r, l)
needHelp : Vect (S (S (n + m))) a -> Vect (S (plus n (S m))) a
needHelp {n=(S n)} {m=(S m)} (x
浏览 20提问于2018-08-20得票数 1
回答已采纳
2回答
用多个列表进行归纳证明
、、、、
我正在关注Scala课程的函数式编程，在视频5.7的末尾，Martin Odersky要求通过归纳来证明以下公式的正确性：
(xs ++ ys) map f = (xs map f) ++ (ys map f)
当涉及多个列表时，如何处理归纳证明？
我检查了xs为Nil和ys为Nil的基本情况。我已经通过归纳证明，当x被x::xs代替时，方程仍然成立，但是我们是否也需要用y::ys代替y来检查方程呢？
在这种情况下(在不破坏练习的情况下，much...which无论如何也不会被分级)，您如何处理：(xs ++ (y::ys)) map f？
这就是我在一个类似的例子中使用的方法，以证明
(xs
浏览 7提问于2015-05-22得票数 2
回答已采纳
2回答
使用Idris的类型驱动开发展示了这个练习：
same_cons : {xs : List a} -> {ys : List a} -> xs = ys -> x :: xs = x :: ys
但是，我尝试通过以下方式实现它：
data EqList : (xs : List a) -> (ys : List a) -> Type where
Same : (xs: List a) -> EqList xs xs
sameS : (xs : List a) -> (ys : List a) -> (x: a) -> (eq : E
浏览 0提问于2016-05-06得票数 0
1回答
我的任务是为seq数据类型实现一个相等类型的实例。为此，我需要创建一个比较函数，并证明此函数是正确的：
From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat div seq.
Set Implicit Arguments.
Unset Strict Implicit.
Unset Printing Implicit Defensive.
Fixpoint eq_seq {T: eqType} (x y: seq T) : bool :=
match x, y with
| [::],[::] =>
浏览 16提问于2019-11-01得票数 0
回答已采纳
我在锻炼。这里似乎有一件琐碎的事情要做(简化以显示问题显然存在于列表拆分中)：
infixr 4 _::_ _++_ _==_
data _==_ {A : Set} : (x : A) -> (y : A) -> Set where
refl : (x : A) -> x == x
data List (A : Set) : Set where
nil : List A
_::_ : A -> List A -> List A
_++_ : forall {A} -> List A -> List A
浏览 4提问于2014-01-06得票数 2
回答已采纳
我需要证明∀xs, ys mystery f xs ys = map f (zip xs ys)
我可以证明mystery f [] ys = map f (zip [] ys)是基本情况，mystery f (x:xs) (y:ys) = map f (zip (x:xs) (y:ys)是归纳吗？我对如何将y从ys中分离出来以便使用归纳假设感到困惑。
浏览 0提问于2020-02-22得票数 1
2回答
假设我们有一个函数merge，它只合并两个列表：
Order : Type -> Type
Order a = a -> a -> Bool
merge : (f : Order a) -> (xs : List a) -> (ys : List a) -> List a
merge f xs [] = xs
merge f [] ys = ys
merge f (x :: xs) (y :: ys) = case x `f` y of
True => x :: merge f
浏览 0提问于2018-05-01得票数 1
回答已采纳
我对Haskell很陌生，我想了解这个语法意味着什么。这是该职能的背景：
map' :: (a -> b) -> [a] -> [b]
map' f xs = foldr (\y ys -> (f y):ys) [] xs
它用foldr定义了序言中的map函数。我搞不懂foldr (\y ys -> (f y):ys) [] xs是什么意思。尤其是(\y ys -> (f y): ys)部分。
据我理解，y是列表ys中的第一个值，它是输入，而f函数正在应用于列表ys中的y值。我理解这些值是在模式匹配的上下文中获取的。如果我错了，请纠正我。
浏览 6提问于2022-12-01得票数 -1
我很难理解Haskell函数。我知道它表面上做什么，但我不确定它是如何实现这个功能的。
zip (x:xs) (y:ys) = (x,y) : zip xs ys
zip xs ys = [ ]
我的想法：
zip是函数的名称。
zip采用2个参数。(我认为跑步在这里并不重要)。
参数为(x:xs)和(y:ys)。
zip返回一个元组类型(x,y)的列表。
现在我不太明白参数
(x:xs) (y:ys)
冒号会在列表的开头附加一些内容(返回列表)，那么为什么我们要在要压缩的列表中添加一些内容呢？函数定义中的x和y是什么？
右边看起来很明显:我们将(0)元组(x，y)插
浏览 4提问于2015-08-02得票数 1
让我们考虑一个谓词，该谓词显示列表中的元素是按递增顺序排列的(为了简单起见，我们只处理非空列表)：
mutual
data Increasing : List a -> Type where
SingleIncreasing : (x : a) -> Increasing [x]
RecIncreasing : Ord a => (x : a) ->
(rest : Increasing xs) ->
(
浏览 0提问于2018-04-05得票数 1
回答已采纳
如何将一个列表分成两个子列表，其中第一个子列表从初始列表开始就包含元素，等于第一个元素，第二个子列表包含其他元素？我必须在不使用前奏函数的情况下解决这个问题。
我的基本解决办法是：
partSameElems :: [a] -> ([a],[a])
partSameElems [] = ([],[])
partSameElems (x:xs) = fstList (x:xs) scdList (x:xs)
where
fstList (x:y:xs) = if x == y then x:y:fstList xs {- I need to do Nothing
浏览 0提问于2014-02-21得票数 0
回答已采纳
我试图提出一个问题，这样只有重写才足以证明目标。我想避免使用“聪明”的命题，而是使用可以由Coq计算的bools。
我定义了一个布尔测试函数member，它返回一个元素在列表中的真当且仅当一个元素在列表中，而different在这两个列表中都没有返回任何元素。
我想证明我可以只使用different将member重写成表达式。
Theorem different_member: forall xs ys y,
different xs ys = ((negb (member y ys)) || negb (member y xs)).
( (negb X || Y)形式是布尔蕴涵)。
作
浏览 4提问于2015-10-24得票数 4
回答已采纳
cong和injective允许您将和不应用函数应用于相等：
cong : (f : a -> b) -> x = y -> f x = f y
injective : Injective f => f x = f y -> x = y
对于长度不同的索引向量，这两种方法都失败了，原因很明显。
如何证明两个相等的向量具有相同的长度？也就是说。
sameLen : {xs : Vect n a} -> {ys : Vect m b} -> xs = ys -> n = m
我不能就这么做
sameLen pf = cong length pf
因
浏览 0提问于2021-12-08得票数 1
这是的后续行动.Zipp是一个使用折叠的非递归、非模式匹配的zip实现.关于非类型化的lambda微积分，我们有：
-- foldr for church encoded lists (that is, folds)
foldr cons nil list = list cons nil
zipp_left = foldr (λ x xs cont -> (cont x xs)) (const [])
zipp_right = foldr (λ y ys x cont -> (cons (pair x y) (cont ys))) (const (const []))
zipp
浏览 4提问于2015-06-02得票数 4
回答已采纳
2回答
我有一个较小的Erlang函数，用于比较两个列表是否相等：
myEq([], []) -> true;
myEq([X|Xs], [X|Ys]) -> myEq(Xs, Ys);
myEq(_, _) -> false.
比较发生在第2行，X of [X|Xs]总是绑定到第一个列表的第一个元素，只有当两个列表的第一个元素相等时，[X|Ys]才匹配。
如果我在Haskell中尝试这一点，就会得到一条错误消息：“x的冲突定义”。在Haskell，一种可能的解决办法是：
myEq (x:xs) (y:ys) = if x == y then my
浏览 1提问于2017-02-20得票数 7
1回答
我试着进入Idris，试图将移植到Idris。我想我成功了，用这个代码..。
windowl : Nat -> List a -> List (List a)
windowl size = loop
where
loop xs = case List.splitAt size xs of
(ys, []) => if length ys == size then [ys] else []
(ys, _) => ys :: loop (drop 1 xs)
但是，当我在交互式idris中调用它时，似乎只对函数的第一个调用进行了计算，递归
浏览 5提问于2017-05-19得票数 4
回答已采纳
我在Idris中做了一些开发，我正在进入下面的问题。假设我们有三个向量：
xs : Vect len a
ys : Vect len a
zs : Vect len' a
说我们也有
samelen : len = len'
最后，我们还有以下几点：
xsys : xs = ys
yszs : ys = zs
在第一个等式中，我们对类型Vect len有一个等式，而对于Vect len‘a，我们有一个等式。现在，我们要建立：
xsza : xs = zs
我一直很难做好这件事。特别是，反式需要相同类型之间的平等，但这里不是这样的。这里如何使用传递性来实现xsza？
浏览 0提问于2019-04-18得票数 3
回答已采纳
1回答
我有一个在列表上匹配的函数：
fun merge where
‹merge [] [] = []› |
‹merge (v#vs) [] = (v#vs)› |
‹merge [] (v#vs) = (v#vs)› |
‹merge (x#xs) (y#ys) =
(if x < y then x # merge xs (y#ys) else y # merge (x#xs) ys)›
当我试图证明这一点的正确性时，我很难从以下几个方面进行归纳：
...
lemma sorted_merge:
assumes s_xs: "sorted(xs)
浏览 3提问于2020-11-17得票数 1
回答已采纳
2回答
几天来，我一直在面对一个问题，但我的Agda技能并不很强。
我试图在索引数据类型上编写一个函数，它只在特定的索引上定义。这仅适用于数据构造函数的某些特定特性。我不知道如何定义这样的函数。我试图把我的问题简化成一个较小的例子。
该设置涉及自然数列表，其中包含用于见证列表成员的类型，以及用于删除列表成员的函数。
open import Data.Nat
open import Relation.Binary.Core
data List : Set where
nil : List
_::_ : (x : ℕ) -> (xs : List) -> List
-- mem
浏览 5提问于2014-11-20得票数 7
回答已采纳
1回答
我试图实现以下几点：
headEqual : DecEq a => (x : a) -> (y : a) -> Maybe (Dec (x = y))
headEqual x y = case decEq x y of
Yes Refl => Just (Yes Refl)
No contra => Nothing
vectEqual : DecEq a => (xs : Vect n a) -> (ys : Vect n a) -> Maybe (Dec (xs = y
浏览 4提问于2017-04-04得票数 1
回答已采纳
我有以下定义
Inductive subseq : list nat -> list nat -> Prop :=
| empty_subseq : subseq [] []
| add_right : forall y xs ys, subseq xs ys -> subseq xs (y::ys)
| add_both : forall x y xs ys, subseq xs ys -> subseq (x::xs) (y::ys)
.
利用这个，我想证明下面的引理
Lemma del_l_preserves_subseq : forall x xs ys, su
浏览 0提问于2019-01-26得票数 4
回答已采纳
4回答
我在阅读RWH时失败了；没有人可以放弃，我命令Haskell:函数式编程的工艺。现在我对146页的这些功能证明很好奇。具体来说，我试图证明8.5.1 sum (reverse xs) = sum xs。我可以做一些归纳证明，但后来我被困住了..
海普：
sum ( reverse xs ) = sum xs
基地：
sum ( reverse [] ) = sum []
Left = sum ( [] ) (reverse.1)
= 0 (sum.1)
Right = 0 (sum.1)
上岗：
sum ( reverse (x:xs) )
浏览 11提问于2010-07-15得票数 21
回答已采纳
2回答
我有两个整数列表。我需要使用递归获得两个列表的公共元素。例如：
intersect [1, 2, 4, 6] [5, 4, 2, 5, 7] == [2, 4] (or [4, 2]!)
intersect [1, 2, 4, 6] [3, 5, 7] == []
我是用两种功能做的。
inlist :: Integer -> [Integer] -> Bool
inlist _ [] = False
inlist x (y:ys) | x==y = True
| otherwise = inlist x ys
intersect :: [I
浏览 3提问于2021-05-26得票数 0
回答已采纳
我跟随着惊人的TDDwI，写了一个简单的removeElem。
关于它的四个问题：
为什么我可以为相同的模式编写3个声明？
absurd和impossible有什么区别？
在返回[]的第三种情况下，[]是一个值，因此.证明xs有一个a要移除，而且确实.对吗？
如果我把它们全部删除，函数仍然是完全的，而且我有一种莫名其妙的痒感，奇怪的事情正在发生。？。(我想这是个问题)
removeElem : (value : a)
-> (xs : Vect (S n) a)
-> (prf : Elem value xs)
浏览 6提问于2017-10-04得票数 4
回答已采纳
我有第一个列表和第二个列表，我想编写一个函数，它接受两个列表，并返回一个列表，其中只包含第二个列表中没有出现在第一个列表中的元素。我不想使用内置功能。例如：
> removeAll [1..3] [0..10]
[0,4,5,6,7,8,9,10]
> removeAll "aeiou" "supercalifragilisticexpialidocious"
"sprclfrglstcxpldcs"
removeAll _ [] = []
removeAll [] y = y
removeAll (x:xs) (y:ys)
浏览 2提问于2018-11-22得票数 0
回答已采纳
我尝试连接两个列表，以便结果列表中的元素只发生一次。我不想使用预定义的函数，因为那样做太容易了。因此，由于我正在学习haskell，所以我编写了以下代码：
import Data.List
add :: [Int] -> [Int] -> [Int]
add xs ys = zs ++ ws
where
zs = if elem x (x:xs) == True then x:(elem x xs)
else elem x xs
ws = if elem y (y:ys) == True then y:(
浏览 2提问于2014-04-22得票数 1
我想把一个向量划分成两个新的向量。
我们不能知道单个向量的长度，但是结果向量的和必须等于参数。我试图按以下方式捕获此属性：
partition : (a -> Bool) -> Vect (m+n) a -> (Vect m a, Vect n a)
partition p [] = ([], [])
partition p (x::xs)
= let (ys,zs) = partition p xs
in case p xs of
True => (x::ys, zs)
False => (ys, zs)
但是Idris报告(指向“分区
浏览 5提问于2014-05-05得票数 5
回答已采纳
1回答
我试图在Lean中证明，如果一项小于排序列表的头部，则它不是列表的成员。
theorem not_in_greater {α: Type} [d: decidable_linear_order α] {x h: α} (t: list α) (Hs: is_sorted (h::t)) (Hlt: x < h) : x ∉ (h::t) :=
match t with
| [] := not_eq_not_in (ne_of_lt Hlt)
| (y::ys) :=
have x_neq_h: x ≠ h, from ne_of_lt Hlt,
have
浏览 15提问于2017-07-05得票数 2
回答已采纳
1回答
在上下文中使用等价性来减少力
、、、、
此问题的设置与此中的“排序列表合并”示例相同。
{-# OPTIONS --sized-types #-}
open import Relation.Binary
open import Relation.Binary.PropositionalEquality as P hiding (trans)
module ListMerge
{ ℓ}
(A : Set )
{_<_ : Rel A ℓ}
(isStrictTotalOrder : IsStrictTotalOrder _≡_ _<_) where
open import Data.Pr
浏览 0提问于2014-02-11得票数 3
回答已采纳
我想知道什么是最好的方法来处理清单-理解或笛卡儿产品在Agda是。
我有两个向量，xs和ys。我要(非正式)集合{(x，y) \x在xs中，y在ys }中。
我可以很容易地使用map和concat来形成这个集合：
allPairs : {A : Set} -> {m n : ℕ} -> Vec A m -> Vec A n -> Vec (A × A) (m * n)
allPairs xs ys = Data.Vec.concat (Data.Vec.map (λ x -> Data.Vec.map (λ y -> (x , y) ) ys ) xs
浏览 3提问于2015-07-13得票数 4
回答已采纳
2回答
在学习了命题和谓词逻辑之后，我继续学习Prolog。
我想知道是否有人能为我澄清语法，因为我阅读它有困难。
我能很容易地读到下面这样的内容。所以它是说
如果X是Y的子代，则X是Y的下降。
然后它接着说
X是Y的下降，如果X是Z的子，Z是Y的下降。
descend(X,Y) :-
child(X,Y).
descend(X,Y) :-
child(X,Z),
descend(Z,Y).
但是，一旦我开始研究列表编程，我就很难读到谓词的语法。例如，以下内容
remove([], _, []).
remove([X | Xs], X, Ys) :- remove(X
浏览 2提问于2016-04-24得票数 7
回答已采纳
1回答
我需要用SWI-Prolog编写我自己的all_different版本。我已经编写了一个谓词，它对我给出的输入返回与all_different相同的true/false，但是我在网上找不到一种将这个谓词作为约束实际应用的方法。这是我的all_different版本。
distinct([]).
distinct([X|Xs]) :-
different(X,Xs),
distinct(Xs).
different(_,[]).
different(X,[Y|Ys]) :-
(nonvar(X), nonvar(Y) -> X \= Y
;
true
),
浏览 1提问于2012-04-29得票数 0
回答已采纳
我想要做一个函数，它从对的列表中返回从每对中的乘元素列表。例如：
>product [1,2] [3,4]
[3,8]
我想用list comprehension来做这件事。我试过这样的方法：
product :: Num a => [a] -> [a] -> [a]
product xs ys = [x*y | z<-zip xs ys, (x, _)<-z, (_, y)<-z]
但这不管用。应该改变什么？
浏览 3提问于2015-05-19得票数 2
回答已采纳
我仍然在努力更好地理解Haskell中的列表和元组，我遇到了一个我似乎无法理解的问题。
我有一种类型的乐趣：
func :: [String] -> [(String,String)] -> Bool
在这里，我试图查看字符串列表中的每个值是否都存在于字符串元组列表中。
例如，输入和输出，假设我调用func ["Thomas","Jeff"] [("Thomas", "22"), ("Jeff", "16")] ，它应该返回真正的
然而，如果我尝试func ["Brian
浏览 4提问于2021-10-15得票数 1
2回答
这来源于“Haskell”一书中的“基本原则”中的练习。练习是为Applicative实现ZipList'，这类似于前奏曲的ZipList。这本书有这样的暗示
检查预存功能，这些函数可以满足您的需要。一个以字母z开头，另一个以字母r开头。您正在从这些函数中寻找灵感，而不能直接重用它们，因为您使用的是自定义List类型，而不是Prelude提供的列表类型。
我猜想以z开头的函数是zipWith，但我不知道以r开头的函数。
data List a =
Nil
| Cons a (List a)
deriving (Eq, Show)
zipWith' :: (a
浏览 1提问于2019-10-28得票数 3
回答已采纳
1回答
考虑以下代码： type CFunctor f = forall x y. (x -> y -> Constraint) -> f x -> f y -> Constraint
type MapList :: CFunctor []
class MapList c xs ys
instance MapList c '[] '[]
instance (c x y, MapList c xs ys) => MapList c (x ': xs) (y ': ys) 这可以很好地工作，但在某些情况下，通过引入表单的函数依赖来“计
浏览 13提问于2020-12-31得票数 8
回答已采纳
1回答
继我的另一个之后，我尝试在中实现same_cons的实际练习，以证明在给定两个相同的列表时，在每个列表中加上相同的元素会导致两个相同的列表。
示例：
prove that 1 :: [1,2,3] == 1 :: [1,2,3]
所以我想出了下面的代码来编译：
sameS : {xs : List a} -> {ys : List a} -> (x: a) -> xs = ys -> x :: xs = x :: ys
sameS {xs} {ys} x prf = cong prf
same_cons : {xs : List a} -> {ys : List
浏览 3提问于2016-05-07得票数 0
回答已采纳
1回答
Haskell右侧递归到左侧递归
、、、、
在我的问题中，我有列表列表，我想找到列表的选择器列表(选择器列表包含每个列表中的一个元素)，满足特殊条件。
生成所有选择器的代码如下所示：
selectors :: [[a]] -> [[a]]
selectors [] = [[]]
selectors (y:ys) = [ (x:xs) | x <- y, xs <- selectors ys]
如果我想增加一些额外的条件，这就像
selectors :: [[a]] -> ([a] -> Bool) -> [[a]]
selectors [] _ = [[]]
selectors (y:ys) f =
浏览 4提问于2014-05-24得票数 1
回答已采纳
1回答
我正在编写一个递归函数，它使用特定的公式计算两个列表。但是，我将简化函数，以便您能够理解我遇到的问题，因为这里的重点是检测列表的[]。
因此，我有以下代码：
listSum::([Integer],[Integer])->Double
listSum ((x:xs),(y:ys))
| ((x:xs),(y:ys))==(x:[],y:[])=0.0
| otherwise = (((fromIntegral x)::Double)+((fromIntegral y)::Double)) + listSum ((xs),(ys))
我现在的输出
listSum([1,2
浏览 2提问于2015-02-21得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
