相关疑难解决方法(0)

难道不知道两个函数是否相同吗？例如,编译器编写者想要确定开发人员编写的两个函数是否执行相同的操作,可以使用哪些方法来确定那个函数？或者我们可以做些什么来找出两个TM是相同的？有没有办法规范机器？

编辑:如果一般情况是不可判定的,在正确地说两个函数是等价的之前,您需要多少信息？

monad是一种数学结构,大量用于(纯)函数式编程,基本上是Haskell.然而,还有许多其他数学结构可用,例如应用函子,强单子或幺半群.有些更具体,有些更通用.然而,monads更受欢迎.这是为什么？

我提出的一个解释是,它们是通用性和特异性之间的最佳点.这意味着monad捕获关于数据的足够假设,以应用我们通常使用的算法以及我们通常满足monadic定律的数据.

另一种解释可能是Haskell为monad(do-notation)提供了语法,但没有为其他结构提供语法,这意味着Haskell程序员(以及函数式编程研究人员)直观地被用于monad,其中更通用或特定(高效)的函数将也工作.

我正在通过Sipser 对计算理论介绍中的停止问题进行证明,我主要关注的是下面的证据:

如果TM M不知道它何时循环(它不能接受或拒绝这就是为什么TM对所有字符串都是图灵可识别的),那么决策者H怎么能决定M是否可能在循环中？当TM D进行处理时,同样的问题将继续存在.

我并没有深入根植于静态代码分析的正式方面,因此这个问题.

几年前,我读到使用静态代码分析区分代码和数据等同于暂停问题.(引用需要,但我不再拥有它了.Stackoverflow在这里或这里有线程.)至少对于基于冯诺依曼架构的常见计算机架构,其中代码和数据共享相同的内存,这似乎是有意义的.

现在我正在研究C/C++代码和指针分析的静态分析; 该程序不执行.不知怎的,我有一种感觉,静态跟踪指针值的所有创建和使用类似于停止问题,因为我无法确定内存中的给定值是否是指针值,即我无法通过指针值跟踪指针值的值记忆. 别名分析可能会缩小问题范围,但面对多线程代码似乎变得不那么有用了.

(人们甚至可以考虑跟踪任意值,而不仅仅是指针:为任何给定的"有趣"值构建一个完整的值流似乎等同于停止问题.)

由于这只是一种预感,我的问题是:我可以参考更正式的发现吗？我错了吗？

我试图理解静态分析和动态分析之间的差异,以便程序流程执行,检测安全漏洞.

很明显,动态分析的主要缺点是它无法探索程序可以进入的所有可能状态,因为它依赖于实际运行具有特定输入集的程序.

但是,静态分析似乎是所有可能的程序状态的原因,所以我无法想象静态分析可能会失败的情况,即使我确信这样的情况确实存在.我所看到的大多数参考文献似乎都模糊地说"抽象状态分析"并不像动态分析所能提供的那样精确,但这对我来说太过蓬松.

任何人都可以用静态分析失败的地方和需要动态分析的具体例子提供简单的解释吗？

虽然一般情况是不可判定的,但许多人仍然可以解决日常使用中相当不足的问题.

在科恩关于计算机病毒的博士论文中,他展示了病毒扫描如何与停止问题等效,但我们有一个完整的行业围绕着这一挑战.

我也见过微软的终结者项目 - http://research.microsoft.com/Terminator/

这让我想问一下 - 停止问题被高估 - 我们是否需要担心一般情况？

随着时间的推移,类型是否会变得完整 - 依赖类型似乎是一个很好的发展？

或者,从另一个角度来看,我们是否会开始使用非图灵完整语言来获得静态分析的好处？

从Code Complete 2引用,

int Factorial( int number ) {
   if ( number == 1 ) {
      return 1;
   }
   else {
      return number * Factorial( number - 1 );
   }
}

Run Code Online (Sandbox Code Playgroud)

除了慢^[1]并且使得 运行时内存不可预测^[2]之外,这个例程的递归版本比迭代版本更难理解,后面是:

int Factorial( int number ) {
   int intermediateResult = 1;
   for ( int factor = 2; factor <= number; factor++ ) {
      intermediateResult = intermediateResult * factor;
   }
   return intermediateResult;
}

Run Code Online (Sandbox Code Playgroud)

我认为缓慢的部分是因为不必要的函数调用开销.

但递归如何使运行时内存的使用变得不可预测？

难道我们不能总是预测需要多少内存(因为我们知道递归应该何时结束)？我认为这与迭代案例一样不可预测,但现在不再如此.

我有这个代码

isPrime x = x > 0 && filter divisible [1..x] == [1,x]
where divisible y = x `mod` y == 0

primes = filter isPrime [1..]

它定义了无限的素数列表.

所有这些案例都按预期工作:

*Main> take 10 primes
[2,3,5,7,11,13,17,19,23,29]

*Main> take 10 $ filter odd primes
[3,5,7,11,13,17,19,23,29,31]

然而

*Main> take 10 $ filter even primes
[2

挂起并且不会继续.我不知道为什么......我重新启动了ghci并且问题仍然存在.我正在使用ghc 8.0.1.

我的包裹:

C:\projects\littlethings\prime>ghc-pkg list
C:/Program Files/Haskell Platform/8.0.1\lib\package.conf.d
    Cabal-1.24.0.0
    GLURaw-2.0.0.1
    GLUT-2.7.0.7
    HTTP-4000.3.3
    HUnit-1.3.1.1
    ObjectName-1.1.0.1
    OpenGL-3.0.0.2
    OpenGLRaw-3.1.0.0
    QuickCheck-2.8.2
    StateVar-1.1.0.4
    Win32-2.3.1.1
    array-0.5.1.1
    async-2.1.0
    attoparsec-0.13.0.2
    base-4.9.0.0
    binary-0.8.3.0
    bytestring-0.10.8.1
    case-insensitive-1.2.0.6
    containers-0.5.7.1
    deepseq-1.4.2.0
    directory-1.2.6.2 …

谁可以给我解释一下这个？首先,我知道为什么这个代码

String getName(){
    for(;;){}
}

将违反return类型方法:它是无限的,但为什么这段代码需要最终的返回值？

String getName(){
    for(;i < limit; i++){// i is already defined
        if(someArrayList.get(i).isDead)
            continue;
        return someArrayList.get(i).name;
    }
    //needs a final return
}

返回值存在于循环内部并返回getName()方法的值,那么原因是什么？另一篇文章建议,如果循环对我的条件是负面的,那么我用这样重写:

String getName(){
    for(; i < 10; i++){// i is already defined
        if((i+1) == limit){
            if(!someArrayList.get(i).isDead)
                return "";
        }else{
            if(someArrayList.get(i).isDead)
                continue;
            return someArrayList.get(i).name;
        }
    }
    // needs a final return
}

相同的编译时错误,即使我i在for循环条件中重新定义0,所以我i变为零,如果内部条件检出否定我自己处理它.总而言之,如果我将它嵌套在无限循环中,那就没关系.

String getName(){
    for(;;){
        for(; i < limit; i++){// …