精华内容
下载资源
问答
  • 主析取范式

    2021-06-22 20:46:09
    定义:对于给定的命题公式A(P1,P2,P3,……,Pn),如果有一个仅由最小项的析取构成的等值式称为原命题公式的主析取范式。 定理:任意含n个命题变元的非永假式,其主析取范式是惟一的。 证明:(反证法) 假设非...

    定义:对于给定的命题公式A(P1,P2,P3,……,Pn),如果有一个仅由最小项的析取构成的等值式称为原命题公式的主析取范式。
    定理:任意含n个命题变元的非永假式,其主析取范式是惟一的。
    证明:(反证法)
    假设非永假式A(P1,P2,P3,……,Pn)有两个不同的主析取范式A1和A2则A<=>A1,A<=>A2,故A1<=>A2,由于A1和A2是两个不同的主析取范式故,至少存在一最小项mi,是mi只存在于A1和A2两者之一中,不妨设mi在A1中,而不再A2中。设mi在A1中有一组成真指派R,于是在R指派下,主析取范式A1为真,但在R指派情况下,主析取范式A2为假,这与A1 <=>A2相矛盾。
    ——证毕

    展开全文
  • 研究生人工智能课的作业,主合取范式转主析取范式,敲了四五个小时,亲测可用,python版本的,用anaconda可直接运行,注释详细,要的自取
  • 通过代码编译出的程序帮助用户求出其输入的命题公式的真值表以及主析取范式和主合取范式。 要求:能够列出含三个以内变量的合式公式的真值表,并给出相应的主析取和主合取范式。
  • 主析取范式与主合取范式

    万次阅读 多人点赞 2019-04-08 02:27:36
    主析取范式与主合取范式 定义设A为恰含命题变元p1,…,pn的公式。公式A'称为A的主析(合)取范式(majordisjunctive(conjunctive)normal form),如果A'是A的析(合)取范式,并且其每个合(析)取子句中p1,…,...

    主析取范式与主合取范式

     

    定义    设A为恰含命题变元p1,…,pn的公式。公式A'称为A主析(合)取范式(majordisjunctive(conjunctive)normal form),如果A'是A的析(合)取范式,并且其每个合(析)取子句中p1,…,pn均恰出现一次。

    据定义,例1.21中公式┐p→┐(p→q)的主析取范式是(p∧q)∨(p∧┐q),而其主合取范式则应是(p∨q)∧(p∨┐q)。

         例1  求公式(p∧q)∨r的主析取范式及主合取范式。

        (p∧q)∨r

         (p∧q∧(r∨┐r))∨((p∨┐p)∧(q∨┐q)∧r)

         (p∧q∧r)∨(p∧q∧┐r)∨(p∧q∧r)∨(p∧┐q∧r)∨(┐p∧q∧r)∨(┐p∧┐q∧r)

         (p∧q∧r)∨(p∧q∧┐r)∨(p∧┐q∧r)∨(┐p∧q∧r)∨(┐p∧┐q∧r)

        此即所求的主析取范式。另外

    (p∧q)∨r

    (p∨r)∧(q∨r)

    (p∨(q∧┐q)∨r)∧((p∧┐p)∨q∨r)

    (p∨q∨r)∧(p∨┐q∨r)∧(p∨q∨r)∧(┐p∨q∨r)

    (p∨q∨r)∧(p∨┐q∨r)∧(┐p∨q∨r)

    最后一式即为所求的主合取范式。

    **** 我们总结一下利用等价推演求公式的主析(合)取范式的方法步骤:

    第一步:求出该公式的析(合)取范式;

    第二步:简化各子句.除去范式中所有恒假(真)的合(析)取子句,即化掉含有互补文字对的合(析)取子句;将合(析)取子句中同一命题变元的多个出现合并为一个;

    第三步:对析(合)取范式中合(析)取子句不是每一变元都出现的,利用pp∧tp∧(q∨┐q)或pp∨fp∨ (q∧┐q)把未出现的变元补进来,并用分配律将其展开,最后得到给定公式的主析(合)取范式。

    现在我们要讨论指派与两种范式之间的联系。

    很明白,要使主析取范式取值1,只要使其一个合取子句取值1,从而须使这一子句中的每个文字都取值1,即令正文字中命题变元取值1,而令负文字中命题变元取值0。换言之,由主析取范式的一个合取子句可确定一个弄真原公式的指派;反之,亦可由弄真原公式的一个指派确定其主析取范式中的一个合取子句。弄真公式的指派与主析取范式的合取子句是一一对应的。例如,例1.23中公式的主析取范式有五个合取子句,它们分别对应于5个弄真公式的指派:

            p∧q∧r                1,1,1

                p∧q∧┐r              1,1,0

                p∧┐q∧r              1,0,1

                ┐p∧q∧r              0,1,1

                ┐p∧┐q∧r            0,0,1

        类似地,要使主合取范式取值0,只要使其一个析取子句取值0,从而须使析取子句中的每一文字取值0,即令正文字中命题变元取值0,而令负文字中命题变元取值1。换言之,由主合取范式的一个析取子句可确定一个弄假原公式的指派;反之,亦可由弄假原公式的一个指派确定其主合取范式中的一个析取子句。弄假公式的指派与主合取范式的析取子句是一一对应的,只是对应方式刚好相反,正文字对应0,负文字都对应1。例如,例1.23中公式的三个析取子句,如下对应于三个弄假指派:

    p∨q∨r                0,0,0

                p∨┐q∨r              0,1,0

                ┐p∨q∨r              1,0,0

        由以上分析,我们可以进一步得到下述结论:

        (1)每公式的主析取范式和主合取范式都是唯一确定的,因为任一公式的弄真指派及弄假指派是完全确定的。

        (2)永真式,例如p∨┐p,没有主合取范式,因为它没有弄假指派。永真式只有主析取范式,它包含所有可能的合取子句(p∨┐p的主析取范式为其自身),因为一切指派均弄真它。为讨论方便,约定永真式的主合取范式为t。

        (3)永假式,例如p∧┐p,没有主析取范式,因为它没有弄真指派。永假式只有主合取范式,它包含所有可能的析取子句(p∧┐p的主合取范式为自身),因为一切指派均弄假它。为讨论方便,约定永假式的主析取范式为f。

    (4)n个命题变元的主析取范式及主合取范式都有 个,因为不同的合取子句及析取子句都是 个,而两种主范式都是从 个子句中取若干个(0,1,…, 个)子句组成的(取0个子句组成t或f)。我们知道 + + … + = 。从真值表的角度看也是如此。一张真值表(确定了弄真指派和弄假指派)恰对应一个主析(合)取范式。因此,n个变元的真值表有多少种,便相应地有多少n个变元的主析(合)取范式。事实上,n个变元的真值表必有 行,对应于 个可能的指派,而最后一列的每一行有0,1两个可能的值,因而这一列可能的取值状况有 种,从而生成 张不同的真值表。

    (5)由于每一公式均有主析(合)取范式,因此,无限多的含n个变元的公式可以分作 (有限)个类,这一类公式都逻辑等价于它们共同的主析(合)取范式。

    展开全文
  • 满意答案zxuu112013.09.15采纳率:44%等级:8已帮助:2365人//从键盘上任意输入一个主析取范式,输出与之等值的主合取范式。┐∧∨# include # include # include using namespace std ;//跳出函数bool jump(const ...

    满意答案

    02ae427d08e371d7e90d5b995e828d6d.png

    zxuu11

    2013.09.15

    02ae427d08e371d7e90d5b995e828d6d.png

    采纳率:44%    等级:8

    已帮助:2365人

    //从键盘上任意输入一个主析取范式,输出与之等值的主合取范式。┐∧∨

    # include

    # include

    # include

    using namespace std ;

    //跳出函数

    bool jump(const char ch){

    char c = cin.peek() ;

    if (ch == ')' && c != '+' && c != '*')

    return 1 ;

    return 0 ;

    }

    //将字母转化为二进制

    int change(char ch){

    int k = ch-97 ;

    return pow(2,k) ;

    }

    //将转化后的和取公式输出

    void output(int k, int n , int left){

    char ch = 96;

    int i ;

    cout << '(' ;

    for (i=0 ; i

    ch++ ;

    switch (k%2){

    case 1:

    cout << ch << '*' ;

    k/=2 ;

    break ;

    case 0 :

    cout << '!' << ch << '*' ;

    k/=2 ;

    break ;

    }

    }

    if (left == 0)

    cout << '\b' << ')' ;

    else

    cout << '\b' << ')' << '+' ;

    }

    //公式输入 and 公式输出....

    void funtion(){

    cout << "输入变量数:" ;

    int var_n=0 , k ;

    cin >> var_n ;

    if (var_n>26 || var_n<1){

    cout << "enter error!" << endl ;

    MessageBox(NULL, "输入错误!", "error", MB_OK);

    exit (0) ;

    }

    k = pow(2, var_n) ;

    int *p = new int[k] ;

    for (int i=0; i

    p[i] = 0 ;

    char ch ;

    int num = 1 , count = 0 ;

    cout << "----------------------------------------------------" << endl ;

    cout << "输入析取公式: " ;

    while (1){

    cin >> ch ;

    if(jump(ch))

    break ;

    if (ch == '*'){

    p[count] = 1 ;

    num++ ;

    count = 0 ;

    cin >> ch ;

    }

    if (ch == '(' || ch == ')' || ch == '+')

    cin >> ch ;

    if (ch == '!')

    cin >> ch >> ch;

    if(jump(ch))

    break ;

    if (ch != '*' && ch != '!' && ch != '(' && ch != ')' && ch != '+'){

    count += change(ch) ;

    }

    if (ch == '*'){

    p[count] = 1 ;

    num++ ;

    count = 0 ;

    cin >> ch ;

    }

    }

    p[count] = 1 ;

    cout << "变项数有: " << num << endl ;

    cout << "----------------------------------------------------" << endl ;

    cout << "和取公式:" ;

    int left ;

    left = k - num ;

    for (i=0 ; i

    if (p[i] == 0){

    left-- ;

    output(i, var_n, left) ;

    }

    cout << "\n变项数有:" << k - num << endl ;

    cout << "\n----------------------------------------------------" << endl ;

    }

    main(){

    funtion();

    return 0 ;

    }

    00分享举报

    展开全文
  • 南京邮电大学实验一真值表法求主析取范式和主合取范式代码 离散数学 实 验 一利用真值表法求取主析取范式以及主合取范式的实现 实验名称:利用真值表法求取主析取范式以及主合取范式的实现 实验目的:通过编程实现...
  • 关于离散数学中主合取与主析取范式的实现,主要通过c++实现
  • 离散主析取范式算法

    2012-12-30 15:31:34
    自动省城某命题的主析取范式,通过用JAVA来实现这个目的。
  • 编程析取范式求主析取范式。。

    千次阅读 2014-11-03 10:43:47
     ...离散数学中析取范式如何通过计算机求主析取范式。其中一种办法就是用二维数组存储析取范式的真值表,然后代入命题公式,真值为T,就是它的最小项。其中会用到栈这种数据结构判断优先级。。
    
    离散数学中析取范式如何通过计算机求主析取范式。其中一种办法就是用二维数组存储析取范式的真值表,然后代入命题公式,真值为T,就是它的最小项。其中会用到栈这种数据结构判断优先级。。
    #include<iostream>
    #include <cstdio>  
    #include <cstdlib>
    #include <string>
    using namespace std;
    template<class T>
    class stack
    {
    private:
    	int top;
    	T *atr;
    	int maxize;
    public:
    	stack(int size=0);
    	~stack();
    	bool IsFull();
    	bool IsEmpty();
    	void pop(T &item);
    	void push(T &item);
    	void clear();
    	void GetTop(T &item);
    };
    class calculator
    {
    private:
    	int number;
    	int iN;
    	string thz;
    	char* min;
    	int **p;
    	string st1;
    public:
    	calculator();
    	~calculator();
    	void TheMin();
    	void show();
    };
    template<class T>
    stack<T>::stack(int size=0)
    {
    	maxize = size;
    	atr = new T[maxize];
    	top = -1;
    }
    template<class T>
    stack<T>::~stack()
    {
    	delete[]atr;
    }
    template<class T>
    bool stack<T>::IsFull()
    {
    	return top ==maxize - 1;
    }
    template<class T>
    bool stack<T>::IsEmpty()
    {
    	return top== -1;
    }
    template<class T>
    void stack<T>::clear()
    {
    	top == -1;
    }
    template<class T>
    void stack<T>::pop(T &item)
    {
    	item = atr[top--];
    }
    template<class T>
    void stack<T>::push(T &item)
    {
    	atr[++top] = item;
    }
    template<class T>
    void stack<T>::GetTop(T &item)
    {
    	item = atr[top];
    }
    calculator::calculator()
    {
    	char p[100], c = '\0',a='\0';
    	stack <char> s(10);
    	int i = 0;
    	number = 0;
    	cout << "输入*表示合取,+表示析取,!表示非,记得输入大写字母的命题变员" << endl;
    	while (1)
    	{
    		c = getchar();
    		if (c == '\n')
    			break;
    		p[i++] = c;
    	}
    	
    	for (int j = 0; j < i; j++)
    	{
    		if (p[j] >= 'A'&&p[j] <= 'Z')
    		{
    			thz += p[j];
    			int k = 0;
    			for (;st1[k];k++)
    			{
    				if (p[j] == st1[k])
    					break;
    			}
    			if (!st1[k])
    			{
    				st1 += p[j];
    				number++;
    			}
    		}
    		else if (p[j] == '+' || p[j] == '*' || p[j] == '!'||p[j]=='(')
    		{
    			s.GetTop(c);
    			if (s.IsEmpty()||p[j]=='!'||p[j] == '(')
    			{
    				s.push(p[j]);
    			}
    			else if (p[j] == '*'&&(c=='*'||c=='!'))
    			{
    				s.pop(a);
    				thz += a;
    				s.push(p[j]);
    			}
    			else if (p[j] == '+'&&!s.IsEmpty() && c != '(')
    			{
    				s.pop(a);
    				thz += a;
    				s.push(p[j]);
    			}
    			else if (c == '(')
    				s.push(p[j]);
    		}
    		else if (p[j] == ')')
    		{
    			if (!s.IsEmpty())
    			{
    				while (!s.IsEmpty())
    				{
    					s.pop(a);
    					if (a == '(')
    						break;
    					thz += a;
    				}
    				if (a != '(')
    				{
    					cout << "能不能输入正确呀!" << endl;
    					return ;
    				}
    			}
    			else
    			{
    				cout << "哈哈哈,你又错了!" << endl;
    				return;
    			}
    		}
    	}
    	while (!s.IsEmpty())
    	{
    		s.pop(a);
    		thz += a;
    		
    	}
    }
    calculator::~calculator()
    {    
    	
    	for (int i = 0; i < iN; i++)
    	{
    		delete[]p[i];
    	}
    	delete []p;
    }
    void calculator::TheMin()
    {
    	stack<int> s1(20);
    	min = new char[100];
    	int a, b,c=0,d=1,t=0;
    	iN = pow(2, number);
    	int count = number;
    	p = new int*[iN];
    	for (int i = 0; i < iN; i++)
    	{
    		p[i] =new int[number];
    
    	}
    	for (int i = 0; i < iN; i++)
    	{
    		for (int j = count - 1, k = i; j >= 0; j--)
    		{
    
    			p[i][j] = k % 2;
    			k = k / 2;
    		}
    	}
    	int k = 0;
    	for (; k<iN; k++)
    	{
    		for (int j = 0;thz[j]; j++)
    		{
    			if (thz[j] >= 'A'&&thz[j] <= 'Z')
    			{
    				int e = 0;
    				for (; st1[e]; e++)
    				{
    					if (thz[j] == st1[e])
    						break;
    				}
    				s1.push(p[k][e]);
    			}
    			else if (thz[j] == '!')
    			{
    				s1.pop(a);
    				if (a == 1)
    					s1.push(c);
    				else
    					s1.push(d);
    			}
    			else if (thz[j]=='*')
    			{
    				s1.pop(a);
    				s1.pop(b);
    				if (a == 1 && b == 1)
    					s1.push(d);
    				else
    					s1.push(c);
    			}
    			else
    			{
    				s1.pop(a);
    				s1.pop(b);
    				if (a == 0 && b == 0)
    					s1.push(c);
    				else
    					s1.push(d);
    			}
    		}
            s1.pop(a);
    		if (a == 1)
    		{
    			for (int f = 0; f < number; f++)
    				{
    					if (p[k][f] == 0)
    					{
    						min[t++]= '!';
    						min[t++]= st1[f];
    					}
    					if (p[k][f] == 1)
    						min[t++]= st1[f];
    					if (f != number - 1)
    						min [t++]= '*';
    				}
    				min[t++]= '+';
    	}
    }
    	min[t] = '\0';
    	for (int i = 0; i<t-1; i++)
    	{
    		cout << min[i];
    	}
    }
    int main()
    {
    	calculator c;
    	c.TheMin();
    }

    展开全文
  • C# 主析取范式求解工具,对于输入的表达式,可以快速地得出其极小项
  • 据定义,公式┐p→┐(p→q)的主析取范式是(p∧q)∨(p∧┐q),而其主合取范式则应是(p∨q)∧(p∨┐q)。 例 求公式(p∧q)∨r的主析取范式及主合取范式。 (p∧q)∨r (p∧q∧(r∨┐r))∨((p∨┐p)∧(q∨┐q)∧r) (p∧q∧...
  • 离散数学中的主析取范式,及其应用!
  • 编程实现求解逻辑表达式的真值表、主析取范式、主合取范式对于一个含n个命题变元的表达式(n为相异的命题变元总个数),其真值表可看作由从0到2ⁿ-1的二进制数的变化表。因此,可以通过按行列举0到2ⁿ-1的二进制数来...
  • C语言实现主析取范式 第一次写,不喜勿喷 (先来水一波) 先保证输入的式子是合法的 (不合法我也不会,太弱了) 难点主要是计算真值表,可以用堆栈实现,建立两个堆栈,一个储存操作符,另一个储存数值 (手写堆栈) ...
  • 主析取范式 对任意一个命题公式来说,主析取范式与主合取范式都是唯一的。 命题变元指原子化的,P,Q命题。 极小项的定义:包含全部N个命题变元的合取式,称其为极小项,且N个命题变元中,每个变元与它的否定不能...
  • 主析取范式和主合取范式的c++求解程序

    千次阅读 多人点赞 2019-10-27 19:40:14
    主要思想是:先求真值表,再根据真值表输出主析取范式和主合取范式。 用!来表示非,用小写v表示析取,用^来表示合取,用~来表示双条件,用-来表示条件,用大写字母来表示命题变元。 真值表的求...
  • 真值表及主析取范式

    2011-10-26 20:29:51
    用MFC编写的具有界面的离散数学真值表及主析取范式,主和取范式求解程序!
  • 主析取范式与主合取范式原理探究

    千次阅读 2021-03-24 09:01:46
    主析取范式 对任意一个命题公式来说,主析取范式与主合取范式都是唯一的。 命题变元指原子化的,P,Q命题。 极小项的定义:包含全部N个命题变元的合取式,称其为极小项,且N个命题变元中,每个变元与它的否定不能...
  • 主析取范式和主合取范式

    千次阅读 2021-04-06 15:31:04
    主析取范式 小项 是n个命题变元的合取式,其中每个变元必出现且仅出现一次(以本身或否定形式),称这个合取式为小项 例:含有两个变元的小项 P ^ Q , P ^ !Q , !P ^ Q , !P ^ !Q 若有n个变元,则有2的n次方个小项 ...
  • 离散数学主析取范式及主合取范式

    万次阅读 多人点赞 2018-03-28 19:28:21
    今天总结了一下关于离散数学化简主析取范式以及主合取范式的一些方法。首先一般可能会用到 分配律: A∨(B∧C)&lt;=&gt;(A∨B)∧(A∨C), A∧(B∨C)&lt;=&gt;(A∧B)∨(A∧C);其次若化简式里有蕴涵...
  • 构造主析取范式(离散数学)

    千次阅读 2019-06-11 09:12:58
    构造主析取范式 先上图。。。 主界面: 真值表: 主析取范式
  • 编程实现用真值表法求取任意数量变量的合式公式的主析取范式和主合取范式。 要求: 能够列出任意合式公式的真值表并给出相应主析取和主合取范式。 内容: 编程实现用真值表法求取任意数量变量的合式公式的主析取...
  • 范式包含析取范式和合取范式,而主析取范式和主合取范式的求解也是命题逻辑的重要内容,小项和大项也是必须掌握的内容。
  • 关于自动生成真值表/主析取范式/主合取范式的计算器 我用c++写了一个,需要的自取,如果好用请点赞 链接:https://pan.baidu.com/s/1Ji1zPDtjAc6-TDxovEzMVw 密码:8jmv 源码在下面,写了一整天,转的麻烦标明...
  • 公式的主析取范式和主合取范式,输出形式为:“ mi ∨ mj ; Mi ∧ Mj” ,极小项和 ∨ 符号之间有一个空格,极大项和 ∧ 符号之间有一个空格;主析取范式和主合取范式之间用“ ; ”隔开,“ ; ”前后各有一个空格。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,325
精华内容 530
关键字:

主析取范式