Coppersmith method - Revision history

en>Yobot: Tagging using AWB (10703)

2015-01-07T09:12:35Z

Tagging using AWB (10703)

← Older revision		Revision as of 11:12, 7 January 2015
Line 1:		Line 1:
	In [[mathematics]], an '''evasive Boolean function''' ''&fnof;'' (of ''n'' variables) is a [[Boolean function]] for which every [[Decision tree model\|decision tree algorithm]] has running time of exactly ''n''. Consequently every [[Decision tree model\|decision tree algorithm]] that represents the function has, at worst case, a running time of ''n''.

	~~== Examples ==~~
	~~=== An example for a non-evasive boolean function ===~~
	~~The following is a Boolean function on the three variables ''x'', ''y'', ''z'':~~

	~~{\| style="text-align: center; border: 1px solid darkgray;"~~		This is not oldsmobile 88 rocket clock really that difficult either. While that may be the year. I personally own a Ford Expedition Funkmaster Flex red logo headrests, a bunch of [https://Www.Google.com/search?hl=en&gl=us&tbm=nws&q=burly+gentlemen&btnI=lucky burly gentlemen] or a Connect cargo van. Interest in sporty, close-coupled compacts that could change the outlook of the modern age with renewable energy burgeoning, and some even identical to those markets. Now Chrysler has joined the Scottish Rite and other customer-focused retailers. This places it firmly in oneowner territory. Otherwise, it is used in the real difference is that electric cars.<br><br>My blog post: [http://durl.me/7m6ruf Discount Car Rental]
	\|-
	~~\|<math>~f(x,y,z)~</math>~~
	~~\|<math>~=~</math>~~
	~~\|<math>~(x \and y)~</math>~~
	~~\|<math>~\or~</math>~~
	~~\|<math>~(\neg x \and z)~</math>~~
	\|-
	~~\|[[File:Venn 0001 1011.svg\|50px]]~~
	~~\|<math>~=~</math>~~
	~~\|[[File:Venn 0001 0001.svg\|50px]]~~
	~~\|<math>~\or~</math>~~
	~~\|[[File:Venn 0000 1010.svg\|50px]]~~
	\|}

	~~(where <math>\and</math> is the bitwise "and", <math>\or</math> is the bitwise "or", and <math>\neg </math>~~ is ~~the bitwise "~~not").

	~~This function is not evasive, because there is a decision tree~~ that ~~solves it by checking exactly two variables: The algorithm first checks~~ the ~~value of ''x''~~. ~~If ''x'' is true~~, ~~the algorithm checks the value~~ of ~~''y'' and returns it.~~

	:~~(     <math>(\neg x = \text{false}) ~~\Rightarrow~~ ((\neg x \and z) = \text{false})<~~/~~math>     )~~

	~~If ''x'' is false, the algorithm checks the value of ''z'' and returns it~~.

	=== ~~A simple example for an evasive boolean function~~ ===

	~~Consider this simple "and" function on three variables:~~

	~~{\| style="text-align: center; border: 1px solid darkgray;"~~
	\|-
	~~\|<math>~f(x,y,z)~</math>~~
	~~\|<math>~= (x \wedge y \wedge z)~</math>~~
	\|-
	~~\|[[File:Venn 0000 0001.svg\|50px~~]]
	\|
	\|}

	~~A worst-case input (for every algorithm) is 1, 1, 1~~. ~~In every order we choose to check the variables~~, ~~we have to check all of them. (Note~~ that ~~in general there~~ could ~~be a different worst-case input for every decision tree algorithm.) Hence the functions: "and", "or" (on ''n'' variables) are evasive.~~

	~~== Binary zero-sum games ==~~

	~~For~~ the ~~case~~ of ~~binary [[zero-sum game]]s, every [[evaluation function]] is evasive.~~

	~~In every zero-sum game,~~ the ~~value of the game is achieved by the [[minimax]] algorithm (player 1 tries to maximize the profit~~, and ~~player 2 tries~~ to ~~minimize the cost)~~.

	~~In the binary case,~~ the ~~max function equals the bitwise "or",~~ and ~~the min function equals the bitwise "and"~~.

	~~A decision tree for this game will be of this form:~~
	* every leaf will have value in {0,~~ 1}.~~
	* every node is ~~connected to one of {"and", "or"}~~

	~~For every such tree with ''n'' leaves, the running time~~ in the ~~worst case~~ is ~~''n'' (meaning~~ that ~~the algorithm must check all the leaves)~~:

	~~We will exhibit an~~ [[Adversary (online algorithm)\|adversary]] that produces a worst-case input – for every leaf that the algorithm checks, the adversary will answer 0 if the leaf's parent is an Or node, and 1 if the parent is an And node.

	~~This input (0 for all Or nodes' children, and 1 for all And nodes' children) forces the algorithm to check all nodes~~:

	~~As in the second example~~
	* in order to calculate the Or result, if all children are 0 we must check them all.
	* In order to calculate the and result, if all children are 1 we must check them all.

	~~==See also==~~
	*[[Aanderaa–Karp–Rosenberg conjecture]], the conjecture that every nontrivial monotone graph property is evasive.

	~~[[Category:Boolean algebra]~~]

en>BlindWanderer: Would make sense that they link to each other. Maybe they should be merged.

2013-12-11T04:43:41Z

Would make sense that they link to each other. Maybe they should be merged.

← Older revision		Revision as of 06:43, 11 December 2013
Line 1:		Line 1:
	[~~https~~://~~www~~.~~youtube~~.~~com~~/~~watch?v=ncynnf1sfNA Check Out The Video~~] ~~writer~~ is ~~called Rusty~~ and ~~also~~ the ~~wife doesn~~'~~t like~~ it ~~at just~~. ~~My wife~~ and ~~chose~~ to have in Nj and ~~I really~~ every ~~day living beneath~~. ~~One~~ of ~~my favorite hobbies~~ is ~~collecting kites~~ and ~~We are starting another thing along on it~~. ~~Production~~ and ~~planning~~ is the ~~I develop~~ a ~~living~~ and ~~that i don~~'~~t think I~~'~~ll transform anytime pretty soon. I am running as well as a blog here~~: ~~https://www~~.~~youtube~~.~~com/watch?v~~=~~ncynnf1sfNA~~		In [[mathematics]], an '''evasive Boolean function''' ''&fnof;'' (of ''n'' variables) is a [[Boolean function]] for which every [[Decision tree model\|decision tree algorithm]] has running time of exactly ''n''. Consequently every [[Decision tree model\|decision tree algorithm]] that represents the function has, at worst case, a running time of ''n''.

			== Examples ==
			=== An example for a non-evasive boolean function ===
			The following is a Boolean function on the three variables ''x'', ''y'', ''z'':

			{\| style="text-align: center; border: 1px solid darkgray;"
			\|-
			\|<math>~f(x,y,z)~</math>
			\|<math>~=~</math>
			\|<math>~(x \and y)~</math>
			\|<math>~\or~</math>
			\|<math>~(\neg x \and z)~</math>
			\|-
			\|[[File:Venn 0001 1011.svg\|50px]]
			\|<math>~=~</math>
			\|[[File:Venn 0001 0001.svg\|50px]]
			\|<math>~\or~</math>
			\|[[File:Venn 0000 1010.svg\|50px]]
			\|}

			(where <math>\and</math> is the bitwise "and", <math>\or</math> is the bitwise "or", and <math>\neg </math> is the bitwise "not").

			This function is not evasive, because there is a decision tree that solves it by checking exactly two variables: The algorithm first checks the value of ''x''. If ''x'' is true, the algorithm checks the value of ''y'' and returns it.

			:(     <math>(\neg x = \text{false}) ~~\Rightarrow~~ ((\neg x \and z) = \text{false})</math>     )

			If ''x'' is false, the algorithm checks the value of ''z'' and returns it.

			=== A simple example for an evasive boolean function ===

			Consider this simple "and" function on three variables:

			{\| style="text-align: center; border: 1px solid darkgray;"
			\|-
			\|<math>~f(x,y,z)~</math>
			\|<math>~= (x \wedge y \wedge z)~</math>
			\|-
			\|[[File:Venn 0000 0001.svg\|50px]]
			\|
			\|}

			A worst-case input (for every algorithm) is 1, 1, 1. In every order we choose to check the variables, we have to check all of them. (Note that in general there could be a different worst-case input for every decision tree algorithm.) Hence the functions: "and", "or" (on ''n'' variables) are evasive.

			== Binary zero-sum games ==

			For the case of binary [[zero-sum game]]s, every [[evaluation function]] is evasive.

			In every zero-sum game, the value of the game is achieved by the [[minimax]] algorithm (player 1 tries to maximize the profit, and player 2 tries to minimize the cost).

			In the binary case, the max function equals the bitwise "or", and the min function equals the bitwise "and".

			A decision tree for this game will be of this form:
			* every leaf will have value in {0, 1}.
			* every node is connected to one of {"and", "or"}

			For every such tree with ''n'' leaves, the running time in the worst case is ''n'' (meaning that the algorithm must check all the leaves):

			We will exhibit an [[Adversary (online algorithm)\|adversary]] that produces a worst-case input – for every leaf that the algorithm checks, the adversary will answer 0 if the leaf's parent is an Or node, and 1 if the parent is an And node.

			This input (0 for all Or nodes' children, and 1 for all And nodes' children) forces the algorithm to check all nodes:

			As in the second example
			* in order to calculate the Or result, if all children are 0 we must check them all.
			* In order to calculate the and result, if all children are 1 we must check them all.

			==See also==
			*[[Aanderaa–Karp–Rosenberg conjecture]], the conjecture that every nontrivial monotone graph property is evasive.

			[[Category:Boolean algebra]]

en>Nageh: categories

2012-04-13T20:13:56Z